Aller au contenu

Lab 05 : Utilisation des CLI et du SDK OUTSCALE

À l’issue de ce lab, vous serez capable de :

  • installer et configurer octl, l’interface en ligne de commande (CLI) d’OUTSCALE ;
  • créer avec octl une paire de clés (keypair), un Security Group (groupe de sécurité) et une VM (machine virtuelle) à partir d’une OMI (OUTSCALE Machine Image) ;
  • utiliser les options --jq, --output et --waitfor d’octl pour exploiter les réponses de l’API OUTSCALE dans un terminal ;
  • interroger les mêmes ressources avec AWS CLI, via l’API AWS-compatible FCU (Flexible Compute Unit) ;
  • écrire un script Python qui lit vos ressources avec le SDK osc-sdk-python ;
  • supprimer les ressources du lab en ligne de commande.

Dans ce lab, vous ne travaillez pas dans Cockpit, mais depuis le terminal de votre poste de travail. Trois outils envoient des requêtes aux API OUTSCALE de la Région eu-west-2 :

  • octl appelle l’API OUTSCALE (api.eu-west-2.outscale.com) ;
  • AWS CLI appelle l’API FCU (fcu.eu-west-2.outscale.com), compatible avec l’API EC2 d’AWS ;
  • le script Python appelle l’API OUTSCALE avec le SDK osc-sdk-python.

octl et le SDK Python lisent tous les deux vos access keys dans le même fichier de profil, ~/.osc/config.json. AWS CLI utilise son propre fichier, ~/.aws/credentials.

Avec octl, vous créez une VM Ubuntu dans le Public Cloud (hors Net), protégée par un Security Group qui n’autorise que le SSH depuis votre adresse IP publique. Vous retrouvez ensuite cette VM avec AWS CLI puis avec le script Python : les trois outils manipulent les mêmes ressources de votre compte.

Avant de commencer, vous devez disposer :

  • d’un compte OUTSCALE actif ;
  • d’un accès à Cockpit, pour récupérer une access key ;
  • d’un terminal bash sur Linux (x86_64) ou macOS, avec curl, unzip et un client SSH ;
  • de Python 3.10 ou ultérieur, avec le module venv ;
  • d’une connexion Internet ;
  • des connaissances de base acquises dans les Labs 01 à 04 (VM, OMI, Security Group, paire de clés).

Ce lab ne réutilise aucune ressource des labs précédents.

Le lab utilise la région eu-west-2.

Remarque : sous Windows, utilisez WSL (Windows Subsystem for Linux) pour suivre ce lab avec les mêmes commandes.

Important : octl est un projet open source récent, publié par OUTSCALE sur GitHub et en évolution rapide. Ce lab a été rédigé avec octl v0.0.35. Si une commande ne se comporte pas comme décrit, vérifiez votre version avec octl --version et consultez l’aide intégrée avec octl <commande> --help.

octl est distribué sous la forme d’un binaire unique : il n’y a ni dépendance ni environnement virtuel à installer.

  1. Installez octl en suivant uniquement la méthode de votre système.

    Sous Linux (x86_64) : téléchargez la dernière version et installez-la dans /usr/local/bin.

    Terminal window
    curl -L -o octl https://github.com/outscale/octl/releases/latest/download/octl_Linux_x86_64
    chmod +x octl
    sudo mv octl /usr/local/bin

    Sous macOS : installez octl avec Homebrew.

    Terminal window
    brew install octl
  2. Vérifiez l’installation :

    Terminal window
    octl --version

    La commande affiche la version d’octl, par exemple octl version v0.0.35.

L’autocomplétion propose les commandes, les options et certaines valeurs avec la touche Tab. Elle est très utile avec octl, car chaque appel de l’API OUTSCALE possède ses propres options.

  1. Générez et installez le script d’autocomplétion pour bash :

    Terminal window
    octl completion bash > octl-completion.bash
    sudo cp octl-completion.bash /etc/bash_completion.d/
    source ~/.bashrc
  2. Tapez octl iaas puis appuyez deux fois sur Tab : la liste des ressources gérées par octl s’affiche (vm, keypair, securitygroup, etc.).

