Skip to main content
Version: 0.1

Install on EKS

This page takes you from an EKS cluster to a working Infrared, step by step: one ir install of the public chart, which also runs the setup wizard from a file; an org whose agent steps run on Claude through Amazon Bedrock, as an IAM role in your own account, with no model key anywhere; and your first Product and Change. Infrared reaches AWS through IAM roles and the cluster's own identity, never a long-lived key. Allow about an hour, most of it waiting for the install and the first run.

The commands need ir and Infrared from release 0.1.3-rc.1 on. Two of the things you set up here, install telemetry and the org's model provider, are new in that release and sit behind rollout flags, which your values file turns on.

Install it with us

Infrared's EKS cluster template, aws/eks-cluster, is built from nothing, connected, used and deleted every day as a workload cluster, and Infrared's management cluster runs on it with Bedrock, as this page describes. It has had less use than GKE, so if anything on this page doesn't go as it says, book a call or write to [email protected] and we install it with you.

Before you start​

  • An EKS cluster with private nodes, and a kubectl context named after it. Build it from Infrared's EKS cluster template, aws/eks-cluster v0.21.0 or later in infrared-iac-modules, which we share with you when you start, or use a cluster of your own with:
    • a managed node group of at least 3 nodes of 4 vCPU and 16 GiB, such as m6i.xlarge, in private subnets behind a NAT gateway. The nodes reach the internet through it: that is how they pull Infrared's images, and how agent steps reach Bedrock and your forge;
    • the EBS CSI driver, with a default StorageClass (the template's is gp3);
    • containerd on every node trusting the install's own registry at its cluster address, so that a zone can pull the images Infrared builds. Pick a free ClusterIP in the cluster's service range, with port 5000: EKS's default range is 172.20.0.0/16, or 10.100.0.0/16 for a VPC in 10.0.0.0/8, and aws eks describe-cluster --name acme-cp --query cluster.kubernetesNetworkConfig.serviceIpv4Cidr says which, so 172.20.0.50:5000 as a rule. The template takes it as containerd_registry_hosts = [{ server = "172.20.0.50:5000", hosts = [{ host = "http://172.20.0.50:5000" }] }] and writes containerd's registry host entry, /etc/containerd/certs.d/172.20.0.50:5000/hosts.toml, on every node at boot; a cluster of your own needs that file on every node. On a cluster that already exists, the apply replaces the nodes: EKS launches a new node in every availability zone before it drains any, which needs that much spare on-demand vCPU quota, or node_update_strategy = "MINIMAL" to launch one node at a time. The same address goes in the values file below as registry.address and builds.registry, and it must stay free, since Infrared pins the registry's Service to it;
    • an IAM OIDC provider for the cluster (the template makes one; aws iam list-open-id-connect-providers lists yours). Infrared's identity and your Bedrock role both rest on it;
    • the identity you run ir as made a cluster admin, through an EKS access entry.
  • The AWS CLI, signed in to the account the cluster is in, able to create IAM roles and to read the cluster. aws sts get-caller-identity names the account. If your sign-in is short-lived, sign in again when the CLI says the token has expired.
  • Amazon Bedrock in the region your agents will call it in: Anthropic's Claude models enabled for the account, under Bedrock's Model access, with quotas above zero for the models you name. A new account can hold a quota of zero for the newest models, Claude 5.5 among them, until you ask AWS to raise it; the Claude 4.6 and 4.5 ids in Bedrock for your org work by default.
  • ir, from 0.1.3-rc.1 on, with helm 3.8 or later, kubectl, crane and yq on your PATH: ir install drives the first two, and step 2 uses the others. See Get ir.
  • Infrared's release, in your ECR. From 0.1.15, Infrared's final releases are published publicly (the chart oci://us-central1-docker.pkg.dev/darkshift-public/infrared/charts/infrared, the images us-central1-docker.pkg.dev/darkshift-public/infrared/infrared-<component>), as 0.1.0 was; the patches between them, and release candidates such as 0.1.3-rc.1, are not: they live in Darkshift's own registry, which Darkshift gives you access to when you start. Either way an install on EKS runs from ECR repositories in your own account, which the nodes pull from with their node role; crane and yq on your machine copy the release there in step 2.
  • A domain on Cloudflare, and cloudflared on your machine signed in to the account that holds the zone (cloudflared tunnel login). The nodes are private, so Infrared's edge is reached through a Cloudflare Tunnel: cloudflared runs beside Infrared's Envoy edge on the cluster and connects out to Cloudflare, nothing listens on a node's ports, and the install needs no Cloudflare API token. Infrared answers at a name such as infrared.example.com, and your environments at <environment>.apps.example.com.
  • No license yet. Infrared 0.1 runs with no license through November 30, 2026 (UTC). See Licensing.

1. Make the tunnel​

Once per cluster:

cloudflared tunnel create acme-cp
cp ~/.cloudflared/<tunnel id>.json ~/.secrets/cloudflare-tunnel-acme-cp.json
chmod 600 ~/.secrets/cloudflare-tunnel-acme-cp.json

cloudflared tunnel create prints the tunnel's id and writes its credentials file. The file can answer for the tunnel's names, so keep it where only you can read it and never put it in a values file: it reaches the chart as a secret, through ir install. The id is not a secret; it goes in the values file below.

Then, in the zone on Cloudflare, make two DNS records, both proxied CNAMEs to <tunnel id>.cfargotunnel.com: one for Infrared's own address, infrared.example.com, and one wildcard for your environments, *.apps.example.com. Make them in the Cloudflare dashboard or with its API; cloudflared tunnel route dns acme-cp infrared.example.com makes a record like the first. Cloudflare terminates TLS for both names at its edge, and the tunnel carries the traffic to Infrared.

2. Copy the release into your ECR​

Private nodes pull Infrared's images from ECR in their own account with their node role, and Argo CD pulls the chart from there with a short-lived ECR token, so the release you run lives in ECR repositories named after the cluster: acme-cp/charts/infrared for the chart, and acme-cp/infrared-operator, acme-cp/infrared-api, acme-cp/infrared-ui, acme-cp/infrared-runner, acme-cp/infrared-mcp and acme-cp/infrared-summaryvideo for the images. Infrared's final releases from 0.1.15 on are published publicly and its release candidates are not, so the source is the public registry or the registry Darkshift gave you access to, as the release you run requires. If your release is already in your ECR, skip this step.

Each image is copied by its digest, to the tag the chart pins, so what runs is exactly the release: the chart infrared names each component's tag and digest under infrared-core.

REL=0.1.3-rc.1
SRC=<Darkshift's registry> # us-central1-docker.pkg.dev/darkshift-public/infrared for a final release
ECR=<account id>.dkr.ecr.<region>.amazonaws.com
for r in charts/infrared infrared-operator infrared-api infrared-ui infrared-runner infrared-mcp infrared-summaryvideo; do
aws ecr create-repository --region <region> --repository-name acme-cp/$r --image-tag-mutability IMMUTABLE
done
aws ecr get-login-password --region <region> | crane auth login $ECR --username AWS --password-stdin
aws ecr get-login-password --region <region> | helm registry login $ECR --username AWS --password-stdin
# for a release candidate, also crane auth login and helm registry login to $SRC with the access Darkshift gave you
helm show values oci://$SRC/charts/infrared --version $REL > release-values.yaml
for c in operator api ui mcp runner summaryvideo; do
tag=$(yq -r ".\"infrared-core\".$c.image.tag" release-values.yaml)
digest=$(yq -r ".\"infrared-core\".$c.image.digest" release-values.yaml)
crane copy $SRC/infrared-$c@$digest $ECR/acme-cp/infrared-$c:$tag
done
crane copy $SRC/charts/infrared:$REL $ECR/acme-cp/charts/infrared:$REL

crane digest $ECR/acme-cp/infrared-api:<tag> answers the digest the chart pins once the copy is done. The repositories keep their tags immutable, so a tag that already points at another digest refuses the copy rather than moving. The chart also pins a code index image, which this install leaves out, so it isn't copied.

3. Write the values file​

ir install hands this file to the chart as the values of infrared-core, Infrared's own chart inside the infrared chart, so unlike the GKE page nothing here is nested under infrared-core:.

# infrared-values.yaml
managementCluster:
name: acme-cp # the EKS cluster's own name
cloud: aws
image:
registry: <account id>.dkr.ecr.<region>.amazonaws.com/acme-cp # your ECR repositories, from step 2
gitops:
chartRepository: <account id>.dkr.ecr.<region>.amazonaws.com/acme-cp/charts # where Argo CD pulls the chart from for upgrades
registryToken:
aws:
region: <region> # Argo CD pulls the chart with a short-lived ECR token
hostNetwork: true
cloudIdentity:
aws:
webIdentity: true # Infrared reaches your AWS accounts as the cluster's own identity
installation:
edge: gateway
tunnel:
id: 6ff42ae2-765d-4adf-8112-31c55c1551ef # the tunnel's id from step 1
previews:
domain: apps.example.com # environments answer at <environment>.apps.example.com
signInURL: https://infrared.example.com # Infrared's own address
stores:
enabled: true # Postgres and an object store on the cluster
registry:
address: 172.20.0.50:5000 # the install's own registry, at the cluster address the nodes trust
builds:
registry: 172.20.0.50:5000 # where Product images are built into
gitea:
enabled: true # your repos and gitops repo on Infrared's own Gitea
persistence:
storageClass: "" # the cluster's default StorageClass
size: 10Gi
components:
disabled: [aws-load-balancer-controller, infisical, code-index]
codeIndex:
enabled: false
api:
clientAddressHeader: CF-Connecting-IP # every request arrives through Cloudflare
strategy:
type: Recreate
flags:
installTelemetry: true # rollout flag: the install may register with Darkshift's telemetry plane
modelProviderSettings: true # rollout flag: an org may choose Amazon Bedrock as its model provider
runner:
bedrock:
enabled: true # agent steps on Claude through Amazon Bedrock, for the orgs that choose it

Line by line:

ValueWhat it does
managementCluster.nameThe management cluster's name, which must be the EKS cluster's own name. It names the folder registry/clusters/<cluster>/ in your gitops repo.
cloud: awsThe cloud the management cluster runs in. Infrared then detects the cluster as flavor eks on provider aws, and the gitops repo gets the components that flavor needs.
image.registry, gitops.chartRepositoryYour ECR repositories from step 2: every component image is pulled as <registry>/infrared-<component>:<tag>@<digest>, and the chart from the repository named with no oci://. With cloud: aws the chart's own default is a registry you can't reach, so set both.
registryToken.aws.region, registryToken.aws.hostNetworkA short-lived ECR token, good for 12 hours and refreshed every 30 minutes, which Argo CD pulls the chart with: a Job mints it as the node's role. The nodes pull the images with that role directly and need no token. hostNetwork: true runs the Job on the node's own network, where the instance metadata answers in one hop.
cloudIdentity.aws.webIdentity: trueHow Infrared reaches the AWS accounts your orgs add: as the cluster's own identity, a projected ServiceAccount token for the audience sts.amazonaws.com, which a role of yours trusts through the cluster's OIDC provider. No role for Infrared itself, and no key. See Cloud accounts.
installation.edge: gatewayThe Envoy Gateway edge, which serves Infrared's own address and every environment's.
installation.tunnel.idThe Cloudflare Tunnel the edge is reached through. With it set, the gitops repo runs cloudflared beside Envoy, binds no node port, gives the edge a certificate from a certificate authority inside the cluster, and leaves out external-dns and Cloudflare's origin issuer: the install needs no Cloudflare token.
installation.previews.domain, installation.previews.signInURLWhere environments answer, and Infrared's own address: the two names step 1 pointed at the tunnel.
stores.enabled: trueThe platform's own stores on the cluster, one Postgres and one object store, on the cluster's default StorageClass. The registry's layers live in the object store.
registry.address, builds.registryThe install's own registry, pinned to the ClusterIP the nodes trust (the prerequisite above), and where kpack builds Product images into: 172.20.0.50:5000/<org>/<product>. With both set, the gitops repo renders the registry, kpack's builder and the builds namespace, and the operator mints each org's registry user and push credential. No role and no ECR repository for Products: only Infrared's own images are in your ECR.
gitea.enabled: true, gitea.persistenceGitea beside Infrared, as the forge for your repos and gitops repo, with nothing to connect; "" takes the cluster's default StorageClass. To use a GitHub organization instead, leave Gitea out and see Connect GitHub: a GitHub App is created in a browser, so ir install --setup stops at that step and ir setup run finishes after it.
components.disabledComponents of the gitops catalog this install leaves out. aws-load-balancer-controller: nothing behind the tunnel asks for an AWS load balancer, and the controller needs an IAM role of its own; leave it in only if your Products' Services will ask for one. infisical: installed for later use on other installs, with nothing on it yet. code-index: the optional code index, with codeIndex.enabled: false beside it.
api.clientAddressHeaderThe header that carries a caller's address, which the sign-in page's limits count failures by. Behind Cloudflare that is CF-Connecting-IP, set on every request.
api.strategy.type: RecreateHow a new API rolls out at an upgrade: the old pod stops before the new one starts, a short outage, rather than a second API waiting for a node with room beside the first.
api.flags.installTelemetry: trueThe rollout flag for install telemetry: with it on, ir install registers the install with Darkshift's telemetry plane once it is Ready, and platform admins see Telemetry in Settings → System → Features, with the switch that turns it off. Off, nothing registers and nothing shows.
api.flags.modelProviderSettings: trueThe rollout flag for an org's model provider: with it on, an org admin chooses Amazon Bedrock with ir org model-provider set, and get answers the provider the org has. Off, every org reads as the Anthropic API and the choice answers 404.
runner.bedrock.enabled: trueThe install's Bedrock switch: an org whose model provider names one of its AWS cloud accounts runs its agent steps on Claude through Bedrock as that account's role. Off, every org runs on the Anthropic API with its own key, and the choice is kept but ignored.

Every other value is in Chart values; the three above that belong to this release are explained there too. Never put a token or a credentials file in this file.

4. Write the install file​

infrared.yaml is what ir reads: the chart, the values file, the secrets by file name, and the setup wizard's answers.

# infrared.yaml
install:
chart: oci://<account id>.dkr.ecr.<region>.amazonaws.com/acme-cp/charts/infrared # your ECR, from step 2
version: 0.1.3-rc.1
subchart: infrared-core # the values and the secrets go to Infrared's own chart inside the umbrella
chartLogin: # helm signs in to your ECR for this install alone; the password is never printed
username: AWS
command: [aws, ecr, get-login-password, --region, <region>]
values: infrared-values.yaml
secrets:
- value: platformTokens.cloudflareTunnelCredentials
file: ~/.secrets/cloudflare-tunnel-acme-cp.json # the file from step 1, never its content
setup:
admin:
email: [email protected] # the root user, the install's first platform admin
# passwordFile: ~/.secrets/acme-cp-root-password # optional; without it ir uses a throwaway password it never keeps
org:
name: acme # the platform org; it can't be renamed later
displayName: Acme
cluster: acme-cp # the management cluster, as managementCluster.name
forge: gitea
gitops:
name: gitops
visibility: private

ir reads a relative path from the file's directory and ~/ as your home directory. chartLogin runs its command without a shell and hands the output to helm as the registry password, for this install alone; add --profile <name> to the command if your AWS CLI signs in with one. Every file under install.secrets must be readable by you alone (mode 600), and each one reaches helm on a file descriptor, never as an argument. The chart refuses a credentials file that isn't a JSON object with a TunnelID, or whose TunnelID isn't installation.tunnel.id.

Without setup.admin.passwordFile, ir finishes the wizard with a throwaway password it makes in memory and never prints or writes down, mints an API token for your machine and saves it. Set the real root password afterwards, from your break-glass vault, under Break glass in Settings → System → Sign-in. See Scripted setup.

5. Install​

ir install --context acme-cp -f infrared.yaml --setup --wait --timeout 30m \
--config ~/.config/infrared/acme-cp.yaml

Name the cluster with --context: ir never uses your current context. --config names the file ir saves this install's address and API token in; without it ir install writes them over ir's default config file, so name one per install, and pass the same --config to every ir command on this page from now on.

ir install then does four things, writing a TIME line to stderr as each ends:

  1. step=helm-install: the one helm install of the chart, as the release infrared in the namespace infrared, with the tunnel's credentials from the file.
  2. step=setup: the setup wizard, through a port-forward of its own: the setup token from the cluster, the root user, the platform org acme, the management cluster confirmed, the Gitea organization, and the gitops repo hydrated from the template. Argo CD then syncs it wave by wave.
  3. wait=status: waits until the Installation is Ready and every Application is Synced and Healthy. About fifteen minutes: Gitea, Postgres, the object store, the registry, the edge, the metrics stack, kpack and Infrared itself come up in turn.
  4. step=login: checks the saved token at Infrared's own address, https://infrared.example.com, through the tunnel, trying again for up to five minutes while the edge comes up, and saves the address in the config file. Then step=telemetry: the install registers with Darkshift's telemetry plane, and one line says the platform it registered as, install-<id>, and where it writes. See What is sent to Darkshift below.

It ends with the status table: Phase Ready, Version v0.1.3-rc.1, the platform org, the management cluster, the gitops repo and its sync waves, and the counts. Open Infrared in your browser, signed in as the root user:

ir --config ~/.config/infrared/acme-cp.yaml status
ir --config ~/.config/infrared/acme-cp.yaml open
ir --config ~/.config/infrared/acme-cp.yaml flags # installTelemetry and modelProviderSettings read true

If step=login warns that the address doesn't answer yet, the DNS records of step 1 are the first thing to check; ir login --context acme-cp --config ~/.config/infrared/acme-cp.yaml finishes the sign-in once they resolve.

6. Bedrock for your org​

Agent steps reach Claude through the Anthropic API with the org's key, or through Amazon Bedrock in one region as the role of one of the org's AWS cloud accounts. On Bedrock the org holds no model key: each step's runner assumes the role with the cluster's own token, the agent's container holds no AWS credential, the model calls are signed for Bedrock in your region, and the spend lands on your AWS bill at Bedrock's prices. An org admin sets it up in four commands.

The IAM role​

Make one role, acme-cp-bedrock, that two identities on the cluster may assume by web identity: infrared/infrared-cloud, which checks the cloud account and keeps it Verified, and each org's runner, which runs as the default ServiceAccount of the org's namespace ir-org-<org>. Its permissions are the least Claude needs: invoke Anthropic's models and the account's inference profiles, and read which exist.

First find the cluster's OIDC provider, which the trust policy names twice:

aws eks describe-cluster --name acme-cp --query 'cluster.identity.oidc.issuer' --output text
# https://oidc.eks.<region>.amazonaws.com/id/<oidc id>

The trust policy, bedrock-trust.json, with your account id, region and OIDC id in place of the placeholders:

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::<account id>:oidc-provider/oidc.eks.<region>.amazonaws.com/id/<oidc id>"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringEquals": {
"oidc.eks.<region>.amazonaws.com/id/<oidc id>:aud": "sts.amazonaws.com"
},
"StringLike": {
"oidc.eks.<region>.amazonaws.com/id/<oidc id>:sub": [
"system:serviceaccount:infrared:infrared-cloud",
"system:serviceaccount:ir-org-*:default"
]
}
}
}
]
}

