Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 14: CI/CD mit Gitea Actions

Ziel: Infrastruktur nur noch über Pull-Requests ändern: Plan im PR, Apply nach dem Merge, Drift-Prüfung im Zeitplan – alles auf der eigenen VM. · Dauer: ca. 120 min · Voraussetzung: Tag 9, Tag 13

Briefing

  • Gitea ist ein schlanker Git-Server mit eingebauter CI, Gitea Actions. Die Workflow-Syntax entspricht weitgehend der von GitHub Actions.
  • tea ist die Kommandozeile zu Gitea – wie gh zu GitHub. Repository anlegen, PR öffnen, mergen, Läufe ansehen: je ein kurzer Befehl.
  • Ein Runner (act_runner) holt Jobs ab und führt sie aus. Im Host-Modus laufen die Schritte direkt auf der VM – mit dem tofu, conftest und Docker, die schon installiert sind.
 Branch ─► Pull-Request ─► plan.yml:   fmt, validate, plan, conftest, Plan als Kommentar
          Review + Merge ─► apply.yml:  apply auf main
          täglich 06:00 ─► drift.yml:  plan -detailed-exitcode → Exit 2 = Drift
  • Den State hält weiter der S3-Speicher aus Tag 9. Die Pipeline bekommt dessen Zugangsdaten als Secrets des Repositorys – nicht im Code.

Drill 1: Gitea starten

source ~/tf-lab/setup/env.sh
docker volume create gitea-data
docker run -d --name gitea --restart unless-stopped -p 127.0.0.1:3000:3000 \
  -v gitea-data:/data \
  -e GITEA__security__INSTALL_LOCK=true \
  -e GITEA__server__ROOT_URL=http://127.0.0.1:3000/ \
  gitea/gitea:28.3.0
sleep 15
curl -s http://127.0.0.1:3000/api/v1/version; echo

Erwartet (die Container-ID weicht ab):

gitea-data
5c1d0e7a9b3f...
{"version":"28.3.0"}
  • INSTALL_LOCK=true überspringt den Einrichtungsassistenten im Browser. Gitea nutzt dann SQLite im Volume – für ein Labor genau richtig.
  • Antwortet curl noch nicht, warte ein paar Sekunden und rufe es noch einmal auf.

Einen Admin anlegen – mit dem gitea-Befehl im Container:

docker exec -u git gitea gitea admin user create --admin --username lab \
  --password lab-gitea-pw-123 --email [email protected] --must-change-password=false

Erwartet:

New user 'lab' has been successfully created!

Die Weboberfläche erreichst du vom Laptop über einen SSH-Tunnel: ssh -L 3000:127.0.0.1:3000 ubuntu@<VM-IP>, dann http://127.0.0.1:3000 im Browser, Anmeldung als lab.

Fortschritt speichern? Kostenlos registrieren

Drill 2: tea einrichten

curl -sSL -o ~/.local/bin/tea https://dl.gitea.com/tea/0.16.0/tea-0.16.0-linux-amd64
chmod +x ~/.local/bin/tea
tea --version | head -1

Erwartet:

Version: 0.16.0 golang: 1.26.6  go-sdk: v1.2.0

Anmelden. tea erzeugt dabei selbst ein API-Token und speichert es in ~/.config/tea/config.yml:

tea logins add --name lab --url http://127.0.0.1:3000 --user lab \
  --password lab-gitea-pw-123 | head -1
tea whoami

Erwartet (gekürzt):

Login as lab on http://127.0.0.1:3000 successful. Added this login as lab
NOTE: no login matched this repository, falling back to login 'lab' ...
  # lab (admin)
...

Den NOTE-Hinweis gibt tea außerhalb eines Repositorys aus: Es nimmt dann die einzige Anmeldung, die es kennt.

Damit auch git push das Token nutzt, trägt tea sich als Git-Credential-Helper ein:

tea login helper setup
git config --global --get-regexp 'credential.*helper'

