Building a Serverless REST API with AWS Lambda and API Gateway

In the modern development landscape, serverless architecture has gained immense popularity due to its cost efficiency, scalability, and ease of use. AWS Lambda and API Gateway form a powerful duo for creating serverless REST APIs. This blog will guide you through creating a simple CRUD API using AWS Lambda, API Gateway, and Node.js with TypeScript.

Serverless REST API

A serverless REST API is an API where the backend logic runs on a cloud provider’s infrastructure, eliminating the need for server management. AWS Lambda enables developers to focus purely on writing code while API Gateway handles HTTP requests and integrates seamlessly with Lambda.

AWS Lambda and API Gateway

Key Benefits:

1. Scalability: Automatically handles increasing traffic without manual intervention.
2. Cost Efficiency: Pay only for the compute time you use, with no upfront costs.
3. Ease of Integration: Supports seamless integration with other AWS services.

Setting Up Your Environment

Before diving into the implementation, ensure you have the following:

1. AWS Account: Sign up for a free-tier AWS account if you don’t already have one.
2. Node.js and NPM: Install Node.js on your system from Node.js official website.
3. AWS CLI: Install and configure the AWS CLI to interact with your AWS account.
4. SAM CLI: Install the Serverless Application Model (SAM) CLI for managing serverless applications.
5. Postman or curl: For API testing.

Step-by-Step Implementation

1. Create a New AWS Lambda Function

Start by creating a directory for your project and initializing it with TypeScript:

    mkdir serverless-crud-api
    cd serverless-crud-api
    npm init -y
    npm install typescript @types/node
    npx tsc --init

Install AWS SDK and dependencies:

  npm install @types/aws-lambda --save-dev

Create a new Lambda function for handling requests. Add the following code in a file called index.ts:

    import { APIGatewayProxyEvent, APIGatewayProxyResult } from "aws-lambda";

    // In-memory database (for simplicity)
    let items: { id: string; name: string }[] = [];

    export const handler = async (event: APIGatewayProxyEvent): Promise => {
      if (event.httpMethod == 'GET') {
        return getItems(event);
      }
      else if (event.httpMethod == 'POST') {
        return createItem(event);
      }
      else if (event.httpMethod == 'DELETE') {
        return deleteItem(event);
      }
      else {
        return {
          statusCode: 500,
          body: JSON.stringify({ message: "Internal Server Error" }),
        };
      }
    }

    // GET all items
    export const getItems = async (event: APIGatewayProxyEvent): Promise => {
      return {
        statusCode: 200,
        body: JSON.stringify(items),
      };
    };

    // POST a new item
    export const createItem = async (event: APIGatewayProxyEvent): Promise => {
      const body = JSON.parse(event.body || "{}");
      const newItem = { id: new Date().toISOString(), name: body.name };
      items.push(newItem);
      return {
        statusCode: 201,
        body: JSON.stringify(newItem),
      };
    };

    // DELETE an item by ID
    export const deleteItem = async (event: APIGatewayProxyEvent): Promise => {
      const id = event.pathParameters?.id;
      items = items.filter((item) => item.id !== id);
      return {
        statusCode: 204,
        body: "",
      };
    };

2. Deploy the Lambda Function

Use the AWS SAM CLI to package and deploy the function. Create a template.yaml file for defining the serverless infrastructure:

    AWSTemplateFormatVersion: '2010-09-09'
    Transform: AWS::Serverless-2016-10-31
    Resources:
      CrudApiFunction:
        Type: AWS::Serverless::Function
        Properties:
          Handler: index.handler
          Runtime: nodejs14.x
          CodeUri: .
          Events:
            GetItems:
              Type: Api
              Properties:
                Path: /items
                Method: GET
            CreateItem:
              Type: Api
              Properties:
                Path: /items
                Method: POST
            DeleteItem:
              Type: Api
              Properties:
                Path: /items/{id}
                Method: DELETE

Deploy the application:

    sam build
    sam deploy --guided

Follow the prompts to configure the deployment. After deployment, you’ll receive an API Gateway endpoint URL.

Testing Your REST API

Use Postman or curl to test the API endpoints:

1. GET Items

    curl -X GET https://your-api-id.amazonaws.com/items

2. POST New Item

    curl -X POST https://your-api-id.amazonaws.com/items \
    -H "Content-Type: application/json" \
    -d '{"name": "New Item"}'

3. DELETE an Item

    curl -X DELETE https://your-api-id.amazonaws.com/items/{id}

Key Takeaways

1. Event-Driven Architecture: AWS Lambda and API Gateway enable you to build highly scalable, cost-effective APIs with minimal management overhead.
2. Flexibility: The serverless model is ideal for building APIs with fluctuating workloads.
3. Best Practices: Use environment variables and CloudWatch for monitoring and logging

Conclusion

Serverless REST APIs with AWS Lambda and API Gateway provide a robust foundation for building scalable and cost-effective applications. By following this guide, you’ve created a simple CRUD API using Node.js with TypeScript and deployed it in a completely serverless environment.

Ready to scale your application and explore more serverless possibilities? The cloud awaits!