Brancher les CLI officiels Scaleway, Outscale et Exoscale

Les trois CLI officiels pilotent Feint sans modification, avec une nuance de configuration par client que feint env signale au lieu de vous laisser la découvrir. Cette page installe d'abord scw et octl, puis déroule les commandes courantes des trois fournisseurs, puis les familles qui vont plus loin : le stockage bloc chez Scaleway et Exoscale, la séquence d'image dorée, et les quotas.

Ce que vous allez obtenir

À la fin de cette page, les trois CLI officiels créeront des ressources sur votre machine : un serveur chez Scaleway, un Net chez Outscale, un volume chez Exoscale si vous avez le CLI exo, chacun listé par sa propre commande.

• Installer scw et octl à une version épinglée, sans compte, et vérifier l'installation.
• Pointer chaque CLI officiel sur l'émulateur sans copier une variable.
• Lire ce que renvoie l'API quand elle diffère de ce que le CLI affiche.
• Créer un volume bloc chez Scaleway, et chez Exoscale si exo est installé.
• Dérouler la séquence d'image dorée, dans l'ordre que l'API impose.

Prérequis

L'émulateur Feint installé, un terminal Linux, curl, sha256sum et jq (qui extrait un champ d'une sortie JSON, utilisé par la séquence d'image dorée). Pour vérifier la signature d'octl, cosign 2.0 ou plus récent est nécessaire. Le CLI exo d'Exoscale est facultatif : cette page ne l'installe pas.

Installer scw et octl

scw et octl s'installent sans compte cloud, à une version que vous choisissez et que vous vérifiez. Cette section suppose l'émulateur Feint installé. Les deux CLI sont des binaires autonomes ; l'installation ne demande aucune connexion, puisque feint env fournit plus bas des identifiants fictifs. Les pages scw en détail et octl en détail couvrent les autres systèmes, la connexion à un vrai compte et les profils : ici, seul le strict nécessaire. Le CLI exo d'Exoscale reste une option : la section qui lui est consacrée suppose qu'il est déjà installé et configuré, ce que cette page ne couvre pas.

Pour scw, la version épinglée est la 2.65.1. Le binaire Linux amd64 se télécharge avec le fichier SHA256SUMS de la même release, dont la commande sha256sum contrôle l'intégrité avant toute installation.

VERSION=2.65.1
curl -fsSLO "https://github.com/scaleway/scaleway-cli/releases/download/v${VERSION}/scaleway-cli_${VERSION}_linux_amd64"
curl -fsSLO "https://github.com/scaleway/scaleway-cli/releases/download/v${VERSION}/SHA256SUMS"
sha256sum --ignore-missing -c SHA256SUMS
sudo install -m 0755 "scaleway-cli_${VERSION}_linux_amd64" /usr/local/bin/scw
scw version

La ligne du binaire doit afficher OK, et scw version doit afficher 2.65.1. Un FAILED signifie que le fichier est altéré : ne l'installez pas.

Pour octl, la version épinglée est la 0.0.33. Le binaire statique se télécharge depuis la release du dépôt outscale/octl, avec le fichier de sommes de contrôle de la même release. Ses binaires sont signés : la signature porte sur le fichier de sommes, que cosign vérifie avant que sha256sum ne contrôle le binaire. Le bloc ci-dessous enchaîne les deux. La page octl en détail explique la procédure.

VERSION=0.0.33
base="https://github.com/outscale/octl/releases/download/v${VERSION}"
curl -fsSL -o octl_Linux_x86_64 "$base/octl_Linux_x86_64"
curl -fsSLO "$base/octl_${VERSION}_checksums.txt"
curl -fsSLO "$base/octl_${VERSION}_checksums.txt.sigstore.json"
cosign verify-blob \
  --bundle "octl_${VERSION}_checksums.txt.sigstore.json" \
  --certificate-oidc-issuer "https://token.actions.githubusercontent.com" \
  --certificate-identity-regexp "^https://github.com/outscale/octl/" \
  "octl_${VERSION}_checksums.txt"
sha256sum --ignore-missing -c "octl_${VERSION}_checksums.txt"
sudo install -m 0755 octl_Linux_x86_64 /usr/local/bin/octl
octl --version

cosign doit répondre Verified OK, la ligne du binaire doit afficher OK, et octl --version doit afficher octl version v0.0.33 suivi de la liste des bibliothèques embarquées. La forme octl version, sans tirets, n'existe pas : elle répond unknown command "version". Deux précautions protègent votre éventuel vrai compte pendant les tests : lancez octl avec --no-upgrade, pour qu'il ne cherche pas de nouvelle version, et, si un profil réel existe sur votre poste, donnez-lui un fichier de configuration fictif avec --config plutôt que de laisser l'outil lire le vrai. Ce fichier doit contenir un profil nommé default (format décrit dans la page octl) : un fichier vide répond no default profile found.

