# AWS CodePipeline

Cloud service · AWS. Updated 2026-11-12. Page: https://blowstack.com/tools/cloud-services-hub/aws-codepipeline

> AWS CodePipeline is a continuous integration and continuous delivery (CI/CD) service for fast and reliable application and infrastructure updates.

Practice exams covering AWS CodePipeline: [AIF-C01 AWS Certified AI Practitioner](https://blowstack.com/practice-exams/aws-certified-ai-practitioner), [CLF-C02 AWS Certified Cloud Practitioner](https://blowstack.com/practice-exams/aws-certified-cloud-practitioner), [DEA-C01 AWS Certified Data Engineer - Associate](https://blowstack.com/practice-exams/aws-certified-data-engineer-associate), [DVA-C02 AWS Certified Developer - Associate](https://blowstack.com/practice-exams/aws-certified-developer-associate), [DOP-C02 AWS Certified DevOps Engineer - Professional](https://blowstack.com/practice-exams/aws-certified-devops-engineer-professional), [AIP-C01 AWS Certified Generative AI Developer - Professional](https://blowstack.com/practice-exams/aws-certified-generative-ai-developer-professional), [MLA-C02 AWS Certified Machine Learning Engineer - Associate](https://blowstack.com/practice-exams/aws-certified-machine-learning-engineer-associate), [SCS-C03 AWS Certified Security - Specialty](https://blowstack.com/practice-exams/aws-certified-security-specialty), [SAP-C03 AWS Certified Solutions Architect - Professional](https://blowstack.com/practice-exams/aws-certified-solutions-architect-professional).

## 10 key features of AWS CodePipeline

AWS CodePipeline offers an automated, flexible, and scalable CI/CD service that integrates well with AWS and third-party services, prioritizing fast delivery, security, and high availability.

1. **Continuous Integration and Delivery**: AWS CodePipeline automates the build, test, and deploy phases of your release process every time there is a code change, based on the release model you define.
2. **Fast Delivery**: Speed up the release process by automating the build and deployment phases, allowing for rapid delivery of features and updates.
3. **Scalable**: AWS CodePipeline can scale automatically to accommodate the growth of projects as they evolve over time, handling an increase in workloads seamlessly.
4. **Flexible**: Easily integrate with third-party services such as GitHub or integrate with custom plugins, providing flexibility in the tools and services you can use for your CI/CD processes.
5. **Integrated with AWS Services**: CodePipeline is deeply integrated with other AWS services like AWS CodeBuild, AWS CodeDeploy, Amazon EC2, and Amazon S3, offering a seamless CI/CD experience within the AWS ecosystem.
6. **Secure**: AWS CodePipeline is designed with security in mind, providing strong access control policies and allowing for encryption of data using AWS Key Management Service (KMS).
7. **High Availability**: AWS CodePipeline is designed for high availability and fault tolerance, ensuring that the CI/CD process remains operational and efficient without significant downtime.
8. **Manual Approval Gates**: Manual approval actions can prevent changes from progressing through a pipeline and can be included in any stage except a source stage.
9. **Pipeline Monitoring and Recovery**: Review real-time pipeline status, inspect alerts and source revisions, retry failed stages or actions, and manually rerun pipelines.
10. **Pipeline Execution History**: View pipeline execution history, including start and end times, run duration, and execution IDs.

## Where AWS CodePipeline is used

AWS CodePipeline facilitates automated Continuous Integration/Continuous Delivery (CI/CD) processes for a variety of applications, from microservices and serverless architectures to infrastructure provisioning and complex deployment strategies, ensuring rapid, reliable, and high-quality software releases.

1. **Continuous Integration and Delivery for Microservices**: AWS CodePipeline automates the steps required to release new versions of microservices, integrating code changes, building the application, running automated tests, and deploying the code to various environments such as staging and production. This use case highlights the ability to manage complex architectures and multiple deployments in a streamlined process.
2. **Automated Deployment for Serverless Applications**: Leverage AWS CodePipeline to automate deployment processes for serverless applications built on AWS Lambda, Amazon API Gateway, and other serverless services. This involves automating the build, test, and deploy phases for applications where server management is abstracted away, ensuring rapid delivery with less overhead.
3. **Blue/Green Deployments**: Use AWS CodePipeline to implement blue/green deployment strategies, which minimize downtime and risk by running two identical production environments termed as 'Blue' and 'Green'. CodePipeline automates the process of deploying and testing the new version in the 'Green' environment before moving traffic from 'Blue' to 'Green', facilitating easy rollbacks if issues are detected.
4. **Infrastructure as Code (IaC) Deployments**: AWS CodePipeline integrates with AWS CloudFormation and other IaC tools to automate the deployment and updates of infrastructure. This ensures that the provisioning of AWS resources and the deployment of applications can be done in a consistent, repeatable manner across different environments, improving efficiency and reducing the chances for human error.
5. **Automated Testing and Quality Assurance**: Automatically trigger the execution of tests, including unit tests, integration tests, and UI tests, as part of the CI/CD process. This use case emphasizes the role of AWS CodePipeline in ensuring that every code change is verified, ensuring a high quality of code and quick identification of bugs or integration issues before they reach production.

## How AWS CodePipeline is priced

AWS CodePipeline employs a pricing model based on the number of active pipelines per month, with additional costs for artifact storage and transfer.

- **Per-active Pipeline Pricing**: V1 pipelines cost $1.00 per active pipeline per month, with one active V1 pipeline free per month. An active pipeline has existed for more than 30 days and has at least one code change run through it during the month. Pipelines are free for their first 30 days, and pipelines with no new code changes running through them during the month are not charged. Active pipeline charges are not prorated for partial months.
- **Artifact Storage and Transfer Pricing**: Additional charges apply for artifact storage and the transfer of artifacts out of AWS CodePipeline to another region or out of AWS. These costs are based on the amount of data stored and transferred.
- **V2 Action Execution Pricing**: V2 pipelines cost $0.002 per action execution minute, with each action's duration rounded up to the nearest minute. Manual approval and custom action types are excluded from these charges. The free tier includes 100 action execution minutes per month shared across all V2 pipelines in the account; unused minutes do not carry over.

## Services AWS CodePipeline works with

- **[AWS CodeBuild](https://blowstack.com/tools/cloud-services-hub/aws-codebuild)**: CodePipeline integrates with CodeBuild, a fully managed build service that compiles source code, runs tests, and produces software packages. CodeBuild can be used as a build stage in your pipeline to automate the build process.
- **[AWS CodeDeploy](https://blowstack.com/tools/cloud-services-hub/aws-codedeploy)**: CodePipeline integrates with CodeDeploy, a service that automates code deployments to various compute services, such as Amazon EC2, AWS Lambda, and on-premises servers. This integration allows you to use CodeDeploy as a deployment stage in your pipeline.
- **[Amazon S3](https://blowstack.com/tools/cloud-services-hub/amazon-s3)**: CodePipeline can use S3 as a source or artifact store. You can configure CodePipeline to retrieve source code or deployment artifacts from S3 buckets or store build artifacts in S3 for further stages.
- **[AWS Lambda](https://blowstack.com/tools/cloud-services-hub/aws-lambda)**: CodePipeline can integrate with Lambda to perform custom actions or trigger functions at any stage of the pipeline. This allows you to add custom logic, notifications, or other automated processes as part of your CI/CD workflow.
- **[Amazon Elastic Container Service (Amazon ECS)](https://blowstack.com/tools/cloud-services-hub/amazon-elastic-container-service-(amazon-ecs))**: CodePipeline integrates with ECS to deploy containerized applications. You can configure a deployment stage in your pipeline to update ECS services with new Docker images.
- **[Amazon Elastic Container Registry (Amazon ECR)](https://blowstack.com/tools/cloud-services-hub/amazon-elastic-container-registry-(amazon-ecr))**: CodePipeline can use ECR as a source stage for Docker images. You can configure your pipeline to automatically trigger builds and deployments when new images are pushed to ECR.
- **[AWS CloudFormation](https://blowstack.com/tools/cloud-services-hub/aws-cloudformation)**: CodePipeline integrates with CloudFormation to automate the deployment of infrastructure as code. You can use CloudFormation templates as part of your pipeline to create, update, or delete AWS resources in a controlled and repeatable manner.
- **[AWS CodeCommit](https://blowstack.com/tools/cloud-services-hub/aws-codecommit)**: A fully managed source control service that makes it easy for teams to host secure and scalable Git repositories.
- **[AWS Elastic Beanstalk](https://blowstack.com/tools/cloud-services-hub/aws-elastic-beanstalk)**: An easy-to-use service for deploying and scaling web applications and services.
- **[Amazon CloudWatch](https://blowstack.com/tools/cloud-services-hub/amazon-cloudwatch)**: CodePipeline publishes pipeline execution metrics to CloudWatch for monitoring and alarms. Pipeline stage conditions can also evaluate CloudWatch alarms to block a release or initiate a rollback when application health deteriorates.
- **[Amazon CodeGuru](https://blowstack.com/tools/cloud-services-hub/amazon-codeguru)**: CodePipeline workflows can incorporate CodeGuru Reviewer analysis through a build or test step that submits source code for review. This lets a release workflow check for code-quality and security findings before deployment.
- **[Amazon EC2](https://blowstack.com/tools/cloud-services-hub/amazon-ec2)**: CodePipeline's EC2 deployment action installs application artifacts on selected EC2 instances using AWS Systems Manager. Deployment scripts can stop the application, install the new revision, and restart it.
- **[Amazon ECS Anywhere](https://blowstack.com/tools/cloud-services-hub/amazon-ecs-anywhere)**: CodePipeline's ECS deployment action can update container images for an ECS service running on external instances registered through ECS Anywhere. This extends an automated container release pipeline to customer-managed infrastructure.
- **[Amazon Elastic Kubernetes Service (Amazon EKS)](https://blowstack.com/tools/cloud-services-hub/amazon-elastic-kubernetes-service-(amazon-eks))**: CodePipeline provides an EKS deployment action that deploys applications to a cluster using Kubernetes manifests or Helm charts. A pipeline can build a container image and then roll out the corresponding application revision.
- **[Amazon EventBridge](https://blowstack.com/tools/cloud-services-hub/amazon-eventbridge)**: CodePipeline can be an EventBridge rule target, allowing repository changes, schedules, or other events to start pipeline executions. It also emits pipeline, stage, and action state-change events that rules can route to notification or automation targets.
- **[Amazon Inspector](https://blowstack.com/tools/cloud-services-hub/amazon-inspector)**: CodePipeline provides an InspectorScan action for scanning source-code dependencies or container images for vulnerabilities. Configurable severity thresholds can fail the action and prevent vulnerable changes from progressing.
- **[Amazon SageMaker](https://blowstack.com/tools/cloud-services-hub/amazon-sagemaker)**: CodePipeline powers CI/CD workflows created by SageMaker Projects templates, including workflows for model building and deployment. For example, an approved model version in the SageMaker Model Registry can initiate a pipeline that deploys and tests inference endpoints.
- **[Amazon Simple Notification Service (Amazon SNS)](https://blowstack.com/tools/cloud-services-hub/amazon-simple-notification-service-(amazon-sns))**: CodePipeline manual approval actions can publish approval requests to an SNS topic. Pipeline notification rules can also use SNS to notify subscribers about execution failures, successes, and other release events.
- **[Amazon VPC](https://blowstack.com/tools/cloud-services-hub/amazon-vpc)**: CodePipeline supports interface VPC endpoints so clients in a VPC can access its API without using a public internet connection. Endpoint policies can restrict which pipeline operations are accessible through the endpoint.
- **[AWS App2Container](https://blowstack.com/tools/cloud-services-hub/aws-app2container)**: AWS App2Container can generate and deploy CodePipeline pipelines for applications it containerizes. These pipelines automate rebuilding container images and deploying subsequent application revisions.
- **[AWS AppConfig](https://blowstack.com/tools/cloud-services-hub/aws-appconfig)**: CodePipeline provides an AppConfig deployment action that releases configuration artifacts to an AppConfig environment. AppConfig applies the selected deployment strategy and its configured validation and monitoring controls.
- **[AWS Chatbot](https://blowstack.com/tools/cloud-services-hub/aws-chatbot)**: CodePipeline notification rules can deliver pipeline events to AWS Chatbot clients through AWS CodeStar Notifications. Teams can receive release failures and approval-related notifications in configured chat channels.
- **[AWS CloudTrail](https://blowstack.com/tools/cloud-services-hub/aws-cloudtrail)**: CloudTrail records CodePipeline API activity, including pipeline creation, configuration changes, and execution requests. These records help audit who changed a release workflow or started a deployment.
- **[AWS CodeConnections](https://blowstack.com/tools/cloud-services-hub/aws-codeconnections)**: CodePipeline uses CodeConnections-backed source actions to retrieve code from supported external Git providers. Repository and branch filters can automatically start pipelines for selected pushes or pull-request events.
- **[AWS Config](https://blowstack.com/tools/cloud-services-hub/aws-config)**: AWS Config can record CodePipeline pipeline configurations and track changes over time. Config rules can assess pipeline resources against organizational requirements.
- **[AWS Device Farm](https://blowstack.com/tools/cloud-services-hub/aws-device-farm)**: CodePipeline provides a Device Farm test action that runs application tests on real devices. A pipeline can pass a built mobile application and test package to Device Farm and require successful testing before continuing.
- **[AWS DevOps Agent](https://blowstack.com/tools/cloud-services-hub/aws-devops-agent)**: AWS DevOps Agent can use CodePipeline deployment activity as change context during operational investigations. This helps correlate an incident with a recent pipeline execution and the revision it released.
- **[AWS Fargate](https://blowstack.com/tools/cloud-services-hub/aws-fargate)**: CodePipeline can deploy applications to ECS services running on Fargate through its ECS deployment actions. It also supports ECS blue/green deployments through CodeDeploy, allowing traffic to shift to a newly deployed Fargate task set.
- **[AWS Identity and Access Management (IAM)](https://blowstack.com/tools/cloud-services-hub/aws-identity-and-access-management-(iam))**: CodePipeline assumes an IAM service role to access source repositories, artifacts, build projects, and deployment targets. Separate action roles can restrict permissions for individual actions or enable deployments into other accounts.
- **[AWS Key Management Service (AWS KMS)](https://blowstack.com/tools/cloud-services-hub/aws-key-management-service-(aws-kms))**: CodePipeline uses KMS encryption for artifacts stored in its S3 artifact buckets. Customer-managed keys provide control over artifact access and are used when configuring supported cross-account artifact sharing.
- **[AWS PrivateLink](https://blowstack.com/tools/cloud-services-hub/aws-privatelink)**: CodePipeline exposes API access through AWS PrivateLink interface endpoints. Private clients can manage pipelines without an internet gateway or NAT gateway.
- **[AWS Secrets Manager](https://blowstack.com/tools/cloud-services-hub/aws-secrets-manager)**: CodePipeline Commands actions can reference Secrets Manager secrets through secret-backed environment variables. This allows commands to use credentials without placing their plaintext values in the pipeline definition.
- **[AWS Security Token Service (AWS STS)](https://blowstack.com/tools/cloud-services-hub/aws-security-token-service-(aws-sts))**: CodePipeline uses STS to assume its service role and configured action roles, obtaining temporary credentials for pipeline operations. Cross-account actions use this role-assumption mechanism to access resources in a target account.
- **[AWS Service Catalog](https://blowstack.com/tools/cloud-services-hub/aws-service-catalog)**: CodePipeline provides a Service Catalog deployment action that publishes a CloudFormation template as a new provisioning artifact for an existing product. This automates releasing tested infrastructure versions to a service catalog.
- **[AWS Step Functions](https://blowstack.com/tools/cloud-services-hub/aws-step-functions)**: CodePipeline provides an invoke action that starts a Step Functions state machine. A release can use a state machine to coordinate validation or deployment tasks and use its result to determine whether the pipeline continues.
- **[AWS Systems Manager](https://blowstack.com/tools/cloud-services-hub/aws-systems-manager)**: CodePipeline's EC2 deployment action uses Systems Manager to execute deployment commands on managed EC2 instances. Target instances require the SSM Agent and appropriate permissions so the action can install and validate an application revision.
- **[AWS User Notifications](https://blowstack.com/tools/cloud-services-hub/aws-user-notifications)**: AWS User Notifications can create notification configurations for CodePipeline execution events. Filters and aggregation settings let users receive selected pipeline updates through their configured delivery channels.

## What is AWS CodePipeline

AWS CodePipeline is a fully managed continuous integration and continuous delivery (CI/CD) service that automates the steps required to release software changes quickly and reliably. This service connects various stages involved in the software release process, such as building code, running tests, and deploying it to production environments, using a model defined in a pipeline.

A pipeline in AWS CodePipeline is essentially a workflow that defines how code changes are to be promoted through various stages from source control to production. It is composed of a series of stages, each designed to perform specific actions on the code. Stages in a pipeline are typically categorized into source, build, test, and deploy, although users can customize this to suit their project needs.

A stage's inbound transition can be disabled to prevent executions from entering that stage and enabled to let them continue. If multiple executions reach a disabled transition, only the latest continues when the transition is enabled; newer executions supersede waiting executions.

The default quota is 1,000 pipelines per AWS account per Region, counting pipelines that use either polling or event-based change detection.

CodePipeline offers V1 and V2 pipeline types, which differ in features and price. Pipelines default to V1 when no type is specified; V2 must be explicitly configured.

Each stage consists of one or more actions, which are tasks performed on the code within the stage. Actions can include tasks such as compiling code, running unit tests, or deploying code to a specific environment.

Actions within a stage can run in series or in parallel.

Manual approval actions have an account-level default timeout of seven days. An individual action can override this with a timeout from five minutes to 86,400 minutes (60 days); otherwise, the account-level default applies.

One of the key features of AWS CodePipeline is its integration with other AWS services and third-party tools. For instance, it can automatically pull source code from repositories like GitHub, AWS CodeCommit, or Bitbucket. For building and testing code, it integrates seamlessly with AWS CodeBuild; for deploying code, it integrates with AWS CodeDeploy.

Additionally, it supports integration with Jenkins, a popular open-source automation server, enabling developers to use existing Jenkins-based workflows within their pipelines. This wide range of integrations provides users with flexibility in building their CI/CD workflows and allows them to leverage existing tools and services in their development ecosystem. AWS CodePipeline also provides automated triggers for pipeline execution. These triggers can be configured to automatically start a pipeline based on specific events, such as a commit to a source repository or a change in a particular branch. This feature ensures that the software release process remains streamlined, with minimal manual intervention required, leading to faster and more frequent deployments.

A specific pipeline execution can be stopped from continuing through the pipeline.

Security in AWS CodePipeline is handled with AWS Identity and Access Management (IAM), which controls access to the service and its resources. Users can set granular permissions for each action within a pipeline, ensuring that only authorized persons can make changes to the pipeline or the code. Moreover, the service is designed to keep your code and data secure throughout the release process, using encryption to protect your artifacts stored in S3 buckets and encrypting data in transit.

Overall, AWS CodePipeline offers a robust solution for automating the software release process, making it faster, more reliable, and secure. Its ability to integrate with a wide array of AWS and third-party services, coupled with its automated execution triggers and security features, make it an attractive choice for developers and businesses looking to streamline their CI/CD workflows.

## Concepts related to AWS CodePipeline

- [CI/CD](https://blowstack.com/tools/cloud-concepts-hub/cicd): CI/CD is a software engineering approach that continuously integrates code changes and automates their validation and delivery or deployment.
- [Version Control](https://blowstack.com/tools/cloud-concepts-hub/version-control): Version control is the practice of tracking and identifying changes to artifacts so teams can compare revisions, reproduce releases, and restore earlier states.
- [Quality Gates](https://blowstack.com/tools/cloud-concepts-hub/quality-gates): Quality gates are explicit pass-or-fail checkpoints that use evidence to determine whether a change can advance through a delivery workflow.
- [Security Quality Gates](https://blowstack.com/tools/cloud-concepts-hub/security-quality-gates): Security quality gates are enforced checkpoints that allow software changes to advance only when defined security acceptance criteria are satisfied.
- [Test Pyramid](https://blowstack.com/tools/cloud-concepts-hub/test-pyramid): The Test Pyramid is a testing strategy that favors many fast, focused tests, fewer integration tests, and a small set of broad end-to-end tests.
- [Code Coverage](https://blowstack.com/tools/cloud-concepts-hub/code-coverage): Code coverage measures how much application code is executed while automated tests run.
- [Trunk-Based Development](https://blowstack.com/tools/cloud-concepts-hub/trunk-based-development): Trunk-Based Development is a version-control strategy in which developers integrate small changes frequently into a single shared main branch, using direct commits or short-lived branches.
- [Unit Testing](https://blowstack.com/tools/cloud-concepts-hub/unit-testing): Unit testing verifies the behavior of a small, independently testable piece of code while controlling its dependencies.
- [Agile Development](https://blowstack.com/tools/cloud-concepts-hub/agile-development): Agile development is an iterative, incremental approach to software delivery that adapts plans through frequent feedback, collaboration, and working software.
- [Gitflow](https://blowstack.com/tools/cloud-concepts-hub/gitflow): Gitflow is a Git branching workflow that separates ongoing development, release preparation, and production fixes using branches with defined roles.
- [Infrastructure as code (IaC)](https://blowstack.com/tools/cloud-concepts-hub/infrastructure-as-code-(iac)): Infrastructure as code (IaC) is the practice of defining and managing infrastructure through machine-readable, version-controlled configuration or code rather than manual setup.
- [Integration Testing](https://blowstack.com/tools/cloud-concepts-hub/integration-testing): Integration testing verifies that connected software components exchange data and work together correctly across their interfaces.
- [Waterfall Model](https://blowstack.com/tools/cloud-concepts-hub/waterfall-model): The Waterfall Model is a software development lifecycle approach that organizes work into sequential phases, typically completing and approving each phase before the next begins.
- [Acceptance Testing](https://blowstack.com/tools/cloud-concepts-hub/acceptance-testing): Acceptance testing verifies that a system satisfies agreed acceptance criteria and is suitable for its intended business use.
- [All-at-Once Deployment](https://blowstack.com/tools/cloud-concepts-hub/all-at-once-deployment): All-at-once deployment releases a new application version to the entire targeted environment in a single deployment batch rather than through staged updates.
- [API Gateway Pattern](https://blowstack.com/tools/cloud-concepts-hub/api-gateway-pattern): The API Gateway Pattern places a controlled entry point between clients and backend services to centralize request routing and shared API policies.
- [Canary Deployment](https://blowstack.com/tools/cloud-concepts-hub/canary-deployment): Canary deployment releases a new application or model version to a small portion of production traffic before expanding exposure after validation.
- [Code Refactoring](https://blowstack.com/tools/cloud-concepts-hub/code-refactoring): Code refactoring is the restructuring of existing source code to improve its internal design without changing its externally observable behavior.
- [Contract Testing](https://blowstack.com/tools/cloud-concepts-hub/contract-testing): Contract testing verifies that communicating components satisfy agreed expectations for requests, responses, or messages at their integration boundaries.
- [Dependency Pinning](https://blowstack.com/tools/cloud-concepts-hub/dependency-pinning): Dependency pinning fixes build dependencies to explicitly selected versions or immutable identifiers so automated builds do not silently consume different inputs.
- [Deployment Rollback](https://blowstack.com/tools/cloud-concepts-hub/deployment-rollback): Deployment rollback restores a previously validated application, infrastructure, or model release when a new deployment fails or causes unacceptable behavior.
- [Developer tools](https://blowstack.com/tools/cloud-concepts-hub/developer-tools): Developer tools are software utilities and services that help engineers write, test, debug, package, and deliver applications.
- [Environment Isolation](https://blowstack.com/tools/cloud-concepts-hub/environment-isolation): Environment isolation separates development, testing, staging, and production resources so that activity in one environment does not unintentionally affect another.
- [Exit Codes](https://blowstack.com/tools/cloud-concepts-hub/exit-codes): Exit codes are numeric status values that processes return when they terminate so calling systems can determine whether an operation succeeded or failed.
- [Fail-Fast](https://blowstack.com/tools/cloud-concepts-hub/fail-fast): Fail-Fast is the practice of detecting invalid conditions early, reporting failure explicitly, and stopping work that cannot safely succeed.
- [Load Testing](https://blowstack.com/tools/cloud-concepts-hub/load-testing): Load testing evaluates how a system performs under a defined workload to verify capacity, response times, reliability, and scaling behavior.
- [Low-Rank Adaptation](https://blowstack.com/tools/cloud-concepts-hub/low-rank-adaptation): Low-Rank Adaptation is a parameter-efficient fine-tuning technique that customizes a pretrained model by training small, low-rank weight updates while keeping the original model weights frozen.
- [Microservices and component delivery](https://blowstack.com/tools/cloud-concepts-hub/microservices-and-component-delivery): Microservices and component delivery is an approach to building applications as loosely coupled services that can be developed, tested, deployed, and scaled independently.
- [Parameterization](https://blowstack.com/tools/cloud-concepts-hub/parameterization): Parameterization separates environment-specific values from reusable infrastructure definitions by supplying those values through explicit inputs.
- [Performance Benchmarking](https://blowstack.com/tools/cloud-concepts-hub/performance-benchmarking): Performance benchmarking is the repeatable measurement of a system under defined workloads to compare its behavior against a baseline, alternative configuration, or performance target.
- [Phased Rollout](https://blowstack.com/tools/cloud-concepts-hub/phased-rollout): Phased rollout is the controlled introduction of a capability to progressively larger groups or workloads, using evidence from each stage to decide whether to expand.
- [Policy as Code](https://blowstack.com/tools/cloud-concepts-hub/policy-as-code): Policy as Code expresses governance and security requirements as version-controlled, machine-evaluable rules that automated workflows can test and enforce.
- [RACI Matrix](https://blowstack.com/tools/cloud-concepts-hub/raci-matrix): A RACI matrix maps activities and decisions to the roles that are Responsible, Accountable, Consulted, and Informed.
- [Reproducible Builds](https://blowstack.com/tools/cloud-concepts-hub/reproducible-builds): Reproducible builds produce byte-for-byte identical artifacts when the same source code, declared inputs, and build instructions are used.
- [Shadow Testing](https://blowstack.com/tools/cloud-concepts-hub/shadow-testing): Shadow testing evaluates a candidate system using copies of live production requests while only the established production system returns responses to users.
- [Shift-Left Security](https://blowstack.com/tools/cloud-concepts-hub/shift-left-security): Shift-left security integrates security design, testing, and remediation into the earliest practical stages of software development and delivery.
- [Stage-Gate Process](https://blowstack.com/tools/cloud-concepts-hub/stage-gate-process): A stage-gate process divides an initiative into phases separated by evidence-based decisions to proceed, scale, pause, rework, or terminate.
- [Static Analysis](https://blowstack.com/tools/cloud-concepts-hub/static-analysis): Static analysis examines code, configuration, or infrastructure definitions for defects and policy violations without executing the workload or deploying the resources being analyzed.
- [Static Application Security Testing](https://blowstack.com/tools/cloud-concepts-hub/static-application-security-testing): Static Application Security Testing analyzes application source code or compiled artifacts for security weaknesses without running the application.
- [Stress Testing](https://blowstack.com/tools/cloud-concepts-hub/stress-testing): Stress testing deliberately pushes a system beyond its expected operating load or constrains its resources to evaluate failure behavior, capacity limits, and recovery.
- [UI Testing](https://blowstack.com/tools/cloud-concepts-hub/ui-testing): UI testing verifies that an application's user interface behaves correctly when users interact with it.

## AWS CodePipeline exam questions

Real practice exam questions on AWS CodePipeline, with the correct answer and its explanation.

### Question 1 (AIF-C01)

**Question:**

A company is preparing an ML-powered application for production. Each change to the application's inference code must follow the same release process: run automated tests, stop the release if any test fails, and obtain approval from the ML team before deploying to production. The company wants to minimize manual coordination between these steps. Which solution best meets these requirements?

**Correct answer:** Use AWS CodePipeline with sequential stages for automated tests, manual approval, and production deployment, preventing progression when tests fail.

**Explanation:** AWS CodePipeline orchestrates a repeatable CI/CD workflow. Failed tests block progression, and a manual approval stage ensures that the ML team authorizes the release before production deployment. Human approval is compatible with continuous delivery.

### Question 2 (MLA-C02)

**Question:**

A company fine-tunes a foundation model in Amazon Bedrock in a development AWS Region. An AWS CodePipeline release pipeline evaluates each custom model and records its ARN in an immutable release manifest. Production must run in a different Region in the same AWS account and must use the exact evaluated model without retraining. The selected model supports cross-Region custom model copying, and inference requires Provisioned Throughput in both Regions. The production application uses a regional Bedrock Runtime client.

Which deployment procedure should the ML engineer automate?

**Correct answer:** Call CreateModelCopyJob in the production Region with the release manifest's custom model ARN and source Region. Wait for the copy to complete, create Provisioned Throughput for the resulting target model ARN, and wait until it is InService. Record the destination identifiers in the release record and configure production to invoke the destination provisioned model ARN.

**Explanation:** Cross-Region custom model copying transfers the evaluated model without retraining. Using the manifest's exact source ARN preserves release identity. Waiting for copying and provisioning to finish ensures readiness, and invoking the destination provisioned model ARN serves the copied model in the required Region.

### Question 3 (SAP-C03)

**Question:**

A company uses an AWS CodePipeline V2 pipeline in PARALLEL execution mode to validate changes in an existing AWS CodeCommit repository. An Amazon EventBridge rule invokes a Lambda function for each update to the main branch. The function calls StartPipelineExecution. Source polling and other automatic pipeline triggers are disabled.

During bursts of commits, multiple executions sometimes validate the same newer commit instead of the individual commits that caused their events. The pipeline's CodeBuild actions consume only the source artifact produced by the CodeCommit source action, which is named RepositorySource.

The company must validate the exact commit identified in each branch-update event, even if the branch advances before the source action starts. The repository, parallel execution mode, and artifact-based build process must remain unchanged.

Which change should a solutions architect make?

**Correct answer:** Modify the Lambda function to include a sourceRevisions entry in StartPipelineExecution with actionName set to RepositorySource, revisionType set to COMMIT_ID, and revisionValue set to the commit ID from the event.

**Explanation:** A source revision override explicitly binds the source action to the event's commit ID. This is necessary because a CodeCommit source action in PARALLEL mode otherwise clones HEAD when the source action starts, which can be newer than the commit that triggered the execution.

### Question 4 (CLF-C02)

**Question:**

A company already has tools that build, test, and deploy its application. Employees currently start each tool manually and check whether the previous step succeeded. The company wants code changes to automatically move through these steps, stop if a step fails, and wait for a manager's approval before production deployment. Which solution meets these requirements without the company developing and maintaining custom workflow orchestration?

**Correct answer:** Use AWS CodePipeline to connect the existing tools in successive stages and add a manual approval action before production deployment.

**Explanation:** CodePipeline manages software release workflows across integrated tools. It can start a release when source code changes, prevent progression after a failed action, and pause for manual approval before production deployment.

### Question 5 (DEA-C01)

**Question:**

A data engineering team releases an AWS Glue Python shell job from a Git repository. An automated release workflow packages the script and its dependencies, tests the package in a staging environment, and waits for production approval. Developers continue merging changes while approval is pending. Currently, the production deployment downloads the latest code from the main branch and packages it again, which sometimes deploys changes that were not tested.

The team wants AWS-managed orchestration that ensures each approved release deploys the exact package tested by that release, even when additional commits arrive before approval. Which solution best meets these requirements?

**Correct answer:** Use AWS CodePipeline with AWS CodeBuild to produce a packaged output artifact. Test that artifact in staging, add a manual approval action, and have the production deployment consume the same execution's packaged artifact without rebuilding it. Publish the package to a release-specific S3 location and configure the production job to use that location.

**Explanation:** CodePipeline carries artifacts between actions within a pipeline execution. Promoting the same packaged artifact after testing and approval preserves the tested script and dependency versions. A release-specific S3 location prevents later releases from overwriting the package referenced by the production job.

### Question 6 (AIP-C01)

**Question:**

A medical software company releases domain-specific fine-tuned foundation models to Amazon SageMaker AI endpoints. An existing release pipeline updates a staging endpoint, evaluates the candidate, and then promotes it to production. Only one release runs at a time.

The staging deployment action currently reports success when UpdateEndpoint returns. However, loading a candidate can take 25–40 minutes. Evaluations have sometimes run against the previous model while the update was still in progress. SageMaker deployment guardrails can also roll back a failed update, leaving the staging endpoint healthy but serving the previous model.

The company requires automated evaluations to run only after the requested candidate is active. Production promotion must stop if staging deployment fails, rolls back, or exceeds a defined deadline. The solution must not rely on fixed waiting periods.

Which pipeline design meets these requirements?

**Correct answer:** Use an AWS CodePipeline action to invoke a Standard AWS Step Functions workflow. Have the workflow call UpdateEndpoint and poll DescribeEndpoint until the endpoint is InService with the requested endpoint configuration. Fail the workflow on deployment failure, rollback to the previous configuration, or timeout. Run candidate evaluations only after that verification succeeds, and allow production promotion only after evaluation succeeds.

**Explanation:** The CodePipeline Step Functions action waits for the Standard workflow to finish. The workflow can monitor a deployment that takes longer than a Lambda invocation, enforce a deadline, and verify both endpoint readiness and the identity of the deployed configuration. Checking the configuration prevents a healthy endpoint that rolled back to the previous release from passing the gate.

### Question 7 (DVA-C02)

**Question:**

A company deploys a compiled application to Amazon EC2 instances by using an existing AWS CodeDeploy application and deployment group. Developers store the source code and deployment scripts in a Git repository. The repository does not contain compiled binaries.

An existing AWS CodeBuild project compiles the application, runs unit tests, and produces a deployment artifact containing the binaries, scripts, and a valid AppSpec file. The build fails if any test fails. Repository access and change detection are already configured, but automatic releases have not been implemented.

The company wants every push to the main branch to automatically build, test, and deploy the application. A failed build or test must prevent deployment, and each deployment must use the artifact produced for that pipeline execution. Which solution should the developer implement?

**Correct answer:** Create a CodePipeline pipeline with a main-branch source stage, followed by a CodeBuild stage and then a CodeDeploy stage. Configure the deployment action to consume the CodeBuild output artifact.

**Explanation:** CodePipeline starts an execution for the repository change and runs the stages in sequence. If compilation or testing fails, the build action fails and the deployment stage does not run. Passing that execution's build output to CodeDeploy ensures that the tested, compiled revision is deployed.

### Question 8 (SCS-C03)

**Question:**

A company uses AWS CodePipeline and AWS CodeBuild to deliver an application. The application's repository contains a buildspec that runs a security scanner and evaluates its findings. During a security exercise, a developer changes the buildspec to skip scanning and return success. The pipeline then deploys the application.

Developers must retain permission to change application build commands, but they must not be able to change or bypass the security assessment. Only the security team can modify pipeline configuration and security-tool configuration. Every release must be blocked if the assessment fails or cannot complete.

Which solution best meets these requirements?

**Correct answer:** Create a separate CodeBuild assessment project with its buildspec and policy scripts maintained outside the application repository under security-team control. Have it scan the candidate source artifact without executing repository-provided build scripts and fail on unacceptable findings or assessment errors. Make successful completion a required CodePipeline action before deployment.

**Explanation:** This separates developer-controlled build instructions from the trusted security assessment. The assessment evaluates the candidate artifact using security-controlled commands and fails closed. Requiring the assessment action to succeed before deployment makes its result an enforceable release gate.

### Question 9 (DOP-C02)

**Question:**

A company runs an AWS CodePipeline pipeline in a tooling account. The pipeline validates AWS CloudFormation templates and requires release-manager approval before deploying to a production account. Its artifact bucket is in the tooling account and uses SSE-KMS encryption with the AWS managed key aws/s3. Both accounts use the same AWS Region.

The company must add a native CloudFormation deployment action for production. The pipeline service role must not receive permissions to provision production resources. A production action role must perform deployment API calls, and a separate CloudFormation service role in production must provision the stack resources. Production deployments must consume the approved pipeline artifact without copying it to another bucket.

Which configuration meets these requirements?

**Correct answer:** Configure the artifact store to use a customer managed symmetric KMS key and encrypt the deployment artifacts with it. Grant the production action role the required S3 and KMS access through identity, bucket, and key policies. Allow the pipeline service role to assume that action role, and configure it as the deployment action's role. Give the action role permission to pass the production CloudFormation service role, which trusts CloudFormation and has the required resource-provisioning permissions.

**Explanation:** This configuration addresses both authorization paths. The production action role can retrieve and decrypt the approved cross-account artifact, and CodePipeline can assume that role to invoke CloudFormation. The action role passes a separate, production-local service role to CloudFormation, keeping resource-provisioning permissions off the pipeline service role.

## Practice AWS CodePipeline in a full exam

Questions on AWS CodePipeline in each practice exam, with every answer option and an explanation for each:

- [DOP-C02](https://blowstack.com/practice-exams/aws-certified-devops-engineer-professional): 44 questions
- [MLA-C02](https://blowstack.com/practice-exams/aws-certified-machine-learning-engineer-associate): 18 questions
- [SAP-C03](https://blowstack.com/practice-exams/aws-certified-solutions-architect-professional): 14 questions
- [DVA-C02](https://blowstack.com/practice-exams/aws-certified-developer-associate): 12 questions
- [AIP-C01](https://blowstack.com/practice-exams/aws-certified-generative-ai-developer-professional): 11 questions
- [CLF-C02](https://blowstack.com/practice-exams/aws-certified-cloud-practitioner): 3 questions
- [DEA-C01](https://blowstack.com/practice-exams/aws-certified-data-engineer-associate): 3 questions
- [SCS-C03](https://blowstack.com/practice-exams/aws-certified-security-specialty): 3 questions
- [AIF-C01](https://blowstack.com/practice-exams/aws-certified-ai-practitioner): 2 questions

## Learn AWS CodePipeline in lessons

23 short lessons on AWS CodePipeline in 8 certification courses.

- AIF-C01: AWS CodePipeline: repeatable release workflows (Premium), https://app.blowstack.com/lessons/aws-codepipeline-repeatable-release-workflows-aif-c01
- MLA-C02: AWS CodeDeploy vs AWS CodePipeline: deployment execution and release orchestration (Premium), https://app.blowstack.com/lessons/aws-codedeploy-vs-aws-codepipeline-deployment-execution-and-release-orchestration-mla-c02
- SAP-C03: AWS CodeBuild vs. AWS CodePipeline: execution and orchestration (Premium), https://app.blowstack.com/lessons/aws-codebuild-vs-aws-codepipeline-execution-and-orchestration-sap-c03
- CLF-C02: AWS CodeBuild vs AWS CodePipeline: builds and release orchestration (Premium), https://app.blowstack.com/lessons/aws-codebuild-vs-aws-codepipeline-builds-and-release-orchestration-clf-c02
- DEA-C01: AWS CodeDeploy vs AWS CodePipeline: deployment and release orchestration (Premium), https://app.blowstack.com/lessons/aws-codedeploy-vs-aws-codepipeline-deployment-and-release-orchestration-dea-c01
- AIP-C01: AWS CodeBuild vs AWS CodePipeline: execution and orchestration (Premium), https://app.blowstack.com/lessons/aws-codebuild-vs-aws-codepipeline-execution-and-orchestration-aip-c01
