Remarques :

• Ce tutoriel est disponible dans un environnement d'atelier gratuit fourni par Oracle.
• Il utilise des exemples de valeurs pour les informations d'identification, la location et les compartiments Oracle Cloud Infrastructure. Lorsque vous terminez votre atelier, remplacez ces valeurs par celles propres à votre environnement cloud.

Gérer des machines virtuelles KVM à l'aide d'Oracle Linux Automation Manager

Introduction

La collection community.libvirt fournit des modules libvirt et des plug-ins pris en charge par la communauté libvirt Ansible. Ces modules et modules d'extension permettent de gérer les machines virtuelles et les conteneurs à l'aide de l'API libvirt.

Objectifs

Dans ce tutoriel, vous allez apprendre à :

• Créez un livre de jeux qui utilise la collection community.libvirt
• Configurer les informations d'identification pour Ansible Galaxy
• Création d'un modèle de tâche
• Exécutez le job

Prérequis

• Système sur lequel Oracle Linux Automation Manager est installé
• Accès à un référentiel Git
• Un système Oracle Linux avec KVM installé

Remarque : pour plus de détails sur l'installation d'Oracle Linux Automation Manager ou de KVM, reportez-vous aux liens à la fin de cet exercice.

Déployer Oracle Linux Automation Manager

Remarque : en cas d'exécution dans votre propre location, lisez le projet linux-virt-labs GitHub README.md et respectez les prérequis avant de déployer l'environnement d'atelier.

1. Ouvrez un terminal sur le bureau Luna.

2. Clonez le projet linux-virt-labs GitHub.

   git clone https://github.com/oracle-devrel/linux-virt-labs.git
   

3. Accédez au répertoire de travail.

   cd linux-virt-labs/olam
   

4. Installez les collections requises.

   ansible-galaxy collection install -r requirements.yml
   

5. Mettez à jour la configuration de l'instance Oracle Linux.

   cat << EOF | tee instances.yml > /dev/null
   compute_instances:
     1:
       instance_name: "olam-node"
       type: "control"
     2:
       instance_name: "git-server"
       type: "server"
     3:
       instance_name: "kvm-server"
       type: "server"
   passwordless_ssh: true
   use_git: true
   use_kvm: true
   EOF
   

6. Déployez l'environnement d'exercice.

   ansible-playbook create_instance.yml -e ansible_python_interpreter="/usr/bin/python3.6" -e "@instances.yml"
   

   L'environnement d'atelier gratuit nécessite la variable supplémentaire ansible_python_interpreter car il installe le package RPM pour le kit SDK Oracle Cloud Infrastructure pour Python. L'emplacement d'installation de ce package se trouve sous les modules python3.6.

   La forme de déploiement par défaut utilise la CPU AMD et Oracle Linux 8. Pour utiliser une CPU Intel ou Oracle Linux 9, ajoutez -e instance_shape="VM.Standard3.Flex" ou -e os_version="9" à la commande de déploiement.

   Important : attendez que le playbook s'exécute correctement et atteignez la tâche de pause. L'installation d'Oracle Linux Automation Manager est terminée à ce stade du manuel et les instances sont prêtes. Notez la lecture précédente, qui imprime les adresses IP publiques et privées des noeuds qu'elle déploie.

Créer un Playbook

1. Ouvrez une nouvelle fenêtre de terminal.

2. Définissez une variable sur l'instance de serveur git distante.

   export REMOTE=<ip_address_of_instance>
   

3. Créez le répertoire du projet.

   mkdir ~/olamkvm
   

4. Créez un fichier de conditions.

   Oracle Linux Automation Engine utilise le fichier d'exigences pour extraire les ensembles ou rôles requis dans le projet lors de l'exécution.

   cat << EOF > ~/olamkvm/requirements.yml 
   ---
   collections:
     - name: community.libvirt
     - name: community.general
     - name: community.crypto
   EOF
   

5. Créez un fichier de variables.

   Le fichier stocke les variables et leurs valeurs par défaut. Le playbook importe ce fichier lors de l'exécution.

   1. Créez un répertoire de stockage pour le fichier.

      mkdir ~/olamkvm/vars
      

   2. Créez le fichier .

      cat << EOF > ~/olamkvm/vars/defaults.yml
      ---
      username: oracle
      base_image_name: OL9U5_x86_64-kvm-b253.qcow2
      base_image_url: https://yum.oracle.com/templates/OracleLinux/OL9/u5/x86_64/
      base_image_sha: 3b00bbbefc8e78dd28d9f538834fb9e2a03d5ccdc2cadf2ffd0036c0a8f02021
      libvirt_pool_dir: "/var/lib/libvirt/images"
      vm_name: ol9-dev
      vm_vcpus: 2
      vm_ram_mb: 2048
      vm_net: default
      vm_root_pass: 
      cleanup_tmp: no 
      EOF
      

