Koti Vellanki's B(V)logs

Day 20: Building a Serverless API with Amazon API Gateway and AWS Lambda

Koti Vellanki's photo
Koti Vellanki
·

6 min read

Welcome to Day 20 of our exciting "30 Days of AWS" journey! If you've been following along from the beginning, kudos to you for diving into the world of Amazon Web Services. Your dedication and curiosity are truly commendable.

For those who might have just joined us or are specifically interested in today's topic, a warm welcome to you as well! While each article in this series delves into a different facet of AWS, rest assured that they are all interconnected, building upon the knowledge we've been cultivating day by day.

If you're here for the first time, I encourage you to take a moment to catch up on our previous discussions. This will enhance your understanding and ensure a seamless flow as we dive deeper into the fascinating journey of AWS together.

In today’s installment, we will explore "Building a Serverless API with Amazon API Gateway and AWS Lambda." APIs (Application Programming Interfaces) are essential for connecting different applications and services. With AWS’s serverless options, you can build robust APIs without managing any servers, making it highly scalable and cost-effective.

As always, feel free to engage, ask questions, and share your thoughts in the comments. Your participation is what makes this series vibrant and valuable. I’m thrilled to have you join us on this journey. Let’s get started!

What is Amazon API Gateway?

Let’s start with the technical definition:

Amazon API Gateway is a fully managed service that allows developers to create, publish, and manage RESTful and WebSocket APIs at any scale. It acts as a front door to your backend services, such as AWS Lambda, EC2, or any other HTTP endpoint, and helps control access, throttle requests, and handle authorization.

To put it in a simple way:

Imagine API Gateway as a receptionist at a big office. Visitors (incoming requests) come to the receptionist (API Gateway), who then directs them to the appropriate office or department (backend service) based on their request. The receptionist also makes sure that only authorized visitors are allowed in, keeps track of how many people come and go, and can block access if needed.

Why Use API Gateway?

  1. Easily Create and Deploy APIs:
    Quickly create RESTful APIs for web or mobile applications.

  2. Integrated with AWS Lambda:
    API Gateway works seamlessly with Lambda, making it perfect for building serverless backends.

  3. Security and Access Control:
    API Gateway allows you to define who can access your APIs and under what conditions.

  4. Scalability:
    Automatically scales to handle any number of requests.

What is AWS Lambda?

Here’s a quick refresher:

AWS Lambda is a serverless compute service that lets you run code in response to events (like API requests) without provisioning or managing servers. You only pay for the compute time you use.

To put it in a simple way:

Imagine Lambda as a chef who starts cooking only when you place an order (event). Once the dish (function) is prepared, the chef stops working, and you pay only for the time the chef was actively cooking.

Why Use Lambda?

  1. No Server Management:
    You don’t need to worry about setting up or maintaining servers.

  2. Automatic Scaling:
    Lambda automatically scales based on the number of incoming requests.

  3. Cost-Effective:
    You’re billed only for the compute time you use, making it cost-effective for sporadic workloads.

How Do API Gateway and Lambda Work Together?

When combined, API Gateway and Lambda are a powerful duo for building serverless APIs. Here’s how they interact:

  1. API Gateway acts as the entry point for incoming HTTP requests (e.g., GET or POST requests).

  2. When a request hits the API Gateway, it triggers a Lambda function.

  3. Lambda processes the request (e.g., retrieves data from a database) and sends back a response to the API Gateway.

  4. API Gateway formats the response and sends it back to the user.

This combination is perfect for building secure, scalable, and low-cost APIs for web and mobile applications.

Building a Serverless API: Step-by-Step Guide

Let’s build a simple serverless API that returns a welcome message using API Gateway and AWS Lambda.

Step 1: Create an AWS Lambda Function

  1. Go to the AWS Lambda Console.

  2. Click on Create Function and choose Author from scratch.

  3. Name your function welcomeFunction.

  4. Choose Node.js as the runtime.

  5. Click Create Function.

Step 2: Add Code to the Lambda Function

In the function editor, replace the default code with the following:

exports.handler = async (event) => {
    return {
        statusCode: 200,
        body: JSON.stringify('Hello from your first Serverless API!'),
    };
};

Click Deploy to save the changes.

Step 3: Create an API in API Gateway

  1. Go to the API Gateway Console.

  2. Click on Create API and choose REST API.

  3. Select New API and name it WelcomeAPI.

  4. Click Create API.

Step 4: Create a Resource and Method

  1. In the left-hand menu, click on Actions → Create Resource.

  2. Set the Resource Name to welcome.

  3. Click Create Resource.

  4. With the welcome resource selected, click on Create Method.

  5. Choose GET and click the checkmark.

  6. Select Lambda Function as the integration type.

  7. Enter the name of your Lambda function (welcomeFunction).

  8. Click Save and confirm the permission dialog.

Step 5: Deploy the API

  1. Click on Actions → Deploy API.

  2. Create a new stage (e.g., prod).

  3. Click Deploy.

API Gateway will generate a URL for your API. Copy this URL—it’s your API endpoint.

Step 6: Test the Serverless API

  1. Open a new browser tab and paste the API endpoint URL, followed by /welcome.

    For example:
    https://<api-id>.execute-api.<region>.amazonaws.com/prod/welcome

  2. You should see the message:
    "Hello from your first Serverless API!"

Step 7: Secure the API with an API Key (Optional)

  1. Go to the API Gateway Console and select your API.

  2. Click on API Keys and create a new key.

  3. Enable API Key Required on your GET method.

  4. Deploy the changes.

You can now pass the API Key in the headers to control access to your API.

Benefits of Serverless APIs

  1. No Server Maintenance:
    You don’t have to worry about servers, OS updates, or scaling.

  2. Built-In Security:
    API Gateway offers built-in authentication, throttling, and access control.

  3. Cost-Effectiveness:
    Pay only for the number of requests and Lambda compute time, making it ideal for small-to-medium-sized applications.

  4. Scalability:
    Both API Gateway and Lambda scale automatically to handle millions of requests.

Best Practices for Building Serverless APIs

  1. Use Proper HTTP Status Codes:
    Return appropriate status codes (200 OK, 404 Not Found, etc.) to improve client-side error handling.

  2. Enable Caching in API Gateway:
    Reduce latency and improve performance by enabling caching.

  3. Monitor and Log API Usage:
    Use CloudWatch Logs to monitor API calls, error rates, and latency.

  4. Use Environment Variables:
    Store configuration settings and secrets in Lambda environment variables instead of hardcoding them in your function.

Summary

Today, we explored:

  • What Amazon API Gateway and AWS Lambda are.

  • How to build a simple serverless API using API Gateway and Lambda.

  • Key benefits and best practices for building serverless APIs.

What’s Next?

In Day 21, we’ll explore AWS OpsWorks and see how it helps automate infrastructure management using Chef and Puppet. We’ll see how to build custom stacks and manage complex configurations effortlessly.

Stay tuned, and let’s keep this AWS learning journey going strong!

Hope you find this blog helpful. Please share your thoughts in the comments—it will help me refine and provide more insightful content. Happy Learning!

Connect with Me - LinkedIn - Twitter/X - Topmate

serverlessAmazon Web ServicesAWSAPI Gateway