15 min de lecture

Objectifs d'apprentissage

À la fin de ce module, vous serez en mesure de:

  • Créer un workflow GitHub Actions qui teste TaskBoard, pousse les images Git-SHA vers le Private Container Registry et les déploie sur Managed Kubernetes
  • Mettre en œuvre le pipeline équivalent dans GitLab CI avec des étapes de build et de déploiement
  • Automatiser Terraform dans la CI : exécuter le plan à chaque pull request avec le plan en commentaire, et appliquer lors de la fusion vers `main`
  • Configurer les secrets du pipeline pour le jeton de l'API Cloud, les clés Object Storage, le jeton du registre et un kubeconfig limité à un espace de noms
  • Revenir en arrière sur un déploiement échoué avec `kubectl rollout undo` et récupérer l'état de Terraform, et extraire l'infrastructure de TaskBoard en modules Terraform réutilisables

Unité 3.3 : Pipelines CI/CD pour IONOS CLOUD

Introduction

Jusqu'à présent, vous avez exécuté chaque étape manuellement : terraform apply depuis votre ordinateur portable, docker push depuis votre shell, kubectl apply avec un kubeconfig d'administrateur. Cela fonctionne pour un seul développeur. Pour une équipe, toute modification de main doit passer par le même chemin examiné et reproductible, et aucun ordinateur portable ne doit détenir les identifiants de production.

Dans cette unité, vous automatisez les deux volets de TaskBoard. Le pipeline applicatif construit, teste, pousse et déploie. Le pipeline d'infrastructure planifie sur les pull requests et applique lors de la fusion. Vous stockez chaque identifiant dans le coffre-fort de secrets du système CI, choisissez une stratégie de déploiement, pratiquez les retours arrière et transformez le Terraform de TaskBoard en modules que votre équipe peut réutiliser. Dans le Code Lab, vous créez un pipeline GitHub Actions qui déploie TaskBoard à chaque push vers main.

1. Conception du pipeline

TaskBoard utilise deux pipelines avec des déclencheurs et des identifiants différents :

Pipeline Déclencheur Étapes Identifiants
Application Push vers main test, build, push image, deploy Jeton de push du registre, kubeconfig du déploiement
Infrastructure Demande de tirage / fusion terraform plan, terraform apply IONOS_TOKEN, clés Object Storage pour l'état

Gardez-les séparés. Le pipeline d'application n'a jamais besoin du jeton Cloud API, de sorte qu'une étape de build compromise ne peut pas créer ou supprimer des ressources. Le pipeline d'infrastructure n'a jamais besoin du kubeconfig.

1.1 Inventaire des secrets

IONOS_TOKEN            Cloud API bearer token (infrastructure pipeline only)
AWS_ACCESS_KEY_ID      Object Storage Access Key for the Terraform state bucket
AWS_SECRET_ACCESS_KEY  Object Storage Secret Key for the Terraform state bucket
CR_HOST                Registry hostname (Unit 3.1)
CR_USERNAME            Push token username
CR_PASSWORD            Push token password
KUBECONFIG_DEPLOYER    Kubeconfig of the taskboard-deployer service account (Unit 3.2)

Générez IONOS_TOKEN pour un utilisateur CI dédié disposant uniquement des privilèges nécessaires à l'infrastructure, et définissez un ttl explicite, comme dans l'unité 1.1. Le jeton de poussée du registre de l'unité 3.1 porte pull et push. Object Storage s'authentifie avec une Access Key et une Secret Key, et non avec le jeton bearer, de sorte que le backend d'état a besoin de sa propre paire.

1.2 Un Kubeconfig pour le pipeline

Le kubeconfig de l'API donne un accès complet au cluster. Pour la CI, construisez-en un pour le compte de service taskboard-deployer de l'unité 3.2 :

kubectl -n taskboard apply -f - <<'EOF'
apiVersion: v1
kind: Secret
metadata:
  name: taskboard-deployer-token
  annotations:
    kubernetes.io/service-account.name: taskboard-deployer
type: kubernetes.io/service-account-token
EOF

SA_TOKEN="$(kubectl -n taskboard get secret taskboard-deployer-token -o jsonpath='{.data.token}' | base64 -d)"
SERVER="$(kubectl config view --raw -o jsonpath='{.clusters[0].cluster.server}')"
CA="$(kubectl config view --raw -o jsonpath='{.clusters[0].cluster.certificate-authority-data}')"

