Procédure

1. Installez le générateur d'images et les autres paquets nécessaires sur la VM :

   • osbuild-composer - pris en charge à partir de RHEL 8.3
   • composer-cli
   • cockpit-composer
   • bash-completion

   # dnf install osbuild-composer composer-cli cockpit-composer bash-completion

   La console web est installée en tant que dépendance du paquetage cockpit-composer.

2. Activer le démarrage du constructeur d'images après chaque redémarrage :

   # systemctl enable --now osbuild-composer.socket
   # systemctl enable --now cockpit.socket

   Les services osbuild-composer et cockpit démarrent automatiquement lors du premier accès.

3. Charger le script de configuration de l'interpréteur de commandes pour que la fonction d'autocomplétion de la commande composer-cli fonctionne immédiatement sans redémarrage :

   $ source /etc/bash_completion.d/composer-cli

Procédure

1. Créez un répertoire dans lequel vous souhaitez stocker vos dérogations au référentiel :

   $ sudo mkdir -p /etc/osbuild-composer/repositories

2. Vous pouvez créer votre propre structure de fichier JSON.

3. Créez un fichier JSON, en utilisant un nom correspondant à votre version de RHEL. Vous pouvez également copier le fichier correspondant à votre distribution à partir de /usr/share/osbuild-composer/ et en modifier le contenu.

   Pour RHEL 9, utilisez /etc/osbuild-composer/repositories/rhel-92.json.

4. Ajoutez la structure suivante à votre fichier JSON, par exemple :

   {
       "<ARCH>": [
           {
               "name": "baseos",
               "baseurl": "http://mirror.example.com/composes/released/RHEL-9/9.0/BaseOS/x86_64/os/",
               "gpgkey": "-----BEGIN PGP PUBLIC KEY BLOCK-----\n\n (…​)",
               "check_gpg": true,
               "metadata_expire": ""
           }
       ]
   }

   Ne spécifiez qu'un seul des attributs suivants :

   • baseurl - chaîne de caractères : URL de base du référentiel.
   • metalink - string : URL d'un fichier metalink contenant une liste de dépôts miroirs valides.

   • mirrorlist - string : URL d'un fichier mirrorlist contenant une liste de dépôts miroirs valides

     Les autres champs sont facultatifs.

     1. Vous pouvez également copier le fichier JSON pour votre distribution.

        1. Copiez le fichier du référentiel dans le répertoire que vous avez créé. Dans la commande suivante, remplacez rhel-version.json par votre version de RHEL, par exemple : rhel-9.json.

           $  cp /usr/share/osbuild-composer/repositories/rhel-version.json /etc/osbuild-composer/repositories/

5. À l'aide d'un éditeur de texte, modifiez les chemins d'accès baseurl dans le fichier rhel-9.json et enregistrez-le. Par exemple :

   $ vi /etc/osbuild-composer/repositories/rhel-version.json

6. Redémarrer le site osbuild-composer.service:

   $ sudo systemctl restart osbuild-composer.service

Procédure

1. Obtenez le baseurl à partir du fichier /etc/yum.repos.d/redhat.repo:

   # cat /etc/yum.repos.d/redhat.repo
   [AppStream]
   name = AppStream mirror example
   baseurl = https://mirror.example.com/RHEL-9/9.0/AppStream/x86_64/os/
   enabled = 1
   gpgcheck = 0
   sslverify = 1
   sslcacert = /etc/pki/ca1/ca.crt
   sslclientkey = /etc/pki/ca1/client.key
   sslclientcert = /etc/pki/ca1/client.crt
   metadata_expire = 86400
   enabled_metadata = 0

2. Configurez le référentiel pour qu'il utilise le même baseurl et attribuez la valeur true à rhsm:

   {
       "x86_64": [
           {
               "name": "AppStream mirror example",
               "baseurl": "https://mirror.example.com/RHEL-9/9.0/AppStream/x86_64/os/",
               "gpgkey": "-----BEGIN PGP PUBLIC KEY BLOCK-----\n\n (…​)",
               "check_gpg": true,
               "rhsm": true
           }
       ]
   }

   Note

   osbuild-composer n'utilise pas automatiquement les référentiels définis à l'adresse /etc/yum.repos.d/. Vous devez les spécifier manuellement, soit en tant que remplacement du référentiel système, soit en tant que source supplémentaire à l'aide de composer-cli. Les dérogations au référentiel système sont généralement utilisées pour les référentiels "BaseOS" et "AppStream", tandis que les sources composer-cli sont utilisées pour tous les autres référentiels.

1. Exporter (save) la définition du plan vers un fichier texte
2. Modifier ce fichier dans un éditeur de texte
3. Importer (push) le fichier texte du plan dans Image Builder
4. Exécuter une composition pour créer une image à partir du plan
5. Exporter le fichier image pour le télécharger

Procédure

1. Créez un fichier de texte brut avec le contenu suivant :

   name = "BLUEPRINT-NAME"
   description = "LONG FORM DESCRIPTION TEXT"
   version = "0.0.1"
   modules = []
   groups = []

   Remplacez BLUEPRINT-NAME et LONG FORM DESCRIPTION TEXT par un nom et une description de votre plan.

   Remplacer 0.0.1 par un numéro de version conformément au schéma de versionnement sémantique.

2. Pour chaque paquet que vous souhaitez inclure dans le plan, ajoutez les lignes suivantes au fichier :

   [[packages]]
   name = "package-name"
   version = "package-version"

   Remplacez package-name par le nom du paquet, par exemple httpd, gdb-docou coreutils.

   Remplacez package-version par la version à utiliser. Ce champ prend en charge les spécifications de la version dnf:

   • Pour une version spécifique, utilisez le numéro de version exact, par exemple 8.7.0.
   • Pour obtenir la dernière version disponible, utilisez l'astérisque *.
   • Pour la dernière version mineure, utilisez des formats tels que 8.*.

3. Personnalisez vos plans en fonction de vos besoins. Par exemple, pour désactiver le multithreading simultané (SMT), ajoutez les lignes suivantes au fichier blueprint :

   [customizations.kernel]
   append = "nosmt=force"

   Pour connaître les autres personnalisations disponibles, voir Personnalisations d'images prises en charge.

4. Enregistrez le fichier, par exemple, sous BLUEPRINT-NAME.toml et fermez l'éditeur de texte.

5. Pousser (importer) le plan :

   # composer-cli blueprints push BLUEPRINT-NAME.toml

   Remplacez BLUEPRINT-NAME par la valeur que vous avez utilisée dans les étapes précédentes.

   Note

   Pour créer des images en utilisant composer-cli en tant que non-root, ajoutez votre utilisateur aux groupes weldr ou root.

   # usermod -a -G weldr user
   $ newgrp weldr

Procédure

1. Enregistrer (exporter) le plan dans un fichier texte local :

   # composer-cli blueprints save BLUEPRINT-NAME

2. Modifiez le fichier BLUEPRINT-NAME.toml à l'aide d'un éditeur de texte et apportez vos modifications.

