Git for IaC
Schulung & Kurs

Meistere Git-Workflows für Infrastructure as Code – PR-first, GitOps, Policy-as-Code, sichere Secrets und skalierbare Team-Kollaboration.

Infrastructure as Code revolutioniert die Art, wie wir Infrastruktur verwalten. Git bildet das Fundament für erfolgreiche IaC-Implementierungen. In diesem intensiven Training lernst Du, Git optimal für Infrastruktur-Projekte einzusetzen – von der grundlegenden Konfiguration bis hin zu ausgeklügelten, **PR-basierten** Workflows für grosse Teams. Wir verbinden **GitOps-Prinzipien**, **Policy-as-Code**, **Remote State & Locking**, **Drift-Detection** und **Secrets-Management** (z. B. SOPS/Vault), damit Deine Infrastruktur-Entwicklung kollaborativ, versioniert, auditierbar und betriebssicher wird.

Kurse für Teams:

Gerne führen wir zugeschnittene Kurse für euer Team durch - vor Ort, remote oder in unseren Kursräumen.

In-House Kurs Anfragen

 

Kursinhalt:


Willkommen zu unserem umfassenden Training über Git im Kontext von Infrastructure as Code. Dieser Kurs richtet sich an Infrastruktur-Engineers, DevOps-/Platform-Teams, SREs und System-Administratoren, die ihre IaC-Workflows professionalisieren, skalieren und absichern möchten.

In der modernen IT-Landschaft ist IaC Standard. Git bildet als Versionskontrollsystem das Rückgrat: **Pull-Requests als Change-Gate**, **verpflichtende Reviews**, **automatische Pläne**, **Policy-Prüfungen**, **freigegebene Promotion-Flows** über Umgebungen hinweg. Dieses Training vermittelt Dir das nötige Wissen und Hands-on-Praxis, um Git-Workflows optimal für Infrastruktur-Projekte zu nutzen.

Über den Verlauf des Trainings wirst Du folgende Themen meistern:

– **Einführung in Infrastructure as Code (IaC):**
... - IaC-Prinzipien und Vorteile; Push vs. Pull; GitOps-Grundlagen (Argo CD/Flux)
... - Git als Fundament für IaC-Workflows in Terraform, Ansible, Kubernetes
... - Repo-Strategien: Monorepo vs. Polyrepo, Trunk-Based vs. GitFlow für IaC

– **Version-Control-Konzepte für Infrastruktur:**
... - Unterschiede zwischen Applikations- und Infrastruktur-Code
... - Abhängigkeiten & Modulversionierung (SemVer, Registry, Git-Tags)

– **Git Grundlagen und Setup:**
... - Installation, globale/projektspezifische Settings, Commit-Signierung (GPG/SSH)
... - Konventionen: Conventional Commits, Scopes (env, module, provider)

– **SSH Keys und Remote-Konfiguration:**
... - SSH-Key-Generierung/-Rotation; Multi-Key-Strategien für Tenants/Accounts
... - Sichere Remote-Verbindungen; Git-Hosts, Deploy-/Robot-Keys
... - Upstream/Downstream-Patterns, Forks, Mirror-Repos (DR)

– **.gitignore für IaC-Projekte:**
... - IaC-spezifische Ignore-Patterns (z. B. Terraform `.tfstate*`)
... - Umgang mit State-Files/Backends; Umgang mit sensiblen Artefakten
... - Templates für Terraform, Ansible, Helm/Kustomize

– **Git History & Vergleiche:**
... - Effizient mit `git log`, `git diff`, `git blame` für Compliance & Audit
... - Visualisierung von Infrastruktur-Evolution (Plans, Graphs, Diffs)

– **Branching-Strategien für IaC:**
... - Environment-basierte Modelle (dev→stage→prod), Trunk-Based IaC
... - Feature-Branches für Infra-Änderungen, Hotfix-Workflows
... - Release-Branches und Promotion-Strategien (Tags/Releases)

– **Merge, Rebase und Konfliktlösung:**
... - Merge-Strategien für HCL/YAML; Rebase für saubere History
... - Konfliktlösung in IaC-Dateien (Terraform/K8s-Manifeste)
... - Best Practices für kollaboratives Arbeiten

– **Code Reviews & Governance für Infrastruktur:**
... - PR-/MR-Prozesse mit automatischem `terraform plan` im Thread (Atlantis/CI)
... - **CODEOWNERS**, Required Approvals, Branch Protection Rules
... - **Security- und Compliance-Checks** (tflint, tfsec/Checkov, Conftest/OPA)
... - Review-Templates (Risk/Impact/Rollback), Change Windows

– **Remote State, Workspaces & Drift Detection:**
... - Remote Backends (S3+DynamoDB/Azure/GCS), State Locking
... - Workspaces/Stacks & Isolations-Patterns (Accounts/Subscriptions)
... - Geplante Drift-Checks (`terraform plan`), auto-PRs, Notifications

– **Releases, Promotion & Automatisierung:**
... - Git Tags & Semantic Versioning für Module/Stacks
... - Changelog-Generierung (Conventional Commits, release-please)
... - CI/CD-Pipelines (GitHub Actions/GitLab CI): fmt/validate/lint/scan/plan/apply
... - ChatOps (Atlantis `/plan`/`/apply`) & “comment-driven” Pipelines

