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.

Exécuter des tâches Oracle Linux avec Oracle Linux Automation Engine

Présentation

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-code (IaC) au moyen d'une série de livres de jeu et de tâches.

Objectifs

Dans ce tutoriel, vous apprendrez à :

Écrivez des livres de jeu qui :
- Créer un utilisateur
- Ajoute l'utilisateur au groupe de 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.
- Manipule les fichiers

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: olae
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.

Écrire le livre de jeu de configuration initiale

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

Oracle Linux Automation Engine vous permet de définir ces variables dans plusieurs emplacements, chacun avec un ordre de priorité spécifique. Les variables de niveau livre de jeu sont définies dans le livre de jeu à 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'un autre jeu, comme nous le ferons dans cet exemple, qui définit la configuration du système avant d'exécuter le livre de jeu.

Ouvrez un nouveau terminal et connectez-vous au système ol-control-node via SSH.
```
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 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
   
```
Cette information explique chaque variable et comment nous l'utiliserons :
- username : Nom de l'utilisateur du sudo créé lors de l'exécution du livre de jeu. Pour cet exemple, le nom de l'utilisateur sera 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 plugiciel de consultation pour rechercher la clé publique id_rsa.pub dans le répertoire $HOME/.ssh/ des utilisateurs locaux.
- additional_packages : Ajoutez le nom de tous les ensembles supplémentaires à installer au format de tableau. Chaque paquet du tableau doit être placé entre apostrophes et séparé par une virgule. Si vous installez un module de flux d'applications tel que container-tools, le tableau ressemblerait à ['git',' @container-tools:ol8'].

Créez le fichier Playbook.

   
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 pièces :

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 du livre de jeu de ce tutoriel.

Installer les collections requises

L'ensemble ansible-core contient un jeu minimal de modules pour la gestion des hôtes, organisés dans la collection ansible.builtin. Une collection est une méthode pour distribuer des livres de jeu, des rôles, des modules ou des plugiciels 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 éléments intégrés.

Comme le livre de jeu ci-dessus utilise la collection ansible.posix, nous devons installer cette collection et d'autres. La façon la plus simple de le faire est de créer un fichier d'exigences qui contient toutes les dépendances.

