Gestionar Variables y Hechos en RHEL con Ansible

AnsibleBeginner
Practicar Ahora

Introducción

En este laboratorio, aprenderá técnicas fundamentales para gestionar variables, facts (hechos) y secretos dentro de playbooks de Ansible en un sistema Red Hat Enterprise Linux (RHEL). Explorará cómo hacer su automatización más flexible y potente utilizando variables de playbook, recopilando información del sistema con facts de Ansible tanto integrados como personalizados, y asegurando datos sensibles como contraseñas utilizando Ansible Vault.

A través de una serie de pasos prácticos, creará un playbook para desplegar y configurar un servidor web Apache. Comenzará definiendo variables simples para el nombre del paquete y el contenido web, luego aprovechará los facts personalizados para actualizar dinámicamente la configuración del servidor web. Finalmente, utilizará Ansible Vault para crear de forma segura un nuevo usuario del sistema con una contraseña cifrada, ejecutará el playbook completo y verificará que todas las configuraciones se hayan aplicado correctamente.

Este es un Guided Lab, que proporciona instrucciones paso a paso para ayudarte a aprender y practicar. Sigue las instrucciones cuidadosamente para completar cada paso y obtener experiencia práctica. Los datos históricos muestran que este es un laboratorio de nivel intermedio con una tasa de finalización del 79%. Ha recibido una tasa de reseñas positivas del 98% por parte de los estudiantes.

Definir y Usar Variables de Playbook para Desplegar un Servidor Web Apache

