Unité 2.1 : Calcul et automatisation des serveurs
Introduction
Dans le Module 1, vous avez construit le VDC de base de TaskBoard avec un serveur générique. Désormais, TaskBoard a besoin d'une couche de calcul réelle : un serveur API avec des cœurs dédiés qui gère le trafic de requêtes, et un worker moins coûteux qui traite les tâches en arrière-plan. Les deux doivent être démarrés et configurés, sans que personne ait à se connecter pour installer des paquets.
Dans cette unité, vous décrivez cette couche de calcul sous forme de code : types de serveurs et options de CPU, cloud-init via Terraform, une IP publique réservée, des instantanés, des groupes VM Auto Scaling et des Cubes. Dans le Code Lab, vous déployez la couche de calcul et vérifiez l'accès SSH ainsi que l'exécution de cloud-init.
1. Types de serveurs dans Terraform
resource "ionoscloud_server" "api" {
name = "taskboard-api-01"
datacenter_id = ionoscloud_datacenter.taskboard.id
type = "ENTERPRISE"
cores = 4
ram = 8192
cpu_family = ionoscloud_datacenter.taskboard.cpu_architecture[0].cpu_family
availability_zone = "AUTO"
image_name = data.ionoscloud_image.ubuntu.id
ssh_keys = [var.ssh_public_key]
volume {
name = "system"
size = 20
disk_type = "BALANCED"
}
nic {
lan = ionoscloud_lan.public.id
name = "public"
dhcp = true
}
}
L'argument type sélectionne l'utilisation du serveur : ENTERPRISE (désormais nommé Dedicated Core), CUBE ou VCPU. Il est immuable, tout comme availability_zone, qui accepte AUTO, ZONE_1 ou ZONE_2 (Compute n'a pas de Zone 3 ; voir l'Unité 2.4). ram est indiqué en Mo, donc 8 Go correspond à 8192.
1.1 Dedicated Core vs vCPU
Les deux types de serveurs Compute Engine diffèrent par la manière dont la capacité CPU est attribuée et par ce que vous pouvez contrôler dans le code :
| Propriété | Dedicated Core Server | vCPU Server |
|---|---|---|
| Utilisation du CPU | Exclusive | Partagée |
| Calcul maximal | 62 cœurs | 60 vCPUs |
| RAM maximale | 230 Go | 230 Go |
cpu_family sélectionnable |
Oui | Non |
| Ressource Terraform | ionoscloud_server avec type = "ENTERPRISE" |
ionoscloud_vcpu_server (ou type = "VCPU") |
Comme le montre le tableau, choisissez Dedicated Core pour une capacité CPU prévisible et un contrôle sur l'architecture CPU. La performance d'un vCPU Server dépend du CPU sous-jacent, de la configuration de la VM et de la charge actuelle sur l'hôte partagé. La RAM est définie par incréments de 0,25 Go. Pour le travailleur en arrière-plan de TaskBoard, un vCPU Server suffit :
resource "ionoscloud_vcpu_server" "worker" {
name = "taskboard-worker-01"
datacenter_id = ionoscloud_datacenter.taskboard.id
cores = 2
ram = 4096
image_name = data.ionoscloud_image.ubuntu.id
ssh_keys = [var.ssh_public_key]
volume {
name = "system"
size = 20
disk_type = "BALANCED"
}
nic {
lan = ionoscloud_lan.public.id
name = "public"
dhcp = true
}
}
volume est obligatoire sur ionoscloud_vcpu_server, et il n'existe pas d'argument cpu_family : la famille de CPU d'un vCPU Server ne peut être ni choisie à la création, ni modifiée ultérieurement.
1.2 Sélection de la famille de CPU
Sur un Dedicated Core Server, cpu_family définit l'architecture du CPU. Toutes les architectures de CPU ne sont pas disponibles dans toutes les régions des centres de données, c'est pourquoi le serveur API ci-dessus lit la famille à partir de l'attribut cpu_architecture calculé de ionoscloud_datacenter au lieu d'en coder une en dur. Contrairement au vCPU Server, la famille de CPU d'un Dedicated Core Server peut être modifiée après sa création.
2. Amorçage Cloud-Init depuis Terraform
Cloud-init automatise l'initialisation des serveurs lors du démarrage du système. Les données utilisateur doivent être rédigées sous forme de scripts shell ou de directives cloud-config utilisant la syntaxe YAML. Il est disponible sur toutes les images Linux publiques fournies par IONOS CLOUD ; les images Windows et les configurations Linux LVM sont actuellement hors périmètre.
2.1 Rédaction de la configuration cloud-config
Conservez la configuration à côté de votre code Terraform, par exemple cloud-init/api.yaml :
#cloud-config
package_update: true
packages:
- nginx
runcmd:
- systemctl enable --now nginx
La première ligne #cloud-config marque le contenu comme des données cloud-config. Un fichier qui commence par #! est exécuté à la place en tant que script user-data.
2.2 Transmission de user_data
Dans l'API Cloud v6, cloud-init est configuré sur la ressource volume. Dans Terraform, user_data est un argument du bloc volume et s'attend à la configuration cloud-init en tant que chaîne encodée en base64 :
data "ionoscloud_image" "ubuntu" {
image_alias = "ubuntu:latest"
type = "HDD"
cloud_init = "V1"
location = var.location
}
resource "ionoscloud_server" "api" {
# ... arguments from Section 1 ...
volume {
name = "system"
size = 20
disk_type = "BALANCED"
user_data = base64encode(file("${path.module}/cloud-init/api.yaml"))
}
}
La propriété user_data est immuable, n'est autorisée que lors de la création d'un nouveau volume et ne fonctionne qu'avec les images compatibles cloud-init, ce qui explique pourquoi la source de données de l'image filtre sur cloud_init = "V1".
2.3 Injection de clé SSH
ssh_keys accepte du texte de clé ou des chemins de fichiers, et les clés SSH ne sont prises en charge que si une image Linux publique est utilisée pour la création du volume. Le champ est immuable, ne peut être défini que dans les requêtes de création et renvoie toujours null lors de la lecture.
variable "ssh_public_key" {
type = string
description = "Public key text, for example the content of ~/.ssh/id_ed25519.pub"
}
Le format de chemin ne prend pas en charge l'expansion ~, il est donc nécessaire de transmettre le texte de la clé à partir d'une variable, comme indiqué, ou d'utiliser un chemin absolu.
3. Adresses IP publiques avec ionoscloud_ipblock
Une carte réseau (NIC) connectée à Internet reçoit une adresse IPv4 publique par DHCP, et cette adresse peut changer lorsque vous libérez la VM à l'aide de Power Stop ou lorsque vous supprimez l'interface réseau. Pour un point de terminaison API derrière un enregistrement DNS, réservez une adresse statique.
3.1 Réservation du bloc
resource "ionoscloud_ipblock" "api" {
name = "taskboard-api-ip"
location = ionoscloud_datacenter.taskboard.location
size = 1
}
Une adresse IP ne peut être utilisée que dans la région du centre de données où elle a été réservée, de sorte que le bloc hérite de son location du centre de données. Vous ne pouvez pas réserver une adresse IPv4 spécifique. Seuls les propriétaires de contrat, les administrateurs ou les utilisateurs disposant du privilège Reserve IP Blocks peuvent réserver des adresses IP, de sorte qu'un jeton CI doit posséder ce privilège.
3.2 Affectation de l'adresse à la carte réseau
resource "ionoscloud_server" "api" {
# ...
nic {
lan = ionoscloud_lan.public.id
name = "public"
dhcp = true
ips = [ionoscloud_ipblock.api.ips[0]]
}
}
La référence à la liste ips calculée fait en sorte que Terraform réserve le bloc avant de créer le serveur. L'attribut ip_consumers calculé indique quelle carte réseau et quel serveur utilisent chaque adresse. Les adresses réservées sont facturées, il convient donc de détruire les blocs inutilisés.
4. Snapshots et environnements reproductibles
4.1 Capture d'un volume configuré
resource "ionoscloud_snapshot" "api_golden" {
datacenter_id = ionoscloud_datacenter.taskboard.id
volume_id = ionoscloud_server.api.boot_volume
name = "taskboard-api-golden"
description = "API server after cloud-init bootstrap"
}
L'attribut boot_volume calculé du serveur vous donne l'ID du volume. Si des données encore présentes dans la RAM de la VM doivent se trouver dans le Snapshot, exécutez sync ou arrêtez d'abord le système d'exploitation invité.
4.2 Création de serveurs à partir du Snapshot
image_name sur un serveur accepte un nom d'image, un ID ou un alias, et peut également être un ID de Snapshot :
resource "ionoscloud_server" "api_clone" {
# same arguments as ionoscloud_server.api, except:
name = "taskboard-api-02"
image_name = ionoscloud_snapshot.api_golden.id
}
Les Snapshots sont limités à l'emplacement du centre de données où ils ont été initialement créés, bien que plusieurs VDC situés à cet emplacement puissent les utiliser. Les Snapshots ne sont pas incrémentiels : chacun est une copie distincte qui utilise de l'espace de stockage dans votre compte. Supprimez donc les anciens dans votre pipeline. Utilisez cloud-init pour des initialisations rapides à partir d'images propres, et un Snapshot lorsqu'une initialisation lente doit être figée dans un état connu.
5. VM Auto Scaling et Cubes
5.1 Un groupe de mise à l'échelle automatique en tant que code
resource "ionoscloud_autoscaling_group" "workers" {
datacenter_id = ionoscloud_datacenter.taskboard.id
name = "taskboard-workers"
min_replica_count = 1
max_replica_count = 4
policy {
metric = "INSTANCE_CPU_UTILIZATION_AVERAGE"
scale_in_threshold = 25
scale_out_threshold = 70
unit = "PER_MINUTE"
scale_in_action {
amount = 1
amount_type = "ABSOLUTE"
termination_policy_type = "OLDEST_SERVER_FIRST"
cooldown_period = "PT5M"
delete_volumes = true
}
scale_out_action {
amount = 1
amount_type = "ABSOLUTE"
cooldown_period = "PT5M"
}
}
replica_configuration {
availability_zone = "AUTO"
cores = 2
ram = 4096
nic {
lan = ionoscloud_lan.app.id # private app LAN, built in Unit 2.2
name = "app"
dhcp = true
}
volume {
image_alias = "ubuntu:latest"
name = "system"
size = 20
type = "BALANCED"
user_data = base64encode(file("${path.module}/cloud-init/worker.yaml"))
ssh_keys = [var.ssh_public_key]
boot_order = "AUTO"
}
}
}
VM Auto Scaling prend en charge uniquement la mise à l'échelle horizontale : il ajoute ou supprime des VM de la même taille, en fonction d'une politique de mise à l'échelle par groupe. La métrique est l'une des suivantes : INSTANCE_CPU_UTILIZATION_AVERAGE, INSTANCE_NETWORK_IN_BYTES, INSTANCE_NETWORK_IN_PACKETS, INSTANCE_NETWORK_OUT_BYTES ou INSTANCE_NETWORK_OUT_PACKETS. Les seuils de réduction et d'extension doivent différer d'au moins 40 %, ce qui explique pourquoi l'exemple utilise 25 et 70. La période d'attente se situe entre 2 minutes et 24 heures, avec une valeur par défaut de 5 minutes. Les volumes répliqués utilisent les types de stockage Essential, Balanced ou Performance.
5.2 Règles qui affectent votre code
- La configuration des répliques ne s'applique qu'aux nouvelles répliques. La mise à jour de
replica_configurationn'affecte pas les répliques existantes. - Définissez
delete_volumesde manière délibérée. Avecfalse, les volumes des répliques supprimées restent dans le centre de données (voir Pièges courants). - Gardez la taille du groupe modérée. Le nombre minimal de répliques est de 1. IONOS CLOUD recommande au maximum 100 VM par groupe et au maximum 5 VM ajoutées ou supprimées par action de mise à l'échelle.
- Prévoyez les pics d'activité. Les minuteries d'attente évoluent progressivement, il est donc conseillé d'ajouter des VM avant un pic de trafic connu.
Le groupe lui-même réside dans l'API distincte de VM Auto Scaling (voir la fiche rapide).
5.3 Cubes dans le code
data "ionoscloud_template" "xs" {
name = "Basic Cube XS"
}
resource "ionoscloud_cube_server" "helper" {
name = "taskboard-cube-01"
datacenter_id = ionoscloud_datacenter.taskboard.id
template_uuid = data.ionoscloud_template.xs.id
image_name = "ubuntu:latest"
image_password = var.image_password
volume {
name = "nvme"
licence_type = "LINUX"
disk_type = "DAS"
}
}
La taille d'un Cube est déterminée par son modèle, et non par cores et ram. Son volume en ligne doit utiliser disk_type = "DAS", et vous ne pouvez pas définir volume.size, car le modèle définit le stockage NVMe en direct. Les modèles Basic vont du Basic Cube XS (1 vCPU, 2 Go de RAM, 60 Go NVMe) au Basic Cube XL (16 vCPUs, 32 Go de RAM, 960 Go NVMe). Les propriétés du modèle ne peuvent pas être modifiées après le provisionnement, et la suppression du Cube supprime également son volume NVMe ; prenez donc une instantané au préalable si vous avez besoin des données. Chaque Cube prend en charge jusqu'à 23 volumes Block Storage en plus du volume NVMe.
Fiche de référence rapide de l'API
Principaux points de terminaison d'API derrière les ressources de cette unité :
| Méthode | Point de terminaison | Description |
|---|---|---|
POST |
/datacenters/{datacenterId}/servers |
Créé par ionoscloud_server et ionoscloud_vcpu_server |
POST |
/ipblocks |
Créé par ionoscloud_ipblock |
POST |
/datacenters/{datacenterId}/volumes/{volumeId}/create-snapshot |
Crée une image instantanée d'un volume |
GET |
/templates |
Répertorie les modèles Cube |
GET |
/groups/{groupId}/servers |
Répertorie les serveurs d'un groupe de mise à l'échelle automatique (API VM Auto Scaling) |
URL de base : https://api.ionos.com/cloudapi/v6 (VM Auto Scaling : https://api.ionos.com/autoscaling)
Authentification : Authorization: Bearer <token>
Atelier de code
Objectif : Déployer la couche de calcul de TaskBoard avec Terraform : un serveur API Dedicated Core (4 cœurs, 8 Go de RAM) avec une IP publique réservée et un bootstrap cloud-init, ainsi qu'un travailleur vCPU (2 cœurs). Vérifier l'accès SSH et l'exécution de cloud-init.
Prérequis :
- Un compte IONOS CLOUD avec un jeton API dans
IONOS_TOKENet le privilège Reserve IP Blocks - Terraform installé localement, avec le fournisseur verrouillé comme dans l'Unité 1.2
- Une paire de clés SSH, par exemple
~/.ssh/id_ed25519
Étape 1 : Créer le projet et le cloud-config
mkdir -p taskboard-compute/cloud-init && cd taskboard-compute
# save the cloud-config from Section 2.1 as cloud-init/api.yaml
head -n 1 cloud-init/api.yaml
Sortie attendue :
#cloud-config
Étape 2 : Écrire main.tf
Combiner le fournisseur épinglé, le centre de données et le LAN public de l'Unité 1.2, la source de données de l'image (Section 2.2), le bloc IP (Section 3.1), le serveur API (Section 1, ainsi que user_data de la 2.2 et ips de la 3.2) et le worker (Section 1.1). Ajouter :
output "datacenter_id" { value = ionoscloud_datacenter.taskboard.id }
output "api_public_ip" { value = ionoscloud_ipblock.api.ips[0] }
output "worker_ip" { value = ionoscloud_vcpu_server.worker.primary_ip }
Sortie attendue :
(file saved)
Étape 3 : Planifier et appliquer
export TF_VAR_ssh_public_key="$(cat ~/.ssh/id_ed25519.pub)"
terraform init
terraform plan -out=tfplan
terraform apply tfplan
Sortie attendue :
Plan: 5 to add, 0 to change, 0 to destroy.
...
Apply complete! Resources: 5 added, 0 changed, 0 destroyed.
Outputs:
api_public_ip = "<reserved IP>"
datacenter_id = "<datacenter UUID>"
worker_ip = "<DHCP-assigned IP>"
Étape 4 : Vérifier les serveurs via l'API
DC=$(terraform output -raw datacenter_id)
curl -s -H "Authorization: Bearer $IONOS_TOKEN" \
"https://api.ionos.com/cloudapi/v6/datacenters/$DC/servers?depth=1" \
| jq -r '.items[].properties | "\(.name) \(.type) \(.cores) \(.ram) \(.vmState)"'
Sortie attendue :
taskboard-api-01 ENTERPRISE 4 8192 RUNNING
taskboard-worker-01 VCPU 2 4096 RUNNING
Étape 5 : Se connecter via SSH et attendre cloud-init
ssh -i ~/.ssh/id_ed25519 root@"$(terraform output -raw api_public_ip)" \
'cloud-init status --wait && tail -n 3 /var/log/cloud-init-output.log'
Sortie attendue :
status: done
Cloud-init v. ... finished at ...
Étape 6 : Vérifier le service initialisé
curl -sI "http://$(terraform output -raw api_public_ip)" | head -n 1
Sortie attendue :
HTTP/1.1 200 OK
Liste de contrôle de validation :
- [ ]
terraform applya créé le centre de données, le LAN, le bloc IP et les deux serveurs - [ ] L'API répertorie
taskboard-api-01en tant queENTERPRISEettaskboard-worker-01en tant queVCPU - [ ] SSH fonctionne avec votre clé, et
cloud-init statussignaledone - [ ] Le serveur API répond sur son IP publique réservée
Nettoyage :
terraform destroy -auto-approve
Erreurs courantes
Erreurs de développement à éviter concernant le sujet de cette unité :
-
Tester avant la fin de cloud-init
- Problème :
terraform applyest terminé, mais la première vérification d'état échoue ou des paquets sont manquants. - Pourquoi cela se produit : L'achèvement de la provisionning signifie que l'infrastructure est prête ; le bootstrap, y compris l'exécution des données cloud-init, peut prendre du temps supplémentaire.
- Correction : Attendez avec
cloud-init status --waitdans votre pipeline, et lisez/var/log/cloud-init-output.loget/var/log/cloud-init.loglorsque quelque chose est manquant.
- Problème :
-
S'attendre à ce qu'une modification de user_data reconfigure un serveur
- Problème : Vous modifiez la configuration cloud-config et exécutez
apply, mais le serveur en cours d'exécution n'intègre jamais la modification. - Pourquoi cela se produit :
user_dataest immuable et n'est autorisé que lors de la création d'un nouveau volume. Cloud-init ne peut être défini qu'au moment de la provisionning initiale et ne peut pas être appliqué aux serveurs déjà provisionnés. - Correction : Concevez les serveurs comme remplaçables et reconstruisez-les avec
terraform apply -replace=ionoscloud_server.api, ou appliquez les modifications d'exécution avec un outil de gestion de configuration.
- Problème : Vous modifiez la configuration cloud-config et exécutez
-
Fuites de volumes d'un Auto Scaling Group
- Problème : Après plusieurs jours de mise à l'échelle, l'extension échoue et le centre de données est rempli de volumes non attachés.
- Pourquoi cela se produit : Avec
delete_volumes = false, les répliques supprimées laissent leurs volumes derrière elles, et chaque extension en crée de nouveaux jusqu'à ce que les limites de ressources du contrat soient atteintes. - Correction : Définissez
delete_volumes = truepour les répliques sans état et conservez l'état dans des services gérés ou un stockage partagé (unités 2.4 et 2.5).
Résumé
Vous pouvez désormais construire la couche de calcul de TaskBoard en tant que code : un serveur API Dedicated Core et un travailleur vCPU qui s'initialisent à partir d'une configuration cloud-config encodée en base64, une adresse IP publique réservée pour l'API, des instantanés pour une réutilisation dans la même localisation, des groupes de mise à l'échelle automatique pour des répliques identiques, et des Cubes dimensionnés par modèle.
Points clés :
typeetavailability_zonesur un serveur sont immuables ; les serveurs utilisentAUTO,ZONE_1ouZONE_2- Seuls les serveurs Dedicated Core permettent de choisir
cpu_family; lisez-le depuiscpu_architecturedu centre de données user_dataest une configuration cloud-init encodée en base64, définie uniquement lors de la création d'un nouveau volume avec une image compatible cloud-init- Les adresses IP réservées proviennent de
ionoscloud_ipblockdans la région du centre de données ; les adresses DHCP peuvent changer lors d'une Power Stop - La mise à l'échelle automatique est uniquement horizontale, et les modifications de configuration des répliques ne s'appliquent qu'aux nouvelles répliques
Terminologie importante :
- Dedicated Core Server : Un serveur avec des cœurs CPU exclusifs,
type = "ENTERPRISE", avec une famille de CPU sélectionnable - vCPU Server : Un serveur avec des CPU virtuels partagés, géré avec
ionoscloud_vcpu_server - user_data : La configuration cloud-init encodée en base64 d'un volume, appliquée une seule fois au premier démarrage
- Bloc IP : Un ensemble d'adresses IPv4 publiques statiques et réservées, lié à une seule région
- Configuration de réplique : Le modèle utilisé par un groupe de mise à l'échelle automatique pour créer chaque nouvelle VM
Prochaines étapes
Continuer l'apprentissage : Unité 2.2 : Réseau et connectivité en tant que code
Sujets connexes :