Erwartet (die erste Zeile kann auch "lab" has already been added! lauten):

Added "lab"
credential.http://127.0.0.1:3000.helper
credential.http://127.0.0.1:3000.helper !tea login helper

Die erste, leere Zeile setzt andere Helfer für diese Adresse zurück. Danach fragt Git für http://127.0.0.1:3000 tea nach dem Token – kein Passwort in der Remote-Adresse.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Den Runner einrichten

curl -sSL -o ~/.local/bin/act_runner \
  https://dl.gitea.com/act_runner/0.6.1/act_runner-0.6.1-linux-amd64
chmod +x ~/.local/bin/act_runner
act_runner --version
docker exec -u git gitea gitea actions generate-runner-token

Erwartet (das Token weicht ab):

act_runner version v0.6.1
Hj3kT0aQ9...

Das Registrierungs-Token gilt für die ganze Gitea-Instanz. Du gibst es einmal bei der Registrierung an:

mkdir -p ~/act_runner && cd ~/act_runner
RT=$(docker exec -u git gitea gitea actions generate-runner-token)
act_runner register --no-interactive --instance http://127.0.0.1:3000 \
  --token "$RT" --name lab-vm --labels host:host
ls -A

Erwartet:

level=info msg="Registering runner, arch=amd64, os=linux, version=v0.6.1."
level=warning msg="Runner in user-mode."
level=debug msg="Successfully pinged the Gitea instance server"
level=info msg="Runner registered successfully."
.runner
  • --labels host:host bedeutet: Jobs mit runs-on: host laufen direkt auf der VM (Host-Modus). Mit ubuntu-latest:docker://… liefen sie stattdessen in Containern.
  • .runner enthält die Registrierung. Ohne diese Datei kennt Gitea den Runner nicht.

Der Runner soll dauerhaft laufen, auch ohne angemeldeten Benutzer – als systemd-Dienst des Benutzers ubuntu:

sudo loginctl enable-linger ubuntu
mkdir -p ~/.config/systemd/user
cat > ~/.config/systemd/user/act_runner.service <<'EOF'
[Unit]
Description=Gitea Actions Runner

[Service]
WorkingDirectory=%h/act_runner
ExecStart=%h/.local/bin/act_runner daemon
Environment=PATH=%h/.local/bin:/usr/local/bin:/usr/bin:/bin
Restart=on-failure

[Install]
WantedBy=default.target
EOF
systemctl --user daemon-reload
systemctl --user enable --now act_runner
systemctl --user is-active act_runner

Erwartet (die erste Zeile gekürzt):

Created symlink /home/ubuntu/.config/systemd/user/default.target.wants/act_runner…
active
  • enable-linger lässt die Benutzerdienste laufen, auch wenn niemand angemeldet ist.
  • Environment=PATH=… ist wichtig: Der Dienst liest weder .bashrc noch env.sh. Ohne ~/.local/bin im Pfad fände ein Job conftest nicht.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Das Infrastruktur-Repository

Das Repository notes-infra beschreibt eine neue Umgebung ci auf Port 8096:

tea repos create --name notes-infra | sed -n 2p

Erwartet:

NOTE: no login matched this repository, falling back to login 'lab' ...
  # lab/notes-infra (empty)

Jetzt der Code – OpenTofu-Konfiguration, Policy aus Tag 13 und .gitignore:

mkdir -p ~/tf-lab/tag14 && cd ~/tf-lab/tag14
git init -q -b main
sed 's|tag05/terraform.tfstate|tag14/ci.tfstate|' ~/tf-lab/tag05/backend.tf > backend.tf
cp ~/tf-lab/tag05/versions.tf .
mkdir -p policy && cp ~/tf-lab/policy/plan.rego policy/
cat > main.tf <<'EOF'
provider "docker" {}

variable "instanzen" {
  type    = set(string)
  default = ["a"]
}

