CI/CD-Pipelines für Kubernetes mit GitLab CI

Moderne Softwareentwicklung erfordert schnelle Bereitstellungszyklen, Skalierbarkeit und Resilienz. Kubernetes hat sich als die bevorzugte Orchestrierungsplattform etabliert, die ein skalierbares Management containerisierter Anwendungen ermöglicht. In Kombination mit GitLab CI/CD-Pipelines werden Kubernetes-Bereitstellungen automatisiert, wiederholbar und zuverlässig.

Dieser Artikel untersucht die technischen Details zur Einrichtung von CI/CD-Pipelines für Kubernetes mit GitLab CI.

Voraussetzungen

Bevor Sie Ihre CI/CD-Pipeline konfigurieren, stellen Sie sicher, dass die folgenden Anforderungen erfüllt sind:

• GitLab-Konto: Zugang zu einem GitLab-Repository, in dem die CI/CD-Pipeline konfiguriert wird.
• Kubernetes-Cluster: Ein vorhandener Kubernetes-Cluster wie Minikube (für lokale Tests) oder verwaltete Cluster wie Google Kubernetes Engine (GKE), Amazon EKS oder Azure AKS.
• kubectl: Das Kubernetes-Befehlszeilenwerkzeug muss installiert und für die Interaktion mit dem Cluster konfiguriert sein.
• Helm (optional): Kubernetes-Paketmanager zum Bereitstellen und Verwalten von Anwendungen.
• GitLab Runner: Stellen Sie sicher, dass GitLab Runner installiert und mit Ihrem Projekt registriert ist, um CI/CD-Jobs auszuführen.
• Docker: Erforderlich zum Erstellen und Pushen von Container-Images in ein Container-Registry.

Einrichtung der Kubernetes-Integration mit GitLab

Kubernetes-Cluster verbinden

Die Integration von Kubernetes mit GitLab ermöglicht eine nahtlose Bereitstellung und Ressourcenverwaltung direkt aus Ihrer Pipeline. Befolgen Sie diese Schritte:

1. Gehen Sie zu Ihrem GitLab-Projekt-Dashboard.
2. Navigieren Sie zu Infrastruktur > Kubernetes-Cluster.
3. Klicken Sie auf Kubernetes-Cluster hinzufügen und verbinden Sie entweder einen vorhandenen Cluster oder erstellen Sie einen neuen mit Cloud-Anbietern.
4. Weisen Sie GitLab die erforderlichen Berechtigungen unter Verwendung des rollenbasierten Zugriffskontrollsystems (RBAC) zu.

RBAC-Konfiguration

RBAC definiert Zugriffsberechtigungen für Kubernetes-Ressourcen. Hier ist ein Beispiel für eine YAML-Konfiguration zur Einrichtung von RBAC:

apiVersion: v1

kind: ServiceAccount

metadata:

  name: gitlab-sa

  namespace: default

---

apiVersion: rbac.authorization.k8s.io/v1

kind: ClusterRoleBinding

metadata:

  name: gitlab-cluster-admin

roleRef:

  apiGroup: rbac.authorization.k8s.io

  kind: ClusterRole

  name: cluster-admin

subjects:

- kind: ServiceAccount

  name: gitlab-sa

  namespace: default

Konfiguration anwenden

Wenden Sie die YAML-Datei mit kubectl an:

kubectl apply -f gitlab-rbac.yaml

Token für die Authentifizierung generieren

Extrahieren Sie das für GitLab benötigte Servicekonto-Token:

kubectl -n default get secret $(kubectl -n default get sa/gitlab-sa -o jsonpath='{.secrets[0].name}') -o jsonpath='{.data.token}' | base64 --decode

Fügen Sie dieses Token in die Kubernetes-Konfigurationseinstellungen von GitLab ein.

Konfiguration der GitLab CI/CD-Pipeline

.gitlab-ci.yml definieren

