Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 10: Environments, OIDC und Updates

Ziel: Ein Environment produktion mit Freigabe und eigenem Secret anlegen, ein OIDC-Token aus dem Lauf holen und seine Claims lesen, und Dependabot die Abhängigkeiten aktuell halten lassen. · Dauer: ca. 75 min · Voraussetzung: Tag 9

Briefing

  • Ein Environment ist ein Ziel wie produktion. Es kann eine Freigabe verlangen, Secrets nur für sich haben und festlegen, welche Branches dorthin deployen dürfen. Ein Job wählt es mit environment:.
  • OIDC: Mit id-token: write holt sich ein Job ein signiertes JWT von GitHub. Darin steht, wer er ist: Repository, Branch, Environment. Clouds und Vaults tauschen es gegen kurzlebige Zugangsdaten – ohne gespeichertes Secret.
  • Dependabot sucht nach neuen Versionen von Go-Modulen, Actions und Base-Images und öffnet dafür Pull-Requests. Konfiguriert in .github/dependabot.yml.
 deploy (environment: produktion)
   ─► wartet ─► Freigabe ─► Secret DEPLOY_TOKEN
                         └► OIDC-Token: sub = repo:…:environment:produktion

Drill 1: Ein Environment mit Freigabe

Die Freigabe soll von dir kommen. Dafür braucht die API deine numerische ID:

cd ~/gha-lab/notes-actions
gh api user --jq .id

Erwartet (deine Zahl weicht ab):

251214518

Die Regeln als JSON – ersetze die Zahl durch deine:

cat > ~/gha-lab/env-produktion.json <<'EOF'
{
  "reviewers": [ { "type": "User", "id": 251214518 } ],
  "prevent_self_review": false,
  "deployment_branch_policy": {
    "protected_branches": true,
    "custom_branch_policies": false
  }
}
EOF
gh api -X PUT repos/{owner}/{repo}/environments/produktion \
  --input ~/gha-lab/env-produktion.json --jq '.name, [.protection_rules[].type]'

Erwartet:

produktion
["required_reviewers","branch_policy"]
  • reviewers: Wer freigeben darf – Personen oder Teams.
  • prevent_self_review: false: Wer den Lauf ausgelöst hat, darf selbst freigeben. Allein im Repository geht es nicht anders; im Team stellst du es auf true.
  • protected_branches: true: Nur Branches mit Schutz dürfen in dieses Environment deployen – bei dir main, über das Ruleset von Tag 4.

Ein Secret nur für dieses Environment:

gh secret set DEPLOY_TOKEN --env produktion --body lab-deploy-token-123
gh secret list --env produktion

Erwartet:

NAME          UPDATED
DEPLOY_TOKEN  less than a minute ago

Den Wert zeigt gh nie an – auch du kannst ein Secret nur überschreiben, nicht lesen.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Ein Deployment, das wartet

cat > .github/workflows/deploy.yml <<'EOF'
name: deploy
on: workflow_dispatch

permissions:
  contents: read

jobs:
  deploy:
    runs-on: ubuntu-24.04
    environment: produktion
    permissions:
      contents: read
      id-token: write
    steps:
      - name: Secret nutzen
        env:
          DEPLOY_TOKEN: ${{ secrets.DEPLOY_TOKEN }}
        run: |
          echo "Token: $DEPLOY_TOKEN"
          echo "Länge: ${#DEPLOY_TOKEN}"
      - name: OIDC-Token
        run: >-
          curl -fsS -H "Authorization: bearer $ACTIONS_ID_TOKEN_REQUEST_TOKEN"
          "$ACTIONS_ID_TOKEN_REQUEST_URL&audience=lab"
          | jq -r .value
          | jq -R 'split(".")[1] | @base64d | fromjson
          | {sub, aud, ref, environment, job_workflow_ref}'
