CI/CD (Continuous Integration / Continuous Delivery bzw. Continuous Deployment)

Von nanologika | 29. Januar 2026 | Kommentare deaktiviert für CI/CD (Continuous Integration / Continuous Delivery bzw. Continuous Deployment)
« Back to Glossary Index

Kurzdefinition

CI/CD bezeichnet Praktiken und Automatisierungen in der Softwareentwicklung, bei denen Codeänderungen kontinuierlich integriert, geprüft und automatisiert ausgeliefert werden. Ziel ist es, schnell, zuverlässig und wiederholbar neue Versionen bereitzustellen.

CI – Continuous Integration (Kontinuierliche Integration)

Bei CI werden Änderungen aus dem Team häufig (mehrmals täglich) in einen gemeinsamen Hauptzweig integriert. Jede Änderung löst automatisierte Prüfungen aus, z. B.:

  • Build/Compilation
  • Unit-Tests
  • Linting/Code-Analyse
  • Security-/Dependency-Checks

Ergebnis: Fehler werden früh erkannt, Integration bleibt stabil.

CD – Continuous Delivery (Kontinuierliche Auslieferung)

Bei Continuous Delivery wird nach erfolgreicher CI eine Version automatisiert bis zur „Release-Reife“ gebracht (z. B. in Staging). Die Produktivsetzung erfolgt dann bewusst per Freigabe (Manual Approval).

Ergebnis: Releases sind jederzeit möglich („Release on demand“).

CD – Continuous Deployment (Kontinuierliche Bereitstellung)

Bei Continuous Deployment geht der Prozess einen Schritt weiter: Jede Änderung, die alle Prüfungen besteht, wird automatisch in Produktion ausgerollt – ohne manuelle Freigabe.

Ergebnis: Sehr schnelle Auslieferung, benötigt aber hohe Testabdeckung und Monitoring.

Merkhilfe:
Delivery = automatisch bereitstellen, manuell freigeben
Deployment = automatisch bereitstellen und ausrollen

Typische Bausteine einer CI/CD-Pipeline

Eine Pipeline ist die Abfolge automatisierter Schritte, z. B.:

  1. Commit/Push (Trigger)
  2. Build & Package (Artefakt erzeugen)
  3. Automatisierte Tests (Unit, Integration, E2E – je nach Strategie)
  4. Quality Gates (Coverage, Linting, SAST, Dependency Scan)
  5. Deploy nach Staging
  6. Smoke-/Regression-Tests
  7. Release (manuell bei Delivery, automatisch bei Deployment)
  8. Monitoring & Rollback (Observability, Alerts, Release-Strategien)

Vorteile

  • Schnelleres Feedback und kürzere Release-Zyklen
  • Weniger Integrationsprobleme durch häufiges Mergen
  • Höhere Qualität durch automatisierte Checks
  • Wiederholbarkeit & Nachvollziehbarkeit (Versionierte Pipelines, auditierbar)

Häufige Stolpersteine

  • Langsame oder fragile Tests (Pipeline wird umgangen)
  • Zu viele UI-E2E-Tests ohne stabile Basis (hoher Wartungsaufwand)
  • Fehlende Rollback-/Release-Strategien (z. B. Blue/Green, Canary)
  • Secrets/Configs unsauber gemanagt (Sicherheitsrisiko)

Mini-Beispiel (Pipeline-Idee, stark vereinfacht)

on: push
steps:
  - build
  - unit_tests
  - security_scan
  - package_artifact
  - deploy_to_staging
  - smoke_tests
  - manual_approval (nur bei Continuous Delivery)
  - deploy_to_production

Welche Tools unterstützen CI/CD?

1) CI/CD-Plattformen (Pipeline-Orchestrierung)

Diese Tools führen Pipelines aus (Build, Test, Deploy, Gates):

  • GitHub Actions (direkt in GitHub integriert)
  • GitLab CI/CD (stark integriert inkl. Runner, Environments)
  • Azure DevOps Pipelines (Microsoft-Stack, Enterprise, YAML/Classic)
  • Jenkins (sehr flexibel, self-hosted, viele Plugins)
  • CircleCI, Travis CI, Bitbucket Pipelines
  • TeamCity, Bamboo (v. a. Enterprise/Legacy-Setups)

Wann welche?

  • Wenn ihr bereits GitHub/GitLab/Azure DevOps nutzt → meist lohnt sich die native CI/CD wegen geringerer Integrationkosten.
  • Wenn ihr maximale Anpassbarkeit/self-hosting wollt → Jenkins (aber mehr Pflege).

2) Versionsverwaltung & Review-Workflows (Trigger der CI)

CI/CD baut fast immer auf Git und Pull/Merge Requests:

  • GitHub, GitLab, Bitbucket, Azure Repos
  • Code-Review & Policies: Branch Protection, Required Checks, CODEOWNERS etc.