module "notes" {
  source      = "git::file:///home/ubuntu/tf-lab/module//notes-docker?ref=v1.2.0"
  name        = "ci"
  port        = 8096
  instanzen   = var.instanzen
  db_passwort = "lab-db-pw-123"
}
EOF
printf '.terraform/\n*.plan\nplan.json\nplan.txt\n' > .gitignore
git remote add origin http://127.0.0.1:3000/lab/notes-infra.git
ls -A

Erwartet:

.git
.gitignore
backend.tf
main.tf
policy
versions.tf

Das Modul kommt per file:// – das klappt, weil der Runner auf derselben VM läuft. Im echten Betrieb stünde hier die HTTPS-Adresse des Modul-Repositorys.

Die Pipeline braucht die S3-Zugangsdaten. Sie kommen als Secrets ins Repository – tea erkennt es am Remote origin:

tea actions secrets create AWS_ACCESS_KEY_ID "$AWS_ACCESS_KEY_ID"
tea actions secrets create AWS_SECRET_ACCESS_KEY "$AWS_SECRET_ACCESS_KEY"
tea actions secrets list -o simple

Erwartet (Zeitstempel weichen ab):

Secret 'AWS_ACCESS_KEY_ID' created successfully
Secret 'AWS_SECRET_ACCESS_KEY' created successfully
AWS_SECRET_ACCESS_KEY 2026-11-02T16:30:16Z
AWS_ACCESS_KEY_ID 2026-11-02T16:30:16Z

Gitea speichert Secrets verschlüsselt, zeigt sie nie wieder an und ersetzt sie in Job-Logs durch ***.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Workflows für Plan und Apply

Workflows liegen in .gitea/workflows/. Zuerst der Plan für Pull-Requests:

mkdir -p .gitea/workflows
cat > .gitea/workflows/plan.yml <<'EOF'
name: plan
on: pull_request

jobs:
  plan:
    runs-on: host
    env:
      AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
      AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
    steps:
      - name: Code holen
        run: |
          git init -q .
          git fetch -q "${{ gitea.server_url }}/${{ gitea.repository }}.git" \
            "${{ gitea.ref }}"
          git checkout -q FETCH_HEAD
      - name: Format und Validierung
        run: |
          tofu fmt -check -recursive
          tofu init -input=false -no-color
          tofu validate -no-color
      - name: Plan
        run: |
          tofu plan -input=false -no-color -out=pr.plan | tee plan.txt
          tofu show -json pr.plan > plan.json
      - name: Plan als Kommentar
        env:
          API: ${{ gitea.server_url }}/api/v1/repos/${{ gitea.repository }}
          PR: ${{ gitea.event.pull_request.number }}
        run: |
          jq -Rs '{body: ("~~~\n" + . + "~~~")}' < plan.txt > kommentar.json
          curl -sf -o /dev/null -H "Authorization: token ${{ gitea.token }}" \
            -H 'Content-Type: application/json' -d @kommentar.json \
            "$API/issues/$PR/comments"
      - name: Policy
        run: conftest test -p policy plan.json --no-color
EOF
  • Code holen ohne actions/checkout: Diese Action braucht Node.js, das auf der VM fehlt. gitea.ref ist bei einem PR refs/pull/<n>/head. Das Repository ist öffentlich, darum klappt git fetch ohne Anmeldung.
  • Plan als Kommentar: jq -Rs liest den ganzen Plan als einen Text und baut daraus das JSON für die Gitea-API. gitea.token ist ein kurzlebiges Token, das Gitea jedem Lauf mitgibt.
  • Policy kommt zuletzt: Auch ein abgelehnter Plan soll als Kommentar sichtbar sein.

Dann apply.yml für main:

cat > .gitea/workflows/apply.yml <<'EOF'
name: apply
on:
  push:
    branches: [main]
  workflow_dispatch:

