AWS Builder Center

Builder Center

Build a Serverless REST API on AWS with Lambda and API Gateway

Build a Serverless REST API on AWS with Lambda and API Gateway

Learn how to build a scalable, cost-effective REST API using AWS Lambda and Amazon API Gateway. This hands-on guide covers architecture, implementation steps, security best practices, and deployment tips for beginners.

Snehal

Build a Serverless REST API on AWS with Lambda and API Gateway

Building backend applications no longer requires managing servers, configuring operating systems, or maintaining infrastructure manually. With AWS serverless services, developers can focus on writing code while AWS handles much of the underlying infrastructure.
In this article, we'll explore how to build a simple REST API using AWS Lambda and Amazon API Gateway.

What Is a Serverless Application?

Serverless computing allows you to run code without provisioning or managing servers directly. You still use servers behind the scenes, but AWS manages the infrastructure for you.
Two important services are:
  • AWS Lambda: Runs your code in response to events without requiring you to manage servers.
  • Amazon API Gateway: Provides HTTP endpoints that clients can call to invoke your backend functionality.
Together, these services provide a straightforward way to build APIs that can scale with demand.

Understanding the Architecture

A typical request follows this flow:
  1. A client sends an HTTP request to an API Gateway endpoint.
  2. API Gateway receives the request and invokes a Lambda function.
  3. The Lambda function processes the request and generates a response.
  4. API Gateway returns the response to the client.
You can extend this architecture with Amazon DynamoDB for data storage, Amazon CloudWatch for monitoring, and AWS Identity and Access Management (IAM) for permissions.

Step 1: Create a Lambda Function

Open the AWS Management Console and navigate to AWS Lambda.
  1. Select Create function.
  2. Choose Author from scratch.
  3. Enter a function name, such as hello-serverless-api.
  4. Select a supported Python runtime.
  5. Create the function using an appropriate execution role.
For a simple demonstration, you can use the following Python code:
1
2
3
4
5
6
7
8
9
10
11
12
13
import json

def lambda_handler(event, context):
return {
"statusCode": 200,
"headers": {
"Content-Type": "application/json"
},
"body": json.dumps({
"message": "Hello from AWS Lambda!",
"success": True
})
}
This function returns a JSON response with an HTTP 200 status code.

Step 2: Create an API Gateway Endpoint

Next, expose the Lambda function through an HTTP API.
  1. Open Amazon API Gateway.
  2. Choose to create an HTTP API.
  3. Add an integration with your Lambda function.
  4. Configure a route, such as GET /hello.
  5. Create a stage and deploy the API.
The console provides an invoke URL for your deployed API.
Your endpoint will resemble:
https://api-id.execute-api.region.amazonaws.com/hello
Replace the example values with the actual URL provided by AWS and the route configured for your API.

Step 3: Test the API

You can test the endpoint using a browser, curl, or an API client.
1
curl https://your-api-url/hello
A successful request should return a response similar to:
1
2
3
4
{
"message": "Hello from AWS Lambda!",
"success": true
}
If the request fails, check the API route, deployment stage, Lambda integration, execution permissions, and CloudWatch logs.

Step 4: Add Security and Monitoring

Before using your API in a real application, consider these improvements.
  • Authentication: Configure an appropriate authorization mechanism when the endpoint should not be public.
  • Least privilege: Give the Lambda execution role only the permissions the function needs.
  • Logging: Use Amazon CloudWatch Logs to investigate errors and application behavior.
  • Throttling: Configure suitable request limits to help protect the API from excessive traffic.
  • Input validation: Validate incoming data and return appropriate error responses.
  • CORS: Configure cross-origin access if a browser-based frontend needs to call your API from another origin.
Never place AWS access keys or other secrets directly in your source code.

Step 5: Understand the Costs

AWS Lambda and API Gateway offer usage-based pricing models, which can make them attractive for applications with variable traffic.
However, costs depend on factors such as invocation volume, execution duration, memory allocation, API requests, data transfer, and the services your application uses.
Review the current AWS pricing pages and use AWS Budgets to monitor spending. Free Tier eligibility and allowances may vary, so verify the terms applicable to your account.

Conclusion

AWS Lambda and Amazon API Gateway provide a practical foundation for building serverless REST APIs without managing traditional application servers.
By starting with a small endpoint, testing it thoroughly, and adding security and monitoring, you can build a foundation for more advanced applications.
As a next step, consider connecting your API to Amazon DynamoDB to support persistent data storage, or automating deployments with AWS SAM or AWS CloudFormation.
Have you built a serverless application on AWS? Share your experience, lessons learned, or questions in the comments.
# serverless# api-gateway# aws-lambda# cloud-operations
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article