Une version épinglée est une version qui vieillit

Ces deux versions sont celles avec lesquelles les exemples de la page ont été rejoués avec Feint 0.13.0. Elles ne reçoivent aucun correctif tant que vous ne les changez pas : relisez les pages des releases avant de reprendre un exemple dans un projet réel.

La leçon sur l'environnement de pratique cite pour sa part des sorties relevées avec scw 2.62.0, lors d'un rejeu daté du 2026-10-12, alors que cette page épingle la 2.65.1. Ce n'est pas une contradiction : la première relate un relevé précis, celle-ci prescrit la version à installer. Installez celle de cette page ; les sorties peuvent différer d'un champ ou d'une ligne entre les deux versions.

Scaleway avec scw

feint env scaleway produit l'environnement dont le client officiel a besoin. La commande n'écrit que des lignes export sur la sortie standard, ce qui rend eval sûr ; les remarques partent sur la sortie d'erreur.

eval "$(feint env scaleway)"
scw instance server create name=web-01 type=DEV1-S image=ubuntu_jammy zone=fr-par-1
scw instance server list zone=fr-par-1

Les variables produites pointent SCW_API_URL sur http://127.0.0.1:4599 et fournissent des identifiants bien formés mais fictifs. C'est suffisant : les SDK valident la forme des identifiants côté client avant d'émettre quoi que ce soit, et l'émulateur ne vérifie aucune signature.

Le serveur créé apparaît immédiatement en running dans la liste, alors que le protocole renvoie stopped à la création. L'explication n'est pas dans l'émulateur : scw instance server create envoie une action de démarrage juste après la création. Interrogé directement, l'émulateur répond ce que répondrait Scaleway :

{"name":"etat-initial","state":"stopped"}

Le stockage bloc Scaleway

Scaleway sert block : les volumes, leurs instantanés et le catalogue de types. Deux détails de forme méritent d'être connus parce qu'ils font échouer la commande avant même d'atteindre l'émulateur.

scw block volume create name=donnees from-empty.size=10G perf-iops=5000 zone=fr-par-1

{"name":"donnees","type":"sbs","size":10000000000,"class":"sbs","iops":5000,"status":"available"}

La taille se note en 10G, un nombre d'octets étant refusé par le CLI là où la commande instance l'accepte, et perf-iops est obligatoire. Un détail d'implémentation vaut d'être signalé pour qui écrit un script : scw interroge /block/v1alpha1 quand le provider Terraform interroge /block/v1. Les deux orthographes répondent, ce qui évite d'avoir à choisir entre deux clients officiels du même cloud.

La séquence d'image dorée