En este paso, aprenderá cómo usar variables en un playbook de Ansible. Las variables son esenciales para hacer su automatización flexible, reutilizable y más fácil de leer y mantener. En lugar de codificar valores como nombres de paquetes o rutas de archivos directamente en sus tareas, puede definirlos como variables y referenciarlos en todo el playbook. Crearemos un playbook simple que utiliza variables para instalar el servidor web Apache (httpd) y desplegar una página web básica.

  1. Navegar al Directorio del Proyecto

    Primero, asegúrese de estar en el directorio de trabajo correcto. Todo su trabajo para este laboratorio se realizará dentro del directorio ~/project, que ha sido creado para usted.

    cd ~/project

    Instale el paquete ansible-core.

    sudo dnf install -y ansible-core
  2. Crear el Playbook de Ansible

    Ahora, creemos nuestro archivo de playbook. Lo llamaremos playbook.yml. Puede usar un editor de texto de línea de comandos como nano para crear y editar el archivo.

    nano playbook.yml

    Este comando abre un archivo vacío en el editor nano. Ahora, agregue la parte inicial del playbook. Esta sección define el nombre del play, el host de destino (localhost, ya que lo estamos ejecutando en la misma máquina) y una sección vars donde definiremos nuestras variables.

    ---
    - name: Deploy Apache using variables
      hosts: localhost
      become: true
      vars:
        web_pkg: httpd
        web_content: "Hello from Ansible Variables"

    Aquí hay un desglose de la estructura del playbook:

    • hosts: localhost: Especifica que el playbook debe ejecutarse en la máquina local.
    • become: true: Indica a Ansible que use la escalada de privilegios (equivalente a sudo) para las tareas, lo cual es necesario para instalar software.
    • vars: Este es un diccionario donde definimos nuestros pares clave-valor para las variables. Hemos definido web_pkg para el nombre del paquete y web_content para el contenido de nuestra página web de prueba.
  3. Agregar Tareas al Playbook

    A continuación, debajo de la sección vars, agregue las tasks que utilizarán estas variables. La primera tarea instalará el paquete Apache y la segunda creará un archivo index.html. Agregue el siguiente bloque tasks a su archivo playbook.yml mientras aún está en el editor nano.

    tasks:
      - name: Install the latest version of Apache
        ansible.builtin.dnf:
          name: "{{ web_pkg }}"
          state: latest
    
      - name: Create a basic index.html file
        ansible.builtin.copy:
          content: "{{ web_content }}"
          dest: /var/www/html/index.html

    Observe cómo usamos {{ variable_name }} para referenciar las variables que definimos anteriormente. Esto es Jinja2 templating, que Ansible utiliza para las variables. Esto hace que las definiciones de tareas sean genéricas; si quisiera instalar Nginx en su lugar, solo necesitaría cambiar la variable web_pkg, no la tarea en sí.

  4. Revisar y Guardar el Playbook

    Su archivo playbook.yml completo debería verse así ahora. Verifique el contenido y la indentación, ya que YAML es muy sensible al espaciado.

    ---
    - name: Deploy Apache using variables
      hosts: localhost
      become: true
      vars:
        web_pkg: httpd
        web_content: "Hello from Ansible Variables"
      tasks:
        - name: Install the latest version of Apache
          ansible.builtin.dnf:
            name: "{{ web_pkg }}"
            state: latest
    
        - name: Create a basic index.html file
          ansible.builtin.copy:
            content: "{{ web_content }}"
            dest: /var/www/html/index.html

    Para guardar el archivo en nano, presione Ctrl+X, luego Y para confirmar los cambios y finalmente Enter para escribir el archivo con el nombre playbook.yml.

  5. Verificar la Sintaxis del Playbook

    Antes de ejecutar un playbook, siempre es una buena práctica verificar su sintaxis en busca de errores.

    ansible-playbook --syntax-check playbook.yml

    Si la sintaxis es correcta, verá la ruta del archivo del playbook como salida, confirmando que es válido:

    playbook: playbook.yml

    Si ve algún error, vuelva a abrir el archivo con nano playbook.yml y corríjalos. Preste mucha atención a la indentación correcta (generalmente dos espacios).

  6. Ejecutar el Playbook

    Ahora, ejecute el playbook. Ansible se conectará a localhost, leerá las variables y ejecutará las tareas.

    ansible-playbook playbook.yml

    Debería ver una salida que indique la ejecución exitosa de cada tarea. El estado changed significa que Ansible realizó una modificación en el sistema, como instalar un paquete o crear un archivo.

    PLAY [Deploy Apache using variables] *******************************************
    
    TASK [Gathering Facts] *********************************************************
    ok: [localhost]
    
    TASK [Install the latest version of Apache] ************************************
    changed: [localhost]
    
    TASK [Create a basic index.html file] ******************************************
    changed: [localhost]
    
    PLAY RECAP *********************************************************************
    localhost                  : ok=3    changed=2    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

    Si ejecuta el playbook una segunda vez, las tareas deberían reportar ok en lugar de changed, porque el paquete ya está instalado y el archivo ya tiene el contenido correcto. Esto demuestra la idempotencia de Ansible.

  7. Verificar la Configuración Manualmente

    Aunque el playbook ha finalizado, puede verificar manualmente que las tareas funcionaron como se esperaba. Primero, verifique si se instaló el paquete httpd:

    rpm -q httpd

    La salida debería mostrar el nombre y la versión del paquete:

    httpd-2.4.57-7.el9.x86_64

    A continuación, verifique el contenido del archivo index.html:

    cat /var/www/html/index.html

    La salida debería coincidir con el valor de su variable web_content:

    Hello from Ansible Variables

    Ha utilizado variables con éxito en un playbook de Ansible para configurar un sistema.

Mostrar Información del Sistema usando Hechos de Ansible

