Remarques :

Utiliser un inventaire dynamique OCI avec Oracle Linux Automation Engine

Introduction

Oracle Linux Automation Engine, un logiciel open source pour le provisionnement et la gestion de la configuration, utilise un fichier d'inventaire pour fonctionner sur les noeuds ou les hôtes gérés de votre infrastructure. Ce fichier d'inventaire contient la liste des serveurs, leurs adresses IP et d'autres informations de connexion facultatives.

Un fichier d'inventaire statique fonctionne bien si votre infrastructure ne change guère.

Cependant, votre infrastructure est probablement en constante évolution lors de l'utilisation du cloud. Par conséquent, il serait avantageux que votre inventaire soit mis à jour dynamiquement à mesure que des hôtes sont ajoutés et supprimés.

Objectifs

Dans ce tutoriel, vous allez apprendre à :

Prérequis

Déployer Oracle Linux Automation Engine

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: "ol-control-node"
    type: "control"
  2:
    instance_name: "ol-host"
    type: "remote"
olam_type: none
EOF

  6. Créez un fichier d'inventaire.

    cat << EOF | tee hosts > /dev/null
localhost ansible_connection=local ansible_connection=local ansible_python_interpreter=/usr/bin/python3.6
EOF

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

    ansible-playbook create_instance.yml -i hosts -e "@instances.yml"

    L'environnement d'atelier gratuit requiert la variable supplémentaire ansible_python_interpreter pour localhost 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 Python par défaut du système en fonction de votre version d'Oracle Linux. L'utilisation d'une variable d'inventaire évite d'avoir un impact sur les lectures en cours d'exécution sur des hôtes autres que localhost.

    La forme de déploiement par défaut utilise l'UC AMD. Vous pouvez modifier la forme des instances en transmettant une nouvelle définition de variable de forme sur la ligne de commande.

    Par exemple : -e instance_shape="VM.Standard3.Flex"

    De même, la version par défaut de l'image Oracle Linux utilise la variable os_version définie dans le fichier `default_vars.yml. Vous pouvez modifier cette valeur en transmettant la version majeure d'Oracle Linux sur la ligne de commande.

    Par exemple : -e os_version="9"

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

Configurer le noeud de contrôle d'Oracle Linux Automation Engine

Le noeud de contrôle est le système d'exécution des livres de jeux Oracle Linux Automation Engine. L'exécution de playbooks nécessite l'installation du package Oracle Linux Automation Engine.

  1. Définissez une variable égale à l'adresse IP du noeud de contrôle.

    export CONTROL="<ip_address_of_ol-control-node>"

  2. Ouvrez un terminal et copiez la paire de clés SSH vers le noeud de contrôle.

    scp -rp ~/.ssh/id_rsa* oracle@$CONTROL:~/.ssh/

  3. Définissez les droits d'accès sur la clé privée SSH.

    ssh oracle@$CONTROL "chmod 600 ~/.ssh/id_rsa"

  4. Connectez-vous au système ol-control-node via SSH.

    ssh oracle@$CONTROL

  5. Installez le package et les dépendances d'Oracle Linux Automation Engine.

    sudo dnf install -y ansible-core

    Le package ansible-core est disponible dans le référentiel AppStream.

  6. Testez l'installation du package.

    ansible --version

    Consultez la sortie et recherchez la version par défaut de Python Oracle Linux Automation Manager. C'est l'environnement dans lequel nous devons installer le kit SDK Oracle Cloud Infrastructure (OCI) pour Python.

    Remarque : si la sortie indique ERREUR : Ansible exige que l'encodage de l'environnement linguistique soit UTF-8 ; Aucun détecté., cela indique un paramètre d'environnement linguistique incorrect pour ansible. Corrigez le problème en définissant les deux variables d'environnement suivantes :

    export LC_ALL="en_US.UTF-8"
export LC_CTYPE="en_US.UTF-8"

Installation d'Oracle Cloud Infrastructure SDK pour Python

