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.

Exécution de tâches Oracle Linux avec Oracle Linux Automation Engine

Introduction

Oracle Linux Automation Engine permet aux administrateurs d'automatiser la configuration initiale d'Oracle Linux et d'exécuter d'autres tâches d'administration à l'aide d'un outil de gestion de configuration Infrastructure-as-Code (IaC) via une série de guides et de tâches.

Objectifs

Dans ce tutoriel, vous allez apprendre à :

Écrivez des livres de jeux qui :
- Création d'un utilisateur
- Il ajoute l'utilisateur au groupe sudo.
- Copie une clé publique SSH locale dans le fichier authorized_keys de l'utilisateur.
- Ajoute un référentiel DNF et installe un package
- Manipuler des fichiers

Prérequis

Au moins deux systèmes Oracle Linux avec la configuration suivante :
- un utilisateur non root avec des autorisations sudo
- Paire de clés SSH pour l'utilisateur non root
- la possibilité d'utiliser SSH d'un hôte à un autre à l'aide d'une connexion SSH sans mot de passe

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.

Ouvrez un terminal sur le bureau Luna.

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"
use_olae_only: true
EOF

Déployez l'environnement d'exercice.
```
ansible-playbook create_instance.yml -e localhost_python_interpreter="/usr/bin/python3.6" -e "@instances.yml"
```
L'environnement d'exercice gratuit nécessite la variable supplémentaire local_python_interpreter, qui définit ansible_python_interpreter pour les lectures exécutées sur localhost. Cette variable est nécessaire car l'environnement installe le package RPM pour le kit SDK Oracle Cloud Infrastructure pour Python, situé 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. 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 imprime les adresses IP publiques et privées des noeuds qu'elle déploie, ainsi que toute autre information de déploiement nécessaire lors de l'exécution de l'exercice.

Ecrire le Playbook de configuration initiale

De nombreux livres de jeux exploitent des variables et des fichiers variables contenant des paires clé-valeur, ce qui permet aux tâches réelles du livre de jeux d'être dynamiques pendant que le code reste statique. Un livre de jeux inclut les variables lors de l'exécution, où ses valeurs deviennent partie intégrante des jeux lors de l'exécution de tâches.

Oracle Linux Automation Engine permet de définir ces variables à plusieurs emplacements, chacun ayant un ordre de priorité. Les variables de niveau Playbook sont définies dans le playbook à l'aide de la directive vars ou vars_files. La directive vars spécifie les variables dans le cadre de la lecture, tandis que la directive vars_files inclut un fichier externe contenant les variables. Les développeurs peuvent créer ces variables de manière dynamique ou statique à partir d'une autre lecture, comme nous le ferons dans cet exemple, qui définit la configuration du système avant d'exécuter le manuel.

Ouvrez un nouveau terminal et connectez-vous via SSH au système ol-control-node.
```
ssh oracle@<ip_address_of_instance>
```
Vérifiez que la commande Oracle Linux Automation Engine est disponible.
```
ansible --version
```
Créez un répertoire de projet de travail.
```
mkdir -p ~/ol-playbook
```

Créez un répertoire et un fichier de variables pour le projet.

mkdir ~/ol-playbook/vars

touch ~/ol-playbook/vars/defaults.yml

Ajoutez les variables et les valeurs au fichier.
```
   
cat << EOF | tee ~/ol-playbook/vars/defaults.yml > /dev/null
---
username: oracle
user_default_password: oracle
ssh_key_file: id_rsa
ssh_private_key_file: "{{ lookup('file', lookup('env','HOME') + '/.ssh/' + ssh_key_file + '.pub') }}"
additional_packages: ['git']
EOF
   
```
Ces informations expliquent chaque variable et comment nous allons l'utiliser :
- username : nom de l'utilisateur sudo créé lors de l'exécution du livre de jeux. Dans cet exemple, le nom de l'utilisateur est oracle.
- user_default_password : mot de passe par défaut de l'utilisateur oracle lors de sa création. Le mot de passe est requis lors de l'exécution des commandes sudo.
- ssh_key_file : définit le nom de la paire de clés SSH de l'utilisateur.
- ssh_private_key_file : copie la clé publique SSH de l'utilisateur dans le fichier authorized_key de l'utilisateur distant au niveau du chemin indiqué. L'exemple utilise le module d'extension lookup pour rechercher la clé publique id_rsa.pub dans le répertoire $HOME/.ssh/ des utilisateurs locaux.
- additional_packages : ajoutez le nom des packages supplémentaires à installer au format tableau. Chaque package du tableau doit être placé entre apostrophes et séparé par une virgule. Si vous installez un module Appstream tel que container-tools, le groupe ressemble à ['git',' @container-tools:ol8'].