En este paso, explorará los Ansible facts (hechos de Ansible). Los facts son fragmentos de información que Ansible recopila sobre los sistemas que gestiona (en este caso, localhost). Esta información incluye detalles como el sistema operativo, las interfaces de red, la memoria y mucho más. Por defecto, Ansible recopila facts al principio de cada play, haciéndolos disponibles en una variable especial llamada ansible_facts. El uso de facts le permite crear playbooks dinámicos que se adaptan al entorno en el que se ejecutan.

  1. Navegar al Directorio del Proyecto

    Primero, asegúrese de estar en el directorio ~/project donde creará el nuevo playbook.

    cd ~/project
  2. Crear un Playbook para Mostrar Todos los Facts

    Comencemos creando un playbook que simplemente muestre todos los facts que Ansible puede recopilar sobre su sistema. Esto le dará una idea de la gran cantidad de información disponible. Use nano para crear un nuevo archivo llamado display_facts.yml.

    nano display_facts.yml

    Dentro del editor nano, agregue el siguiente contenido. Este playbook apunta a localhost y utiliza el módulo ansible.builtin.debug para imprimir el contenido de la variable ansible_facts.

    ---
    - name: Display all Ansible facts
      hosts: localhost
      tasks:
        - name: Print all available facts
          ansible.builtin.debug:
            var: ansible_facts

    Guarde el archivo y salga de nano presionando Ctrl+X, luego Y y Enter.

  3. Ejecutar el Playbook

    Ahora, ejecute el playbook para ver el resultado.

    ansible-playbook display_facts.yml

    La salida será muy larga, ya que Ansible recopila muchos datos. Será una estructura JSON grande que contiene todos los detalles del sistema. Esto es lo esperado.

    PLAY [Display all Ansible facts] ***********************************************
    
    TASK [Gathering Facts] *********************************************************
    ok: [localhost]
    
    TASK [Print all available facts] ***********************************************
    ok: [localhost] => {
        "ansible_facts": {
            "ansible_all_ipv4_addresses": [
                "172.17.0.2"
            ],
            "ansible_all_ipv6_addresses": [
                "fe80::42:acff:fe11:2"
            ],
            "ansible_apparmor": {
                "status": "disabled"
            },
            "ansible_architecture": "x86_64",
            "ansible_bios_date": "01/01/2011",
            "ansible_bios_version": "1.0",
            "ansible_cmdline": {
                "BOOT_IMAGE": "/boot/vmlinuz-5.14.0-427.16.1.el9_4.x86_64",
                "root": "UUID=...",
                "ro": true
            },
            "ansible_date_time": {
                "date": "2024-05-21",
                "day": "21",
                "epoch": "1716298855",
                ...
            },
            "ansible_distribution": "RedHat",
            "ansible_distribution_major_version": "9",
            "ansible_distribution_version": "9.4",
            ...
        }
    }
    
    PLAY RECAP *********************************************************************
    localhost                  : ok=2    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
  4. Crear un Playbook para Mostrar Facts Específicos

    Mostrar todos los facts es útil para el descubrimiento, pero en la mayoría de los casos, solo necesita información específica. Creemos otro playbook, display_specific_facts.yml, para mostrar un mensaje formateado con solo algunos facts clave.

    nano display_specific_facts.yml

    Agregue el siguiente contenido. Este playbook utiliza el parámetro msg del módulo debug para imprimir una cadena personalizada. Accedemos a facts individuales usando notación de corchetes, como ansible_facts['distribution'].

    ---
    - name: Display specific Ansible facts
      hosts: localhost
      tasks:
        - name: Print a summary of system facts
          ansible.builtin.debug:
            msg: >
              The operating system is {{ ansible_facts['distribution'] }}
              version {{ ansible_facts['distribution_major_version'] }}.
              It has {{ ansible_facts['processor_cores'] }} processor cores and
              {{ ansible_facts['memtotal_mb'] }} MB of total memory.

    El carácter > en msg: > es una característica de YAML que le permite escribir una cadena de varias líneas de forma más limpia. Guarde el archivo y salga de nano.

  5. Ejecutar el Playbook para Facts Específicos

    Ahora, ejecute este nuevo playbook.

    ansible-playbook display_specific_facts.yml

    La salida será mucho más limpia y legible, mostrando solo la información que solicitó.

    PLAY [Display specific Ansible facts] ******************************************
    
    TASK [Gathering Facts] *********************************************************
    ok: [localhost]
    
    TASK [Print a summary of system facts] *****************************************
    ok: [localhost] => {
        "msg": "The operating system is RedHat version 9. It has 2 processor cores and 3925 MB of total memory."
    }
    
    PLAY RECAP *********************************************************************
    localhost                  : ok=2    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

    Esto demuestra cómo puede aprovechar los Ansible facts para que sus playbooks sean conscientes del entorno en el que se ejecutan, lo que permite una automatización más inteligente y condicional.