6. Créez les modèles cloud-init.

   Ces modèles créent les fichiers meta-data et user-data pour provisionner la configuration de machine virtuelle via cloud-init.

   1. Créez un répertoire de stockage pour les modèles.

      mkdir ~/olamkvm/templates
      

   2. Créez le modèle de métadonnées.

      cat << EOF > ~/olamkvm/templates/meta-data.j2
      instance-id: iid-local01
      local-hostname: 
      EOF
      

   3. Créez le modèle de données utilisateur.

      cat << EOF > ~/olamkvm/templates/user-data.j2
      #cloud-config
      
      system_info:
        default_user:
          name: opc
      
      ssh_authorized_keys:
        - 
      EOF
      

7. Créez le modèle de définition de machine virtuelle libvirt.

   cat << EOF > ~/olamkvm/templates/vm-template.xml.j2
   <domain type="kvm">
     <name></name>
     <memory unit='MiB'></memory>
     <vcpu placement='static'></vcpu>
     <os>
       <type arch="x86_64" machine="q35">hvm</type>
       <boot dev="hd"/>
     </os>
     <features>
       <acpi/>
       <apic/>
     </features>
     <cpu mode="host-model"/>
     <clock offset="utc">
       <timer name="rtc" tickpolicy="catchup"/>
       <timer name="pit" tickpolicy="delay"/>
       <timer name="hpet" present="no"/>
     </clock>
     <pm>
       <suspend-to-mem enabled="no"/>
       <suspend-to-disk enabled="no"/>
     </pm>
     <devices>
       <emulator>/usr/libexec/qemu-kvm</emulator>
       <disk type="file" device="disk">
         <driver name="qemu" type="qcow2"/>
         <source file="/.qcow"/>
         <target dev="vda" bus="virtio"/>
       </disk>
       <disk type="file" device="cdrom">
         <driver name="qemu" type="raw"/>
         <source file="/.iso"/>
         <target dev="sda" bus="sata"/>
         <readonly/>
       </disk>
       <controller type="usb" model="qemu-xhci" ports="15"/>
       <interface type="network">
         <source network=""/>
         <model type="virtio"/>
       </interface>
       <console type="pty"/>
       <channel type="unix">
         <source mode="bind"/>
         <target type="virtio" name="org.qemu.guest_agent.0"/>
       </channel>
       <memballoon model="virtio"/>
       <rng model="virtio">
         <backend model="random">/dev/urandom</backend>
       </rng>
     </devices>
   </domain>
   EOF
   

