PricingLoginStart free
DevOps Bootcamp · Lektion

Mit Actions in Kubernetes deployen

Richten Sie Continuous Deployment in Kubernetes-Cluster ein und verwalten Sie Deployments und Services direkt über GitHub Actions.

Lektion 3 von 411 Schritte

Mit Actions in Kubernetes deployen ist eine kostenlose DevOps Bootcamp-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des DevOps Bootcamp-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der DevOps Bootcamp-Kurs umfasst insgesamt 4 Lektionen.

Einführung in K8s-CD mit Actions

Willkommen! In dieser Lektion lernen Sie, wie Sie mithilfe von GitHub Actions Continuous Deployment (CD) für Kubernetes-Cluster einrichten.

Automatisierte Deployments ermöglichen es, Änderungen an Ihrer Anwendung schnell und zuverlässig live zu schalten, ohne manuelle Schritte.

Wir behandeln die Authentifizierung, das Anwenden von Kubernetes-Manifesten und das Verwalten von Aktualisierungen.

Grundlagen des K8s-Deployments

Bevor wir deployen, rufen wir uns kurz zwei zentrale Kubernetes-Ressourcen ins Gedächtnis:

  • Deployments: Sie verwalten die Pods Ihrer Anwendung und stellen sicher, dass immer die gewünschte Anzahl an Replikaten ausgeführt wird. Sie kümmern sich um Updates und Rollbacks.
  • Services: Sie definieren, wie auf Ihre Anwendung zugegriffen wird (z. B. intern innerhalb des Clusters oder extern über einen LoadBalancer).

Unser Ziel ist es, YAML-Dateien, die diese Ressourcen definieren, aus GitHub Actions auf unseren Cluster anzuwenden.

Actions bei K8s authentifizieren

Für das Deployment muss Ihr GitHub-Actions-Workflow mit dem API-Server Ihres Kubernetes-Clusters kommunizieren.

Dafür ist eine Authentifizierung erforderlich. Die übliche Methode zur Authentifizierung bei Kubernetes ist eine kubeconfig-Datei.

Wir müssen den Inhalt dieser Datei sicher unserem Workflow-Runner zur Verfügung stellen.

Kubeconfig absichern

Die kubeconfig-Datei enthält vertrauliche Informationen wie Cluster-Endpunkte und Benutzerzugangsdaten. Sie muss geheim bleiben!

GitHub Actions stellt dafür Secrets bereit. Sie speichern den Inhalt Ihrer kubeconfig-Datei als Repository-Secret.

Wie erhalten Sie Ihre kubeconfig? Das hängt von Ihrem K8s-Anbieter ab (z. B. aws eks update-kubeconfig, gcloud container clusters get-credentials).

K8s-Kontext einrichten

Sobald Ihre kubeconfig als Secret gespeichert ist (nennen wir es KUBE_CONFIG_DATA), kann Ihr Workflow sie verwenden.

Üblicherweise wird der Inhalt des Secrets in eine temporäre Datei auf dem Runner geschrieben. Anschließend wird die Umgebungsvariable KUBECONFIG so gesetzt, dass sie auf diese Datei verweist.

Dadurch weiß kubectl, wo die Verbindungsdetails des Clusters zu finden sind.

<code>kubectl</code> in Workflows verwenden

kubectl ist das offizielle Befehlszeilentool für die Interaktion mit Kubernetes-Clustern. Auf GitHub-Actions-Runnern ist kubectl bereits vorinstalliert.

Nachdem Sie die kubeconfig eingerichtet haben, können Sie in den Workflow-Schritten beliebige kubectl-Befehle ausführen.

Sehen wir uns ein einfaches Beispiel an:

name: K8s Setup Test

on: [workflow_dispatch]

jobs:
  test-kubeconfig:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Set up Kubeconfig
        env:
          KUBE_CONFIG_DATA: ${{ secrets.KUBE_CONFIG_DATA }}
        run: |
          mkdir -p ~/.kube
          echo "$KUBE_CONFIG_DATA" > ~/.kube/config
          chmod 600 ~/.kube/config
          echo "KUBECONFIG=$HOME/.kube/config" >> $GITHUB_ENV

      - name: Verify kubectl access
        run: kubectl version --client

Einfaches K8s-Deployment-Manifest

Hier sehen Sie ein einfaches Kubernetes-Manifest mit einem Deployment und einem Service für eine "hello-world"-Anwendung. Diese Konfiguration soll Kubernetes ausführen.

