Pipelines CI/CD para Kubernetes usando GitLab CI

El desarrollo de software moderno exige ciclos de despliegue rápidos, escalabilidad y resiliencia. Kubernetes ha surgido como la plataforma de orquestación preferida, permitiendo la gestión de aplicaciones en contenedores escalables. Cuando se combina con los pipelines de CI/CD de GitLab, los despliegues de Kubernetes se vuelven automáticos, repetibles y fiables.

Este artículo explora los detalles técnicos de la configuración de pipelines de CI/CD para Kubernetes utilizando GitLab CI.

Requisitos previos

Antes de configurar tu pipeline de CI/CD, asegúrate de que se cumplan los siguientes requisitos:

• Cuenta de GitLab: Acceso a un repositorio de GitLab donde se configurará el pipeline de CI/CD.
• Cluster de Kubernetes: Un cluster de Kubernetes existente, como Minikube (para pruebas locales) o clusters gestionados como Google Kubernetes Engine (GKE), Amazon EKS o Azure AKS.
• kubectl: La herramienta de línea de comandos de Kubernetes debe estar instalada y configurada para la interacción con el cluster.
• Helm (opcional): Gestor de paquetes de Kubernetes para desplegar y gestionar aplicaciones.
• GitLab Runner: Asegúrate de que GitLab Runner esté instalado y registrado en tu proyecto para ejecutar trabajos de CI/CD.
• Docker: Necesario para construir y subir imágenes de contenedores a un registro de contenedores.

Configuración de la integración de Kubernetes con GitLab

Conectar el cluster de Kubernetes

Integrar Kubernetes con GitLab permite un despliegue y gestión de recursos sin problemas directamente desde tu pipeline. Sigue estos pasos:

1. Ve a tu panel de proyecto de GitLab.
2. Navega a Infraestructura > Clústeres de Kubernetes.
3. Haz clic en Añadir Clúster de Kubernetes y conecta un clúster existente o crea uno nuevo utilizando proveedores de nube.
4. Asigna los permisos adecuados a GitLab utilizando Control de Acceso Basado en Roles (RBAC).

Configuración de RBAC

RBAC define los permisos de acceso a los recursos de Kubernetes. A continuación se muestra un ejemplo de configuración YAML para configurar 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

Aplicar Configuración

Aplica el archivo YAML utilizando kubectl:

kubectl apply -f gitlab-rbac.yaml

Generar Token para Autenticación

Extrae el token de cuenta de servicio necesario para GitLab:

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

Pega este token en la configuración de Kubernetes de GitLab.

Configurando el Pipeline CI/CD de GitLab

Define .gitlab-ci.yml

El archivo de configuración de CI de GitLab define las etapas del pipeline, variables y comandos. A continuación se muestra un ejemplo de configuración:

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

Explicación de la Configuración

• Etapas: La tubería se divide en etapas de construcción, prueba y despliegue para una ejecución modular.
• Variables: Las variables de entorno como las etiquetas de imagen y los espacios de nombres simplifican la gestión de la configuración.
• before_script: Instala dependencias y configura la autenticación de Kubernetes.
• Etiquetado de Imágenes: Utiliza el SHA de confirmación para identificar de manera única cada versión de imagen.
• Despliegue: Actualiza el despliegue de Kubernetes configurando la imagen del contenedor.

Gestión de Secretos

GitLab CI admite la gestión segura de secretos utilizando variables:

1. Navega a Configuración > CI/CD > Variables.
2. Añade las variables requeridas como KUBE_CONFIG, CI_REGISTRY_USER y CI_REGISTRY_PASSWORD.

Codifica kubeconfig antes de añadirlo como variable:

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

Añade el resultado como KUBE_CONFIG en GitLab.

Despliegue de Helm

Helm simplifica los despliegues de Kubernetes con gráficos reutilizables. Ejemplo de configuración de Helm:

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

Añade comandos de Helm a la tubería:

deploy:

  stage: deploy

  script:

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

Herramientas de Monitoreo y Depuración

Monitorea el estado de la tubería en GitLab bajo CI/CD > Pipelines. Usa herramientas como:

• Prometheus y Grafana: Para métricas y visualización.
• Dashboard de Kubernetes: Gestión de clústeres.
• kubectl logs: Obtener registros de implementación.

kubectl logs -f deployment/my-app

Conclusión

Este artículo describe la configuración de tuberías CI/CD para Kubernetes con GitLab CI. Cubre los requisitos previos, configuraciones YAML, gestión de secretos, implementaciones de Helm y herramientas de monitoreo. Con esta configuración, los desarrolladores pueden construir, probar e implementar aplicaciones contenerizadas de manera eficiente y confiable.