8. Créer un playbook.

   Ce guide pratique interroge le serveur KVM sur les machines virtuelles existantes, puis déploie une nouvelle image cloud Oracle Linux.

   cat << EOF > ~/olamkvm/create_vm.yml
   ---
   - name: Create vm with community.libvirt collection
     hosts: kvm
     become: true
   
     vars_files:
       - vars/defaults.yml
   
     tasks:
   
     - name: Add python lxml module required by libvirt ansible module
       ansible.builtin.dnf:
         name: python3-lxml
         state: present
   
     - name: Get list of existing VMs
       community.libvirt.virt:
         command: list_vms
       register: existing_vms
       changed_when: false
   
     - name: Print list of existing VMs
       ansible.builtin.debug:
         var: existing_vms
   
     - name: Create VM when not exist
       when: ( vm_name not in existing_vms.list_vms )
       block:
   
       - name: Download base image
         ansible.builtin.get_url:
           url: ""
           dest: "/tmp/"
           checksum: "sha256:"
           mode: "0664"
   
       - name: Copy base image to libvirt directory
         ansible.builtin.copy:
           dest: "/.qcow"
           src: "/tmp/"
           force: false
           remote_src: true 
           owner: qemu
           group: qemu
           mode: "0660"
         register: copy_results
   
       - name: Generate a vm ssh keypair
         community.crypto.openssh_keypair:
           path: ~/.ssh/id_rsa
           size: 2048
           comment: vm ssh keypair
         register: vm_ssh_keypair
         become: true
         become_user: ""
   
       - name: Create vm meta-data
         ansible.builtin.template:
           src: templates/meta-data.j2
           dest: "~/meta-data"
           mode: "0664"
         become_user: ""
   
       - name: Read the vm ssh private key
         ansible.builtin.slurp:
           src: "~/.ssh/id_rsa.pub"
         register: vm_ssh_private_key
         become: true
         become_user: ""
   
       - name: Create var for private key
         ansible.builtin.set_fact:
           vm_private_key: ""
   
       - name: Create vm user-data
         ansible.builtin.template:
           src: templates/user-data.j2
           dest: ~/user-data
           mode: "0664"
         become: true
         become_user: ""
   
       - name: Generate iso containing cloud-init configuration
         ansible.builtin.shell: |
           genisoimage -output /tmp/.iso -volid cidata -joliet -rock ~/user-data ~/meta-data
         become: true
         become_user: ""
         register: generate_iso
         changed_when: generate_iso.rc == 0
   
       - name: Copy vm iso image to libvirt directory
         ansible.builtin.copy:
           dest: "/.iso"
           src: "/tmp/.iso"
           force: false
           remote_src: true 
           owner: qemu
           group: qemu
           mode: "0660"
   
       - name: Remove vm iso image from tmp
         ansible.builtin.file:
           path: "/tmp/.iso"
           state: absent
   
       - name: Define the vm
         community.libvirt.virt:
           command: define
           xml: ""
   
     - name: Start the vm
       community.libvirt.virt:
         name: ""
         state: running
       register: vm_start_results
       until: "vm_start_results is success"
       retries: 15
       delay: 2
   
     - name: Remove the temporary file
       ansible.builtin.file:
         path: "/tmp/"
         state: absent
       when: cleanup_tmp | bool
   EOF
   

Ajouter le projet au contrôle des versions

1. Initialisez le répertoire de travail du projet dans un référentiel Git.

   Avant d'initialiser le référentiel, vous devez effectuer certaines étapes de configuration initiale de Git.

   1. Définissez le nom de branchement par défaut utilisé lors de l'initialisation d'un projet.

      git config --global init.defaultBranch main
      

   2. Définissez votre identité.

      Le courriel et le nom sont des exemples dans ce tutoriel. Utilisez votre email et votre nom lorsque vous travaillez sur vos projets, car ces informations sont immuables à chaque engagement.

      git config --global user.email [e-mail]
      git config --global user.name "John Doe"
      

   3. Accédez au répertoire de travail du projet.

      cd ~/olamkvm
      

   4. Initialisez le répertoire en tant que référentiel Git local.

      git init
      

      La commande renvoie qu'elle a initialisé le référentiel Git vide.

2. Vérifiez l'état du répertoire de travail et de la zone intermédiaire du projet.

   git status
   

   L'état du référentiel local indique deux fichiers non suivis, create_vm.yml et requirements.yml, ainsi que les répertoires vars et templates.

3. Ajoutez et suivez les nouveaux fichiers dans la zone intermédiaire.

   git add --all
   

   L'option --all ajoute tous les fichiers non suivis et modifiés à la zone intermédiaire.

4. Validez les modifications actuellement dans la zone intermédiaire.

   git commit -m 'initial commit'
   

   L'option -m permet d'ajouter un commentaire aux modifications validées.

5. Créez et initialisez le référentiel Git distant.

   Un référentiel distant est un référentiel partagé utilisé par tous les contributeurs de projet et stocké sur un service d'hébergement de code tel que GitHub ou un serveur auto-hébergé.

   ssh git@$REMOTE "git init -b main --bare /git-server/repos/olamkvm.git"
   

   L'option -b garantit l'initialisation du référentiel distant à l'aide d'une branche appelée main.

6. Acceptez l'empreinte de la clé ECDSA en saisissant yes.

7. Ajoutez le nouvel enregistrement de connexion au référentiel distant.

   L'ajout de la connexion distante au référentiel local vous permet de l'utiliser comme raccourci nommé dans les commandes Git.

   git remote add origin git@$REMOTE:/git-server/repos/olamkvm.git
   

   Le chemin situé après le signe deux-points correspond à l'emplacement du répertoire du référentiel sur le serveur Git distant.