Une image dorée est un disque de référence, préparé une fois, à partir duquel on lance des machines identiques. Sa séquence est servie de bout en bout : un instantané (la photographie d'un volume à un instant donné) du volume, une image taillée dans cet instantané, puis la suppression dans l'ordre que l'API impose.

Il faut d'abord un volume source, et un volume que rien n'a jamais porté n'est pas photographiable : le vrai cloud refuse l'instantané d'un disque jamais attaché (cannot create a RO disk from an empty disk), et l'émulateur reproduit ce refus. Les trois commandes suivantes créent une machine constructeur, un volume local dont elles rangent l'identifiant dans $vol, puis l'attachent à la machine. L'identifiant se lit sous la clé volume de la réponse JSON, d'où .volume.id et non .id :

srv=$(scw instance server create name=constructeur type=DEV1-S image=ubuntu_jammy zone=fr-par-1 -o json | jq -r .id)
vol=$(scw instance volume create name=source volume-type=l_ssd size=10G zone=fr-par-1 -o json | jq -r .volume.id)
scw instance server attach-volume server-id="$srv" volume-id="$vol" zone=fr-par-1

On enchaîne ensuite. Chaque réponse enveloppe de même l'objet créé sous une clé (snapshot, image) :

snap=$(scw instance snapshot create name=snap-source volume-id="$vol" zone=fr-par-1 -o json | jq -r .snapshot.id)
img=$(scw instance image create name=image-doree snapshot-id="$snap" arch=x86_64 zone=fr-par-1 -o json | jq -r .image.id)
scw instance image list zone=fr-par-1 -o json | jq -c '[.[].name]'

["image-doree"]

L'image que vous créez apparaît dans la liste, et l'ordre de suppression est celui du vrai cloud : tant que l'image existe, l'instantané dont elle est tirée refuse de partir, avec un message qui nomme le coupable.

scw instance snapshot delete "$snap" zone=fr-par-1

scaleway-sdk-go: precondition failed: resource is still in use, the image 7f1db7e3-… is cut from this snapshot

C'est exactement l'ordre que Terraform parcourt quand un même plan retire les deux, ce qui rend ce refus utile plutôt que gênant. Pour nettoyer, on supprime donc l'image, puis l'instantané, puis la machine constructeur, enfin le volume :

scw instance image delete "$img" zone=fr-par-1 with-snapshots=false
scw instance snapshot delete "$snap" zone=fr-par-1
scw instance server terminate "$srv" zone=fr-par-1 with-ip=true with-block=true
scw instance volume delete "$vol" zone=fr-par-1

Une image taillée ici ne démarre toutefois rien : les octets d'un disque sont la seule chose qu'un émulateur ne peut pas fournir, et la limite est signalée au démarrage plutôt qu'à la création.

Outscale avec octl

Le client officiel d'Outscale est octl, qui remplace oapi-cli, archivé en amont. Il lit l'environnement, et feint env outscale lui donne directement la bonne forme d'adresse.

eval "$(feint env outscale)"
octl iaas net create --ip-range 10.0.0.0/16
octl iaas net list

Resolving alias to [octl iaas api CreateNet --output yaml --single --IpRange=10.0.0.0/16]
DhcpOptionsSetId: dopt-4d168602
IpRange: 10.0.0.0/16
NetId: vpc-ac76685b
State: available
Tags: []
Tenancy: default

La première ligne mérite un mot : octl annonce qu'il résout un alias vers l'action d'API sous-jacente. Les alias couvrent les cas courants, et la forme générique reste disponible pour toute action, ce qui en fait le remplacement direct des anciennes commandes :

octl iaas api CreatePublicIp

La sortie est l'objet créé suivi du ResponseContext (l'adresse et les identifiants de votre exécution diffèrent de l'exemple) :

{
  "PublicIp": {
    "PublicIp": "198.51.100.1",
    "PublicIpId": "eipalloc-c1efc8bc",
    "Tags": []
  },
  "ResponseContext": {
    "RequestId": "94aef720-f05c-4e44-83e4-dd551fc7081c"
  }
}

Une paire de clés se crée autrement, parce que l'API réelle et l'émulateur ne lisent pas la clé de la même façon. Générez d'abord une paire locale : ssh-keygen écrit la clé privée dans ./id et la clé publique dans ./id.pub.

ssh-keygen -t ed25519 -f ./id -N ''

L'API Outscale attend la clé publique encodée en Base64 dans le champ PublicKey (référence de l'action CreateKeypair sur docs.outscale.com). Avec octl, on ne la colle donc pas dans la commande : on lui donne le nom du fichier, qu'il lit et encode lui-même. --PublicKey="$(cat ./id.pub)" échoue, car octl prend ce texte pour un nom de fichier (no such file or directory). Contre le vrai Outscale, la commande est :

octl iaas api CreateKeypair --KeypairName=lab --PublicKey ./id.pub

Feint 0.13.0 s'écarte ici de l'API réelle : il attend la clé en clair et refuse la clé en Base64 avec l'erreur 4001 : PublicKey is not an OpenSSH public key. Contre l'émulateur, la commande octl ci-dessus échoue donc, et l'on envoie la requête directement avec curl et jq, en laissant la clé en clair :

jq -n --rawfile k ./id.pub '{KeypairName:"lab",PublicKey:$k}' \
  | curl -s -X POST http://127.0.0.1:4599/api/v1/CreateKeypair -d @-

{"Keypair":{"KeypairFingerprint":"57:72:5e:b8:3f:d0:72:9a:32:fc:be:44:95:6f:23:16","KeypairId":"key-c6290953425c4bb18ef2cc152316d58f","KeypairName":"lab","KeypairType":"ssh-ed25519","Tags":[]}}

La réponse complète porte en plus un ResponseContext. Pour vérifier, comparez l'empreinte à celle de votre clé : ssh-keygen -lf ./id.pub -E md5 affiche la même suite de 16 octets en hexadécimal (la vôtre diffère de l'exemple, la clé étant la vôtre).

Deux formes d'adresse, et une seule est la vôtre

Depuis la 0.12, feint env outscale exporte une adresse qui porte déjà /api/v1 : c'est la forme que lisent octl et le provider Terraform 1.7 et au-delà. Les clients plus anciens, oapi-cli et le provider 1.1.x, ajoutent ce segment eux-mêmes et veulent l'hôte nu : demandez-le explicitement avec feint env outscale --client oapi-cli. Donner la mauvaise forme produit un 404 qui nomme le préfixe en trop, ou en double.