Remarque : pour zsh, utilisez octl completion zsh. Les instructions détaillées sont dans la documentation d’octl.

octl s’authentifie auprès de l’API OUTSCALE avec une access key : un couple formé d’un identifiant (Access Key ID) et d’une clé secrète (Secret Key).

  1. Dans Cockpit, ouvrez la page de gestion des Access Keys de votre compte.

  2. Créez une nouvelle access key, ou utilisez une access key existante.

  3. Notez l’Access Key ID et la Secret Key.

Attention : la Secret Key donne accès à toutes les ressources de votre compte. Ne la copiez jamais dans un script, un dépôt Git ou un message. Dans ce lab, elle est stockée uniquement dans les fichiers de configuration de votre répertoire personnel.

  1. Créez un profil nommé default, en remplaçant <ACCESS_KEY_ID> par votre Access Key ID :

    Terminal window
    octl profile add default --ak <ACCESS_KEY_ID> --region eu-west-2
  2. Saisissez votre Secret Key quand octl vous la demande. Elle ne s’affiche pas pendant la saisie et n’apparaît donc pas dans l’historique de votre terminal.

  3. Affichez le profil actif :

    Terminal window
    octl profile current

    Le profil default s’affiche, avec la Région eu-west-2. La Secret Key est masquée.

octl a enregistré le profil dans le fichier ~/.osc/config.json. Le SDK Python de la partie 5 lira ce même fichier.

Important : ne passez pas l’option --default à la commande octl profile add, et n’utilisez pas octl profile use dans ce lab. Ces commandes ajoutent au profil une clé "default": true que le SDK osc-sdk-python ne reconnaît pas : le script de la partie 5 échouerait alors avec une erreur d’authentification. Un profil nommé default est de toute façon utilisé par défaut par octl.

  1. Listez les VMs de votre compte :

    Terminal window
    octl iaas vm list

    octl affiche un tableau, éventuellement vide si votre compte ne contient aucune VM. Une erreur d’authentification indique une access key incorrecte : recommencez l’étape 2.2.

  2. Affichez la même liste au format JSON brut, tel que renvoyé par l’API OUTSCALE :

    Terminal window
    octl iaas vm list -o raw

Les commandes octl suivent toutes la même structure : octl iaas <ressource> <action>. Les actions courantes sont list, describe, create, update et delete.

Conseil : chaque commande de haut niveau correspond à un appel de l’API OUTSCALE. Par exemple, octl iaas vm list appelle ReadVms. Vous pouvez aussi appeler directement n’importe quelle méthode de l’API avec octl iaas api <Méthode>, par exemple octl iaas api ReadVms.

Dans cette partie, vous créez avec octl toutes les ressources nécessaires à une VM accessible en SSH. Vous enregistrez l’identifiant de chaque ressource dans une variable du shell pour le réutiliser dans les commandes suivantes.

Remarque : les variables du shell (SG_ID, IMAGE_ID, VM_ID, etc.) sont perdues si vous fermez votre terminal. Dans ce cas, retrouvez les identifiants avec les commandes octl iaas <ressource> list.

  1. Créez la paire de clés architecte-lab05 et enregistrez sa clé privée dans un fichier :

    Terminal window
    octl iaas keypair create --name architecte-lab05 \
    -o text --jq '.PrivateKey' > outscale_architecte-lab05.rsa
    • --jq '.PrivateKey' extrait de la réponse de l’API uniquement le champ qui contient la clé privée.
    • -o text affiche ce champ en texte brut, avec de vrais retours à la ligne, ce qui produit un fichier de clé directement utilisable.
  2. Restreignez l’accès au fichier de clé privée à votre seul utilisateur. SSH refuse d’utiliser une clé privée lisible par d’autres utilisateurs.

    Terminal window
    chmod 600 outscale_architecte-lab05.rsa
  3. Vérifiez que la paire de clés existe dans votre compte :

    Terminal window
    octl iaas keypair list

