Setting up Lambda Function and S3

Oct 13, 2025 by leolavanderia.com.br 83 views

Introduction

In this article, we will explore the possibility of uploading files using pre-signed URLs with APPSync in AWS. We will discuss the steps involved in setting up a Lambda function connected to S3 and APPSync, and how to use pre-signed URLs to upload files directly to S3 using APPSync.

What is APPSync?

APPSync is a fully managed GraphQL service provided by AWS that allows developers to build scalable and secure applications. It provides a simple and intuitive way to build data-driven applications by exposing a GraphQL API that can be queried and mutated using GraphQL queries.

What is Pre-Signed URL?

A pre-signed URL is a URL that has been signed with a temporary secret key, allowing a client to upload a file directly to S3 without needing to authenticate with AWS credentials. Pre-signed URLs are commonly used in scenarios where a client needs to upload a file to S3, but does not have the necessary credentials to do so.

Setting up Lambda Function and S3

To set up a Lambda function connected to S3, follow these steps:

Step 1: Create a Lambda Function

Create a new Lambda function in the AWS Management Console. Choose the "Author from scratch" option and select the "Node.js" runtime.

Step 2: Configure the Lambda Function

Configure the Lambda function to execute a Node.js function that will be responsible for generating a pre-signed URL for the S3 bucket.

exports.handler = async (event) => {
  const s3 = new AWS.S3({ region: 'your-region' });
  const bucketName = 'your-bucket-name';
  const objectKey = 'your-object-key';
  const expiration = 60; // expiration in seconds

  const params = {
    Bucket: bucketName,
    Key: objectKey,
    Expires: expiration,
  };

  const presignedUrl = s3.getSignedUrl('putObject', params);

  return {
    statusCode: 200,
    body: JSON.stringify({ presignedUrl }),
  };
};

Step 3: Connect the Lambda Function to S3

Connect the Lambda function to the S3 bucket by creating a new S3 event source mapping.

Connecting Lambda Function to APPSync

To connect the Lambda function to APPSync, follow these steps:

Step 4: Create an APPSync API

Create a new APPSync API in the AWS Management Console. Choose the "Author from scratch" option and select the "GraphQL" schema.

Step 5: Define the GraphQL Schema

Define the GraphQL schema for the APPSync API. In this example, we will create a schema with a single mutation that will be responsible for uploading a file to S3 using a pre-signed URL.

type Mutation {
  uploadFile(file: Upload!): String!
}

type Upload {
  filename: String!
  mimetype: String!
  encoding: String!
}

Step 6: Create a Resolver for the Mutation

Create a resolver for the uploadFile mutation. The resolver will be responsible for calling the Lambda function to generate a pre-signed URL for the S3 bucket.

const { GraphQLUpload } = require('graphql-upload');

const resolvers = {
  Mutation: {
    uploadFile: async (parent, { file }) => {
      const { createReadStream, filename, mimetype, encoding } = await file;
      const stream = createReadStream();

      const lambda = new AWS.Lambda({ region: 'your-region' });
      const lambdaFunctionName = 'your-lambda-function-name';

      const params = {
        FunctionName: lambdaFunctionName,
        InvocationType: 'RequestResponse',
        Payload: JSON.stringify({ file }),
      };

      const response = await lambda.invoke(params).promise();

      const presignedUrl = JSON.parse(response.Payload).presignedUrl;

      const s3 = new AWS.S3({ region: 'your-region' });
      const bucketName = 'your-bucket-name';
      const objectKey = 'your-object-key';

      const uploadParams = {
        Bucket: bucketName,
        Key: objectKey,
        Body: stream,
      };

      await s3.upload(uploadParams).promise();

      return presignedUrl;
    },
  },
};

Uploading Files using Pre-Signed URL with APPSync

To upload files using pre-signed URLs with APPSync, follow these steps:

Step 1: Create a Client

Create a client that will be responsible for calling the APPSync API to upload a file.

