Orchestrazione dei playbook Ansible con OCI Fleet Application Management

Introduzione

Oracle Cloud Infrastructure (OCI) fornisce una piattaforma cloud completa che consente ai clienti di gestire la propria infrastruttura e le proprie applicazioni. Per migliorare ulteriormente le funzionalità di gestione, Fleet Application Management (FAM) in OCI gestisce attività operative su larga scala. Come parte di questa orchestrazione, FAM consente agli utenti di orchestrare Ansible, un popolare strumento di automazione open source, per consentire ai clienti di automatizzare e gestire le proprie risorse OCI in modo più efficiente.

Consentendo agli utenti di orchestrare Ansible con FAM, i clienti possono utilizzare le funzionalità di automazione di Ansible per gestire le infrastrutture OCI e gli stack di applicazioni.

In questa esercitazione verrà illustrato come eseguire il playbook Ansible tramite l'istanza self-hosted con OCI Fleet Application Management (FAM). 

Nota: stiamo descrivendo il processo utilizzando OCI Console, ma puoi anche utilizzare l'interfaccia a riga di comando (OCI CLI) o l'API di Oracle Cloud Infrastructure. Per informazioni su OCI Fleet Application Management, vedere Gestione delle applicazioni flotta.

Introduzione - Esecuzione di un runbook Ansible

OCI FAM utilizza il runbook per attivare uno script su un'istanza self-hosted, in cui viene eseguita una playbook ansible sull'istanza di computazione di destinazione. Ansible può essere integrato con i meccanismi di sicurezza nativi di OCI, come OCI Vault e Instance Principals, per gestire in modo sicuro i segreti (come le chiavi private SSH) e automatizzare i task tra le istanze cloud.

Task 1: Istanza self-hosted

Crea istanza di computazione

In primo luogo, avviare un'istanza di computazione. Scegliere se creare una nuova istanza o selezionarne una esistente, quindi attenersi alla procedura dettagliata riportata di seguito.

Nota: per istruzioni dettagliate su come creare un'istanza di computazione in Oracle Cloud Infrastructure, fare riferimento alla documentazione ufficiale di Oracle: Creazione di un'istanza

Registrare l'istanza in hosting automatico in OCI Fleet Application Management

Un'istanza self-hosted può fungere da hub centrale per monitorare e gestire diverse risorse. Scegliendo un'istanza come istanza self-hosted, puoi eseguire vari controlli per garantire che le istanze di computazione siano in esecuzione come previsto.

  1. Eseguire il login a OCI Console, andare a Observability & Management e selezionare Fleet Application Management.
  2. Fare clic su Amministrazione.
  3. In Gestione dei metadati, fare clic su Istanze self-hosted e Crea istanza self-hosted.
  4. Immettere le seguenti informazioni per le istanze in hosting automatico.
    • Nome: immettere l'istanza ospitata in modo autonomo, evitando qualsiasi informazione riservata come le chiavi e così via.
    • Compartimento: scegliere il compartimento che contiene l'istanza self-hosted
    • Seleziona istanza → Compartimento: 
    • Istanza: scegliere l'istanza** nel compartimento selezionato

Crea istanza self-hosted

Importante: assicurarsi di abilitare il plugin Gestione applicazioni flotta nell'istanza self-hosted e nell'istanza associata. Questo passo garantisce che Fleet Application Management possa prendere in considerazione in modo efficace queste istanze per le operazioni del ciclo di vita.

Task 2: Configurare l'istanza con hosting automatico

Successivamente, preparare il nodo di controllo self-hosted installando e convalidando i componenti riportati di seguito: 

L'RPM di raccolta Ansible installa la raccolta Ansible OCI e le dipendenze richieste. Dopo avere installato l'RPM, è necessario configurare il file di configurazione SDK e CLI come descritto in Configuring Authentication.

Installazione dell'SDK OCI per Python

L'installazione dell'SDK OCI su un'istanza di computazione (istanza self-hosted) in genere implica l'utilizzo di un package manager o di un metodo di download e installazione diretto, a seconda del linguaggio SDK e del sistema operativo dell'istanza di computazione (auto-hosting).

  1. Scaricare e installare l'SDK per Python seguendo le istruzioni riportate nell'argomento SDK per Python. Per ulteriori indicazioni, vedere Download e installazione dell'SDK.
  2. Dopo aver installato l'SDK per Python, è necessario configurarlo utilizzando le istruzioni riportate nell'argomento Configurazione dell'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

Installazione e configurazione di Ansible

