AWS provides a comprehensive suite of services known as AWS Code* for application development and deployment. These services, including AWS CodePipeline, AWS CodeBuild, and AWS CodeDeploy, simplify the CI/CD process. In this blog post, we will explore the functionality of each service and demonstrate their usage through a practical example: deploying a Salesforce package.

What is AWS CodePipeline?

AWS CodePipeline is a continuous delivery service that automates the build, test, and deploy phases of your release process. It orchestrates the steps required to release your software changes, integrating with various services like GitHub, CodeBuild, CodeDeploy, and third-party tools.

Key Features

  • Automated Workflow: Automates steps required to release software changes.
  • Integration: Integrates seamlessly with AWS services and third-party tools.
  • Customizable: Allows for custom workflows and stages.

What is AWS CodeBuild?

AWS CodeBuild is a fully managed continuous integration service that compiles source code, runs tests, and produces software packages ready for deployment. It eliminates the need to manage and scale your own build servers.

Key Features

  • Fully Managed: No need to manage build servers.
  • Scalable: Handles multiple builds concurrently.
  • Customizable: Use pre-built environments or create custom ones with Docker images.

What is AWS CodeDeploy?

AWS CodeDeploy automates code deployments to any instance, including Amazon EC2 instances, on-premises servers, or AWS Lambda. It helps ensure that your application is updated with minimal downtime.

Key Features

  • Automated Deployments: Automates the deployment process.
  • Minimize Downtime: Supports deployment strategies like rolling updates and blue/green deployments.
  • Versatile: Works with various deployment targets including EC2, on-premises servers, and Lambda functions.

Automating Salesforce Package Deployment with AWS Code Services: A Step-by-Step Guide

Let’s explore how you can automate the deployment of a Salesforce package using AWS Code services. Follow these steps to streamline your CI/CD process:

  1. Code Update and Merge in GitHub: Developers push code updates to the force-npower repository on GitHub. When changes are merged into the release branch, it triggers a GitHub Action.
  2. GitHub Action Trigger: The GitHub Action starts the CI/CD pipeline by triggering an AWS CodePipeline.
  3. Source Stage (AWS CodePipeline): The pipeline’s source stage detects the code change in the release branch and pulls the latest code from the GitHub repository.
  4. Build Stage (AWS CodeBuild): CodePipeline triggers a build using AWS CodeBuild. CodeBuild compiles the source code, runs tests, and packages the code into a Salesforce package.
  5. Artifact Storage: The generated Salesforce package is stored in an S3 bucket.
  6. Approval Stage (AWS CodePipeline): A manual approval step ensures that a human reviewer checks the build artifacts before deployment.
  7. Deploy Stage (AWS CodeDeploy/AWS Lambda): Once approved, the package is deployed to a Salesforce instance or notified as ready for installation.

Detailed Steps

  1. GitHub Repository (force-npower):

    • Developers commit and push changes to branches.
    • When changes are merged into the release branch, a GitHub Action triggers the AWS CodePipeline.

  2. GitHub Action:

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

    name: Trigger AWS CodePipeline
on:
  push:
    branches:
      - release
jobs:
  trigger-pipeline:
    runs-on: ubuntu-latest
    steps:
      - name: Trigger AWS CodePipeline
        uses: aws-actions/aws-codepipeline-action@v1
        with:
          name: your-pipeline-name
          region: us-east-1

  3. AWS CodePipeline:

    • Source Stage: Configured to detect changes in the release branch of the GitHub repository.
    • Build Stage: Uses CodeBuild to compile, test, and package the Salesforce code.
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

    const pipeline = new codepipeline.Pipeline(this, "Pipeline", {
  pipelineName: "SalesforcePipeline",
  stages: [
    {
      stageName: "Source",
      actions: [
        new codepipeline_actions.GitHubSourceAction({
          actionName: "GitHub_Source",
          owner: "your-github-username",
          repo: "force-npower",
          branch: "release",
          oauthToken: cdk.SecretValue.secretsManager("github-token"),
          output: sourceOutput,
        }),
      ],
    },
    {
      stageName: "Build",
      actions: [
        new codepipeline_actions.CodeBuildAction({
          actionName: "CodeBuild",
          project: buildProject,
          input: sourceOutput,
          outputs: [buildOutput],
        }),
      ],
    },
    {
      stageName: "Approval",
      actions: [
        new codepipeline_actions.ManualApprovalAction({
          actionName: "ManualApproval",
        }),
      ],
    },
    {
      stageName: "Deploy",
      actions: [
        new codepipeline_actions.LambdaInvokeAction({
          actionName: "DeployToSalesforce",
          lambda: deployLambdaFunction,
          inputs: [buildOutput],
        }),
      ],
    },
  ],
});

  4. AWS CodeBuild:

    • Build Project: Defines the environment and build specifications for creating the Salesforce package.
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

    const buildProject = new codebuild.PipelineProject(this, "BuildProject", {
  environment: {
    buildImage: codebuild.LinuxBuildImage.STANDARD_5_0,
    environmentVariables: {
      PACKAGE_NAME: { value: "SalesforcePackage" },
    },
  },
  buildSpec: codebuild.BuildSpec.fromObject({
    version: "0.2",
    phases: {
      install: {
        commands: ["npm install", "sfdx plugins:install salesforcedx"],
      },
      build: {
        commands: [
          "sfdx force:source:convert -d output",
          'sfdx force:package:create --name "MyPackage" --path output',
        ],
      },
    },
    artifacts: {
      files: ["**/*"],
      "base-directory": "output",
    },
  }),
});

  5. Artifact Storage:

    • The built package is stored in an S3 bucket, making it accessible for deployment or manual download.

  6. Approval Stage:

    • A manual approval action ensures that someone reviews and approves the build before deployment.

  7. Deploy Stage:

    • AWS Lambda can be used to automate the deployment to Salesforce or to notify stakeholders.
    1
2
3
4
5
6
7
8

    const deployLambdaFunction = new lambda.Function(this, "DeployFunction", {
  runtime: lambda.Runtime.NODEJS_14_X,
  handler: "index.handler",
  code: lambda.Code.fromAsset("lambda"),
  environment: {
    PACKAGE_NAME: "SalesforcePackage",
  },
});

Wrapping it up 👏

AWS Code* services like CodePipeline, CodeBuild, and CodeDeploy are awesome for automating CI/CD. They integrate smoothly with GitHub and Salesforce, making it easy to test, package, and deploy code changes. Say goodbye to manual work and hello to faster releases and fewer errors. These tools are perfect for modern development practices, whether you’re working on regular apps or Salesforce packages.

Cheers! 🍺