Containers

Running GitHub Actions runners with Amazon EKS Auto Mode

If you run GitHub Actions runners at scale on your own infrastructure, capacity management is often the biggest challenge. Continuous integration and continuous delivery (CI/CD) workloads are inherently bursty. A team might trigger 200 parallel jobs during peak hours and zero overnight. A static fleet of runners means paying for idle compute most of the day, while under-provisioning means queued workflows and delayed delivery. Although GitHub’s hosted runners work well for many teams, organizations with specific compliance requirements, private networking policies, or custom tooling needs often turn to self-hosted runners. Managing capacity for these runners has traditionally been complex and costly.

Amazon Elastic Kubernetes Service (Amazon EKS) Auto Mode changes this equation, by handling provisioning, scaling, and lifecycle management of the underlying Amazon Elastic Compute Cloud (Amazon EC2) instances, with support for EC2 Spot Instances and AWS Graviton (ARM64) processors. When you combine GitHub’s Actions Runner Controller (ARC), you get an elastic, self-hosted runner infrastructure that scales to hundreds of runners. This approach minimizes capacity planning, idle compute costs, and manual node operations.

In this post, you learn how to:

  • Deploy an EKS cluster with Auto Mode.
  • Install GitHub ARC and configure authentication.
  • Configure runner scale sets that run on On-Demand/Spot and Graviton instances.
  • Route workflows to the appropriate runner fleet based on job characteristics.

Solution overview

The design uses an event-driven model: GitHub Actions sends a runner request, ARC provisions runner pods, and EKS Auto Mode dynamically provisions the underlying compute.

Architecture

Flow from a GitHub Actions workflow to the ARC listener, controller-created runner pods, and EKS Auto Mode provisioning EC2 instances

Figure 1: Architecture showing the flow from a GitHub Actions workflow sending job requests to the ARC listener, the controller creating runners, and EKS Auto Mode provisioning EC2 instances across different specifications

An overview of the design is as follows:

  1. A workflow job starts. GitHub Actions sends a request to the corresponding runner scale set.
  2. The runner scale set’s listener receives the job and increases the replica count in its EphemeralRunnerSet. The controller then creates the runner pods.
  3. EKS Auto Mode detects an unscheduled runner pod. It launches a right-sized EC2 instance from the NodePool that matches the pod’s scheduling rules, and chooses Spot or On-Demand capacity and amd64 or arm64 (Graviton) architecture.
  4. The runner registers with GitHub, runs the job, and streams logs and status back. When the job finishes, ARC deletes the runner pod.
  5. EKS Auto Mode automatically removes nodes that no longer have runner pods.

The solution uses the following building blocks:

  • Amazon EKS Auto Mode manages the compute lifecycle: provisioning, scaling, consolidation, and upgrades.
  • Actions Runner Controller (ARC) listens for GitHub Actions job requests and manages the runner pod lifecycle.
  • GitHub App authentication provides secure, scoped authentication between ARC and your GitHub organization.
  • EC2 Spot Instances can offer savings of up to 90 percent compared to On-Demand for ephemeral, interruption-tolerant runner workloads.
  • AWS Graviton (ARM64) processors are designed to deliver the best price performance for cloud workloads on Amazon EC2. Graviton-based instances cost up to 20 percent less than comparable x86-based EC2 instances and use up to 60 percent less energy for the same performance.

Prerequisites

Before you begin, make sure that you have the following:

  • Access to an AWS account with the necessary permissions to create EKS clusters and related resources.
  • The following tools: AWS CLI v2, eksctl (v0.195.0+), kubectl (compatible with your cluster version), and Helm (v3.x+).
  • A GitHub account as the GitHub organization owner or app manager.

Sample code

To help with configuration, we have included the artifacts in the aws-samples repository on GitHub. You can clone this repository to follow along.

Estimated cost

Prices in this section are for US East (N. Virginia) at the time of writing. For current rates, see Amazon EKS pricing.

Amazon EKS control plane:

Each cluster costs $0.10 per hour (about $73 per month) while its Kubernetes version is in standard support, and $0.60 per hour once the version enters extended support.

Compute and networking:

EC2 instances run the ARC controller, listeners, and runners. They are billed per second with a one-minute minimum. You also pay for the attached Amazon Elastic Block Store (Amazon EBS) volumes, the NAT gateway, and data transfer. Runner pods scale to zero between jobs. The ARC controller and listeners always run, so at least one node always runs.