Nota: questa installazione utilizza Python versione 3.6 e Ansible versione 2.9 o successiva.

Installazione della raccolta Ansible OCI

Installare la raccolta OCI Ansible da Ansible Galaxy utilizzando il comando seguente:

\\# 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

Se la raccolta è già stata installata, è possibile aggiornare i moduli alla versione più recente aggiungendo il flag -force al comando. Ad esempio:

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

Se è necessario installare una memoria centrale ansibile nel calcolo:

\\# 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

Nota: per istruzioni dettagliate e dettagliate su come iniziare a utilizzare Ansible in Oracle Cloud Infrastructure, fare riferimento alla documentazione ufficiale di Oracle: inizio della raccolta Ansible.

Task 3: Configurazione del principal dell'istanza per accedere al segreto (IAM)

In questa sezione verranno configurate le autorizzazioni IAM necessarie per:

Accesso segreto mediante principal istanza

Utilizza i principal delle istanze per consentire all'istanza di computazione di chiamare i servizi OCI senza memorizzare o ruotare le credenziali utente. Inserendo l'istanza in un gruppo dinamico e concedendo il criterio IAM appropriato, l'istanza può leggere in modo sicuro i segreti da OCI Vault. Per utilizzare i principal delle istanze, è necessario creare un gruppo dinamico e un criterio come indicato di seguito.

Crea gruppo dinamico

I gruppi dinamici utilizzano regole per definire quali istanze sono membri del gruppo. La regola di corrispondenza può essere una regola semplice in cui si fornisce l'OCID dell'istanza di computazione utilizzata per l'interfaccia CLI. Esiste un generatore di regole che è possibile utilizzare dalla console OCI per creare la regola. Per creare un gruppo dinamico utilizzando OCI Console, consultare la documentazione qui. 

Per creare un gruppo dinamico, effettuare le operazioni riportate di seguito:

  1. Eseguire il login alla console OCI
  2. Selezionare il menu hamburger nell'angolo superiore sinistro, selezionare Identità, selezionare Gruppi dinamici e fare clic su Crea gruppo dinamico.
  3. Immettere il relativo nome e una descrizione semplice
  4. Immettere una regola di corrispondenza in modo che l'istanza sia qualificata per il gruppo dinamico

Se non si è certi di come definire la regola, è possibile utilizzare Costruzione guidata regole per facilitare la creazione della regola. Fare clic sul pulsante Costruzione guidata regola. Inserire i criteri per la regola. In questa esercitazione viene utilizzata una regola molto semplice, in cui viene specificato l'OCID dell'istanza di computazione in cui verrà eseguito il playbook Ansible.

Immettere la regola di corrispondenza e premere il pulsante Aggiungi regola. Nella schermata Crea gruppo dinamico fare clic su Pulsante Crea.

Crea criterio

Una volta creato il gruppo dinamico, è necessario creare un criterio che conceda al gruppo il privilegio di leggere i segreti nel compartimento del vault. La documentazione per la scrittura dei criteri è disponibile qui. 

Per creare un criterio, effettuare le operazioni riportate di seguito.

  1. Eseguire il login a OCI Console
  2. Selezionare il menu hamburger nell'angolo in alto a sinistra, selezionare Identità, selezionare Criteri e fare clic su Crea criterio.
    • Nome: immettere un nome.
    • Descrizione: aggiungere una descrizione. 
    • Compartimento: scegliere il compartimento

    • Istruzioni criteri: aggiungere quanto riportato di seguito.

      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>

    • Fare clic su Crea.

      Abilitazione dell'autorizzazione principal dell'istanza per il segreto OCI

      Una volta creato il gruppo dinamico, la regola di corrispondenza e il criterio, si è pronti a utilizzare i principal delle istanze per autorizzare le chiamate CLI OCI per OCI Vault/secret. Per abilitare l'autorizzazione Instance Principal dall'interfaccia CLI, è possibile utilizzare l'opzione di autorizzazione (–auth) per un comando. Ad esempio:

\\# 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

Riferimenti

Task 4: Crea runbook per eseguire il playbook Ansible

Al termine dell'installazione e della configurazione, è possibile scrivere un playbook di esempio che utilizza Ansible. Di seguito è riportato un playbook di esempio (denominato run_uptime_date_commands.yml) che esegue il comando semplice nell'istanza di computazione remota.

Creare un Ansible Playbook

\\---

\\# 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

