Créer une instance et s'y connecter

Connectez-vous à la console OpenStack en cliquant sur le bouton Open horizon depuis la console >BETA_.

Créez d'abord une paire de clés (key pair) en important la clé publique SSH.

Dans le bandeau gauche, allez dans la section Compute > Key Pairs et cliquez sur le bouton Import Public Key.

Importez votre clé.

Dans le bandeau gauche, allez dans la section Compute > Instances et cliquez sur le bouton Launch Instance.

Dans la première section (Details) :

• nommez l'instance
• choisissez nova-vm pour l'Availability Zone
• cliquez sur Next

Dans la section suivante (Source) :

• dans le champ Select Boot Source, choisissez Image et surtout cliquez sur Yes pour Create New Volume
• choisissez la taille du volume, qui doit être au moins égale à celle nécessaire pour l'image, et cliquez sur Yes pour Delete Volume on Instance Delete
• choisissez l'image désirée et cliquez sur la flèche vers le haut à droite de l'image
• cliquez sur Next

Les images gérées par OVHcloud ainsi que les images ajoutées par l'utilisateur sont listées.

Dans la section suivante, choisissez le gabarit de l'instance en cliquant sur la flèche vers le haut à droite du gabarit désiré. Les classes de gabarits sont décrites dans l'onglet SNC Regional Panel.

Cliquez sur Next.

Dans la section suivante, choisissez le réseau sur lequel sera connectée l'instance.

Si l'instance doit être accessible depuis le réseau public, choisissez le réseau Ext-Net.

Cliquez ensuite sur Next jusqu'à la section Key Pair.

Dans la section Key Pair, choisissez la clé précédemment créée et cliquez sur Launch Instance.

L'instance est en cours de création. Attendez qu'elle soit au statut Active pour s'y connecter.

Son adresse IP publique apparaît dans la colonne IP Address.

Connectez-vous ensuite à l'instance en SSH (reportez-vous à la section « Connexion à l'instance »).

Tout d'abord, installez la CLI OpenStack. Voici un exemple sous Debian 13 :

sudo apt update
sudo apt install -y python3 python3-pip python3-venv
python3 -m venv ~/.venvs/osc
. ~/.venvs/osc/bin/activate
pip install --upgrade pip
pip install python-openstackclient
echo "source ~/.venvs/osc/bin/activate" >> ~/.bashrc

Créez ensuite un application credential qui fournira les identifiants nécessaires pour se connecter aux API.

Dans la console >BETA_, cliquez sur l'icône du profil en haut à droite, allez dans le menu API access puis cliquez sur le bouton Create application credentials.

Nommez l'application et définissez sa date d'expiration (ne renseignez rien pour éviter l'expiration de l'application). Cliquez sur Request credentials.

Copiez le secret de l'application affiché : il ne pourra plus être récupéré une fois la fenêtre contextuelle fermée.

L'application apparaît dans la liste des applications.

Enfin, récupérez le fichier clouds.yaml en cliquant sur Download clouds.yaml en haut à droite, renseignez les champs demandés et cliquez sur Download clouds.yaml.

Un fichier clouds.yaml va être téléchargé sur le poste de travail. Copiez-le ensuite dans le répertoire ~/.config/openstack/ (ou dans le répertoire depuis lequel les commandes sont lancées). Il permettra l'accès aux API OpenStack.

Pour vérifier l'accès aux API :

(osc) $ openstack server list
+--------------------------------------+------------+--------+----------------------------------------------+--------------------------+--------+
| ID                                   | Name       | Status | Networks                                     | Image                    | Flavor |
+--------------------------------------+------------+--------+----------------------------------------------+--------------------------+--------+
| 1d4bbfcc-48b5-4cb2-80ba-5aafd9f5a0eb | test       | ACTIVE | Ext-Net=192.0.2.10                          | N/A (booted from volume) | b3-8   |
+--------------------------------------+------------+--------+----------------------------------------------+--------------------------+--------+

Créez d'abord une clé SSH à partir de votre clé publique :

(osc) $ openstack keypair create --type ssh --public-key my_key.pub test
+-------------+-------------------------------------------------+
| Field       | Value                                           |
+-------------+-------------------------------------------------+
| created_at  | None                                            |
| fingerprint | ae:e7:62:0a:cf:7f:18:55:d3:f6:5b:96:f5:53:a2:b0 |
| id          | test                                            |
| is_deleted  | None                                            |
| name        | test                                            |
| type        | ssh                                             |
| user_id     | 0123456789abcdef0123456789abcdef                |
+-------------+-------------------------------------------------+

L'instance peut maintenant être créée. On reprend le même exemple que dans les autres méthodes : b3-8, disque de 20 Go, image Debian 13 :

(osc) $ openstack image list -f value -c Name | grep -i "debian 13"
Debian 13

(osc) $ openstack server create --flavor b3-8 --image "Debian 13" --boot-from-volume 20 --network Ext-Net --key-name test test
...

