Organización de manuales de Ansible con OCI Fleet Application Management

Introducción

Oracle Cloud Infrastructure (OCI) proporciona una completa plataforma en la nube para que los clientes gestionen su infraestructura y aplicaciones. Para mejorar aún más las capacidades de gestión, Fleet Application Management (FAM) en OCI organiza tareas operativas a escala. Como parte de esta orquestación, FAM permite a los usuarios orquestar Ansible, una popular herramienta de automatización de código abierto, para permitir a los clientes automatizar y gestionar sus recursos de OCI de manera más eficiente.

Al permitir a los usuarios orquestar Ansible con FAM, los clientes pueden utilizar las capacidades de automatización de Ansible para gestionar sus infraestructuras y pilas de aplicaciones de OCI.

En este tutorial, mostraremos cómo ejecutar el manual de Ansible a través de la instancia autoalojada con OCI Fleet Application Management (FAM). 

Nota: Estamos describiendo el proceso mediante la consola de OCI, pero también puede utilizar la API o la interfaz de línea de comandos de Oracle Cloud Infrastructure (CLI de OCI). Para obtener información sobre OCI Fleet Application Management, consulte Gestión de aplicaciones de conjunto.

Introducción a la ejecución de un Runbook de Ansible

OCI FAM utiliza el libro de ejecución para disparar un script en una instancia autoalojada, donde se ejecuta un posible manual en la instancia informática de destino. Ansible se puede integrar con los mecanismos de seguridad nativos de OCI, como OCI Vault e Instance Principals, para gestionar de forma segura secretos (como claves privadas SSH) y automatizar tareas en las instancias en la nube.

Tarea 1: Instancia autoalojada

Crear instancia informática

En primer lugar, inicie una instancia informática. Elija si desea crear una nueva instancia o seleccionar una existente y, a continuación, siga los pasos detallados a continuación.

Nota: Para obtener instrucciones detalladas paso a paso sobre cómo crear una instancia informática en Oracle Cloud Infrastructure, consulte la documentación oficial de Oracle: Creación de una instancia

Registrar instancia autoalojada en OCI Fleet Application Management

Una instancia autoalojada puede actuar como un hub central para supervisar y gestionar varios recursos. Al seleccionar una instancia como instancia autoalojada, puede realizar varias comprobaciones para asegurarse de que las instancias informáticas se ejecutan como se esperaba.

  1. Conéctese a la consola de OCI, vaya a Observability & Management y seleccione Fleet Application Management.
  2. Haga clic en Administración.
  3. En Gestión de metadatos, haga clic en Instancias autoalojadas y Crear instancia autoalojada.
  4. Introduzca la siguiente información para las instancias autoalojadas.
    • Nombre: introduzca la instancia autoalojada, evitando cualquier información confidencial, como claves, etc.
    • Compartimento: seleccione el compartimento que contiene la instancia autoalojada
    • Seleccionar instancia → Compartimento: 
    • Instancia: seleccione la instancia** en el compartimento seleccionado

Crear instancia autoalojada

Importante: Asegúrese de activar el plugin Fleet Application Management en la instancia autoalojada y su instancia asociada. Este paso garantiza que Fleet Application Management pueda considerar eficazmente estas instancias para las operaciones de ciclo de vida.

Tarea 2: Configurar instancia autoalojada

A continuación, prepare el nodo de control autoalojado instalando y validando los siguientes componentes: 

El RPM de la recopilación de Ansible instala la recopilación de Ansible de OCI y sus dependencias necesarias. Después de instalar el RPM, debe configurar el Archivo de configuración de SDK y CLI como se explica en Configuración de autenticación.

Instalación del SDK de OCI para Python

La instalación del SDK de OCI en una instancia informática (instancia autoalojada) suele implicar el uso de un gestor de paquetes o un método de instalación y descarga directa, según el lenguaje del SDK y el sistema operativo de la instancia informática (autoalojada).

  1. Descargue e instale el SDK para Python siguiendo las instrucciones del tema, SDK para Python. Para obtener más instrucciones, consulte Descarga e instalación del SDK.
  2. Después de instalar el SDK para Python, debe configurarlo a través de las instrucciones del tema Configuración del 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

Instalación y configuración de Ansible

Nota: Esta instalación utiliza Python versión 3.6 y Ansible versión 2.9 o posterior.