The permissions, bedrock-claude.json:

{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "InvokeClaude",
"Effect": "Allow",
"Action": [
"bedrock:InvokeModel",
"bedrock:InvokeModelWithResponseStream",
"bedrock:CountTokens"
],
"Resource": [
"arn:aws:bedrock:*::foundation-model/anthropic.*",
"arn:aws:bedrock:*:<account id>:inference-profile/*anthropic.*"
]
},
{
"Sid": "ReadModels",
"Effect": "Allow",
"Action": [
"bedrock:ListFoundationModels",
"bedrock:GetFoundationModel",
"bedrock:GetFoundationModelAvailability",
"bedrock:ListInferenceProfiles",
"bedrock:GetInferenceProfile"
],
"Resource": "*"
}
]
}

Then:

aws iam create-role --role-name acme-cp-bedrock \
--assume-role-policy-document file://bedrock-trust.json \
--max-session-duration 3600
aws iam put-role-policy --role-name acme-cp-bedrock \
--policy-name bedrock-claude --policy-document file://bedrock-claude.json

The role's session lasts an hour, which the runner renews before it ends; the cluster's token opens nothing on the cluster itself. Infrared's check of the account proves the first subject's trust; the runner's, ir-org-<org>:default, is proven by the first step that runs, so a trust policy that names only infrared-cloud passes the check and stops every step with STS's refusal.