3. Avant de terminer les modifications, vérifiez que le fichier est un plan valide :

   1. Supprimer cette ligne, si elle existe :

      packages = []

   2. Augmentez le numéro de version, par exemple de 0.0.1 à 0.1.0. N'oubliez pas que les versions des plans de construction d'images doivent utiliser le système de versionnement sémantique. Notez également que si vous ne modifiez pas la version, le composant de version patch augmente automatiquement.

   3. Vérifier si le contenu est une spécification TOML valide. Voir la documentation TOML pour plus d'informations.

      Note

      La documentation TOML est un produit communautaire et n'est pas pris en charge par Red Hat. Vous pouvez signaler tout problème lié à l'outil à l'adresse suivante : https://github.com/toml-lang/toml/issues

4. Enregistrez le fichier et fermez l'éditeur de texte.

5. Repousser (importer) le plan dans le constructeur d'images :

   # composer-cli blueprints push BLUEPRINT-NAME.toml

   Note

   Pour réimporter le plan dans Image Builder, il faut fournir le nom du fichier avec l'extension .toml, alors que dans les autres commandes, il faut utiliser uniquement le nom du plan.

6. Pour vérifier que le contenu téléchargé dans le générateur d'images correspond à vos modifications, dressez la liste du contenu du plan :

   # composer-cli blueprints show BLUEPRINT-NAME

7. Vérifiez si les composants et les versions répertoriés dans le plan et leurs dépendances sont valides :

   # composer-cli blueprints depsolve BLUEPRINT-NAME

Procédure

1. Commencez la composition :

   # composer-cli compose start BLUEPRINT-NAME IMAGE-TYPE

   Remplacez BLUEPRINT-NAME par le nom du plan et IMAGE-TYPE par le type d'image. Pour connaître les valeurs disponibles, voir la sortie de la commande composer-cli compose types.

   Le processus de composition démarre en arrière-plan et affiche l'identifiant universel unique (UUID) du compositeur.

2. Attendez que le processus de composition soit terminé. La création d'une image peut prendre jusqu'à dix minutes.

   Pour vérifier l'état de la composition :

   # composer-cli compose status

   Une composition terminée affiche la valeur de l'état FINISHED. Pour identifier votre composition dans la liste, utilisez son UUID.

3. Une fois le processus de composition terminé, téléchargez le fichier image résultant :

   # composer-cli composer image UUID

   Remplacez UUID par la valeur UUID indiquée dans les étapes précédentes.

Procédure

1. Ouvrir https://localhost:9090/ dans un navigateur web sur le système où le générateur d'images est installé.

   Pour plus d'informations sur l'accès à distance au constructeur d'images, voir Managing systems using the RHEL web console document.

2. Connectez-vous à la console web en tant qu'utilisateur root.

3. Pour afficher les commandes du constructeur d'images, cliquez sur l'icône image builder, dans le coin supérieur gauche de la fenêtre.

   Le tableau de bord du constructeur d'images s'ouvre et répertorie les plans existants, le cas échéant.

Procédure

1. Cliquez sur Créer un plan dans le coin supérieur droit.

   Un assistant de dialogue contenant des champs pour le nom et la description du plan s'ouvre.

2. Sur la page Details:

   1. Saisissez le nom du plan et, éventuellement, sa description. Cliquez sur Suivant.

3. Facultatif : dans la page Packages:

   1. Sur la page de recherche Available packages, saisissez le nom du paquet et cliquez sur le bouton > pour le déplacer dans le champ Paquets choisis. Recherchez et incluez autant de paquets que vous le souhaitez. Cliquez sur Suivant.

      Note

      Ces personnalisations sont toutes facultatives, sauf indication contraire.

4. Sur la page Kernel, entrez un nom de noyau et les arguments de la ligne de commande.

5. Sur la page File system, vous pouvez sélectionner Use automatic partitioning ou Manually configure partitions pour votre système de fichiers image. Pour configurer manuellement les partitions, procédez comme suit :

   1. Cliquez sur le bouton Configurer manuellement les partitions.

      La section Configure partitions s'ouvre, montrant la configuration basée sur les standards et les guides de sécurité de Red Hat.

   2. Dans le menu déroulant, fournissez les détails pour configurer les partitions :

      1. Dans le champ Mount point, sélectionnez l'une des options de type de point de montage suivantes :

         • / - le point de montage racine
         • /var
         • /home
         • /opt
         • /srv
         • /usr
         • /app
         • /data
         • /tmp

         • /usr/local

           Vous pouvez également ajouter un chemin supplémentaire au Mount point, tel que /tmp. Par exemple : /var comme préfixe et /tmp comme chemin supplémentaire donne /var/tmp.

           Note

           Selon le type de point de montage choisi, le type de système de fichiers devient xfs, et ainsi de suite.

      2. Dans le champ Minimum size partition du système de fichiers, entrez la taille minimale de partition souhaitée. Dans le menu déroulant Taille minimale, vous pouvez utiliser des unités de taille courantes telles que GiB, MiB ou KiB. L'unité par défaut est GiB.

         Note

         Minimum size signifie que le constructeur d'images peut encore augmenter la taille des partitions, au cas où elles seraient trop petites pour créer une image fonctionnelle.

   3. Pour ajouter d'autres partitions, cliquez sur le bouton Ajouter une partition. Si le message d'erreur suivant s'affiche : "Duplicate partitions : Une seule partition peut être créée à chaque point de montage", vous pouvez.. :

      1. Cliquez sur le bouton Supprimer pour supprimer la partition dupliquée.
      2. Choisissez un nouveau point de montage pour la partition que vous souhaitez créer.
   4. Après avoir terminé la configuration du partitionnement, cliquez sur Suivant.

6. Sur la page Services, vous pouvez activer ou désactiver des services :

   1. Saisissez les noms des services que vous souhaitez activer ou désactiver, en les séparant par une virgule, un espace ou en appuyant sur la touche Entrée. Cliquez sur Suivant.

7. Sur la page Firewall, configurez votre pare-feu :

   1. Saisissez l'adresse Ports et les services de pare-feu que vous souhaitez activer ou désactiver.
   2. Cliquez sur le bouton Ajouter une zone pour gérer vos règles de pare-feu pour chaque zone indépendamment. Cliquez sur Suivant.

8. Sur la page Users, ajoutez un utilisateur en suivant les étapes suivantes :

   1. Cliquez sur Ajouter un utilisateur.
   2. Saisissez un Username, un password et un SSH key. Vous pouvez également marquer l'utilisateur en tant qu'utilisateur privilégié en cochant la case Server administrator. Cliquez sur Suivant.

9. Sur la page Groups, ajoutez des groupes en suivant les étapes suivantes :

   1. Cliquez sur le bouton Ajouter des groupes:

      1. Saisissez un Group name et un Group ID. Vous pouvez ajouter d'autres groupes. Cliquez sur Suivant.

10. Sur la page SSH keys, ajoutez une clé :

    1. Cliquez sur le bouton Ajouter une clé.

       1. Entrez la clé SSH.
       2. Saisissez une adresse User. Cliquez sur Suivant.