EOF
git add .github
git commit -qm "deploy: Environment produktion"
git push -q
gh workflow run deploy.yml
  • environment: produktion bindet den Job an das Environment: Er wartet auf die Freigabe und sieht danach dessen Secrets.
  • Mit id-token: write setzt der Runner zwei Variablen: ACTIONS_ID_TOKEN_REQUEST_URL und ACTIONS_ID_TOKEN_REQUEST_TOKEN. Damit fragt curl ein Token für die Zielgruppe (audience) lab an.
  • Das zweite jq zerlegt das JWT und dekodiert nur den mittleren Teil, die Claims. Das Token selbst landet nicht im Log.

Mit der ID aus gh run list --workflow deploy.yml --limit 1:

gh run view <ID>

Erwartet (gekürzt):

* main deploy · 41626025600
Triggered via workflow_dispatch less than a minute ago

JOBS
* deploy (ID 125883462374)

* – der Lauf ist nicht fertig. gh run list --workflow deploy.yml zeigt als Status waiting: Der Job wartet auf die Freigabe. Freigeben geht im Browser – oder per API. Erst die ID des Environments:

gh api repos/{owner}/{repo}/actions/runs/<ID>/pending_deployments \
  --jq '.[].environment | .name, .id'

Erwartet (die ID weicht ab):

produktion
26123220715
gh api -X POST repos/{owner}/{repo}/actions/runs/<ID>/pending_deployments \
  -F 'environment_ids[]=26123220715' -f state=approved -f comment='Lab-Freigabe' \
  --jq '.[].environment'

Erwartet:

produktion
  • -F übergibt die Zahl als Zahl, -f als Text. environment_ids[] ist eine Liste – hier mit einem Eintrag.
  • state=rejected würde den Lauf abbrechen.

Sobald der Lauf fertig ist:

gh run view <ID> --log | grep -E 'Z (Token|Länge):'

Erwartet (Zeitstempel gekürzt):

deploy  Secret nutzen   ... Token: ***
deploy  Secret nutzen   ... Länge: 20

GitHub ersetzt jedes Secret im Log durch ***. Die Länge zeigt: Der Wert war da.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Was im OIDC-Token steht

gh run view <ID> --log | grep -A6 'Z {$' | cut -f3 | cut -c30-

Erwartet (die Zahlen weichen ab):

{
  "sub": "repo:<du>@251214518/notes-actions@1444038371:environment:produktion",
  "aud": "lab",
  "ref": "refs/heads/main",
  "environment": "produktion",
  "job_workflow_ref": "<du>/notes-actions/.github/workflows/deploy.yml@refs/heads/main"
}
  • cut -f3 nimmt die dritte Spalte des Logs (die Ausgabe), cut -c30- schneidet den Zeitstempel ab.
  • sub ist der wichtigste Claim. Eine Cloud vertraut nicht „GitHub“, sondern genau diesem Wert: „nur Jobs aus <du>/notes-actions im Environment produktion“. Ein Pull-Request aus einem Fork bekommt ein anderes sub und damit keinen Zugang.
  • Hinter Besitzer und Repository stehen ihre unveränderlichen IDs (@251214518, @1444038371). Benennt jemand das Repository um oder legt ein neues mit gleichem Namen an, passt das sub nicht mehr – ein Schutz gegen gekaperte Namen.
  • aud legt fest, für wen das Token gedacht ist. Ein Token für lab nützt bei einem anderen Dienst nichts.

In AWS hieße die Bedingung einer Rolle etwa so:

"token.actions.githubusercontent.com:sub":
    "repo:<du>@251214518/notes-actions@1444038371:environment:produktion"
"token.actions.githubusercontent.com:aud": "sts.amazonaws.com"

Kein Access-Key im Repository, kein Secret, das abläuft oder rotiert werden muss.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Dependabot

mkdir -p .github
cat > .github/dependabot.yml <<'EOF'
version: 2
updates:
  - package-ecosystem: gomod
    directory: /
    schedule:
      interval: weekly
  - package-ecosystem: github-actions
    directory: /
    schedule:
      interval: weekly
    groups:
      actions:
        patterns: ['*']
  - package-ecosystem: docker
    directory: /
    schedule:
      interval: weekly
