Pipelines CI/CD per Kubernetes utilizzando GitLab CI

Lo sviluppo software moderno richiede cicli di distribuzione rapidi, scalabilità e resilienza. Kubernetes è emerso come la piattaforma di orchestrazione preferita, consentendo la gestione di applicazioni containerizzate scalabili. Quando combinato con i pipeline CI/CD di GitLab, i deployment di Kubernetes diventano automatizzati, ripetibili e affidabili.

Questo articolo esplora i dettagli tecnici per impostare pipeline CI/CD per Kubernetes utilizzando GitLab CI.

Requisiti

Prima di configurare il tuo pipeline CI/CD, assicurati che siano soddisfatti i seguenti requisiti:

• Account GitLab: Accesso a un repository GitLab dove verrà configurato il pipeline CI/CD.
• Cluster Kubernetes: Un cluster Kubernetes esistente come Minikube (per test locali) o cluster gestiti come Google Kubernetes Engine (GKE), Amazon EKS o Azure AKS.
• kubectl: Lo strumento da riga di comando Kubernetes deve essere installato e configurato per l’interazione con il cluster.
• Helm (opzionale): Gestore di pacchetti Kubernetes per distribuire e gestire applicazioni.
• GitLab Runner: Assicurati che GitLab Runner sia installato e registrato con il tuo progetto per eseguire i lavori CI/CD.
• Docker: Richiesto per costruire e inviare immagini di container a un registro di container.

Impostazione dell’integrazione di Kubernetes con GitLab

Collegare il Cluster Kubernetes

Integrare Kubernetes con GitLab consente un deployment e una gestione delle risorse senza soluzione di continuità direttamente dalla tua pipeline. Segui questi passaggi:

1. Vai alla dashboard del tuo progetto GitLab.
2. Naviga verso Infrastruttura > Cluster Kubernetes.
3. Clicca su Aggiungi Cluster Kubernetes e collega un cluster esistente o creane uno nuovo utilizzando fornitori di cloud.
4. Assegna le autorizzazioni appropriate a GitLab utilizzando il Controllo degli Accessi Basato sui Ruoli (RBAC).

Configurazione RBAC

RBAC definisce le autorizzazioni di accesso per le risorse Kubernetes. Di seguito è riportato un esempio di configurazione YAML per impostare 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

Applica Configurazione

Applica il file YAML utilizzando kubectl:

kubectl apply -f gitlab-rbac.yaml

Genera Token per l’Autenticazione

Estrai il token dell’account di servizio necessario per GitLab:

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

Incolla questo token nelle impostazioni di configurazione di Kubernetes di GitLab.

Configurare la Pipeline CI/CD di GitLab

Definisci .gitlab-ci.yml

Il file di configurazione CI di GitLab definisce le fasi della pipeline, le variabili e i comandi. Di seguito è riportato un esempio di configurazione:

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

Spiegazione della Configurazione

• Fasi: Il pipeline è diviso in fasi di build, test e deploy per l’esecuzione modulare.
• Variabili: Le variabili d’ambiente come i tag delle immagini e i namespace semplificano la gestione della configurazione.
• before_script: Installa le dipendenze e configura l’autenticazione di Kubernetes.
• Tag delle Immagini: Utilizza l’SHA del commit per identificare univocamente ciascuna versione dell’immagine.
• Deployment: Aggiorna il deployment di Kubernetes impostando l’immagine del contenitore.

Gestione delle Secret

GitLab CI supporta la gestione sicura delle secret utilizzando le variabili:

1. Vai su Impostazioni > CI/CD > Variabili.
2. Aggiungi le variabili richieste come KUBE_CONFIG, CI_REGISTRY_USER e CI_REGISTRY_PASSWORD.

Codifica kubeconfig prima di aggiungerlo come variabile:

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

Aggiungi il risultato come KUBE_CONFIG in GitLab.

Deployment con Helm

Helm semplifica i deployment di Kubernetes con chart riutilizzabili. Esempio di configurazione di 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

Aggiungi i comandi di Helm al pipeline:

deploy:

  stage: deploy

  script:

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

Strumenti di Monitoraggio e Debugging

Monitora lo stato del pipeline su GitLab in CI/CD > Pipelines. Utilizza strumenti come:

• Prometheus e Grafana: Per metriche e visualizzazioni.
• Kubernetes Dashboard: Gestione del cluster.
• kubectl logs: Recupera i log del deployment.

kubectl logs -f deployment/my-app

Conclusion

Questo articolo illustra la configurazione delle pipeline CI/CD per Kubernetes con GitLab CI. Si tratta dei prerequisiti, delle configurazioni YAML, della gestione delle credenziali, dei rilasci di Helm e degli strumenti di monitoraggio. Con questa configurazione, gli sviluppatori possono creare, testare e distribuire applicazioni containerizzate in modo efficiente e affidabile.