DevOps mit GitOps – Methodenübersicht, GitOps-Tools und Vergleich mit Alternativen

GitOps ist ein moderner Ansatz zur Verwaltung von Infrastruktur und Anwendungsbereitstellungen unter Verwendung von Git als einzige Quelle der Wahrheit. Es nutzt die Versionskontrollfunktionen von Git, um den Prozess der Bereitstellung und Verwaltung von Anwendungen und Infrastrukturen zu automatisieren und zu optimieren, insbesondere in cloud-nativen Umgebungen.

Im Wesentlichen betrachtet GitOps den in Git definierten gewünschten Zustand Ihres Systems als autoritative Quelle, und automatisierte Tools stellen sicher, dass der tatsächliche Zustand des Systems mit diesem gewünschten Zustand übereinstimmt.

Hier ist eine Aufschlüsselung dessen, was es ist, wie es funktioniert, typische Workflows und seine Alternativen.

Für verwandte CI/CD-Workflows siehe GitHub Actions Cheatsheet – Standardstruktur und eine Liste der nützlichsten Actions für praktische Automatisierungsmuster.

Für einen breiteren Überblick über Entwicklertools und Workflows, siehe Entwicklertools: Der vollständige Leitfaden für moderne Entwicklungsworkflows

Was ist GitOps?

GitOps ist eine Methodik, die Git-Repositories verwendet, um Infrastruktur- und Anwendungskonfigurationen zu definieren und zu verwalten. Alle Änderungen werden durch Git-Commits und Pull-Requests vorgenommen, die dann von automatisierten Agenten (wie Argo CD oder Flux) automatisch auf die Infrastruktur angewendet werden.

Kernprinzipien:

• Git als einzige Quelle der Wahrheit
• Automatisierte Bereitstellung über Continuous Delivery (CD)
• Abgleich (Reconciliation): Sicherstellen, dass der tatsächliche Zustand mit dem gewünschten Zustand übereinstimmt
• Überprüfbare und versionierte Änderungen

Wie man GitOps verwendet

1. Konfigurationen definieren:

   • Verwenden Sie YAML oder JSON, um Ihre Infrastruktur zu definieren (z. B. Kubernetes-Manifests, Terraform-Dateien).

2. In Git speichern:

   • Pushen Sie Konfigurationsdateien in ein Git-Repository.

3. Bereitstellung automatisieren:

   • Verwenden Sie ein GitOps-Tool wie Argo CD oder Flux, um das Repository zu überwachen und Änderungen in Ihrer Umgebung anzuwenden.

4. Änderungen über Pull-Requests vornehmen:

   • Jede Aktualisierung erfolgt über einen Pull-Request. Sobald dieser gemergt wurde, wendet der GitOps-Agent die Änderungen automatisch an.

Typische GitOps-Workflows

• Anwendungsbereitstellung:

  • Entwickler aktualisieren die App-Konfiguration (z. B. Image-Version) → PR → Merge → GitOps-Tool stellt die Aktualisierung bereit.

• Infrastrukturverwaltung:

  • DevOps-Teams modifizieren den Infrastruktur-Code → PR → Merge → Infrastruktur wird über Tools wie Terraform oder Crossplane aktualisiert.

• Rollback:

  • Einen Commit in Git zurücksetzen → Das GitOps-Tool rollt automatisch auf den vorherigen Zustand zurück.

• Drift-Erkennung:

  • Wenn der Live-Zustand von Git abweicht, warnen GitOps-Tools oder führen einen automatischen Abgleich durch.

Beliebte GitOps-Tools

Argo CD

Argo CD ist ein deklaratives, auf GitOps basierendes Continuous-Delivery (CD)-Tool für Kubernetes. Es automatisiert die Anwendungsbereitstellung, indem es Git-Repositories mit Kubernetes-Clustern synchronisiert, um Konsistenz über Umgebungen hinweg sicherzustellen. Zu den wichtigsten Merkmalen gehören:

• Kubernetes-nativ: Für Kubernetes entwickelt, mit tiefer Integration zur Verwaltung deklarativer Konfigurationen.
• Deklarative Workflows: Verwendet Git als einzige Quelle der Wahrheit für Anwendungsdefinitionen, Konfigurationen und Umgebungen.
• Benutzerfreundliche Oberfläche: Bietet eine Web-Oberfläche für Echtzeit-Überwachung, Anwendungsmanagement und Visualisierung des Bereitstellungsstatus.

