👩🏾‍🤝‍👨🏻 🙀 🤛🏼 Accélérez le pipeline CI / CD avec Kubernetes dans Docker (KinD) 🎧 🤲 👩🏽‍🚒

Dans notre nouvel article traduit, nous comprenons KinD avec un exemple pratique.

La création d'un cluster Kubernetes devient plus facile avec le temps. Il existe plusieurs solutions clé en main disponibles sur le marché, et maintenant personne ne choisit le chemin difficile!

Il convient de noter que Minikube était l'un des principaux clusters que les développeurs utilisaient pour développer et tester rapidement des conteneurs. Bien que Minikube prenne actuellement en charge le clustering multisite à titre expérimental, il n'est pas encore disponible dans l'accès général (GA).

Par conséquent, cela limite la capacité d'intégrer et de tester des composants, c'est pourquoi la plupart des organisations utilisent les services cloud gérés par Kubernetes pour cela.

Pour intégrer Kubernetes dans le pipeline CI / CD (intégration et déploiement continus) et effectuer des tests, vous avez besoin des outils suivants: Terraform, selon le fournisseur de cloud, et bien sûr, un outil CI / CD comme Jenkins, GitLab ou GitHub.

Pour les grandes entreprises disposant d'un budget suffisant, ce sont des options appropriées, mais les développeurs recherchent souvent quelque chose pour les aider à démarrer rapidement. Le déploiement d'un cluster Kubernetes dans le cloud prend également un certain temps (environ 10 minutes), ce qui peut être un obstacle pour les CI qui doivent obtenir des assemblys rapidement.

Kubernetes dans Docker ou KinD est une implémentation de l'approche Docker-in-Docker (DinD) pour Kubernetes. Cet outil crée des conteneurs qui agissent comme des hôtes Kubernetes et il vous suffit d'installer Docker sur votre machine.

Il vous permet de déployer un cluster multi-nœuds en quelques minutes sans dépendre d'autres outils ou fournisseurs de cloud. Cela le rend utile non seulement pour le développement local, mais aussi pour CI / CD.

Architecture KinD

Kubernetes dans Docker utilise l'approche Docker-in-Docker (DinD) pour exécuter un cluster Kubernetes. Il exécute plusieurs conteneurs Docker qui fonctionnent comme des hôtes Kubernetes. Les conteneurs Docker montent un volume docker.sock dans Docker s'exécutant sur votre machine pour communiquer avec l' environnement d' exécution du conteneur sous-jacent.

KinD a été testé pour sa conformité et a obtenu la certification CNCF. Il utilise Kubeadm pour amorcer le cluster et génère également des fichiers de configuration Kube pour l'utilisateur via lequel vous gérez votre cluster, ce qui vous permet d'utiliser kubectl pour interagir avec les clusters. D'autres composants Kubernetes comme Helm et Istio fonctionnent également très bien sur les clusters KinD.

L'inconvénient de KinD est qu'il ne fonctionne pas avec les services LoadBalancer , vous devrez donc utiliser NodePort pour transférer vos services en externe.

De plus, DinD n'est actuellement pas la solution la plus sécurisée, n'utilisez donc que des clusters KinD sur des machines de développement locales et des pipelines CI / CD. N'utilisez jamais KinD dans un environnement de production!

Installer KinD

KinD se compose d'un simple utilitaire de ligne de commande que vous pouvez télécharger et mettre dans votre chemin. Ensuite, vous pouvez interagir avec KinD en utilisant les commandes kind :

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

Ensuite, vous pouvez créer votre cluster à l'aide de la commande suivante:

kind create cluster --wait 10m

Cette commande créera un cluster à nœud unique. Mais si vous souhaitez définir un cluster à plusieurs nœuds, vous pouvez utiliser un fichier de configuration de cluster similaire à celui ci-dessous:

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

Créez ensuite un cluster avec un fichier de configuration à l'aide de la commande suivante:

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

Vous pouvez également créer des clusters avec plusieurs niveaux de gestion en spécifiant plusieurs rôles dans la section des nœuds.

Puisque KinD génère automatiquement un fichier de configuration Kube, vous pouvez utiliser les commandes kubectl comme avec d'autres clusters.

La suppression d'un cluster KinD est également facile. Exécutez la commande suivante:

kind delete cluster

Commencer

Sans plus tarder, voyons en pratique comment le pipeline CI / CD utilise KinD. Nous utiliserons GitHub Actions comme notre outil CI / CD car il est facile à utiliser, ne nécessite aucune infrastructure supplémentaire et peut être exécuté par toute personne disposant d'un ordinateur portable et d'une connexion Internet.

Créons une simple application NGINX intitulée "Hello World".

Nous effectuons les actions suivantes:

Nous créons une version de développement de l'application.
Nous commençons à tester les composants du cluster KinD.
Si le test réussit, nous traduisons l'image en version et la transmettons à Docker Hub.

Les conditions nécessaires

Compte GitHub
Compte Docker Hub

Guide de démarrage rapide

Répartissez ce référentiel sur ce référentiel.
Accédez au référentiel et créez deux secrets : DOCKER_USER et DOCKER_PW . Ils doivent contenir respectivement le nom d'utilisateur et le mot de passe de votre compte Docker Hub.
Accédez à Actions GitHub et réexécutez les tâches. Vous pouvez également modifier le fichier README.md et l'exécuter pour déclencher l'action.

Version longue

Jetons un coup d'œil au fichier build-pipeline.yml sur GitHub Actions pour comprendre comment cela fonctionne:

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

Le pipeline d'assemblage exécute trois tâches dans l'ordre:

La tâche build-docker-image crée une image Docker pour le développement et la pousse vers Docker Hub en cas de génération réussie. Dans cette tâche, vous pouvez exécuter vos tests unitaires.
La tâche kubernetes-component-test configure un cluster KinD et exécute un test de composant pour l'application.
La tâche promouvoir-et-pousser-docker-image extrait l'image de développement, la marque à libérer et pousse la version vers Docker Hub.

Jetons un coup d'œil au Dockerfile pour comprendre ce qu'il crée:

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

La deuxième étape est essentielle, elle exécute le script build-test.sh . Jetons maintenant un œil au script:

#! /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

Ce que fait le script:

Télécharge et installe les utilitaires kind , kubectl et helm sur le serveur CI.
Crée un cluster à plusieurs nœuds à l'aide du fichier kind-config.yaml .
Docker docker build.
Docker KinD. KinD, Docker Hub.
deployment NodePort NodePortservice.
IP- , , «Hello World».
, KinD, «Component test successful» ( ) . , KinD .

Lorsque nous commençons à travailler avec un pipeline, GitHub Actions démarre automatiquement l'ensemble du pipeline:

il s'agit sans aucun doute d'une amélioration et d'un moyen pratique d'effectuer une intégration et un déploiement continus à l'aide de Docker et Kubernetes. Kubernetes dans Docker simplifie non seulement le développement local, mais est également un excellent outil pour CI / CD.

Merci d'avoir lu l'article! J'espère que tu as aimé!

Accélérez le pipeline CI / CD avec Kubernetes dans Docker (KinD)