Créez le fichier de livre de jeux.

   
cat << EOF | tee ~/ol-playbook/setup.yml > /dev/null
---
- hosts: all
  become: yes
  vars_files:
    - vars/defaults.yml

  tasks:

  - name: Generate new ssh keypair
    community.crypto.openssh_keypair:
      path: "~/.ssh/{{ ssh_key_file }}"
      size: 2048
      comment: olam ssh keypair
    become: true
    become_user: "{{ username }}"
    delegate_to: localhost

  - name: Add a user account with access to sudo
    ansible.builtin.user:
      name: "{{ username }}"
      password: "{{ user_default_password | password_hash('sha512') }}"
      comment: Default Oracle user
      groups: wheel
      append: yes
      update_password: on_create

  - name: Set the authorized key for the user using a local public key file
    ansible.posix.authorized_key:
      user: "{{ username }}"
      state: present
      key: "{{ ssh_private_key_file }}"

  - name: install additional packages
    ansible.builtin.dnf:
      name: "{{ additional_packages }}"
      state: latest
EOF
   

Les tâches spécifiques d'un livre de jeu et les noms de module visent à rendre le livre de jeu auto-documentant. Ces éléments indiquent où et qui exécute les lectures :

hosts: all : cette ligne indique les hôtes de l'inventaire qui exécuteront les tâches.
become: yes : indique aux tâches de cette section de s'exécuter avec le privilège sudo par défaut.
vars_files" Cette directive charge le fichier de variables contenant la configuration de playbook de ce tutoriel.

Installer les collections requises

Le package ansible-core contient un ensemble minimal de modules pour la gestion des hôtes appelés collection ansible.builtin. Une collection est une méthode de distribution de livres de jeux, de rôles, de modules ou de modules d'extension qui effectuent une tâche ciblée. ansible-core nécessite le téléchargement et l'installation de tous les modules ou collections requis en dehors des modules intégrés.

Comme le livre de jeux ci-dessus utilise la collection ansible.posix, nous devons installer cette collection et d'autres. Pour ce faire, la méthode la plus simple consiste à créer un fichier de conditions contenant toutes les dépendances.

Créez un fichier de conditions.

cat << 'EOF' | tee ~/ol-playbook/requirements.yml > /dev/null
---
collections:
  - name: ansible.posix
  - name: community.crypto
EOF

Installez la collection.
```
ansible-galaxy collection install -r ~/ol-playbook/requirements.yml
```
La sortie montre le processus de récupération du fichier d'archive compressé à partir du site Galaxy, puis de son installation dans votre répertoire personnel sous .ansible/collections.
Remarque : si la sortie affiche ERROR: Ansible requires the locale encoding to be UTF-8; Detected None., 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"
```

Exécuter le Playbook

Avant d'exécuter le livre de jeux, nous devons créer un fichier d'inventaire pour ce projet pointant vers l'instance Oracle Linux distante que nous prévoyons de gérer.

Affectez l'adresse IP de l'hôte ol à une variable pour notre système distant.

Cette variable facilite la création du fichier d'inventaire.
```
export REMOTE=<ip_address_of_instance>
```

Créez un répertoire de projet de fichier d'inventaire.

cat << EOF | tee ~/ol-playbook/inventory > /dev/null
[production]
ol-host ansible_host=$REMOTE
EOF

Accédez au répertoire de travail du projet.
```
cd ~/ol-playbook
```
Testez la connexion à l'aide de la commande ad hoc ping.
```
ansible ol-host -i ~/ol-playbook/inventory -m ping -u opc
```
- -u : transmet le nom utilisateur de la connexion SSH. Dans l'environnement d'atelier gratuit, nous utilisons l'utilisateur opc, l'utilisateur par défaut fourni sur les instances Oracle Linux dans Oracle Cloud Infrastructure (OCI). Approuvez l'empreinte de clé ECDSA en saisissant yes à l'invite pour continuer.
La commande s'exécute avec succès avec des résultats similaires à ceux affichés.
Exemple de sortie :
```
ol-host | SUCCESS => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/bin/python"
    },
    "changed": false,
    "ping": "pong"
}
```
Exécutez le playbook.
```
ansible-playbook -i inventory setup.yml -u opc
```
La commande doit s'exécuter correctement et afficher le résultat changed de chaque lecture.

Connexion à l'hôte distant

Si le playbook s'exécute correctement, nous pouvons nous connecter au système distant avec l'utilisateur tel que défini dans la variable username.

Connectez-vous via SSH au système ol-host.
```
ssh oracle@$REMOTE
```
Si vous avez modifié la valeur de la variable ssh_key_file, vous devez transmettre l'option `-i' à ssh, en pointant vers le fichier de clés privées de la paire spécifiée.
Par exemple :
```
ssh -i ~/.ssh/<local_ssh_private_key> <username>@<ip_address_of_host>
```
Vérifiez l'installation des packages demandés.