In diesem Beispiel wird ein einfaches Nginx-Image verwendet, das auf Port 80 bereitgestellt wird.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-app-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: hello-app
  template:
    metadata:
      labels:
        app: hello-app
    spec:
      containers:
      - name: hello-app
        image: nginx:latest
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: hello-app-service
spec:
  selector:
    app: hello-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: LoadBalancer

Der vollständige Deployment-Workflow

Integrieren wir nun den Deployment-Schritt in einen Workflow. Nachdem Sie Ihr Container-Image erstellt und gepusht haben (wie in den vorherigen Lektionen), können Sie es deployen.

Dieser Workflow setzt voraus, dass Ihr kubeconfig-Secret eingerichtet ist und die Manifestdatei (z. B. k8s/deployment.yaml) in Ihrem Repository vorhanden ist.

name: Deploy to Kubernetes

on:
  push:
    branches:
      - main
  workflow_dispatch:

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Set up Kubeconfig
        env:
          KUBE_CONFIG_DATA: ${{ secrets.KUBE_CONFIG_DATA }}
        run: |
          mkdir -p ~/.kube
          echo "$KUBE_CONFIG_DATA" > ~/.kube/config
          chmod 600 ~/.kube/config
          echo "KUBECONFIG=$HOME/.kube/config" >> $GITHUB_ENV

      - name: Deploy application to K8s
        run: kubectl apply -f k8s/deployment.yaml

Ihre Anwendung aktualisieren

Eine der großen Stärken von kubectl apply ist seine Idempotenz. Wenn die in Ihrer YAML-Datei definierten Ressourcen bereits vorhanden sind, aktualisiert kubectl apply sie, statt neue Ressourcen zu erstellen.

Um eine neue Version Ihrer Anwendung zu deployen, aktualisieren Sie einfach den Image-Tag in Ihrer deployment.yaml und pushen Sie die Änderung. GitHub Actions wird anschließend ausgelöst, und Kubernetes führt ein Rolling Update durch. Dabei werden alte Pods schrittweise durch neue ersetzt, sodass die Ausfallzeit minimal bleibt.

Kurzer Test

Sie haben die wesentlichen Schritte kennengelernt, um eine Anwendung mithilfe von GitHub Actions in Kubernetes zu deployen.

Welche der folgenden Optionen zeigt die richtige Reihenfolge der Schritte für einen GitHub-Actions-Workflow zum Deployment eines Kubernetes-Manifests?

Beantworte es in der interaktiven Lektion

Zusammenfassung und nächste Schritte

Sehr gut! Sie haben gelernt, wie Sie mithilfe von GitHub Actions Continuous Deployment für Kubernetes einrichten.

  • Wir speichern vertrauliche kubeconfig-Daten in GitHub Secrets.
  • Workflows verwenden dieses Secret, um kubectl zu konfigurieren.
  • Mit kubectl apply -f werden K8s-Manifeste deployed oder aktualisiert.
  • Kubernetes führt bei angewendeten Änderungen Rolling Updates durch.

Diese leistungsstarke Kombination automatisiert Ihre Deployments und macht Ihren Entwicklungsprozess reibungsloser und schneller. Erkunden Sie weiterhin fortgeschrittene K8s-Funktionen!

Kostenlos starten

Lerne DevOps Bootcamp mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse
142
Lektionen
568
Kostenlos lernenDen vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Mit Actions in Kubernetes deployen“ kostenlos?

Ja — der vollständige Text von „Mit Actions in Kubernetes deployen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des DevOps Bootcamp-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der DevOps Bootcamp-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Mit Actions in Kubernetes deployen“?

Richten Sie Continuous Deployment in Kubernetes-Cluster ein und verwalten Sie Deployments und Services direkt über GitHub Actions. Du übst DevOps Bootcamp mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um DevOps Bootcamp zu starten?

Keine Vorkenntnisse erforderlich. DevOps Bootcamp auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Mit Actions in Kubernetes deployen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser DevOps Bootcamp-Lektion Code schreiben und ausführen?

Ja. Jede DevOps Bootcamp-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Docker-Images mit Actions erstellen
  2. Images in Registries pushen
  3. Mit Actions in Kubernetes deployen
  4. Helm-Charts und Kubernetes-Manifeste in CI/CD
← Zurück zu DevOps Bootcamp