11. Sur la page Timezone, définissez vos paramètres de fuseau horaire :

    1. Dans le champ Timezone, entrez le fuseau horaire que vous souhaitez ajouter à votre image système. Par exemple, ajoutez le format de fuseau horaire suivant : "US/Eastern".

       Si vous ne définissez pas de fuseau horaire, le système utilise par défaut le temps universel coordonné (UTC).

    2. Saisissez les serveurs NTP. Cliquez sur Suivant.

12. Sur la page Locale, effectuez les étapes suivantes :

    1. Dans le champ de recherche Keyboard, saisissez le nom du paquet que vous souhaitez ajouter à votre image système. Par exemple, [\N- "en_US.UTF-8\N"] : [\N-"en_US.UTF-8\N"].
    2. Dans le champ de recherche Languages, saisissez le nom du paquet que vous souhaitez ajouter à votre image système. Par exemple : "us". Cliquez sur Suivant.

13. Sur la page Others, effectuez les étapes suivantes :

    1. Dans le champ Hostname, entrez le nom d'hôte que vous souhaitez ajouter à votre image système. Si vous n'ajoutez pas de nom d'hôte, le système d'exploitation détermine le nom d'hôte.
    2. Obligatoire uniquement pour l'image Simplifier Installer : Dans le champ Installation Devices, entrez un nœud valide pour votre image système. Par exemple : dev/sda1. Cliquez sur Suivant.

14. Obligatoire uniquement lors de la création d'images FIDO : Sur la page FIDO device onboarding, effectuez les étapes suivantes :

    1. Dans le champ Manufacturing server URL, entrez les informations suivantes :

       1. Dans le champ DIUN public key insecure, entrez la clé publique non sécurisée.
       2. Dans le champ DIUN public key hash, entrez le hachage de la clé publique.
       3. Dans le champ DIUN public key root certs, entrez les certificats racine de la clé publique. Cliquez sur Suivant.

15. Sur la page OpenSCAP, effectuez les étapes suivantes :

    1. Dans le champ Datastream, entrez les instructions de remédiation datastream que vous souhaitez ajouter à votre image système.
    2. Dans le champ Profile ID, entrez le profil de sécurité profile_id que vous souhaitez ajouter à votre image système. Cliquez sur Suivant.

16. Obligatoire uniquement lors de la création d'images Ignition : Sur la page Ignition, effectuez les étapes suivantes :

    1. Dans le champ Firstboot URL, saisissez le nom du paquet que vous souhaitez ajouter à votre image système.
    2. Dans le champ Embedded Data, faites glisser ou téléchargez votre fichier. Cliquez sur Suivant.
17. . Sur la page Review, passez en revue les détails du plan. Cliquez sur Créer.

Procédure

1. Dans le tableau de bord du constructeur d'images, cliquez sur Importer un projet. L'assistant Import blueprint s'ouvre.
2. Dans le champ Upload, faites glisser ou téléchargez un plan existant. Ce plan peut être au format TOML ou JSON.

3. Cliquez sur Importer. Le tableau de bord répertorie le plan que vous avez importé.

   Lorsque vous cliquez sur le plan que vous avez importé, vous avez accès à un tableau de bord contenant toutes les personnalisations du plan que vous avez importé.

Procédure

1. Dans le tableau de bord du constructeur d'images, sélectionnez le plan que vous souhaitez exporter.
2. Cliquez sur Export blueprint. L'assistant Export blueprint s'ouvre.

3. Pour enregistrer le site Exported blueprint, cliquez sur le bouton Exporter.

   1. En option, cliquez sur le bouton Copier pour copier le plan.

Vérification

1. Ouvrez le plan exporté pour l'inspecter et le réviser.

Procédure

1. Accéder au tableau de bord du constructeur d'images.
2. Sur la table des plans, trouvez le plan que vous voulez construire.
3. Dans la partie droite du plan choisi, cliquez sur Créer une image. L'assistant de la boîte de dialogue Create image s'ouvre.
4. Naviguez jusqu'à l'onglet Images et cliquez sur Create Image. L'assistant Create image s'ouvre.

5. Sur la page Image output, effectuez les étapes suivantes :

   1. Dans la liste Select a blueprint, sélectionnez le type d'image souhaité.

   2. Dans la liste Image output type, sélectionnez le type de sortie d'image que vous souhaitez.

      Selon le type d'image sélectionné, vous devez ajouter des détails supplémentaires.

6. Cliquez sur Suivant.

7. Sur la page Review, vérifiez les détails de la création de l'image et cliquez sur Créer une image.

   La construction de l'image démarre et dure jusqu'à 20 minutes.

Procédure

1. Créer l'image ISO :

   # composer-cli compose start BLUEPRINT-NAME image-installer

   • BLUEPRINT-NAME avec le nom du plan que vous avez créé

   • image-installer est le type d'image

     Le processus de composition démarre en arrière-plan et l'UUID de la composition est affiché.

2. Attendez que la composition soit terminée. Cela peut prendre plusieurs minutes.

   Pour vérifier l'état de la composition :

   # composer-cli compose status

   Une composition terminée affiche une valeur d'état de FINISHED. Identifiez la composition dans la liste par son UUID.

3. Une fois la composition terminée, téléchargez le fichier image créé :

   # composer-cli composer image UUID

   Remplacez UUID par la valeur UUID obtenue dans les étapes précédentes.

   En conséquence, le constructeur d'images construit un fichier .iso qui contient un fichier .tar. Le fichier .tar est l'image qui sera installée pour le système d'exploitation. Le fichier . iso est configuré pour démarrer Anaconda et installer le fichier tar pour configurer le système.

Vérification

1. Naviguez jusqu'au dossier dans lequel vous avez téléchargé le fichier image.
2. Localisez l'image .iso que vous avez téléchargée.

3. Monter l'ISO.

   $ mount -o ro path_to_ISO /mnt

   Vous trouverez le fichier .tar dans le répertoire /mnt/liveimg.tar.gz.

4. Extraire le contenu du fichier .tar.

   $ tar xzf /mnt/liveimg.tar.gz

Procédure

1. Ouvrez l'interface du constructeur d'images de la console web RHEL dans un navigateur. Voir Création d'un modèle de constructeur d'images à l'aide de l'interface de ligne de commande.
2. Localisez le plan que vous souhaitez utiliser pour construire votre image. Pour ce faire, saisissez le nom du plan ou une partie de celui-ci dans la zone de recherche située en haut à gauche, puis cliquez sur Entrée.

3. Sur le côté droit du plan, cliquez sur le bouton Créer une image.

   L'assistant de dialogue Create image s'ouvre.

4. Dans l'assistant de dialogue Create image:

   1. Dans la liste Image Type, sélectionnez "RHEL Installer (.iso)".
   2. Cliquez sur Créer.

1. Cliquez sur Download pour enregistrer l'image "RHEL Installer (.iso)" sur votre système.
2. Naviguez jusqu'au dossier dans lequel vous avez téléchargé l'image "RHEL Installer (.iso)".
3. Localisez l'image .tar que vous avez téléchargée.

