Lab 02 : Création d'une machine virtuelle

Objectifs

Dans cet atelier, vous allez créer une machine virtuelle en récupérant des éléments de réseau virtuel précédemment créés dans Cockpit.

Pré-requis

Terraform doit être installé et fonctionnel
Vous devez disposer de vos identifiants API (Acces Key et Secret Access Key) pour authentifier les appels d’API effectués par Terraform. Si ce n’est pas le cas, créez-en depuis cockpit.

Etapes à suivre

Afin de créer votre machine virtuelle en exécutant Terraform, vous allez :

Initier un projet Terraform et le configurer pour utiliser votre compte Outscale
Créer une paire de clef SSH
Créez un réseau correspondant au schéma ci-dessous depuis cockpit.
Créez aussi un groupe de sécurité contenant les trois règles ci-dessous :
- Règle pour autoriser une connexion ICMP depuis votre IP
- Règle pour autoriser une connexion SSH à depuis votre IP
- Règle pour autoriser une connexion HTTP à depuis votre IP

Architecture cible

Installation du provider Terraform Outscale

Vous pouvez accéder à la documentation du Provider Terraform Outscale via l’URL suivante :

https://registry.terraform.io/providers/outscale/outscale/latest/docs.

Pour se connecter à votre compte Outscale, commencez par créer des variables dans le fichier variables.tf :

L’ID de la clef d’accès au compte Outscale
L’ID de la clef secrète du compte Outscale
La région du compte Outscale

variable "access_key_id" {
  type      = string
  sensitive = true
}
variable "secret_key_id" {
  type      = string
  sensitive = true
}
variable "region" {
  default = "eu-west-2"
  type    = string
}

Dans le fichier terraform.tfvars affectez des valeurs aux variables restées vides.

access_key_id = "xxxxxxx"
secret_key_id = "xwxxxwxwx"

Dans le fichier providers.tf vous allez appliquer le code qui suit. C’est ce dernier qui va permettre de faire le lien entre votre projet Terraform et votre cloud provider Outscale.

terraform {
  required_providers {
    outscale = {
      source  = "outscale/outscale"
      version = ">= 0.12.0"
    }
  }
}

provider "outscale" {
  access_key_id = var.access_key_id
  secret_key_id = var.secret_key_id
  region        = var.region
}

Création de la paire de clef SSH

Pour la la création d’une paire de clef SSH, vous allez ajouter le code suivant dans le fichier keypair.tf :

# Création d’une clef privée RSA de 2048 bits
resource "tls_private_key" "my_key" {
  algorithm = "RSA"
  rsa_bits  = "2048"
}

# Stockage de la clef privée
resource "local_file" "my_key" {
  content         = tls_private_key.my_key.private_key_pem
  filename        = "${path.module}/my_key.pem"
  file_permission = "0600"
}

# Import de la clef
resource "outscale_keypair" "my_keypair" {
  keypair_name = "lab_terraform_as"
  public_key   = tls_private_key.my_key.public_key_openssh
}

Maintenant, vous allez pouvoir initier votre projet Terraform avec la commande suivante :

terraform init

Initializing the backend...

Terraform has been successfully initialized!

You may now begin working with Terraform. Try running "terraform plan" to see
any changes that are required for your infrastructure. All Terraform commands
should now work.

If you ever set or change modules or backend configuration for Terraform,
rerun this command to reinitialize your working directory. If you forget, other
commands will detect it and remind you to do so if necessary.

Vous allez ensuite vérifier le plan d’exécution, qui va vous permettre de prévisualiser les modifications que va effectuer Terraforme sur votre infrastructure :

terraform plan

Terraform used the selected providers to generate the following execution plan. Resource actions are indicated with the following symbols:
  + create

Terraform will perform the following actions:

    # local_file.my_key will be created
    + resource "local_file" "my_key" {
        + content              = (sensitive value)
        + content_base64sha256 = (known after apply)
        + content_base64sha512 = (known after apply)
        + content_md5          = (known after apply)
        + content_sha1         = (known after apply)
        + content_sha256       = (known after apply)
        + content_sha512       = (known after apply)
        + directory_permission = "0777"
        + file_permission      = "0600"
        + filename             = "./my_key.pem"
        + id                   = (known after apply)
      }

    # outscale_keypair.my_keypair will be created
    + resource "outscale_keypair" "my_keypair" {
        + id                  = (known after apply)
        + keypair_fingerprint = (known after apply)
        + keypair_name        = "lab_terraform_as"
        + private_key         = (known after apply)
        + public_key          = (known after apply)
        + request_id          = (known after apply)
      }

    # tls_private_key.my_key will be created
    + resource "tls_private_key" "my_key" {
        + algorithm                     = "RSA"
        + ecdsa_curve                   = "P224"
        + id                            = (known after apply)
        + private_key_openssh           = (sensitive value)
        + private_key_pem               = (sensitive value)
        + private_key_pem_pkcs8         = (sensitive value)
        + public_key_fingerprint_md5    = (known after apply)
        + public_key_fingerprint_sha256 = (known after apply)
        + public_key_openssh            = (known after apply)
        + public_key_pem                = (known after apply)
        + rsa_bits                      = 2048
      }

