Note :

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

Présentation

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

Objectifs

Dans ce tutoriel, vous apprendrez à :

Préalables

Remarque : Pour plus de détails sur l'installation d'Oracle Linux Automation Manager ou de KVM, consultez les liens à la fin de cet exercice.

Déployer Oracle Linux Automation Manager

Note : Si vous exécutez votre propre location, lisez les préalables du projet linux-virt-labs GitHub README.md et remplissez les conditions requises avant de déployer l'environnement de laboratoire.

  1. Ouvrez un terminal sur le Luna Desktop.

  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 de l'exercice.

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

    L'environnement de laboratoire gratuit nécessite la variable supplémentaire ansible_python_interpreter car elle installe l'ensemble RPM pour la trousse SDK Oracle Cloud Infrastructure pour Python. L'emplacement de l'installation de ce package est sous les modules python3.6.

    La forme de déploiement par défaut utilise le processeur AMD et Oracle Linux 8. Pour utiliser une unité centrale 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 livre de jeu s'exécute avec succès et atteignez la tâche Mettre en pause. L'installation d'Oracle Linux Automation Manager est terminée à cette étape du livre de jeu et les instances sont prêtes. Prenez note de la lecture précédente, qui imprime les adresses IP publiques et privées des noeuds qu'il déploie.

Créer un livre de jeu

  1. Ouvrez une nouvelle fenêtre de terminal.

  2. Définissez une variable sur l'instance git-server distante.

    export REMOTE=<ip_address_of_instance>

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

    mkdir ~/olamkvm

  4. Créez un fichier d'exigences.

    Oracle Linux Automation Engine utilise le fichier des exigences pour extraire les collections ou les rôles requis dans le projet au moment 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 livre de jeu importe ce fichier au moment de l'exécution.

    1. Créez un répertoire pour stocker 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 métadonnées et les fichiers de données d'utilisateur pour provisionner la configuration de machine virtuelle au moyen de cloud-init.

    1. Créez un répertoire pour stocker 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éez un playbook.

    Ce livre de jeu interroge le serveur KVM pour les machines virtuelles existantes, puis déploie une nouvelle image Oracle Linux Cloud.

    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 source

  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 Git pour la première fois.

    1. Définissez le nom de branche 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 e-mail et votre nom lorsque vous travaillez sur vos projets, car ces informations sont imbriquées dans chaque validation.

      git config --global user.email johndoe@example.com
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 retourne 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, et 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 numérique de la clé ECDSA en entrant 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 après le deux-points est l'emplacement du répertoire du référentiel sur le serveur Git distant.

  8. Vérifiez l'enregistrement de connexion nouvellement ajouté.

    git remote -v

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

  9. Pousser 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 données d'identification Ansible Galaxy