Argo CD fungiert als Controller, der kontinuierlich den tatsächlichen Zustand von Anwendungen mit dem in Git-Repositories definierten gewünschten Zustand abgleicht.

Wichtige Funktionen von Argo CD als GitOps-Tool Argo CD bietet eine robuste Sammlung von Funktionen, die speziell für GitOps-Workflows zugeschnitten sind:

Wie Argo CD GitOps-Prinzipien umsetzt Argo CD richtet sich an GitOps-Prinzipien durch folgende Mechanismen aus:

• Git als einzige Quelle der Wahrheit: Anwendungen, Konfigurationen und Umgebungen werden in Git-Repositories definiert.
• Automatisierter Abgleich (Reconciliation): Der Application Controller vergleicht kontinuierlich den tatsächlichen Zustand von Kubernetes-Ressourcen mit dem gewünschten Zustand in Git und behebt Abweichungen automatisch.
• Deklarative Konfiguration: Verwendet Kubernetes CRDs (z. B. Application, AppProject) zur Definition von Bereitstellungszielen und Synchronisierungsrichtlinien.
• Pull-basierte Synchronisation: Änderungen werden aus Git-Repositories abgerufen, um bereitgestellte Umgebungen mit gewünschten Zuständen abzugleichen.

Dieser Ansatz sorgt für Überprüfbarkeit, Nachvollziehbarkeit und Konsistenz über Umgebungen hinweg.

Anwendungsfälle und reale Anwendungen von Argo CD Argo CD wird in Produktionsumgebungen weit verbreitet eingesetzt für:

• Kubernetes-Bereitstellungen: Synchronisiert den Clusterzustand mit Git-Repositories für nahtlose Updates.
• CI/CD-Integration: Arbeitet mit CI-Pipelines (z. B. GitHub Actions, Jenkins), um Bereitstellungen und Rollbacks zu automatisieren.
• Sicherheit: Integriert Tools wie Sealed Secrets und SOPS für die Verwaltung verschlüsselter Geheimnisse.

Installationsmethoden:

• Kubectl: Leichte Einrichtung für grundlegende Anwendungsfälle.
• Helm: Empfohlen für Produktionsumgebungen, bietet granulare Kontrolle und HA-Konfigurationen.

Konfigurationsschritte:

1. Erstellen Sie einen Namespace (argocd) und wenden Sie Manifests über kubectl an.
2. Stellen Sie die Argo CD-Oberfläche mit kubectl port-forward bereit.
3. Registrieren Sie Git-Repositories und definieren Sie Application CRDs, die Quelle (Git-Repo) und Ziel (Kubernetes-Cluster/Namespace) angeben.

Tools für die Integration:

• Kustomize: Für umgebungsspezifische Konfigurationen (z. B. dev/staging/prod).
• Helm: Für Paketverwaltung und parametrisierte Bereitstellungen.

Best Practices für die Verwendung von Argo CD in GitOps-Workflows

1. Separate Konfigurations-Repositories: Speichern Sie Kubernetes-Manifests in einem separaten Git-Repository vom Anwendungssourcencode.
2. Verwendung von ApplicationSets: Automatisieren Sie die Bereitstellung parametrisierter Anwendungen über Cluster und Umgebungen hinweg.
3. Sichere Geheimnisse: Vermeiden Sie Klartext-Geheimnisse; verwenden Sie Sealed Secrets oder External Secrets Operator.
4. Überwachung und Audit: Verfolgen Sie Synchronisationsstatus, Diffs und Drifts unter Verwendung der eingebauten Überwachungsfunktionen von Argo CD und der Git-Historie.
5. Selbstheilung aktivieren: Konfigurieren Sie prune=true und selfHeal=true, um Drifts automatisch zu korrigieren.

Zukunftstrends und Entwicklung von Argo CD im GitOps-Ökosystem

• Erweiterte Multi-Cloud-Unterstützung: Ausweitung der Multi-Cluster- und Multi-Cloud-Fähigkeiten für hybride Umgebungen.
• Engere Integration mit IaC-Tools: Tiefere Integration mit Infrastructure-as-Code (IaC)-Plattformen wie Terraform und Pulumi.
• Erweiterte CI/CD-Fähigkeiten: Engere Kopplung mit CI-Tools (z. B. GitHub Actions) für End-to-End-Workflows.
• Verbesserte Beobachtbarkeit: Erweiterte Metriken, Alarmierung und Integration mit Observability-Plattformen wie Grafana und Prometheus.