The EKS Auto Mode management fee is charged per second for each instance that Auto Mode launches, with a one-minute minimum. The fee depends on the instance type. Spot, Reserved Instance, and Savings Plans discounts don’t reduce it. For rates by instance type, see Amazon EKS pricing.

GitHub Actions:

At the time of writing, GitHub doesn’t charge for minutes used by jobs on self-hosted runners, including the ARC-managed runners in this post. GitHub bills artifact storage and Actions cache storage above your plan’s included amounts separately. For details, see GitHub Actions billing.

Walkthrough

The following steps walk through the complete setup, from cluster creation to workflow validation. Each step builds on the previous one, and the entire walkthrough takes about 30 minutes.

Step 1: Create an Amazon EKS cluster with Auto Mode using eksctl

The following configuration provisions an EKS cluster with Auto Mode:

# EKS/cluster-config.yaml
apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig
metadata:
  name: github-runners
  region: us-east-1
  version: "1.36"
autoModeConfig:
  enabled: true

Create the cluster:

eksctl create cluster -f cluster-config.yaml

This takes approximately 15 minutes. The cluster status should transition to ACTIVE upon completion:

aws eks describe-cluster \
  --name github-runners \
  --region us-east-1 \
  --query 'cluster.status' \
  --output text
ACTIVE

Step 2: Create a GitHub App for authentication

ARC can authenticate to the GitHub API using a GitHub App, a personal access token (classic or fine-grained), or vault secrets. For more information, see Authenticating ARC to the GitHub API. In the following example, we demonstrate using the GitHub App on an organization. For the detailed steps, see Register a GitHub App:

  1. Go to the GitHub App creation page: Your organization > Settings > Developer settings > GitHub Apps > New GitHub App.
  2. Configure the app:
  3. Set Repository permissions:
    • Actions: Read.
    • Administration: Read & Write.
    • Metadata: Read.
  4. Set Organization permissions:
    • Self-hosted runners: Read & Write.
  5. Select Create GitHub App. You are redirected to the settings page.
  6. On the settings page, navigate to Install App and install it in the desired GitHub organization. The redirected URL has the following format. Note the INSTALLATION_ID for the next step.https://github.com/organizations/ORGANIZATION/settings/installations/INSTALLATION_ID

Collect the app credentials

After you have created and installed the GitHub App, you need the following credentials for ARC to authenticate with GitHub:

  • APP_ID: The value in the App ID field on the app’s settings page.
  • INSTALLATION_ID: The number at the end of the installation URL.
  • PATH_TO_DOWNLOADED_PEM_FILE: On the GitHub App settings page, generate and download the .pem key from Private keys, then choose Generate a private key. Provide the absolute or relative path of the .pem key.

With these credentials ready:

  1. Create a namespace for ARC.
    kubectl create namespace arc-runners
    namespace/arc-runners created
  2. In the new namespace, create a Kubernetes Secret to hold the credentials.
    kubectl create secret generic pre-defined-secret \
      --namespace arc-runners \
      --from-literal=github_app_id=<APP_ID> \
      --from-literal=github_app_installation_id=<INSTALLATION_ID> \
      --from-file=github_app_private_key=<PATH_TO_DOWNLOADED_PEM_FILE>
    secret/pre-defined-secret created

Step 3: Install Actions Runner Controller (ARC)

The ARC controller manages the lifecycle of runner scale sets and runner pods. The following command installs the controller and uses a nodeSelector to schedule it on On-Demand capacity, so that Spot interruptions do not affect it.

helm install arc \
  --namespace arc-systems \
  --create-namespace \
  --version 0.14.2 \
  --set "nodeSelector.karpenter\.sh/capacity-type=on-demand" \
  oci://ghcr.io/actions/actions-runner-controller-charts/gha-runner-scale-set-controller
...
NAME: arc
LAST DEPLOYED: Thu Sep 24 14:00:32 2026
NAMESPACE: arc-systems
STATUS: deployed
REVISION: 1
DESCRIPTION: Install complete
TEST SUITE: None
NOTES:
Thank you for installing gha-runner-scale-set-controller.
Your release is named arc.

Verify the controller is running:

kubectl get pods -n arc-systems
NAME                                     READY   STATUS    RESTARTS   AGE
arc-gha-rs-controller-5dc59d457c-wdbnp   1/1     Running   0          2m

The controller and the listener pods always run, so this On-Demand node is the fixed baseline cost described in the Estimated cost section. In Step 5, you apply the same nodeSelector to the listener pods through listenerTemplate.