Ces données d'identification permettent à Oracle Linux Automation Manager d'extraire la collection Ansible pour OCI du centre Ansible Galaxy 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 entrez l'URL.

    https://localhost:8444

    Note : 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 d'utilisateur admin et le mot de passe admin créés lors du déploiement automatisé.

    olam2 - Connexion

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

    olam2-webui

  5. Cliquez sur Données d'identification dans la section Ressources du menu de navigation.

  6. Cliquez sur le bouton Ajouter.

  7. Entrez 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 à taper la valeur demandée, puis la sélectionner.

    • Nom : My Ansible Galaxy
    • Organisation : Default
    • Type de données d'identification : Jeton d'API Ansible Galaxy/Automation Hub

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

    • URL du serveur Galaxy : https://galaxy.ansible.com

    olam2-crédits de galaxie

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

  9. Cliquez sur Organizations (Organisations) dans la section Access (Accès) du menu de navigation.

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

  10. Cliquez sur l'organisation Par défaut et cliquez sur le bouton Modifier.

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

  12. Sélectionnez My Ansible Galaxy dans la boîte de dialogue contextuelle Select Galaxy Credentials (Sélectionner les données d'identification Galaxy) et cliquez sur le bouton Select (Sélectionner).

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

    olam2-ansible-galaxy-org

Créer des données d'identification de machine

Ces données d'identification permettent à Oracle Linux Automation Manager de se connecter au système de virtualisation KVM au moyen de SSH.

  1. Cliquez sur Données d'identification sous Ressources dans le menu de navigation.

  2. Cliquez sur le bouton Ajouter.

  3. Entrez 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 à taper la valeur demandée, puis la sélectionner.

    • Nom : My KVM Server
    • Organisation : Default
    • Type de données d'identification : Machine

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

    La page s'actualise et demande les détails du type.

  4. Entrez le nom d'utilisateur.

    • Nom d'utilisateur : oracle

    olam2-crédits-machines

  5. Cliquez sur le bouton Parcourir de 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 Open File et sélectionnez Show Hidden Files (Afficher les fichiers masqués) dans la boîte de dialogue contextuelle.

    olam2-open-file

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

  8. Cliquez sur l'emplacement Accueil dans le menu de navigation à gauche de la fenêtre Ouvrir un fichier.

  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 Clé privée SSH.

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

Créer un inventaire

  1. Cliquez sur Inventaires 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. Entrez ou sélectionnez les valeurs suivantes dans les champs spécifiques.

    • Nom : KVM Servers
    • Groupes d'instances : plan de contrôle

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

    olam2-inv

Ajouter un groupe à un stock

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 de la page Détails des serveurs KVM.

    olam2-inv-kvm-details

  2. Cliquez sur le bouton Ajouter.

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

    • Nom : kvm

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

    olam2-kvm-group-details

Ajouter un hôte au groupe d'inventaire

  1. Cliquez sur l'onglet Hôtes dans la page Détails du groupe kvm.

    olam2-kvm-group-details

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

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

    • Nom : Utilisez l'adresse IP publique de l'hôte kvm-server.

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

    olam2-grp-new-host

Effectuer une commande ping sur le groupe de stocks

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

  1. Utilisez les chemins de navigation et cliquez sur Serveurs KVM.

  2. Cliquez sur l'onglet Groupes.

  3. Cochez la case à côté du groupe kvm et cliquez sur le bouton Exécuter la commande.

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

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

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

  6. Sélectionnez les données d'identification de machine My KVM Server et cliquez sur le bouton Suivant.

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

    Une tâche est lancée et affiche la sortie du module ping.

    olam2-kvm-grp-ping

Ajouter des données d'identification de contrôle source

  1. Cliquez sur Données d'identification dans le menu de navigation.

  2. Cliquez sur le bouton Ajouter.

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

    • Nom : Git Server
    • Organisation : Default
    • Type de données d'identification : Contrôle source

    olam2-git-cred1

    La page s'actualise et demande les détails du type.

  4. Entrez le nom d'utilisateur.

    • Nom d'utilisateur : git

  5. Entrez 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.

    olam2-git-cred2

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

    olam2-git-cred3

Créer un projet

  1. Cliquez sur Projets dans le menu de navigation.

  2. Cliquez sur le bouton Ajouter.

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

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

    olam2-proj1

    La page s'actualise et demande 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 Git Server pour les données d'identification de contrôle source.

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

    olam2-proj2

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

    Après la création du projet, son statut sera affiché dans le sommaire Détails au début de la synchronisation. Le statut passe de En cours d'exécution à Réussite si la configuration est correcte et que le serveur Git est accessible.

    olam2-proj-sync

Créer 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 tâche dans la liste déroulante des valeurs.

  3. Entrez les valeurs requises.

    • Nom : My Template
    • Type de tâche : Exécuter
    • Stock : Serveurs KVM
    • Projet : Mon projet
    • Environnement d'exécution : OLAM EE (2.2)
    • Livre multimédia : create_vm.yml
    • Données d'identification : Mon serveur KVM

    olam2-temp1

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

    olam2-temp2

  5. Lancez le modèle.

    Lancez une tâche à partir de la page sommaire du modèle en cliquant sur le bouton Lancer.

    olam2-temp-lancement

    En cas de succès, le travail est lancé et affiche la sortie du modèle. La sortie standard affiche le playbook en cours d'exécution et produit les résultats du playbook.

    olam2-temp-output

Vérifier la création de machine virtuelle

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

    ssh oracle@<ip_address_of_instance>

  2. Obtenez une 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 supprime 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éer une autre machine virtuelle

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

  1. Passez à 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.

    olam2-temp-edit

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

    olam2-temp-vars

  5. Faites défiler l'affichage 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.

Étapes suivantes

La sortie de la tâche Oracle Linux Automation Manager réussie et la possibilité de SSH dans la machine virtuelle confirment que tout fonctionne. Poursuivez votre expérience avec la collection community.libvirt et créez des machines virtuelles dans Oracle Linux KVM pour étendre votre infrastructure. Essayez ensuite de provisionner ces machines virtuelles avec des livres de jeu supplémentaires. Consultez notre formation supplémentaire au poste de formation Oracle Linux.

Autres ressources d'apprentissage

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

Pour obtenir la documentation sur le produit, visitez Oracle Help Center.