> For the complete documentation index, see [llms.txt](https://docs.verge.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.verge.io/learn-the-platform/fr/module-8-developpeur-et-devops/04-terraform-packer.md).

# Terraform et Packer

L’infrastructure en tant que code (IaC) apporte au provisionnement de l’infrastructure le même contrôle de version, la même revue par les pairs et la même reproductibilité que ceux sur lesquels s’appuient les équipes logiciel. Le **fournisseur Terraform VergeOS** vous permet de déclarer des VM, des réseaux et des utilisateurs dans des fichiers de configuration HCL, tandis que le **plugin Packer** automatise la création d’images de référence. Ensemble, ils forment un pipeline déclaratif : Packer construit les images, Terraform déploie l’infrastructure.

## Fournisseur Terraform

Le fournisseur Terraform VergeOS est publié sur le Terraform Registry et est entièrement compatible avec **OpenTofu** (le fork open source de Terraform). Il vous permet de gérer les ressources VergeOS via des flux de travail standard `terraform plan` / `terraform apply` .

### Configuration du fournisseur

```hcl
terraform {
  required_providers {
    vergeio = {
      source  = "verge-io/vergeio"
      version = "~> 0.1.0"
    }
  }
}

provider "vergeio" {
  host     = "https://vergeos.example.com"
  username = "admin"
  password = var.vergeos_password
  insecure = true  # Définir sur true pour les certificats SSL auto-signés
}
```

| Paramètre    | Obligatoire | Description                                                       |
| ------------ | ----------- | ----------------------------------------------------------------- |
| **host**     | Oui         | URL ou adresse IP du système ou du tenant VergeOS                 |
| **username** | Oui         | Nom d’utilisateur VergeOS avec les autorisations appropriées      |
| **password** | Oui         | Mot de passe de l’utilisateur spécifié (marquer comme `sensible`) |
| **insecure** | Non         | Définissez `true` pour accepter les certificats SSL auto-signés   |

{% hint style="success" %}
**Compatible OpenTofu**

La configuration du fournisseur est identique pour OpenTofu. Remplacez simplement les commandes `terraform` par `tofu` — aucune modification du code requise.
{% endhint %}

### Ressources

Le fournisseur prend actuellement en charge quatre types de ressources gérées pour créer et mettre à jour des objets VergeOS :

| Ressource             | Rôle                                   | Attributs clés                                                                                                                                                                                  |
| --------------------- | -------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **`vergeio_vm`**      | Créer et gérer des machines virtuelles | `cpu_cores`, `ram`, `os_family`, `machine_type`, `ha_group`, `cluster`, `guest_agent`, `uefi`, `secure_boot`, `snapshot_profile`, `powerstate`, en ligne `vergeio_drive` et `vergeio_nic` blocs |
| **`vergeio_network`** | Configurer des réseaux virtuels        | `network_address` (CIDR), `dhcp_enabled`, `dhcp_start`, `dhcp_end`, `dns_server_list`, `gateway`, `powerstate`                                                                                  |
| **`vergeio_user`**    | Provisionner des utilisateurs          | Gestion des comptes utilisateurs dans VergeOS                                                                                                                                                   |
| **`vergeio_member`**  | Gérer l’appartenance aux groupes       | Associer des utilisateurs à des groupes pour le RBAC                                                                                                                                            |

### Sources de données

Huit sources de données en lecture seule vous permettent d’interroger des objets VergeOS existants pour les utiliser dans vos configurations :

| Source de données            | Renvoie                                                    |
| ---------------------------- | ---------------------------------------------------------- |
| **`vergeio_version`**        | Informations sur la version actuelle de VergeOS            |
| **`vergeio_clusters`**       | Clusters de calcul/stockage disponibles                    |
| **`vergeio_nodes`**          | Nœuds dans l’environnement                                 |
| **`vergeio_networks`**       | Réseaux virtuels existants                                 |
| **`vergeio_vms`**            | Machines virtuelles (filtrables par nom, état du snapshot) |
| **`vergeio_groups`**         | Groupes d’utilisateurs pour le RBAC                        |
| **`vergeio_mediasources`**   | ISO et fichiers média téléchargés                          |
| **`vergeio_cloudinitfiles`** | Fichiers de configuration cloud-init disponibles           |

### Exemples HCL

#### VM avec disque et NIC

Cet exemple crée un serveur web Linux avec un disque virtio-scsi de 10 Go et une NIC attachée à un réseau interne :

```hcl
resource "vergeio_vm" "web_server" {
  name                 = "my-web-server"
  description          = "Serveur web"
  enabled              = true
  os_family            = "linux"
  cpu_cores            = 2
  machine_type         = "q35"
  ram                  = 2048
  powerstate           = false
  guest_agent          = true
  cloudinit_datasource = "nocloud"
  ha_group             = "web"

  # Stockage
  vergeio_drive {
    name           = "Disque OS du serveur web"
    description    = "Disque du système d’exploitation"
    disksize       = 10
    interface      = "virtio-scsi"
    preferred_tier = 3
    orderid        = 0
  }

  # Réseau
  vergeio_nic {
    name        = "Réseau du serveur web"
    description = "NIC pour le serveur web"
    interface   = "virtio"
    enabled     = true
    vnet        = vergeio_network.web_network.id
  }
}
```

#### Réseau interne avec DHCP

```hcl
resource "vergeio_network" "web_network" {
  name            = "web-internal-network"
  network_address = "192.168.10.0/24"
  dns_server_list = ["8.8.8.8", "8.8.4.4"]
  dhcp_enabled    = true
  dhcp_start      = "192.168.10.100"
  dhcp_end        = "192.168.10.200"
}
```

#### Interrogation des VM existantes

Utilisez des sources de données pour référencer une infrastructure existante sans la gérer :

```hcl
data "vergeio_vms" "production" {
  filter_name = "prod-db"
  is_snapshot  = false
}

output "production_vms" {
  value = data.vergeio_vms.production.vms
}
```

#### Intégration cloud-init

Le `vergeio_vm` la ressource prend en charge cloud-init pour l’automatisation du premier démarrage. Le schéma du fournisseur expose un `cloudinit_datasource` attribut sur la VM et une `vergeio_cloudinitfiles` source de données pour référencer des fichiers cloud-init déjà présents dans VergeOS :

```hcl
resource "vergeio_vm" "app_server" {
  name                 = "app-server-01"
  os_family            = "linux"
  cpu_cores            = 4
  machine_type         = "q35"
  ram                  = 8192
  guest_agent          = true
  cloudinit_datasource = "nocloud"

  vergeio_drive {
    name           = "Disque OS"
    disksize       = 20
    interface      = "virtio-scsi"
    preferred_tier = 2
  }

  vergeio_nic {
    interface = "virtio"
    vnet      = vergeio_network.web_network.id
  }
}
```

Pour connaître la syntaxe exacte utilisée pour joindre des fichiers cloud-init en ligne dans la ressource VM (par opposition au référencement de fichiers préalablement téléversés via la source de données), consultez le [référentiel du fournisseur](https://github.com/verge-io/terraform-provider-vergeio) — la forme au niveau des champs peut évoluer entre les versions.

### Maturité et feuille de route

{% hint style="warning" %}
**Vérifier la couverture actuelle des ressources**

Le fournisseur Terraform VergeOS est en développement actif, et tous les objets VergeOS ne sont pas encore exposés comme ressources gérées. Parmi les domaines qui peuvent ne pas être entièrement couverts par le fournisseur à un moment donné figurent le provisionnement des tenants, la gestion des profils de snapshot et la configuration des réseaux externes/WAN.

Vérifiez toujours [le dépôt GitHub](https://github.com/verge-io/terraform-provider-vergeio) ainsi que la fiche du Terraform Registry pour connaître la couverture actuelle des ressources et les notes de version avant de concevoir une configuration autour de ceux-ci.
{% endhint %}

## Plugin Packer

Le **Plugin Packer pour VergeOS** (`github.com/verge-io/packer-plugin-vergeio`) automatise la création d’images de VM directement sur la plateforme VergeOS. Là où Terraform gère l’infrastructure en fonctionnement, Packer se concentre sur la création des **images de référence** qui servent de base aux déploiements.

### Pourquoi Packer ?

```mermaid
flowchart LR
    A["ISO de base"] --> B["Construction Packer"]
    B --> C["Installer des paquets<br/>Durcir l’OS<br/>Configurer les services"]
    C --> D["Image de référence"]
    D --> E["Recette de VM"]
    D --> F["Déploiement Terraform"]
    D --> G["Provisionnement manuel"]

    style B fill:#4a9eff,color:#fff
    style D fill:#2ecc71,color:#fff
```

Les images de référence garantissent que chaque VM déployée démarre à partir d’une base connue, testée et durcie. Au lieu de provisionner un système d’exploitation vierge et d’exécuter des scripts de configuration à chaque déploiement, Packer prépare l’image une seule fois :

* **Cohérence** — Chaque VM créée à partir de l’image est identique
* **Rapidité** — Aucun délai de provisionnement au premier démarrage ; les VM sont prêtes immédiatement
* **Conformité** — Les bases de sécurité et les correctifs sont intégrés au moment de la construction
* **Intégration au pipeline** — Déclencher les reconstructions d’images depuis la CI/CD lors des journées de correctifs de l’OS

### Configuration du plugin

Le plugin Packer est déclaré dans un `required_plugins` bloc aux côtés d’un `source` et `build` pour l’image cible. Les noms exacts des champs du `source "vergeio"` bloc (point de terminaison, identifiants, dimensionnement de la VM, options de disque, etc.) doivent être repris du dépôt du plugin, car ils peuvent évoluer entre les versions :

* [`verge-io/packer-plugin-vergeio` sur GitHub](https://github.com/verge-io/packer-plugin-vergeio)

Une `required_plugins` déclaration type ressemble à ceci :

```hcl
packer {
  required_plugins {
    vergeio = {
      source  = "github.com/verge-io/vergeio"
      version = ">= 0.1.1"
    }
  }
}
```

### Capacités

À haut niveau, le plugin pilote l’intégralité du cycle de construction Packer contre l’API VergeOS — création d’une VM temporaire, exécution de provisioners et capture de l’image résultante. Pour connaître le schéma de configuration exact, les types d’invités pris en charge et le comportement d’arrêt/nettoyage, consultez directement le dépôt du plugin :

* [`verge-io/packer-plugin-vergeio` sur GitHub](https://github.com/verge-io/packer-plugin-vergeio)

### Pipeline Packer → Recettes

Les images Packer s’intègrent naturellement au système de **Recette** VergeOS. Flux de travail typique :

1. **Packer** construit et durcit l’image de référence selon un calendrier (p. ex. cycle mensuel de correctifs)
2. L’image est enregistrée comme une **Recette de VM** dans le Marketplace VergeOS
3. Les utilisateurs déploient des VM standardisées à partir de la recette — soit via l’interface, soit via Terraform
4. Les mises à jour suivent automatiquement : reconstruisez l’image Packer, mettez à jour la recette, et tous les nouveaux déploiements obtiennent la dernière version

## Modèles de flux de travail IaC

### Flux de travail Terraform seul

Pour les équipes qui veulent une infrastructure déclarative sans pipeline d’images :

```mermaid
flowchart LR
    A["Config HCL"] --> B["terraform plan"]
    B --> C["terraform apply"]
    C --> D["API VergeOS"]
    D --> E["VM + réseaux<br/>créés"]

    style B fill:#7b42f5,color:#fff
    style C fill:#4a9eff,color:#fff
```

### Pipeline complet (Packer + Terraform)

Pour les environnements de production avec gestion des images de référence :

```mermaid
flowchart LR
    A["ISO de base"] --> B["Construction Packer"]
    B --> C["Image de référence"]
    C --> D["Déploiement Terraform"]
    D --> E["VM de production"]
    F["Déclencheur CI/CD"] -.-> B

    style B fill:#2ecc71,color:#fff
    style D fill:#4a9eff,color:#fff
```

### Combiné avec d’autres outils

Terraform gère le provisionnement ; les outils de gestion de configuration gèrent le reste :

| Phase                | Outil                        | Rôle                                           |
| -------------------- | ---------------------------- | ---------------------------------------------- |
| **Création d’image** | Packer                       | Construire des images de référence durcies     |
| **Provisionnement**  | Terraform                    | Déployer des VM, des réseaux, des utilisateurs |
| **Configuration**    | Ansible / cloud-init         | Configuration logicielle après déploiement     |
| **Surveillance**     | Prometheus / alertes VergeOS | Observer l’infrastructure déployée             |

{% hint style="info" %}
**Pont VMware**

Sur VMware, le fournisseur vSphere de Terraform gère ESXi/vCenter/vSAN comme des préoccupations distinctes et Packer utilise le `vsphere-iso` constructeur via vCenter. Le seul fournisseur VergeOS `vergeio` gère les VM, les réseaux, les disques et les utilisateurs via un seul point de terminaison d’API, et le plugin Packer cible la même API.
{% endhint %}

{% hint style="info" %}
**Pont Nutanix**

Le fournisseur Terraform Nutanix (`nutanix/nutanix`) et le plugin Packer ciblent tous deux l’API v3 de Prism Central. Le fournisseur VergeOS communique avec un seul point de terminaison (l’URL du système ou du tenant VergeOS), sans instance de gestion séparée, et expose la configuration cloud-init directement sur la `vergeio_vm` ressource via l’ `cloudinit_datasource` attribut et la `vergeio_cloudinitfiles` source de données.
{% endhint %}

## Bonnes pratiques

### Gestion de l’état

* **Utilisez des backends d’état distants** (S3, Consul, Terraform Cloud) pour la collaboration en équipe
* **Ne commitez jamais** `terraform.tfstate` dans le contrôle de version — il peut contenir des identifiants
* **Verrouillez les fichiers d’état** pour empêcher les modifications concurrentes dans les environnements multi-utilisateurs

### Sécurité

* **Utilisez des variables** pour les valeurs sensibles (`var.vergeos_password`) — ne codez jamais les identifiants en dur
* **Marquez les sorties sensibles** avec `sensitive = true` pour éviter toute exposition accidentelle dans les journaux
* **Restreignez les autorisations du fournisseur** — créez un utilisateur API VergeOS dédié avec l’accès minimal requis

### Organisation des modules

* **Séparez les environnements** dans des workspaces ou des répertoires (`dev/`, `staging/`, `prod/`)
* **Créez des modules réutilisables** pour les modèles courants (par ex., un module "web-server" avec VM + réseau + règles de pare-feu)
* **Pinez les versions du fournisseur** pour éviter des changements cassants inattendus lors des mises à niveau

## Lectures complémentaires

* [Fournisseur Terraform — GitHub](https://github.com/verge-io/terraform-provider-vergeio)
* [Terraform Registry — fournisseur VergeIO](https://registry.terraform.io/providers/verge-io/vergeio/latest)
* [Plugin Packer — GitHub](https://github.com/verge-io/packer-plugin-vergeio)
* [OpenTofu Registry — fournisseur VergeIO](https://search.opentofu.org/provider/verge-io/vergeio/latest)
* [Documentation VergeOS — fournisseur Terraform](https://docs.verge.io/product-guide/tools-integrations/terraform-provider/)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.verge.io/learn-the-platform/fr/module-8-developpeur-et-devops/04-terraform-packer.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.