👨🏿‍🎤 ⬜️ 👶🏾 Beschleunigen Sie die CI / CD-Pipeline mit Kubernetes in Docker (KinD) 👱 🤰🏻 👎🏼

In unserem neu übersetzten Artikel verstehen wir KinD anhand eines praktischen Beispiels.

Das Erstellen eines Kubernetes- Clusters wird mit der Zeit immer einfacher. Es gibt mehrere schlüsselfertige Lösungen auf dem Markt, und jetzt wählt niemand den schwierigen Weg!

Es ist erwähnenswert, dass Minikube einer der Hauptcluster war, mit denen Entwickler Container schnell entwickelten und testeten . Obwohl Minikube derzeit Multisite-Clustering auf experimenteller Basis unterstützt, ist es in der General Availability (GA) noch nicht verfügbar.

Infolgedessen wird die Möglichkeit zur Integration und zum Testen von Komponenten eingeschränkt, weshalb die meisten Unternehmen hierfür verwaltete Kubernetes-Cloud-Dienste verwenden.

Um Kubernetes in die CI / CD-Pipeline zu integrieren (kontinuierliche Integration und Bereitstellung) und Tests durchzuführen, benötigen Sie die folgenden Tools: Terraform, abhängig vom Cloud-Anbieter, und natürlich ein CI / CD-Tool wie Jenkins, GitLab oder GitHub.

Für große Unternehmen mit ausreichenden Budgets sind dies gute Optionen, aber Entwickler suchen häufig nach etwas, das ihnen hilft, schnell loszulegen. Die Bereitstellung eines Kubernetes-Clusters in der Cloud dauert ebenfalls einige Zeit (~ 10 Minuten). Dies kann ein Hindernis für CIs sein, die Assemblys schnell abrufen müssen.

Kubernetes in Docker oder KinD ist eine Implementierung des Docker-in-Docker-Ansatzes (DinD) für Kubernetes. Dieses Tool erstellt Container, die als Kubernetes-Hosts fungieren, und Sie müssen Docker nur auf Ihrem Computer installieren.

Sie können einen Cluster mit mehreren Knoten in wenigen Minuten bereitstellen, ohne von anderen Tools oder Cloud-Anbietern abhängig zu sein. Dies macht es nicht nur für die lokale Entwicklung nützlich, sondern auch für CI / CD.

KinD-Architektur

Kubernetes in Docker verwendet den Docker-in-Docker-Ansatz (DinD), um einen Kubernetes-Cluster auszuführen. Es werden mehrere Docker-Container ausgeführt, die als Kubernetes-Hosts fungieren. Docker-Container stellen ein Docker.sock- Volume in Docker bereit, das auf Ihrem Computer ausgeführt wird, um mit der zugrunde liegenden Container-Laufzeit zu kommunizieren.

KinD wurde auf Konformität getestet und hat die CNCF-Zertifizierung erhalten. Es verwendet Kubeadm zum Booten des Clusters und generiert Kube-Konfigurationsdateien für den Benutzer, über den Sie Ihren Cluster verwalten. So können Sie mit kubectl mit den Clustern interagieren. Andere Kubernetes-Komponenten wie Helm und Istio eignen sich auch hervorragend für KinD-Cluster.

Der Nachteil von KinD ist, dass es nicht mit LoadBalancer- Diensten funktioniert. Daher müssen Sie NodePort verwenden , um Ihre Dienste extern weiterzuleiten.

Darüber hinaus ist DinD derzeit nicht die sicherste Lösung. Verwenden Sie KinD-Cluster daher nur auf lokalen Entwicklungsmaschinen und CI / CD-Pipelines. Verwenden Sie KinD niemals in einer Produktionsumgebung!

KinD installieren

KinD besteht aus einem einfachen Befehlszeilenprogramm, das Sie herunterladen und in Ihren Pfad einfügen können. Dann können Sie mit KinD mit den interagieren Art Befehle :

