Déployer un manchot avec du tofu

Volontairement bizarre ce titre va me permettre d'introduire Opentofu avec une petite mise en place simple.

Je vais pas revenir sur l'actualité récente du changement de licence d'HashiCorp qui développe le maintenant très utilisé Terraform, je vous laisse faire vos recherches et votre avis sur la situation.

Assez rapidement le projet Opentofu à été mis en place pour proposer une solution Truly open-source, c'est eux qui le disent.

Mon objectif ici est d'être assez pragmatique et de tester une première mise en place et après on verra au fur et à mesure de l'évolution des besoins.

J'avais fait à l'époque de feu K' Rement Libre, une soirée dédiée à l'IAC et pendant la démo je déployais une infra complète avec les services suivants :

• serveur Debian 10
• hébergé chez OVHCloud
• services Apache / PHP-FPM / MariaDB / Docker
• déploiement de Nextcloud
• déploiement de Collabora Online

Terraform gérait la première partie

• créer une instance chez l'hébergeur
• faire les enregistrements dns
• déléguer la suite à Ansible

Je vais pas ici tout refaire (peut-être plus tard) mais juste tester le déploiement de le VM avec Tofu.

Installation

Pour l'installation, il y a plusieurs solutions, j'ai de mon côté sur ma Linux Mint, installé le fichier .deb en le récupérant ici.

Il y a d'autres méthodes, voir la page officielle d'installation.

Ce qui donne une fois installé

tofu --version
OpenTofu v1.6.0-alpha3
on linux_amd64

Créer le projet

Les différents fichiers pour mon infrastructure vont être gérés dans un répertoire, répertoire bien sûr à versionner avec git.

Providers

Le premier fichier va permettre de définir les providers à utiliser, les providers sont les abstractions permettant de se connecter aux différentes API. Tofu réutilise les providers de Terraform.

Dans mon cas j'en ai besoins de deux : ovh api et openstack. Ce qui me donne la configuration suivante dans le fichiers providers.tf

terraform {
  required_providers {
    ovh = {
      source = "ovh/ovh"
    }
    openstack = {
      source  = "terraform-provider-openstack/openstack"
      version = "~> 1.51.1"
    }
  }
}

provider "openstack" {
  auth_url = "https://auth.cloud.ovh.net/v3"
  domain_name = "default"
  alias = "ovh"
  user_name = "${var.os_username}"
  tenant_name = "${var.os_tenant_name}"
  password = "${var.os_password}"
  region = "${var.os_region_name}"
}

provider "ovh" {
  endpoint = "ovh-eu"
  application_key = "${var.application_key}"
  application_secret = "${var.application_secret}"
  consumer_key = "${var.consumer_key}"
}

Les variables

L'objecctif est de variabiliser un maximum de choses, je les identifie dans un fichier variables.tf

# Openstack OVH
variable "os_tenant_id" {
  description = "OpenStack Tenant ID"
}

variable "os_tenant_name" {
  description = "Openstack Tenant Name"
}

variable "os_username" {
  description = "Openstack Username"
}

variable "os_password" {
  description = "Openstack Password"
}

variable "os_region_name" {
  description = "Openstack Region"
}

# Variables OVH API
variable "application_key" {
  description = "OVH Application key"
}

variable "application_secret" {
  description = "OVH Application Secret"
}

variable "consumer_key" {
  description = "OVH Consumer Key"
}

# VMs
variable "vmname" {
  description = "VM Name"
}

variable "flavor" {
  description = "VM Flavor"
}

Et leur valeurs dans terraform.tfvars :

# OVH API
application_key=""
application_secret="" 
consumer_key=""

# Projet Openstack
os_tenant_id=""
os_tenant_name=""
os_username=""
os_password=""
os_region_name=""

# VM
vmname = ""
flavor = ""

On fait quoi ?

Une fois les proiders définies, ainsi que les variables on va dire à Tofu ce qu'il doit faire. Je met ces instructions dans main.tf

# Création d'une paire de clé SSH
resource "openstack_compute_keypair_v2" "keypair" {
  provider = openstack.ovh
  name = "keypaircode"
  public_key = "${file("~ficher.pub")}"
}

# Création d'une vm chez le provider
resource "openstack_compute_instance_v2" "instance01" {
  provider = openstack.ovh
  name = "${var.vmname}"
  flavor_name = "${var.flavor}"
  image_name = "Debian 12"
  key_pair = "${openstack_compute_keypair_v2.keypair.name}"
  network {
    name = "Ext-Net" 
  }
}

Je fais que deux choses en fait :

1. je défini ma clé ssh à utiliser en précisant le fichier .pub de ma clé
2. je crée une vm avec la clé ssh que j'ai précisé au dessus

Afficher des informations en sortie

Dernier fichier, le fichier output.tf qui va me permettre ici de récupérer l'ip de la vm

output "webserver" {
  value = "${openstack_compute_instance_v2.instance01.access_ip_v4}"
}

Déployer

Une fois tout ça préparé on va pouvoir déployer notre mini-infra avec le workflow défini par Opentofu (idem à celui de Terraform)

Initialiser le projet

Permet d'initialiser le projet, notement de récupérer les providers :

tofu init

Les fichiers seront stockés dans le répertoire .terraform/providers/

Planifier / prévisualiser le déploiement

Permet de vérifier et corriger le déploiement :

tofu plan
...
OpenTofu will perform the following actions:
...

Déployer

C'est parti mon kiki

tofu apply

Après quelques secondes (en fait à peu près 1mn)

...
Apply complete! Resources: 2 added, 0 changed, 0 destroyed.

Outputs:

webserver = "IP"

Encore un peu d'attente et je peux me connecter en ssh dessus avec ma clé.

Détruire et reconstruire

C'est en forgeant ...
On peut assez rapidement tout supprimer

tofu destroy

Faire des modifications et recommencer.

Conclusion

Et voilà une petite recette à base de tofu pour déployer rapidement une vm.

J'avais pas beaucoup avancé dans ma formation Terraform et je la reprends donc avec Opentofu et pour le moment pas de perturbations. A suivre pour la suite.

Merci au site expressio.fr pour les citations 🙂