kubectl config --kubeconfig=deployer.yaml set-cluster taskboard --server="$SERVER"
kubectl config --kubeconfig=deployer.yaml set clusters.taskboard.certificate-authority-data "$CA"
kubectl config --kubeconfig=deployer.yaml set-credentials deployer --token="$SA_TOKEN"
kubectl config --kubeconfig=deployer.yaml set-context taskboard --cluster=taskboard --user=deployer --namespace=taskboard
kubectl config --kubeconfig=deployer.yaml use-context taskboard

Stockez deployer.yaml encodé en base64 sous forme de KUBECONFIG_DEPLOYER et supprimez le fichier local. Si vous définissez api_subnet_allow_list sur le cluster, l'adresse de trafic sortant de l'agent d'exécution doit y être incluse, sinon kubectl ne peut pas atteindre le serveur API.

2. GitHub Actions : le pipeline d'application

# .github/workflows/deploy.yml
name: deploy
on:
  push:
    branches: [main]

concurrency:
  group: deploy-production
  cancel-in-progress: false

jobs:
  build-deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Test
        run: |
          pip install -r api/requirements.txt -r api/requirements-dev.txt
          pytest api/tests

      - name: Log in to the registry
        env:
          CR_HOST: ${{ secrets.CR_HOST }}
          CR_USERNAME: ${{ secrets.CR_USERNAME }}
          CR_PASSWORD: ${{ secrets.CR_PASSWORD }}
        run: echo "$CR_PASSWORD" | docker login "$CR_HOST" --username "$CR_USERNAME" --password-stdin

      - name: Build and push
        env:
          CR_HOST: ${{ secrets.CR_HOST }}
        run: |
          SHA="${GITHUB_SHA::12}"
          for svc in api web; do
            docker build -t "$CR_HOST/taskboard/$svc:$SHA" "$svc/"
            docker push "$CR_HOST/taskboard/$svc:$SHA"
          done

      - name: Deploy to MKS
        env:
          CR_HOST: ${{ secrets.CR_HOST }}
          KUBECONFIG_DEPLOYER: ${{ secrets.KUBECONFIG_DEPLOYER }}
        run: |
          echo "$KUBECONFIG_DEPLOYER" | base64 -d > "$RUNNER_TEMP/kubeconfig"
          export KUBECONFIG="$RUNNER_TEMP/kubeconfig"
          SHA="${GITHUB_SHA::12}"
          kubectl set image deploy/taskboard-api api="$CR_HOST/taskboard/api:$SHA"
          kubectl set image deploy/taskboard-web web="$CR_HOST/taskboard/web:$SHA"
          kubectl rollout status deploy/taskboard-api --timeout=5m
          kubectl rollout status deploy/taskboard-web --timeout=5m

Le groupe concurrency ne permet qu'un seul déploiement à la fois, et rollout status marque la tâche comme échouée si les nouveaux pods ne passent pas à l'état prêt. kubectl set image ne modifie que l'image ; les manifests eux-mêmes restent dans Git et sont appliqués lorsqu'ils changent. La publication des deux images de manière séquentielle maintient un seul runner bien en deçà des limites par client du registre, soit 100 connexions simultanées et 60 requêtes par seconde.

3. GitLab CI : le pipeline équivalent

# .gitlab-ci.yml
stages: [test, build, deploy]

variables:
  SHA: $CI_COMMIT_SHORT_SHA

test:
  stage: test
  image: python:3.12-slim
  script:
    - pip install -r api/requirements.txt -r api/requirements-dev.txt
    - pytest api/tests

build:
  stage: build
  image: docker:27
  services: [docker:27-dind]
  before_script:
    - echo "$CR_PASSWORD" | docker login "$CR_HOST" --username "$CR_USERNAME" --password-stdin
  script:
    - for svc in api web; do docker build -t "$CR_HOST/taskboard/$svc:$SHA" "$svc/"; docker push "$CR_HOST/taskboard/$svc:$SHA"; done
  rules:
    - if: $CI_COMMIT_BRANCH == "main"

deploy:
  stage: deploy
  image: alpine:3.20
  resource_group: production
  before_script:
    - apk add --no-cache curl
    - curl -sLo /usr/local/bin/kubectl "https://dl.k8s.io/release/v1.34.0/bin/linux/amd64/kubectl" && chmod +x /usr/local/bin/kubectl
    - echo "$KUBECONFIG_DEPLOYER" | base64 -d > /tmp/kubeconfig
  script:
    - export KUBECONFIG=/tmp/kubeconfig
    - kubectl set image deploy/taskboard-api api="$CR_HOST/taskboard/api:$SHA"
    - kubectl rollout status deploy/taskboard-api --timeout=5m
  rules:
    - if: $CI_COMMIT_BRANCH == "main"