sudo curl -sL https://kind.sigs.k8s.io/dl/v0.9.0/kind-linux-amd64 -o /usr/local/bin/kind
sudo chmod +x /usr/local/bin//kind

Anschließend können Sie Ihren Cluster mit dem folgenden Befehl erstellen:

kind create cluster --wait 10m

Dieser Befehl erstellt einen einzelnen Knotencluster. Wenn Sie jedoch einen Cluster mit mehreren Knoten definieren möchten, können Sie eine Cluster-Konfigurationsdatei verwenden, die der folgenden ähnelt:

# three node (two workers) cluster config
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
- role: worker
- role: worker

Erstellen Sie dann mit dem folgenden Befehl einen Cluster mit einer Konfigurationsdatei:

kind create cluster --wait 10m --config kind-config.yaml

Sie können auch Cluster mit mehreren Verwaltungsebenen erstellen, indem Sie im Abschnitt "Knoten" mehrere Rollen angeben.

Da KinD automatisch eine Kube-Konfigurationsdatei generiert, können Sie kubectl- Befehle wie bei anderen Clustern verwenden.

Das Entfernen eines KinD-Clusters ist ebenfalls einfach. Führen Sie den folgenden Befehl aus:

kind delete cluster

Anfangen

Lassen Sie uns in der Praxis ohne weiteres herausfinden, wie die CI / CD-Pipeline KinD verwendet. Wir werden GitHub-Aktionen als unser CI / CD-Tool verwenden, da es einfach zu verwenden ist, keine zusätzliche Infrastruktur erfordert und von jedem mit einem Laptop und einer Internetverbindung ausgeführt werden kann.

Erstellen wir eine einfache NGINX- Anwendung mit der Bezeichnung "Hello World".

Wir führen folgende Aktionen durch:

Wir erstellen eine Entwicklungsversion der Anwendung.
Wir beginnen mit dem Testen der Komponenten im KinD-Cluster.
Wenn der Test erfolgreich ist, übersetzen wir das Image in die Version und senden es an Docker Hub.

Die notwendigen Bedingungen

GitHub-Konto
Docker Hub-Konto

Schnellstartanleitung

Fork dieses Repository dieses Repository.
Gehen Sie zum Repository und erstellen Sie zwei Geheimnisse : DOCKER_USER und DOCKER_PW . Sie sollten Ihren Docker Hub-Benutzernamen bzw. Ihr Kontokennwort enthalten.
Gehen Sie zu GitHub-Aktionen und führen Sie die Aufgaben erneut aus. Alternativ können Sie die Datei README.md ändern und ausführen, um die Aktion auszulösen.

Lange Version

Schauen wir uns die Datei build-Pipeline.yml in GitHub Actions an, um zu verstehen, wie es funktioniert:

name: Docker Image CI

on: [push]
     # Environment variables available to all jobs and steps in this workflow
env: # Or as an environment variable
      docker_username: ${{ secrets.DOCKER_USER }}
      docker_password: ${{ secrets.DOCKER_PW }}

jobs:

  build-docker-image:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
      with:
        fetch-depth: 0
    - name: Build the Docker image
      run: docker build -t $docker_username/nginx:dev .
    - name: Login to Docker
      run: echo "$docker_password" | docker login -u "$docker_username" --password-stdin
    - name: Push the docker image
      run: docker push $docker_username/nginx:dev

  kubernetes-component-test:
    runs-on: ubuntu-latest
    needs: build-docker-image
    steps:
    - uses: actions/checkout@v2
      with:
        fetch-depth: 0
    - name: Run KIND Test
      run: sudo sh build-test.sh $docker_username
  
  promote-and-push-docker-image:
    runs-on: ubuntu-latest
    needs: kubernetes-component-test
    steps:
    - uses: actions/checkout@v2
      with:
        fetch-depth: 0
    - name: Pull the Docker image
      run: docker pull $docker_username/nginx:dev
    - name: Tag the Docker image
      run: docker tag $docker_username/nginx:dev $docker_username/nginx:release
    - name: Login to Docker
      run: echo "$docker_password" | docker login -u "$docker_username" --password-stdin
    - name: Push the docker image
      run: docker push $docker_username/nginx:release