Step 4: Create and configure a GitHub repository

ARC monitors your GitHub repositories for workflow job requests. Use the following steps to create one. You can also use an existing repository.

  1. Go to GitHub, choose the plus icon in the top-right corner, then choose New repository.
  2. Configure the repository.
    • Owner: choose the organization that the GitHub App was installed in during Step 2.
    • Repository name: choose a suitable name.
    • Visibility: choose Public (private repositories require a paid GitHub plan, see GitHub pricing).
  3. Proceed with Create repository and note the repository URL for the next step.
  4. (Optional) If you installed the GitHub App in Step 2 on a selected repository only, add this repository to the installation.

For more information, see the GitHub documentation Create a new repository. Additionally, the walkthrough demonstrates using ARC to deploy a single-page app (SPA) on GitHub Pages. Use the following steps to enable GitHub Pages, or see Configuring a publishing source for your GitHub Pages site.

  1. Navigate to the GitHub repository you created, then go to Settings.
  2. In the Code, planning, and automation section of the sidebar, choose Pages.
  3. Under Build and deployment, for Source, select GitHub Actions.

Step 5: Deploy a NodePool and runner scale sets

In this step, you create three runner scale sets, each targeting a different compute profile:

  1. x86 Spot runners: Interruption-tolerant CI workloads such as tests and linting.
  2. ARM64/Graviton Spot runners: Lower-cost jobs for arm64-compatible workloads (in this example, the GitHub Pages deployment).
  3. On-Demand runners: Builds and long-running jobs that must not be interrupted.

All three profiles use a single NodePool that allows both Spot and On-Demand capacity and both amd64 and arm64 architectures. Each runner scale set selects its profile with a nodeSelector on karpenter.sh/capacity-type and kubernetes.io/arch. If a pod doesn’t specify a capacity type, EKS Auto Mode launches Spot capacity.

# NodePool/runner-nodepool.yml
apiVersion: karpenter.sh/v1
kind: NodePool
metadata:
  name: runners
spec:
  template:
    spec:
      nodeClassRef:
        group: eks.amazonaws.com
        kind: NodeClass
        name: default
      requirements:
        - key: "karpenter.sh/capacity-type"
          operator: In
          values: ["spot", "on-demand"]
        - key: "eks.amazonaws.com/instance-category"
          operator: In
          values: ["c", "m", "r"]
        - key: "eks.amazonaws.com/instance-cpu"
          operator: In
          values: ["4", "8", "16"]
        - key: "kubernetes.io/arch"
          operator: In
          values: ["amd64", "arm64"]
  limits:
    cpu: "1000"
    memory: 1000Gi
  disruption:
    consolidationPolicy: WhenEmpty
    consolidateAfter: 60s

For more configuration details, see Karpenter NodePool and Create a Node Pool for EKS Auto Mode.

Deploy the NodePool:

kubectl apply -f runner-nodepool.yml
nodepool.karpenter.sh/runners created

Verify the NodePool. The READY status should be True:

kubectl get nodepool
NAME      NODECLASS   NODES   READY   AGE
runners   default     0       True    29s

Create the runner scale set

A runner scale set is a group of runners that ARC scales for one set of workflows. Each scale set has two parts:

  • Listener: Receives job requests from GitHub and scales the runners.
  • Runner: The pod that runs the job.

You configure each scale set with a Helm values file. The pod template in this file tells EKS Auto Mode which nodes to launch. Key settings include the following:

  • githubConfigUrl: The code repository that the runner registers with. Replace it with the repository you created in Step 4.
  • listenerTemplate.spec.nodeSelector.karpenter.sh/capacity-type = on-demand: Keeps listener pods on On-Demand capacity.
  • template.spec.nodeSelector: Places runner pods on nodes with the matching capacity type and architecture.
  • template.spec.containers[0].resources: Sets the CPU and memory that each runner requests.

For all the options, see the full values.yml.

x86 Spot runners

Create the Helm values file for the x86 Spot runner scale set:

# RunnerScaleSet/scale-set-spot-x86.values.yml
githubConfigUrl: "https://github.com/YOUR-ORG/YOUR-REPOSITORY"
githubConfigSecret: pre-defined-secret
minRunners: 0
maxRunners: 10

listenerTemplate:
  spec:
    nodeSelector:
      karpenter.sh/capacity-type: on-demand
    containers:
      - name: listener
        resources: {}