Le module d'extension d'inventaire dynamique OCI nécessite un kit SDK OCI opérationnel pour la configuration Python sur le noeud de contrôle. Nous pouvons installer le kit SDK OCI à l'aide du RPM ou du PIP Oracle Linux, le programme d'installation de package pour Python.

  1. Installez le kit SDK OCI pour Python à l'aide de PIP.

    1. Installez les packages et les dépendances pour PIP.

      Oracle Linux 8 ::

      sudo dnf install -y python3.12-pip python3.12-setuptools

      Oracle Linux 9 ::

      sudo dnf install -y python3.9-pip python3.9-setuptools

    2. Installation des packages Python

      Oracle Linux 8 ::

      /usr/bin/python3.12 -m pip install oci

      Oracle Linux 9 ::

      /usr/bin/python3.9 -m pip install oci

      Ajoutez l'option --proxy si vous êtes derrière un proxy. Les détails sont disponibles dans l'aide en exécutant la commande python3.12 -m pip help install.

  2. Testez le kit SDK OCI pour l'installation Python en imprimant sa version.

    Oracle Linux 8 ::

    python3.12 -c "import oci;print(oci.__version__)"

    Oracle Linux 9 ::

    python3.9 -c "import oci;print(oci.__version__)"

  3. Créez le répertoire de configuration par défaut du kit SDK OCI.

    mkdir -p ~/.oci

  4. Créer le fichier de configuration par défaut du kit SDK

    L'atelier gratuit fournit une configuration SDK pré-générée, que nous pouvons copier vers le système ol-control-node à l'aide de scp.

    1. Ouvrez un nouveau terminal à partir de l'environnement de bureau.

    2. Copiez tous les fichiers de configuration du kit SDK vers le système ol-control-node.

      scp ~/.oci/* oracle@<ip_address_of_instance>:~/.oci/.

      exit

    Si vous suivez ce tutoriel en dehors de l'environnement d'atelier gratuit, reportez-vous aux instructions fournies dans les sections Fichier de configuration du kit SDK et de l'interface de ligne de commande et Clés et OCID requis de la documentation OCI pour générer le fichier de configuration OCI.

  5. Passez à la fenêtre de terminal connectée au système ol-control-node.

  6. Mettez à jour l'emplacement de key_file dans le fichier de configuration du kit SDK.

    Lors de la copie du fichier de configuration du kit SDK à partir de l'environnement de bureau, nous devons modifier la partie du répertoire personnel de l'utilisateur dans key_file pour nous assurer qu'il correspond au nom utilisateur du système de contrôle.

    sed -i 's/luna.user/oracle/g' ~/.oci/config

  7. Créez un script Python de test pour vérifier que le kit SDK fonctionne.

    cat << EOF | tee test.py > /dev/null
import oci
object_storage_client = oci.object_storage.ObjectStorageClient(oci.config.from_file())
result = object_storage_client.get_namespace()
print("Current object storage namespace: {}".format(result.data))
EOF

    Le script test.py affiche l'espace de noms Object Storage pour la location et le compartiment OCI configurés.

  8. Exécutez le script

    Oracle Linux 8 ::

    python3.12 test.py

    Oracle Linux 9 ::

    python3.9 test.py

    Le script de test a réussi à imprimer l'espace de noms unique de la location configurée.

Installation de la collection Ansible pour Oracle Cloud Infrastructure

La collection OCI Ansible contient un ensemble de modules qui automatisent le provisionnement et la configuration de l'infrastructure cloud, orchestrent des processus opérationnels complexes et déploient et mettent à jour des ressources logicielles.

  1. Créez un répertoire de projet.

    mkdir ~/myproject

  2. Créez un fichier de conditions.

    cat << EOF | tee ~/myproject/requirements.yml > /dev/null
---
collections:
  - name: oracle.oci
EOF

  3. Installez la collection OCI Ansible.

    ansible-galaxy collection install -r ~/myproject/requirements.yml

    Si vous avez installé une version précédente, obtenez la dernière version en exécutant la commande avec l'option --force.

    ansible-galaxy collection install --force oracle.oci

Utilisation de l'inventaire dynamique OCI

Oracle inclut son module d'extension d'inventaire dynamique dans la collection OCI Ansible.

  1. Configurez le module d'extension d'inventaire en créant une source de configuration YAML.

    Le nom du fichier source doit être <filename>.oci.yml ou <filename>.oci.yaml. Où <filename> est un identificateur utile défini par l'utilisateur.

    cat << EOF | tee ~/myproject/myproject.oci.yml > /dev/null
---
plugin: oracle.oci.oci

# Optional fields to specify oci connection config:
config_file: ~/.oci/config
config_profile: DEFAULT
EOF

  2. Testez le module d'extension d'inventaire en créant un graphique d'inventaire.

    ansible-inventory -i ~/myproject/myproject.oci.yml --graph

    La sortie affiche une série d'avertissements et d'erreurs. Qu'est-ce qui s'est mal passé ?

    L'erreur survient car le module d'extension nécessite de connaître l'OCID du compartiment. Si vous fournissez l'OCID de location plutôt que l'OCID de compartiment et que vous disposez des droits d'accès appropriés, le module d'extension génère un inventaire pour l'ensemble de la location.

    Etant donné que le module d'extension ne peut pas lire les informations d'OCID de compartiment directement à partir du fichier de configuration du kit SDK, ajoutez-les au fichier source de configuration du module d'extension.

  3. Obtenez l'OCID de compartiment à partir du fichier de configuration du kit SDK et affectez-le à la variable comp_ocid.

    comp_ocid=$(grep -i compartment ~/.oci/config | sed -e 's/compartment-id=//g')

  4. Ajoutez un paramètre de compartiment au fichier source du module d'extension.

    cat << EOF | tee -a ~/myproject/myproject.oci.yml > /dev/null

compartments:
  - compartment_ocid: "$comp_ocid"
    fetch_compute_hosts: true
EOF

    Si vous définissez fetch_compute_hosts sur true, les informations de collecte d'inventaire sont collectées uniquement sur les hôtes de calcul et les autres types d'instance déployés dans le compartiment sont ignorés.

  5. Réexécutez le test.

    ansible-inventory -i ~/myproject/myproject.oci.yml --graph

    Notre exemple montre les instances de calcul disponibles dans le compartiment sous la forme d'une liste des groupes d'inventaire désignés par le caractère @ et affiche l'adresse IP publique de l'instance.

    Et si nous voulions l'adresse IP privée ?

    L'obtention de l'adresse IP privée est nécessaire en fonction de l'emplacement physique du noeud de contrôleur ou de la topologie réseau configurée dans l'infrastructure cloud. Une autre raison d'obtenir l'adresse IP privée est que les instances de calcul demandées n'ont qu'une adresse IP privée.

  6. Modifiez le paramètre de format du nom d'hôte du module d'extension en mettant à jour le fichier source de configuration du module d'extension.

    cat << EOF | tee -a ~/myproject/myproject.oci.yml > /dev/null

hostname_format_preferences:
  - "private_ip"
  - "public_ip"
EOF

    L'exemple de format ci-dessus donne la priorité à l'adresse IP privée d'un système sur son adresse IP publique. Pour plus d'informations sur cette configuration, reportez-vous à la section Hostname Format Preferences dans la documentation.

  7. Testez à nouveau le plugin.

    ansible-inventory -i ~/myproject/myproject.oci.yml --graph

    La sortie affiche désormais l'adresse IP privée.

Exécuter un Playbook

Avec la configuration de l'inventaire dynamique et configurée, nous pouvons l'utiliser pour exécuter un livre de jeux simple. Veillez à activer l'accès SSH entre les noeuds de contrôle et les noeuds distants.

  1. Créez un playbook qui envoie un ping à l'hôte.

    cat << EOF | tee ~/myproject/ping.yml > /dev/null
---
- hosts: all,!$(hostname -i)
  tasks:
  - name: Ansible ping test
    ansible.builtin.ping:
EOF

    Oracle Linux Automation Engine attend une liste d'hôtes ou de groupes séparés par des virgules après l'entrée - hosts:, et ! indique qu'il doit exclure ces entrées. L'entrée all envoie une commande ping à chaque hôte affiché dans l'inventaire en tant que @all au sein du groupe de niveau supérieur. Vous pouvez modifier ce livre de jeux pour utiliser un groupe différent de celui de la sortie de graphique en enlevant le caractère @ de son nom et en saisissant ce nom dans l'entrée - hosts:.

  2. Exécutez le playbook.

    ansible-playbook -u opc -i ~/myproject/myproject.oci.yml ~/myproject/ping.yml

    Acceptez l'empreinte de clé ECDSA lorsque vous y êtes invité.

    L'option -i définit le fichier d'inventaire dynamique utilisé.

    L'option -u définit l'utilisateur SSH distant lors de la tentative de connexion.

Etapes suivantes

L'exécution du livre de jeux avec le statut OK confirme qu'Oracle Linux Automation Engine utilise avec succès l'inventaire dynamique OCI pour communiquer avec l'instance distante qu'il détecte dans le compartiment. Continuez à apprendre et utilisez cette fonctionnalité pour vous aider à gérer votre parc d'instances OCI et à effectuer des tâches d'administration de routine sur 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.