Configurar el Servidor Web usando Hechos Personalizados del Host Gestionado

En este paso, aprenderá a usar facts personalizados. Si bien Ansible recopila automáticamente una amplia gama de facts estándar, también puede definir los suyos propios. Estos se denominan "local facts" o "custom facts". Esta es una característica potente que le permite proporcionar información específica de un host gestionado a sus playbooks, como configuraciones de aplicaciones o datos específicos del hardware que Ansible no recopila por defecto.

Ansible busca facts personalizados en el directorio /etc/ansible/facts.d en el host gestionado. Cualquier archivo en este directorio con la extensión .fact será procesado. Estos archivos pueden ser simples archivos de texto estilo INI o archivos JSON.

  1. Crear el Directorio de Custom Facts

    Primero, necesita crear el directorio donde Ansible buscará los archivos de custom facts. Dado que este es un directorio del sistema, debe usar sudo para crearlo.

    sudo mkdir -p /etc/ansible/facts.d

    La bandera -p asegura que el comando no devuelva un error si el directorio ya existe.

  2. Crear un Archivo de Custom Fact

    Ahora, creemos un archivo de custom fact para definir un mensaje de bienvenida para nuestro servidor web. Crearemos un archivo con formato INI llamado web_config.fact dentro del directorio /etc/ansible/facts.d.

    sudo nano /etc/ansible/facts.d/web_config.fact

    Agregue el siguiente contenido al archivo. Esto define una sección [webserver] con una clave welcome_message.

    [webserver]
    welcome_message = Welcome to the server configured by Custom Facts!

    Guarde el archivo y salga de nano presionando Ctrl+X, luego Y y Enter.

  3. Crear un Playbook para Usar el Custom Fact

    Con el custom fact en su lugar, ahora podemos crear un playbook que lea este fact y lo use para configurar la página de inicio de nuestro servidor web. En su directorio ~/project, cree un nuevo playbook llamado configure_web.yml.

    cd ~/project
    nano configure_web.yml

    Agregue el siguiente contenido al playbook. Este playbook actualizará el archivo /var/www/html/index.html con el mensaje definido en nuestro custom fact.

    ---
    - name: Configure web server using custom facts
      hosts: localhost
      become: true
      tasks:
        - name: Update index.html with custom message
          ansible.builtin.copy:
            content: "{{ ansible_facts.ansible_local.web_config.webserver.welcome_message }}"
            dest: /var/www/html/index.html

    Analicemos la variable {{ ansible_facts.ansible_local.web_config.webserver.welcome_message }}:

    • ansible_facts: El diccionario raíz para todos los facts.
    • ansible_local: La clave donde se almacenan todos los custom facts.
    • web_config: El nombre de nuestro archivo de fact (web_config.fact), sin la extensión.
    • webserver: El nombre de la sección [webserver] de nuestro archivo INI.
    • welcome_message: La clave para el valor que queremos usar.

    Guarde el archivo y salga de nano.

  4. Ejecutar el Playbook de Configuración

    Ahora, ejecute el playbook para aplicar la configuración.

    ansible-playbook configure_web.yml

    La salida debería mostrar que la tarea copy ha changed el archivo index.html.

    PLAY [Configure web server using custom facts] *********************************
    
    TASK [Gathering Facts] *********************************************************
    ok: [localhost]
    
    TASK [Update index.html with custom message] ***********************************
    changed: [localhost]
    
    PLAY RECAP *********************************************************************
    localhost                  : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
  5. Verificar el Resultado

    Finalmente, verifiquemos que la página web se actualizó correctamente. Use el comando cat para ver el contenido del archivo index.html.

    cat /var/www/html/index.html

    La salida ahora debería mostrar el mensaje de su archivo de custom fact:

    Welcome to the server configured by Custom Facts!

    Ha creado con éxito un custom fact en el host gestionado y lo ha utilizado dentro de un playbook para configurar dinámicamente un servicio. Esta técnica es increíblemente útil para hacer que su automatización sea más flexible y basada en datos.