Créez un fichier d'exigences.

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 de base sous .ansible/collections.
Note : Si la sortie affiche ERROR: Ansible requires the locale encoding to be UTF-8; Detected None., 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"
```

Exécuter le livre de jeux

Avant d'exécuter le livre de jeu, 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 le script de création du fichier d'inventaire.
```
export REMOTE=<ip_address_of_instance>
```

Créez un fichier d'inventaire dans le répertoire du projet.

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 d'utilisateur pour la connexion SSH. Dans l'environnement de laboratoire 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 numérique de la clé ECDSA en entrant 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 avec succès et afficher le résultat modifié de chaque lecture.

Se connecter à l'hôte distant

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

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

Après vous être connecté, vous pouvez vérifier que le livre de jeu a installé l'ensemble git.
```
git --version
```
Déconnectez-vous de l'hôte distant.
```
exit
```

Ajouter un référentiel

Oracle Linux offre une plateforme sécurisée, évolutive et fiable pour le déploiement de vos applications essentielles. 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 ensembles supplémentaires qui gèrent le provisionnement de ces référentiels supplémentaires.

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

Ajoutez ces tâches supplémentaires au fichier de livre de jeu 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: Add the EPEL repository
    ansible.builtin.dnf:
      name: oracle-epel-release-el9
      state: present
    when:
      - ansible_distribution == 'OracleLinux'
      - ansible_facts['distribution_major_version'] == '9'

  - 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'

  - name: Install the htop utility package
    ansible.builtin.dnf:
      name: htop
      enablerepo: ol9_developer_EPEL
      state: present
    when:
      - ansible_distribution == 'OracleLinux'
      - ansible_facts['distribution_major_version'] == '9'
EOF

Ce livre de jeu ajoute plusieurs tâches dans le jeu défini. Le premier jeu ajoute le référentiel EPEL aux référentiels logiciels existants sur l'instance Oracle Linux. Pendant ce temps, le deuxième jeu de lectures installe l'ensemble htop sur la même instance hôte cible.

Paramètres à noter :

state: present : Garantit que l'ensemble 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 courante.

Réexécutez le livre de jeu pour effectuer les tâches supplémentaires.
```
ansible-playbook -i inventory setup.yml -u opc
```
Le livre de jeu se termine avec succès, affichant quelques avertissements pendant l'exécution. Vous pouvez ignorer ces avertissements pour le moment, car ils n'affectent pas le livre de jeu actuel. Le livre de jeu indique que les tâches sont correctement terminées avec un statut ok ou changé. Le statut modifié indique que le livre de jeu a modifié l'hôte en ajoutant l'ensemble htop ou en mettant à jour la mémoire cache dnf lors de la demande de la dernière version d'un ensemble plutôt que de simplement vérifier s'il est présent. Un ok indique l'achèvement 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 affectation TTY car htop nécessite un interpréteur de commandes interactif.
Quittez le programme htop en entrant q.

Ajouter, mettre à jour et supprimer des fichiers et des répertoires

Créez un répertoire et un fichier en ajoutant ce qui suit au fichier de livre de jeu 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 jeu ajoute deux tâches dans le jeu défini. Le premier crée un nouveau répertoire nommé exemple dans le répertoire de base de l'utilisateur distant, et le second crée un fichier vide nommé test.txt dans le nouveau répertoire exemple.

Paramètres supplémentaires à noter :
- state: : Le module ansible.builtin.file prend en charge les paramètres suivants : absent, répertoire, fichier, dur, lien et touch. Ces tâches utilisent le répertoire, qui crée le chemin du répertoire s'il n'est pas déjà présent, et touchez, qui crée un fichier vide s'il n'est pas déjà présent.
- mode : Définit les autorisations 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 des privilèges become: pour exécuter une tâche en tant qu'utilisateur racine. Cet exemple montre comment utiliser des fonctionnalités similaires 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 jeu pour effectuer les tâches supplémentaires.
```
ansible-playbook -i inventory setup.yml -u opc
```
Vérifiez que le nouveau répertoire et le 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 contient zéro octet et que l'utilisateur oracle en est le responsable.
Ajoutez plusieurs fichiers.

Lors de la configuration du 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 une seule 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 l'écriture des fichiers. Oracle Linux Automation Engine remplace la variable `` par chaque item du paramètre with_items lors de l'exécution.
- with_items: : Ce paramètre indique la liste items à boucler pendant 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 jeu pour effectuer les tâches supplémentaires.
```
ansible-playbook -i inventory setup.yml -u opc
```
Vérifiez que le nouveau répertoire et le fichier existent sur l'hôte distant.
```
ssh oracle@$REMOTE ls -al example
```
La sortie affiche le fichier test.txt initial 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 an additional test.
      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 jeu utilise d'abord ansible.builtin.command pour afficher le contenu du fichier mis à jour dans stdout et l'enregistrer 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 livre de jeu. La deuxième tâche de débogage présente une méthode pour limiter la sortie à une partie spécifique de la sortie JSON de la tâche précédente.

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

Ajoutez 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 jeu 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 de faits effectuée par le livre de jeu sur l'hôte distant lors de l'exécution.
Confirmez la création du nouveau fichier et l'ajout de notre contenu.
```
ssh oracle@$REMOTE cat example/testing.txt
```
Supprimer des fichiers et des répertoires.

En plus de créer des fichiers et des répertoires et d'ajouter du texte, Oracle Linux Automation Engine peut également supprimer ces éléments. Supprimons le répertoire et tous les fichiers créés par ce livre de jeu, laissant le système dans le même état que lorsque nous avons démarré. Ces tâches utilisent d'abord le paramètre state (État) réglé à absent pour supprimer la liste des fichiers, puis le répertoire. La deuxième tâche consiste à supprimer les fichiers et le répertoire en une seule étape. Néanmoins, nous incluons la première tâche pour une démonstration supplémentaire des fonctions 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 récursivement un répertoire et tout contenu à l'aide de la deuxième tâche affichée. La première tâche, la suppression de fichiers individuellement, est disponible si vous voulez seulement supprimer des fichiers spécifiques. Si vous souhaitez supprimer des fichiers, des fichiers et des répertoires, la deuxième tâche est plus efficace.
Exécutez le livre de jeu pour effectuer les tâches supplémentaires.
```
ansible-playbook -i inventory setup.yml -u opc
```
Vérifiez la suppression du répertoire indiqué.
```
ssh oracle@$REMOTE ls
```
L'absence de sortie confirme que le répertoire spécifié et les fichiers créés au cours de ce tutoriel ne sont plus présents.

Étapes suivantes

Félicitations pour le faire jusqu'ici. Ce tutoriel présente plusieurs façons dont Oracle Linux Automation Engine permet l'automatisation des tâches de routine sur Oracle Linux, notamment l'installation d'ensembles, la création, la mise à jour et la suppression de fichiers et de répertoires, ainsi que l'ajout de comptes d'utilisateur à Oracle Linux. Nous avons également démontré comment utiliser le module ansible.builtin.debug d'Oracle Linux Automation Engine pour afficher des informations sur le terminal lors de l'exécution d'un livre de jeu. Avec ces compétences, vous avez une longueur d'avance pour vous aventurer et écrire vos livres de jeu.

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

Run Oracle Linux Tasks with Oracle Linux Automation Engine

G33089-02