Nota: si consiglia di mantenere il playbook autonomo e di passare tutti gli input tramite -e in modo che lo stesso runbook FAM possa eseguire host/utenti/comandi diversi senza modifiche ai file. Inoltre, si consiglia di memorizzare la chiave ssh nel vault e recuperare il segreto quando necessario.

Crea un'operazione del ciclo di vita per l'esecuzione di Ansible Playbook

Creare un'operazione del ciclo di vita personalizzata in FAM per l'esecuzione dello script di applicazione delle patch del sistema operativo DbNode, in quanto non rientra nelle categorie del ciclo di vita standard.

  1. In OCI Console, passare a Gestione applicazioni flotta > Gestione metadati > Operazioni ciclo di vita
  2. Creare una nuova operazione del ciclo di vita denominata, ad esempio Ansible_playbook_execution_operation.
  3. Specificare che utilizza un'istanza self-hosted (configurata nei passi successivi)

    Creare un runbook tramite la console OCI

    Questa esercitazione sull'esecuzione del playbook ansible con l'istanza self-hosted utilizza il runbook FAM OCI, in grado di definire come eseguire il playbook con variabili. Ad esempio, per eseguire il playbook ansible, si scrive il comando per eseguire il playbook ansible.

Per creare un runbook, effettuare le operazioni riportate di seguito.

  1. Andare a OCI Console, andare a Gestione applicazioni flotta e fare clic su Azioni e controlli.
  2. Fare clic su Runbook e Crea runbook.
  3. Immettere Nome, Descrizione, Operazione ciclo di vita, Tipo di registro e selezionare Tipo di sistema operativo e Tempo di completamento stimato.
  4. Crea il runbook utilizzando il visual designer, carica un file YAML o JSON o fai riferimento allo script di automazione esistente tramite task di script Bash o Python all'interno del runbook.
    • . Carica file (playbook yml)
  5. Fornire il comando per eseguire il playbook possibile utilizzando i task di script Bash o Python nel runbook.
  6. Dopo aver aggiunto il comando da eseguire, è necessario modificare le proprietà in istanza self-hosted e scegliere l'istanza self-hosted creata in precedenza dal task 1.
  7. Aggiungi altri task per personalizzare il runbook in base alle esigenze.

    Task 5: Playbook su esecuzione Ansible

Dopo la creazione del runbook, sei pronto per eseguire l'Ansible Playbook in OCI Fleet Application Management. Ora puoi eseguire il playbook ansible attraverso l'istanza self-hosted. Per eseguire il runbook, creare una flotta contenente l'istanza in hosting automatico.

Creare una flotta per l'istanza

Creare una flotta in FAM per gestire l'istanza self-hosted. Non è necessario aggiungere prodotti per l'esecuzione CR.

  1. Nella console OCI, andare a Gestione applicazioni flotta > Fleets.
  2. Creare una nuova flotta (ad esempio, ansible_playbook_fleet) e aggiungere l'istanza self-hosted come risorsa.
  3. Assicurarsi che la flotta si trovi nel compartimento desiderato e che sia impostata sul tipo di ambiente di produzione, se applicabile.

    Esecuzione del runbook Ansible Playbook

Attivare l'esecuzione del runbook per l'Ansible Playbook.

  1. In OCI Console, andare a Gestione applicazioni flotta > Fleets > ansible_playbook_fleet.
  2. Creare un nuovo job o una nuova esecuzione, selezionando ansible_playbook_runbook e l'operazione del ciclo di vita.
  3. Pianificare l'esecuzione o eseguirla immediatamente.
  4. Fare clic per Eseguire.
  5. Esecuzioni

    Output esecuzione

Una volta completata l'esecuzione o durante l'esecuzione, è possibile monitorare lo stato di avanzamento dell'esecuzione del playbook ansible.

Controllare i log di esecuzione in FAM per verificare che lo script sia stato eseguito correttamente.

  1. Nella console OCI, andare a Gestione applicazioni flotta > Gestione ciclo di vita > Job.
  2. Selezionare il job di esecuzione e visualizzarne i log per verificare la presenza di errori o messaggi di operazione riuscita (ad esempio, avanzamento del job di applicazione delle patch al sistema operativo).
  3. Log 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

Conferme

Altre risorse di apprendimento

Esplora altri laboratori su docs.oracle.com/learn o accedi a più contenuti di formazione gratuiti sul canale YouTube di Oracle Learning. Inoltre, visitare education.oracle.com/learning-explorer per diventare Oracle Learning Explorer.

Per la documentazione del prodotto, visitare Oracle Help Center.