4. Extraire le contenu de l'image "RHEL Installer (.iso)".

   $ tar -xf content.tar

Procédure

1. Écrire l'image ISO amorçable directement sur la clé USB à l'aide de l'outil dd. Par exemple :

   dd if=installer.iso of=/dev/sdX

   Où installer.iso est le nom du fichier image ISO et /dev/sdX est le chemin d'accès de votre clé USB.

2. Insérez la clé USB dans un port USB de l'ordinateur que vous souhaitez démarrer.

3. Démarrez l'image ISO à partir de la clé USB.

   Lorsque l'environnement d'installation démarre, il se peut que vous deviez terminer l'installation manuellement, de la même manière que pour l'installation par défaut de Red Hat Enterprise Linux.

Procédure

1. Créer un schéma directeur au format TOML, avec le contenu suivant :

   name = "blueprint_name"
   description = "blueprint_description"
   version = "0.0.1"
   modules = []
   groups = []
    distro = ""
   
   [customizations]
   [[customizations.user]]
   name = "scap-security-guide"
   description = "Admin account"
   password = secure_password_hash
   key = ssh-key
   home = "/home/scap-security-guide"
   group = ["wheel"]
   
   
   [[customizations.filesystem]]
   mountpoint = "/tmp"
   size = 13107200
   [customizations.openscap]
   datastream = "/usr/share/xml/scap/ssg/content/ssg-rhel8-ds.xml "
   profile_id = "cis"

2. Lance la construction d'une image OpenSCAP :

   # composer-cli compose start blueprint_name qcow2

   Où blueprint_name est le nom du plan.

   Une fois que la construction de l'image est prête, vous pouvez utiliser votre image pré-durcie pour vos déploiements. Voir Création d'une machine virtuelle.

1. Connectez-vous à l'image en utilisant SSH.

2. Lancez le scanner oscap.

   # scap-workbench

3. Sélectionnez la version du système que vous souhaitez analyser. Cliquez sur Charger le contenu.
4. Sélectionnez le profil à analyser et cliquez sur Analyser. OpenSCAP vérifie toutes les exigences du système.

5. Une fois l'analyse terminée, cliquez sur Afficher le rapport.

   Les résultats montrent que le système est sûr.

Procédure

1. Cliquez sur le nom du plan que vous avez créé.
2. Sélectionnez l'onglet Images.
3. Cliquez sur Create Image pour créer votre image personnalisée. Une fenêtre pop-up s'ouvre.
4. Dans la liste du menu déroulant Type, sélectionnez QEMU Image(.qcow2).
5. Définissez la taille que vous souhaitez donner à l'image lorsqu'elle est instanciée et cliquez sur Create.
6. Une petite fenêtre contextuelle en haut à droite de la fenêtre vous informe que la création d'image a été ajoutée à la file d'attente. Une fois le processus de création d'image terminé, vous pouvez consulter l'état de Image build complete.

Vérification

1. Cliquez sur l'icône du fil d'Ariane et sélectionnez l'option Download. Image builder télécharge le fichier de l'image de l'invité KVM .qcow2 à votre emplacement de téléchargement par défaut.

Procédure

1. Déplacez l'image KVM Guest que vous avez créée à l'aide de Image builder dans le répertoire /var/lib/libvirt/images.

2. Créez un répertoire, par exemple cloudinitiso, et naviguez jusqu'à ce répertoire nouvellement créé :

   $ mkdir cloudinitiso
   $ cd cloudinitiso

3. Créez un fichier nommé meta-data. Ajoutez les informations suivantes à ce fichier :

   instance-id: citest
   local-hostname: vmname

4. Créez un fichier nommé user-data. Ajoutez les informations suivantes au fichier :

   #cloud-config
   user: admin
   password: password
   chpasswd: {expire: False}
   ssh_pwauth: True
   ssh_authorized_keys:
     - ssh-rsa AAA...fhHQ== your.email@example.com

   Où ssh_authorized_keys est votre clé publique SSH. Vous trouverez votre clé publique SSH à l'adresse ~/.ssh/id_rsa.pub.

5. Utilisez la commande genisoimage pour créer une image ISO qui inclut les fichiers user-data et meta-data.

   # genisoimage -output cloud-init.iso -volid cidata -joliet -rock user-data meta-data
   
   I: -input-charset not specified, using utf-8 (detected in locale settings)
   Total translation table size: 0
   Total rockridge attributes bytes: 331
   Total directory bytes: 0
   Path table size(bytes): 10
   Max brk space used 0
   183 extents written (0 MB)

6. Créez une nouvelle VM à partir de l'image KVM Guest à l'aide de la commande virt-install. Incluez l'image ISO que vous avez créée à l'étape 4 en tant que pièce jointe à l'image de la VM.

   # virt-install \
       --memory 4096 \
       --vcpus 4 \
       --name myvm \
       --disk rhel-9-x86_64-kvm.qcow2,device=disk,bus=virtio,format=qcow2 \
       --disk cloud-init.iso,device=cdrom \
       --os-variant rhel 9 \
       --virt-type kvm \
       --graphics none \
       --import

   Où ?

   • --graphics none - signifie qu'il s'agit d'une VM RHEL 9 sans tête.
   • --vcpus 4 - signifie qu'il utilise 4 CPU virtuels.
   • --Mémoire 4096 - signifie qu'il utilise 4096 Mo de RAM.

7. L'installation de la VM démarre :

   Starting install...
   Connected to domain mytestcivm
   ...
   [  OK  ] Started Execute cloud user/final scripts.
   [  OK  ] Reached target Cloud-init target.
   
   Red Hat Enterprise Linux 9 (Ootpa)
   Kernel 4.18.0-221.el8.x86_64 on an x86_64

1. Saisissez admin comme nom d'utilisateur et appuyez sur Entrée.

2. Saisissez password comme mot de passe et appuyez sur Entrée.

   Une fois l'authentification terminée, vous pouvez accéder à la VM à l'aide de la CLI.

Procédure

1. Créez un fichier registry-config.toml pour sélectionner le fournisseur de conteneurs.

   provider = "container_provider"
   
   [settings]
   tls_verify = false
   username = "admin"
   password = "your_password"

2. Créez un plan au format .toml. Il s'agit d'un plan pour le conteneur dans lequel vous installez un paquet nginx dans le plan.

   name = "simple-container"
   description = "Simple RHEL container"
   version = "0.0.1"
   
   [[packages]]
   name = "nginx"
   version = "*"

3. Pousser le plan d'action :

   # composer-cli blueprints push blueprint.toml

4. Construire l'image du conteneur :

   # composer-cli compose start simple-container container "quay.io:8080/osbuild/repository" registry-config.toml

   • simple-container - est le nom du modèle.
   • container - est le type d'image.

   • \N "quay.io:8080/osbuild/repository\N" est le registre cible, est l'organisation et est l'emplacement pour pousser le conteneur lorsque la construction est terminée - quay.io est le registre cible, osbuild est l'organisation et repository est l'emplacement où pousser le conteneur à la fin de sa construction. En option, vous pouvez définir une valeur pour tag. Si vous ne définissez pas de valeur pour :tag, la balise :latest est utilisée par défaut.

     Note

     La construction de l'image du conteneur prend du temps en raison de la suppression des paquets personnalisés.

