Developer Tools and DevOps
|
This content was generated with the assistance of AI and should be verified against the official documentation before being relied on in production. See the section bibliography for the reference material consulted while preparing these pages. |
Commands and service statuses on this page were checked against the live AWS documentation on 2026-10-01: AWS CLI v2
(2.37 line), aws-actions/configure-aws-credentials v6 (6.3 was the latest release), CDK CLI 2.1143, SAM CLI 1.166.
The developer-tools services change status often (three of them were closed to new customers and one came back in
the last two years), so confirm availability in the linked documentation before designing around any of them.
This page covers the tooling around AWS rather than one runtime service: how the Bookshelf services
(catalog-api, orders-api, notifier) get from a Git push to running in ECS, Lambda or EKS; the AWS-native
CI/CD services (CodeBuild, CodePipeline, CodeDeploy, CodeArtifact, CodeCommit); the browser shell and IDE toolkits
developers use to work with the account; which SDK major versions are still supported; and the services that are no
longer open to new customers. The Docker pipeline mechanics (build cache, tags, multi-platform images) are in
Docker CI/CD with GitHub Actions and the AWS side of the OIDC trust is in
Identity and Access; this page links to both instead of repeating them. The Azure
counterpart is Developer Tools and DevOps.
Choosing a CI/CD approach
There are two broad options, and they mix well: keep the pipeline in the system that already hosts the code (GitHub Actions, GitLab CI/CD, Jenkins) and let it call AWS with short-lived credentials, or use the AWS-native services that run entirely inside the account.
| Approach | Good fit | Trade-offs |
|---|---|---|
GitHub Actions + OIDC |
Code already on GitHub; the team knows the workflow syntax; one pipeline definition lives next to the code. |
The runner is outside AWS (or you host runners yourself); the AWS role trust policy must be scoped carefully. |
CodeBuild alone |
Builds that need VPC access, large instances, or credentials that must never leave the account; also usable as the runner for GitHub Actions jobs. |
You write the orchestration yourself (or add CodePipeline). |
CodePipeline + CodeBuild + deploy action |
Pipelines that must stay inside the AWS account, approval gates, cross-account promotion with IAM-only access. |
Another service to model and pay for; the pipeline definition is JSON, CloudFormation or CDK rather than the repository’s own workflow files. |
CDK Pipelines or SAM pipelines |
Infrastructure-as-code projects that want the pipeline generated from the same code (see below). |
Opinionated; the pipeline is a deployed stack that updates itself. |
GitHub Actions with OIDC
A pipeline should never hold an access key. GitHub issues each workflow job a signed OIDC token, and the official
aws-actions/configure-aws-credentials action exchanges it with AWS STS for a short-lived session of an IAM role.
The identity provider, the role and its trust policy are created once; see
Identity and Access for the console and CLI steps and the trust policy JSON. The workflow then
needs only the id-token: write permission and the role ARN, which is an identifier and not a secret.
Three details matter in practice:
-
Scope the trust policy on
sub. The role should match one repository and one branch, tag or GitHub environment (repo:<org>/<repo>:ref:refs/heads/mainorrepo:<org>/<repo>:environment:production), never the organization alone. AvoidForAllValues:operators in anAllowstatement: they evaluate to true when the claim is missing or misspelled. -
The default
subformat is changing. GitHub documents that repositories created after 2026-07-15 use an immutable subject that embeds the owner and repository IDs (for examplerepo:octo-org@123456/octo-repo@456789:ref:refs/heads/main), while older repositories keep the name-only format unless an administrator opts in; transfers and renames after that date move a repository to the immutable format. A trust policy written for one format silently stops matching when the repository moves to the other, so check which format your repository emits before copying a condition from an older guide. -
Use one role per purpose. A role that can push images is not the role that should be able to run
cloudformation:*. Give the build job, the deploy job and the infrastructure job different roles and different trust conditions (for example anenvironment:productioncondition with required reviewers on the GitHub side).
Deploying catalog-api to ECS
The image build and push is shown in Container Registry; this job deploys the pushed image by registering a new task definition revision and updating the service (the service behaviour is in ECS and Fargate and ECS Deployments, Scaling and Networking).
name: deploy-catalog-api
on:
workflow_run:
workflows: [catalog-api-image]
types: [completed]
branches: [main]
permissions:
id-token: write
contents: read
env:
AWS_REGION: us-east-1
CLUSTER: bookshelf
SERVICE: catalog-api
jobs:
deploy:
if: ${{ github.event.workflow_run.conclusion == 'success' }}
runs-on: ubuntu-latest
environment: production
steps:
- uses: actions/checkout@v5
- uses: aws-actions/configure-aws-credentials@v6
with:
role-to-assume: arn:aws:iam::111122223333:role/bookshelf-github-actions-deploy
aws-region: ${{ env.AWS_REGION }}
- id: render
uses: aws-actions/amazon-ecs-render-task-definition@v1
with:
task-definition: deploy/catalog-api-task-definition.json
container-name: catalog-api
image: 111122223333.dkr.ecr.us-east-1.amazonaws.com/bookshelf/catalog-api:${{ github.event.workflow_run.head_sha }}
- uses: aws-actions/amazon-ecs-deploy-task-definition@v2
with:
task-definition: ${{ steps.render.outputs.task-definition }}
cluster: ${{ env.CLUSTER }}
service: ${{ env.SERVICE }}
wait-for-service-stability: true
Derived from the configure-aws-credentials,
amazon-ecs-render-task-definition and
amazon-ecs-deploy-task-definition action
documentation. The same step can be done with the CLI (aws ecs register-task-definition followed by
aws ecs update-service, see update-service),
which is easier to run locally. Pin actions to a version your repository standard allows; the major-version tags
shown are convenient but mutable.
Deploying notifier with SAM
jobs:
deploy-notifier:
runs-on: ubuntu-latest
permissions:
id-token: write
contents: read
steps:
- uses: actions/checkout@v5
- uses: actions/setup-java@v5
with:
distribution: corretto
java-version: "25"
- uses: aws-actions/setup-sam@v2
- uses: aws-actions/configure-aws-credentials@v6
with:
role-to-assume: arn:aws:iam::111122223333:role/bookshelf-github-actions-sam
aws-region: us-east-1
- run: sam build --use-container
working-directory: notifier
- run: sam deploy --stack-name bookshelf-notifier --no-confirm-changeset --no-fail-on-empty-changeset --resolve-s3 --capabilities CAPABILITY_IAM
working-directory: notifier
Derived from the sam deploy
reference and the setup-sam action. The template and the function are in
Infrastructure as Code and Lambda: Event-Driven and Serverless Apps.
--resolve-s3 lets SAM manage its artifact bucket; CAPABILITY_IAM acknowledges that the stack creates the
function’s execution role, so review the change set in a protected environment before approving it for production.
Deploying to EKS
- uses: aws-actions/configure-aws-credentials@v6
with:
role-to-assume: arn:aws:iam::111122223333:role/bookshelf-github-actions-eks
aws-region: us-east-1
- run: aws eks update-kubeconfig --name bookshelf-eks
- run: kubectl apply -f deploy/k8s/
- run: kubectl rollout status deployment/catalog-api --timeout=300s
Derived from update-kubeconfig. The IAM
role also needs an EKS access entry with a Kubernetes permission policy (see EKS Clusters);
IAM permission alone does not authorize kubectl. The manifests and Helm options are in
Deploying Microservices on EKS.
Infrastructure changes
npx cdk deploy --require-approval never (or aws cloudformation deploy) in a workflow follows the same pattern with
a separate, more privileged role that only the main branch (or a production environment) can assume. Run
cdk diff or a CloudFormation change set in the pull-request job with a read-only role and post the result as a
comment, so a reviewer sees the change before it is applied; see Infrastructure as Code.
AWS CodeBuild
CodeBuild is a managed build service: each build runs in a fresh container (or a Lambda-based environment, a
reserved-capacity fleet instance, or a macOS instance) that executes the commands in a buildspec.yml. There is no
build server to patch, and you pay per build minute for the compute type used.
The buildspec
version: 0.2
env:
variables:
AWS_REGION: us-east-1
phases:
install:
runtime-versions:
java: corretto21
pre_build:
commands:
- aws ecr get-login-password --region $AWS_REGION | docker login --username AWS --password-stdin $ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com
build:
commands:
- mvn -B verify
- docker build -t $ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/bookshelf/catalog-api:$CODEBUILD_RESOLVED_SOURCE_VERSION .
post_build:
commands:
- docker push $ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/bookshelf/catalog-api:$CODEBUILD_RESOLVED_SOURCE_VERSION
- printf '[{"name":"catalog-api","imageUri":"%s"}]' "$ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/bookshelf/catalog-api:$CODEBUILD_RESOLVED_SOURCE_VERSION" > imagedefinitions.json
reports:
unit-tests:
files: ["**/surefire-reports/*.xml"]
file-format: JUNITXML
cache:
paths:
- /root/.m2/**/*
artifacts:
files:
- imagedefinitions.json
Derived from the Build specification
reference. Set ACCOUNT_ID as a plain environment variable on the project and use parameter-store or
secrets-manager entries under env for anything sensitive, never literal values. Building Docker images needs
privileged mode on the project. Choose a runtime-versions value the selected build image offers.
In the AWS Management Console
-
Open CodeBuild → Build projects → Create build project (check the Region selector first).
-
Name it
bookshelf-catalog-api, choose the source provider (GitHub, via a CodeConnections connection, an Amazon S3 bucket or another Git host) and the branch. -
Under Environment choose Managed image, an Amazon Linux image, the compute type (a Lambda compute type is the cheap option for short builds) and a new service role; enable Privileged for Docker builds.
-
Under Buildspec use the repository’s
buildspec.yml, add logging to CloudWatch Logs, and create the project. -
Choose Start build, then follow the phase details and the test report.
With the AWS CLI
aws codebuild create-project \
--name bookshelf-catalog-api \
--source type=GITHUB,location=https://github.com/<org>/bookshelf-catalog-api.git \
--artifacts type=NO_ARTIFACTS \
--environment type=LINUX_CONTAINER,image=aws/codebuild/amazonlinux-x86_64-standard:5.0,computeType=BUILD_GENERAL1_SMALL,privilegedMode=true,environmentVariables="[{name=ACCOUNT_ID,value=$ACCOUNT_ID}]" \
--service-role "arn:aws:iam::${ACCOUNT_ID}:role/bookshelf-codebuild"
BUILD_ID=$(aws codebuild start-build --project-name bookshelf-catalog-api \
--query build.id --output text)
aws codebuild batch-get-builds --ids "$BUILD_ID" --query 'builds[0].buildStatus' --output text
Derived from create-project and start-build. The service role needs CloudWatch Logs write access, ECR push permission on the three Bookshelf repositories and read access to any secret the buildspec resolves; start from the guidance in the CodeBuild identity and access management page and scope it down.
CodeBuild as a GitHub Actions runner
A CodeBuild project of type Runner project can run GitHub Actions jobs: CodeBuild receives the
WORKFLOW_JOB_QUEUED webhook, starts an ephemeral build that registers a runner for that single job, and ends it
when the job finishes. A workflow opts in with a runs-on label such as
codebuild-<project-name>-<run id>-<run attempt> (built from the GitHub run ID and run attempt expressions), and the label can override the image,
instance size or fleet. This keeps the workflow files in GitHub while the job runs inside your account (useful for
private-network access or larger instances). Because the job runs on AWS compute, the runner can use the CodeBuild
service role directly instead of the OIDC exchange. See
Tutorial: Configure a CodeBuild-hosted
GitHub Actions runner.
AWS CodePipeline
CodePipeline models a release process as stages (source, build, test, approval, deploy) made of actions. Two pipeline types exist, and the choice affects both features and price:
| Type | Characteristics |
|---|---|
V1 |
The original structure: stages and actions only. No pipeline-level variables, no |
V2 |
Everything in V1 plus pipeline-level variables, triggers with filtering on Git tags, pull requests, branches and file
paths, |
Source: What type of pipeline is
right for me?. A typical Bookshelf pipeline is source (a GitHub repository through a CodeConnections connection) →
build (CodeBuild, producing imagedefinitions.json) → approval (manual) → deploy (the Amazon ECS standard
action, which updates the service with the new image).
In the AWS Management Console
-
Open CodePipeline → Create pipeline and choose Build custom pipeline; select pipeline type V2 and a new service role.
-
Source: choose GitHub (via GitHub App), create or select a connection (the console walks through installing the GitHub app, and the connection stays Pending until you finish that step), then the repository and branch.
-
Build: choose Other build providers → AWS CodeBuild and select
bookshelf-catalog-api. -
Deploy: choose Amazon ECS, the cluster
bookshelfand servicecatalog-api, and the image definitions fileimagedefinitions.json. -
Review and Create pipeline; the first execution starts immediately.
With the AWS CLI
aws codeconnections create-connection --provider-type GitHub --connection-name bookshelf-github
# finish the handshake in the console, then:
aws codepipeline create-pipeline --cli-input-json file://catalog-api-pipeline.json
aws codepipeline start-pipeline-execution --name catalog-api
aws codepipeline get-pipeline-state --name catalog-api \
--query 'stageStates[].{stage:stageName,status:latestExecution.status}'
Derived from create-connection
and create-pipeline. The JSON
document names the pipeline, its service role and artifact store (an S3 bucket in the same Region), and the stage
list; the action structures are documented in the
pipeline structure
reference and, for the ECS deploy action, the Amazon ECS deploy action reference.
Pipelines are better managed as code (CloudFormation AWS::CodePipeline::Pipeline or CDK Pipelines) than as
hand-edited JSON.
AWS CodeDeploy
CodeDeploy automates deployments to three compute platforms: EC2/on-premises servers (in-place or blue/green, with an agent on each instance), Lambda (traffic shifting between function versions with canary, linear or all-at-once configurations) and Amazon ECS (blue/green with a replacement task set). The unit of deployment is an application revision described by an AppSpec file. An EC2 deployment of a Spring Boot jar looks like this:
version: 0.0
os: linux
files:
- source: catalog-api.jar
destination: /opt/bookshelf
hooks:
ApplicationStop:
- location: scripts/stop.sh
timeout: 60
AfterInstall:
- location: scripts/install-service.sh
timeout: 60
ApplicationStart:
- location: scripts/start.sh
timeout: 60
ValidateService:
- location: scripts/health-check.sh
timeout: 120
Derived from the AppSpec file reference. The instances need an instance profile with read access to the revision bucket and the CodeDeploy agent installed and running (see Amazon EC2 and Auto Scaling for launch templates and Auto Scaling groups that install it).
aws deploy create-application --application-name bookshelf-catalog-api --compute-platform Server
aws deploy create-deployment-group --application-name bookshelf-catalog-api \
--deployment-group-name production \
--service-role-arn "arn:aws:iam::${ACCOUNT_ID}:role/bookshelf-codedeploy" \
--auto-scaling-groups bookshelf-catalog-asg \
--deployment-config-name CodeDeployDefault.OneAtATime
aws deploy create-deployment --application-name bookshelf-catalog-api \
--deployment-group-name production \
--s3-location bucket="$REVISION_BUCKET",key=catalog-api.zip,bundleType=zip
Derived from create-deployment-group and create-deployment. In the console, use CodeDeploy → Applications → Create application, then Create deployment group.
CodeDeploy is no longer the only way to do blue/green on ECS. ECS has native blue/green deployments (since 2025-07)
and linear and canary strategies (since 2025-10), and CloudFormation can also drive an ECS blue/green deployment.
Older guides that wire two target groups and a test listener through CodeDeploy describe a pattern that now has
simpler alternatives; see ECS Deployments, Scaling and Networking. CodeDeploy remains the
right tool for EC2 fleets and for Lambda traffic shifting outside SAM (SAM’s DeploymentPreference uses it under
the hood).
AWS CodeArtifact
CodeArtifact is a managed package repository for Maven, Gradle, npm, pip, NuGet and other formats. Repositories live in a domain, can chain upstream repositories, and can have an external connection to a public registry such as Maven Central or npmjs, which gives builds a cached, access-controlled path to open-source dependencies. Packages in CodeArtifact cannot be made public, and every client authenticates with a short-lived authorization token created from AWS credentials.
aws codeartifact create-domain --domain bookshelf
aws codeartifact create-repository --domain bookshelf --repository internal
aws codeartifact create-repository --domain bookshelf --repository maven-central-store
aws codeartifact associate-external-connection --domain bookshelf \
--repository maven-central-store --external-connection public:maven-central
aws codeartifact update-repository --domain bookshelf --repository internal \
--upstreams repositoryName=maven-central-store
export CODEARTIFACT_AUTH_TOKEN=$(aws codeartifact get-authorization-token \
--domain bookshelf --query authorizationToken --output text)
aws codeartifact get-repository-endpoint --domain bookshelf --repository internal --format maven
Derived from the CodeArtifact CLI reference.
The Maven settings.xml then references ${env.CODEARTIFACT_AUTH_TOKEN} as the password for the endpoint URL (see
Use CodeArtifact with mvn). In a CodeBuild
buildspec, fetch the token in pre_build; in GitHub Actions, fetch it after configure-aws-credentials.
In the console, open CodeArtifact → Domains → Create domain, then Repositories → Create repository and
add the upstream or external connection in the repository settings.
AWS CodeCommit
CodeCommit hosts private Git repositories in your account, with IAM access control and pull requests. Its status matters because older guides disagree: it stopped accepting new customers in mid-2024, and AWS announced on 2025-11-24 that it is back in full general availability, with new customer sign-ups open, unchanged pricing and a roadmap that includes Git LFS support and additional Regions. Treat an older statement that CodeCommit is closed or being retired as out of date. For a team starting today the practical question is not availability but ecosystem: GitHub, GitLab and Bitbucket integrate with more tools, while CodeCommit keeps source code inside the account and under IAM, which can matter for regulated workloads.
aws codecommit create-repository --repository-name bookshelf-catalog-api
git remote add origin codecommit::us-east-1://bookshelf-catalog-api
Derived from create-repository
and the git-remote-codecommit
setup page (install git-remote-codecommit first so the remote helper can use your CLI credentials). CodeCommit
repositories work as CodePipeline sources and CodeBuild sources like any other. The service’s own documentation lists
workloads that suit Git poorly (frequently changing large files, databases, audit trails, backups) and points to S3,
DynamoDB and AWS Backup instead.
CI for infrastructure code: CDK Pipelines and SAM pipelines
CDK Pipelines (the aws-cdk-lib.pipelines module) builds a CodePipeline-based pipeline from CDK code. It is
self-mutating: when you add a stage or stack to the application, the pipeline first updates itself, then deploys the
new stacks, typically to several accounts. Every target environment must be bootstrapped (cdk bootstrap) with a
trust relationship to the pipeline account. Source can be GitHub through a connection, CodeCommit or S3. See
Continuous integration and delivery (CI/CD) using CDK
Pipelines.
SAM pipelines generate pipeline definitions for serverless applications:
sam pipeline bootstrap # creates the IAM roles, artifact bucket and (optionally) OIDC trust per stage
sam pipeline init # generates the pipeline configuration for your CI/CD system
Derived from the SAM CI/CD documentation. Supported targets include CodePipeline, GitHub Actions, GitLab CI/CD, Bitbucket Pipelines and Jenkins, and the bootstrap step can configure OIDC so no long-lived keys are stored. Both tools produce what this page already showed by hand; use them when you manage several accounts or stages and want the pipeline kept consistent.
CloudShell and the closed cloud IDEs
AWS CloudShell is a browser-based shell launched from the console (the terminal icon in the navigation bar). It is
already authenticated with your console credentials, so there is nothing to configure before running aws commands,
and it offers Bash, PowerShell and Zsh. The environment is based on Amazon Linux 2023 with the AWS CLI v2, Git,
Python, Node.js, tmux, vim and other tools pre-installed. Each Region gives you 1 GB of persistent storage in
$HOME at no additional charge; the rest of the environment is recycled when the session ends. CloudShell has no
extra charge, you pay only for the resources you create from it. VPC environments place the shell in a subnet of
your VPC with chosen security groups (to reach private databases, for example), but they have no persistent storage
and time out after 20 to 30 minutes of inactivity. Use CloudShell for one-off commands and walkthroughs from this
section when you do not want to install the CLI locally; use a local shell with SSO profiles for daily work (see
Getting Started with AWS).
aws sts get-caller-identity
aws s3 ls
AWS Cloud9 was a browser IDE backed by an EC2 instance. It is no longer available to new customers (closed since 2024-07); existing customers can continue to use it, and AWS publishes a blog post on migrating to the IDE toolkits or CloudShell. Older guides that start a tutorial by launching a Cloud9 environment should be followed from a local IDE with the AWS Toolkit, or from CloudShell, instead.
Amazon CodeCatalyst (an integrated project, repository, workflow and dev-environment service) is also no longer open to new customers (closed 2025-11-07); existing customers can continue, and the documentation has a migration guide. See What is AWS Cloud9? and What is Amazon CodeCatalyst?.
IDEs, SDKs and local development
AWS Toolkits
The AWS Toolkit for Visual Studio Code and the AWS Toolkit for JetBrains (IntelliJ IDEA for the Bookshelf Spring Boot modules, plus PyCharm, WebStorm, Rider, GoLand and others) are open-source plugins that put the account in the IDE: an explorer for resources, credential and Region switching (the same SSO profiles the CLI uses), creating, running, debugging, deploying and deleting SAM applications, invoking and debugging Lambda functions locally or remotely, viewing CloudFormation stack events, and debugging ECS tasks. The VS Code toolkit also hosts the Infrastructure Composer experience described below. Older Amazon Q Developer integrations inside these plugins are being replaced by newer AI tooling; check the plugin’s release notes rather than a dated guide, and see AI, Data and Analytics Services Overview. See AWS Toolkit for JetBrains.
SDKs and support dates
Application code uses the SDK for the language, with the default credential provider chain so the same code works on
a laptop (SSO profile), in ECS (task role), in Lambda (execution role) and on EKS (Pod Identity); credentials are
never written into code or configuration (see Identity and Access). Prefer the current major
versions: the AWS SDK for Java 2.x and the modular AWS SDK for JavaScript v3. The older majors are out of
support: AWS announced end of support for the AWS SDK for Java 1.x on 2025-12-31 and for the AWS SDK for JavaScript v2
on 2025-09-08, and AWS CLI v1 enters maintenance on 2026-07-15 with end of support on 2027-07-15. Older tutorials
that use AmazonS3ClientBuilder, require("aws-sdk") or aws configure with pip install awscli need migrating. The authoritative
dates are in the AWS SDKs and Tools Maintenance
Policy and the version support matrix;
the Java migration guide is Migrate
from version 1.x to 2.x of the AWS SDK for Java.
Local testing
-
SAM local runs Lambda functions and a local API in Docker:
sam local invoke Notifier --event events/order.jsonandsam local start-api(see Infrastructure as Code). -
DynamoDB Local is an AWS-provided downloadable version of DynamoDB for development; see Amazon DynamoDB and the DynamoDB local documentation.
-
LocalStack is a third-party emulator of many AWS services; it is useful for integration tests (typically through Testcontainers, see Testcontainers Fundamentals) but it is not AWS software, its coverage and behaviour differ from the real services, and its licensing and feature tiers change, so keep a smoke test against a real account in the pipeline.
-
Containers, queues and databases that have an official image (PostgreSQL, Valkey, OpenSearch) can run in Docker Compose instead; see Compose for Local Development.
Infrastructure Composer and Console-to-Code
AWS Infrastructure Composer is a visual designer for CloudFormation and SAM templates. AWS announced that the standalone Infrastructure Composer console ends on 2026-12-07; the visual editor is being embedded into the console pages where it was available, and the full experience remains in the AWS Toolkit for Visual Studio Code. The CloudFormation console mode is the recommended replacement for the retired CloudFormation Designer. See What is AWS Infrastructure Composer?. The console also offers Console-to-Code, which records console actions and generates equivalent CLI, CloudFormation or CDK code as a starting point; treat generated output as a draft to review, not a finished template.
AWS Amplify, briefly
AWS Amplify Hosting is a Git-based hosting service for web applications: connect a repository (GitHub, Bitbucket, GitLab or CodeCommit), and each push builds and deploys to the AWS content delivery network with feature-branch environments, pull-request previews, custom domains, redirects and rewrites, and password-protected branches. It supports server-rendered frameworks (such as Next.js and Nuxt), single-page applications (React, Angular, Vue) and static site generators. Amplify Gen 2 adds a TypeScript, code-first way to define a backend (data, authentication, storage, functions) that deploys as CloudFormation through CDK. It is a good fit when a small team wants one opinionated workflow for a JavaScript front end; for the Bookshelf static front end with full control over the bucket, certificate and cache behaviour, the S3 plus CloudFront pattern in S3 Security and Static Hosting and CloudFront and CDN Delivery is the more explicit alternative, and the build and deployment steps for common front-end frameworks are in Build and Deployment and Deployment & Self-Hosting. See AWS Amplify Hosting User Guide.
Pricing model
No prices are repeated here because they change; use the dated pricing pages linked in the references.
-
CodeBuild charges per build minute, with a rate that depends on the compute type and platform (small to large general instances, Arm, Lambda-based, GPU and macOS options); reserved-capacity fleets are billed for the reserved instances. Cutting build time (dependency caching, a smaller compute type that still finishes quickly, Lambda compute for short jobs) is the main lever.
-
CodePipeline V1 pipelines are billed per active pipeline; V2 pipelines are billed per action execution minute, with certain actions (manual approval and custom actions) not billed per minute. AWS publishes a script to estimate the difference for an existing V1 pipeline before you convert it.
-
CodeDeploy has no charge for deployments to EC2, on-premises servers, Lambda or ECS in the standard pricing model; check the pricing page for any on-premises instance charges.
-
CodeArtifact charges for storage, requests and data transfer out of the Region.
-
CodeCommit pricing is unchanged from before the 2025 return to general availability; check the page for the free tier of active users.
-
CloudShell has no charge; resources created from it are billed normally.
-
Amplify Hosting bills for build minutes, hosted storage and data served, plus SSR requests and compute for server-rendered apps.
-
GitHub Actions minutes are billed by GitHub (or by CodeBuild when it hosts the runner).
Limits and quotas
Defaults checked on 2026-10-01; most are adjustable through Service Quotas.
| Item | Default or limit |
|---|---|
CodeBuild build projects per Region |
5,000 |
CodeBuild build timeout |
5 to 2,160 minutes (36 hours) |
CodeBuild concurrent builds |
Per compute type and platform, often low for a new account (the page lists 1 for many types and 0 for some GPU and largest types); request an increase before a busy release day |
CodeBuild VPC configuration |
Up to 16 subnets and 5 security groups per project |
CodeBuild build history retention |
1 year |
CloudShell persistent storage |
1 GB per Region (none for VPC environments) |
CloudShell idle timeout |
About 20 to 30 minutes (10 minutes in GovCloud); VPC environments are deleted on timeout |
The other services' quotas (CodePipeline pipelines and actions, CodeDeploy deployment groups, CodeArtifact
repositories and package sizes) are on their own quota pages, linked below. AssumeRoleWithWebIdentity sessions
obtained by configure-aws-credentials have a configurable duration limited by the role’s maximum session duration
(one hour by default), so very long jobs need a longer maximum or a credential refresh step.
Recent changes and retired guidance
| Item | Status and current approach |
|---|---|
CodeCommit |
Closed to new customers in 2024, returned to general availability on 2025-11-24. Older guides saying it is closed are out of date; GitHub, GitLab and Bitbucket remain common alternatives. |
AWS Cloud9 |
Closed to new customers since 2024-07. Use a local IDE with the AWS Toolkit, or CloudShell. |
Amazon CodeCatalyst |
Closed to new customers on 2025-11-07. Existing customers can continue; a migration guide is published. |
AWS Infrastructure Composer console |
The standalone console ends on 2026-12-07; the editor is embedded in console pages and remains in the VS Code toolkit. |
CodePipeline V1 pipelines |
Still supported, but new features (triggers, variables, stage conditions, rollback) are V2-only. |
ECS blue/green with CodeDeploy |
Legacy approach for ECS: native blue/green (2025-07) and linear/canary (2025-10) are built into ECS. |
GitHub OIDC |
Repositories created after 2026-07-15 use an immutable subject containing owner and repository IDs; check your trust policy. |
AWS SDK for Java 1.x, JavaScript SDK v2 |
End of support on 2025-12-31 and 2025-09-08 respectively. Use Java 2.x and JavaScript v3. |
AWS CLI v1 |
Maintenance from 2026-07-15, end of support on 2027-07-15. Use v2. |
AWS Copilot CLI |
End of support on 2026-06-12; see Infrastructure as Code. |
Long-lived access keys in CI |
Replace with an OIDC role as shown above, or run the job on CodeBuild. |
Troubleshooting
| Symptom | Likely cause | Check |
|---|---|---|
|
The job lacks |
Add the permission at workflow or job level; deploy only from branches you control. |
|
The trust policy |
Print the |
CodeBuild fails at |
The GitHub connection or access token is missing or pending, or the service role cannot use it. |
Re-authorize the connection; check the project’s source settings. |
|
Privileged mode is off. |
Enable privileged mode on the project environment. |
CodePipeline stuck in the source stage with a pending connection |
The CodeConnections handshake was not completed in the console. |
Complete the GitHub app installation; the connection status must be Available. |
CodeDeploy deployment fails at a lifecycle hook |
A script exited non-zero, or the agent is not running on the instance. |
Read the deployment’s event details and the agent log on the instance. |
|
The role has no EKS access entry or Kubernetes permission policy. |
Create the access entry (see EKS Clusters). |
Maven cannot resolve dependencies from CodeArtifact |
The authorization token expired (it is short-lived) or the role lacks |
Fetch a new token before the build and check the role policy. |
Clean up
Delete in dependency order. IAM roles created for the pipelines are removed after the resources that use them, and the OIDC provider is shared with other pipelines, so delete it only if nothing else uses it (see Identity and Access).
aws codepipeline delete-pipeline --name catalog-api
aws codeconnections delete-connection --connection-arn "$CONNECTION_ARN"
aws codebuild delete-project --name bookshelf-catalog-api
aws deploy delete-deployment-group --application-name bookshelf-catalog-api --deployment-group-name production
aws deploy delete-application --application-name bookshelf-catalog-api
aws codeartifact delete-repository --domain bookshelf --repository internal
aws codeartifact delete-repository --domain bookshelf --repository maven-central-store
aws codeartifact delete-domain --domain bookshelf
aws codecommit delete-repository --repository-name bookshelf-catalog-api
aws s3 rm "s3://$ARTIFACT_BUCKET" --recursive
aws s3api delete-bucket --bucket "$ARTIFACT_BUCKET"
aws iam delete-role --role-name bookshelf-codebuild # after detaching and deleting its policies
Derived from the CLI reference pages for delete-pipeline,
delete-project,
delete-application and
delete-domain. A CodeArtifact
domain can only be deleted after its repositories. A pipeline’s artifact bucket may be versioned; if so, empty all
versions and delete markers first (see S3 Object Storage). delete-repository on CodeCommit
is irreversible, so confirm the code exists elsewhere. CloudShell and the IDE toolkits create nothing to clean up
beyond the resources you deployed through them; stacks deployed with SAM or CDK are removed with sam delete or
cdk destroy.
Related pages
-
Identity and Access creates the OIDC provider and the deploy roles used above.
-
Container Registry covers the ECR side of the image pipeline.
-
Infrastructure as Code covers CloudFormation, CDK and SAM in depth.
-
ECS Deployments, Scaling and Networking covers ECS deployment strategies.
-
Monitoring and Observability covers CloudWatch Logs and alarms for build and deploy failures.
-
Docker CI/CD with GitHub Actions covers the general Docker and GitHub Actions workflow.
-
Developer Tools and DevOps is the Azure counterpart.