Unité 3.2 : Déploiement et exploitation de Kubernetes
Introduction
Les images de TaskBoard se trouvent dans le registre depuis l'unité 3.1. Elles ont maintenant besoin d'un environnement d'exécution. Managed Kubernetes gère le plan de contrôle ; vous gérez les pools de nœuds et les charges de travail à l'aide du code.
Certaines parties fonctionnent différemment des autres plateformes Kubernetes. Un Service de type LoadBalancer associe une IP statique à un nœud unique au lieu de créer un équilibreur de charge, et les nœuds sont remplacés lors de la maintenance.
Dans cette unité, vous provisionnez le cluster avec Terraform, vous connectez kubectl, vous déployez les charges de travail de TaskBoard, vous placez l'ALB de l'unité 2.3 devant un contrôleur d'ingress, et vous gérez les pools de nœuds. Dans le Code Lab, vous passez TaskBoard de terraform apply à un point d'accès fonctionnel derrière l'ALB.
1. Provisionnement de MKS avec Terraform
1.1 Le Cluster
resource "ionoscloud_k8s_cluster" "taskboard" {
name = "taskboard-dev"
k8s_version = var.k8s_version
maintenance_window {
day_of_the_week = "Sunday"
time = "02:00:00Z"
}
api_subnet_allow_list = ["203.0.113.0/24"]
s3_buckets {
name = "taskboard-k8s-audit-7f3a"
}
}
Seul name est requis. api_subnet_allow_list restreint l'accès au serveur API Kubernetes à ces CIDR ; le trafic interne au cluster n'est pas affecté, et sans liste, l'accès n'est pas restreint. s3_buckets spécifie un seau IONOS Cloud Object Storage existant pour les journaux d'audit de l'API Kubernetes. La fenêtre de maintenance s'ouvre à l'heure que vous définissez et reste ouverte pendant quatre heures.
Lisez la version par défaut actuelle depuis l'API et transmettez-la, au lieu de copier une version ancienne depuis un exemple :
curl --silent "https://api.ionos.com/cloudapi/v6/k8s/versions/default" \
--header "Authorization: Bearer $IONOS_TOKEN"
export TF_VAR_k8s_version="<version from the response>"
Les versions mineures prises en charge sont les 1.32, 1.33, 1.34 et 1.35. La version 1.32 atteindra sa fin de vie sur IONOS CLOUD le 1er décembre 2026, et de nouveaux pools de nœuds ne peuvent pas être créés pour un cluster sur une version en fin de vie. Les rétrogradations ne sont pas prises en charge.
1.2 Le Node Pool
# In the existing ionoscloud_lan.app and ionoscloud_lan.db from Unit 2.2, add:
# lifecycle {
# create_before_destroy = true
# }
resource "ionoscloud_k8s_node_pool" "general" {
datacenter_id = ionoscloud_datacenter.taskboard.id
k8s_cluster_id = ionoscloud_k8s_cluster.taskboard.id
name = "general"
k8s_version = ionoscloud_k8s_cluster.taskboard.k8s_version
server_type = "VCPU"
availability_zone = "AUTO"
storage_type = "SSD"
node_count = 2
cores_count = 2
ram_size = 4096
storage_size = 20
lans {
id = ionoscloud_lan.app.id
dhcp = true
}
lans {
id = ionoscloud_lan.db.id
dhcp = true
}
maintenance_window {
day_of_the_week = "Sunday"
time = "03:00:00Z"
}
}
Les blocs lans connectent chaque Node au LAN privé de l'application de l'unité 2.2, où l'ALB les atteint dans la section 4, et au LAN de base de données, où les pods atteignent PostgreSQL, In-Memory DB et Kafka (unité 2.5). Les pools de Node reçoivent leurs adresses IP dans un LAN privé via DHCP. Le fournisseur recommande create_before_destroy sur les LAN afin que le pool de Node soit mis à jour avant la destruction d'un LAN.
Ces arguments sont immuables : name, cpu_family, availability_zone, cores_count, ram_size, storage_size et storage_type. allow_replace = true les modifie en détruisant et en recréant le pool, ce qui entraîne une interruption de service pour tous les pods qui s'y trouvent. server_type accepte DedicatedCore ou VCPU, et vous pouvez basculer un pool existant entre les deux. Un cœur provisionné équivaut à 2 CPU Managed Kubernetes.
1.3 Récupération du Kubeconfig
data "ionoscloud_k8s_cluster" "taskboard" {
id = ionoscloud_k8s_cluster.taskboard.id
depends_on = [ionoscloud_k8s_node_pool.general]
}
resource "local_file" "kubeconfig" {
sensitive_content = yamlencode(jsondecode(data.ionoscloud_k8s_cluster.taskboard.kube_config))
filename = "kubeconfig.yaml"
}
La source de données renvoie kube_config, et l'ensemble de son Node config est marqué comme sensible. Écrire le kubeconfig dans un fichier constitue un risque de sécurité : ne le placez pas dans Git. En dehors de Terraform, vous obtenez le même fichier via l'API ou l'interface en ligne de commande (CLI) :
curl --silent "https://api.ionos.com/cloudapi/v6/k8s/$CLUSTER_ID/kubeconfig" \
--header "Authorization: Bearer $IONOS_TOKEN" > kubeconfig.yaml
ionosctl k8s kubeconfig get --cluster-id "$CLUSTER_ID"
L'API renvoie du YAML par défaut, ou du JSON lorsque l'en-tête Accept l'exige. Seuls les administrateurs peuvent récupérer le kubeconfig d'un cluster sans Node pool ; tous les autres utilisateurs doivent d'abord créer un Node pool.
2. Connexion au Cluster
export KUBECONFIG="$PWD/kubeconfig.yaml"
kubectl config get-contexts
kubectl get nodes -o wide
kubectl create namespace taskboard
kubectl config set-context --current --namespace=taskboard
Utilisez le kubeconfig téléchargé pour la configuration, et non pour les déploiements quotidiens.
2.1 RBAC pour les déploiements
Pour le pipeline CI de l'Unité 3.3, créez un compte de service qui ne peut gérer que l'espace de noms de TaskBoard :
apiVersion: v1
kind: ServiceAccount
metadata:
name: taskboard-deployer
namespace: taskboard
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
name: taskboard-deployer-edit
namespace: taskboard
subjects:
- kind: ServiceAccount
name: taskboard-deployer
namespace: taskboard
roleRef:
kind: ClusterRole
name: edit
apiGroup: rbac.authorization.k8s.io
Le ClusterRole intégré edit, lié via un RoleBinding, accorde des droits uniquement à l'intérieur de taskboard. La création de clusters est un privilège IONOS CLOUD : un groupe doit disposer de createK8sCluster (Création de clusters Kubernetes dans le DCD).
3. Charges de travail TaskBoard
3.1 Récupération depuis le Private Container Registry
kubectl create secret docker-registry taskboard-registry \
--docker-server="$CR_HOST" \
--docker-username=taskboard-k8s-pull \
--docker-password="$(cat k8s-pull.pass)" \
--namespace taskboard
Le secret contient le jeton de récupération uniquement (pull-only) de l'Unité 3.1. Il doit être référencé dans chaque spécification de pod via imagePullSecrets. Sans lui, les pods restent dans l'état ImagePullBackOff, car le registre n'autorise jamais les récupérations non authentifiées.
3.2 Déploiement, Service, ConfigMap et Secret
apiVersion: v1
kind: ConfigMap
metadata:
name: taskboard-config
data:
LOG_LEVEL: "info"
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: taskboard-api
spec:
replicas: 2
selector:
matchLabels: { app: taskboard-api }
template:
metadata:
labels: { app: taskboard-api }
spec:
imagePullSecrets:
- name: taskboard-registry
containers:
- name: api
image: <registry-hostname>/taskboard/api:<git-sha>
ports:
- containerPort: 8000
envFrom:
- configMapRef: { name: taskboard-config }
- secretRef: { name: taskboard-db }
resources:
requests: { cpu: 250m, memory: 256Mi }
limits: { memory: 512Mi }
readinessProbe:
httpGet: { path: /api/health, port: 8000 }
---
apiVersion: v1
kind: Service
metadata:
name: taskboard-api
spec:
selector: { app: taskboard-api }
ports:
- port: 80
targetPort: 8000
Le Secret taskboard-db contient les valeurs de connexion PostgreSQL de l'unité 2.5 ; créez-le à partir de votre coffre de secrets, jamais à partir d'un fichier dans Git. Le Deployment web utilise le port 8080, et le Deployment worker n'a pas de Service. Définissez les requêtes et les limites : un nœud qui épuise sa RAM peut finir par être NotReady, occupé par l'E/S disque.
4. Ingress : contrôleurs sur les nœuds, Load Balancer provisionnés séparément
4.1 Rôle d'un service LoadBalancer sur MKS
apiVersion: v1
kind: Service
metadata:
name: demo
spec:
type: LoadBalancer
loadBalancerIP: 198.51.100.20 # an IP you reserved in IP Management
selector: { app: demo }
ports:
- port: 80
Sur un pool de nœuds public, cela ne crée pas d'ALB ni de NLB. IONOS CLOUD attribue une adresse IP statique pré-réservée ou en réserve une nouvelle, et l'attache en tant qu'IP secondaire à un Node worker. Ce Node agit en tant que nœud d'entrée ; kube-proxy transfère le trafic vers les pods sur les autres nœuds, et cette étape NAT remplace l'IP du client. Chaque Node offre jusqu'à 2 Gbit/s sur l'interface publique. Sans loadBalancerIP, l'adresse est libérée lorsque vous supprimez le Service. Les pools de nœuds privés ne prennent pas en charge le type LoadBalancer.
4.2 TaskBoard : Contrôleur d'entrée derrière l'ALB
TaskBoard utilise l'ALB managé de l'Unité 2.3, provisionné avec Terraform, et non à partir d'un manifeste. Le contrôleur d'entrée s'exécute sur les Nodes worker et est exposé en tant que NodePort ; l'ALB envoie le trafic vers les Nodes du LAN de l'application.
helm repo add traefik https://traefik.github.io/charts
helm install traefik traefik/traefik --namespace ingress --create-namespace \
--set service.type=NodePort --set ports.web.nodePort=30080
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: taskboard
spec:
ingressClassName: traefik
rules:
- http:
paths:
- path: /api
pathType: Prefix
backend: { service: { name: taskboard-api, port: { number: 80 } } }
- path: /
pathType: Prefix
backend: { service: { name: taskboard-web, port: { number: 80 } } }
Le groupe de cibles pointe désormais vers les adresses des nœuds dans le LAN de l'application, sur le NodePort :
variable "ingress_node_ips" {
type = list(string)
}
resource "ionoscloud_target_group" "ingress" {
name = "taskboard-ingress"
algorithm = "ROUND_ROBIN"
protocol = "HTTP"
protocol_version = "HTTP1"
dynamic "targets" {
for_each = var.ingress_node_ips
content {
ip = targets.value
port = 30080
weight = 100
}
}
http_health_check {
path = "/api/health"
method = "GET"
match_type = "STATUS_CODE"
response = "200"
}
}
Dirigez la règle de transfert de l'Unité 2.3 vers ionoscloud_target_group.ingress.id. Lisez les adresses des nœuds qui se trouvent dans 10.10.1.0/24 depuis kubectl get nodes -o wide, ou depuis l'intérieur d'un nœud. Les nœuds sont remplacés lors de la maintenance (Section 5), il est donc nécessaire de vérifier la liste des cibles après chaque modification du pool de nœuds.
5. Opérations sur les pools de nœuds et dépannage
5.1 Mise à l'échelle et pools multiples
resource "ionoscloud_k8s_node_pool" "workers" {
# ... same required arguments as Section 1.2, name = "workers"
node_count = 1
auto_scaling {
min_node_count = 1
max_node_count = 4
}
labels = { pool = "workers" }
taints {
key = "dedicated"
value = "worker"
effect = "NoSchedule"
}
lifecycle {
ignore_changes = [node_count]
}
}
Un second pool isole le travailleur en arrière-plan de TaskBoard : le taint empêche les autres pods d'y être placés, et le Deployment du travailleur reçoit une tolération correspondante ainsi qu'un nodeSelector de pool: workers. Grâce à auto_scaling, l'autoscaler modifie le nombre de nœuds, ce qui permet à ignore_changes d'empêcher Terraform d'entrer en conflit avec lui. L'autoscaler reste compris entre votre valeur minimale et votre valeur maximale, ne peut pas dépasser le quota du contrat et ne peut pas passer à 0.
| Limite | Valeur |
|---|---|
| Nœuds par pool de nœuds | 100 maximum, 20 recommandés |
| Pools de nœuds par cluster | 500 |
| Nœuds par cluster | 5000 |
| Pods par nœud | 110 |
5.2 Mises à niveau et maintenance
Lors de la maintenance d'un pool de nœuds, tous les nœuds du pool sont remplacés, l'un après l'autre, en commençant par le nœud le plus ancien. Un nouveau nœud rejoint d'abord le pool, puis le nœud ancien est vidangé et supprimé. Les nœuds sont immuables, de sorte que les mises à jour logicielles arrivent également sous forme de nouveaux nœuds. La maintenance prend en compte la fenêtre de quatre heures ; les nœuds qui ne sont pas remplacés à temps sont remplacés lors de la prochaine maintenance.
Les pools de nœuds peuvent exécuter une version de Kubernetes plus ancienne que le plan de contrôle, mais jamais une version plus récente, et les versions mineures peuvent différer d'au plus 1. Pour effectuer une mise à niveau, augmentez d'abord k8s_version sur le cluster, puis sur chaque pool. Préparez vos charges de travail à une éviction à tout moment : exécutez au moins deux répliques et utilisez des PodDisruptionBudgets qui autorisent un pod à quitter le pool.
5.3 Débogage
kubectl get pods -o wide
kubectl describe pod <pod> # events: ImagePullBackOff, scheduling, probes
kubectl logs deploy/taskboard-api --since=15m
kubectl exec -it deploy/taskboard-api -- sh
kubectl get events --sort-by=.lastTimestamp
kubectl est votre outil principal pour les problèmes liés aux charges de travail. Le Logging Service reçoit ce que l'agent Fluent Bit transmet ou ce que vous envoyez au format OTLP, de sorte que les journaux d'application ne l'atteignent qu'après le déploiement d'un agent ou leur envoi via OTLP (Unité 5.1). Les journaux d'audit de l'API du cluster sont envoyés vers le bucket Object Storage dans s3_buckets. Si un nœud devient non réactif, remplacez-le via l'API à l'aide de POST /k8s/{k8sClusterId}/nodepools/{nodePoolId}/nodes/{nodeId}/replace.
Fiche de référence rapide de l'API
Principaux points de terminaison d'API pour le sujet de cette unité :
| Méthode | Point de terminaison | Description |
|---|---|---|
GET |
/k8s/versions/default |
Version par défaut pour les nouveaux clusters et pools de nœuds |
POST |
/k8s |
Créer un cluster |
POST |
/k8s/{k8sClusterId}/nodepools |
Créer un pool de nœuds |
GET |
/k8s/{k8sClusterId}/kubeconfig |
Télécharger le kubeconfig (YAML par défaut) |
POST |
/k8s/{k8sClusterId}/nodepools/{nodePoolId}/nodes/{nodeId}/replace |
Remplacer un nœud non réactif |
URL de base : https://api.ionos.com/cloudapi/v6
Authentification : Authorization: Bearer <token>
Atelier de code
Objectif : Déployer TaskBoard sur Managed Kubernetes : créer le cluster et le pool de nœuds avec Terraform, déployer les manifests avec un secret de récupération du registre, et vérifier le point d'accès via l'ALB.
Prérequis :
- Compte IONOS CLOUD avec un jeton API dans
IONOS_TOKEN - Terraform,
kubectlet Helm installés localement - Le registre, les images et
k8s-pull.passde l'Unité 3.1 - La configuration du centre de données, du LAN applicatif et de l'ALB des Unités 2.2 et 2.3
Étape 1 : Ajouter le cluster et le pool de nœuds
Ajoutez le cluster (Section 1.1, sans s3_buckets à moins que vous n'ayez un seau), le pool de nœuds (Section 1.2) et le fichier kubeconfig (Section 1.3) à votre configuration.
export TF_VAR_k8s_version="<default version from /k8s/versions/default>"
terraform apply -target=ionoscloud_k8s_node_pool.general -target=local_file.kubeconfig
Sortie attendue :
ionoscloud_k8s_cluster.taskboard: Creation complete after ...
ionoscloud_k8s_node_pool.general: Creation complete after ...
local_file.kubeconfig: Creation complete after ...
Étape 2 : Connexion
export KUBECONFIG="$PWD/kubeconfig.yaml"
kubectl get nodes
Sortie attendue :
NAME STATUS ROLES AGE VERSION
<node-1> Ready <none> ... v<version>
<node-2> Ready <none> ... v<version>
Étape 3 : Créer l'espace de noms et les secrets
kubectl create namespace taskboard
kubectl -n taskboard create secret docker-registry taskboard-registry \
--docker-server="$CR_HOST" --docker-username=taskboard-k8s-pull \
--docker-password="$(cat k8s-pull.pass)"
kubectl -n taskboard create secret generic taskboard-db --from-literal=DATABASE_URL="$DATABASE_URL"
Sortie attendue :
namespace/taskboard created
secret/taskboard-registry created
secret/taskboard-db created
Étape 4 : Déployer les charges de travail
kubectl -n taskboard apply -f k8s/
kubectl -n taskboard rollout status deploy/taskboard-api
Sortie attendue :
deployment "taskboard-api" successfully rolled out
Étape 5 : Installer le contrôleur d'ingress et l'Ingress
helm install traefik traefik/traefik --namespace ingress --create-namespace \
--set service.type=NodePort --set ports.web.nodePort=30080
kubectl -n taskboard apply -f k8s/ingress.yaml
Sortie attendue :
STATUS: deployed
ingress.networking.k8s.io/taskboard created
Étape 6 : Pointez l'ALB vers les nœuds
kubectl get nodes -o wide # note each node's address in 10.10.1.0/24
export TF_VAR_ingress_node_ips='["10.10.1.x","10.10.1.y"]'
terraform apply
Sortie attendue :
ionoscloud_target_group.ingress: Creation complete after ...
ionoscloud_application_loadbalancer_forwardingrule.http: Modifications complete after ...
Étape 7 : Vérifier le point d'accès
curl --silent "http://$(terraform output -raw alb_ip)/api/health"
Sortie attendue :
{"status": "ok"}
Liste de contrôle de validation :
- [ ] Les deux nœuds sont
Ready - [ ] Tous les pods TaskBoard sont
Running, sans aucunImagePullBackOff - [ ] La vérification d'état de l'ALB signale les cibles comme saines
- [ ]
/api/healthrépond via l'IP de l'ALB
Nettoyage :
helm uninstall traefik --namespace ingress
terraform destroy -auto-approve
rm -f kubeconfig.yaml
Erreurs courantes
Erreurs de développement à éviter concernant le sujet de cette unité :
-
S'attendre à un équilibreur de charge à partir d'un manifeste
- Problème : Vous appliquez un Service
type: LoadBalanceret cherchez un nouvel ALB, mais tout le trafic arrive sur un seul nœud, et vos journaux affichent des adresses IP internes de nœuds au lieu des adresses IP des clients. - Pourquoi cela se produit : Sur MKS, le Service reçoit une adresse IP statique sur un nœud d'entrée, et le NAT de kube-proxy remplace l'adresse du client.
- Correction : Provisionnez l'ALB ou le NLB séparément avec Terraform (section 4.2), ou utilisez
externalTrafficPolicy: Localavec l'adresse IP liée au nœud qui exécute le contrôleur d'entrée.
- Problème : Vous appliquez un Service
-
ImagePullBackOffsur chaque pod- Problème :
kubectl describe podaffiche une erreur d'autorisation lors de la récupération depuis le registre. - Pourquoi cela se produit : La spécification du pod ne contient pas de
imagePullSecrets, le secret se trouve dans un autre espace de noms, ou le jeton a expiré et a été supprimé. - Correction : Créez le secret
docker-registrydans l'espace de noms de la charge de travail, référencez-le dans la spécification du pod, et donnez au jeton de récupération aucune date d'expiration ou faites-le tourner avant la date d'expiration.
- Problème :
-
Modification d'un argument de pool de nœuds immuable
- Problème : Vous augmentez
ram_sizeet le plan montre une destruction et une recréation du pool. - Pourquoi cela se produit :
cores_count,ram_size,storage_sizeet les autres arguments du modèle sont immuables. - Correction : Créez un nouveau pool avec la nouvelle taille, déplacez les charges de travail à l'aide d'étiquettes ou en vidant le pool, puis supprimez l'ancien pool.
- Problème : Vous augmentez
Résumé
Vous pouvez désormais exécuter TaskBoard sur Managed Kubernetes à partir du code. Terraform crée le cluster, les pools de nœuds et le kubeconfig ; les charges de travail tirent leurs images depuis le Private Container Registry à l'aide d'un secret de récupération ; et un contrôleur d'ingress sur les nœuds est placé derrière un ALB provisionné séparément. Vous savez comment la maintenance remplace les nœuds et où chercher lorsqu'un pod échoue.
Points clés :
- Lire la version par défaut depuis
/k8s/versions/default; les pools de nœuds peuvent être en retard d'au plus une version mineure par rapport au plan de contrôle - Les arguments du modèle de nœud sont immuables ;
allow_replacerecrée le pool avec une interruption de service - Un Service
LoadBalancersur MKS est une IP statique sur un nœud, et non un ALB ou un NLB - Chaque pod qui tire des images depuis le registre a besoin d'une entrée
imagePullSecrets - La maintenance des pools de nœuds remplace les nœuds un par un dans une fenêtre de quatre heures ; maintenir les pools à 20 nœuds ou moins
Terminologie importante :
- Pool de nœuds : Un groupe de nœuds ayant le même type de serveur, la même CPU, la même RAM et le même stockage, géré comme
ionoscloud_k8s_node_pool - Kubeconfig : Le fichier contenant l'adresse du serveur API et les identifiants utilisés par
kubectl - Nœud d'ingress : Le nœud de travail qui détient l'IP statique d'un Service
LoadBalancer - NodePort : Un type de Service qui ouvre un port fixe sur chaque nœud, utilisé ici comme port cible de l'ALB
- imagePullSecrets : Le champ de la spécification du pod qui référence les identifiants du registre pour les images privées
Prochaines étapes
Continuer à apprendre : Unité 3.3 : Pipelines CI/CD pour IONOS CLOUD
Sujets connexes :