5. Une fois la construction de l'image terminée, le conteneur que vous avez créé est disponible sur quay.io.

6. Accédez à quay.io et cliquez sur Repository Tags.

    You can see details about the container you created, such as:
   - last modified
   - image size
   - the `manifest ID`, that you can copy to the clipboard.

7. Copiez la valeur manifest ID pour construire l'image dans laquelle vous souhaitez intégrer un conteneur.

Procédure

1. Créez un modèle pour construire une image qcow2. Le modèle doit contenir la personnalisation.

   name = "image"
   description = "A qcow2 image with a container"
   version = "0.0.1"
   distro = "rhel-90"
   
   [[packages]]
   name = "podman"
   version = "*"
   
   [[containers]]
   source = "registry.access.redhat.com/ubi9:8080/osbuild/container/container-image@sha256:manifest-ID-from-Repository-tag: tag-version"
   name =  "source-name"
   tls-verify = true

2. Pousser le plan d'action :

   # composer-cli blueprints push blueprint-image.toml

3. Construire l'image du conteneur :

   # composer-cli start compose image qcow2

   Où ?

   • image est le nom du plan.

   • qcow2 est le type d'image.

     Note

     La création de l'image prend du temps car elle vérifie le conteneur dans le registre quay.io.

     Une fois que l'état de construction de l'image est "FINISHED", vous pouvez utiliser l'image qcow2 que vous avez créée dans une VM.

Vérification

1. Transférez l'image .qcow2 depuis le site composer-cli vers votre système de fichiers local :

   # composer-cli compose image COMPOSE-UUID

2. Démarrez l'image qcow2 dans une machine virtuelle. Voir Création d'une machine virtuelle à partir d'une image d'invité KVM.

3. L'assistant qemu s'ouvre. Connectez-vous à l'image qcow2.

   1. Saisissez le nom d'utilisateur et le mot de passe. Il peut s'agir du nom d'utilisateur et du mot de passe que vous avez définis dans le projet .qcow2 dans la section \N "customizations.user\N", ou que vous avez créés au démarrage avec cloud-init.

4. Exécutez l'image du conteneur et ouvrez une invite shell à l'intérieur du conteneur :

   # podman run -it registry.access.redhat.com/ubi9:8080/osbuild/repository /bin/bash/

   Où ?

   • registry.access.redhat.com est le registre cible, osbuild est l'organisation et repository est l'emplacement où pousser le conteneur à la fin de sa construction.

5. Vérifiez que les paquets que vous avez ajoutés au plan sont disponibles :

   # type -a nginx

   La sortie indique le chemin du paquet nginx.

Procédure

1. Installez Python 3 et l'outil pip:

   # dnf install python3
   # dnf install python3-pip

2. Installez les outils en ligne de commande AWS avec pip:

   # pip3 install awscli

3. Exécutez la commande suivante pour définir votre profil. Le terminal vous invite à fournir vos informations d'identification, votre région et le format de sortie :

   $ aws configure
   AWS Access Key ID [None]:
   AWS Secret Access Key [None]:
   Default region name [None]:
   Default output format [None]:

4. Définissez un nom pour votre seau et utilisez la commande suivante pour créer un seau :

   $ BUCKET=bucketname
   $ aws s3 mb s3://$BUCKET

   Remplacez bucketname par le nom du seau. Il doit s'agir d'un nom unique au niveau mondial. Le résultat est la création d'un seau.

5. Pour autoriser l'accès au seau S3, créez un rôle S3 vmimport dans le système de gestion des identités et des accès (IAM) d'AWS, si vous ne l'avez pas déjà fait par le passé :

   $ printf '{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "vmie.amazonaws.com" }, "Action": "sts:AssumeRole", "Condition": { "StringEquals":{ "sts:Externalid": "vmimport" } } } ] }' > trust-policy.json
   $ printf '{ "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":[ "s3:GetBucketLocation", "s3:GetObject", "s3:ListBucket" ], "Resource":[ "arn:aws:s3:::%s", "arn:aws:s3:::%s/*" ] }, { "Effect":"Allow", "Action":[ "ec2:ModifySnapshotAttribute", "ec2:CopySnapshot", "ec2:RegisterImage", "ec2:Describe*" ], "Resource":"*" } ] }' $BUCKET $BUCKET > role-policy.json
   $ aws iam create-role --role-name vmimport --assume-role-policy-document file://trust-policy.json
   $ aws iam put-role-policy --role-name vmimport --policy-name vmimport --policy-document file://role-policy.json

Procédure

1. À l'aide d'un éditeur de texte, créez un fichier de configuration avec le contenu suivant :

   provider = "aws"
   
   [settings]
   accessKeyID = "AWS_ACCESS_KEY_ID"
   secretAccessKey = "AWS_SECRET_ACCESS_KEY"
   bucket = "AWS_BUCKET"
   region = "AWS_REGION"
   key = "IMAGE_KEY"

   Remplacez les valeurs des champs par vos informations d'identification pour accessKeyID, secretAccessKey, bucket, et region. La valeur IMAGE_KEY est le nom de votre image VM à télécharger sur EC2.

2. Enregistrez le fichier sous CONFIGURATION-FILE.toml et fermez l'éditeur de texte.

3. Commencez la composition :

   # composer-cli composer start BLUEPRINT-NAME IMAGE-TYPE IMAGE_KEY CONFIGURATION-FILE .toml

   Remplacer :

   • BLUEPRINT-NAME avec le nom du plan que vous avez créé
   • IMAGE-TYPE avec le type d'image ami.
   • IMAGE_KEY avec le nom de l'image de la VM à télécharger sur EC2.

   • CONFIGURATION-FILE.toml avec le nom du fichier de configuration du fournisseur de cloud.

     Note

     Vous devez avoir les paramètres IAM corrects pour le panier dans lequel vous allez envoyer votre image personnalisée. Vous devez définir une politique pour votre panier avant de pouvoir y télécharger des images.

4. Vérifiez l'état de la création de l'image et téléchargez-la sur AWS :

   # composer-cli compose status

   Une fois le processus de téléchargement de l'image terminé, vous pouvez voir l'état "FINISHED".

1. Accédez à EC2 dans le menu et sélectionnez la région correcte dans la console AWS. L'image doit avoir le statut available, pour indiquer qu'elle a été téléchargée avec succès.
2. Dans le tableau de bord, sélectionnez votre image et cliquez sur Launch.

Procédure

1. Cliquez sur le site blueprint name.
2. Sélectionnez l'onglet Images.

