Automate Serverless Deployments with GitHub Actions

Amaresh Pelleti

In today’s fast-paced development environment, automating serverless deployments is crucial for achieving scalability, efficiency, and consistency. This blog post will guide you through creating a generic CI/CD pipeline using GitHub Actions to deploy an AWS Lambda function and integrate it with an existing API Gateway.

By leveraging reusable configurations, avoiding hardcoded values, and securely managing sensitive data, this approach ensures your pipeline is flexible, secure, and adaptable to various projects and environments.

Why Automate Serverless Deployments?

Deploying serverless applications manually can lead to errors, inconsistencies, and inefficiencies. Automation eliminates these risks by:

  • Ensuring consistent deployments across multiple environments (e.g., dev, staging, prod).
  • Reducing human error by automating repetitive tasks.
  • Enabling rapid iteration and testing in a continuous integration/continuous deployment (CI/CD) pipeline.

Additionally, integrating with API Gateway allows your Lambda function to be invoked via HTTP requests, making it accessible as a web service.

If you’re new to AWS or need help setting up IAM credentials, check out this step-by-step guide on creating IAM user access keys and secret keys. Properly configured IAM credentials are essential for authenticating your GitHub Actions workflow with AWS services.

Overview of the Workflow

Our GitHub Actions workflow will:

  1. Check out the code from the repository.
  2. Set up Python and install dependencies required for the Lambda function.
  3. Configure AWS credentials to authenticate with AWS services.
  4. Zip the Lambda function code for deployment.
  5. Load environment-specific variables from JSON files stored securely in the repository.
  6. Create or update the Lambda function based on whether it already exists.
  7. Link the Lambda function to an existing API Gateway, ensuring seamless communication between the two.

This solution avoids hardcoded values, making it reusable for any project that requires serverless deployments.

For more details on AWS Lambda commands and their usage, refer to the official AWS CLI Lambda documentation.

Step-by-Step Implementation

1. Define Environment-Specific Configuration

Instead of hardcoding sensitive variables like API keys or configuration settings, we’ll use environment-specific JSON files to store these values. This approach keeps sensitive data secure and makes the pipeline reusable across environments.

For example:

  • env-vars/dev.json:
  {
    "Variables": {
      "SERVICE_URL": "https://api-dev.example.com",
      "AUTH_TOKEN": "${{ secrets.DEV_AUTH_TOKEN }}",
      "TIMEOUT": "30"
    }
  }
  • env-vars/staging.json:
  {
    "Variables": {
      "SERVICE_URL": "https://api-staging.example.com",
      "AUTH_TOKEN": "${{ secrets.STAGING_AUTH_TOKEN }}",
      "TIMEOUT": "60"
    }
  }
  • env-vars/prod.json:
  {
    "Variables": {
      "SERVICE_URL": "https://api.example.com",
      "AUTH_TOKEN": "${{ secrets.PROD_AUTH_TOKEN }}",
      "TIMEOUT": "120"
    }
  }

Here, placeholders like ${{ secrets.* }} reference GitHub Secrets, ensuring sensitive values are securely injected during deployment.

2. Create the GitHub Actions Workflow

Below is the complete GitHub Actions workflow:

name: Deploy Lambda Function

on:
  workflow_dispatch:
    inputs:
      environment:
        description: "Target environment (dev, staging, prod)"
        required: true
        type: choice
        options:
          - dev
          - staging
          - prod

env:
  AWS_REGION: ${{ secrets.AWS_REGION }}
  AWS_ROLE_TO_ASSUME: ${{ secrets.AWS_ROLE_TO_ASSUME }}

permissions:
  id-token: write
  contents: read

