How to do a conditional deployment via code pipeline

To set up conditional deployments in a single AWS CodePipeline for staging and production environments, you can use multiple deployment stages and conditions based on Git branches or input parameters.

Add a Lambda function to the pipeline to check the branch or condition, triggering the appropriate deployment (staging or production).

Optionally, include a manual approval step before production deployment and configure ECS to deploy to the correct clusters for each environment, ensuring that staging and production stages target their respective resources within the same pipeline.

Here’s a step-by-step guide to implementing a conditional deployment in your CodePipeline:

1. Add Environment Variables to CodeBuild Stage:

In your buildspec.yml file (or CodeBuild build configuration), you can define environment variables to identify the deployment environment. These variables can be passed from CodePipeline, specifying whether it's staging or production.

version: 0.2
env:
  variables:
    ENVIRONMENT: "staging"  # Or "production"
phases:
  build:
    commands:
      - echo "Deploying to $ENVIRONMENT environment"

2. Use Lambda for Conditional Logic:

You can introduce a Lambda function as an action in your CodePipeline to control the conditional deployment logic. This function will inspect the branch or tag and determine whether the deployment should proceed to staging or production.

The Lambda function can modify pipeline variables based on conditions, such as:

• Branch name (e.g., develop, main, or specific tags)
• Metadata (such as custom environment values from GitLab commit messages)

import json

def lambda_handler(event, context):
    # Example: Extract branch from pipeline event or custom GitLab tag
    branch_name = event['detail']['reference']

    if branch_name == 'refs/heads/main':
        environment = 'production'
    elif branch_name == 'refs/heads/develop':
        environment = 'staging'
    else:
        environment = 'development'

    # Return the environment variable to be used in CodePipeline
    return {
        "environment": environment
    }

• Add this Lambda function to the pipeline before the deployment step.
• Based on the environment (staging, production), the Lambda function can output a value that subsequent CodeDeploy actions can consume.

3. Modify CodePipeline for Multi-Environment Deployment:

To support multiple environments, you can add multiple deploy actions in your pipeline for ECS (one for staging and one for production). Each deployment action will be conditional based on the environment value produced by the Lambda function.

You can use parameters like Condition to skip the staging or production deployment depending on which environment is being targeted.

Example Pipeline Structure

stages:
  - name: Source
    actions:
      - name: GitLabSource
        actionTypeId:
          category: Source
          owner: Custom
          provider: GitLab
        outputArtifacts:
          - name: SourceOutput

  - name: Build
    actions:
      - name: BuildAction
        actionTypeId:
          category: Build
          owner: AWS
          provider: CodeBuild
        inputArtifacts:
          - name: SourceOutput
        environmentVariables:
          - name: ENVIRONMENT
            value: 'staging'  # or use dynamic values

  - name: Pre-Deploy Lambda
    actions:
      - name: ConditionalCheck
        actionTypeId:
          category: Invoke
          owner: AWS
          provider: Lambda
        inputArtifacts:
          - name: BuildOutput

  - name: Deploy
    actions:
      - name: StagingDeploy
        actionTypeId:
          category: Deploy
          owner: AWS
          provider: CodeDeploy
        inputArtifacts:
          - name: BuildOutput
        runOrder: 1  # Staging deploy first
        environmentVariables:
          - name: ENVIRONMENT
            value: 'staging'
      
      - name: ProductionDeploy
        actionTypeId:
          category: Deploy
          owner: AWS
          provider: CodeDeploy
        inputArtifacts:
          - name: BuildOutput
        runOrder: 2  # Production deploy after staging
        environmentVariables:
          - name: ENVIRONMENT
            value: 'production'

4. Branch-Based Deployment:

Use the branch name or Git tag in the source stage to trigger deployments only for certain environments. For example:

• If the branch is main, deploy to production.
• If the branch is develop, deploy to staging.

5. Use CodeDeploy with Multiple ECS Targets:

In the CodeDeploy step, configure multiple ECS deployment groups, one for each environment (staging and production). The deployment action will dynamically select the target group based on the value provided by Lambda or the environment variable.

6. Automate the Process Based on GitLab Branches or Tags:

In GitLab, you can also use pipeline triggers or tags to control which environment to deploy to by having different branches (e.g., develop for staging, main for production). The CodePipeline will react to these Git events and trigger the appropriate deployment.

By leveraging environment variables, Lambda, and branch-based conditions, you can build a single pipeline that dynamically deploys to the correct ECS environment based on the current context (branch, tag, or environment).

Thank you for the answers, I will look into this and will get back.