Orchestration de Ansible Playbooks avec OCI Fleet Application Management

Introduction

Oracle Cloud Infrastructure (OCI) fournit une plate-forme cloud complète permettant aux clients de gérer leur infrastructure et leurs applications. Pour améliorer davantage les fonctionnalités de gestion, Fleet Application Management (FAM) dans OCI orchestre les tâches opérationnelles à grande échelle. Dans le cadre de cette orchestration, FAM permet aux utilisateurs d'orchestrer Ansible, un outil d'automatisation open source populaire, afin de permettre aux clients d'automatiser et de gérer leurs ressources OCI plus efficacement.

En permettant aux utilisateurs d'orchestrer Ansible avec FAM, les clients peuvent utiliser les fonctionnalités d'automatisation d'Ansible pour gérer leurs infrastructures OCI et leurs piles d'applications.

Dans ce tutoriel, nous allons montrer comment exécuter le guide de lecture Ansible via l'instance auto-hébergée avec OCI Fleet Application Management (FAM). 

Remarque : nous décrivons le processus à l'aide de la console OCI, mais vous pouvez également utiliser l'interface de ligne de commande ou l'API Oracle Cloud Infrastructure. Pour plus d'informations sur OCI Fleet Application Management, reportez-vous à Gestion des applications de parc.

Premiers pas - Exécution d'un guide d'exécution Ansible

OCI FAM utilise le guide d'exécution pour déclencher un script sur une instance auto-hébergée, où un guide d'exécution ansible est exécuté sur l'instance de calcul cible. Ansible peut être intégré aux mécanismes de sécurité natifs d'OCI, tels qu'OCI Vault et Principaux d'instance, pour gérer en toute sécurité les clés secrètes (comme les clés privées SSH) et automatiser les tâches sur les instances cloud.

Tâche 1 : instance auto-hébergée

Créer une instance de calcul

Lancez d'abord une instance de calcul. Choisissez de créer une instance ou de sélectionner une instance existante, puis suivez les étapes détaillées ci-dessous.

Remarque : pour obtenir des instructions détaillées et détaillées sur la création d'une instance de calcul dans Oracle Cloud Infrastructure, reportez-vous à la documentation Oracle officielle : Création d'une instance.

Inscription d'une instance auto-hébergée dans OCI Fleet Application Management

Une instance auto-hébergée peut servir de hub central pour surveiller et gérer plusieurs ressources. En choisissant une instance en tant qu'instance auto-hébergée, vous pouvez effectuer différentes vérifications pour vous assurer que vos instances Compute sont exécutées comme prévu.

  1. Connectez-vous à la console OCI, accédez à Observation & gestion et sélectionnez Gestion des applications de parc.
  2. Cliquez sur Administration.
  3. Sous Gestion des métadonnées, cliquez sur Instances auto-hébergées et sur Créer une instance auto-hébergée.
  4. Entrez les informations suivantes pour les instances auto-hébergées.
    • Nom : entrez l'instance auto-hébergée, en évitant les informations confidentielles telles que les clés, etc.
    • Compartiment : choisissez le compartiment qui contient l'instance auto-hébergée.
    • Sélectionner une instance → Compartiment : 
    • Instance : choisissez l'instance** dans le compartiment sélectionné

Créer une instance autohébergée

Important : veillez à activer le module d'extension de gestion des applications de parc sur l'instance auto-hébergée et l'instance associée. Cette étape garantit que Fleet Application Management peut prendre en compte efficacement ces instances pour les opérations de cycle de vie.

Tâche 2 : configurer l'instance auto-hébergée

Préparez ensuite votre noeud de contrôle auto-hébergé en installant et en validant les composants ci-dessous : 

Le RPM de la collection Ansible installe la collection OCI Ansible et ses dépendances requises. Une fois le package RPM installé, vous devez configurer le fichier d'authentification du kit SDK et de l'interface de ligne de ligne de commande comme expliqué dans Configuration l'authentification.