8. Vérifiez le nouvel enregistrement de connexion ajouté.

   git remote -v
   

   La sortie affiche l'enregistrement de connexion origin pointant vers l'emplacement du référentiel Git distant pour les commandes git fetch et git push.

9. Poussez les modifications apportées au référentiel local vers le référentiel distant.

   git push origin main
   

   L'utilisation de la source olamkvm dans un projet Oracle Linux Automation Manager est désormais possible.

Créer des informations d'identification Ansible Galaxy

Ces informations d'identification permettent à Oracle Linux Automation Manager d'extraire la collection OCI Ansible de l'Ansible Galaxy Hub public.

1. Ouvrez une nouvelle fenêtre de terminal et configurez un tunnel SSH vers l'instance olam-node.

   ssh -L 8444:localhost:443 oracle@<ip_address_of_instance>
   

2. Ouvrez un navigateur Web et saisissez l'URL.

   https://localhost:8444
   

   Remarque : approuvez l'avertissement de sécurité en fonction du navigateur utilisé. Pour le navigateur Chrome, cliquez sur le bouton Avancé, puis sur le lien Passer à localhost (non sécurisé).

3. Connectez-vous à Oracle Linux Automation Manager WebUI. Utilisez le nom utilisateur admin et le mot de passe admin créés lors du déploiement automatisé.

   

4. WebUI s'affiche après une connexion réussie.

   

5. Cliquez sur Informations d'identification sous la section Ressources dans le menu de navigation.

6. Cliquez sur le bouton Ajouter.

7. Saisissez ou sélectionnez les valeurs suivantes dans les champs spécifiques.

   Pour les champs avec une recherche ou une liste de valeurs, nous pouvons commencer à saisir la valeur demandée, puis la sélectionner.

   • Nom : My Ansible Galaxy
   • Organisation : Default
   • Type d'informations d'identification : Jeton d'API Ansible Galaxy/Automation Hub

   Oracle Linux Automation Manager utilise les informations d'identification Ansible Galaxy pour permettre le téléchargement des rôles et des collections à l'aide de la commande ansible-galaxy.

   • URL de Galaxy Server : https://galaxy.ansible.com

   

8. Vérifiez les entrées et cliquez sur le bouton Enregistrer.

9. Cliquez sur Organisations dans la section Accès du menu de navigation.

   L'affectation des informations d'identification Ansible Galaxy dans l'organisation permet de télécharger la collection Ansible d'infrastructure Oracle Linux à partir du projet git.

10. Cliquez sur l'organisation Par défaut, puis sur le bouton Modifier.

11. Sélectionnez l'option de recherche dans le champ Informations d'identification Galaxy.

12. Sélectionnez My Ansible Galaxy dans la boîte de dialogue instantanée Sélectionner les informations d'identification Galaxy et cliquez sur le bouton Sélectionner.

13. Vérifiez et cliquez sur le bouton Enregistrer.

    

Créer des informations d'identification de machine

Ces informations d'identification permettent à Oracle Linux Automation Manager de se connecter au système de virtualisation KVM via SSH.

1. Cliquez sur Informations d'identification sous Ressources dans le menu de navigation.

2. Cliquez sur le bouton Ajouter.

3. Saisissez ou sélectionnez les valeurs suivantes dans les champs spécifiques.

   Pour les champs avec une recherche ou une liste de valeurs, nous pouvons commencer à saisir la valeur demandée, puis la sélectionner.

   • Nom : My KVM Server
   • Organisation : Default
   • Type d'informations d'identification : ordinateur

   Oracle Linux Automation Manager utilise les informations d'identification de machine pour définir les informations requises lors de l'établissement d'une connexion SSH à un hôte.

   La page est actualisée, en demandant les Détails du type.

4. Entrez le nom utilisateur.

   • Nom utilisateur : oracle

   

5. Cliquez sur le bouton Parcourir pour la clé privée SSH.

   Une boîte de dialogue s'affiche et affiche la fenêtre Open File.

6. Cliquez avec le bouton droit de la souris dans le panneau central de la fenêtre Ouvrir un fichier et sélectionnez Afficher les fichiers masqués dans la boîte de dialogue contextuelle.

   

7. Cliquez n'importe où dans le panneau central pour fermer la boîte de dialogue.

8. Cliquez sur l'emplacement Home dans le menu de navigation situé à gauche de la fenêtre Open File.