jobs:
  apply:
    runs-on: host
    env:
      AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
      AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
    steps:
      - name: Code holen
        run: |
          git init -q .
          git fetch -q "${{ gitea.server_url }}/${{ gitea.repository }}.git" \
            "${{ gitea.sha }}"
          git checkout -q FETCH_HEAD
      - name: Apply
        run: |
          tofu init -input=false -no-color
          tofu apply -input=false -no-color -auto-approve
EOF

apply.yml holt den Commit über gitea.sha – genau den, der gepusht wurde. workflow_dispatch erlaubt zusätzlich einen Start von Hand.

Einchecken und pushen:

git add -A
git -c user.name=Lab -c [email protected] commit -qm "Umgebung ci"
git push -q -u origin main

Erwartet: keine Ausgabe. Der Push auf main startet sofort apply.yml. Der erste Lauf lädt Provider und Images und dauert etwa eine Minute:

sleep 60
tea actions runs list -o simple

Erwartet (Zeitpunkt und Dauer weichen ab):

1 completed Umgebung ci main push 2026-11-02 16:08 32s

Spalten: Lauf-ID, Status, Commit-Nachricht, Branch, Auslöser, Start, Dauer. Steht dort noch running, warte und frage noch einmal. Ob der Lauf erfolgreich war, zeigt view:

tea actions runs view 1 | grep -E '^(Conclusion|Workflow):'
curl -s -o /dev/null -w '%{http_code}\n' http://127.0.0.1:8096/healthz

Erwartet:

Conclusion: success
Workflow: Umgebung ci
200

Die Umgebung ci läuft – angelegt von der Pipeline, nicht von dir.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Eine Änderung per Pull-Request

Die Umgebung soll eine zweite Instanz bekommen:

git switch -c zweite-instanz
sed -i 's/\["a"\]/["a", "b"]/' main.tf
git diff --stat
git -c user.name=Lab -c [email protected] commit -qam "Zweite Instanz"
git push -q -u origin zweite-instanz
tea pr create --head zweite-instanz --base main --title "Zweite Instanz" | sed -n 2p

Erwartet:

Switched to a new branch 'zweite-instanz'
 main.tf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
remote:
remote: Create a new pull request for 'zweite-instanz':
remote:   http://127.0.0.1:3000/lab/notes-infra/pulls/new/zweite-instanz
remote:
  # #1 Zweite Instanz (open)

Die remote:-Zeilen schickt Gitea bei jedem neuen Branch – den PR legt hier aber tea pr create an.

sleep 30
tea actions runs view 2 | grep -E '^(Conclusion|Event):'

Erwartet:

Conclusion: failure
Event: pull_request

Der Plan ist gescheitert. Warum, steht im Log des Laufs:

tea actions runs logs 2 | grep -oE 'Plan: .*|FAIL - .*'

Erwartet:

Plan: 2 to add, 0 to change, 1 to destroy.
FAIL - plan.json - main - module.notes.docker_container.proxy löscht – Freigabe nötig

Den vollständigen Plan zeigt der Kommentar im PR. Öffne im Browser http://127.0.0.1:3000/lab/notes-infra/pulls/1: Unter dem PR steht der Kommentar von gitea-actions mit dem Plan, darunter der rote Status des Laufs.

Genau dafür ist die Regel da: Der Proxy wird ersetzt, also kurz gelöscht. Hier ist das in Ordnung – eine Sekunde ohne Proxy in einer CI-Umgebung. Die Freigabe ist der bewusste Merge trotz roter Policy:

tea pr merge 1
sleep 40
tea actions runs view 3 | grep -E '^(Conclusion|Event):'
docker ps --format '{{.Names}}' | grep '^ci-api-' | sort

Erwartet:

Conclusion: success
Event: push
ci-api-a
ci-api-b

In einem echten Team schützt man main (Branch Protection): Merge nur mit grünem Plan oder mit Freigabe einer zweiten Person. Das stellst du in Gitea unter Einstellungen → Branches ein.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Drift erkennen

