L'infrastructure as code facile avec Terraform et scaleway

Oct 16, 2023 min read

Terraform, c’est quoi ?

On replace le contexte : C’est un outil qui permet de créer des objets dans le cloud.  En gros, on décrit dans des fichiers les instances, les groupes de sécurité, les load-balancers, les réseaux et tout ce qui fait un SI.

Terraform lit des fichiers dans lesquels sont décrits les objets et les crée dans le système du cloud en se connectant aux apis de ce même cloud. (J’élargis la notion de cloud à tout système permettant de gérer une infrastructure, comme vmware, openstack ou même kubernetes)

Terraform étant un outil multicloud, dans les exemples suivants, nous utiliserons le cloud de SCALEWAY, que j’affectionne particulièrement, tant pour son prix que pour les bonnes idées et la dynamique des équipes.

1. Création des identifiants de connexion scaleway

Créez tout d’abord un compte gratuitement sur https://console.scaleway.com/register et renseignez vos coordonnées bancaire (et oui, ça va coûter des sous si vous suivez ce tutoriel, mais c’est pour la bonne cause, mais rassurez-vous, nous partirons sur une instance à 0,006€ de l’heure, ce qui devrait faire qq centimes)

Ensuite, il faut créer un token d’API pour être autorisé à envoyer des requètes à la plateforme de cloud de façon sécurisée.

Pour scaleway, tout est expliqué ici (anglais) : How to generate an API token

Mais bon sinon, en résumé, vous cliquez sur “credentials” dans le menu en haut à droite de la console scaleway :

Ensuite, vous cliquez sur le bouton vert “generate new token” :

Donnez un nom à votre token :

Notez bien les informations ( le secret ne s’affichera qu’une fois !)

Voilà, le token est créé.

NE LE DIFFUSEZ PAS ! Celà donne un accès direct à votre portefeuille et n’importe qui pourrait l’utiliser. (Ne rêvez pas, celui que je vous donne est déjà supprimé ).

Gardez en tête que les objets que vous créez avec ceci sont payants. Dans le cas de scaleway, ça ne coûte pas très cher, mais la facture peut monter très vite chez amazon, par exemple.

**        2. Création des fichiers terraform**

Premièrement, installez le client terraform comme indiqué ici : https://learn.hashicorp.com/terraform/getting-started/install.html

Pour des questions pratiques, vous pouvez également cloner dès à présent ce repo dans lequel vous trouverez tout le code qui suit :

_`git clone https://github.com/jeremiegoldberg/terraform_howto.git`_

On crée le fichier “provider.tf” dans notre projet. (Le découpage des fichiers n’est pas obligatoire, mais on le fait pour plus de lisibilité), le provider étant le lien entre votre cloud et votre code.

on y rentre les information récupérées précédemment :

`provider "scaleway" {`  
 `access_key      = "SCW4WVSRBY9TBRBWKHSR"`  
 `organization_id = "<mon organisation_ID>"`  
 `secret_key      = "f4609fc2-7964-47a4-835e-8ea9a44c6b30"`  
 `region          = "fr-par"`  
 `zone            = "fr-par-1"`  
`}`

Nous créons le fichier instance.tf dans lequel nous allons mettre toutes les informations relatives à notre première instance de serveur.

Dans ce fichier, nous commençons par créer une adresse ip publique :

resource "scaleway\_instance\_ip" "public\_ip" {}

Ensuite, le security group, qui gère le parefeu du serveur que l’on va créer :

resource "scaleway\_instance\_security\_group" "my\_security\_group" {  
 external\_rules = true  
 name = "netasgard\_VPC"  
}  
resource "scaleway\_instance\_security\_group\_rules" "security-rule" {  
security\_group\_id = "${scaleway\_instance\_security\_group.netasgard\_private.id}"  
  
inbound\_rule {  
action = "accept"  
 port   = "22"  
  }  inbound\_rule {  
action = "accept"  
 port   = "80"  
  }  inbound\_rule {  
action = "accept"  
 port   = "443"  
}  inbound\_rule {  
     action = "drop"  
  }  
}