template:
  spec:
    nodeSelector:
      kubernetes.io/arch: amd64
      karpenter.sh/capacity-type: spot
    containers:
      - name: runner
        image: ghcr.io/actions/actions-runner:latest
        command: ["/home/runner/run.sh"]
        resources:
          requests:
            cpu: "3"
            memory: "8Gi"
          limits:
            cpu: "3"
            memory: "8Gi"

Install the scale set. The release name, arc-runner-x86-spot, is the value that you use for runs-on in your workflows.

helm install arc-runner-x86-spot \
  --namespace arc-runners \
  --version 0.15.0 \
  -f scale-set-spot-x86.values.yml \
  oci://ghcr.io/actions/actions-runner-controller-charts/gha-runner-scale-set
...
NAME: arc-runner-x86-spot
LAST DEPLOYED: Thu Sep 24 15:47:14 2026
NAMESPACE: arc-runners
STATUS: deployed
REVISION: 1
DESCRIPTION: Install complete
TEST SUITE: None
NOTES:
Thank you for installing gha-runner-scale-set.
Your release is named arc-runner-x86-spot.

ARM64/Graviton Spot runners

# RunnerScaleSet/scale-set-spot-arm64.values.yml
githubConfigUrl: "https://github.com/YOUR-ORG/YOUR-REPOSITORY"
githubConfigSecret: pre-defined-secret
minRunners: 0
maxRunners: 30

listenerTemplate:
  spec:
    nodeSelector:
      karpenter.sh/capacity-type: on-demand
    containers:
      - name: listener
        resources: {}

template:
  spec:
    nodeSelector:
      kubernetes.io/arch: arm64
      karpenter.sh/capacity-type: spot
    containers:
      - name: runner
        image: ghcr.io/actions/actions-runner:latest
        command: ["/home/runner/run.sh"]
        resources:
          requests:
            cpu: "3"
            memory: "8Gi"
          limits:
            cpu: "3"
            memory: "8Gi"
helm install arc-runner-arm64-spot \
  --namespace arc-runners \
  --version 0.15.0 \
  -f scale-set-spot-arm64.values.yml \
  oci://ghcr.io/actions/actions-runner-controller-charts/gha-runner-scale-set

On-Demand runners (for critical jobs)

# RunnerScaleSet/scale-set-ondemand-x86.values.yml
githubConfigUrl: "https://github.com/YOUR-ORG/YOUR-REPOSITORY"
githubConfigSecret: pre-defined-secret
minRunners: 0
maxRunners: 30

listenerTemplate:
  spec:
    nodeSelector:
      karpenter.sh/capacity-type: on-demand
    containers:
      - name: listener
        resources: {}

template:
  spec:
    nodeSelector:
      kubernetes.io/arch: amd64
      karpenter.sh/capacity-type: on-demand
    containers:
      - name: runner
        image: ghcr.io/actions/actions-runner:latest
        command: ["/home/runner/run.sh"]
        resources:
          requests:
            cpu: "3"
            memory: "8Gi"
          limits:
            cpu: "3"
            memory: "8Gi"
helm install arc-runner-x86-on-demand \
  --namespace arc-runners \
  -f scale-set-ondemand-x86.values.yml \
  oci://ghcr.io/actions/actions-runner-controller-charts/gha-runner-scale-set

Verify the runner scale sets

After deploying the preceding runner scale sets, there should be a listener for each of them, and the status should be Running. The output should be like the following:

kubectl get pods -n arc-systems
NAME                                         READY   STATUS    RESTARTS   AGE
arc-gha-rs-controller-5dc59d457c-wdbnp       1/1     Running   0          132m
arc-runner-arm64-spot-847d8967-listener      1/1     Running   0          8s
arc-runner-x86-on-demand-847d8967-listener   1/1     Running   0          3s
arc-runner-x86-spot-847d8967-listener        1/1     Running   0          25m

Verify the helm charts installation:

helm list -n arc-runners
NAME                       NAMESPACE     REVISION   UPDATED                                   STATUS     CHART                         APP VERSION
arc-runner-arm64-spot      arc-runners   1          2026-09-24 16:12:32.440308 -0700 PDT      deployed   gha-runner-scale-set-0.14.2   0.14.2
arc-runner-x86-on-demand   arc-runners   1          2026-09-24 16:12:37.281974 -0700 PDT      deployed   gha-runner-scale-set-0.14.2   0.14.2
arc-runner-x86-spot        arc-runners   1          2026-09-24 15:47:14.614698 -0700 PDT      deployed   gha-runner-scale-set-0.14.2   0.14.2