jobs:
  deploy:
    name: Deploy Lambda to ${{ inputs.environment }}
    runs-on: ubuntu-latest

    steps:
    - name: Checkout
      uses: actions/checkout@v3

    - name: Set up Python
      uses: actions/setup-python@v4
      with:
        python-version: '3.13'

    - name: Install dependencies
      run: |
        pip install awscli pytest requests

    - name: Configure AWS credentials
      uses: aws-actions/configure-aws-credentials@v3
      with:
        aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
        aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
        aws-session-token: ${{ secrets.AWS_SESSION_TOKEN }}
        aws-region: ${{ env.AWS_REGION }}
        role-to-assume: ${{ env.AWS_ROLE_TO_ASSUME }}

    - name: Zip the Lambda function
      run: zip function.zip lambda_function.py

    - name: Load Environment Variables
      run: |
        echo "Loading environment variables for ${{ inputs.environment }}"
        cat env-vars/${{ inputs.environment }}.json > env-vars/current.json

    - name: Check if Lambda function exists
      id: check_lambda
      run: |
        if aws lambda get-function --function-name "my-generic-lambda-${{ inputs.environment }}"; then
          echo "::set-output name=lambda_exists::true"
        else
          echo "::set-output name=lambda_exists::false"
        fi

    - name: Create or Update Lambda function
      run: |
        REST_API_ID="${{ secrets.API_GATEWAY_REST_API_ID }}"

        # Dynamically set the source ARN based on the environment
        SOURCE_ARN="arn:aws:execute-api:${AWS_REGION}:${{ secrets.AWS_ACCOUNT_ID }}:$REST_API_ID/${{ inputs.environment }}/GET/*"

        if [ "${{ steps.check_lambda.outputs.lambda_exists }}" == "false" ]; then
          echo "Creating Lambda function..."
          aws lambda create-function --function-name "my-generic-lambda-${{ inputs.environment }}" \
            --runtime python3.13 --role ${{ env.AWS_ROLE_TO_ASSUME }} \
            --handler lambda_function.lambda_handler --zip-file fileb://function.zip \
            --environment "$(cat env-vars/current.json)"
        else
          echo "Updating Lambda function..."
          aws lambda update-function-code \
            --function-name "my-generic-lambda-${{ inputs.environment }}" \
            --zip-file fileb://function.zip --publish

          echo "Waiting for 10 seconds to allow AWS Lambda to process the code update..."
          sleep 10

          echo "Updating Lambda function configuration..."
          aws lambda update-function-configuration \
            --function-name "my-generic-lambda-${{ inputs.environment }}" \
            --environment "$(cat env-vars/current.json)"
        fi

Key Features of the Workflow

  • Environment-Specific Deployment: The pipeline dynamically selects the environment (dev, staging, prod) and loads the corresponding JSON file for configuration.
  • No Hardcoded Values: All sensitive data and configuration settings are stored securely in GitHub Secrets or JSON files.
  • Reusable Across Projects: Replace the JSON file contents and Lambda function logic to adapt the pipeline to any project.
  • Scalability: Easily extendable to support additional environments or configurations.

Explanation of the YAML File

1. Triggering the Workflow

The pipeline is triggered manually using workflow_dispatch, allowing developers to select the target environment (dev, staging, prod) from a dropdown menu.

on:
  workflow_dispatch:
    inputs:
      environment:
        description: "Target environment (dev, staging, prod)"
        required: true
        type: choice
        options:
          - dev
          - staging
          - prod

2. Environment Variables

Global environment variables like AWS_REGION and AWS_ROLE_TO_ASSUME are defined using GitHub Secrets, ensuring sensitive data is securely managed.

env:
  AWS_REGION: ${{ secrets.AWS_REGION }}
  AWS_ROLE_TO_ASSUME: ${{ secrets.AWS_ROLE_TO_ASSUME }}

3. Steps

Each step in the pipeline serves a specific purpose:

  • Checkout: Fetches the code from the repository.
  • Set Up Python: Installs Python and necessary dependencies.
  • Configure AWS Credentials: Authenticates with AWS using GitHub Secrets. For more information on configuring AWS credentials, refer to the AWS CLI Lambda documentation.
  • Zip the Lambda Function: Compresses the Lambda function code for deployment.
  • Load Environment Variables: Loads environment-specific configuration from JSON files.
  • Check if Lambda Exists: Determines whether the Lambda function already exists.
  • Create or Update Lambda: Creates or updates the Lambda function and its configuration.

Conclusion

Automating serverless deployments with GitHub Actions and AWS Lambda ensures consistency, security, and scalability while reducing manual effort. By leveraging environment-specific configurations and avoiding hardcoded values, this pipeline is reusable and adaptable to various projects.

If you’re just starting with AWS, don’t forget to check out this step-by-step guide for creating IAM user access keys and secret keys to ensure proper authentication. For advanced users, the AWS CLI Lambda documentation provides detailed insights into Lambda commands and configurations.

Feel free to customize the workflow to suit your specific needs, and happy coding! 🚀

Call to Action: If you found this guide helpful, share it with your team or leave a comment below. For more tips on serverless architecture and automation, subscribe to our blog!

Final Notes

By following this guide, you can build a robust CI/CD pipeline for deploying serverless applications. Use the focus keyphrase strategically throughout the content, and ensure your meta tags are optimized for maximum visibility in search engine results.

Uncategorized

Leave a Reply