3. Cliquez sur Créer une image pour créer votre image personnalisée.

   Une fenêtre pop-up s'ouvre.

   1. Dans la liste du menu déroulant Type, sélectionnez Amazon Machine Image Disk (.raw).
   2. Cochez la case Upload to AWS pour télécharger votre image dans le nuage AWS et cliquez sur Suivant.

   3. Pour authentifier votre accès à AWS, saisissez votre AWS access key ID et AWS secret access key dans les champs correspondants. Cliquez sur Suivant.

      Note

      Vous ne pouvez consulter votre clé d'accès secrète AWS que lorsque vous créez un nouvel ID de clé d'accès. Si vous ne connaissez pas votre clé secrète, générez un nouvel ID de clé d'accès.

   4. Saisissez le nom de l'image dans le champ Image name, le nom du panier Amazon dans le champ Amazon S3 bucket name et le champ AWS region pour le panier dans lequel vous allez ajouter votre image personnalisée. Cliquez sur Suivant.

   5. Vérifiez les informations et cliquez sur Terminer.

      En option, vous pouvez cliquer sur Retour pour modifier tout détail incorrect.

      Note

      Vous devez disposer des paramètres IAM corrects pour le panier dans lequel vous allez envoyer votre image personnalisée. Cette procédure utilise l'importation et l'exportation IAM, vous devez donc configurer a policy pour votre panier avant de pouvoir y télécharger des images. Pour plus d'informations, voir Autorisations requises pour les utilisateurs IAM.

4. Une petite fenêtre contextuelle en haut à droite vous informe de la progression de l'enregistrement. Elle indique également que la création d'une image a été lancée, l'état d'avancement de cette création et le téléchargement ultérieur vers le nuage AWS.

   Une fois le processus terminé, vous pouvez consulter l'état de Image build complete.

5. Cliquez sur Service→EC2 dans le menu et choisissez la bonne région dans la console AWS. L'image doit avoir le statut Available, pour indiquer qu'elle est téléchargée.
6. Dans le tableau de bord, sélectionnez votre image et cliquez sur Launch.
7. Une nouvelle fenêtre s'ouvre. Choisissez un type d'instance en fonction des ressources dont vous avez besoin pour démarrer votre image. Cliquez sur Review et Launch.
8. Passez en revue les détails de votre début d'instance. Vous pouvez éditer chaque section si vous avez besoin de faire des changements. Cliquez sur Launch

9. Avant de démarrer l'instance, sélectionnez une clé publique pour y accéder.

   Vous pouvez utiliser la paire de clés que vous possédez déjà ou en créer une nouvelle.

   Suivez les étapes suivantes pour créer une nouvelle paire de clés dans EC2 et l'attacher à la nouvelle instance.

   1. Dans la liste du menu déroulant, sélectionnez Create a new key pair.
   2. Entrez le nom de la nouvelle paire de clés. Une nouvelle paire de clés est générée.
   3. Cliquez sur Download Key Pair pour enregistrer la nouvelle paire de clés sur votre système local.

10. Ensuite, vous pouvez cliquer sur Launch Instance pour démarrer votre instance.

    Vous pouvez vérifier l'état de l'instance, qui s'affiche comme suit : Initializing.

11. Une fois que l'état de l'instance est running, le bouton Connecter devient disponible.

12. Cliquez sur Connecter. Une fenêtre contextuelle s'affiche avec des instructions sur la manière de se connecter en utilisant SSH.

    1. Sélectionnez A standalone SSH client comme méthode de connexion préférée et ouvrez un terminal.

    2. À l'endroit où vous stockez votre clé privée, assurez-vous qu'elle est publiquement visible pour que SSH fonctionne. Pour ce faire, exécutez la commande suivante

       $ chmod 400 <nom-de-votre-instance.pem>_

    3. Connectez-vous à votre instance en utilisant son DNS public :

       $ ssh -i "<_votre-nom-d'instance.pem_"> ec2-user@<_votre-adresse-IP-d'instance_>

    4. Tapez yes pour confirmer que vous voulez continuer à vous connecter.

       Par conséquent, vous êtes connecté à votre instance en utilisant SSH.

Vérification

1. Vérifiez si vous pouvez effectuer une action lorsque vous êtes connecté à votre instance à l'aide de SSH.

Procédure

1. Importer la clé du référentiel Microsoft :

   # rpm --import https://packages.microsoft.com/keys/microsoft.asc

2. Créer un dépôt local d'informations azure-cli:

   # sh -c 'echo -e \N-[azure-cli]\N-[azure-cli]\N-[azure-cli]\N-[azure-cli]\Nbaseurl=https://packages.microsoft.com/yumrepos/azure-cli\Nenabled=1\Npgcheck=1\Npgkey=https://packages.microsoft.com/keys/microsoft.asc\N" > /etc/yum.repos.d/azure-cli.repo'

3. Installez la CLI Microsoft Azure :

   # dnfdownloader azure-cli
   # rpm -ivh --nodeps azure-cli-2.0.64-1.el7.x86_64.rpm

   Note

   La version téléchargée du paquet Microsoft Azure CLI peut varier en fonction de la version actuellement disponible.

4. Exécutez l'interface de programmation Microsoft Azure :

   $ az login

   Le terminal affiche le message suivant : Note, we have launched a browser for you to login. For old experience with device code, use "az login --use-device-code. Ensuite, le terminal ouvre un navigateur avec un lien vers https://microsoft.com/devicelogin à partir duquel vous pouvez vous connecter.

   Note

   Si vous exécutez une session à distance (SSH), le lien https://microsoft.com/devicelogin ne s'ouvrira pas dans le navigateur. Dans ce cas, vous pouvez copier le lien dans un navigateur et vous connecter pour authentifier votre session à distance. Pour vous connecter, utilisez un navigateur web pour ouvrir la page https://microsoft.com/devicelogin et entrez le code de l'appareil pour vous authentifier.

5. Listez les clés du compte de stockage dans Microsoft Azure :

   $ GROUP=resource-group-name
   $ ACCOUNT=storage-account-name
   $ az storage account keys list --resource-group $GROUP --account-name $ACCOUNT

   Remplacez resource-group-name par le nom de votre groupe de ressources Microsoft Azure et storage-account-name par le nom de votre compte de stockage Microsoft Azure.

   Note

   Vous pouvez dresser la liste des ressources disponibles à l'aide de la commande suivante :

   $ az resource list

6. Notez la valeur key1 dans la sortie de la commande précédente, et affectez-la à une variable d'environnement :

   kEY1=value

7. Créer un conteneur de stockage :

   $ CONTAINER=storage-account-name
   $ az storage container create --account-name $ACCOUNT \
   --account-key $KEY1 --name $CONTAINER

   Remplacez storage-account-name par le nom du compte de stockage.

Procédure

1. Transférez l'image vers Microsoft Azure et créez une instance à partir de celle-ci :

   $ VHD=25ccb8dd-3872-477f-9e3d-c2970cd4bbaf-disk.vhd
   $ az storage blob upload --account-name $ACCOUNT --container-name $CONTAINER --file $VHD --name $VHD --type page
   ...

2. Une fois le téléchargement vers le stockage Microsoft Azure Blob terminé, créez une image Microsoft Azure à partir de celui-ci :

   $ az image create --resource-group $GROUP --name $VHD --os-type linux --location eastus --source https://$ACCOUNT.blob.core.windows.net/$CONTAINER/$VHD
    - Running ...