Crear un Usuario del Sistema usando Variables Cifradas con Ansible Vault

En este paso, aprenderá a gestionar datos sensibles, como contraseñas o claves de API, utilizando Ansible Vault. Almacenar información sensible en texto plano dentro de sus playbooks representa un riesgo de seguridad importante. Ansible Vault proporciona una forma de cifrar archivos o variables individuales, manteniendo sus secretos seguros. Luego puede usar estos archivos cifrados en sus playbooks, y Ansible los descifrará en tiempo de ejecución cuando proporcione la contraseña correcta.

Crearemos un archivo cifrado que contenga un nombre de usuario y una contraseña hasheada, y luego usaremos un playbook para crear un nuevo usuario del sistema con estas credenciales.

  1. Navegar al Directorio del Proyecto

    Asegúrese de estar en el directorio ~/project para esta tarea.

    cd ~/project
  2. Crear un Archivo de Vault Cifrado

    Usaremos el comando ansible-vault create para crear un nuevo archivo YAML cifrado llamado secrets.yml. Este comando le pedirá que cree una contraseña para el vault. Esta contraseña es necesaria para abrir, editar o usar el archivo más tarde.

    Primero, configuremos el editor a nano para que sea más fácil trabajar con él:

    export EDITOR=nano

    Ahora cree el archivo de vault:

    ansible-vault create secrets.yml

    Cuando se le solicite, ingrese una contraseña para su vault. Para este laboratorio, usemos labex como contraseña del vault para simplificar las cosas. Deberá ingresarla dos veces.

    New Vault password:
    Confirm New Vault password:

    Después de confirmar la contraseña, el comando abrirá el archivo secrets.yml en el editor de texto nano.

  3. Agregar Variables Secretas al Archivo de Vault

    Dentro del editor nano, que ahora está editando el archivo cifrado secrets.yml, agregue las siguientes variables. Definiremos un nombre de usuario y una contraseña pre-hasheada para un nuevo usuario. Usar una contraseña hasheada es mucho más seguro que almacenar una contraseña en texto plano.

    username: myappuser
    pwhash: $6$mysalt$QwMzWSEyCAGmz7tzVrAi5o.8k4d05i2QsfGGwmPtlJsWhGjSjCW6yFCH/OEqEsHk7GMSxqYNXu5sshxPmWyxo0
    • username: El nombre del usuario del sistema que queremos crear.
    • pwhash: Una contraseña hasheada de forma segura. Este hash específico corresponde a la contraseña AnsibleUserP@ssw0rd y está en un formato que el módulo ansible.builtin.user entiende.

    Guarde el archivo y salga de nano (Ctrl+X, luego Y, luego Enter). El archivo secrets.yml en su directorio ~/project ahora está cifrado. Si intenta verlo con cat secrets.yml, solo verá texto cifrado.

  4. Crear un Playbook para Usar el Archivo de Vault

    Ahora, cree un nuevo playbook llamado create_user.yml que utilizará las variables de su archivo cifrado secrets.yml.

    nano create_user.yml

    Agregue el siguiente contenido. La directiva vars_files le indica a Ansible que cargue variables del archivo especificado.

    ---
    - name: Create a user from secret variables
      hosts: localhost
      become: true
      vars_files:
        - secrets.yml
      tasks:
        - name: Create the {{ username }} user
          ansible.builtin.user:
            name: "{{ username }}"
            password: "{{ pwhash }}"
            state: present

    Este playbook creará un usuario con el nombre y el hash de contraseña definidos en secrets.yml. Guarde el archivo y salga de nano.

  5. Ejecutar el Playbook con la Contraseña del Vault

    Para ejecutar un playbook que utiliza un archivo de vault, debe proporcionar la contraseña del vault. Puede hacerlo interactivamente usando la bandera --ask-vault-pass.

    ansible-playbook --ask-vault-pass create_user.yml

    Ansible le pedirá la contraseña del vault. Ingrese labex (la contraseña que estableció en el paso 2).

    Vault password:

    Después de proporcionar la contraseña correcta, Ansible descifrará el archivo en memoria y ejecutará el playbook. Debería ver la siguiente salida, que indica que el usuario fue creado.

    PLAY [Create a user from secret variables] *************************************
    
    TASK [Gathering Facts] *********************************************************
    ok: [localhost]
    
    TASK [Create the myappuser user] ***********************************************
    changed: [localhost]
    
    PLAY RECAP *********************************************************************
    localhost                  : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
  6. Verificar que el Usuario fue Creado

    Puede confirmar que myappuser se creó correctamente en el sistema utilizando el comando id.

    id myappuser

    Si el usuario existe, verá su información de ID de usuario (uid) y ID de grupo (gid).

    uid=1002(myappuser) gid=1002(myappuser) groups=1002(myappuser)

    Esto confirma que ha utilizado con éxito Ansible Vault para gestionar datos sensibles para sus tareas de automatización.