Add the cloud account​

ir --config ~/.config/infrared/acme-cp.yaml cloud-account create --aws \
--account-id <account id> --role-arn arn:aws:iam::<account id>:role/acme-cp-bedrock \
--name bedrock --wait

Infrared checks the account by acting as it, which takes up to a minute, and answers Cloud account bedrock of org acme (...) is Verified: Infrared acts as ..., naming the role it assumed. Failed says why instead, and nothing is saved. ir cloud-account list shows it afterwards, as Settings → Cloud does under Cloud accounts; Infrared checks it again every 24 hours.

Name Bedrock's models​

An org on Bedrock maps its three tiers to Bedrock model ids or inference profiles rather than to Anthropic's own ids. These three work in a new account by default:

ir --config ~/.config/infrared/acme-cp.yaml models tiers set \
--frontier us.anthropic.claude-opus-4-6-v1 \
--balanced us.anthropic.claude-sonnet-4-6 \
--fast us.anthropic.claude-haiku-4-5-20251001-v1:0

To run the Claude 5.5 models, ask AWS to raise the account's Bedrock quotas for them first, then name their ids, such as us.anthropic.claude-sonnet-5-5; a model whose quota is zero can't be called, and the step's record shows each refused call with Bedrock's error type. ir models tiers get shows the mapping in force and where each tier comes from; --clear puts the install's mapping back. See Models and costs.

