Streamlining Post-Deployment Tasks: Invoking AWS Lambda Functions from CodePipeline

Continuous integration and continuous delivery (CI/CD) pipelines automate application deployments. However, additional tasks may be required after deployment. This article explores integrating AWS Lambda functions with AWS CodePipeline to execute post-deployment actions. You'll learn how to create a Lambda function for these tasks and configure CodePipeline to trigger its execution after a successful deployment.

1. Building the Helper: A Lambda Function for Post-Deployment Tasks

• Navigate to the AWS Lambda service console and click "Create function."
• Choose "Author from scratch" as the creation method.
• Provide a descriptive name for your function (e.g., "post-deployment-tasks").
• Select ".NET 6" (or your preferred runtime) as the runtime environment.
• Click "Create function" to initialize the function.

Coding the Lambda Function:

Here's a basic example of a .NET 6 Lambda function that sends a notification after a successful deployment:

C#

using Amazon.SimpleNotificationService;
using Amazon.SimpleNotificationService.Model;

public class Function 
{
    private readonly IAmazonSimpleNotificationService _snsClient;

    public Function(IAmazonSimpleNotificationService snsClient)
    {
        _snsClient = snsClient;
    }

    public async Task<string> FunctionHandler(string input, ILambdaContext context)
    {
        // Replace with your actual SNS topic ARN
        var topicArn = "arn:aws:sns:<region>:<account-id>:MySNSTopic";
        var message = "Deployment completed successfully!";

        await _snsClient.PublishAsync(new PublishRequest
        {
            TopicArn = topicArn,
            Message = message
        });

        return message;
    }
}

 

Explanation:

• This function utilizes the AWS SDK for .NET to interact with the Amazon Simple Notification Service (SNS).
• The FunctionHandler method is triggered when the Lambda function is invoked.
• It publishes a message to a specific SNS topic after a successful deployment.
• Remember to replace the placeholder topic ARN with your actual SNS topic details.

Configuring Permissions:

For the Lambda function to access SNS, ensure its IAM role has the necessary permissions (e.g., sns:Publish). You can configure this during function creation or by attaching a policy later.

2. Integrating the Pipeline: Adding the Lambda Invocation Action

• Navigate to the AWS CodePipeline console and select the pipeline you want to modify.
• Locate the stage where deployment occurs (e.g., the stage using CodeDeploy or another deployment provider).

Adding the Lambda Action:

• Click the "Actions" tab within that stage.
• Click "Add action" and choose "AWS Lambda" as the action type.
• Provide a descriptive name for the action (e.g., "Post-Deployment-Notification").
• Choose the Lambda function you created earlier (e.g., "post-deployment-tasks").

Passing Parameters (Optional):

CodePipeline allows you to pass parameters to your Lambda function during invocation. This can be useful for customizing the function's behavior based on the deployment context.

Here's how to configure a parameter:

• In the "Lambda function invocation" section, click the "Input" tab.
• Click "Add another parameter."
• Specify a name for the parameter (e.g., "deploymentEnvironment") and choose its type (e.g., String).
• Under "Value," choose "Pipeline variable" and select the desired pipeline variable containing the environment name (e.g., "${environment.name}").

Pipeline Variables:

Pipeline variables are defined within your pipeline configuration and can hold values accessible throughout the pipeline execution. In this example, the pipeline variable ${environment.name} might contain the name of the environment where the deployment just occurred (e.g., "dev" or "prod").

By using pipeline variables, you can dynamically adjust the Lambda function's behavior based on the deployment environment.

3. The Combined Workflow: Automating Post-Deployment Actions

With the Lambda function and CodePipeline configuration in place, the following workflow emerges:

1. Code changes trigger the CodePipeline execution.
2. The pipeline deploys the application code to the designated environment (e.g., using CodeDeploy).
3. Upon successful deployment, the pipeline reaches the stage containing the Lambda invocation action.
4. CodePipeline invokes the Lambda function, passing any configured parameters (e.g., the deployment environment name).
5. The Lambda function executes its defined logic, in this case, sending a notification via SNS.