Ejecutar un Playbook con un Archivo de Contraseña de Vault para Aplicar Configuraciones

En este paso, aprenderá una forma más automatizada de proporcionar la contraseña del vault a Ansible. En el paso anterior, utilizó --ask-vault-pass para ingresar la contraseña de forma interactiva. Si bien esto es seguro, no es adecuado para entornos automatizados como pipelines de CI/CD donde no hay ningún usuario presente para escribir una contraseña.

La solución es usar un archivo de contraseña de vault. Este es un archivo de texto simple que contiene la contraseña del vault. Luego puede hacer referencia a este archivo al ejecutar su playbook, y Ansible leerá la contraseña de él automáticamente. Por seguridad, es crucial restringir los permisos de este archivo de contraseña para que solo los usuarios autorizados puedan leerlo.

  1. Navegar al Directorio del Proyecto

    Asegúrese de estar en el directorio ~/project donde se encuentran su playbook y archivo de vault.

    cd ~/project
  2. Crear el Archivo de Contraseña de Vault

    Crearemos un archivo para almacenar nuestra contraseña de vault. Lo llamaremos vault_pass.txt. Podemos usar el comando echo para crear el archivo y escribir la contraseña (labex) en él en un solo paso.

    echo "labex" > vault_pass.txt

    Puede verificar el contenido del archivo con cat:

    cat vault_pass.txt

    La salida debería ser:

    labex
  3. Asegurar el Archivo de Contraseña

    Almacenar una contraseña en un archivo de texto plano es arriesgado. Debe restringir sus permisos de archivo para protegerlo. El comando chmod le permite cambiar los permisos de archivo. Estableceremos los permisos a 600, lo que significa que solo el propietario del archivo (en este caso, el usuario labex) tiene permisos de lectura y escritura. Ningún otro usuario en el sistema podrá acceder a él.

    chmod 600 vault_pass.txt

    Puede verificar los nuevos permisos usando el comando ls -l:

    ls -l vault_pass.txt

    La salida debería comenzar con -rw-------, confirmando los permisos restringidos.

    -rw-------. 1 labex labex 6 May 21 14:30 vault_pass.txt
  4. Modificar el Playbook para Agregar un Usuario a un Grupo

    Modificaremos nuestro playbook create_user.yml para realizar una acción adicional. Agregaremos myappuser al grupo wheel, que en muchos sistemas otorga privilegios administrativos (sudo). Esto demostrará la ejecución de un playbook que realiza un cambio en una configuración existente.

    Primero, abra el playbook create_user.yml para editarlo.

    nano create_user.yml

    Modifique la tarea ansible.builtin.user para incluir los parámetros groups y append.

    ---
    - name: Create a user from secret variables
      hosts: localhost
      become: true
      vars_files:
        - secrets.yml
      tasks:
        - name: Create the {{ username }} user and add to wheel group
          ansible.builtin.user:
            name: "{{ username }}"
            password: "{{ pwhash }}"
            state: present
            groups: wheel
            append: true
    • groups: wheel: Especifica el grupo al que se agregará el usuario.
    • append: true: Asegura que el usuario se agregue a este grupo sin eliminarlo de ningún otro grupo al que pueda pertenecer.

    Guarde el archivo y salga de nano.

  5. Ejecutar el Playbook con el Archivo de Contraseña de Vault

    Ahora, ejecute el playbook nuevamente. Esta vez, en lugar de --ask-vault-pass, use la opción --vault-password-file (o su alias más corto --vault-pass-file) para especificar la ruta a su archivo de contraseña.

    ansible-playbook --vault-password-file vault_pass.txt create_user.yml

    Ansible ahora se ejecutará sin solicitar una contraseña porque la lee directamente de vault_pass.txt. Debería ver una salida que indica que la configuración del usuario fue modificada.

    PLAY [Create a user from secret variables] *************************************
    
    TASK [Gathering Facts] *********************************************************
    ok: [localhost]
    
    TASK [Create the myappuser user and add to wheel group] ************************
    changed: [localhost]
    
    PLAY RECAP *********************************************************************
    localhost                  : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

    El estado changed confirma que Ansible modificó al usuario agregándolo al grupo wheel.

  6. Verificar la Pertenencia al Grupo del Usuario

    Finalmente, verifique que myappuser ahora sea miembro del grupo wheel. Puede hacerlo con el comando groups.

    groups myappuser

    La salida debería mostrar tanto el grupo principal del usuario (myappuser) como el grupo wheel.

    myappuser : myappuser wheel

    Ha utilizado con éxito un archivo de contraseña de vault para ejecutar un playbook de forma no interactiva, una habilidad clave para automatizar flujos de trabajo seguros.

