Platform Engineers

GitOps for Serverless Functions: Streamlining Deployments for Microservices

Platform Engineers's photo
Platform Engineers
·

6 min read

Serverless functions have become increasingly popular in recent years, as they offer a way to build and deploy microservices without having to manage the underlying infrastructure. However, managing the deployment and configuration of serverless functions can be a complex and time-consuming task. This is where GitOps comes in.

GitOps is a set of practices that use Git as the single source of truth for infrastructure and application configuration. By using GitOps, teams can automate the deployment and configuration of serverless functions, ensuring that they are always up-to-date and consistent across environments.

In this blog post, we will explore how to use GitOps to streamline deployments for serverless functions, using AWS Lambda and the Serverless Framework as an example.

Prerequisites

Before we dive into the details, let's make sure we have the following prerequisites in place:

  • An AWS account with the necessary permissions to create and manage Lambda functions and other AWS resources.

  • The Serverless Framework installed and configured on your local machine.

  • A Git repository to store your infrastructure and application code.

Setting up the GitOps workflow

The first step in setting up a GitOps workflow for serverless functions is to define the infrastructure and application code in a Git repository. This can be done using the Serverless Framework, which allows you to define your Lambda functions and other AWS resources using a simple YAML syntax.

Here's an example of a serverless.yml file that defines a simple Lambda function:

service: my-service

provider:
  name: aws
  runtime: nodejs14.x
  region: us-east-1

functions:
  hello:
    handler: handler.hello
    events:
      - http:
          path: hello
          method: get

This file defines a Lambda function named hello that is triggered by an HTTP request. The function is written in Node.js and is deployed to the us-east-1 region.

Once you have defined your infrastructure and application code, you can commit it to your Git repository. This will serve as the single source of truth for your serverless functions.

Next, you will need to set up a continuous delivery (CD) pipeline that automatically deploys your serverless functions whenever changes are pushed to the Git repository. This can be done using a tool like AWS CodePipeline, which allows you to define a pipeline that builds, tests, and deploys your serverless functions.

Here's an example of a buildspec.yml file that defines the build steps for your serverless functions:

version: 0.2

phases:
  install:
    runtime-versions:
      nodejs: 14
    commands:
      - npm install -g serverless
      - npm install

  build:
    commands:
      - serverless package
      - mv .serverless/package/* .
      - rm -rf .serverless

artifacts:
  files:
    - '**/*'

This file defines two phases: install and build. The install phase installs the necessary dependencies, including the Serverless Framework. The build phase packages the Lambda function and its dependencies into a ZIP file, which is then uploaded to AWS as an artifact.

Once you have defined your CD pipeline, you can configure it to trigger whenever changes are pushed to the Git repository. This can be done using a tool like AWS CodeCommit, which allows you to set up a webhook that triggers the pipeline whenever changes are pushed to the repository.

Here's an example of a codepipeline.yml file that defines the CD pipeline:

version: 0.2

pipeline:
  name: my-pipeline
  stages:
    - name: Source
      actions:
        - name: Source
          actionTypeId:
            category: Source
            owner: AWS
            provider: CodeCommit
            version: '1'
          outputArtifacts:
            - name: SourceOutput
          configuration:
            RepositoryName: my-repo
            BranchName: master
            PollForSourceChanges: 'false'

    - name: Build
      actions:
        - name: Build
          actionTypeId:
            category: Build
            owner: AWS
            provider: CodeBuild
            version: '1'
          inputArtifacts:
            - name: SourceOutput
          outputArtifacts:
            - name: BuildOutput
          configuration:
            ProjectName: my-project

    - name: Deploy
      actions:
        - name: Deploy
          actionTypeId:
            category: Deploy
            owner: AWS
            provider: CodeDeploy
            version: '1'
          inputArtifacts:
            - name: BuildOutput
          configuration:
            ApplicationName: my-app
            DeploymentGroupName: my-deployment-group

This file defines a pipeline with three stages: Source, Build, and Deploy. The Source stage retrieves the latest changes from the Git repository. The Build stage builds and packages the Lambda function and its dependencies. The Deploy stage deploys the Lambda function to AWS.

Once you have defined your CD pipeline, you can commit it to your Git repository. This will ensure that the pipeline is always up-to-date and consistent across environments.

Using GitOps to manage serverless functions

With the GitOps workflow in place, you can now use Git to manage your serverless functions. This means that you can make changes to your infrastructure and application code, commit them to the Git repository, and have them automatically deployed to AWS.

For example, let's say you want to update the hello function to return a different message. You can make the necessary changes to the handler.js file, commit them to the Git repository, and push them to the master branch. This will trigger the CD pipeline, which will build and deploy the updated function to AWS.

Here's an example of the updated handler.js file:

module.exports.hello = async (event) => {
  return {
    statusCode: 200,
    body: JSON.stringify({
      message: 'Hello, world! (updated)'
    })
  };
};

Once the changes have been deployed, you can verify that the hello function is returning the updated message by making an HTTP request to the function's endpoint

GitOps can also be used for platform engineering, which involves building and managing the underlying infrastructure that supports serverless functions and other microservices. By using GitOps for platform engineering, teams can ensure that their infrastructure is always up-to-date and consistent across environments.

For example, let's say you want to create a new AWS Lambda function that uses a specific version of Node.js. You can define the necessary infrastructure and configuration in a Git repository, commit it, and have it automatically deployed to AWS using a CD pipeline.

Here's an example of a serverless.yml file that defines a new Lambda function with a specific version of Node.js:

service: my-new-service

provider:
  name: aws
  runtime: nodejs16.x
  region: us-east-1

functions:
  hello:
    handler: handler.hello
    events:
      - http:
          path: hello
          method: get

Once you have committed this file to the Git repository, the CD pipeline will automatically build and deploy the new Lambda function to AWS. This ensures that the function is always using the correct version of Node.js, regardless of which environment it is deployed to.

Conclusion

GitOps is a powerful set of practices that can help teams streamline deployments for serverless functions and other microservices. By using Git as the single source of truth for infrastructure and application configuration, teams can automate the deployment and configuration of their serverless functions, ensuring that they are always up-to-date and consistent across environments.

In this blog post, we have explored how to use GitOps to streamline deployments for serverless functions, using AWS Lambda and the Serverless Framework as an example. We have also discussed how GitOps can be used for platform engineering, which involves building and managing the underlying infrastructure that supports serverless functions and other microservices.

By following the practices outlined in this blog post, teams can improve their development and deployment processes, reduce errors and inconsistencies, and deliver high-quality serverless applications more quickly and efficiently.

Platform Engineering Infrastructure as code