Die Assembly-Pipeline führt drei Aufgaben nacheinander aus:

Die Build-Docker-Image- Task erstellt ein Docker-Image für die Entwicklung und überträgt es bei erfolgreicher Erstellung an den Docker Hub. In dieser Aufgabe können Sie Ihre Unit-Tests ausführen.
Die Aufgabe kubernetes-component-test richtet einen KinD-Cluster ein und führt einen Komponententest für die Anwendung aus.
Die Aufgabe " Promoter -and-Push-Docker-Image" ruft das Entwicklungsimage ab, markiert es zur Freigabe und überträgt die Freigabe an Docker Hub.

Werfen wir einen Blick auf die Docker-Datei, um zu verstehen, was sie erstellt:

FROM nginx
RUN echo 'Hello World' > /usr/share/nginx/html/index.html

Der zweite Schritt ist der Schlüssel. Er führt das Skript build-test.sh aus . Schauen wir uns nun das Skript an:

#! /bin/bash
docker_username=$1
set -xe
curl -sL https://kind.sigs.k8s.io/dl/v0.9.0/kind-linux-amd64 -o /usr/local/bin/kind
chmod 755 /usr/local/bin//kind
curl -sL https://storage.googleapis.com/kubernetes-release/release/v1.17.4/bin/linux/amd64/kubectl -o
chmod 755 /usr/local/bin//kubectl
curl -LO https://get.helm.sh/helm-v3.1.2-linux-amd64.tar.gz
tar -xzf helm-v3.1.2-linux-amd64.tar.gz
mv linux-amd64/helm /usr/local/bin/
rm -rf helm-v3.1.2-linux-amd64.tar.gz
kind version
kubectl version --client=true
helm version
kind create cluster --wait 10m --config kind-config.yaml
kubectl get nodes
docker build -t $docker_username/nginx:dev .
kind load docker-image $docker_username/nginx:dev
kubectl apply -f nginx-deployment.yaml
kubectl apply -f nginx-service.yaml
NODE_IP=$(kubectl get node -o wide|tail -1|awk {'print $6'})
NODE_PORT=$(kubectl get svc nginx-service -o go-template='{{range.spec.ports}}{{if .nodePort}}{{.node
sleep 60
SUCCESS=$(curl $NODE_IP:$NODE_PORT)
if [[ "${SUCCESS}" != "Hello World" ]];
then
 kind -q delete cluster
exit 1;
else
 kind -q delete cluster
echo "Component test succesful"
fi

Was das Skript macht:

Lädt die Dienstprogramme kind , kubectl und helm auf den CI-Server herunter und installiert sie .
Erstellt einen Cluster mit mehreren Knoten mithilfe der Datei kind-config.yaml .
Docker docker build.
Docker KinD. KinD, Docker Hub.
deployment NodePort NodePortservice.
IP- , , «Hello World».
, KinD, «Component test successful» ( ) . , KinD .

Wenn wir mit einer Pipeline arbeiten, startet GitHub Actions automatisch die gesamte Pipeline:

Dies ist zweifellos eine Verbesserung und eine bequeme Möglichkeit, eine kontinuierliche Integration und Bereitstellung mit Docker und Kubernetes durchzuführen. Kubernetes in Docker vereinfacht nicht nur die lokale Entwicklung, sondern ist auch ein großartiges Tool für CI / CD.

Vielen Dank für das Lesen des Artikels! Ich hoffe, dass es Ihnen gefallen hat!

Beschleunigen Sie die CI / CD-Pipeline mit Kubernetes in Docker (KinD)