resource_group est l'équivalent GitLab du groupe concurrency de GitHub. Définissez CR_PASSWORD et KUBECONFIG_DEPLOYER en tant que variables masquées et protégées. Maintenez la version kubectl à une version mineure près de celle de votre cluster.

4. Terraform dans CI/CD

4.1 Plan sur la demande d'extraction, application lors de la fusion

# .github/workflows/infra.yml
name: infra
on:
  pull_request:
    paths: ["infra/**"]
  push:
    branches: [main]
    paths: ["infra/**"]

concurrency:
  group: terraform-production
  cancel-in-progress: false

permissions:
  contents: read
  pull-requests: write

jobs:
  terraform:
    runs-on: ubuntu-latest
    defaults:
      run:
        working-directory: infra
    env:
      IONOS_TOKEN: ${{ secrets.IONOS_TOKEN }}
      AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
      AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
    steps:
      - uses: actions/checkout@v4
      - uses: hashicorp/setup-terraform@v3
        with:
          terraform_wrapper: false
      - run: terraform init -input=false
      - run: terraform plan -input=false -no-color -out=tfplan
      - name: Comment the plan
        if: github.event_name == 'pull_request'
        env:
          GH_TOKEN: ${{ github.token }}
        run: |
          terraform show -no-color tfplan > plan.txt
          gh pr comment ${{ github.event.pull_request.number }} --body-file plan.txt
      - name: Apply
        if: github.event_name == 'push'
        run: terraform apply -input=false tfplan

Le fournisseur lit IONOS_TOKEN depuis l'environnement, et le backend s3 de l'unité 1.2 lit les clés Object Storage depuis AWS_ACCESS_KEY_ID et AWS_SECRET_ACCESS_KEY. Le groupe de concurrence terraform-production sérialise les exécutions, ce qui est le comportement par défaut sûr tant que vous n'avez pas vérifié le verrouillage de l'état par rapport à votre bucket. Conservez le fournisseur épinglé à 6.7.39 et committez .terraform.lock.hcl, afin que le plan sur la pull request et l'application sur main utilisent la même version.

Chaque application attend les requêtes asynchrones IONOS CLOUD. Un cluster ou un pool de nœuds peut prendre beaucoup de temps, il ne faut donc pas réduire le timeouts du fournisseur pour la CI. Si une échec se produit à mi-parcours, l'état contient déjà les ressources terminées ; relancez le pipeline après avoir corrigé la cause.

4.2 Gestion de plusieurs environnements

Attribuez à chaque environnement son propre état key et son propre travail de workflow, par exemple dev/terraform.tfstate et prod/terraform.tfstate. Protégez le travail de production avec un environnement GitHub qui exige un examinateur, afin qu'une simple fusion ne puisse pas modifier la production.

5. Stratégies de déploiement et retour arrière

5.1 Mise à jour progressive et recréation

spec:
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0

RollingUpdate est la valeur par défaut de Kubernetes : les nouveaux pods démarrent avant l'arrêt des anciens, et avec maxUnavailable: 0, la capacité ne diminue jamais. Recreate arrête d'abord tous les anciens pods, ce qui n'est nécessaire que lorsque deux versions ne peuvent pas fonctionner côte à côte, par exemple lors d'une modification du schéma de base de données qui casse l'ancienne version. Les déploiements canary et blue-green nécessitent soit un second Deployment derrière le même Service avec moins de répliques, soit un contrôleur tel qu'Argo Rollouts ; l'unité 5.3 aborde GitOps avec ArgoCD.

5.2 Revenir en arrière sur l'application

kubectl rollout history deploy/taskboard-api
kubectl rollout undo deploy/taskboard-api
kubectl rollout undo deploy/taskboard-api --to-revision=3

Chaque image étant associée à une étiquette Git SHA, un retour arrière restaure une compilation connue. Une étiquette mobile telle que latest ferait pointer la révision précédente vers la même image défectueuse.

5.3 Récupération de l'état Terraform

L'unité 2.4 a activé la gestion des versions sur le bucket d'état. Un état corrompu ou écrasé par erreur peut être restauré à partir d'une version antérieure :

EP="https://s3.eu-central-3.ionoscloud.com"
aws s3api list-object-versions --endpoint-url "$EP" \
  --bucket taskboard-tfstate-7f3a --prefix prod/terraform.tfstate
aws s3api get-object --endpoint-url "$EP" --bucket taskboard-tfstate-7f3a \
  --key prod/terraform.tfstate --version-id "<version-id>" restored.tfstate
terraform state push restored.tfstate
terraform plan