const { ApolloClient, InMemoryCache } = require('@apollo/client');
const { createUploadLink } = require('apollo-upload-client');

const client = new ApolloClient({
  cache: new InMemoryCache(),
  link: createUploadLink({
    uri: 'https://your-graphql-api.com/graphql',
  }),
});

Step 2: Call the Mutation

Call the uploadFile mutation to upload a file to S3 using a pre-signed URL.

const { uploadFile } = require('./resolvers');

const file = {
  filename: 'example.txt',
  mimetype: 'text/plain',
  encoding: 'utf-8',
  createReadStream: () => {
    // return a stream that will be used to upload the file
  },
};

const { data } = await client.mutate({
  mutation: uploadFile,
  variables: { file },
});

const presignedUrl = data.uploadFile;

// use the presigned URL to upload the file to S3

Q: What is the purpose of using a pre-signed URL to upload files to S3?

A: A pre-signed URL is used to upload files to S3 without needing to authenticate with AWS credentials. This is useful in scenarios where a client needs to upload a file to S3, but does not have the necessary credentials to do so.

Q: How do I generate a pre-signed URL for an S3 bucket?

A: You can generate a pre-signed URL for an S3 bucket using the AWS SDK. The AWS SDK provides a method called getSignedUrl that takes the bucket name, object key, and expiration time as input and returns a pre-signed URL.

Q: Can I use a pre-signed URL to upload files to S3 using APPSync?

A: Yes, you can use a pre-signed URL to upload files to S3 using APPSync. To do this, you need to create a resolver for the uploadFile mutation that will be responsible for generating a pre-signed URL for the S3 bucket.

Q: How do I create a resolver for the `uploadFile` mutation in APPSync?

A: To create a resolver for the uploadFile mutation, you need to define a function that will be called when the mutation is executed. This function should generate a pre-signed URL for the S3 bucket and return it as the result of the mutation.

Q: Can I use a pre-signed URL to upload files to S3 using a client-side library?

A: Yes, you can use a pre-signed URL to upload files to S3 using a client-side library such as Apollo Client. To do this, you need to create a client that will be responsible for calling the APPSync API to upload a file using a pre-signed URL.

Q: How do I call the `uploadFile` mutation using a client-side library?

A: To call the uploadFile mutation using a client-side library, you need to create a client that will be responsible for calling the APPSync API to upload a file using a pre-signed URL. You can use the mutate method of the client to call the mutation and pass the file as a variable.

Q: What are the benefits of using a pre-signed URL to upload files to S3?

A: The benefits of using a pre-signed URL to upload files to S3 include:

Security: Pre-signed URLs provide an additional layer of security by allowing clients to upload files to S3 without needing to authenticate with AWS credentials.
Flexibility: Pre-signed URLs can be used to upload files to S3 from any client-side library or framework.
Scalability: Pre-signed URLs can be used to upload files to S3 in a scalable and efficient manner.

Q: What are the limitations of using a pre-signed URL to upload files to S3?

A: The limitations of using a pre-signed URL to upload files to S3 include:

Expiration: Pre-signed URLs have an expiration time, after which they become invalid.
Security: Pre-signed URLs can be used to upload files to S3 without needing to authenticate with AWS credentials, which can be a security risk if not properly managed.
Scalability: Pre-signed URLs can be used to upload files to S3 in a scalable and efficient manner, but may require additional configuration and management to achieve optimal performance.

Q: How do I troubleshoot issues with uploading files to S3 using a pre-signed URL?

A: To troubleshoot issues with uploading files to S3 using a pre-signed URL, you can use the following steps:

Check the pre-signed URL: Verify that the pre-signed URL is valid and has not expired.
Check the file: Verify that the file is properly formatted and can be uploaded to S3.
Check the S3 bucket: Verify that the S3 bucket is properly configured and can receive uploads.
Check the APPSync API: Verify that the APPSync API is properly configured and can receive mutations.

By following these steps, you can troubleshoot issues with uploading files to S3 using a pre-signed URL and ensure that your application is working correctly.