Choose Bedrock​

ir --config ~/.config/infrared/acme-cp.yaml org model-provider set --bedrock \
--cloud-account bedrock --region us-east-1

Infrared answers The model provider of org acme is Amazon Bedrock in us-east-1 through cloud account bedrock (Verified). Steps started from now run there. It checks the account the way the operator checks it before each step, and refuses, saving nothing, an account the org doesn't have, one that isn't an AWS account or isn't Verified, and a region that isn't one. ir org model-provider get shows the provider, the account's state, and whether the org also holds an Anthropic key; set --anthropic goes back to the Anthropic API.

An org on Bedrock needs no Anthropic key for its agent steps. The key, if the org sets one in Settings → Models and runs, under Model provider, serves its summary videos' scripts and logo suggestions alone; an org without one does without those.

7. Your first Product​

Create it and ask for a change​

The quickest Product is a page in a zip: index.html with a heading and a README.md, zipped from inside their folder with zip -X hello.zip index.html README.md. Describe it in the same infrared.yaml, or a file of its own:

products:
- name: hello
displayName: Hello
description: A one-page site, and the first agent step on Bedrock
repos:
- name: hello
visibility: private
starterZip: ./hello.zip
build: false
ir --config ~/.config/infrared/acme-cp.yaml product create -f infrared.yaml
ir --config ~/.config/infrared/acme-cp.yaml issue create --product hello \
--title "Say hello from Bedrock" \
--body "Add a line under the heading of index.html that says hello from Amazon Bedrock." -o json

