Note :

Ce tutoriel est disponible dans un environnement de laboratoire gratuit fourni par Oracle.
Il utilise des exemples de valeurs pour les données d'identification, la location et les compartiments d'Oracle Cloud Infrastructure. À la fin de votre laboratoire, remplacez ces valeurs par celles qui sont propres à votre environnement en nuage.

Utiliser un inventaire dynamique OCI avec Oracle Linux Automation Engine

Présentation

Oracle Linux Automation Engine, un logiciel à code source libre pour le provisionnement et la gestion de la configuration, utilise un fichier d'inventaire pour fonctionner sur des noeuds ou des hôtes gérés dans votre infrastructure. Ce fichier d'inventaire contient une liste de 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 nuage. Par conséquent, il serait avantageux d'avoir votre inventaire mis à jour dynamiquement à mesure que les hôtes sont ajoutés et supprimés.

Objectifs

Dans ce tutoriel, vous apprendrez à :

Configurer Oracle Linux Automation Engine
Créer un inventaire dynamique OCI
Utiliser l'inventaire dynamique OCI avec un livre de jeu

Préalables

Un minimum de deux systèmes Oracle Linux avec la configuration suivante :
- un utilisateur non racine avec les autorisations sudo
- paire de clés SSH pour l'utilisateur non racine
- la possibilité de SSH d'un hôte à un autre à l'aide d'une connexion SSH sans mot de passe

Déployer Oracle Linux Automation Engine

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.

Ouvrez un terminal sur le Luna Desktop.

Clonez le projet linux-virt-labs GitHub.

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

Accédez au répertoire de travail.
```
cd linux-virt-labs/olam
```

Installez les collections requises.

ansible-galaxy collection install -r requirements.yml

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

Sert à créer 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

Déployez l'environnement de l'exercice.
```
ansible-playbook create_instance.yml -i hosts -e "@instances.yml"
```
L'environnement de laboratoire gratuit nécessite la variable supplémentaire ansible_python_interpreter pour localhost, car il installe l'ensemble RPM pour la trousse SDK Oracle Cloud Infrastructure pour Python. L'emplacement d'installation de cet ensemble est 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 une incidence sur les lectures exécutées sur des hôtes autres que localhost.

La forme de déploiement par défaut utilise l'unité centrale 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 principale d'Oracle Linux sur la ligne de commande.

Par exemple : -e os_version="9"

Important : Attendez que le livre de jeu s'exécute avec succès et atteignez la tâche Mettre en pause. À ce stade du livre de jeu, l'installation d'Oracle Linux est terminée et les instances sont prêtes. Notez la lecture précédente, qui imprime les adresses IP publiques et privées des noeuds qu'il déploie.

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

Le noeud de contrôle est le système permettant d'exécuter les livres de jeu Oracle Linux Automation Engine. L'exécution de livres de jeu nécessite l'installation de l'ensemble Oracle Linux Automation Engine.

Définissez une variable égale à l'adresse IP du noeud de contrôle.
```
export CONTROL="<ip_address_of_ol-control-node>"
```
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/
```
Définissez les autorisations sur la clé privée SSH.
```
ssh oracle@$CONTROL "chmod 600 ~/.ssh/id_rsa"
```
Connectez-vous au système ol-control-node via SSH.
```
ssh oracle@$CONTROL
```
Installez l'ensemble Oracle Linux Automation Engine et les dépendances.
```
sudo dnf install -y ansible-core
```
L'ensemble ansible-core est disponible dans le référentiel AppStream.
Testez l'installation du package.
```
ansible --version
```
Vérifiez la sortie et recherchez la version par défaut de Python Oracle Linux Automation Manager. C'est l'environnement dans lequel nous devons installer la trousse SDK Oracle Cloud Infrastructure (OCI) pour Python.
Note : Si la sortie affiche ERROR : Ansible exige que l'encodage des paramètres régionaux soit UTF-8; Aucun détecté., cela indique un paramètre de paramètres régionaux incorrect pour ansible. Corrigez le problème en définissant ces deux variables d'environnement :
```
export LC_ALL="en_US.UTF-8"
export LC_CTYPE="en_US.UTF-8"
```

Installer la trousse SDK Oracle Cloud Infrastructure pour Python

Le plugiciel d'inventaire dynamique OCI nécessite une configuration de trousse SDK OCI pour Python sur le noeud de contrôle. Nous pouvons installer la trousse SDK OCI à l'aide du RPM ou de PIP d'Oracle Linux, le programme d'installation de l'ensemble pour Python.

Installez la trousse SDK OCI pour Python à l'aide de PIP.
1. Installez les packages et 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. Installer les ensembles 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 mandataire. Les détails sont disponibles dans l'aide en exécutant la commande python3.12 -m pip help install.
Tester l'installation de la trousse SDK OCI pour 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__)"
```
Créez le répertoire de configuration par défaut de la trousse SDK pour OCI.
```
mkdir -p ~/.oci
```
Créer le fichier de configuration par défaut de la trousse SDK

