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.

flowchart LR Dev[Developer push] --> GH[GitHub repository] GH -->|workflow| GHA[GitHub Actions job] GHA -->|OIDC token| STS[AWS STS role session] STS --> ECR[(ECR image)] STS --> ECS[ECS service] STS --> SAM[SAM deploy to Lambda] STS --> EKS[EKS kubectl apply] GH -->|connection| CP[CodePipeline] CP --> CB[CodeBuild] CB --> ECR CP --> CD[CodeDeploy or ECS deploy action] CD --> ECS
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/main or repo:<org>/<repo>:environment:production), never the organization alone. Avoid ForAllValues: operators in an Allow statement: they evaluate to true when the claim is missing or misspelled.

  • The default sub format is changing. GitHub documents that repositories created after 2026-07-15 use an immutable subject that embeds the owner and repository IDs (for example repo: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 an environment:production condition 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

  1. Open CodeBuild → Build projects → Create build project (check the Region selector first).

  2. 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.

  3. 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.

  4. Under Buildspec use the repository’s buildspec.yml, add logging to CloudWatch Logs, and create the project.

  5. 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 QUEUED or PARALLEL execution modes, no Git tag, branch or file-path trigger filters, no stage conditions, no stage rollback, no Commands action.

V2

Everything in V1 plus pipeline-level variables, triggers with filtering on Git tags, pull requests, branches and file paths, QUEUED and PARALLEL execution modes, source revision overrides, stage conditions, automatic stage retry, stage rollback and the Commands action. Choose V2 for new pipelines.

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

  1. Open CodePipeline → Create pipeline and choose Build custom pipeline; select pipeline type V2 and a new service role.

  2. 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.

  3. Build: choose Other build providers → AWS CodeBuild and select bookshelf-catalog-api.

  4. Deploy: choose Amazon ECS, the cluster bookshelf and service catalog-api, and the image definitions file imagedefinitions.json.

  5. 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.json and sam 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 sub claim

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

Credentials could not be loaded in a workflow

The job lacks permissions: id-token: write, or it runs from a fork pull request, which does not receive an OIDC token.

Add the permission at workflow or job level; deploy only from branches you control.

Not authorized to perform sts:AssumeRoleWithWebIdentity

The trust policy aud or sub condition does not match the token (branch, environment, or the name-only versus immutable sub format).

Print the sub claim your repository actually emits and compare it with the condition; check the provider exists in this account.

CodeBuild fails at DOWNLOAD_SOURCE

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.

Cannot connect to the Docker daemon in CodeBuild

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.

kubectl returns Unauthorized after update-kubeconfig

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 codeartifact:ReadFromRepository.

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.