Attention : OUTSCALE ne conserve que la clé publique. La clé privée n’est renvoyée qu’une seule fois, dans la réponse de création. Si vous perdez le fichier outscale_architecte-lab05.rsa, vous devez supprimer et recréer la paire de clés.

  1. Créez le Security Group architecte-lab05-sg-ssh dans le Public Cloud et enregistrez son identifiant dans la variable SG_ID :

    Terminal window
    SG_ID=$(octl iaas securitygroup create \
    --name architecte-lab05-sg-ssh \
    --description "Lab 05 - SSH depuis le poste du stagiaire" \
    -o text --jq '.SecurityGroupId')
    echo $SG_ID

    L’identifiant du Security Group s’affiche (il commence par sg-).

  2. Récupérez votre adresse IP publique :

    Terminal window
    MON_IP=$(curl -s https://api.ipify.org)
    echo $MON_IP
  3. Ajoutez une règle entrante qui autorise le SSH (TCP 22) uniquement depuis votre adresse IP :

    Terminal window
    octl iaas securitygrouprule create \
    --group-id $SG_ID \
    --flow Inbound \
    --ports tcp/22 \
    --remote-ranges $MON_IP/32
  4. Vérifiez les règles du Security Group :

    Terminal window
    octl iaas securitygroup rules $SG_ID

    Le tableau affiche une règle Inbound, protocole tcp, port 22, depuis votre adresse IP suivie de /32.

Remarque : le suffixe /32 désigne une seule adresse IP. N’ouvrez pas le port 22 à 0.0.0.0/0, c’est-à-dire à tout Internet.

  1. Listez les OMI Ubuntu 22.04 publiées par OUTSCALE :

    Terminal window
    octl iaas image list --account-alias Outscale --name 'Ubuntu-22.04-*'
    • --account-alias Outscale limite la recherche aux OMI officielles d’OUTSCALE.
    • Le caractère * remplace la date de publication qui termine le nom de chaque OMI.
  2. Dans le tableau, repérez l’OMI la plus récente : sa date de création, colonne Created On, est la plus récente.

  3. Enregistrez son identifiant dans la variable IMAGE_ID, en remplaçant <ID_OMI> par l’identifiant relevé (il commence par ami-) :

    Terminal window
    IMAGE_ID=<ID_OMI>

Remarque : les identifiants des OMI changent à chaque nouvelle publication et diffèrent d’une Région à l’autre. Ne les codez jamais en dur : recherchez toujours l’OMI par son nom et son propriétaire.

  1. Créez la VM et enregistrez son identifiant dans la variable VM_ID :

    Terminal window
    VM_ID=$(octl iaas vm create \
    --image-id $IMAGE_ID \
    --type tinav5.c1r1p2 \
    --keypair-name architecte-lab05 \
    --security-group-id $SG_ID \
    --placement-subregion eu-west-2a \
    -o text --jq '.VmId')
    echo $VM_ID
    • --type tinav5.c1r1p2 : un type de VM avec 1 vCore, 1 Gio de mémoire et une performance high (p2), identique au type par défaut proposé par Cockpit au Lab 01.
    • --placement-subregion eu-west-2a : la Sous-région (Subregion) dans laquelle la VM est créée.

    L’identifiant de la VM s’affiche (il commence par i-).

  2. Nommez la VM en lui ajoutant le tag Name :

    Terminal window
    octl iaas tag create --resource-id $VM_ID --key Name --value architecte-lab05-vm

    Cockpit et octl affichent la valeur du tag Name comme nom de la VM.

  1. Attendez que la VM passe à l’état running :

    Terminal window
    octl iaas vm describe $VM_ID --waitfor '.State=="running"'

    octl interroge l’API toutes les quelques secondes et rend la main dès que la condition est vraie.

  2. Récupérez l’IP publique de la VM :

    Terminal window
    VM_IP=$(octl iaas vm describe $VM_ID -o text --jq '.PublicIp')
    echo $VM_IP
  3. Affichez la VM dans la liste de vos VMs :

    Terminal window
    octl iaas vm list

    La VM architecte-lab05-vm apparaît à l’état running, avec son IP publique. Le résultat ressemble à ceci, avec vos propres valeurs :

    Terminal window
    Resolving alias to [octl iaas api ReadVms --output table]
    ┌────────────┬─────────────────────┬───────────────┬─────────┬──────────────┬─────────────┬───────┬──────────┐
    │ ID │ Name │ Type │ State │ PublicIp │ PrivateIp │ NetId │ SubnetId │
    ├────────────┼─────────────────────┼───────────────┼─────────┼──────────────┼─────────────┼───────┼──────────┤
    │ i-12345678 │ architecte-lab05-vm │ tinav5.c1r1p2 │ running │ 203.0.113.25 │ 10.9.42.117 │ │ │
    └────────────┴─────────────────────┴───────────────┴─────────┴──────────────┴─────────────┴───────┴──────────┘
    • La ligne Resolving alias to […] indique l’appel de l’API OUTSCALE exécuté par octl : ici, ReadVms.
    • Les colonnes NetId et SubnetId sont vides, car la VM est créée dans le Public Cloud, hors de tout Net.
  1. Connectez-vous en SSH à la VM :

    Terminal window
    ssh -i outscale_architecte-lab05.rsa outscale@$VM_IP

    Acceptez l’empreinte de la VM en saisissant yes lors de la première connexion.

  2. Une fois connecté, affichez le nom d’hôte de la VM :

    Terminal window
    hostname
  3. Quittez la VM avec la commande exit, ou avec Ctrl + D.

Remarque : si la connexion SSH échoue juste après le démarrage, attendez une minute : le système de la VM termine encore son initialisation. Si l’échec persiste, vérifiez que votre adresse IP publique n’a pas changé depuis l’étape 3.2.

OUTSCALE propose, en plus de son API, des API compatibles avec celles d’AWS. Vous pouvez donc utiliser AWS CLI, l’interface en ligne de commande d’Amazon Web Services, pour gérer certaines ressources OUTSCALE. Chaque service AWS correspond à un service OUTSCALE :

Commande AWS CLIService OUTSCALE
ec2FCU (Flexible Compute Unit) : VMs, volumes, Security Groups, etc.
elbLBU (Load Balancer Unit)
iamEIM (Elastic Identity Management)
directconnectDirectLink
s3api, s3OOS (OUTSCALE Object Storage)

Pour chaque requête, AWS CLI doit connaître l’endpoint OUTSCALE du service, c’est-à-dire l’adresse de l’API à appeler. Pour FCU dans la Région eu-west-2, l’endpoint est https://fcu.eu-west-2.outscale.com.

  1. Installez AWS CLI version 2 en suivant uniquement la méthode de votre système.

    Sous Linux (x86_64) : utilisez l’installateur officiel d’AWS.

    Terminal window
    curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
    unzip awscliv2.zip
    sudo ./aws/install

    Sous macOS : installez AWS CLI avec Homebrew.

    Terminal window
    brew install awscli

    Pour les autres systèmes, suivez la documentation d’installation d’AWS CLI.

  2. Vérifiez l’installation :

    Terminal window
    aws --version
  1. Lancez l’assistant de configuration :

    Terminal window
    aws configure
  2. Renseignez les valeurs demandées :

    • AWS Access Key ID : votre Access Key ID OUTSCALE ;
    • AWS Secret Access Key : votre Secret Key OUTSCALE ;
    • Default region name : eu-west-2 ;
    • Default output format : json.

AWS CLI enregistre les access keys dans ~/.aws/credentials et la Région dans ~/.aws/config.

  1. Listez vos VMs en indiquant l’endpoint FCU avec l’option --endpoint-url :

    Terminal window
    aws ec2 describe-instances \
    --endpoint-url https://fcu.eu-west-2.outscale.com \
    --query 'Reservations[].Instances[].[InstanceId,State.Name,PublicIpAddress]' \
    --output table
    • --query sélectionne les champs à afficher dans la réponse. AWS CLI utilise la syntaxe JMESPath, alors qu’octl utilise la syntaxe jq.
    • --output table affiche le résultat sous forme de tableau.
  2. Vérifiez que la VM créée avec octl apparaît, avec le même identifiant que $VM_ID et la même IP publique que $VM_IP.

Dans AWS CLI, une VM s’appelle une instance et une OMI s’appelle une AMI. Les identifiants sont les mêmes que dans l’API OUTSCALE.

Remarque : la documentation OUTSCALE utilise parfois la forme courte --endpoint, qu’AWS CLI accepte comme abréviation de --endpoint-url.

4.4 Enregistrer l’endpoint dans la configuration

Section intitulée « 4.4 Enregistrer l’endpoint dans la configuration »

Pour ne plus saisir --endpoint-url à chaque commande, vous pouvez enregistrer l’endpoint FCU dans le fichier ~/.aws/config. Cette configuration nécessite AWS CLI version 2.13 ou ultérieure.

  1. Ouvrez le fichier ~/.aws/config avec un éditeur de texte.

  2. Remplacez son contenu par le suivant :

    [default]
    region = eu-west-2
    output = json
    services = outscale-eu-west-2
    [services outscale-eu-west-2]
    ec2 =
    endpoint_url = https://fcu.eu-west-2.outscale.com

    Respectez l’indentation de la ligne endpoint_url : elle indique que ce paramètre appartient au service ec2.

  3. Relancez la commande sans l’option --endpoint-url :

    Terminal window
    aws ec2 describe-instances \
    --query 'Reservations[].Instances[].[InstanceId,State.Name,PublicIpAddress]' \
    --output table

    Le résultat est identique à celui de l’étape 4.3.

Un SDK (Software Development Kit) permet d’appeler l’API OUTSCALE depuis un programme. Le SDK osc-sdk-python expose chaque méthode de l’API OUTSCALE (ReadVms, CreateVms, etc.) sous la forme d’une méthode Python.

  1. Créez un environnement virtuel Python, puis activez-le :

    Terminal window
    python3 -m venv ~/architecte-lab05-venv
    source ~/architecte-lab05-venv/bin/activate

    L’environnement virtuel isole les paquets Python de ce lab de ceux de votre système.

  2. Installez le SDK :

    Terminal window
    pip install osc-sdk-python
  1. Créez le fichier architecte-lab05-inventaire.py avec le contenu suivant :

    from osc_sdk_python import Gateway
    if __name__ == "__main__":
    # Lit les access keys et la Région du profil "default" de ~/.osc/config.json
    gw = Gateway(profile="default")
    print("VMs :")
    for vm in gw.ReadVms()["Vms"]:
    print(f'- {vm["VmId"]} ({vm["State"]})')
    print("\nVolumes :")
    for volume in gw.ReadVolumes()["Volumes"]:
    print(f'- {volume["VolumeId"]} ({volume["Size"]} Gio)')

    Le script ne contient aucune access key : le SDK lit le profil default créé avec octl à l’étape 2.2.

  2. Lancez le script :

    Terminal window
    python architecte-lab05-inventaire.py

    Le script affiche la VM architecte-lab05-vm à l’état running, ainsi que son volume racine.

  3. Désactivez l’environnement virtuel :

    Terminal window
    deactivate

Remarque : si le script échoue avec l’erreur TypeError: can only concatenate str (not "NoneType") to str, le SDK n’a pas pu lire le profil. Ouvrez ~/.osc/config.json et supprimez la ligne "default": true si elle est présente (voir l’étape 2.2).

Pour valider votre lab, vérifiez les points suivants :

  • octl profile current affiche le profil default avec la Région eu-west-2.
  • octl iaas keypair list affiche la paire de clés architecte-lab05.
  • octl iaas securitygroup rules $SG_ID affiche une seule règle entrante, TCP 22, limitée à votre adresse IP (/32).
  • octl iaas vm list affiche la VM architecte-lab05-vm à l’état running, avec une IP publique.
  • La connexion SSH à la VM avec le fichier outscale_architecte-lab05.rsa fonctionne.
  • aws ec2 describe-instances affiche la même VM, avec le même identifiant.
  • Le script architecte-lab05-inventaire.py affiche la même VM et son volume.

Réalisez les actions suivantes en ligne de commande, sans utiliser Cockpit :

  1. Avec octl, arrêtez la VM architecte-lab05-vm, attendez qu’elle soit à l’état stopped, puis redémarrez-la et reconnectez-vous en SSH.
  2. Avec AWS CLI, créez une deuxième VM nommée architecte-lab05-vm-awscli, avec la même OMI, le même type de VM, la même paire de clés et le même Security Group.
  3. Modifiez le script Python pour qu’il affiche aussi le nom et l’identifiant de chaque Security Group du compte.

Question : Après l’arrêt et le redémarrage de la VM, pourquoi faut-il relire son IP publique avant de se reconnecter ?

💡 Correction — Arrêt et redémarrage de la VM avec octl
Terminal window
octl iaas vm stop $VM_ID
octl iaas vm describe $VM_ID --waitfor '.State=="stopped"'
octl iaas vm start $VM_ID
octl iaas vm describe $VM_ID --waitfor '.State=="running"'
VM_IP=$(octl iaas vm describe $VM_ID -o text --jq '.PublicIp')
ssh -i outscale_architecte-lab05.rsa outscale@$VM_IP

L’IP publique de la VM a été attribuée automatiquement à la création. Elle n’est pas réservée dans votre compte : l’IP publique de la VM peut donc être différente après un arrêt. Pour conserver une adresse fixe, allouez une IP publique dans votre compte et associez-la à la VM, comme aux Labs 02 et 03.

💡 Correction — Création d'une VM avec AWS CLI
Terminal window
VM2_ID=$(aws ec2 run-instances \
--endpoint-url https://fcu.eu-west-2.outscale.com \
--image-id $IMAGE_ID \
--instance-type tinav5.c1r1p2 \
--key-name architecte-lab05 \
--security-group-ids $SG_ID \
--placement AvailabilityZone=eu-west-2a \
--query 'Instances[0].InstanceId' --output text)
echo $VM2_ID
aws ec2 create-tags \
--endpoint-url https://fcu.eu-west-2.outscale.com \
--resources $VM2_ID \
--tags Key=Name,Value=architecte-lab05-vm-awscli

L’option --endpoint-url est inutile si vous avez réalisé l’étape 4.4. La nouvelle VM apparaît aussi dans octl iaas vm list : les deux CLI gèrent les mêmes ressources.

💡 Correction — Liste des Security Groups avec le SDK

Ajoutez les lignes suivantes à la fin du bloc if __name__ == "__main__": du script :

print("\nSecurity Groups :")
for sg in gw.ReadSecurityGroups()["SecurityGroups"]:
print(f'- {sg["SecurityGroupName"]} ({sg["SecurityGroupId"]})')

Attention : avant de supprimer une ressource, vérifiez qu’elle n’est pas utilisée par d’autres labs.

Les ressources de ce lab ne sont pas réutilisées dans les labs suivants. Conservez uniquement :

  • la paire de clés architecte-lab01 du Lab 01 et son fichier outscale_architecte-lab01.rsa ;
  • les outils installés (octl, AWS CLI) et leurs fichiers de configuration ~/.osc/config.json et ~/.aws/, que vous pourrez réutiliser.

Supprimez les ressources dans cet ordre avec octl. Confirmez chaque suppression en sélectionnant Yes.

  1. Supprimer les VMs, puis attendre qu’elles ne soient plus listées :

    • architecte-lab05-vm
    • architecte-lab05-vm-awscli (si vous avez fait le challenge)
    Terminal window
    octl iaas vm delete $VM_ID

    Si vous avez fait le challenge, supprimez aussi la deuxième VM :

    Terminal window
    octl iaas vm delete $VM2_ID

    Vérifiez ensuite la liste de vos VMs :

    Terminal window
    octl iaas vm list

    Relancez octl iaas vm list jusqu’à ce que les VMs n’apparaissent plus ou soient à l’état terminated.

  2. Supprimer le Security Group :

    • architecte-lab05-sg-ssh
    Terminal window
    octl iaas securitygroup delete $SG_ID
  3. Supprimer la paire de clés :

    • architecte-lab05

    Relevez l’identifiant de la paire de clés dans la colonne ID, puis supprimez-la en remplaçant <ID_KEYPAIR> :

    Terminal window
    octl iaas keypair list
    octl iaas keypair delete <ID_KEYPAIR>
  4. Supprimer les fichiers locaux :

    • outscale_architecte-lab05.rsa
    • l’environnement virtuel ~/architecte-lab05-venv

Conseil : dans un script, ajoutez l’option -y aux commandes delete pour répondre automatiquement Yes à la confirmation.