Instalación de la recopilación de Ansible de OCI

Instale la recopilación de Ansible de OCI desde Ansible Galaxy mediante el siguiente comando:

\\# 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 ya ha instalado la recopilación, puede actualizar sus módulos a la última versión agregando el indicador –force al comando. Por ejemplo:

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

Si necesita instalar un núcleo posible en los recursos informáticos:

\\# 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: Para obtener instrucciones detalladas paso a paso sobre cómo empezar a utilizar Ansible en Oracle Cloud Infrastructure, consulte la documentación oficial de Oracle: Introducción a la recopilación de Ansible.

Tarea 3: Configuración del principal de instancia para acceder al secreto (IAM)

En esta sección, configurará los permisos de IAM necesarios para:

Acceso secreto con principal de instancia

Utilice los principales de instancias para permitir que su instancia informática llame a los servicios de OCI sin almacenar ni rotar las credenciales de usuario. Al colocar la instancia en un grupo dinámico y otorgar la política de IAM adecuada, la instancia puede leer secretos de forma segura desde OCI Vault. Para utilizar principales de instancia, debe crear un grupo dinámico y una política como se indica a continuación.

Crear Grupo Dinámico

Los grupos dinámicos utilizan reglas para definir qué instancias son miembros del grupo. La regla de coincidencia puede ser una regla simple en la que se proporcione el OCID de la instancia informática que se utiliza para CLI. Hay un creador de reglas que puede utilizar desde la consola de OCI para realizar la regla. Para crear un grupo dinámico mediante la consola de OCI, consulte la documentación aquí. 

Para crear un grupo dinámico, realice lo siguiente:

  1. Conéctese a la consola de OCI
  2. Seleccione el menú de hamburguesa en la esquina superior izquierda, seleccione Identidad, seleccione Grupos dinámicos y haga clic en Crear grupo dinámico.
  3. Introduzca su nombre y una descripción fácil de recordar.
  4. Introduzca una regla de coincidencia para que la instancia esté cualificada para el grupo dinámico

Si no está seguro de cómo definir la regla, puede utilizar el Creador de reglas para ayudarle a crear la regla. Haga clic en el botón Creador de reglas. Introduzca los criterios para la regla. En este tutorial, estamos utilizando una regla muy sencilla, en la que especificamos el OCID de la instancia informática en la que ejecutaremos el manual de Ansible.

Introduzca la regla de paridad y pulse el botón Add Rule. En la pantalla Crear grupo dinámico, haga clic en el botón Crear.

Crear política

Una vez que haya creado el grupo dinámico, debe crear una política que otorgue a su grupo el privilegio para leer los secretos del compartimento de almacén. La documentación para escribir políticas se proporciona aquí. 

Para crear una política, haga lo siguiente:

  1. Conexión a la consola de OCI
  2. Seleccione el menú de hamburguesa en la esquina superior izquierda, seleccione Identidad, seleccione Políticas y haga clic en Crear política.
    • Nombre: introduzca un nombre
    • Description: agregue una descripción. 
    • Compartimento: seleccione el compartimento

    • Sentencias de política: agregue lo siguiente:

      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>

    • Haga clic en Crear.

      Activación de la autorización de principal de instancia para el secreto de OCI

      Una vez que haya creado el grupo dinámico, la regla de coincidencia y la política, estará listo para utilizar los principales de instancia para autorizar las llamadas de la CLI de OCI para OCI Vault/secret. Para activar la autorización de director de instancias desde la CLI, puede utilizar la opción de autorización (–auth) para un comando. Por ejemplo:

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

Referencias

Tarea 4: Crear libro de ejecución para ejecutar el manual de Ansible

Una vez finalizada la instalación y la configuración, puede escribir un cuaderno de estrategias de ejemplo que utilice Ansible. A continuación se muestra un manual de ejemplo (denominado run_uptime_date_commands.yml) que ejecuta el comando simple en la instancia informática remota.

Creación de un manual de 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

Nota: Recomendamos mantener el manual autónomo y transferir todas las entradas a través de -e para que el mismo Runbook de FAM pueda ejecutar diferentes hosts/usuarios/comandos sin editar archivos. Además, se recomienda almacenar la clave ssh en el almacén y recuperar el secreto cuando sea necesario.