9. Cliquez deux fois sur le dossier .ssh dans la liste, puis cliquez deux fois sur le fichier id_rsa.

   Cette action copie le contenu du fichier id_rsa dans le champ SSH Private Key.

10. Vérifiez les entrées, faites défiler la page vers le bas et cliquez sur le bouton Enregistrer.

Créer un inventaire

1. Cliquez sur Stocks dans le menu de navigation.

2. Cliquez sur le bouton Ajouter et sélectionnez Ajouter un inventaire dans la liste déroulante des valeurs.

3. Saisissez ou sélectionnez les valeurs suivantes dans les champs spécifiques.

   • Nom : KVM Servers
   • Groupes d'instances : controlplane

4. Vérifiez et cliquez sur le bouton Enregistrer.

   

Ajouter un groupe à un inventaire

Un groupe dans un inventaire est une classification d'hôtes ou d'autres groupes qui permettent de contrôler un ensemble d'hôtes pour une tâche donnée.

1. Cliquez sur l'onglet Groupes sur la page Détails des serveurs KVM.

   

2. Cliquez sur le bouton Ajouter.

3. Saisissez ou sélectionnez les valeurs suivantes dans les champs spécifiques.

   • Nom : kvm

4. Vérifiez et cliquez sur le bouton Enregistrer.

   

Ajout d'un hôte au groupe d'inventaire

1. Cliquez sur l'onglet Hôtes sur la page Détails du groupe de la machine virtuelle.

   

2. Cliquez sur le bouton Ajouter et sélectionnez Ajouter un nouvel hôte dans la liste déroulante des valeurs.

3. Saisissez ou sélectionnez les valeurs suivantes dans les champs spécifiques.

   • Nom : utilisez l'adresse IP publique de l'hôte du serveur kvm.

4. Vérifiez et cliquez sur le bouton Enregistrer.

   

Ping du groupe d'inventaire

Utilisez le module ping pour vérifier qu'Oracle Linux Automation peut se connecter à l'hôte du groupe d'inventaire.

1. Utilisez le chemin de navigation et cliquez sur Serveurs KVM.

2. Cliquez sur l'onglet Groupes.

3. Cochez la case en regard du groupe kvm et cliquez sur le bouton Run Command.

   La boîte de dialogue contextuelle Exécuter la commande s'affiche.

4. Sélectionnez le module ping et cliquez sur le bouton Next.

5. Sélectionnez l'environnement d'exécution OLAM EE (2.2) et cliquez sur le bouton Next.

6. Sélectionnez les informations d'identification de la machine My KVM Server et cliquez sur le bouton Next.

7. Vérifiez et cliquez sur le bouton Lancer.

   Un travail est lancé et affiche la sortie du module ping.

   

Ajouter des informations d'identification de contrôle des versions

1. Cliquez sur Informations d'identification dans le menu de navigation.

2. Cliquez sur le bouton Ajouter.

3. Saisissez ou sélectionnez les valeurs suivantes dans les champs spécifiques.

   • Nom : Git Server
   • Organisation : Default
   • Type d'informations d'identification : Contrôle source

   

   La page est actualisée, en demandant les Détails du type.

4. Entrez le nom utilisateur.

   • Nom utilisateur : git

5. Entrer la clé privée SCM

   Cliquez sur le bouton Parcourir et cliquez deux fois sur le fichier id_rsa. Cette action copie le contenu de la clé dans le champ Clé privée SCM.

   

6. Vérifiez et cliquez sur le bouton Enregistrer.

   

Créez un projet

1. Cliquez sur Projets dans le menu de navigation.

2. Cliquez sur le bouton Ajouter.

3. Saisissez ou sélectionnez les valeurs suivantes dans les champs spécifiques.

   • Nom : My Project
   • Environnement d'exécution : OLAM EE (2.2)
   • Type d'informations d'identification de contrôle source : Git

   

   La page est actualisée, en demandant les Détails du type.

4. Entrez l'URL distante du serveur git.

   • URL de contrôle source : git@<ip_address_of_instance>:/git-server/repos/olamkvm.git

5. Sélectionnez Serveur Git pour les informations d'identification de contrôle source.

6. Vérifiez et cliquez sur le bouton Enregistrer.

   

7. Vérifiez le statut de synchronisation du projet.

   Une fois le projet créé, son statut apparaît dans le récapitulatif Détails au début de la synchronisation. Le statut passe de En cours d'exécution à Succès si la configuration est correcte et que le serveur Git est accessible.

   