3) Build- und Paket-Tools (Artefakt-Erzeugung)

Je nach Tech-Stack:

  • Java/Kotlin: Maven, Gradle
  • .NET: dotnet CLI, MSBuild, NuGet
  • JavaScript/TS: npm, yarn, pnpm
  • Python: pip, poetry
  • Go: go build / goreleaser
  • Rust: cargo

Diese Schritte laufen in der Pipeline und erzeugen ein Artefakt (z. B. JAR, Wheel, Container Image).

4) Artefakt- & Container-Registries (Speichern/Versionieren)

Damit Builds reproduzierbar sind:

  • JFrog Artifactory, Sonatype Nexus
  • GitHub Packages, GitLab Package Registry
  • Azure Artifacts
  • Container Registries: Docker Hub, GHCR, GitLab Registry, Azure Container Registry, ECR (AWS), GCR/Artifact Registry (GCP)

5) Container & Orchestrierung (häufigster Deploy-Standard)

Für moderne Deployments:

  • Docker (Image Build/Run)
  • Kubernetes (Orchestrierung)
  • Helm (K8s Packaging)
  • Kustomize (K8s Manifest Overlays)

6) Deployment- & Release-Automation

Tools, die Rollouts (Staging → Prod) steuern:

Klassisches CD / Deployment Tools

  • Octopus Deploy (stark für .NET/Enterprise)
  • Spinnaker (Multi-Cloud, progressive delivery)
  • Harness (CD + Governance)
  • Cloud-native: AWS CodeDeploy, Azure Deployment/Release, Google Cloud Deploy

GitOps (besonders für Kubernetes)

  • Argo CD
  • Flux CD

GitOps: Git ist “Single Source of Truth” für Deployments; Cluster zieht gewünschten Zustand.

7) Infrastructure as Code (IaC) & Konfigurationsmanagement

Damit Infrastruktur genauso versioniert & getestet wird wie Code:

  • Terraform, Pulumi
  • AWS CloudFormation, AWS CDK
  • Azure Bicep, ARM Templates
  • Ansible (Config Mgmt), Chef/Puppet (eher klassisch)

8) Testing-Tools (Qualitätssicherung in der Pipeline)

CI/CD steht und fällt mit Automatisierung:

  • Unit/Integration: JUnit, NUnit, xUnit, pytest
  • API-Tests: Postman/Newman, REST Assured
  • E2E/UI: Playwright, Cypress, Selenium
  • Performance/Load: k6, JMeter, Gatling
  • Contract Tests: Pact

Tipp: Für stabile Pipelines lieber mehr Unit/Integration/API und gezielt E2E (weil E2E oft fragiler ist).

9) Code Quality, Security & Compliance (DevSecOps)

Automatische Gates vor dem Deploy:

Codequalität / Static Analysis

  • SonarQube/SonarCloud
  • ESLint, Pylint, Checkstyle, SpotBugs

SCA (Dependencies) & Vulnerability Scans

  • Dependabot (GitHub)
  • Snyk
  • OWASP Dependency-Check

SAST / Semgrep / CodeQL

  • Semgrep
  • CodeQL (GitHub Advanced Security)

Container & IaC Scans

  • Trivy, Grype
  • Checkov, tfsec

10) Secrets-Management & Policy

Wichtig für sichere CI/CD:

  • HashiCorp Vault
  • Azure Key Vault, AWS Secrets Manager, GCP Secret Manager
  • SOPS (verschlüsselte Secrets in Git)
  • Policy/Controls: OPA/Conftest, Kyverno (Kubernetes)

11) Monitoring, Logging, Tracing (Feedback nach dem Release)

CD ist erst “fertig”, wenn Observability steht:

  • Prometheus + Grafana (Metrics/Dashboards)
  • ELK/EFK Stack (Logs)
  • Datadog, New Relic
  • OpenTelemetry + Jaeger/Tempo (Tracing)
  • Cloud: Azure Monitor, CloudWatch, GCP Operations

12) Feature Flags & Progressive Delivery

Für sichere Releases:

  • LaunchDarkly
  • Unleash
  • Kubernetes Rollouts: Argo Rollouts, Flagger
  • Strategien: Canary, Blue/Green, Rolling, A/B

Mini-Orientierung: „Welche Tool-Kombi ist typisch?“

A) GitHub-zentriert

  • GitHub + GitHub Actions + GHCR + Terraform + Kubernetes/Helm + Argo CD + Sonar/Snyk/Trivy

B) GitLab-zentriert

  • GitLab + GitLab CI + GitLab Registry + Terraform + K8s + (optional) Argo/Flux

C) Microsoft/Enterprise

  • Azure DevOps Repos + Pipelines + Azure Artifacts + Bicep/Terraform + AKS + Key Vault + Azure Monitor

« Back to Glossary Index