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"
olam_type: olae
EOF

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

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.

Ecrire le Playbook de configuration initiale

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

Oracle Linux Automation Engine vous permet de définir ces variables à plusieurs emplacements, chacun avec un ordre de priorité spécifique. Les variables de niveau Playbook sont définies dans le livre de jeux à 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 dynamiquement ou statiquement à 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 livre de jeux.

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 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, organisés dans la 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 d'extension.

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 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 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, affichant 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 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, 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 offre une plate-forme sécurisée, évolutive et fiable pour le déploiement de vos applications stratégiques. L'ajout d'un référentiel supplémentaire permet d'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 proposés 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: 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 jeux ajoute plusieurs tâches dans le jeu défini. Le premier ensemble ajoute le référentiel EPEL aux référentiels de logiciels existants sur l'instance Oracle Linux. Pendant ce temps, le second ensemble de lectures 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, 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 guide de lecture indique que les tâches sont correctement terminées avec un statut ok ou changed. L'état changed indique que le livre de jeux 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. Un ok indique que la tâche est terminée 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 présenté la fonctionnalité d'escalade des privilèges become: pour exécuter une tâche en tant qu'utilisateur root. 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 comme la 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 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 é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 pendant l'exécution de cette tâche. Bien que cet exemple utilise seulement 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 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 présentent une méthode permettant de confirmer les modifications. Le livre de jeux 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. Ensuite, il utilise le module ansible.builtin.debug pour imprimer ce contenu à l'écran dans le cadre de la sortie du livre de jeux. La deuxième tâche de débogage présente une méthode permettant de limiter la sortie à une partie spécifique 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 de notre 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 livre de lecture, laissant le système dans le même état que lorsque nous avons commencé. 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 permet de 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 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 récursivement un répertoire et tout contenu à l'aide de la deuxième tâche présentée. La première tâche, qui consiste à supprimer des fichiers individuellement, est disponible si vous souhaitez uniquement supprimer des fichiers spécifiques. 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 que le répertoire spécifié et les fichiers créés lors de ce tutoriel ne sont plus présents.

Etapes suivantes

Félicitations d'avoir suivi jusqu'ici. Ce tutoriel a présenté plusieurs façons dont Oracle Linux Automation Engine permet d'automatiser les tâches de routine sur Oracle Linux, notamment 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 expliqué 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 Playbook. Avec ces compétences, vous avez une longueur d'avance pour vous aventurer et écrire vos livres de jeux.

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