Création d'un modèle de tâche

1. Cliquez sur Modèles dans le menu de navigation.

2. Cliquez sur le bouton Ajouter et sélectionnez Ajouter un modèle de travail dans la liste déroulante des valeurs.

3. Entrez les valeurs obligatoires.

   • Nom : My Template
   • Type de job : Run.
   • Inventaire : serveurs KVM
   • Projet : Mon projet
   • Environnement d'exécution : OLAM EE (2.2)
   • Playbook : create_vm.yml
   • Informations d'identification : Mon serveur KVM

   

4. Vérifiez, faites défiler vers le bas et cliquez sur le bouton Enregistrer.

   

5. Lancez le modèle.

   Lancez un travail à partir de la page de synthèse du modèle en cliquant sur le bouton Lancer.

   

   En cas de réussite, la tâche s'ouvre et affiche la sortie du modèle. La sortie standard montre le playbook en cours d'exécution et affiche les résultats du playbook.

   

Vérifier la création de la machine virtuelle

1. Ouvrez un terminal et connectez-vous via ssh au noeud de serveur kvm.

   ssh oracle@<ip_address_of_instance>
   

2. Obtenez la liste des machines virtuelles en cours d'exécution.

   sudo virsh list
   

   Exemple de sortie :

   [oracle@kvm-server ~]$ sudo virsh list
    Id   Name      State
   -------------------------
    1    ol9-dev   running
   

3. Obtenez l'adresse IP de la machine virtuelle ol9-dev.

   sudo virsh net-dhcp-leases default
   

   Exemple de sortie :

   [oracle@kvm-server ~]$ sudo virsh net-dhcp-leases default
    Expiry Time           MAC address         Protocol   IP address           Hostname   Client ID or DUID
   ------------------------------------------------------------------------------------------------------------
    2023-04-06 18:59:33   52:54:00:6e:93:07   ipv4       192.168.122.167/24   ol9-dev    01:52:54:00:6e:93:07
   

4. Connectez-vous à la machine virtuelle.

   ssh opc@$(sudo virsh -q domifaddr ol9-dev | awk '{print substr($4, 1, length($4)-3)}')
   

   -q enlève l'en-tête de la sortie des commandes virsh. awk extrait la quatrième colonne de la commande virsh domifaddr, et substr() supprime les trois derniers caractères.

5. Déconnectez-vous de la machine virtuelle.

   exit
   

(Facultatif) Création d'une autre machine virtuelle

Le livre de jeux permet la création d'une autre machine virtuelle en modifiant la variable vm_name.

1. Accédez à la fenêtre du navigateur contenant Oracle Linux Automation Manager WebUI et connectez-vous si nécessaire.

2. Cliquez sur Modèles dans le menu de navigation.

3. Cliquez sur l'icône Modifier le modèle pour Mon modèle.

   

4. Ajoutez la variable vm_name avec la valeur ol9-new à la section Variables.

   

5. Faites défiler l'écran vers le bas et cliquez sur le bouton Enregistrer.

6. Lancez le modèle.

7. Répétez les étapes de vérification de la machine virtuelle et connectez-vous à la machine virtuelle nouvellement créée.

Etapes suivantes

La sortie de travail réussie d'Oracle Linux Automation Manager et la possibilité d'utiliser SSH dans la machine virtuelle confirment que tout fonctionne. Testez davantage la collection community.libvirt et créez des machines virtuelles dans Oracle Linux KVM pour développer votre infrastructure. Essayez ensuite de provisionner ces machines virtuelles avec des livres de jeux supplémentaires. Consultez notre formation supplémentaire sur le poste de formation Oracle Linux.

Liens connexes

• Documentation d'Oracle Linux Automation Manager
• Guide d'installation d'Oracle Linux Automation Manager
• Formation Oracle Linux Automation Manager
• Création de machines virtuelles avec KVM sur Oracle Linux
• Centre de formation Oracle Linux

Ressources de formation supplémentaires

Explorez d'autres ateliers sur docs.oracle.com/learn ou accédez à d'autres contenus de formation gratuits sur le canal Oracle Learning YouTube. De plus, visitez le site education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir la documentation produit, consultez le site Oracle Help Center.

---

Informations relatives au titre et au copyright

Manage KVM Virtual Machines using Oracle Linux Automation Manager

G32915-01

Copyright ©2023, Oracle and/or its affiliates.