Flux V2 für GitOps

Flux ist ein CNCF-graduiertes Open-Source-Tool, das für GitOps-basierte Automatisierung in Kubernetes-Umgebungen entwickelt wurde. Entwickelt von Weaveworks ermöglicht es Teams, Kubernetes-Cluster mit Git-Repositories zu synchronisieren, um sicherzustellen, dass Infrastrukturen und Anwendungszustände immer mit versionskontrollierten Definitionen übereinstimmen.

Wichtige Aspekte von Flux umfassen:

• GitOps-Operator: Flux fungiert als Kubernetes-Controller, der Git-Repositories kontinuierlich überwacht und Änderungen in Clustern anwendet.
• Leichtgewichtig und erweiterbar: Modulares Design ermöglicht Anpassungen (z. B. Aktivieren/Deaktivieren von Controllern wie Source, Kustomize oder Helm).
• CLI-zentrierter Workflow: Flux priorisiert Kommandozeilen-Schnittstellen (CLI) für Skripting und Automatisierung, obwohl Drittanbieter-GUIs (z. B. Weave GitOps) verfügbar sind.

Flux wird in cloud-nativen Umgebungen für seine Automatisierung, Sicherheit und Skalierbarkeit weithin adoptiert.

3. Wichtige Funktionen von Flux als GitOps-Tool
Flux bietet eine Reihe von Funktionen, die mit GitOps-Prinzipien übereinstimmen:

1. Git-gesteuerte Konfiguration:

   • Speichert Kubernetes-Manifests, Helm-Charts und Kustomize-Overlays in Git-Repositories.
   • Beispiel: Ein typisches Flux-Konfigurations-Repository enthält Verzeichnisse für namespaces.yaml, deployments.yaml und umgebungsspezifische Konfigurationen.

2. Kubernetes-Ressourcenverwaltung:

   • Überwacht kontinuierlich Git-Repositories und wendet Änderungen in Clustern über Abgleichsschleifen an.
   • Unterstützt Helm, Kustomize und OCI-Registries zur Verwaltung von Anwendungs- und Infrastrukturdefinitionen.

3. Automatisierte Image-Updates:

   • Erkennt neue Container-Image-Versionen in Registries (z. B. Docker Hub, Azure Container Registry) und aktualisiert Manifests in Git.

4. Sicherheit und Compliance:

   • Verwendet RBAC-Richtlinien für feingranulare Zugriffskontrolle.
   • Integriert sich mit Geheimnisverwaltungstools (z. B. SOPS, Sealed Secrets), um sensible Daten (z. B. API-Tokens) zu verschlüsseln.

5. Progressive Delivery:

   • Arbeitet mit Flagger zur Implementierung von Canary-Bereitstellungen, A/B-Tests und Blue-Green-Rollouts.

6. Multi-Cluster-Unterstützung:

   • Verwaltet mehrere Kubernetes-Cluster über Git-Repositories und ermöglicht konsistente Bereitstellungen über Umgebungen hinweg.

4. Wie Flux mit GitOps-Prinzipien übereinstimmt
Flux setzt GitOps-Prinzipien durch seine Architektur und Workflows vollständig um:

• Deklarativer Zustand: Alle Kubernetes-Ressourcen werden in Git definiert, was Nachvollziehbarkeit und Versionskontrolle sicherstellt.
• Kontinuierlicher Abgleich: Flux synchronisiert Cluster automatisch mit Git-Repositories und eliminiert manuelle kubectl apply-Befehle.
• Versionskontrolle: Änderungen werden über Pull-Requests vorgenommen, was Zusammenarbeit, Reviews und Genehmigungen ermöglicht.
• Automatisierung: Flux reduziert den operativen Aufwand, indem es Bereitstellungs-Pipelines von Code-Commits bis zu Cluster-Updates automatisiert.

Das Pull-basierte Modell von Flux (im Gegensatz zu push-basiertem CI/CD) verbessert die Sicherheit, indem es die Exposition gegenüber manuellen Interventionen minimiert.

Anwendungsfälle für Flux in realen Szenarien
Flux ist ideal für folgende Anwendungsfälle:

1. Automatisierte Kubernetes-Bereitstellungen:
   • Synchronisiert Clusterzustände mit Git-Repositories und sorgt für Konsistenz über dev, staging und Produktionsumgebungen.
2. Progressive Delivery:
   • Ermöglicht Canary-Rollouts mit Flagger für kontrollierte Bereitstellungen.
3. Multi-Cluster-Verwaltung:
   • Stellt Anwendungen über mehrere Kubernetes-Cluster hinweg bereit (z. B. AKS, EKS, Azure Arc).
4. CI/CD-Integration:
   • Arbeitet mit GitHub Actions, Jenkins und GitLab CI/CD zur Automatisierung von Test-, Build- und Bereitstellungs-Pipelines.
5. Infrastructure as Code (IaC):
   • Verwaltet Infrastruktur über Terraform oder Helm und richtet sich an GitOps-Prinzipien.

Beispiel: Ein FinTech-Unternehmen verwendet Flux, um Produktionsbereitstellungen zu automatisieren, Audit-Trails sicherzustellen und schnelle Rollbacks zu ermöglichen.

Installation:

• CLI: Installieren Sie über brew install fluxctl oder direkten Download.
• Helm:

  helm repo add fluxcd https://charts.fluxcd.io
  helm upgrade -i flux fluxcd/flux \
  --set git.url=git@github.com:your-username/your-repo \
  --namespace flux
  

Integration in CI/CD-Pipelines und Infrastruktur
Flux integriert sich nahtlos mit CI/CD-Tools:

• GitHub Actions: Löst Flux-Sync bei Git-Push-Ereignissen aus (siehe Codebeispiel).
• Jenkins: Automatisiert Test-, Build- und Bereitstellungs-Pipelines.
• GitLab CI/CD: Verwendet .gitlab-ci.yml, um Flux-Synchronisation auszulösen.

Infrastruktur-Integration:

• Terraform: Verwaltet Infrastructure-as-Code (IaC) über Flux.
• Prometheus: Überwacht Flux-Bereitstellungen mit Metriken und Alarmen.
• Open Policy Agent (OPA): Erzwingt Policy-as-Code für Kubernetes-Ressourcen.

Herausforderungen und Einschränkungen bei der Verwendung von Flux

• Sicherheitskomplexität: Die Verwaltung von Geheimnissen in Git erfordert Tools wie SOPS oder Sealed Secrets.
• Audit-Overhead: Erfordert strikte Durchsetzung der Git-Commit-Signierung und das Verbot von Force-Pushes.
• Versionsförderung: Umgebungsspezifische Konfigurationen (z. B. dev vs. production) benötigen sorgfältige Review-Prozesse.
• Reife der Tools: Die UI von Flux ist weniger ausgereift als die von Argo CD und erfordert die Abhängigkeit von Drittanbieter-Tools zur Überwachung.

Best Practices für die Implementierung von Flux

• Vermeiden Sie :latest-Tags: Verwenden Sie semantische Versionierung für Container-Images.
• Strukturieren Sie Git-Repositories logisch: Verwenden Sie Verzeichnisse wie /apps, /clusters und /environments.
• Überwachen Sie den Abgleichstatus: Verwenden Sie flux get all und Alarme für Echtzeit-Feedback.
• Aktivieren Sie RBAC: Implementieren Sie feingranulare Zugriffskontrolle für Flux und Kubernetes-Ressourcen.
• Integrieren Sie die Geheimnisverwaltung: Verwenden Sie SOPS oder HashiCorp Vault für verschlüsselte Geheimnisse.

Wichtige Erkenntnisse:

• Stärken: Automatisierung, deklarative Workflows und Integration in CI/CD-Pipelines.
• Schwächen: Sicherheitskomplexität, Audit-Overhead und begrenzte UI.
• Am besten geeignet für: Teams, die CLI-gesteuerte Automatisierung, Helm/Kustomize und Multi-Cluster-Verwaltung priorisieren.

Flux stimmt mit der Zukunft von GitOps überein, bei der Infrastruktur- und Anwendungsmanagement vollständig automatisiert, sicher und skalierbar sind. Seine kontinuierliche Evolution unter dem CNCF stellt seine Relevanz im DevOps-Ökosystem sicher.

GitOps mit Jenkins X