Arrêtez d'abord tous les pipelines. Après la poussée, terraform plan affiche la différence entre l'état restauré et l'infrastructure réelle ; résolvez-la à l'aide d'imports (Unité 1.2) avant la prochaine application.

6. Modules Terraform pour TaskBoard

À mesure que TaskBoard se développe, les mêmes blocs se répètent pour chaque environnement. Extraites-les en modules :

infra/
  modules/
    mks-cluster/
      main.tf        # ionoscloud_k8s_cluster, ionoscloud_k8s_node_pool
      variables.tf
      outputs.tf
  envs/
    dev/main.tf
    prod/main.tf
# modules/mks-cluster/variables.tf
variable "name"          { type = string }
variable "datacenter_id" { type = string }
variable "lan_id"        { type = string }
variable "k8s_version"   { type = string }
variable "node_count" {
  type    = number
  default = 2
}

# modules/mks-cluster/outputs.tf
output "cluster_id" { value = ionoscloud_k8s_cluster.this.id }
# envs/prod/main.tf
module "mks" {
  source        = "git::https://git.example.com/platform/tf-modules.git//mks-cluster?ref=v1.2.0"
  name          = "taskboard-prod"
  datacenter_id = ionoscloud_datacenter.taskboard.id
  lan_id        = ionoscloud_lan.app.id
  k8s_version   = var.k8s_version
  node_count    = 3
}

Un module déclare ses entrées sous forme de variables et n'expose que les sorties nécessaires à d'autres codes. Fixez les modules à une étiquette Git à l'aide de ?ref=, de la même manière que vous fixez le fournisseur, et publiez les modifications sous forme de nouvelles étiquettes. Placez le bloc required_providers avec la source ionoscloud dans chaque module afin qu'il indique le fournisseur avec lequel il a été testé.

Fiche de référence rapide de l'API

Points de terminaison API clés pour le sujet de cette unité :

Méthode Point de terminaison Description
GET https://api.ionos.com/auth/v1/tokens/generate?ttl=<seconds> Émettre le jeton d'accès CI
GET /k8s/{k8sClusterId}/kubeconfig Télécharger le kubeconfig administrateur pour la configuration
GET /requests/{requestId}/status Interroger une requête asynchrone
POST https://api.ionos.com/containerregistries/registries/{registryId}/tokens Créer un jeton de registre pour un pipeline

URL de base : https://api.ionos.com/cloudapi/v6 Authentification : Authorization: Bearer <token>

Atelier de code

Objectif : Créer un pipeline GitHub Actions qui teste TaskBoard, pousse les images Git-SHA vers le registre et les déploie sur MKS à chaque push vers main, puis effectue un retour arrière d'une version défectueuse.

Prérequis :

  • Le registre et le jeton de push de l'Unité 3.1
  • Le cluster MKS, l'espace de noms taskboard, le compte de service deployer et les Deployments en cours d'exécution de l'Unité 3.2
  • Un dépôt GitHub contenant TaskBoard et le CLI gh

Étape 1 : Créer le kubeconfig du deployer

Exécutez les commandes de la section 1.2 avec le kubeconfig administrateur.

KUBECONFIG=deployer.yaml kubectl auth can-i update deployments
KUBECONFIG=deployer.yaml kubectl auth can-i create namespaces

Sortie attendue :

yes
no

Étape 2 : Stocker les secrets

gh secret set CR_HOST --body "$CR_HOST"
gh secret set CR_USERNAME --body "taskboard-ci-push"
gh secret set CR_PASSWORD < ci-push.pass
gh secret set KUBECONFIG_DEPLOYER --body "$(base64 -w0 deployer.yaml)"
rm deployer.yaml
gh secret list

Sortie attendue :

CR_HOST              Updated ...
CR_PASSWORD          Updated ...
CR_USERNAME          Updated ...
KUBECONFIG_DEPLOYER  Updated ...

Étape 3 : Ajouter le flux de travail

Enregistrez le flux de travail de la section 2 sous le nom .github/workflows/deploy.yml, puis effectuez un commit et une opération push.

git add .github/workflows/deploy.yml
git commit -m "ci: deploy TaskBoard to MKS"
git push origin main
gh run watch

Sortie attendue :

✓ build-deploy
  ✓ Test
  ✓ Build and push
  ✓ Deploy to MKS

Étape 4 : Vérifier l'image en cours d'exécution

kubectl -n taskboard get deploy taskboard-api -o jsonpath='{.spec.template.spec.containers[0].image}'
git rev-parse --short=12 HEAD

Sortie attendue :

<registry-hostname>/taskboard/api:<sha>
<sha>