Une fois connecté, vous pouvez vérifier que le livre de jeux a installé le package git.
```
git --version
```
Déconnectez-vous de l'hôte distant.
```
exit
```

Ajouter un référentiel

Oracle Linux fournit une plate-forme sécurisée, évolutive et fiable sur laquelle vous pouvez déployer vos applications stratégiques. L'ajout d'un référentiel supplémentaire est utilisé pour installer un nouveau produit Oracle ou une application tierce. Oracle Linux fournit des packages supplémentaires qui gèrent le provisionnement de ces référentiels supplémentaires.

Le serveur YUM Oracle Linux fournit des détails sur les nombreux référentiels fournis par Oracle.

Ajoutez ces tâches supplémentaires au fichier playbook existant.
```
cat << EOF | tee -a setup.yml > /dev/null
  - name: Add the EPEL repository
    ansible.builtin.dnf:
      name: oracle-epel-release-el8
      state: present
    when:
      - ansible_distribution == 'OracleLinux'
      - ansible_facts['distribution_major_version'] == '8'

  - name: Install the htop utility package
    ansible.builtin.dnf:
      name: htop
      enablerepo: ol8_developer_EPEL
      state: present
    when:
      - ansible_distribution == 'OracleLinux'
      - ansible_facts['distribution_major_version'] == '8'
EOF
```
Ce livre de jeux ajoute deux tâches dans le jeu défini. Le premier ajoute le référentiel EPEL aux référentiels de logiciels existants sur l'instance Oracle Linux. Pendant ce temps, la seconde lecture installe le package htop sur la même instance hôte cible.

Paramètres à noter :
- state: present : garantit que le package référencé est déjà sur le système ou qu'il est installé à l'aide de dnf.
- enablerepo : active le référentiel spécifique (si désactivé) uniquement pendant la durée de la tâche en cours.
Exécutez à nouveau le livre de jeux pour effectuer les tâches supplémentaires.
```
ansible-playbook -i inventory setup.yml -u opc
```
Le playbook se termine avec succès, montrant quelques avertissements que nous pouvons ignorer. Le livre de jeux signale les tâches correctement terminées avec un statut ok ou changé. L'état changed indique que le playbook a modifié l'hôte en ajoutant le package htop ou en mettant à jour le cache dnf lors de la demande de la dernière version d'un package plutôt que de simplement vérifier s'il est présent. ok indique la fin de la tâche et ne nécessite aucune action.
Vérifiez l'installation du référentiel et du package.
```
ssh oracle@$REMOTE which htop
```
Exécutez la commande htop.
```
ssh oracle@$REMOTE -t htop
```
L'option -t de la commande SSH force une allocation TTY car htop nécessite un shell interactif.
Quittez le programme htop en saisissant q.

Ajout, mise à jour et suppression de fichiers et de répertoires

Créez un répertoire et un fichier en ajoutant les éléments suivants au fichier playbook existant.
```
   
cat << EOF | tee -a setup.yml > /dev/null     

  - name: Create an example directory (if it does not already exist)
    ansible.builtin.file:
      path: "/home/{{ username }}/example"
      state: directory
      mode: '0755'
    become_user: "{{ username }}"

  - name: Create an empty file
    ansible.builtin.file:
      path: "/home/{{ username }}/example/test.txt"
      state: touch
      # mode: u=rw,g=r,o=r
    become_user: "{{ username }}"
EOF
   
```
Ce livre de jeux ajoute deux tâches dans le jeu défini. Le premier crée un répertoire nommé example dans le répertoire personnel de l'utilisateur distant, et le second crée un fichier vide nommé test.txt dans le répertoire example nouvellement créé.