Le laboratoire gratuit fournit une configuration de trousse SDK pré-générée, que nous pouvons copier dans 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 de la trousse SDK dans 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 de laboratoire gratuit, consultez les instructions fournies dans les sections Fichier de configuration des trousses SDK et de l'interface de ligne de commande et Clés et OCID requis de la documentation OCI pour générer votre fichier de configuration OCI.
Passez à la fenêtre de terminal connectée au système ol-control-node.
Mettez à jour l'emplacement de key_file dans le fichier de configuration de la trousse SDK.

Lors de la copie du fichier de configuration de la trousse SDK à partir de l'environnement de bureau, nous devons modifier la partie du répertoire de base de l'utilisateur key_file pour nous assurer qu'il correspond au nom d'utilisateur du système de contrôle.
```
sed -i 's/luna.user/oracle/g' ~/.oci/config
```

Créez un script Python de test pour vérifier que la trousse 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 du stockage d'objets pour l'emplacement et le compartiment OCI configurés.

Exécutez le script

Oracle Linux 8 :
```
python3.12 test.py
```
Oracle Linux 9 :
```
python3.9 test.py
```
Le script de test imprime avec succès l'espace de noms unique de la location configurée.

Installer la collection Ansible pour Oracle Cloud Infrastructure

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

Créez un répertoire de projet.
```
mkdir ~/myproject
```

Créez un fichier d'exigences.

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

Installez la collection Ansible pour OCI.
```
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 plugiciel d'inventaire dynamique dans la collection Ansible pour OCI.

Configurez le plugiciel 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
```
Testez le plugiciel 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 se produit car le plugiciel doit connaître l'OCID du compartiment. Si vous fournissez l'OCID de la location plutôt que l'OCID du compartiment et que vous disposez des autorisations appropriées, le plugiciel générera un inventaire pour l'ensemble de la location.

Comme le plugiciel ne peut pas lire les informations sur l'OCID du compartiment directement à partir du fichier de configuration de la trousse SDK, ajoutez-le au fichier source de configuration du plugiciel.
Obtenez l'OCID du compartiment dans le fichier de configuration de la trousse SDK et affectez-le à la variable comp_ocid.
```
comp_ocid=$(grep -i compartment ~/.oci/config | sed -e 's/compartment-id=//g')
```
Ajoutez un paramètre de compartiment au fichier source du plugiciel.
```
cat << EOF | tee -a ~/myproject/myproject.oci.yml > /dev/null

compartments:
  - compartment_ocid: "$comp_ocid"
    fetch_compute_hosts: true
EOF
```
Le réglage de fetch_compute_hosts à true entraîne la collecte des informations d'inventaire uniquement sur les hôtes de calcul et l'ignorance des autres types d'instance déployés dans le compartiment.
Réexécutez le test.
```
ansible-inventory -i ~/myproject/myproject.oci.yml --graph
```
Notre exemple présente les instances de calcul disponibles dans le compartiment sous forme de 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 de réseau configurée dans l'infrastructure en nuage. Une autre raison d'attraper l'adresse IP privée est lorsque les instances de calcul demandées n'ont qu'une adresse IP privée.
Modifiez le paramètre de format du nom d'hôte du plugiciel en mettant à jour le fichier source de configuration du plugiciel.
```
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 par rapport à son adresse IP publique. Pour plus de détails sur cette configuration, voir Préférences de format du nom d'hôte dans la documentation.
Testez à nouveau le plugiciel.
```
ansible-inventory -i ~/myproject/myproject.oci.yml --graph
```
La sortie affiche maintenant l'adresse IP privée.

Exécuter un livre de jeux

Avec la configuration et la configuration de l'inventaire dynamique, nous pouvons l'utiliser pour exécuter un livre de jeu simple. Assurez-vous d'activer l'accès SSH entre vos noeuds de contrôle et tous les noeuds distants.

Créez un livre de jeu qui appelle 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 dans le groupe de niveau supérieur. Vous pouvez modifier ce livre de jeu pour utiliser un groupe différent de la sortie du graphique en supprimant le caractère @ de son nom et en entrant ce nom dans l'entrée - hosts:.
Exécutez le playbook.
```
ansible-playbook -u opc -i ~/myproject/myproject.oci.yml ~/myproject/ping.yml
```
Lorsque vous y êtes invité, acceptez l'empreinte numérique de la cléECDSA.

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

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

Étapes suivantes

Le fait de terminer l'exécution du livre de jeu avec un statut OK confirme qu'Oracle Linux Automation Engine utilise avec succès l'inventaire dynamique OCI pour communiquer avec l'instance distante détectée dans le compartiment. Poursuivez l'apprentissage et utilisez cette fonction pour gérer votre parc d'instances OCI et effectuer des tâches d'administration de routine sur 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.

Informations sur le titre et les droits d'auteur

Use an OCI Dynamic Inventory with Oracle Linux Automation Engine

G33073-02