Plan: 3 to add, 0 to change, 0 to destroy.

------------------------

Note: You didn’t use the -out option to save this plan, so Terraform can’t guarantee to take exactly these actions if you run "terraform
apply" now.

si vous n’avez pas d’erreur, vous pouvez créez votre infrastructure avec la commande : terraform apply.

Vous devriez retrouver le fichier de la clé SSH my_key.pem dans le dossier :

ls -alrt
drwxr-xr-x   3 srt20  staff     96 27 aoû 07:58 ..
-rw-r--r--   1 srt20  staff    490 27 aoû 08:13 keypair.tf
-rw-r--r--   1 srt20  staff    254 27 aoû 08:14 providers.tf
-rw-r--r--   1 srt20  staff    264 27 aoû 08:18 .envrc
drwxr-xr-x   3 srt20  staff     96 27 aoû 08:19 .terraform
-rw-r--r--   1 srt20  staff   2828 27 aoû 08:19 .terraform.lock.hcl
-rw-r--r--   1 srt20  staff    111 27 aoû 08:34 main.tf
-rw-r--r--   1 srt20  staff    204 27 aoû 08:39 variables.tf
-rw-------   1 srt20  staff   1679 27 aoû 08:39 my_key.pem
-rw-r--r--   1 srt20  staff  12585 27 aoû 08:39 terraform.tfstate
drwxr-xr-x  11 srt20  staff    352 27 aoû 08:39 .

Récupération des éléments du réseau et sécurité existants

Dans le fichier main.tf utilisez le datasource outscale_subnet pour récupérez l’id de votre subnet créé précédement dans Cockpit. Remplacez le nom du tag par celui que vous avez attributé à votre subnet (si ce n’est pas le cas , alors ajoutez-en un) :

data "outscale_subnet" "subnet-a" {
  filter {
    name   = "tag_values"
    values = ["public_subnet-a"]
  }
}

Vous pouvez exécuter la commande terraform plan pour voir si vous récupérez correctement les ID.

Faites de même avec le groupe de sécurité.

Création de la machine virtuelle

Commencez par entrer les variables qui vous seront utilisées dans le fichier variables.tf :

variable "image_id" {
  type    = string
  default = "ami-7b8d1702"
}

variable "vm_type" {
  type    = string
  default = "tinav5.c1r1p3"
}

Puis dans le fichier main.tf où vous écrirez votre code pour créer votre machine virtuelle.

resource "outscale_vm" "vm_lab02" {
  image_id           = var.image_id
  vm_type            = var.vm_type
  keypair_name       = outscale_keypair.my_keypair.keypair_name
  security_group_ids = [data.outscale_security_group.security_group-a.security_group_id]
  subnet_id          = data.outscale_subnet.subnet-a.subnet_id

    tags {
      key   = "name"
      value = "vm_lab02"
    }
}

resource "outscale_public_ip" "public_ip_lab02" {
  tags {
    key   = "name"
    value = "public_ip_lab02"
  }
}

resource "outscale_public_ip_link" "public_ip_link_lab02" {
  vm_id     = outscale_vm.vm_lab02.vm_id
  public_ip = outscale_public_ip.public_ip_lab02.public_ip
}

Executez la commande terraform plan pour voir les modifications que Terraform effectuera et si vous n’avez pas d’erreurs. Si tout est bon, exécutez la commande terraform apply.

Sur Cockpit, rendez-vous sur la page listant les machines virtuelles et copier l’IP publique de la machine que vous venez de créer.

Cockpit

Testez la première règle de votre groupe de sécurité en faisant un ping sur votre machine virtuelle.
Testez la seconde règle de votre groupe de sécurité en vous connectant à votre machine virtuelle en SSH.

ssh -i ./my_key.pem outscale@217.75.171.111
Warning: Permanently added '217.75.171.111' (ED25519) to the list of known hosts.
Welcome to Ubuntu 22.04.1 LTS (GNU/Linux 5.15.0-56-generic x86_64)

* Documentation:  https://help.ubuntu.com
* Management:     https://landscape.canonical.com
* Support:        https://ubuntu.com/advantage

      System information as of Tue Aug 27 07:10:12 UTC 2024

      System load:  0.080078125       Processes:             92
      Usage of /:   16.7% of 9.51GB   Users logged in:       0
      Memory usage: 20%               IPv4 address for eth0: 10.0.1.156
      Swap usage:   0%

2 updates can be applied immediately.
To see these additional updates run: apt list --upgradable

The list of available updates is more than a week old.
To check for new updates run: sudo apt update

The programs included with the Ubuntu system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.

Ubuntu comes with ABSOLUTELY NO WARRANTY, to the extent permitted by
applicable law.

To run a command as administrator (user "root"), use "sudo &lt;command>".
See "man sudo_root" for details.

outscale@ip-10-0-1-156:~$

Enfin, testez la troisième règle de votre groupe de sécurité en installant apache sur votre VM avec les commandes :

sudo apt update -y && sudo apt install apache2 -y

Puis sur votre navigateur entrez l’IP publique de votre machine virtuelle.