Paramètres supplémentaires à noter :
- state: : le module ansible.builtin.file prend en charge les paramètres suivants : absent, directory, file, hard, link et touch. Ces tâches utilisent directory, qui crée le chemin du répertoire s'il n'est pas déjà présent, et touch, qui crée un fichier vide s'il n'est pas déjà présent.
- mode : définit les droits d'accès du système de fichiers pour l'objet créé. Lorsque vous utilisez la ligne de commande, vous pouvez utiliser les modes octal 0644 ou symbolique u=rw,g=r,o=r. Le mode par défaut du système est appliqué si vous omettez le paramètre mode :.
- become_user: "" : utilise la fonctionnalité d'escalade des privilèges d'Oracle Linux Automation Engine pour exécuter une tâche. Dans les tutoriels précédents, nous avons introduit la fonctionnalité d'escalade du privilège become: pour exécuter une tâche en tant qu'utilisateur root. Cet exemple montre comment utiliser une fonctionnalité similaire pour exécuter une tâche en tant qu'autre utilisateur. Nous définissons l'utilisateur en tant que variable "", que nous avons prédéfinie en tant qu'utilisateur oracle dans le fichier vars/defaults.yml. Par conséquent, cette tâche s'exécute en tant qu'utilisateur oracle et hérite des valeurs par défaut de cet utilisateur.
Exécutez le livre de jeux pour effectuer les tâches supplémentaires.
```
ansible-playbook -i inventory setup.yml -u opc
```
Vérifiez que le nouveau répertoire et le nouveau fichier existent sur l'hôte distant.
```
ssh oracle@$REMOTE ls -al example
```
La sortie confirme la création d'un nouveau répertoire et du fichier vide. Notez que le fichier test.txt ne contient aucun octet et que l'utilisateur oracle en est propriétaire.
Ajouter plusieurs fichiers.

Lors de la configuration d'un système, vous devrez peut-être créer plusieurs fichiers dans un répertoire. Plutôt que d'utiliser des tâches individuelles, vous pouvez créer plusieurs fichiers dans un répertoire en tant qu'opération atomique.
```
   
cat << EOF | tee -a setup.yml > /dev/null     

  - name: Add multiple files
    ansible.builtin.file:
      path: "/home/{{ username }}/example/{{ item }}"
      state: touch
    with_items:
    - file01.txt
    - file02.txt
    - file03.txt
    - file04.txt
    become_user: "{{ username }}"
EOF
   
```
Cette tâche utilise une boucle pour créer plusieurs fichiers vides à partir d'une liste.
- path: : définit l'emplacement sur le système distant pour écrire les fichiers. Oracle Linux Automation Engine remplace la variable par chaque valeur item du paramètre with_items lors de l'exécution.
- with_items: : ce paramètre indique la liste de items à exécuter en boucle lors de l'exécution de cette tâche. Bien que cet exemple n'utilise que quatre noms de fichier, vous pouvez créer la liste aussi longtemps que nécessaire.
Exécutez le livre de jeux pour effectuer les tâches supplémentaires.
```
ansible-playbook -i inventory setup.yml -u opc
```
Vérifiez que le nouveau répertoire et le nouveau fichier existent sur l'hôte distant.
```
ssh oracle@$REMOTE ls -al example
```
La sortie affiche le fichier test.txt d'origine et les nouveaux.

Ajoutez une seule ligne de contenu à un fichier.

   
cat << 'EOF' | tee -a setup.yml > /dev/null     

  - name: Insert some text into the test.txt file
    ansible.builtin.lineinfile:
      path: "/home/{{ username }}/example/test.txt"
      line: This is a test
      create: True
      owner: "{{ username }}"
      group: "{{ username }}"
      mode: '0644'

  - name: Add an extra line after the line just inserted
    ansible.builtin.lineinfile:
      path: "/home/{{ username }}/example/test.txt"
      regexp: '^a test'
      insertafter: 'This is a test'
      line: This is some updated text that was added later.
      create: True
      owner: "{{ username }}"
      group: "{{ username }}"
      mode: '0644'

  - name: Get the contents of the test.txt file
    ansible.builtin.command: cat ~/example/test.txt
    register: command_output
    become_user: "{{ username }}"

  - name: Print the results of the cat command
    ansible.builtin.debug:
      msg: "{{ command_output }}"

  - name: Print only the lines added to the text file
    ansible.builtin.debug:
      msg: "{{ command_output.stdout_lines }}"
EOF
   

Les deux premières tâches utilisent ansible.builtin.lineinfile pour ajouter et mettre à jour des lignes uniques dans le fichier.
Les tâches restantes affichent une méthode pour confirmer les modifications. Le livre de jeux utilise d'abord ansible.builtin.command pour sortir le contenu du fichier mis à jour vers stdout et l'enregistre en mémoire dans une variable register. Il utilise ensuite le module ansible.builtin.debug pour imprimer ce contenu à l'écran dans le cadre de la sortie du playbook. La deuxième tâche de débogage montre un moyen de limiter la sortie à une partie particulière de la sortie JSON de la tâche précédente.