EOF
git add .github/dependabot.yml
git commit -qm "dependabot: Go, Actions, Docker"
git push -q
  • Ein Eintrag pro Ökosystem. github-actions findet alle uses: – auch die mit SHA gepinnten und dem Kommentar # v7.0.1 aus Tag 9.
  • groups: fasst alle Action-Updates zu einem Pull-Request zusammen.
  • docker liest die FROM-Zeilen des Dockerfiles.

Dependabot läuft kurz nach dem Push zum ersten Mal. Nach ein paar Minuten:

gh pr list --author app/dependabot

Erwartet (je nach Stand der Abhängigkeiten):

Showing 1 of 1 pull request in <du>/notes-actions that matches your search

ID   TITLE                          BRANCH                   CREATED AT
#16  build(deps): bump github.c...  dependabot/go_module...  about 4 minutes ago

Ganz: build(deps): bump github.com/jackc/pgx/v5 from 5.11.0 to 5.12.0. Steht dort nichts, ist alles aktuell. Ob Dependabot gelaufen ist, zeigen seine Läufe:

gh run list --workflow 'Dependabot Updates' --limit 3 --json displayTitle \
  --jq '.[].displayTitle'

Erwartet (die Zahlen weichen ab):

docker in /. - Update #1677437037
github_actions in /. - Update #1677437022
go_modules in /. - Update #1677437015

Dependabot Updates ist ein Workflow, den GitHub selbst verwaltet – er taucht in gh workflow list --all auf, liegt aber nicht in deinem Repository. Ein Lauf pro Ökosystem. Für Actions und Docker gab es nichts Neues – die Actions hast du an Tag 9 auf den neuesten Stand gepinnt.

Dependabot-Pull-Requests durchlaufen ci wie jeder andere – das Ruleset verlangt grüne Checks, bevor du sie mergst.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

gh api repos/{owner}/{repo}/environments --jq '.environments[].name'

Erwartet:

produktion
gh run list --workflow deploy.yml --limit 1 --json conclusion --jq '.[0].conclusion'

Erwartet (nach der Challenge steht dort failure):

success
gh api repos/{owner}/{repo}/contents/.github/dependabot.yml --jq .name

Erwartet:

dependabot.yml

Challenge

Lehne ein Deployment ab: Starte deploy.yml noch einmal und weise die Freigabe mit einem Kommentar zurück. Welches Ergebnis hat der Lauf?

Hinweis: Wie in Drill 2, mit state=rejected.

Lösung

gh workflow run deploy.yml

Mit der neuen ID aus gh run list --workflow deploy.yml --limit 1:

gh api -X POST repos/{owner}/{repo}/actions/runs/<ID>/pending_deployments \
  -F 'environment_ids[]=26123220715' -f state=rejected -f comment='Nicht heute' \
  --jq '.[].environment'
gh run view <ID> --json conclusion --jq .conclusion

Erwartet:

produktion
failure

Der Lauf endet als failure, der Job deploy lief nie los. Im Browser steht der Kommentar „Nicht heute“ an der Ablehnung.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • OIDC statt Secrets: AWS, Azure, Google Cloud, HashiCorp Vault und OpenBao nehmen GitHub-OIDC-Tokens an. Die Vertrauensregel prüft mindestens sub und aud – eine Regel nur auf den Besitzer (repo:<org>/*) lässt jedes Repository der Organisation hinein.
  • sub anpassen: Organisationen können festlegen, welche Claims im sub stehen (z. B. zusätzlich job_workflow_ref). So lässt sich Zugang an einen bestimmten wiederverwendbaren Workflow binden (Tag 12).
  • Environments als Schranke: Freigaben, Wartezeiten (wait_timer) und Branch-Regeln sind die Stelle, an der ein Mensch vor Produktion zustimmt – mit Eintrag im Audit-Log.
  • Renovate statt Dependabot: Renovate kann mehr – eigene Datenquellen, Regeln über viele Repositorys, Automerge nach Testlauf. Das Schwesterbuch „Renovate zum Anfassen“ geht in die Tiefe.