Finally, verify the runners in the GitHub repository. In the repository, navigate to Settings > Actions > Runners > Runner scale sets. The runners should be listed with their status as Online. Individual runners appear only while a job runs.

Runner scale sets listed in the GitHub repository settings after deployment

Figure 2: The runner scale sets appear in the GitHub repository settings after successful deployment

Step 6: Route workflows to the right runner fleet

Use the runs-on label in the GitHub Actions workflows to select the appropriate runner scale set by name, in this case arc-runner-x86-spot, arc-runner-arm64-spot, or arc-runner-x86-on-demand.

The following example workflow uses all three runner scale sets. The workflow file must be stored in the .github/workflows directory, in this example .github/workflows/ci.yml. To facilitate the test, we add workflow_dispatch in the on section so that it can be triggered manually. Note that it must be committed to the default branch.

For the demo React app, see the sample code repository.

# .github/workflows/ci.yml

name: CI/CD Pipeline

on:
  workflow_dispatch:

permissions:
  contents: read
  pages: write
  id-token: write

concurrency:
  group: "pages"
  cancel-in-progress: false

jobs:
  test-and-lint:
    name: Test & Lint
    runs-on: arc-runner-x86-spot
    defaults:
      run:
        working-directory: web
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache-dependency-path: web/package-lock.json

      - name: Install dependencies
        run: npm ci

      - name: Run linter
        run: npm run lint

      - name: Run tests
        run: npm test

  build:
    name: Build
    runs-on: arc-runner-x86-on-demand
    needs: test-and-lint
    defaults:
      run:
        working-directory: web
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
          cache-dependency-path: web/package-lock.json

      - name: Install dependencies
        run: npm ci

      - name: Build
        run: npm run build

      - name: Upload artifact
        uses: actions/upload-pages-artifact@v3
        with:
          path: web/build

  deploy:
    name: Deploy to GitHub Pages
    runs-on: arc-runner-arm64-spot
    needs: build
    environment:
      name: github-pages
      url: ${{ steps.deployment.outputs.page_url }}
    steps:
      - name: Deploy to GitHub Pages
        id: deployment
        uses: actions/deploy-pages@v4

The workflow tests, builds, and deploys a ReactJS single-page app (SPA) to GitHub Pages. The build runs on On-Demand because it is the longest job and produces the artifact that the deployment needs. The test job runs on x86 Spot, and the deployment runs on Graviton Spot, so that the example exercises all three runner scale sets. If Spot reclaims a runner mid-job, that job fails and nothing retries it automatically. In that case, choose Re-run failed jobs in the Actions tab, then confirm that your Pages site shows the expected deployment. See the Follow-up section.

Step 7: Validate the end-to-end flow

  1. Trigger the workflow on GitHub.The triggering methods are defined in the on section in the workflow YAML. In the preceding example, you can trigger it manually by navigating to Actions > CI/CD Pipeline > Run workflow.
  2. Monitor ARC for scheduling the runner.After triggering the workflow, the job starts. The listener starts scheduling runner pods to handle the job. You can monitor the runners by:
    kubectl get pods -n arc-runners -w
    NAME                                     READY   STATUS    RESTARTS   AGE
    arc-runner-x86-spot-hwkkw-runner-ntnpt   1/1     Running   0          13s
  3. Monitor EKS Auto Mode node handling.Because the preceding workflow runs on different node types, we expect EKS Auto Mode to provision multiple nodes to handle each job.
    kubectl get nodes -o custom-columns="\
    NAME:.metadata.name,\
    ARCH:.metadata.labels.kubernetes\.io/arch,\
    CAPACITY:.metadata.labels.karpenter\.sh/capacity-type,\
    INSTANCE:.metadata.labels.node\.kubernetes\.io/instance-type"
    NAME                  ARCH    CAPACITY    INSTANCE
    i-02e36ad7dad5c3949   arm64   on-demand   c6g.large
    i-050c811c899c90b31   amd64   on-demand   c6a.large
    i-080e964095e2f226a   arm64   spot        c7g.2xlarge
    i-0997fee8a72bda0ec   amd64   spot        c8i-flex.2xlarge
  4. Monitor the workflows on GitHub.

    CI/CD pipeline run in GitHub Actions with each job routed to a different runner scale set

    Figure 3: CI/CD pipeline run in GitHub Actions with each job routed to the appropriate runner scale set

  5. After workflow completion, the unused nodes should be drained and removed automatically.