Exécutez le livre de jeux pour effectuer les tâches supplémentaires.
```
ansible-playbook -i inventory setup.yml -u opc
```
La dernière tâche du livre de jeux imprime le contenu du fichier à l'aide du module debug.

Ajouter plusieurs lignes de contenu à un fichier.

   
cat << EOF | tee -a setup.yml > /dev/null     

  - name: Add two lines into test.txt
    ansible.builtin.blockinfile:
      path: "/home/{{ username }}/example/test.txt"
      insertafter: 'This is some updated text that was added later.'
      block: |
        "Welcome to {{ ansible_hostname }}"
        "Last updated on {{ ansible_date_time.iso8601 }}"

  - name: Create a new file and insert content into it
    ansible.builtin.copy:
      content: |
        === The text below was added by Oracle Linux Automation Engine ==========

        Hello from the ansible.builtin.copy module.
        This task is an example of inserting multiple lines into a text file.
        You can insert more lines if you want.

        === The text above was added by Oracle Linux Automation Engine ===========
      dest: "/home/{{ username }}/example/testing.txt"
      mode: '0644'
    become_user: "{{ username }}"
EOF
   

Exécutez le livre de jeux pour effectuer les tâches supplémentaires.
```
ansible-playbook -i inventory setup.yml -u opc
```
Vérifiez que deux nouvelles lignes sont présentes dans le fichier.
```
ssh oracle@$REMOTE cat example/test.txt
```
La sortie affiche le contenu ajouté et interprète les valeurs de variable de la tâche en fonction de la collecte automatique des faits effectuée par le livre de jeux sur l'hôte distant lors de l'exécution.
Confirmez la création du nouveau fichier et l'ajout du contenu.
```
ssh oracle@$REMOTE cat example/testing.txt
```
Supprimez des fichiers et des répertoires.

Outre la création de fichiers et de répertoires et l'ajout de texte, Oracle Linux Automation Engine peut également supprimer ces éléments. Supprimons le répertoire et tous les fichiers créés par ce playbook et laissons le système dans le même état que lorsque nous avons démarré. Ces tâches utilisent d'abord le paramètre state : défini sur absent pour supprimer la liste des fichiers, puis le répertoire. La deuxième tâche gère la suppression des fichiers en une seule étape avec le répertoire. Néanmoins, nous incluons la première tâche pour une démonstration supplémentaire des fonctionnalités d'Oracle Linux Automation Engine.
```
    
cat << EOF | tee -a setup.yml > /dev/null     

  - name: Delete multiple files
    ansible.builtin.file:
      path: '{{ item }}'
      state: absent
    with_items:
      - "/home/{{ username }}/example/test.txt"
      - "/home/{{ username }}/example/file01.txt"
      - "/home/{{ username }}/example/file02.txt"
      - "/home/{{ username }}/example/file03.txt"
      - "/home/{{ username }}/example/file04.txt"
      - "/home/{{ username }}/example/testing.txt"

  - name: Recursively remove directory
    ansible.builtin.file:
      path: "/home/{{ username }}/example"
      state: absent
EOF
    
```
Il est possible de supprimer de manière récursive un répertoire et tout contenu en utilisant la deuxième tâche présentée. La première tâche, la suppression des fichiers individuellement, est présente dans le cas où vous voulez seulement supprimer des fichiers. Si vous souhaitez supprimer à la fois des fichiers et des fichiers et des répertoires, la deuxième tâche est plus efficace.
Exécutez le livre de jeux pour effectuer les tâches supplémentaires.
```
ansible-playbook -i inventory setup.yml -u opc
```
Vérifiez la suppression du répertoire spécifié.
```
ssh oracle@$REMOTE ls
```
L'absence de sortie confirme le répertoire spécifié et les fichiers créés au cours de ce tutoriel ont disparu.

Etapes suivantes

Nous vous félicitons d'avoir atteint ce niveau. Ce tutoriel a présenté plusieurs façons dont Oracle Linux Automation Engine permet d'effectuer des tâches de routine sur Oracle Linux grâce à l'automatisation, telles que l'installation de packages, la création, la mise à jour et la suppression de fichiers et de répertoires, ainsi que l'ajout de comptes utilisateur à Oracle Linux. Nous avons également montré comment utiliser le module ansible.builtin.debug d'Oracle Linux Automation Engine pour renvoyer des informations au terminal lors de l'exécution d'un Playbook. Avec ces compétences, vous avez une longueur d'avance pour vous aventurer et écrire vos propres livres de jeu.

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

Run Oracle Linux Tasks with Oracle Linux Automation Engine

F49868-05