Vérification

1. Créez une instance à l'aide du portail Microsoft Azure ou d'une commande similaire à la suivante :

   $ az vm create --resource-group $GROUP --location eastus --name $VHD --image $VHD --admin-username azure-user --generate-ssh-keys
    - Running ...

2. Utilisez votre clé privée via SSH pour accéder à l'instance résultante. Connectez-vous en tant que azure-user.

Procédure

1. Dans le tableau de bord du constructeur d'images, sélectionnez le modèle que vous souhaitez utiliser.
2. Cliquez sur l'onglet Images.

3. Cliquez sur Créer une image pour créer votre image .vhd personnalisée.

   L'assistant Create image s'ouvre.

   1. Sélectionnez Microsoft Azure (.vhd) dans la liste du menu déroulant Type.
   2. Cochez la case Upload to Azure pour télécharger votre image dans le nuage Microsoft Azure.
   3. Saisissez le site Image Size et cliquez sur Next.

4. Sur la page Upload to Azure, saisissez les informations suivantes :

   1. Sur la page Authentification, entrez :

      1. Votre nom Storage account. Vous le trouverez sur la page Storage account, dans le portail Microsoft Azure.
      2. Votre Storage access key: Vous pouvez le trouver sur la page Access Key Storage.
      3. Cliquez sur Suivant.

   2. Sur la page Authentication, entrez :

      1. Le nom de l'image.
      2. Le Storage container est le conteneur blob dans lequel vous allez télécharger l'image. Vous le trouverez sous la section Blob service, dans le portail Microsoft Azure.
      3. Cliquez sur Suivant.
5. Sur la page Review, cliquez sur Créer. Les processus de construction et de téléchargement de l'image démarrent.

Prochaines étapes

1. Pour accéder à l'image que vous avez transférée sur Microsoft Azure Cloud, accédez au portail Microsoft Azure.
2. Dans la barre de recherche, tapez "compte de stockage" et cliquez sur Storage accounts dans la liste.
3. Dans la barre de recherche, tapez "Images" et sélectionnez la première entrée sous Services. Vous êtes redirigé vers le site Image dashboard.
4. Dans le panneau de navigation, cliquez sur Containers.
5. Trouvez le conteneur que vous avez créé. Dans le conteneur se trouve le fichier your_image_name.vhd que vous avez créé et poussé.

1. Dans la barre de recherche, tapez compte images et cliquez sur Images dans la liste.
2. Cliquez sur Créer.
3. Dans la liste déroulante, choisissez le groupe de ressources que vous avez utilisé précédemment.
4. Entrez un nom pour l'image.
5. Pour le site OS type, sélectionnez Linux.
6. Pour le site VM generation, sélectionnez Gen 2.
7. Sous Storage Blob, cliquez sur Parcourir et cliquez sur les comptes de stockage et les conteneurs jusqu'à ce que vous atteigniez votre fichier VHD.
8. Cliquez sur Select à la fin de la page.
9. Choisissez un type de compte, par exemple, Standard SSD.
10. Cliquez sur Réviser créer, puis sur Créer. Attendez quelques instants pour la création de l'image.

1. Cliquez sur Aller à la ressource.
2. Cliquez sur Créer une VM dans la barre de menu de l'en-tête.
3. Entrez un nom pour votre machine virtuelle.
4. Complétez les sections Size et Administrator account.

5. Cliquez sur Examiner la création, puis sur Créer. Vous pouvez voir la progression du déploiement.

   Une fois le déploiement terminé, cliquez sur le nom de la machine virtuelle pour récupérer l'adresse IP publique de l'instance afin de vous connecter à l'aide de SSH.

6. Ouvrez un terminal pour créer une connexion SSH afin de vous connecter à la VM.

Procédure

1. Naviguez jusqu'au répertoire où vous avez téléchargé votre image .vmdk.

2. Lancer l'image sur vSphere en suivant les étapes :

   1. Importez l'image .vmdk dans vSphere :

      govc import.vmdk ./composer-api.vmdk foldername

   2. Créez la VM dans VSphere sans la mettre sous tension :

      govc vm.create \
      -net.adapter=vmxnet3 \
      -m=4096 -c=2 -g=rhel8_64Guest \
      -firmware=efi -disk=”foldername/composer-api.vmdk” \
      -disk.controller=scsi -on=false \
       vmname

   3. Mettez la VM sous tension :

      govc vm.power -on vmname

   4. Récupérer l'adresse IP de la VM :

      HOST=$(govc vm.ip vmname)

   5. Utilisez SSH pour vous connecter à la VM, en utilisant le nom d'utilisateur et le mot de passe que vous avez spécifiés dans votre plan :

      $ ssh admin@HOST

      Note

      Si vous avez copié l'image .vmdk de votre hôte local vers la destination à l'aide de la commande govc datastore.upload, l'utilisation de l'image n'est pas prise en charge. Il n'y a pas d'option pour utiliser la commande import.vmdk dans l'interface graphique vSphere et, par conséquent, l'interface graphique vSphere ne prend pas en charge le téléchargement direct, ce qui signifie que l'image .vmdk n'est pas directement utilisable à partir de l'interface graphique vSphere.

Procédure

1. Pour le plan que vous avez créé, cliquez sur l'onglet Images.

2. Cliquez sur Créer une image pour créer votre image personnalisée.

   La fenêtre Type d'image s'ouvre.

3. Dans la fenêtre Image type:

   1. Dans le menu déroulant, sélectionnez le type : VMware VSphere (.vmdk).
   2. Cochez la case Upload to VMware pour télécharger votre image sur vSphere.
   3. Facultatif : Définissez la taille de l'image que vous souhaitez instancier. La taille minimale par défaut est de 2 Go.
   4. Cliquez sur Suivant.

4. Dans la fenêtre Upload to VMware, sous Authentication, entrez les détails suivants :

   1. Usernamenom d'utilisateur du compte vSphere.
   2. Passwordmot de passe du compte vSphere.

5. Dans la fenêtre Upload to VMware, sous Destination, entrez les détails suivants :

   1. Image name: un nom pour l'image à télécharger.
   2. Host: L'URL de votre VMware vSphere où l'image sera téléchargée.
   3. Cluster: Le nom du cluster où l'image sera téléchargée.
   4. Data center: Le nom du centre de données où l'image sera téléchargée.
   5. Data store:Le nom du magasin de données où l'image sera téléchargée.
   6. Cliquez sur Next.

6. Dans la fenêtre Review, vérifiez les détails de la création de l'image et cliquez sur Terminer.

   Vous pouvez cliquer sur Retour pour modifier tout détail incorrect.

   Image builder ajoute la composition d'une image RHEL vSphere à la file d'attente, crée et télécharge l'image vers le cluster sur l'instance vSphere que vous avez spécifiée.

   Note

   Les processus de création et de téléchargement de l'image prennent quelques minutes.

   Une fois le processus terminé, vous pouvez consulter l'état de Image build complete.