ir product create makes the repo on your Gitea with the zip's files as its second commit, then the Product. ir issue create opens the issue on it and starts its Change, the change-quick AgentWorkflow, and the answer names the run. Its first step is the architect's hydration, the first agent step on Bedrock. Follow it:

ir --config ~/.config/infrared/acme-cp.yaml run get change-quick-hello-1-<suffix> -o yaml

Within a minute or two the hydrate step is Succeeded, and its record shows the model it ran on, a Bedrock id such as us.anthropic.claude-sonnet-4-6, its tokens, its cost at list prices and, from this release, that its model calls went to provider: bedrock in your region, with each call by model and outcome. In the browser, the Change's page shows the same on the step's verdict card, with the model and tier, tokens, cost and time (Steps and their verdicts), and Workforce → Agents → Models and costs and Usage add it up by AgentRole and model. On the AWS side, CloudWatch's AWS/Bedrock metric OutputTokenCount for the model, over the run's window, matches the step's output tokens.

The run then waits for you at Triage. Build it sends the work to the builder and the reviewers, each also on Bedrock, and the Change goes on as Your first Change describes, to the approval of the merge.

Build and deploy it​

Up to the merge nothing needs a container registry. From the merge on, Infrared builds the Product's image with kpack and pushes it to the install's own registry on the cluster, and the zone's nodes pull it from there by its cluster address, as on every cluster Infrared runs on; the deployment then promotes it zone by zone. On EKS that rests on two things this page already set: the nodes trusting the registry's address, through the cluster template's containerd_registry_hosts (Before you start), and the values registry.address and builds.registry naming it. No role, no ECR repository and nothing in the cluster by hand: Infrared's own images stay in your ECR, and each Product's go to 172.20.0.50:5000/<org>/<product>, pulled by digest.