Jenkins X ist eine cloud-native, Open-Source CI/CD-Plattform, die die Bereitstellung von Anwendungen auf Kubernetes automatisiert. Sie richtet sich an GitOps-Prinzipien, die die Verwendung von Git-Repositories als einzige Quelle der Wahrheit für Infrastruktur- und Anwendungskonfigurationen betonen. Durch die Integration mit Kubernetes ermöglicht Jenkins X Teams, CI/CD-Pipelines, Bereitstellungen und Umgebungs-Förderungen über Git-basierte Workflows zu verwalten. Dieser Ansatz sorgt für Versionskontrolle, Überprüfbarkeit und Zusammenarbeit, was ihn zu einem robusten Werkzeug für moderne DevOps-Praktiken macht.

Jenkins X: Wichtige Funktionen und Architektur Jenkins X basiert auf Kubernetes und integriert Tekton, Helm und FluxCD, um eine umfassende CI/CD-Lösung bereitzustellen. Wichtige Funktionen umfassen:

• GitOps-Workflow: Verwendet Git-Repositories zur Verwaltung von Pipelines, Infrastruktur und Bereitstellungen.
• Umgebungs-Förderung: Automatisiert die Bereitstellung über Umgebungen (dev, staging, production) über vordefinierte Strategien.
• Pipeline-as-Code: Konfiguriert CI/CD-Pipelines mit YAML-Dateien (z. B. jenkins-x.yml) für Reproduzierbarkeit.
• Beobachtbarkeit (Observability): Integriert Prometheus und Grafana für Echtzeit-Überwachung und Protokollierung.

Die Architektur umfasst:

• Jenkins X CLI: Für Cluster-Erstellung (jx create cluster) und Projekt-Einrichtung (jx create quickstart).
• GitOps-Repository: Speichert Pipeline-Definitionen, Helm-Charts und Kubernetes-Manifests.
• Kubernetes-Integration: Stellt Anwendungen mit Helm-Charts bereit und verwaltet Umgebungen über FluxCD.

Beispiel:

pipelineConfig:
  pipelines:
    release:
      pipeline:
        stages:
          - name: Deploy
            steps:
              - script: kubectl apply -f kubernetes-manifests/

Jenkins X ist ein umfassendes GitOps-Tool, das cloud-native CI/CD-Workflows auf Kubernetes strafft. Durch die Ausrichtung an GitOps-Prinzipien stellt es Überprüfbarkeit, Automatisierung und Zusammenarbeit sicher, was es ideal für Organisationen macht, die DevOps und Microservices einführen. Seine opinionierte Workflows können jedoch für fortgeschrittene Anwendungsfälle Anpassungen erfordern. Da sich GitOps weiterentwickelt, ist Jenkins X gut positioniert, um sich mit aufkommenden Tools (z. B. Kustomize, Lens) zu integrieren und sich an Unternehmensumgebungen zu skalieren, was seine Rolle in modernen DevOps-Praktiken festigt.

Finale Einsicht: Jenkins X überbrückt die Lücke zwischen traditionellem CI/CD und GitOps und bietet eine kohärente Lösung für Teams, die Automatisierung, Beobachtbarkeit und Zusammenarbeit in Kubernetes-basierten Workflows suchen.

Weave GitOps

Weave GitOps ist ein Open-Source, cloud-natives Tool, das von Weaveworks entwickelt wurde, um die Bereitstellung und Verwaltung von Anwendungen auf Kubernetes zu automatisieren. Das Tool vereinfacht Continuous Delivery (CD), indem es Produktionsumgebungen mit in Git definierten gewünschten Zuständen abgleicht, was Konsistenz sicherstellt und manuelle Eingriffe reduziert. Weave GitOps integriert sich nahtlos mit Kubernetes, CI/CD-Pipelines und Infrastructure-as-Code (IaC)-Tools, was es zu einer beliebten Wahl für Teams macht, die GitOps-Praktiken einführen.

Architektur und Komponenten des Tools Weave GitOps ist als Kubernetes-natives Tool aufgebaut und nutzt Kubernetes-Controller und benutzerdefinierte Ressourcen (CRDs) für GitOps-Automatisierung. Wichtige Komponenten umfassen:

• GitOps-Operator: Ein Kubernetes-Operator, der Git-Repositories auf Änderungen überwacht und Updates im Cluster anwendet.
• Abgleichs-Engine (Reconciliation Engine): Vergleicht den tatsächlichen Clusterzustand mit gewünschten Zuständen in Git und löst Updates aus, um sie abzugleichen.
• UI und CLI: Bietet ein webbasiertes Dashboard zur Visualisierung von Bereitstellungen und eine CLI (gitops) zur Verwaltung von Workflows.
• Integrationsschicht: Verbindet sich mit externen Tools wie Flux, Helm, Kustomize und CI/CD-Plattformen für End-to-End-Automatisierung.

Die Architektur betont Skalierbarkeit, Sicherheit und Erweiterbarkeit, was sie sowohl für kleine Teams als auch für Unternehmensumgebungen geeignet macht.

Wichtige Anwendungsfälle und Szenarien Weave GitOps ist ideal für folgende Anwendungsfälle:

• Continuous Delivery (CD): Automatisiert Bereitstellungs-Pipelines für Anwendungen und sorgt für schnelle und zuverlässige Updates.
• Multi-Cluster und Multi-Cloud-Umgebungen: Verwaltet Bereitstellungen über hybride und Multi-Cloud-Kubernetes-Cluster hinweg.
• Enterprise-Infrastruktur-Automatisierung: Erzwingt Sicherheitsrichtlinien, Compliance und Governance über Policy-as-Code.
• Entwickler-Self-Service-Plattformen: Ermöglicht Entwicklern, Infrastruktur und Anwendungen zu verwalten, ohne tiefes Kubernetes-Wissen zu benötigen.
• Beobachtbarkeit und Fehlerbehebung: Liefert Echtzeit-Einblicke in Anwendungszustände und Abgleichsprozesse.

Installation

• Helm: Verwenden Sie das Weave GitOps Helm-Chart, um das Tool auf Kubernetes bereitzustellen.
• CLI: Installieren Sie über curl oder Homebrew (brew install weaveworks/tap/gitops).
• Bootstrap: Führen Sie gitops bootstrap aus, um die Plattform zu initialisieren.

Konfiguration

• Definieren Sie Anwendungsmanifests, Helm-Charts oder Kustomize-Konfigurationen in Git-Repositories.
• Verwenden Sie gitops apply, um Clusterzustände mit Git zu synchronisieren.
• Stellen Sie die UI über einen Kubernetes-Service und LoadBalancer bereit (z. B. auf AWS EKS).

Herausforderungen und Einschränkungen

• Lernkurve: Erfordert Vertrautheit mit Kubernetes, GitOps und IaC-Tools.
• Begrenzte Anpassung: Weniger modular als Flux, was für fortgeschrittene Benutzer ein Nachteil sein kann.
• Kleinere Community: Hat ein kleineres Ökosystem im Vergleich zu Argo CD oder Flux.
• Kommerzielle Funktionen: Enterprise-Funktionen (z. B. erweiterte Sicherheit, Multi-Cloud-Unterstützung) erfordern Lizenzen.

Weave GitOps ist ein robustes, unternehmensreifes Tool zur Automatisierung von Kubernetes-Bereitstellungen über GitOps. Es zeichnet sich durch Sicherheit, Multi-Cluster-Verwaltung und Integration in CI/CD-Pipelines aus, was es zu einer starken Wahl für Organisationen macht, die GitOps im großen Maßstab einführen. Obwohl es Konkurrenz von Flux und Argo CD erfährt, positionieren seine umfassende Funktionspalette, unternehmensweite Fähigkeiten und kommerzielle Unterstützung es als führende Lösung im GitOps-Ökosystem. Teams sollten ihre spezifischen Bedürfnisse und Workflows abwägen, wenn sie zwischen Weave GitOps, Flux oder Argo CD wählen.

Alternativen zu GitOps

Nützliche Links

• https://github.com/argoproj/argo-cd
• https://argo-cd.readthedocs.io/en/stable/
• https://argoproj.github.io/cd/
• https://fluxcd.io/
• https://github.com/fluxcd/flux2
• https://jenkins-x.io/
• https://github.com/weaveworks/weave-gitops
• https://docs.gitops.weaveworks.org/

Andere Links

• Gitea – Installation und Test
• Backup und Wiederherstellung des Gitea-Servers
• Verwendung von Gitea Actions zur Bereitstellung einer Hugo-Website auf AWS S3