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
ghzu 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 demtofu,conftestund 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; echoErwartet (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
curlnoch 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=falseErwartet:
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 -1Erwartet:
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 whoamiErwartet (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-tokenErwartet (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 -AErwartet:
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:hostbedeutet: Jobs mitruns-on: hostlaufen direkt auf der VM (Host-Modus). Mitubuntu-latest:docker://…liefen sie stattdessen in Containern..runnerenthä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_runnerErwartet (die erste Zeile gekürzt):
Created symlink /home/ubuntu/.config/systemd/user/default.target.wants/act_runner…
active
enable-lingerlässt die Benutzerdienste laufen, auch wenn niemand angemeldet ist.Environment=PATH=…ist wichtig: Der Dienst liest weder.bashrcnochenv.sh. Ohne~/.local/binim Pfad fände ein Jobconftestnicht.
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 2pErwartet:
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 -AErwartet:
.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 simpleErwartet (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.refist bei einem PRrefs/pull/<n>/head. Das Repository ist öffentlich, darum klapptgit fetchohne Anmeldung. - Plan als Kommentar:
jq -Rsliest den ganzen Plan als einen Text und baut daraus das JSON für die Gitea-API.gitea.tokenist 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
EOFapply.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 mainErwartet: 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 simpleErwartet (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/healthzErwartet:
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 2pErwartet:
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-' | sortErwartet:
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 1Erwartet:
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_runnerErwartet:
active
tea actions runs list -o simple | wc -lErwartet: drei Pushes, ein PR, zwei Starts von Hand.
6
curl -s -o /dev/null -w '%{http_code}\n' http://127.0.0.1:8096/healthzErwartet:
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.ymlneu. Strenger ist es, die Plandatei aus dem PR als Artefakt zu speichern und genau sie anzuwenden. Hat sichmaininzwischen 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.