16 min de lecture

Objectifs d'apprentissage

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

  • Provisionner des serveurs Dedicated Core et vCPU avec `ionoscloud_server` et `ionoscloud_vcpu_server`, dimensionnés dans les limites de la plateforme
  • Initialiser les serveurs au premier démarrage avec des `user_data` cloud-init passés depuis Terraform
  • Réserver des adresses IPv4 publiques statiques avec `ionoscloud_ipblock` et les assigner à une carte réseau d'un serveur
  • Construire des environnements reproductibles à partir de `ionoscloud_snapshot` et définir la mise à l'échelle horizontale avec `ionoscloud_autoscaling_group`
  • Choisir entre les serveurs Cubes et Compute Engine en fonction du modèle de stockage que chacun provisionne

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_configuration n'affecte pas les répliques existantes.
  • Définissez delete_volumes de manière délibérée. Avec false, 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_TOKEN et 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 apply a créé le centre de données, le LAN, le bloc IP et les deux serveurs
  • [ ] L'API répertorie taskboard-api-01 en tant que ENTERPRISE et taskboard-worker-01 en tant que VCPU
  • [ ] SSH fonctionne avec votre clé, et cloud-init status signale done
  • [ ] 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é :

  1. Tester avant la fin de cloud-init

    • Problème : terraform apply est 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 --wait dans votre pipeline, et lisez /var/log/cloud-init-output.log et /var/log/cloud-init.log lorsque quelque chose est manquant.
  2. 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_data est 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.
  3. 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 = true pour 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 :

  • type et availability_zone sur un serveur sont immuables ; les serveurs utilisent AUTO, ZONE_1 ou ZONE_2
  • Seuls les serveurs Dedicated Core permettent de choisir cpu_family ; lisez-le depuis cpu_architecture du centre de données
  • user_data est 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_ipblock dans 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 :