👵🏻 ➖ 🤲🏾 Acelere la canalización de CI / CD con Kubernetes en Docker (KinD) 👩🏼‍🚀 ⛷️ 🤰🏼

En nuestro nuevo artículo traducido, tratamos de KinD con un ejemplo práctico.

La creación de un clúster de Kubernetes se vuelve más fácil con el tiempo. Hay varias soluciones llave en mano disponibles en el mercado, ¡y ahora nadie elige el camino difícil!

Vale la pena señalar que Minikube fue uno de los principales clústeres que los desarrolladores utilizaron para desarrollar y probar contenedores rápidamente. Si bien Minikube actualmente admite la agrupación en clústeres de varios sitios de forma experimental, aún no está disponible en la Disponibilidad general (GA).

En consecuencia, esto limita la capacidad de integrar y probar componentes, razón por la cual la mayoría de las organizaciones usan los servicios en la nube administrados de Kubernetes para esto.

Para integrar Kubernetes en la canalización de CI / CD (integración e implementación continuas) y realizar pruebas, necesita las siguientes herramientas: Terraform, según el proveedor de la nube y, por supuesto, una herramienta de CI / CD como Jenkins, GitLab o GitHub.

Para las grandes empresas con presupuestos suficientes, estas son buenas opciones, pero los desarrolladores a menudo buscan algo que les ayude a comenzar rápidamente. La implementación de un clúster de Kubernetes en la nube también lleva algo de tiempo (~ 10 minutos), lo que puede ser un obstáculo para los CI que necesitan obtener ensamblajes rápidamente.

Kubernetes en Docker o KinD es una implementación del enfoque Docker-in-Docker (DinD) para Kubernetes. Esta herramienta crea contenedores que actúan como hosts de Kubernetes y solo necesita instalar Docker en su máquina.

Le permite implementar un clúster de varios nodos en un par de minutos sin depender de otras herramientas o proveedores de la nube. Esto lo hace útil no solo para el desarrollo local, sino también para CI / CD.

Arquitectura KinD

Kubernetes en Docker usa el enfoque Docker-in-Docker (DinD) para ejecutar un clúster de Kubernetes. Ejecuta varios contenedores Docker que funcionan como hosts de Kubernetes. Los contenedores Docker montan un volumen docker.sock en Docker que se ejecuta en su máquina para comunicarse con el tiempo de ejecución del contenedor subyacente.

KinD ha pasado la prueba de cumplimiento y recibió el certificado CNCF. Utiliza Kubeadm para iniciar el clúster y también genera archivos de configuración de Kube para el usuario a través del cual administra su clúster, lo que le permite usar kubectl para interactuar con los clústeres. Otros componentes de Kubernetes, como Helm e Istio, también funcionan muy bien en clústeres de KinD.

La desventaja de KinD es que no funciona con los servicios LoadBalancer , por lo que tendrá que usar NodePort para reenviar sus servicios externamente.

Además, DinD no es actualmente la solución más segura, por lo tanto, use los clústeres de KinD solo en máquinas de desarrollo local y canalizaciones de CI / CD. ¡Nunca use KinD en un entorno de producción!

Instalación de KinD

KinD consiste en una sencilla utilidad de línea de comandos que puede descargar y poner en su camino. Luego puedes interactuar con KinD usando los comandos 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

Luego, puede crear su clúster con el siguiente comando:

kind create cluster --wait 10m

Este comando creará un clúster de un solo nodo. Pero si desea definir un clúster de varios nodos, puede usar un archivo de configuración de clúster similar al siguiente:

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

Luego, cree un clúster con un archivo de configuración usando el siguiente comando:

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

También puede crear clústeres con múltiples niveles de administración especificando múltiples roles en la sección de nodos.

Dado que KinD genera automáticamente un archivo de configuración de Kube, puede usar los comandos de kubectl como lo haría con otros clústeres.

Eliminar un clúster de KinD también es fácil. Ejecute el siguiente comando:

kind delete cluster

Empezando

Sin más preámbulos, descubramos en la práctica cómo la canalización de CI / CD usa KinD. Tomaremos Acciones de GitHub como nuestra herramienta de CI / CD porque es fácil de usar, no requiere ninguna infraestructura adicional y puede ser ejecutada por cualquier persona con una computadora portátil y una conexión a Internet. Creemos una

aplicación NGINX simple con la etiqueta "Hello World".

Realizamos las siguientes acciones:

Creamos una versión de desarrollo de la aplicación.
Comenzamos a probar los componentes en el clúster KinD.
Si la prueba tiene éxito, traducimos la imagen en versión y la enviamos a Docker Hub.

Las condiciones necesarias

Cuenta de GitHub
Cuenta de Docker Hub

Guía de inicio rápido

Bifurque este repositorio este repositorio.
Vaya al repositorio y cree dos secretos : DOCKER_USER y DOCKER_PW . Deben contener su nombre de usuario y contraseña de cuenta de Docker Hub, respectivamente.
Vaya a Acciones de GitHub y vuelva a ejecutar las tareas. Alternativamente, puede modificar el archivo README.md y ejecutarlo para activar la acción.

Versión larga

Echemos un vistazo al archivo build-pipeline.yml en Acciones de GitHub para entender cómo funciona:

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

La canalización de ensamblaje ejecuta tres tareas en secuencia:

La tarea build-docker-image crea una imagen de Docker para el desarrollo y la envía al Docker Hub en una compilación exitosa. En esta tarea, puede ejecutar sus pruebas unitarias.
La tarea kubernetes-component-test configura un clúster de KinD y ejecuta una prueba de componentes para la aplicación.
La tarea promover-y-empujar-docker-image extrae la imagen de desarrollo, la marca para liberarla y envía la versión a Docker Hub.

Echemos un vistazo al Dockerfile para entender qué crea:

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

El segundo paso es clave, ejecuta el script build-test.sh . Ahora echemos un vistazo al guión:

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

Qué hace el guión:

Descarga e instala las utilidades kind , kubectl y helm en el servidor de CI.
Crea un clúster de varios nodos mediante el archivo kind-config.yaml .
Docker docker build.
Docker KinD. KinD, Docker Hub.
deployment NodePort NodePortservice.
IP- , , «Hello World».
, KinD, «Component test successful» ( ) . , KinD .

Cuando comenzamos a trabajar con una canalización, GitHub Actions inicia automáticamente toda la canalización:

sin duda, esta es una mejora y una forma conveniente de realizar una integración e implementación continuas utilizando Docker y Kubernetes. Kubernetes en Docker no solo simplifica el desarrollo local, sino que también es una gran herramienta para CI / CD.

¡Gracias por leer el articulo! ¡Espero que lo hayan disfrutado!

Acelere la canalización de CI / CD con Kubernetes en Docker (KinD)