1. Accédez au client VMware vSphere.
2. Recherchez l'image dans le cluster sur l'instance vSphere que vous avez spécifiée.

3. Vous pouvez créer une nouvelle VM à partir de l'image que vous avez téléchargée :

   1. Sélectionnez l'image que vous avez téléchargée.
   2. Cliquez avec le bouton droit de la souris sur l'image sélectionnée.

   3. Cliquez sur New Virtual Machine.

      Une fenêtre New Virtual Machine s'ouvre.

      Dans la fenêtre New Virtual Machine, fournissez les informations suivantes :

      1. Sélectionnez New Virtual Machine.
      2. Sélectionnez un nom et un dossier pour votre VM.
      3. Sélectionner une ressource informatique : choisir une ressource informatique de destination pour cette opération.
      4. Sélectionnez le stockage : Par exemple, sélectionnez NFS-Node1
      5. Sélectionnez la compatibilité : L'image doit être réservée au BIOS.
      6. Sélectionnez un système d'exploitation invité : Par exemple, sélectionnez Linux et Red Hat Fedora (64-bit).
      7. Customize hardware: Lors de la création d'une VM, sur le bouton Device Configuration en haut à droite, supprimez le Nouveau disque dur par défaut et utilisez le menu déroulant pour sélectionner une image de disque dur existante :
      8. Prêt à compléter : Passez en revue les détails et cliquez sur Finish pour créer l'image.

   4. Naviguez jusqu'à l'onglet VMs.

      1. Dans la liste, sélectionnez la VM que vous avez créée.
      2. Cliquez sur le bouton Start dans le tableau de bord. Une nouvelle fenêtre apparaît, montrant le chargement de l'image VM.
      3. Connectez-vous avec les informations d'identification que vous avez créées pour le projet.

      4. Vous pouvez vérifier si les paquets que vous avez ajoutés au plan sont installés. Par exemple, vous pouvez vérifier si les paquets que vous avez ajoutés au plan directeur sont installés :

         $ rpm -qa | grep firefox

Procédure

1. Commencez la composition d'une image QCOW2.

   # composer-cli compose start blueprint_name openstack

2. Vérifier l'état du bâtiment.

   # composer-cli compose status

   Une fois la construction de l'image terminée, vous pouvez télécharger l'image.

3. Télécharger l'image QCOW2:

   # composer-cli composer image UUID

4. Accédez au tableau de bord OpenStack et cliquez sur Créer une image.

5. Dans le menu de gauche, sélectionnez l'onglet Admin.

   1. Sur le site System Panel, cliquez sur Image.

      L'assistant Create An Image s'ouvre.

6. Dans l'assistant Create An Image:

   1. Saisir un nom pour l'image
   2. Cliquez sur Browse pour télécharger l'image QCOW2.
   3. Dans la liste déroulante Format, sélectionnez le site QCOW2 - QEMU Emulator.

   4. Cliquez sur Créer une image.

      

7. Dans le menu de gauche, sélectionnez l'onglet Project.

   1. Dans le menu Compute, sélectionnez Instances.

   2. Cliquez sur le bouton Launch Instance sur le bouton

      L'assistant Launch Instance s'ouvre.

   3. Sur la page Details, saisissez un nom pour l'instance. Cliquez sur Suivant.
   4. Sur la page Source, sélectionnez le nom de l'image que vous avez téléchargée. Cliquez sur Suivant.

   5. Sur la page Flavor, sélectionnez les ressources machine qui correspondent le mieux à vos besoins. Cliquez sur Launch.

      

8. Vous pouvez exécuter l'instance de l'image en utilisant n'importe quel mécanisme (CLI ou OpenStack web UI) à partir de l'image. Utilisez votre clé privée via SSH pour accéder à l'instance résultante. Connectez-vous en tant que cloud-user.

Procédure

1. Connectez-vous au système contenant l'image que vous souhaitez vérifier en utilisant le site Alibaba image_check tool.

2. Télécharger le site image_check tool:

   $ curl -O http://docs-aliyun.cn-hangzhou.oss.aliyun-inc.com/assets/attach/73848/cn_zh/1557459863884/image_check

3. Modifier les droits d'accès au fichier de l'outil de mise en conformité des images :

   # chmod +x image_check

4. Exécutez la commande pour lancer le contrôle de l'outil de conformité de l'image :

   # ./image_check

   L'outil vérifie la configuration du système et génère un rapport qui s'affiche à l'écran. L'outil image_check enregistre ce rapport dans le même dossier que l'outil image compliance.

Procédure

1. Connectez-vous à la console OSS.
2. Dans le menu Bucket sur la gauche, sélectionnez le bucket dans lequel vous souhaitez télécharger une image.
3. Dans le menu supérieur droit, cliquez sur l'onglet Fichiers.

4. Cliquez sur Upload. Une fenêtre de dialogue s'ouvre à droite. Configurez les éléments suivants :

   • Upload To: Choisissez de télécharger le fichier dans le répertoire Current ou dans un répertoire Specified.
   • File ACL: Choisissez le type d'autorisation du fichier téléchargé.
5. Cliquez sur Upload.
6. Sélectionnez l'image que vous souhaitez télécharger.
7. Cliquez sur Ouvrir.

Procédure

1. Connectez-vous à la console ECS.

   1. Dans le menu de gauche, cliquez sur Images.
   2. En haut à droite, cliquez sur Importer une image. Une fenêtre de dialogue s'ouvre.

   3. Confirmez que vous avez configuré la région correcte où se trouve l'image. Saisissez les informations suivantes :

      1. OSS Object Address: Voir comment obtenir l'adresse de l'objet OSS.
      2. Image Name
      3. Operating System
      4. System Disk Size
      5. System Architecture
      6. Platform: Red Hat

   4. Si vous le souhaitez, vous pouvez fournir les informations suivantes :

      7. Image Formatle format de l'image téléchargée est le suivant : qcow2 ou ami, selon le format de l'image téléchargée.
      8. Image Description

      9. Add Images of Data Disks

         L'adresse peut être déterminée dans la console de gestion OSS. Après avoir sélectionné le seau souhaité dans le menu de gauche :

2. Sélectionnez la section Files.

3. Cliquez sur le lien Détails à droite pour l'image appropriée.

   Une fenêtre apparaît sur le côté droit de l'écran, affichant les détails de l'image. L'adresse de l'objet OSS se trouve dans la case URL.

4. Cliquez sur OK.

   Note

   La durée du processus d'importation peut varier en fonction de la taille de l'image.

Procédure

1. Connectez-vous à la console ECS.
2. Dans le menu de gauche, sélectionnez Instances.
3. Dans le coin supérieur droit, cliquez sur Create Instance. Vous êtes redirigé vers une nouvelle fenêtre.
4. Complétez toutes les informations requises. Pour plus de détails, voir Création d'une instance à l'aide de l'assistant.

5. Cliquez sur Create Instance et confirmez la commande.

   Note

   Vous pouvez voir l'option Create Order au lieu de Create Instance, selon votre abonnement.