Orchestrating Multi-Environment Deployments with AWS CodePipeline

Continuous integration and continuous delivery (CI/CD) pipelines streamline deployments, but managing updates across multiple environments (dev, staging, prod) requires careful planning. This article explores using AWS CodePipeline to create a CI/CD pipeline that deploys your application to separate environments with manual approval gates for controlled rollouts.

1. Building the Pipeline Foundation: Stages for Each Environment

• Navigate to the AWS CodePipeline console and click "Create pipeline" to define a new pipeline.
• Provide a descriptive name for your pipeline (e.g., "multi-env-deployment").
• Choose "New service role" to allow CodePipeline to create a role with necessary permissions.

Connecting to CodeCommit:

• In the "Source provider" section, select "AWS CodeCommit."
• Choose the CodeCommit repository containing your application code.
• Click "Next" to proceed with configuring the pipeline stages.

Creating Separate Stages:

CodePipeline allows you to define multiple stages within a single pipeline. Each stage can handle specific tasks in the deployment process. Here's how to create stages for dev, staging, and prod environments:

1. Click "Add stage" and provide a name for the first stage (e.g., "dev-deploy").
2. Repeat step 1 to create additional stages for staging (e.g., "staging-deploy") and production (e.g., "prod-deploy").

2. Deployment Providers: Tailoring Each Stage

• Within each stage configuration, select the appropriate deployment provider based on your application type.
  • For web applications, consider AWS CodeDeploy or AWS Elastic Beanstalk.
  • For serverless functions, AWS CodeDeploy can be used with AWS Lambda.

CodeDeploy Configuration:

Here's an example configuration for a CodeDeploy stage assuming you're deploying to an EC2 instance:

• Choose "AWS CodeDeploy" as the deployment provider.
  • Create a separate CodeDeploy application and deployment group for each environment (dev, staging, prod).
• Configure the deployment settings within each stage:
  • Specify the appropriate CodeDeploy application and deployment group based on the environment.
  • Crucially, under "Deployment configuration," choose "Extract file before deploy" to ensure proper deployment.

This ensures each stage deploys your application code to the designated environment using the configured CodeDeploy setup.

3. Enforcing Control: Implementing Manual Approvals

• Navigate to the stage configuration for your staging environment (e.g., "staging-deploy").
• Click the "Actions" tab within that stage.
• Click "Add action" and choose "Manual approval" as the action type.
• Provide a descriptive name for the approval stage (e.g., "Pre-Prod Approval").
• Click "Next" to configure the approval details.

Repeating for Production:

Repeat the process of adding a manual approval stage after the deployment stage for your production environment (e.g., "prod-deploy").

Permissions and Notifications:

CodePipeline will automatically notify the designated users when a deployment reaches the manual approval stage. Configure IAM policies to restrict who can approve deployments, as explained in the previous article (". Trigger AWS CodePipeline with AWS CodeCommit Approval Rules").

With manual approval gates in place, deployments must be explicitly approved before progressing to the next environment. This allows for controlled rollouts and additional review before reaching production.

4. The Multi-Environment Pipeline in Action

The configured pipeline creates the following workflow:

1. Code changes are pushed to the CodeCommit repository.
2. CodePipeline triggers the pipeline execution.
3. The pipeline deploys the code to the development environment (dev-deploy stage).
4. Developers can test and verify the changes in the development environment.
5. Once satisfied, a designated user can approve the deployment through the manual approval stage for staging (staging-deploy).
6. The code is deployed to the staging environment, allowing for further testing in a more production-like environment.
7. Following successful testing and approval in staging, another manual approval stage gates the deployment to production (prod-deploy).
8. After approval, the code is deployed to the production environment.

This approach offers a structured and controlled deployment process across multiple environments, ensuring code quality and minimizing the risk of introducing issues to production.

Conclusion:

By leveraging CodePipeline stages and manual approval gates, you create a robust CI/CD pipeline for multi-environment deployments. This allows for efficient development cycles while maintaining control and oversight throughout the deployment process.