Verificar la Configuración del Servidor Web y del Usuario

En este paso final, consolidará su aprendizaje creando un playbook de verificación dedicado. Hasta ahora, ha estado comprobando manualmente los resultados de sus playbooks utilizando comandos estándar de Linux como cat, id y groups. Un enfoque más potente y repetible es utilizar el propio Ansible para auditar y validar el estado de su sistema.

Este playbook actuará como un conjunto de pruebas, comprobando mediante programación que el servidor web está instalado, la página web tiene el contenido correcto y el usuario del sistema existe con la pertenencia adecuada al grupo. Esto demuestra cómo Ansible se puede utilizar no solo para la gestión de la configuración, sino también para la validación de cumplimiento y estado.

  1. Navegar al Directorio del Proyecto

    Primero, asegúrese de estar en el directorio ~/project.

    cd ~/project
  2. Crear el Playbook de Verificación

    Creemos un nuevo playbook llamado verify_config.yml. Este playbook contendrá una serie de tareas que verifican las configuraciones que aplicó en los pasos anteriores.

    nano verify_config.yml
  3. Agregar Tareas para Verificar la Configuración

    Dentro del editor nano, agregue el siguiente contenido. Construiremos este playbook con varias tareas, cada una diseñada para afirmar que una condición específica es verdadera. Si alguna aserción falla, el playbook se detendrá e informará un error, indicándole inmediatamente qué está mal.

    ---
    - name: Verify system configuration
      hosts: localhost
      become: true
      tasks:
        - name: Check if httpd package is installed
          ansible.builtin.dnf:
            list: httpd
          register: httpd_pkg_info
    
        - name: Assert that httpd is installed
          ansible.builtin.assert:
            that:
              - httpd_pkg_info.results | length > 0
            fail_msg: "Apache (httpd) package is not installed."
            success_msg: "Apache (httpd) package is installed."
    
        - name: Read the content of the index.html file
          ansible.builtin.slurp:
            src: /var/www/html/index.html
          register: index_file
    
        - name: Assert that the web page content is correct
          ansible.builtin.assert:
            that:
              - "'Custom Facts' in (index_file.content | b64decode)"
            fail_msg: "Web page content is incorrect."
            success_msg: "Web page content is correct."
    
        - name: Check if myappuser exists
          ansible.builtin.getent:
            database: passwd
            key: myappuser
          register: user_info
    
        - name: Assert that myappuser exists
          ansible.builtin.assert:
            that:
              - user_info.getent_passwd['myappuser'] is defined
            fail_msg: "User 'myappuser' does not exist."
            success_msg: "User 'myappuser' exists."
    
        - name: Assert that myappuser is in the wheel group
          ansible.builtin.assert:
            that:
              - "'wheel' in user_info.getent_passwd['myappuser'][3]"
            fail_msg: "User 'myappuser' is not in the wheel group."
            success_msg: "User 'myappuser' is in the wheel group."

    Revisemos los módulos clave utilizados aquí:

    • ansible.builtin.dnf con list: Esto verifica un paquete y register el resultado.
    • ansible.builtin.slurp: Esto "absorbe" todo el contenido de un archivo del host remoto. El contenido está codificado en base64 para un transporte seguro.
    • ansible.builtin.getent: Esta es una forma segura de consultar bases de datos del sistema como passwd y group.
    • ansible.builtin.assert: Este es el núcleo de nuestra verificación. Comprueba si una condición dada es verdadera. Si no lo es, falla la ejecución. Proporcionamos mensajes personalizados de éxito y fracaso.
    • b64decode: Este es un filtro Jinja2 utilizado para decodificar el contenido base64 que obtuvimos del módulo slurp.

    Guarde el archivo y salga de nano (Ctrl+X, Y, Enter).

  4. Ejecutar el Playbook de Verificación

    Ahora, ejecute su playbook de verificación. Dado que no utiliza ningún archivo de vault, no necesita proporcionar una contraseña.

    ansible-playbook verify_config.yml

    Si todos sus pasos anteriores se completaron correctamente, el playbook se ejecutará con éxito y verá el mensaje de éxito personalizado para cada aserción.

    PLAY [Verify system configuration] *********************************************
    
    TASK [Gathering Facts] *********************************************************
    ok: [localhost]
    
    TASK [Check if httpd package is installed] *************************************
    ok: [localhost]
    
    TASK [Assert that httpd is installed] ******************************************
    ok: [localhost] => {
        "changed": false,
        "msg": "Apache (httpd) package is installed."
    }
    
    TASK [Read the content of the index.html file] *********************************
    ok: [localhost]
    
    TASK [Assert that the web page content is correct] *****************************
    ok: [localhost] => {
        "changed": false,
        "msg": "Web page content is correct."
    }
    
    TASK [Check if myappuser exists] ***********************************************
    ok: [localhost]
    
    TASK [Assert that myappuser exists] ********************************************
    ok: [localhost] => {
        "changed": false,
        "msg": "User 'myappuser' exists."
    }
    
    TASK [Assert that myappuser is in the wheel group] *****************************
    ok: [localhost] => {
        "changed": false,
        "msg": "User 'myappuser' is in the wheel group."
    }
    
    PLAY RECAP *********************************************************************
    localhost                  : ok=9    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

    ¡Felicitaciones! Ha utilizado con éxito Ansible para definir variables, recopilar hechos del sistema, gestionar secretos con Vault y, finalmente, para verificar el estado de su sistema de forma automatizada.

Resumen

En este laboratorio, aprendió a gestionar diferentes tipos de datos dentro de playbooks de Ansible para configurar un sistema RHEL. Comenzó definiendo y utilizando variables de playbook estándar para instalar y configurar de manera flexible un servidor web Apache. Después de esto, exploró cómo aprovechar los hechos incorporados de Ansible para mostrar información del sistema, proporcionando una base para crear tareas de automatización dinámicas y conscientes del host.

Basándose en esto, configuró aún más el servidor web creando y utilizando hechos personalizados del host gestionado. Para manejar información sensible de forma segura, utilizó Ansible Vault para cifrar una contraseña de usuario, creó un nuevo usuario del sistema con esta variable cifrada y ejecutó el playbook de forma no interactiva con un archivo de contraseña de vault. El laboratorio concluyó verificando que tanto el servidor web como el nuevo usuario del sistema estaban configurados correctamente, confirmando la aplicación exitosa de todos los conceptos aprendidos.