Installation du kit SDK OCI pour Python

L'installation du kit SDK OCI sur une instance de calcul (instance auto-hébergée) implique généralement l'utilisation d'un gestionnaire de packages ou d'une méthode de téléchargement et d'installation directs, en fonction du langage du kit SDK et du système d'exploitation de l'instance de calcul (auto-hébergée).

  1. Téléchargez et installez le kit SDK pour Python en suivant les instructions de la rubrique Kit kit SDK pour Python. Pour plus d'informations, reportez-vous à la section Téléchargement et installation du kit SDK.
  2. Une fois le kit SDK pour Python installé, vous devez la configurer à l'aide des instructions de la rubrique Configuration du kit SDK.
\\# Create and activate a Python virtual environment (for pip/CLI tools)

python3 -m venv fam\\_ansible

source fam\\_ansible/bin/activate

\\# Upgrade pip inside the venv

pip install --upgrade pip

\\# Verify OCI CLI if already present in your path

oci -version

3\\.66.1

\\# If OCI CLI not installed

\$ pip install oci-cli

Collecting oci-cli`

 Downloading oci\\_cli-3.66.1-py3-none-any.whl 


Successfully installed oci-2.160.1 oci-cli-3.66.1

Installation et configuration d'Ansible

Remarque : cette installation utilise Python version 3.6 et Ansible version 2.9 ou ultérieure.

Installation de la collection OCI Ansible

Installez la collection Ansible pour OCI à partir d'Ansible Galaxy à l'aide de la commande suivante :

\\# Install the Oracle OCI Ansible Collection

ansible-galaxy collection install oracle.oci

Starting galaxy collection install process

Process install dependency map

Starting collection install process

Downloading https://galaxy.ansible.com/oracle-oci-5.5.0.tar.gz 

Installing 'oracle.oci:5.5.0' to '/root/.ansible/collections/ansible\\_collections/oracle/oci'

oracle.oci:5.5.0 was installed successfully

\\# 

ansible-doc -l | grep oracle.oci

oracle.oci (collection)  5.5.0

\\# 

ansible -m ping localhost -c local

localhost | SUCCESS => {

    "changed": false,

    "ping": "pong"

}

\\# 

ansible-doc -l | grep oci\\_ | tail

oracle.oci.oci\\_waf\\_web\\_app\\_firewall\\_policy\\_facts              

oracle.oci.oci\\_work\\_requests\\_work\\_request\\_error\\_facts         

oracle.oci.oci\\_work\\_requests\\_work\\_request\\_facts               

oracle.oci.oci\\_work\\_requests\\_work\\_request\\_log\\_entry\\_facts

Si vous avez déjà installé la collection, vous pouvez mettre à jour ses modules vers la dernière version en ajoutant l'indicateur –force à la commande. Exemple :

\$ ansible-galaxy collection install --force oracle.oci

Si vous devez installer un coeur ansible dans le calcul :

\\# Refresh repo metadata and install Ansible core + Git

sudo dnf makecache

sudo dnf install -y ansible-core git

\\# Verify Ansible

ansible --version

ansible [core 2.14.18]

config file = /etc/ansible/ansible.cfg

ansible python module location = /usr/lib/python3.9/site-packages/ansible

executable location = /usr/bin/ansible

python version = 3.9.21

Remarque : pour obtenir des instructions détaillées et détaillées sur la prise en main d'Ansible dans Oracle Cloud Infrastructure, reportez-vous à la documentation Oracle officielle : Présentation d'Ansible Collection.

Tâche 3 : configuration du principal d'instance pour accéder à la clé secrète (IAM)

Dans cette section, vous allez configurer les droits d'accès IAM requis pour :

Accès à la clé secrète à l'aide du principal d'instance

Utilisez des ID instance pour permettre à votre instance de calcul d'appeler des services OCI sans stocker ni faire pivoter les informations d'identification utilisateur. En plaçant l'instance dans un groupe dynamique et en accordant la stratégie IAM appropriée, l'instance peut lire les clés secrètes de manière sécurisée à partir d'OCI Vault. Pour utiliser des principaux d'instance, vous devez créer un groupe dynamique et une stratégie comme indiqué ci-dessous.

Créer un groupe dynamique

Les groupes dynamiques utilisent des règles pour définir les instances qui sont membres du groupe. La règle de mise en correspondance peut être une règle simple dans laquelle vous fournissez l'OCID de l'instance de calcul utilisée pour l'interface de ligne de commande. Il existe un générateur de règles que vous pouvez utiliser à partir de la console OCI pour créer la règle. Pour créer un groupe dynamique à l'aide de la console OCI, consultez la documentation ici. 

Pour créer un groupe dynamique, effectuez les opérations suivantes :

  1. Connexion à la console OCI
  2. Sélectionnez le menu dans l'angle supérieur gauche, sélectionnez Identité, Groupes dynamiques et cliquez sur Créer un groupe dynamique.
  3. Saisissez son nom et une description conviviale
  4. Entrez une règle de mise en correspondance afin que votre instance soit qualifiée pour le groupe dynamique

Si vous ne savez pas comment définir la règle, vous pouvez utiliser le générateur de règles pour vous aider à la créer. Cliquez sur le bouton Générateur de règles. Saisissez les critères de votre règle. Dans ce tutoriel, nous utilisons une règle très simple, dans laquelle nous indiquons l'OCID de l'instance de calcul sur laquelle nous allons exécuter le guide de lecture Ansible.

Entrez la règle de rapprochement et cliquez sur le bouton Ajouter une règle. Dans l'écran Créer un groupe dynamique, cliquez sur le bouton Créer.

Créer une stratégie

Une fois que vous avez créé le groupe dynamique, vous devez créer une stratégie qui accorde à votre groupe le privilège de lire les clés secrètes dans le compartiment de coffre. La documentation relative à l'écriture de stratégies est disponible ici. 

Pour créer une stratégie, procédez comme suit :

  1. Connexion à la console OCI
  2. Sélectionnez le menu dans l'angle supérieur gauche, sélectionnez Identité, Stratégies et cliquez sur Créer une stratégie.
    • Nom : entrez un nom.
    • Description : Ajouter une description 
    • Compartiment : choisissez le compartiment.

    • Instructions de stratégie : ajoutez les éléments suivants :

      allow dynamic-group ansible\_control\_node\_dg to use secret-family in compartment <vault-compartment>

      allow dynamic-group ansible\_control\_node\_dg to read vaults in compartment <vault-compartment>

    • Cliquez sur Créer.

      Activation de l'autorisation de principal d'instance pour la clé secrète OCI

      Une fois que vous avez créé le groupe dynamique, la règle de mise en correspondance et la stratégie, vous êtes prêt à utiliser des ID instance pour autoriser les appels de l'interface de ligne de commande OCI pour OCI Vault/secret. Pour activer l'autorisation de Principal d'instance à partir de l'interface de ligne de ligne de commande, vous pouvez utiliser l'option d'autorisation (–auth) pour une commande. Exemple :

\\# From the self-host, check a simple IAM call via Instance Principals

oci iam region list --auth instance\\_principal

\\# Test a secrets call (replace with your secret OCID)

oci secrets secret-bundle get \\

--secret-id ocid1.vaultsecret.oc1..example \\

--auth instance\\_principal \\

--raw-output \\

--query 'data."secret-bundle-content".content' | base64 -d

Références

Tâche 4 : créer un guide d'exécution pour exécuter le guide d'exécution Ansible

Une fois l'installation et la configuration terminées, vous pouvez écrire un exemple de livre de jeux qui utilise Ansible. Voici un exemple de livre de jeux (nommé run_uptime_date_commands.yml) qui exécute la commande simple sur l'instance de calcul distante.

Créer un Playbook Ansible

\\---

\\# Play 1: Fetch the OCI Vault secret (private key) and write to a local file

\\- name: Fetch private key from OCI Vault and save to file

hosts: localhost

connection: local

gather\\_facts: false

vars:

# Override at runtime: -e secret\\_ocid= -e output\\_path= -e target\\_host= -e ssh\\_user=

secret\\_ocid: "ocid1.vaultsecret.oc1.iad.amXXXXXXaaaal4XXXXXXXXXXXXXXXXXXXXX2d7swXXXXXzq"

output\\_path: "/secret\\_value.txt"

# SSH connection parameters to the target

target\\_host: "famosXXXXXXXXXXXXXXXXX.com"

ssh\\_user: "XXXXX"

ssh\\_port: 22

# Optional: relax host key checking for first-time connections

# For production, set to "" and manage known\\_hosts strictly

ssh\\_common\\_args: "-o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null"

tasks:

- name: Fetch secret (base64) via OCI CLI using instance principals

ansible.builtin.command:

   argv:

         - oci

         - secrets

         - secret-bundle

         - get

         - --secret-id

         - ""

         - --auth

         - instance\\_principal

         - --raw-output

         - --query

         - "data.\\"secret-bundle-content\\".content"

      register: secret\\_b64

      changed\\_when: false

      environment:

        NO\\_PROXY: "169.254.0.0/16,127.0.0.1,localhost"

        no\\_proxy: "169.254.0.0/16,127.0.0.1,localhost"

    - name: Fail if fetch failed

      ansible.builtin.fail:

        msg: "Failed to fetch secret. stderr="

      when: secret\\_b64.rc != 0

    - name: Decode base64 to raw secret string

      ansible.builtin.set\\_fact:

        secret\\_raw: ""

    # If the secret was stored with literal "\\n", convert to real newlines (typical for PEM pasted as single line)

    - name: Normalize newlines if needed

      ansible.builtin.set\\_fact:

        secret\\_value: ""

      when: "'\\\\n' in secret\\_raw or '\\\\r\\\\n' in secret\\_raw"

    - name: Keep decoded secret as-is

      ansible.builtin.set\\_fact:

        secret\\_value: ""

      when: "'\\\\n' not in secret\\_raw and '\\\\r\\\\n' not in secret\\_raw"

    - name: Write key to file with strict permissions (0600)

      ansible.builtin.copy:

        dest: ""

        content: ""

        mode: "0600"

      no\\_log: true

    - name: Add dynamic host with SSH parameters

      ansible.builtin.add\\_host:

        name: ""

        groups: dynamic\\_targets

        ansible\\_user: ""

        ansible\\_port: ""

        ansible\\_ssh\\_private\\_key\\_file: ""

        ansible\\_ssh\\_common\\_args: ""

\\# Play 2: Connect to the target and run uptime and date

\\- name: Run health checks on target

  hosts: dynamic\\_targets

  gather\\_facts: false

  tasks:

    - name: Wait for SSH to be ready

      ansible.builtin.wait\\_for\\_connection:

        timeout: 60

        sleep: 3

    - name: Run uptime

      ansible.builtin.command: uptime

      register: uptime\\_out

      changed\\_when: false

    - name: Show uptime output

      ansible.builtin.debug:

        var: uptime\\_out.stdout

    - name: Run date

      ansible.builtin.command: date

      register: date\\_out

      changed\\_when: false

    - name: Show date output

      ansible.builtin.debug:

        var: date\\_out.stdout

Remarque : nous vous recommandons de conserver le guide de lecture autonome et de transmettre toutes les entrées via -e afin que le même guide de lecture FAM puisse exécuter différents hôtes/utilisateurs/commandes sans modification de fichier. Nous vous recommandons également de stocker la clé SSH dans le coffre et d'extraire la clé secrète si nécessaire.

Création d'une opération de cycle de vie pour l'exécution d'Ansible Playbook

Créez une opération de cycle de vie personnalisée dans FAM pour exécuter le script d'application de patches de système d'exploitation DbNode, car il ne relève pas des catégories de cycle de vie standard.

  1. Dans la console OCI, accédez à Gestion des applications de parc > Gestion des métadonnées > Opérations de cycle de vie
  2. Créez une opération de cycle de vie nommée, par exemple Ansible_playbook_execution_operation.
  3. Indiquer qu'elle utilise une instance auto-hébergée (configurée dans des étapes ultérieures)

    Création d'un guide d'exploitation via la console OCI

    Ce tutoriel sur l'exécution du livre de jeux ansible avec l'instance auto-hébergée utilise le livre d'exécution OCI FAM, qui peut définir comment exécuter le livre de jeux avec des variables. Par exemple, pour exécuter le livre de jeux ansible, vous écrivez la commande pour exécuter le livre de jeux ansible.

Pour créer un guide d'exploitation, procédez comme suit :

  1. Accédez à la console OCI, accédez à Gestion des applications de parc et cliquez sur Actions et contrôles.
  2. Cliquez sur Livres d'exécution et Créer un livre d'exécution.
  3. Entrez le nom, la description, l'opération de cycle de vie et le type de livre d'exécution, puis sélectionnez le type de système d'exploitation et l'heure de fin estimée.
  4. Créez votre guide d'exploitation à l'aide du concepteur visuel, téléchargez un fichier YAML ou JSON ou référencez votre script d'automatisation existant via des tâches de script Bash ou Python dans le guide d'exploitation.
    • . Télécharger le fichier (playbook yml)
  5. Fournissez la commande permettant d'exécuter le livre de jeux ansible à l'aide de tâches de script Bash ou Python dans le livre d'exécution.
  6. Après avoir ajouté la commande à exécuter, vous devez remplacer les propriétés par l'instance auto-hébergée et choisir l'instance auto-hébergée que vous avez créée pour la tâche 1 précédente.
  7. Ajoutez d'autres tâches pour personnaliser votre guide d'exploitation selon vos besoins.

    Tâche 5 : Playbook d'exécution Ansible

Une fois le guide d'exploitation créé, vous êtes prêt à exécuter le Ansible Playbook dans OCI Fleet Application Management. Vous pouvez désormais exécuter le livre de jeux ansible via l'instance auto-hébergée. Pour exécuter le guide d'exploitation, créez un parc contenant l'instance auto-hébergée.

Créer un parc pour l'instance

Créez un parc dans FAM pour gérer l'instance auto-hébergée. Aucun produit n'a besoin d'être ajouté pour l'exécution CR.

  1. Dans la console OCI, accédez à Gestion des applications de parc > Parcs.
  2. Créez un parc (par exemple, ansible_playbook_fleet) et ajoutez l'instance auto-hébergée en tant que ressource.
  3. Assurez-vous que le parc se trouve dans le compartiment souhaité et définissez le type d'environnement de production, le cas échéant.

    Exécuter le guide d'exécution Ansible Playbook

Déclenchez l'exécution du guide d'exploitation pour Ansible Playbook.

  1. Dans la console OCI, accédez à Gestion des applications de parc > Parcs > ansible_playbook_fleet.
  2. Créez un travail ou une exécution, en sélectionnant ansible_playbook_runbook et l'opération de cycle de vie.
  3. Planifiez l'exécution ou exécutez-la immédiatement.
  4. Cliquez ici pour Exécuter.
  5. Exécutions

    Sortie d'exécution

Une fois l'exécution terminée ou au cours de l'exécution, vous pouvez surveiller la progression de l'exécution d'un livre de jeux ansible.

Consultez les journaux d'exécution dans FAM pour vérifier que le script a bien été exécuté.

  1. Dans la console OCI, accédez à Gestion des applications de parc > Gestion du cycle de vie > Travaux.
  2. Sélectionnez le travail d'exécution et affichez ses journaux pour rechercher les erreurs ou les messages de succès (par exemple, la progression du travail d'application de patches au système d'exploitation).
  3. Journal Ansible
Parsing the config file
Validating config format
Successfully validated config format
Processing target section
Target section not found or empty, skipping target parsing
Processing subjects section
Subject section patches is missing or invalid. Skipping
Subjects section parsed and written to file
Either Patches section not found or it has empty list
Processing script section
Script section extracted
Processing input\\_variables section
Input variables section not found or empty
Processing credentials section
Credentials section not found or has wrong format
Finished parseJSON function
Mount point: /
/var/lib/oracle-cloud-agent/plugins/oci-fams/executions/run/ocid1.famsschedulerjob.oc1.iad..amaaaaaal4gwqoaahh3nhaske7upkuttqsqkwjbesec525zxsosjxcw2nska/1861f58f-bb31-467e-9350-143060d360c9/run\\_uptime\\_date\\_commands.yml
object content written to file: /var/lib/oracle-cloud-agent/plugins/oci-fams/executions/run/ocid1.famsschedulerjob.oc1.iad..amaaaaaal4gwqoaahh3nhaske7upkuttqsqkwjbesec525zxsosjxcw2nska/1861f58f-bb31-467e-9350-143060d360c9/run\\_uptime\\_date\\_commands.yml
No input variable object storage namespace provided
Executing command: /bin/sh -c set -e; source /root/fams\\_ansible/fam\\_ansi/bin/activate; ansible-playbook -i "localhost," -c local run\\_uptime\\_date\\_commands.yml -e target\\_host="famoscompute01.xxxx.xxxx.oraclevcn.com" -e ssh\\_user="rduser" -e output\\_path="/root/fams\\_ansible/secret\\_value.txt"  -e ssh\\_port=22

PLAY [Fetch private key from OCI Vault and save to file] \\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*

TASK [Fetch secret (base64) via OCI CLI using instance principals] \\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*
ok: [localhost]

TASK [Fail if fetch failed] \\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*
skipping: [localhost]

TASK [Decode base64 to raw secret string] \\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*
ok: [localhost]

TASK [Normalize newlines if needed] \\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*
ok: [localhost]

TASK [Keep decoded secret as-is] \\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*
skipping: [localhost]

TASK [Write key to file with strict permissions (0600)] \\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*
ok: [localhost]

TASK [Add dynamic host with SSH parameters] \\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*
changed: [localhost]

PLAY [Run health checks on target] \\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*

TASK [Wait for SSH to be ready] \\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*
ok: [famoscompute01.xxx.xxx.oraclevcn.com]

TASK [Run uptime] \\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*
ok: [famoscompute01.xxx.xxx.oraclevcn.com]

TASK [Show uptime output] \\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*
ok: [famoscompute01.xxx.xxx.oraclevcn.com] => {
 `    `"uptime\\_out.stdout": " 08:37:26 up 89 days, 18:55,  0 users,  load average: 0.11, 0.05, 0.01"
 }

TASK [Run date] \\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*
ok: [famoscompute01.xxx.xxx.oraclevcn.com]

TASK [Show date output] \\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*
ok: [famoscompute01.xxx.xxx.oraclevcn.com] => {
 `    `"date\\_out.stdout": "Tue Sep 30 08:37:27 AM GMT 2025"
 }

PLAY RECAP \\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*
famoscompute01.xxx.xxx.oraclevcn.com : ok=5    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0   
 localhost                  : ok=5    changed=1    unreachable=0    failed=0    skipped=2    rescued=0    ignored=0   


 ======= Stderr ========

   stderr

Accusés de réception

Ressources de formation supplémentaires

Explorez d'autres ateliers sur le site docs.oracle.com/learn ou accédez à d'autres contenus d'apprentissage gratuits sur le canal Oracle Learning YouTube. En outre, visitez le site education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir de la documentation sur le produit, consultez Oracle Help Center.