Follow-up: The two sides of using Spot Instances for GitHub Actions runners

Spot Instances offer up to 90 percent savings on On-Demand prices with a 2-minute interruption notification, which makes them best suited for fault-tolerant, flexible workflows. They are particularly suitable for GitHub Actions workflows that have a short job duration and can accept interruption, such as unit tests and linting.

With that said, Spot Instances can still be reclaimed and the jobs they host interrupted. This typically fails with the “The self-hosted runner … lost communication with the server” error. Currently, neither GitHub Actions nor ARC automatically retries in this scenario.

Therefore, keep long, non-idempotent, or release-critical jobs on the On-Demand set, keep retriable test shards on Spot, and add an explicit re-run path. The GitHub Pages deployment in this walkthrough runs on Spot mainly to demonstrate the Graviton fleet. For a production release pipeline, run the deployment on the On-Demand set as well. The goal is to maximize cost efficiency while minimizing interruptions to the workflows.

Clean up

  1. Delete the runner scale sets.
    helm uninstall arc-runner-x86-on-demand -n arc-runners
    helm uninstall arc-runner-arm64-spot -n arc-runners
    helm uninstall arc-runner-x86-spot -n arc-runners
  2. Delete the ARC controller.
    helm uninstall arc -n arc-systems
  3. Delete the EKS cluster. This removes all associated resources, including the Kubernetes secret.
    eksctl delete cluster --name github-runners --region us-east-1
  4. In GitHub, uninstall the GitHub App from the organization and delete the GitHub App you created.

Conclusion

Amazon EKS Auto Mode reduces the operational complexity that previously made self-hosted runners a burden. In this walkthrough, you learned how to deploy an EKS cluster with Auto Mode, configure NodePools, and install GitHub ARC to run a self-hosted runner cluster that is scalable (right-sized compute provisioned on demand), secure (runners stay in your virtual private cloud (VPC) and compliance boundary), and cost efficient (Spot + Graviton + scale-to-zero).

Optional enhancements

The following sections cover optional enhancements for production deployments that improve performance, security, and operational maturity.

EKS provisioned control plane

Amazon EKS offers two modes of operation for the cluster control plane: Standard mode and Provisioned mode. By default, EKS uses Standard mode, where the control plane automatically scales up and down based on workload demand. With Provisioned mode, you can pre-allocate control plane capacity that is always ready to handle demanding workload requirements.

As ARC scales, each runner pod generates API requests to the control plane. When scaling is more aggressive and at a larger scale, Standard mode might not be sufficient. With Provisioned mode, you configure the control plane to scale at fixed, higher tiers, which delivers more consistent API performance and pod scheduling rates. To determine whether your workload needs Provisioned mode, see the tier specification.

Also consider the cost. Each tier is billed per cluster-hour on top of the standard cluster fee. For example, the XL tier is $1.65 per hour in addition to the $0.10 per hour cluster fee (see Amazon EKS pricing for all tiers). We recommend Standard mode for most use cases. Provisioned mode is aimed at very large-scale workloads, so evaluate it only if Standard mode isn’t meeting your needs.

AWS Secrets and Configuration Provider (ASCP)

In the preceding walkthrough, ARC authenticates with GitHub using credentials stored in a Kubernetes Secret. With the AWS Secrets and Configuration Provider (ASCP), you can instead store the credentials in AWS Secrets Manager and sync them into that Kubernetes Secret with the Secrets Store CSI Driver, using secretObjects in the SecretProviderClass. This centralizes secret management, supports automatic rotation, and provides audit logging through AWS CloudTrail. The driver creates the Kubernetes Secret only while a pod mounts the volume, and deletes it when the last such pod is removed. To keep the secret available, run a small, long-lived pod that mounts it. For more information, see the AWS Secrets Manager User Guide.

To build on this solution, consider exploring the following:


About the authors

Vardy Ng

Vardy Ng

Vardy is a Software Development Engineer in AWS Kubernetes, having transitioned from a Cloud Support Engineer role in AWS Enterprise Support when he authored this post. He is passionate about developing applications on Cloud, Container technologies, and CI/CD.

Mridul Chopra

Mridul Chopra

Mridul is a Senior Containers Specialist Technical Account Manager at AWS, where she guides enterprise customers through their container modernization journeys with a focus on Amazon EKS and Kubernetes. She helps organizations design secure, scalable cloud-native solutions, focusing on implementing best practices for modern cloud infrastructure.