Terraform et Packer

Infrastructure déclarative en tant que code pour VergeOS avec le fournisseur Terraform, OpenTofu et le plugin Packer pour la création automatisée d’images de référence.

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

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

Compatible OpenTofu

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

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 :

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

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 :

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 :

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 — la forme au niveau des champs peut évoluer entre les versions.

Maturité et feuille de route

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 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.

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 ?

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

Une required_plugins déclaration type ressemble à ceci :

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

Pipeline Packer → Recettes

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

Packer construit et durcit l’image de référence selon un calendrier (p. ex. cycle mensuel de correctifs)
L’image est enregistrée comme une Recette de VM dans le Marketplace VergeOS
Les utilisateurs déploient des VM standardisées à partir de la recette — soit via l’interface, soit via Terraform
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 :

Pipeline complet (Packer + Terraform)

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

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

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.

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.

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

PrécédentModule PowerShell (PSVergeOS)

SuivantCollection Ansible

Mis à jour il y a 2 mois

Ce contenu vous a-t-il été utile ?