Die GitLab CI-Konfigurationsdatei definiert Pipeline-Stufen, Variablen und Befehle. Hier ist eine Beispielkonfiguration:

image: docker:20.10

​

stages:

  - build

  - test

  - deploy

​

variables:

  KUBE_NAMESPACE: default

  KUBECONFIG: "/root/.kube/config"

  IMAGE_TAG: $CI_COMMIT_SHA

  REGISTRY: registry.gitlab.com/username/project

​

services:

  - docker:dind

​

before_script:

  - apk add --no-cache curl jq bash git

  - curl -LO https://storage.googleapis.com/kubernetes-release/release/v1.22.0/bin/linux/amd64/kubectl

  - chmod +x ./kubectl && mv ./kubectl /usr/local/bin/kubectl

  - echo "$KUBE_CONFIG" | base64 -d > $KUBECONFIG

  - chmod 600 $KUBECONFIG

​

build:

  stage: build

  script:

    - docker build -t $REGISTRY:$IMAGE_TAG .

    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY

    - docker push $REGISTRY:$IMAGE_TAG

​

unit-test:

  stage: test

  script:

    - echo "Running tests..."

    - ./run-tests.sh

​

deploy:

  stage: deploy

  script:

    - kubectl set image deployment/my-app my-app=$REGISTRY:$IMAGE_TAG -n $KUBE_NAMESPACE

  only:

    - main

Erklärung der Konfiguration 

• Stufen: Die Pipeline ist in Build-, Test- und Bereitstellungsstufen für eine modulare Ausführung unterteilt.
• Variablen: Umgebungsvaiablen wie Bild-Tags und Namespaces vereinfachen das Konfigurationsmanagement.
• before_script: Installiert Abhängigkeiten und richtet die Kubernetes-Authentifizierung ein.
• Bild-Markierung: Verwendet den Commit-SHA zur eindeutigen Identifizierung jeder Bildversion.
• Bereitstellung: Aktualisiert Kubernetes-Bereitstellung durch Festlegung des Container-Bildes.

Verwaltung von Secrets

GitLab CI unterstützt sichere Secrets-Verwaltung mithilfe von Variablen:

1. Gehe zu Einstellungen > CI/CD > Variablen.
2. Füge erforderliche Variablen wie KUBE_CONFIG, CI_REGISTRY_USER und CI_REGISTRY_PASSWORD hinzu.

Kodiere kubeconfig bevor du es als Variable hinzufügst:

cat ~/.kube/config | base64 | tr -d '\n'

Füge das Ergebnis als KUBE_CONFIG in GitLab hinzu.

Helm-Bereitstellung

Helm vereinfacht Kubernetes-Bereitstellungen mit wiederverwendbaren Charts. Beispiel Helm-Konfiguration:

apiVersion: v2

name: my-app

version: 1.0.0

appVersion: 1.0.0

​

image:

  repository: registry.gitlab.com/username/project

  tag: latest

​

service:

  type: ClusterIP

  port: 80

Füge Helm-Befehle zur Pipeline hinzu:

deploy:

  stage: deploy

  script:

    - helm upgrade --install my-app ./helm-chart --set image.tag=$IMAGE_TAG

Überwachungs- und Debugging-Tools

Überwache den Pipeline-Status in GitLab unter CI/CD > Pipelines. Verwende Tools wie:

• Prometheus und Grafana: Für Metriken und Visualisierung.
• Kubernetes-Dashboard: Cluster-Management.
• kubectl logs: Abrufen von Bereitstellungsprotokollen.

kubectl logs -f deployment/my-app

Schlussfolgerung

Dieser Artikel beschreibt die Konfiguration von CI/CD-Pipelines für Kubernetes mit GitLab CI. Er umfasst Voraussetzungen, YAML-Konfigurationen, Secrets-Verwaltung, Helm-Bereitstellungen und Überwachungstools. Mit diesem Setup können Entwickler containerisierte Anwendungen effizient und zuverlässig erstellen, testen und bereitstellen.