Étape 5 : Publier une version défectueuse

Modifiez le chemin de la sonde de disponibilité dans l'API afin qu'elle renvoie 500, puis effectuez un commit et une opération push.

git commit -am "break health check" && git push origin main
gh run watch

Sortie attendue :

X Deploy to MKS
error: timed out waiting for the condition

Étape 6 : Revenir en arrière

kubectl -n taskboard rollout undo deploy/taskboard-api
kubectl -n taskboard rollout status deploy/taskboard-api

Sortie attendue :

deployment.apps/taskboard-api rolled back
deployment "taskboard-api" successfully rolled out

Liste de contrôle de validation :

  • [ ] Une poussée vers main exécute les tests, pousse les deux images et met à jour les Deployments
  • [ ] L'étiquette de l'image en cours d'exécution correspond au SHA de l'engagement
  • [ ] Un déploiement en échec provoque l'échec du pipeline, et rollout undo restaure le service
  • [ ] Aucune information d'identification n'est stockée dans le dépôt

Nettoyage :

git revert --no-edit HEAD && git push origin main

Conservez le cluster pour l'unité 3.4 et le module 5, ou exécutez terraform destroy à partir de l'unité 3.2.

Pièges courants

Erreurs de développement à éviter concernant le sujet de cette unité :

  1. Deux exécutions Terraform simultanées

    • Problème : Deux fusions effectuées à court intervalle déclenchent deux applications, et l'une d'elles échoue ou laisse l'état incohérent.
    • Cause : Les deux exécutions lisent et écrivent le même objet d'état dans le bucket.
    • Correction : Sérialiser les exécutions à l'aide d'un groupe concurrency (GitHub) ou d'un resource_group (GitLab) par environnement, et n'appliquer que le tfplan qui a été examiné.
  2. Identifiants qui expirent silencieusement

    • Problème : Le pipeline fonctionnait depuis des semaines, puis chaque exécution échoue avec 401 sur l'API Cloud ou sur docker login.
    • Cause : Le jeton d'accès a atteint sa ttl, ou le jeton du registre a atteint sa date d'expiration et a été supprimé.
    • Correction : Noter chaque date d'expiration à côté du secret, effectuer la rotation avant celle-ci, et créer le jeton de registre de remplacement avant de supprimer l'ancien.
  3. kubeconfig administrateur dans la CI

    • Problème : Une étape de compilation compromise supprime des espaces de noms ou lit tous les secrets du cluster.
    • Cause : Le pipeline utilise le kubeconfig de l'API, qui dispose d'un accès complet au cluster.
    • Correction : Utiliser le kubeconfig taskboard-deployer limité à l'espace de noms de la section 1.2, et ne pas inclure le kubeconfig administrateur dans la CI.

Résumé

Vous pouvez désormais publier TaskBoard uniquement via l'examen du code. Le pipeline de l'application teste, construit des images Git-SHA, les pousse vers le Private Container Registry et les déploie sur MKS avec un compte limité à un espace de noms. Le pipeline d'infrastructure publie le plan Terraform sur chaque demande d'extraction et l'applique lors de la fusion, une exécution à la fois. Vous pouvez annuler une publication, restaurer une version antérieure de l'état et partager l'infrastructure sous forme de modules versionnés.

Points clés :

  • Séparez les pipelines de l'application et de l'infrastructure afin que chacun ne détienne que les identifiants nécessaires
  • Utilisez IONOS_TOKEN pour Terraform, une paire Access Key et Secret Key pour le backend d'état, et un jeton de registre pour Docker
  • Sérialisez les exécutions Terraform et les déploiements par environnement avec concurrency ou resource_group
  • Déployez les étiquettes Git-SHA et attendez rollout status ; annulez avec kubectl rollout undo
  • Fixez la version du fournisseur et de vos modules, et restaurez l'état à partir des versions du bucket uniquement lorsque tous les pipelines sont arrêtés

Terminologie importante :

  • Plan sur PR : Exécuter terraform plan pour chaque demande d'extraction et publier le résultat pour examen
  • Groupe de concurrence : Un paramètre CI qui n'autorise qu'une seule exécution par groupe à la fois
  • kubeconfig du compte de service : Un kubeconfig avec un jeton de compte de service Kubernetes limité par RBAC
  • Mise à jour progressive : La stratégie de déploiement par défaut qui remplace progressivement les pods
  • Module Terraform : Un répertoire réutilisable de ressources avec des variables d'entrée et des sorties

Prochaines étapes

Continuer l'apprentissage : Unité 3.4 : Vérification des connaissances - Conteneurs et CI/CD

Sujets connexes :