Drift heißt: Die echte Welt weicht vom Code ab, weil jemand von Hand eingegriffen hat. Ein Plan mit -detailed-exitcode meldet das über den Exit-Code: 0 = nichts zu tun, 1 = Fehler, 2 = Änderungen.

git switch -q main
git pull -q
cat > .gitea/workflows/drift.yml <<'EOF'
name: drift
on:
  schedule:
    - cron: "0 6 * * *"
  workflow_dispatch:

jobs:
  drift:
    runs-on: host
    env:
      AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
      AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
    steps:
      - name: Code holen
        run: |
          git init -q .
          git fetch -q "${{ gitea.server_url }}/${{ gitea.repository }}.git" main
          git checkout -q FETCH_HEAD
      - name: Drift prüfen
        run: |
          tofu init -input=false -no-color
          tofu plan -input=false -no-color -detailed-exitcode
EOF
git add -A
git -c user.name=Lab -c [email protected] commit -qm "Drift-Prüfung"
git push -q
sleep 40
tea actions runs list -o simple --limit 1

Erwartet:

4 completed Drift-Prüfung main push 2026-11-02 16:09 12s

Der Push hat wieder apply.yml gestartet – ohne Änderung an der Infrastruktur. drift.yml liefe erst morgen um 6 Uhr (UTC). Jetzt ein Eingriff an der Pipeline vorbei – und die Drift-Prüfung von Hand gestartet:

docker rm -f ci-api-b
tea actions workflows dispatch drift.yml --ref main --follow \
  | grep -oE 'Plan: .*|Job succeeded|Failure - .*'

Erwartet:

ci-api-b
Plan: 1 to add, 0 to change, 0 to destroy.
Failure - Main Drift prüfen

--follow zeigt das Log, während der Job läuft. Ein roter Drift-Lauf ist das Signal: Jemand hat an der Pipeline vorbei gearbeitet. In echten Teams schickt der Job dann eine Nachricht in den Team-Chat.

Die Reparatur ist ein Apply aus der Pipeline, ebenfalls von Hand gestartet:

tea actions workflows dispatch apply.yml --ref main --follow \
  | grep -oE 'Apply complete.*|Job succeeded'
docker ps --format '{{.Names}}' | grep -c '^ci-api-'

Erwartet:

Apply complete! Resources: 1 added, 0 changed, 0 destroyed.
Job succeeded
2

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

systemctl --user is-active act_runner

Erwartet:

active
tea actions runs list -o simple | wc -l

Erwartet: drei Pushes, ein PR, zwei Starts von Hand.

6
curl -s -o /dev/null -w '%{http_code}\n' http://127.0.0.1:8096/healthz

Erwartet:

200

Challenge

Starte die Drift-Prüfung noch einmal. Jetzt muss sie grün sein.

Hinweis: Derselbe Befehl wie in Drill 7. Suche diesmal nach No changes.

Lösung

cd ~/tf-lab/tag14
tea actions workflows dispatch drift.yml --ref main --follow \
  | grep -oE 'No changes\..*|Job succeeded'

Erwartet:

No changes. Your infrastructure matches the configuration.
Job succeeded

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Den geprüften Plan anwenden: Hier plant apply.yml neu. Strenger ist es, die Plandatei aus dem PR als Artefakt zu speichern und genau sie anzuwenden. Hat sich main inzwischen geändert, lehnt OpenTofu den alten Plan ab („Saved plan is stale“).
  • Getrennte Rechte: Der Runner für prod hat eigene Zugangsdaten und nimmt nur Jobs von geschützten Branches an. Ein PR aus einem Fork darf nie an die prod-Secrets kommen.
  • Werkzeuge mit PR-Workflow: Atlantis, Digger oder Spacelift bauen den hier gezeigten Ablauf fertig nach – mit Sperren je Verzeichnis und Apply per Kommentar. Wer den Ablauf einmal selbst gebaut hat, versteht, was sie tun.