Integrate with Lambda & API Gateway by using 'boto3' Python Library!

Certainly! Integrating AWS Lambda with API Gateway using boto3 involves creating an API Gateway REST API, creating a Lambda function, and then setting up the integration between them. Let's break down the process step by step:

Step 1: Import the boto3 Library

import boto3

Step 2: Create an API Gateway REST API

def create_api_gateway(api_name):
    api_gateway = boto3.client('apigateway')

    response = api_gateway.create_rest_api(
        name=api_name,
        description='My API created using boto3',
        version='1.0'
    )

    return response

In this step, we define a function create_api_gateway that takes the desired API name as a parameter. Inside the function:

• We create an API Gateway client using boto3.client('apigateway').

• We call the create_rest_api method to create a new REST API. We provide the API name, a description, and a version.

• The function returns the response containing information about the created API.

Step 3: Create a Lambda Function

def create_lambda_function(function_name, role_arn):
    lambda_client = boto3.client('lambda')

    response = lambda_client.create_function(
        FunctionName=function_name,
        Runtime='python3.8',
        Role=role_arn,
        Handler='lambda_handler',
        Code={
            'ZipFile': b'lambda code here'
        }
    )

    return response

In this step, we define a function create_lambda_function that takes the function name and an IAM role ARN as parameters. Inside the function:

• We create a Lambda client using boto3.client('lambda').

• We call the create_function method to create a new Lambda function. We provide the function name, runtime, IAM role ARN, handler (function to execute), and the function code (replace b'lambda code here' with your actual code).

Step 4: Integrate API Gateway with Lambda

def create_api_gateway_integration(api_id, resource_id, function_name):
    api_gateway = boto3.client('apigateway')

    response = api_gateway.put_integration(
        restApiId=api_id,
        resourceId=resource_id,
        httpMethod='GET',
        type='AWS_PROXY',
        integrationHttpMethod='POST',
        uri=f'arn:aws:apigateway:{aws_region}:lambda:path/2015-03-31/functions/arn:aws:lambda:{aws_region}:{account_id}:function:{function_name}/invocations'
    )

    return response

In this step, we define a function create_api_gateway_integration that takes the API ID, resource ID, and Lambda function name as parameters. Inside the function:

• We call the put_integration method to set up the integration between API Gateway and Lambda. We provide the REST API ID, resource ID, HTTP method, integration type, integration HTTP method, and the URI for the Lambda function.

Step 5: Deploy the API

def create_api_gateway_deployment(api_id, stage_name):
    api_gateway = boto3.client('apigateway')

    response = api_gateway.create_deployment(
        restApiId=api_id,
        stageName=stage_name
    )

    return response

In this step, we define a function create_api_gateway_deployment that takes the API ID and a stage name as parameters. Inside the function:

• We call the create_deployment method to deploy the API to a specific stage. We provide the REST API ID and the desired stage name.

Step 6: Putting it All Together

api_name = 'MyAPI'
function_name = 'MyLambdaFunction'
role_arn = 'arn:aws:iam::account-id:role/role-name'
aws_region = 'us-east-1'
account_id = 'your-account-id'
stage_name = 'dev'

api_response = create_api_gateway(api_name)
print(f"API Gateway '{api_name}' created.")

lambda_response = create_lambda_function(function_name, role_arn)
print(f"Lambda function '{function_name}' created.")

api_id = api_response['id']
resource_id = api_response['resourceId']
integration_response = create_api_gateway_integration(api_id, resource_id, function_name)
print("API Gateway integration created.")

deployment_response = create_api_gateway_deployment(api_id, stage_name)
print(f"API Gateway deployed to stage '{stage_name}'.")

Explanation:

• Replace 'MyAPI' with your desired API name.

• Replace 'MyLambdaFunction' with your desired Lambda function name.

• Replace 'arn:aws:iam::account-id:role/role-name' with the actual IAM role ARN you want to use.

• Replace 'us-east-1' with your desired AWS region.

• Replace 'your-account-id' with your AWS account ID.

• Replace 'dev' with the desired stage name.

This script automates the process of creating an API Gateway REST API, a Lambda function, integrating them, and deploying the API. It demonstrates how to use boto3 to set up the foundation for connecting Lambda with API Gateway.

Remember to have the necessary IAM permissions and AWS credentials configured to perform these operations.