On recherche la dernière image docker x86_64 :

data "scaleway\_image" "docker" {  
architecture = "x86\_64"  
name = "Docker"  
}

Le code suivant permet de créer une instance, un DEV1-S avec l’image docker récupérée juste avant:

resource "scaleway\_instance\_server" "instance" {  
  name  = "monserveur"  
  type  = "DEV1-S"  
  image = "${data.scaleway\_image.docker.id}"  
  tags = \[ "tag1", "tag2" \]  
  ip\_id = scaleway\_instance\_ip.public\_ip.id  
  security\_group\_id = "${scaleway\_instance\_security\_group.my\_security\_group.id}  
connection {  
    type     = "ssh"  
    user     = "root"  
    host     = "${scaleway\_instance\_ip.public\_ip.address}"  
  }  
  provisioner "file" {  
    source      = "files/docker-compose.yml"  
    destination = "/root/docker-compose.yml"  
  }  
  provisioner "remote-exec" {  
    inline = \[  
      "docker-compose up -d"  
    \]  
  }  
}

Notez que j’ai rajouté une petite partie supplémentaire dans le code ci-dessus. Nous allons démarrer notre instance et automagiquement y déployer wordpress et mysql.

Parce que pourquoi pas.

Je déclare une connexion ssh avec le user et l’ip distante qui est notre ip publique (déclarée en premier dans ce tuto)

  connection {  
    type     = "ssh"  
    user     = "root"  
    host     = "${scaleway\_instance\_ip.public\_ip.address}"  
  }

Je copie en scp le fichier docker-compose.yml sur le serveur dans le /root/

  provisioner "file" {  
    source      = "files/docker-compose.yml"  
    destination = "/root/docker-compose.yml"  
  }

J’exécute le docker-compose pour démarrer les application sur la machine

  provisioner "remote-exec" {  
    inline = \[  
      "docker-compose up -d"  
    \]  
  }

Dernière chose, en fin de fichiers, ces dernières lignes pour que le script nous donne l’url de notre wordpress:

output "lien\_de\_wordpress" {  
value = \["http://${scaleway\_instance\_ip.public\_ip.address}"\]  
}

/!\ N’oubliez pas de pousser vos clés publiques ssh chez scaleway (au même endroit que la création des identifiants), sinon la création de la machine échouera. Et même si on retire les 3 derniers morceaux de code ci-dessus, vous ne pourrez pas vous connecter à la machine, la connexion ssh par mot de passe étant abandonnée chez scaleway.

**        3. Exécution du code**

Bon, commençons la partie magique.

Initialisons le depot terraform :

_terraform init_

Ce qui donne la sortie suivante:

Ça y est, Terraform est prêt ! On va pouvoir lancer les hostilités et créer notre serveur avec la commande

terraform apply

Terraform détaille l’ensemble des objets qui vont être créé avant de lancer l’exécution.

Le prompt attend un “yes” de votre part pour continuer :

C’est parti pour la création de notre instance !

Et quand tout s’est bien passé, vous obtenez :

Suivez le lien et vous aboutirez sur un wordpress tout neuf :

Pour détruire tout ce qui a été créé via terraform, c’est simple :

terraform destroy

Et voilà, celà ne vous coûte plus rien.

En conclusion

En quelques fichiers, nous avons installé un CMS wordpress avec sa base de données. Nous avons déployé ça sur une instance à 2,99€ par mois sur un cloud compatible avec terraform.

Avec la même facilité, nous aurions pu utiliser ansible ou autre gestionnaire de configuration sur l’instance nouvellement créée. Nous aurions pu déployer également de nombreuses instances en parallèle de celle-ci, avec des applications diverses, grâce à docker-compose.

Les possibilités sont infinies. Ce n’est qu’un exemple très simple de ce que l’on peut faire. Le but de ce billet est de prouver que de faire de l’infrastructure as code n’est ni cher, ni compliqué. C’est avant tout une question de volonté.

Pour approfondir, si vous voulez comprendre les atouts et dangers du cloud, je vous renvois vers mon billet sur le sujet

-|