Creación de una operación de ciclo de vida para la ejecución de Ansible Playbook

Cree una operación de ciclo de vida personalizada en FAM para ejecutar el script de aplicación de parches del sistema operativo DbNode, ya que no está incluida en las categorías de ciclo de vida estándar.

  1. En la consola de OCI, vaya a Gestión de aplicaciones de conjunto > Gestión de metadatos > Operaciones de ciclo de vida
  2. Cree una nueva operación de ciclo de vida denominada, por ejemplo, Ansible_playbook_execution_operation.
  3. Especificar que utiliza una instancia autoalojada (configurada en pasos posteriores)

    Crear un runbook a través de la consola de OCI

    Este tutorial de ejecución del manual ansible con la instancia autoalojada utiliza el manual de OCI FAM, que puede definir cómo ejecutar el manual con variables. Por ejemplo, para ejecutar el manual ansible, escriba el comando para ejecutar el manual ansible.

Para crear un runbook, siga estos pasos:

  1. Vaya a la consola de OCI, vaya a Gestión de aplicaciones de conjunto y haga clic en Acciones y controles.
  2. Haga clic en Libros de ejecución y Crear libro de ejecución.
  3. Introduzca Nombre, Descripción, Operación de ciclo de vida, Tipo de libro de ejecución y seleccione Tipo de sistema operativo y Tiempo de finalización estimado.
  4. Cree su libro de ejecución mediante el diseñador visual, cargue un archivo YAML o JSON o haga referencia al script de automatización existente mediante tareas de script de Bash o Python dentro del libro de ejecución.
    • . Cargar archivo (playbook yml)
  5. Proporcione el comando para ejecutar el manual ansible mediante tareas de script de Bash o Python en el manual.
  6. Después de agregar el comando que se va a ejecutar, debe cambiar las propiedades a la instancia autoalojada y seleccionar la instancia autoalojada que ha creado la tarea anterior 1.
  7. Agregue más tareas para personalizar el runbook según sea necesario.

    Tarea 5: Manual de ejecución de Ansible

Después de la creación del runbook, está listo para ejecutar el Playbook de Ansible en OCI Fleet Application Management. Ahora puede ejecutar el manual ansible a través de la instancia autoalojada. Para ejecutar el libro de ejecución, cree un conjunto que contenga la instancia autoalojada.

Crear un conjunto para la instancia

Cree un conjunto en FAM para gestionar la instancia autoalojada. No es necesario agregar productos para la ejecución de CR.

  1. En la consola de OCI, vaya a Gestión de aplicaciones de conjunto > Fleets.
  2. Cree un nuevo conjunto (por ejemplo, ansible_playbook_fleet) y agregue la instancia autoalojada como recurso.
  3. Asegúrese de que el conjunto está en el compartimento deseado y defina el tipo de entorno Production si procede.

    Ejecución del manual de estrategias de Ansible

Disparar la ejecución del runbook para el Playbook de Ansible.

  1. En la consola de OCI, vaya a Gestión de aplicaciones de conjunto > Fleets > ansible_playbook_fleet.
  2. Cree un nuevo trabajo o ejecución, seleccionando ansible_playbook_runbook y la operación de ciclo de vida.
  3. Programe la ejecución o ejecútela inmediatamente.
  4. Haga clic para ejecutar.
  5. Ejecuciones

    Salida de ejecución

Una vez finalizada la ejecución o durante la ejecución, puede supervisar el progreso de una posible ejecución de un cuaderno de estrategias.

Compruebe los logs de ejecución en FAM para verificar que el script se ha ejecutado correctamente.

  1. En la consola de OCI, vaya a Gestión de aplicaciones de conjunto > Gestión del ciclo de vida > Trabajos.
  2. Seleccione el trabajo de ejecución y vea sus logs para comprobar si hay errores o mensajes correctos (por ejemplo, progreso del trabajo de aplicación de parches del sistema operativo).
  3. Log de 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

Acuses de recibo

Más recursos de aprendizaje

Explore otros laboratorios en docs.oracle.com/learn o acceda a más contenido de aprendizaje gratuito en el canal YouTube de Oracle Learning. Además, visite education.oracle.com/learning-explorer para convertirse en un explorador de Oracle Learning.

Para obtener documentación sobre el producto, visite Oracle Help Center.