Deploy from GitHub Actions without a stored key
Let a GitHub Actions job exchange its own OIDC token for credentials of an IAM role that last at most one hour, so no access key is stored in the repository.
The job asks GitHub for an OIDC token, sends it to Deutsche Cloud, and gets back a temporary access
key acting as the role. Replace org-EXAMPLE1234 with your organization's id and
role-id with the role's id.
Prerequisites
- GitHub Actions registered as an identity provider (see Add an identity provider).
- A role, here ci-deployer, with the policies the job needs attached (see Create a role) and a trust policy that admits the repository and branch or environment (see Set a trust policy).
- To copy the workflow from the console,
iam:GetRoleon the role; without it the role's page answers "not found". - The exchange itself needs no IAM permission: the role's trust policy decides.
Add the workflow
- Open the role, choose Trust policy, and copy the GitHub Actions workflow shown under the
saved trust policy. It has the console address, the audience and the role's resource name
filled in, and an
environment:line when the trust policy pins a GitHub environment. - Put it in
.github/workflows/of the repository. Its sign-in step is:
permissions:
id-token: write # lets the job request an OIDC token
contents: read
jobs:
deploy:
runs-on: ubuntu-latest
env:
EWS_API_URL: https://console.example.com
EWS_ROLE_RN: rn:ews::org-EXAMPLE1234:iam:role/role-id
EWS_AUDIENCE: https://console.example.com
steps:
- name: Sign in to Deutsche Cloud (OIDC, no stored secret)
run: |
AUD=$(jq -rn --arg a "$EWS_AUDIENCE" '$a|@uri')
OIDC_TOKEN=$(curl -sS --fail-with-body \
-H "Authorization: bearer $ACTIONS_ID_TOKEN_REQUEST_TOKEN" \
"$ACTIONS_ID_TOKEN_REQUEST_URL&audience=$AUD" | jq -r .value)
CREDS=$(curl -sS --fail-with-body -X POST \
"$EWS_API_URL/iam/api/sts/assume-role-with-web-identity" \
-H 'content-type: application/json' \
-d "$(jq -n --arg role "$EWS_ROLE_RN" --arg token "$OIDC_TOKEN" \
'{roleRn: $role, webIdentityToken: $token}')") \
|| { echo "Deutsche Cloud refused the token: $CREDS" >&2; exit 1; }
KEY_ID=$(jq -r .data.accessKeyId <<<"$CREDS")
SECRET=$(jq -r .data.secretKey <<<"$CREDS")
echo "::add-mask::$SECRET"
echo "::add-mask::$KEY_ID:$SECRET"
{
echo "EWS_ACCESS_KEY=$KEY_ID:$SECRET"
echo "EWS_ACCESS_KEY_ID=$KEY_ID"
echo "EWS_SECRET_KEY=$SECRET"
} >> "$GITHUB_ENV"
echo "Signed in until $(jq -r .data.expiresAt <<<"$CREDS")"Result
For the rest of the job, EWS_ACCESS_KEY holds <key id>:<secret>, the variable the CLI reads,
and EWS_ACCESS_KEY_ID and EWS_SECRET_KEY hold the two halves, for example for docker login.
The credential works wherever an access key does and carries the role's policies. To deploy an app
with it, see Deploy from GitHub Actions without a stored key.
The exchange
POST /iam/api/sts/assume-role-with-web-identity takes no Authorization header: the token is the
credential.
{
"roleRn": "rn:ews::org-EXAMPLE1234:iam:role/<role id>",
"webIdentityToken": "<OIDC token>",
"durationSeconds": 3600,
"sessionName": "gha-1234-1"
}durationSecondsis 900 to 3600; without it the credential lasts 3600 seconds.sessionNameis 2 to 64 characters ofA-Z a-z 0-9 _ + = , . @ -; without it, a GitHub token's session is namedgha-<run id>-<run attempt>.
The answer's data holds accessKeyId, secretKey, accessKey (<key id>:<secret>),
expiresAt, orgId, orgSlug, roleRn, sessionName and subject (the token's sub).
Every exchange for a role that exists, allowed or refused, is recorded in the audit log as
iam:AssumeRoleWithWebIdentity on the role. Once the token's signature and claims are checked,
the entry carries its repository, ref, environment, workflow and run id; a token refused before
that carries only the reason and, when it has one, its issuer. A malformed request body, a 429,
and a role that does not exist are not recorded.
On Deutsche Cloud's own runners
Jobs that run on Deutsche Cloud CI get tokens from Deutsche Cloud's own issuer with GitHub's claim names.
Register Deutsche Cloud CI as an identity provider and add a statement for it to the same trust
policy, so one role serves both. For a repository imported or mirrored from GitHub,
dcloud iam roles trust-ci adds those statements from the ones that trust GitHub Actions (see
Set a trust policy). There, uses: dcloud/configure-credentials@v1 with
role-to-assume: <role RN> does the exchange and signs Docker in to the container registry.
If the exchange is refused
- 403
AccessDenied: not authorized to assume this role with this token: no trust policy, no statement matches the token's claims, aDenymatches, or the role does not exist. A job in a GitHub environment carriesenvironment:in itssub, notref:. - 400
InvalidIdentityToken: token audience is not accepted by this provider: the job requested an audience the provider does not list. - 400
InvalidIdentityToken: no identity provider is registered for this issuer. - 400
InvalidIdentityToken: token has expired, or anotherInvalidIdentityToken: …reason. - 400
roleRn: roleRn must look like rn:…::<org-id>:iam:role/<role-id>. - 429
Too many requests: more than 30 exchanges a minute from one address, or 60 a minute for one role.