Resource dependencies - Terraform - Centre de documentation Alibaba Cloud

Terraform construit un graphe de dépendances à partir de votre configuration pour déterminer l'ordre correct de création, de mise à jour et de suppression des ressources.

Lors de son exécution, Terraform analyse votre configuration et génère un graphe de dépendances. Ce graphe définit l'ordre de création des ressources et identifie celles qui peuvent être provisionnées en parallèle. La configuration suivante crée une instance ECS ainsi que les ressources réseau requises :

provider "alicloud" {
  # Configure your Alibaba Cloud credentials and region.
  # To avoid exposing sensitive credentials, use environment variables:
  # export ALICLOUD_ACCESS_KEY="<Your Alibaba Cloud AccessKey>"
  # export ALICLOUD_SECRET_KEY="<Your Alibaba Cloud SecretKey>"
  region = "cn-hangzhou"
}

# Create a VPC.
resource "alicloud_vpc" "my_vpc" {
  vpc_name   = "main-vpc"
  cidr_block = "10.0.0.0/16"
}

# Create a vSwitch.
resource "alicloud_vswitch" "my_vswitch" {
  vpc_id       = alicloud_vpc.my_vpc.id
  cidr_block   = "10.0.1.0/24"
  zone_id      = "cn-hangzhou-h"
  vswitch_name = "main-vswitch"
}

# Create a security group.
resource "alicloud_security_group" "my_sg" {
  vpc_id = alicloud_vpc.my_vpc.id
  name   = "main-security-group"
}

# Add a security group rule to allow SSH access.
resource "alicloud_security_group_rule" "allow_ssh" {
  type              = "ingress"
  ip_protocol       = "tcp"
  nic_type          = "intranet"
  policy            = "accept"
  port_range        = "22/22"
  priority          = 1
  security_group_id = alicloud_security_group.my_sg.id
  cidr_ip           = "0.0.0.0/0"
}

# Create an ECS instance.
resource "alicloud_instance" "my_instance" {
  instance_name              = "Ubuntu20-Instance"
  image_id                   = "ubuntu_20_04_x64_20G_alibase_20240508.vhd" # Ubuntu 20.04 image ID.
  instance_type              = "ecs.c6.large"                              # 2 vCPUs and 4 GiB of memory.
  security_groups            = [alicloud_security_group.my_sg.id]
  vswitch_id                 = alicloud_vswitch.my_vswitch.id
  internet_charge_type       = "PayByTraffic"
  instance_charge_type       = "PostPaid"
  system_disk_category       = "cloud_efficiency"
  password                   = "Abc@12345"                                 # Replace with your logon password.
  internet_max_bandwidth_out = 10                                          # Set to a value greater than 0 to assign an internet IP address automatically.

  tags = {
    Name = "ubuntu20"
  }
}

Dans cette configuration, l'instance ECS dépend du groupe de sécurité et du vSwitch, comme l'établissent les références aux propriétés security_groups et vswitch_id. Pour les ressources indépendantes les unes des autres, Terraform exécute le provisionnement en parallèle afin de réduire le temps total de déploiement.

Dépendances

Terraform prend en charge deux types de dépendances : implicites et explicites. Les dépendances implicites sont détectées automatiquement. Vous devez déclarer manuellement les dépendances explicites à l'aide du méta-argument depends_on.

Dépendances implicites

Lorsqu'une ressource fait référence à un attribut d'une autre ressource, Terraform déduit qu'il s'agit d'une dépendance implicite.

Dans cet exemple :

Le vSwitch et le groupe de sécurité dépendent du VPC.
L'instance ECS dépend à la fois du vSwitch et du groupe de sécurité.
La règle de groupe de sécurité dépend du groupe de sécurité.

Il s'agit de dépendances implicites que Terraform détecte grâce aux références d'attributs dans les affectations de propriétés.

Par exemple, le paramètre vswitch_id de my_instance fait référence à alicloud_vswitch.my_vswitch.id. Cette référence crée une dépendance implicite de l'instance vers le vSwitch, indiquant ainsi à Terraform qu'il doit créer le vSwitch en premier.

L'ordre de création pour cette configuration est le suivant :

Créez d'abord my_vpc.
Créez ensuite my_vswitch et my_sg en parallèle (les deux dépendent uniquement de my_vpc).
Créez enfin my_instance (dépend à la fois de my_vswitch et de my_sg).

Une fois toutes les ressources créées, Terraform enregistre leurs propriétés dans le fichier d'état. Il définit vpc_id dans my_vswitch et my_sg avec l'ID de my_vpc, et configure vswitch_id ainsi que security_groups dans my_instance en utilisant les ID de my_vswitch et de my_sg.

Dépendances explicites

Utilisez depends_on pour gérer les dépendances cachées, c'est-à-dire les cas où une ressource repose sur le comportement d'une autre sans référencer aucun de ses attributs. Comme Terraform ne peut pas déduire ces relations automatiquement, vous devez les déclarer explicitement.

depends_on accepte une liste de références vers d'autres ressources ou modules présents dans la même configuration.

Supposons par exemple que vous deviez ajouter des règles de groupe de sécurité pour les ports 443 et 8080, et que la règle pour le port 8080 ne doive être créée qu'après celle du port 443. Aucune référence d'attribut ne reliant ces deux règles, Terraform ne peut pas détecter cette exigence d'ordre. Utilisez depends_on pour la déclarer :

Grâce à la déclaration depends_on, Terraform crée la règle pour le port 443 avant celle du port 8080 lorsque vous exécutez terraform apply.

graph (1).svg

L'ordre dans lequel vous définissez les ressources dans vos fichiers de configuration n'affecte pas l'ordre d'exécution. Organisez vos fichiers de configuration selon la méthode la plus adaptée à votre équipe.

Bonnes pratiques

Privilégiez les dépendances implicites. Lorsque cela est possible, utilisez des références d'attributs pour exprimer les relations entre les ressources. Les dépendances implicites sont détectées automatiquement et ne nécessitent aucune maintenance supplémentaire.

**Recourez à depends_on en dernier recours.** L'utilisation de depends_on peut amener Terraform à générer des plans d'exécution plus conservateurs, en considérant davantage de valeurs comme inconnues (known after apply) et en remplaçant potentiellement plus de ressources que nécessaire. Cet effet est particulièrement prononcé lorsque depends_on est utilisé avec des modules. N'y faites appel que lorsqu'une dépendance cachée ne peut pas être exprimée via une référence d'attribut.

Documentez vos dépendances explicites. Lorsque vous ajoutez depends_on, incluez un commentaire expliquant pourquoi il est nécessaire. Cela aide vos collègues à comprendre l'intention et évite que la dépendance ne soit supprimée par inadvertance. Par exemple :

resource "alicloud_security_group_rule" "allow_8080" {
  # ...

  depends_on = [
    # The port 8080 rule must be created after the port 443 rule
    # because the upstream service performs a health check on 443 first.
    alicloud_security_group_rule.allow_443,
  ]
}

**Exécutez terraform plan avant d'appliquer.** Utilisez terraform plan pour vérifier que le graphe de dépendances produit l'ordre de création attendu avant de valider les modifications.