– **Secrets-Management & sichere Credentials:**
... - **SOPS + age**, **Vault**, External Secrets Operator (für K8s)
... - Kurzlebige Cloud-Credentials (OIDC federation), Least-Privilege-Policies
... - Secret-Masking in CI, Vermeidung von Secret-Leaks (pre-commit hooks)

– **Hands-on Übungen:**
... - Terraform-Repo-Layout mit `/modules` & `/envs`, Remote State & Locking
... - PR-Workflow: CI (fmt, validate, tflint, tfsec/Checkov, Conftest/OPA) + Plan-Kommentar
... - CODEOWNERS & Required Checks; Policy-Verstoss wird blockiert
... - Module-Release (SemVer) & Environment-Promotion (dev→stage→prod)
... - SOPS-basierte Secrets im CI; Rotation; Drift-Detection mit auto-PR

– **Tooling & Integration:**
... - VS Code-Integration, Git CLI/GUI (GitHub Desktop, Sourcetree)
... - Terragrunt, Atlantis/Spacelift/Env0, Argo CD/Flux, Kustomize/Helm
... - Pre-commit Hooks (fmt, validate, tflint, tfsec, yamllint, kubeconform)

Dieser Kurs kombiniert Theorie mit intensiver Praxis und bereitet Dich darauf vor, **PR-first GitOps-Workflows** mit **Policy-Gates**, **sicheren Secrets** und **robustem Remote State** in realen IaC-Projekten sicher zu betreiben.


Disclaimer: Der effektive Kursinhalt kann, abhängig vom Trainer, Durchführung, Dauer und Konstellation der Teilnehmer:innen von obigen Angaben abweichen.

Ob wir es Schulung, Kurs, Workshop, Seminar oder Training nennen, wir möchten Teilnehmer/innen an ihrem Punkt abholen und mit dem nötigen praktischen Wissen ausstatten, damit sie die Technologie nach der Schulung direkt anwenden und eigenständig vertiefen können.

Ziel:

Teilnehmer/innen können nach dem Kurs **PR-first GitOps-Workflows** für IaC sicher betreiben: mit **Remote State & Locking**, **Policy-as-Code-Gates** (tflint, tfsec/Checkov, Conftest/OPA), **CODEOWNERS & Branch Protection**, **sicherem Secrets-Management** (SOPS/Vault) und **Environment-Promotion** (dev→stage→prod).


Form:

Bewährter Mix aus Erläuterung, Live-Demos und **Hands-on-Labs** in einer vorbereiteten Umgebung. Wir arbeiten PR-basiert mit **CI/CD-Gates, Policy-as-Code, Remote State & Drift Detection** – realitätsnahe Szenarien statt Folien.


Zielgruppe:

Infrastructure/Platform Engineers, DevOps Engineers, SREs, System-Administratoren und Cloud-Architekt/innen, die Git-basierte IaC-Workflows mit Governance, Security und Automatisierung aufsetzen oder professionalisieren möchten.


Voraussetzungen:

Sicherer Umgang mit Kommandozeile; Basiswissen IaC (z. B. Terraform/Ansible/Kubernetes) und erste Git-Erfahrung. Von Vorteil: Grundverständnis von CI/CD, YAML und Cloud-Principals (IAM).


Vorbereitung:

Nach Anmeldung: Fragebogen & Setup-Guide. Wir stellen eine Laborumgebung mit **Git, Terraform, tflint, tfsec/Checkov, Conftest/OPA, SOPS + age**, sowie CI-Vorlagen bereit. Optional: eigenes Cloud-Testkonto mitbringen.

In-House Kurs anfragen:

In-House Kurs Anfragen

Trage dich in die Warteliste ein für weitere öffentliche Kurs-Termine. Sobald wir genügend Personen auf der Warteliste haben, klären wir einen möglichst für alle passenden Termin ab und schalten einen neuen Termin auf. Falls du direkt mit zwei Kollegen oder Kolleginnen teilnehmen möchtest, können wir sogar direkt einen öffentlichen Kurs für euch planen.

Warteliste

(Falls ihr bereits mehr 3 Teilnehmer:innen oder mehr habt, klären wir mit euch direkt euren Wunschtermin ab und schreiben den Kurs aus.)

Mehr über Git für Infrastructure as Code


Git ist das de-facto Standard-Versionskontrollsystem für IaC. In PR-first Workflows werden Änderungen via **Merge Requests** mit **automatischem Plan**, **Policy-as-Code-Prüfungen** und **verpflichtenden Reviews** kontrolliert. **Remote State & Locking** verhindern Race Conditions, **Drift Detection** macht Abweichungen sichtbar, **SemVer** und **Changelogs** stabilisieren Modul-Releases, und **SOPS/Vault** sichern Secrets.




Geschichte und Entwicklung


Mit dem Aufkommen von IaC wurde Git vom reinen Code-VC zum **Change-Control-System für Infrastruktur**: PRs als Gate, automatisierte Pläne und Policies als Guardrails, sichere Secrets und reproduzierbare Releases. Heute bilden **GitOps-Ansätze** in Kombination mit Tools wie Terraform, Argo CD/Flux und Policy-Engines die Grundlage für skalierbare, auditierbare Infrastructure Delivery.