Create a Product with build: true and a zone, or set up delivery on hello from its page: Infrared writes the build, a chart and the environment's files, and starts the first deployment. The environment answers at https://web-rc.apps.example.com, through the tunnel, for people signed in to Infrared.

# web.yaml
products:
- name: web
displayName: Web
repos:
- name: web
visibility: private
starterZip: ./web.zip
build: true
zones:
- name: web-rc
environment: pre-release
approval: auto
access: sign-in
ir --config ~/.config/infrared/acme-cp.yaml product create -f web.yaml
ir --config ~/.config/infrared/acme-cp.yaml deployment wait --product web --for released --timeout 20m

The Product's page shows Getting web live with its four steps: the build, chart and environment written to the gitops repo, the first image built, the deployment, and live. ir deployment wait ends when the version runs in web-rc, and ir product zones web shows the image it runs, by digest, from the install's own registry. From then on each merged Change deploys on its own: the build, the tag, the promotion to web-rc, and your approval for a production environment once you add one. See Start from a zip and Deployments.

Check it​

Two scripts in infrared-gitops-template check an install end to end, against a named context and never from CI. bedrock-proof.sh proves the Bedrock path in one line once the cloud account and the tiers are set: it chooses Bedrock on the account named by --cloud-account (bedrock by default) in --region (us-east-1 by default), creates a Product hello-bedrock and its first issue where they don't exist yet, waits for the hydrate step, and prints what it ran on, with its tokens and cost, locally and, with --cloudwatch, from CloudWatch; with --token-file (an API token in a file of one line) and --account-id and --role-arn it adds the cloud account and sets the tiers too. observability-check.sh checks the install's monitoring, the write to the telemetry plane and, with Bedrock on, that model calls are counted on it:

scripts/bedrock-proof.sh acme-cp https://infrared.example.com/api acme --config ~/.config/infrared/acme-cp.yaml
scripts/observability-check.sh acme-cp

Each prints its checks as ok, FAIL, WARN or SKIP with the reason, and exits with the number of failures. The proof spends one agent step on your Bedrock account.

What is sent to Darkshift​

What is sent to Darkshift

With installTelemetry on, the install registers itself with Darkshift's telemetry plane once it is Ready, with no sign-in and no account, and its metrics stack writes a fixed set of series there under the platform name install-<id>: Infrared's own counters (agent steps by org, workflow, role, model and provider, model calls by outcome, API requests), the install's release, cloud and counts, and the memory and CPU of agent pods. Never an event, a prompt, a file, a path, a token, a run or issue id, or a person's name or email. Telemetry lists every series and every way to turn it off; the shortest is:

ir --config ~/.config/infrared/acme-cp.yaml telemetry disconnect

which revokes the install's token at the plane, deletes it from the cluster and stops the write. ir install --no-telemetry registers nothing in the first place, and Telemetry, in Settings → System → Features, shows where the install stands.

Differences from GKE​

GKEEKS
Flavor detectednone (provider gcp)eks (provider aws)
The edgeEnvoy on every node's ports 80 and 443 behind Cloudflare's proxy, with a Cloudflare API token for DNS and origin certificatesEnvoy behind a Cloudflare Tunnel: private nodes, no node port, no Cloudflare API token
Image pullsInfrared's public registry, no sign-inECR repositories in your account, filled from the release by digest; the nodes pull with their node role, Argo CD with a short-lived ECR token
Infrared's cloud identityA Google service accountThe cluster's own identity (cloudIdentity.aws.webIdentity), trusted by a role of yours through the cluster's OIDC provider
managementCluster.nameAny nameThe EKS cluster's name
Model providerThe Anthropic APIThe Anthropic API, or Amazon Bedrock as a role in your account (runner.bedrock.enabled)
BuildsThe install's own registry on the cluster, which the zone's nodes pull fromThe same, at a cluster address the nodes trust through the cluster template's containerd_registry_hosts (see Build and deploy it)
Load balancersNone for Infrared's edgeThe AWS Load Balancer Controller, sync wave 10, only if you leave it in for Services that ask for one
BackupsCloud Storage, with no keyAmazon S3 or another S3-compatible store, with an access key

