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
mainexé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 undorestaure 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é :
-
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'unresource_group(GitLab) par environnement, et n'appliquer que letfplanqui a été examiné.
-
Identifiants qui expirent silencieusement
- Problème : Le pipeline fonctionnait depuis des semaines, puis chaque exécution échoue avec
401sur l'API Cloud ou surdocker 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.
- Problème : Le pipeline fonctionnait depuis des semaines, puis chaque exécution échoue avec
-
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-deployerlimité à 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_TOKENpour 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
concurrencyouresource_group - Déployez les étiquettes Git-SHA et attendez
rollout status; annulez aveckubectl 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 planpour 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 :