En sortie JSON, la même liste montre l'enveloppe Outscale au complet, celle que votre code devra décoder : un tableau nommé par le type de ressource, et un ResponseContext qui porte l'identifiant de requête.

{
  "Nets":[
    {
      "IpRange":"10.0.0.0/16",
      "NetId":"vpc-3a31b260",
      "State":"available",
      "Tags":[],
      "Tenancy":"default"
    }
  ],
  "ResponseContext":{"RequestId":"3b25f637-a288-4839-b4aa-c3b1a709f6bb"}
}

Exoscale avec exo

Le CLI exo prend son point d'accès dans son fichier de configuration, où endpoint doit valoir http://127.0.0.1:4599/v2. Notez le suffixe /v2, qui fait partie de l'adresse chez ce fournisseur.

eval "$(feint env exoscale)"
exo compute instance-type list

|                  ID                  |  FAMILY  | SIZE  |
|--------------------------------------|----------|-------|
| 21624abb-764e-4def-81d7-9fc54b5957fb | standard | tiny  |
| b6cd1ff5-3a2f-4e9d-a4d1-8988c1191fe8 | standard | small |

Deux types d'instances seulement : c'est le catalogue figé de l'émulateur, pas l'inventaire d'Exoscale.

Le stockage bloc Exoscale

Le stockage bloc d'Exoscale est servi : volumes, instantanés, redimensionnement et chaîne d'attachement, pilotés par le CLI officiel.

exo compute block-storage create lab-vol --size 10 --zone "$EXOSCALE_ZONE"
exo compute block-storage list

|                  ID                  |  NAME   |  ZONE   |  SIZE  |  STATE   |
|--------------------------------------|---------|---------|--------|----------|
| 7d4ca985-3365-44e4-aa5c-2ade17d51453 | lab-vol | ch-dk-2 | 10 GiB | detached |

L'état detached est celui d'un volume que rien ne porte encore. Chaque nombre publié par un volume dit que le stockage ne contient aucun octet : la taille est une déclaration, pas une allocation, et la page Ce que Feint prouve le pose noir sur blanc.

Les quotas

Les quotas répondent aussi, mais ils ne prouvent rien : la limite affichée est une valeur fixe de l'émulateur, comme le catalogue, l'usage affiché est celui que l'émulateur a enregistré, et aucun refus de quota n'est émis, même au-delà de la limite affichée. Mesuré avec Feint 0.13.0 et exo : exo limits sur un émulateur vierge annonce 0 instance, 3 après trois créations (exo compute instance create), puis 105 sur un maximum de 100 après 105 créations, sans une seule erreur. Une suppression décrémente l'usage (104). Les deux autres lignes restent à 0 dans ce scénario (ni instantané ni modèle créé) ; côté Outscale, la lecture des quotas (ReadQuotas) n'est pas servie et répond OperationNotEmulated. La page Ce que Feint prouve dit la même chose : aucun test de dépassement de quota n'a de sens ici.

|          RESOURCE          | USED | MAX |
|----------------------------|------|-----|
| Compute instances          | 0    | 100 |
| Compute instance snapshots | 0    | 100 |
| Compute instance templates | 0    | 100 |

À retenir

• scw et octl s'installent sans compte, à une version épinglée (2.65.1 et 0.0.33) que l'on vérifie par scw version et octl --version.
• feint env <fournisseur> produit l'environnement attendu ; eval suffit pour scw.
• octl lit l'environnement avec une adresse qui porte déjà /api/v1, et exo lit son fichier de configuration avec le suffixe /v2.
• Le CLI peut ajouter des appels : un serveur affiché running a été démarré par scw, pas par l'émulateur.
• Le stockage bloc est servi chez Scaleway et Exoscale, avec des tailles qui ne recouvrent aucun octet.
• La séquence d'image dorée respecte l'ordre de suppression du vrai cloud, celui que Terraform parcourt.
• Les quotas affichent un usage enregistré et une limite fixe, sans jamais refuser une création.

Contrôle de connaissances

Vérifiez que l'essentiel de ce guide est acquis. Les questions portent uniquement sur ce qui vient d'être expliqué ici.

Contrôle de connaissances

Validez vos connaissances avec ce quiz interactif

6 questions

6 min.

70% requis

Informations

• Le chronomètre démarre au clic sur Démarrer
• Questions à choix multiples, vrai/faux et réponses courtes
• Vous pouvez naviguer entre les questions
• Les résultats détaillés sont affichés à la fin

Démarrer le quiz

Lance le quiz et démarre le chronomètre

×

📖 Voir la documentation →