Troubleshooting​

  • helm install refuses the tunnel credentials file. The file isn't the JSON cloudflared tunnel create wrote, or its TunnelID isn't installation.tunnel.id. Copy the file for the tunnel whose id the values name, and check the id.
  • helm install can't pull the chart. chartLogin's command failed, or the chart isn't in acme-cp/charts/infrared at install.version. Run the chartLogin command yourself to check the sign-in, and crane digest the chart's tag in your ECR.
  • Pods stuck in ImagePullBackOff. An image isn't in your ECR at the tag and digest the chart pins, or the node role may not read ECR. crane digest each repository against the chart's values (step 2), and check the node role carries ECR read, AmazonEC2ContainerRegistryReadOnly or the same rights.
  • The install is Ready but https://infrared.example.com doesn't answer. The two DNS records of step 1 are missing, not proxied, or point at another tunnel. Make them proxied CNAMEs to <tunnel id>.cfargotunnel.com; the edge Application in Argo CD shows cloudflared's state.
  • ir cloud-account create answers Failed. The role's trust policy doesn't name the cluster's OIDC provider, the audience sts.amazonaws.com, or the subject system:serviceaccount:infrared:infrared-cloud. Fix bedrock-trust.json, aws iam update-assume-role-policy, and create the account again.
  • A step stops saying the org's model provider is Bedrock through a cloud account that is Pending, Failed, Missing or not AWS. The account's check failed, or the account was deleted. Fix it in Settings → Cloud, under Cloud accounts, or add it again; the step runs again with Retry.
  • A step's log shows STS refusing AssumeRoleWithWebIdentity. The trust policy names infrared-cloud but not system:serviceaccount:ir-org-*:default. Add the second subject and retry the step.
  • A step's model calls end 403 or 429 with AccessDeniedException or ThrottlingException. The account hasn't enabled the model under Bedrock's Model access, the id isn't served in the region, or its quota is zero. Enable the model or name one the account can call; for Claude 5.5, ask AWS to raise the quota first.
  • ir org model-provider set or ir telemetry say the flag is off. The values file lacks api.flags.modelProviderSettings or api.flags.installTelemetry. Add it in the install's values file in your gitops repo, registry/clusters/<cluster>/values/infrared.yaml, under infrared-core:; the API reads it within 15 seconds. See Install configuration.
  • ir says it isn't signed in after the install. ir install ran without --config, or another command ran without it. Pass --config ~/.config/infrared/<cluster>.yaml to every command, or ir login --context <cluster> --config <file>.

For more, see Troubleshooting.