openstack server show test -f value -c volumes_attached   # avant de supprimer l'instance : noter l'ID du volume de boot
openstack volume delete <volume-id>                        # une fois l'instance supprimée

Attendez que l'instance soit au statut ACTIVE et récupérez son IP publique :

(osc) $ openstack server show test -f value -c status -c addresses
{'Ext-Net': ['192.0.2.10']}
ACTIVE

Connectez-vous ensuite à l'instance en SSH avec l'utilisateur debian (reportez-vous à la section « Connexion à l'instance »).

Tout d'abord, installez la CLI OpenTofu. Voici un exemple sous Debian 13 :

sudo apt update
sudo apt install -y apt-transport-https ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://get.opentofu.org/opentofu.gpg | sudo tee /etc/apt/keyrings/opentofu.gpg > /dev/null
curl -fsSL https://packages.opentofu.org/opentofu/tofu/gpgkey | sudo gpg --no-tty --batch --dearmor -o /etc/apt/keyrings/opentofu-repo.gpg > /dev/null
sudo chmod a+r /etc/apt/keyrings/opentofu.gpg /etc/apt/keyrings/opentofu-repo.gpg
echo "deb [signed-by=/etc/apt/keyrings/opentofu.gpg,/etc/apt/keyrings/opentofu-repo.gpg] https://packages.opentofu.org/opentofu/tofu/any/ any main" | sudo tee /etc/apt/sources.list.d/opentofu.list > /dev/null
sudo apt update
sudo apt install -y tofu

Vérifiez l'installation :

$ tofu version
OpenTofu v1.12.2
on linux_amd64

Créez ensuite un application credential qui fournira les identifiants nécessaires pour se connecter aux API, comme détaillé dans l'onglet CLI OpenStack.

Voici un exemple simplifié de scripts Terraform pour créer la paire de clés SSH et l'instance, avec en sortie l'adresse IP publique de l'instance. L'authentification passe par le même clouds.yaml que la CLI, via les variables d'environnement OS_CLOUD et OS_CLIENT_CONFIG_FILE :

export OS_CLOUD=openstack
export OS_CLIENT_CONFIG_FILE=/chemin/vers/clouds.yaml

// provider.tf
#
# Providers definition
#

# Providers
terraform {
  required_providers {
    openstack = {
      source  = "terraform-provider-openstack/openstack"
    }
  }
}

# OpenStack provider
# Authentification identique à celle de la CLI : clouds.yaml + OS_CLOUD
# (voir le guide Terraform de la plateforme). Pas de secret en clair dans les .tf.
provider "openstack" {
  cloud = "openstack"
}


// variables.tf
#
# Variables for the deployment
#

# SSH Key
variable "ssh_key" {
  description = "ssh key"
  default     = {
    public_key = "ssh-ed25519 xxxxxx user@domain",
    name       = "test"
  }
}

# Instance
variable "instance" {
  description = "Instance parameters"
  default     = {
    image                 = "Debian 13"
    flavor                = "b3-8"
    volume_size           = 20
    delete_on_termination = true
  }
}


// instance.tf
#
# Instance deployment
#

# Get image id
data "openstack_images_image_v2" "debian" {
  name        = var.instance.image
  most_recent = true
}

# SSH Key creation
resource "openstack_compute_keypair_v2" "test" {
  name       = var.ssh_key.name
  public_key = var.ssh_key.public_key
}

# Instance creation
resource "openstack_compute_instance_v2" "test" {
  name        = "test"
  flavor_name = var.instance.flavor
  key_pair    = var.ssh_key.name
  block_device {
    uuid                  = data.openstack_images_image_v2.debian.id
    source_type           = "image"
    destination_type      = "volume"
    boot_index            = 0
    volume_size           = var.instance.volume_size
    delete_on_termination = var.instance.delete_on_termination
  }
  network {
    name = "Ext-Net"
  }
  depends_on = [
    openstack_compute_keypair_v2.test
  ]
  security_groups = ["default"]
}

// outputs.tf
output "ip_address" {
  description = "instance public IP address"
  value       = openstack_compute_instance_v2.test.network[0].fixed_ip_v4
}

Initialisez et appliquez la configuration :

$ tofu init
...
$ tofu version
OpenTofu v1.12.2
on linux_amd64
+ provider registry.opentofu.org/terraform-provider-openstack/openstack v3.4.0

$ tofu apply
...
Plan: 2 to add, 0 to change, 0 to destroy.

Changes to Outputs:
  + ip_address = (known after apply)

Do you want to perform these actions?
  OpenTofu will perform the actions described above.
  Only 'yes' will be accepted to approve.

  Enter a value: yes

...
openstack_compute_instance_v2.test: Creating...
openstack_compute_instance_v2.test: Still creating... [10s elapsed]
...
openstack_compute_instance_v2.test: Creation complete after 2m21s [id=8e97df41-f2e2-43f7-a1d7-a7fa4121ab11]

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

Outputs:

ip_address = "192.0.2.10"

Connectez-vous ensuite en SSH avec l'utilisateur associé à l'image, et la clé privée associée à la clé publique enregistrée.