LabEx
EntrarÚnete

Implementar un Playbook de Ansible en RHEL

AnsibleBeginner
Practicar Ahora

Introducción

En este laboratorio, aprenderá a implementar un playbook completo de Ansible para desplegar un servidor web Apache en un sistema Red Hat Enterprise Linux (RHEL). Comenzará configurando los componentes fundamentales de un proyecto Ansible, lo que incluye la creación de un archivo de inventario estático para definir sus nodos administrados y la configuración del entorno local de Ansible utilizando un archivo ansible.cfg.

Tras la configuración inicial, escribirá un playbook de múltiples tareas para automatizar el proceso de despliegue principal. Esto implica instalar e iniciar el servicio Apache, desplegar una página web personalizada y configurar el firewall del sistema para permitir el tráfico HTTP. Para completar el laboratorio, agregará una segunda "play" a su playbook que probará el servidor web desde la línea de comandos, verificando que todo el despliegue se realizó con éxito.

Crear un Archivo de Inventario Estático para Servidores Web

En este paso, aprenderá los fundamentos de un inventario de Ansible. Un inventario es un archivo de texto que lista los servidores (o "nodos administrados") que Ansible gestionará. Creará un archivo de inventario estático simple para un grupo de servidores web y aprenderá a verificar su contenido.

Primero, necesita asegurarse de que Ansible esté instalado en su sistema. Dado que no está instalado por defecto, utilizará el gestor de paquetes dnf para instalarlo.

  1. Abra su terminal e instale el paquete ansible-core, que proporciona las herramientas fundamentales de línea de comandos de Ansible.

    sudo dnf install -y ansible-core

    Debería ver una salida que indica que el paquete se está instalando y verificando.

    ...
Installed:
  ansible-core-2.16.x-x.el9.x86_64
...
Complete!

  2. Para una mejor organización, cree un directorio dedicado para este proyecto dentro de su directorio de inicio. Llamémoslo ansible-lab.

    mkdir -p ~/project/ansible-lab

  3. Navegue a su directorio de proyecto recién creado. Todo el trabajo posterior en este laboratorio se realizará desde esta ubicación.

    cd ~/project/ansible-lab

  4. Ahora, creará su primer archivo de inventario. Un archivo de inventario se escribe típicamente en un formato similar a INI. Utilizará el editor de texto nano para crear un archivo llamado inventory.

    nano inventory

  5. Dentro del editor nano, agregue el siguiente contenido. Esta configuración define un grupo llamado [webservers] y agrega su máquina local, localhost, a este grupo.

    • [webservers] es un nombre de grupo. Los grupos se utilizan para apuntar a varios hosts con un solo comando.
    • localhost es el nombre de host de la máquina que desea administrar. En este caso, es la propia VM de LabEx.
    • ansible_connection=local es una variable especial que le indica a Ansible que ejecute comandos directamente en el nodo de control (su VM) en lugar de intentar conectarse a través de SSH.
    [webservers]
localhost ansible_connection=local

    Para guardar el archivo en nano, presione Ctrl+O, luego Enter para confirmar el nombre del archivo y Ctrl+X para salir del editor.

  6. Con su archivo de inventario creado, puede usar el comando ansible-inventory para analizar el archivo y mostrar una lista de los hosts que contiene. La bandera -i especifica la ruta a su archivo de inventario.

    ansible-inventory --list -i inventory

    El comando generará una representación con formato JSON de su inventario, lo que confirma que Ansible puede leer y comprender su archivo correctamente.

    {
  "_meta": {
    "hostvars": {
      "localhost": {
        "ansible_connection": "local"
      }
    }
  },
  "all": {
    "children": ["ungrouped", "webservers"]
  },
  "webservers": {
    "hosts": ["localhost"]
  }
}

Ha creado con éxito un archivo de inventario estático básico y ha verificado que Ansible puede interpretarlo correctamente. Este archivo de inventario será la base de los playbooks que escribirá en los siguientes pasos.

Configurar el Entorno de Ansible con ansible.cfg

En este paso, creará un archivo de configuración de Ansible, ansible.cfg. Este archivo le permite establecer comportamientos predeterminados para Ansible, ahorrándole la necesidad de escribir opciones comunes en la línea de comandos repetidamente. Al colocar un archivo ansible.cfg en su directorio de proyecto, puede definir configuraciones como la ruta predeterminada del archivo de inventario, que Ansible utilizará automáticamente cuando se ejecute desde ese directorio.

Debería seguir estando en el directorio ~/project/ansible-lab del paso anterior.

  1. Utilice el editor de texto nano para crear un nuevo archivo llamado ansible.cfg en su directorio actual (~/project/ansible-lab).

    nano ansible.cfg

  2. Dentro del editor nano, agregue el siguiente contenido. Esta configuración le indica a Ansible dónde encontrar su archivo de inventario predeterminado.

    • La sección [defaults] es una parte estándar del archivo ansible.cfg donde define la mayoría de las configuraciones predeterminadas.
    • La línea inventory = ./inventory establece el inventario predeterminado en el archivo inventory ubicado en el directorio actual (.).
    [defaults]
inventory = ./inventory

    Guarde el archivo presionando Ctrl+O, luego Enter, y salga con Ctrl+X.

  3. Ahora que ha configurado la ruta del inventario predeterminado, ya no necesita usar la bandera -i con sus comandos de Ansible (siempre que se encuentre en el directorio ~/project/ansible-lab).

    Para probar esto, ejecute nuevamente el comando ansible-inventory --list, pero esta vez, omita la parte -i inventory.

    ansible-inventory --list

    Debería ver la misma salida JSON exacta que en el paso anterior, lo que confirma que Ansible está encontrando y utilizando automáticamente su archivo inventory gracias a la nueva configuración ansible.cfg.

    {
  "_meta": {
    "hostvars": {
      "localhost": {
        "ansible_connection": "local"
      }
    }
  },
  "all": {
    "children": ["ungrouped", "webservers"]
  },
  "webservers": {
    "hosts": ["localhost"]
  }
}

Al crear un ansible.cfg específico del proyecto, ha hecho que su flujo de trabajo sea más eficiente. Esta es una práctica común en los proyectos de Ansible para garantizar un comportamiento consistente y reducir la complejidad de la línea de comandos.

Escribir un Playbook para Instalar y Arrancar el Servicio Apache

En este paso, escribirá su primer Ansible Playbook. Un playbook es un archivo escrito en formato YAML que describe un conjunto de tareas a ejecutar en sus hosts administrados. Creará un playbook que instala el servidor web Apache (httpd) y levanta su servicio en la máquina localhost definida en su inventario.

Debería seguir estando en el directorio ~/project/ansible-lab.

  1. Primero, utilice el editor de texto nano para crear un nuevo archivo llamado apache.yml. Este archivo contendrá su playbook.

    nano apache.yml

  2. Dentro del editor nano, definirá un "play". Un play es la unidad central de un playbook y mapea un grupo de hosts a un conjunto de tareas. Agregue el siguiente contenido a apache.yml.

    • ---: Este es un marcador estándar de YAML que indica el inicio de un documento.
    • - name: ...: Este es el comienzo de su play. Darle un nombre descriptivo es una buena práctica.
    • hosts: webservers: Esto le dice a Ansible que ejecute este play en todos los hosts del grupo webservers de su archivo de inventario.
    • become: true: Esto instruye a Ansible a usar la escalada de privilegios (como sudo) para ejecutar las tareas. Esto es necesario para acciones como instalar software o administrar servicios.
    • tasks:: Esta palabra clave inicia la lista de tareas a realizar.
    ---
- name: Install and start Apache web server
  hosts: webservers
  become: true
  tasks:

  3. Ahora, agregue las tareas a su playbook. Cada tarea es una acción única que llama a un módulo de Ansible. La indentación es crítica en YAML, así que asegúrese de que las tareas estén correctamente indentadas debajo de la sección tasks:.

    • Tarea 1: Instalar httpd. Esta tarea utiliza el módulo ansible.builtin.dnf para asegurar que el paquete httpd esté instalado. El parámetro state: present significa que Ansible instalará el paquete si falta, y no hará nada si ya está instalado.
    • Tarea 2: Levantar el servicio httpd. Esta tarea utiliza el módulo ansible.builtin.service. state: started asegura que el servicio esté en ejecución, y enabled: true asegura que se iniciará automáticamente al arrancar el sistema.

    Agregue las siguientes tareas a su archivo apache.yml, directamente debajo de la línea tasks::

    - name: Install httpd package
  ansible.builtin.dnf:
    name: httpd
    state: present

- name: Start and enable httpd service
  ansible.builtin.service:
    name: httpd
    state: started
    enabled: true

  4. Su playbook apache.yml completo debería verse ahora así. Verifique cuidadosamente la indentación.

    ---
- name: Install and start Apache web server
  hosts: webservers
  become: true
  tasks:
    - name: Install httpd package
      ansible.builtin.dnf:
        name: httpd
        state: present

    - name: Start and enable httpd service
      ansible.builtin.service:
        name: httpd
        state: started
        enabled: true

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

  5. Antes de ejecutar su playbook, es una buena práctica verificar su sintaxis usando el comando ansible-playbook con la bandera --syntax-check.

    ansible-playbook --syntax-check apache.yml

    Si la sintaxis es correcta, el comando imprimirá el nombre del archivo del playbook sin errores.

    playbook: apache.yml

  6. Ahora, ejecute el playbook.

    ansible-playbook apache.yml

    Ansible ejecutará las tareas. Dado que esta es la primera ejecución, verá el estado changed para ambas tareas, lo que indica que el estado del sistema fue modificado.

    PLAY [Install and start Apache web server] *************************************

TASK [Gathering Facts] *********************************************************
ok: [localhost]

TASK [Install httpd package] ***************************************************
changed: [localhost]

TASK [Start and enable httpd service] ******************************************
changed: [localhost]

PLAY RECAP *********************************************************************
localhost                  : ok=3    changed=2    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

  7. Finalmente, verifique que el servidor web Apache esté en ejecución usando curl para solicitar la página web predeterminada desde localhost.

    curl http://localhost

    Debería ver la Página de Prueba Predeterminada de Apache, lo que confirma que su playbook funcionó correctamente.

    <html>
  <head>
    <title>Test Page</title>
  </head>
  <body>
    <h1>Test Page</h1>
    <p>This is the default test page for the Apache HTTP server.</p>
  </body>
</html>

Añadir Tareas para Desplegar una Página Web

En este paso, ampliará su playbook para realizar una configuración de servidor web más realista. Agregará una tarea para desplegar una página index.html personalizada. Esto demuestra cómo administrar archivos utilizando los módulos de administración de archivos de Ansible.

Debería seguir estando en el directorio ~/project/ansible-lab.

  1. Primero, cree un archivo HTML simple que su playbook desplegará. Use nano para crear un archivo llamado index.html en su directorio actual.

    nano index.html

  2. Agregue el siguiente contenido HTML al archivo. Este será el contenido de su página web personalizada.

    <h1>Welcome to the Ansible-managed Web Server!</h1>
<p>This page was deployed using an Ansible Playbook.</p>

    Guarde y salga de nano (Ctrl+O, Enter, Ctrl+X).

  3. Ahora, actualizará su playbook apache.yml para agregar la nueva tarea. Para evitar errores de formato YAML, se recomienda recrear el archivo con el contenido completo.

    Importante: Para asegurar el formato YAML correcto y evitar errores de indentación, elimine el archivo apache.yml existente y cree uno nuevo con el contenido completo que se muestra a continuación.

    rm apache.yml
nano apache.yml

  4. Agregará una nueva tarea al playbook. Esta tarea copiará el archivo index.html a la raíz del documento del servidor web (/var/www/html/).

    • Tarea: Desplegar index.html. Esta tarea utiliza el módulo ansible.builtin.copy. src especifica el archivo de origen en el nodo de control (index.html), y dest especifica la ruta de destino en el host administrado.

  5. Copie y pegue el contenido completo del playbook apache.yml a continuación. Esto asegura el formato y la indentación YAML correctos.

    ---
- name: Install and start Apache web server
  hosts: webservers
  become: true
  tasks:
    - name: Install httpd package
      ansible.builtin.dnf:
        name: httpd
        state: present

    - name: Deploy custom index.html
      ansible.builtin.copy:
        src: index.html
        dest: /var/www/html/index.html

    - name: Start and enable httpd service
      ansible.builtin.service:
        name: httpd
        state: started
        enabled: true

    Guarde y salga de nano.

  6. Guarde el archivo y salga de nano (Ctrl+O, Enter, Ctrl+X), luego ejecute el playbook actualizado.

    ansible-playbook apache.yml

    Esta vez, debería ver la nueva tarea ejecutándose. Las tareas "Install httpd" y "Start httpd" deberían reportar ok porque su estado deseado ya se ha cumplido. La tarea "Deploy custom index.html" reportará changed.

    PLAY [Install and start Apache web server] *************************************

TASK [Gathering Facts] *********************************************************
ok: [localhost]

TASK [Install httpd package] ***************************************************
ok: [localhost]

TASK [Deploy custom index.html] ************************************************
changed: [localhost]

TASK [Start and enable httpd service] ******************************************
ok: [localhost]

PLAY RECAP *********************************************************************
localhost                  : ok=4    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

  7. Finalmente, use curl nuevamente para verificar que su página web personalizada ahora se está sirviendo.

    curl http://localhost

    La salida ahora debería ser el contenido de su archivo index.html.

    <h1>Welcome to the Ansible-managed Web Server!</h1>
<p>This page was deployed using an Ansible Playbook.</p>

Implementar un Segundo Play para Probar el Despliegue del Servidor Web

En este paso final, agregará un segundo play a su playbook. Un único archivo de playbook puede contener múltiples plays, que se ejecutan secuencialmente. Esto es útil para organizar tareas que se dirigen a diferentes hosts o tienen diferentes propósitos. Agregará un nuevo play que se ejecutará solo en el nodo de control (localhost) para probar el servidor web que se configuró en el primer play.

Debería seguir estando en el directorio ~/project/ansible-lab.

  1. Ahora agregará un segundo play a su playbook. Para asegurar el formato YAML correcto al agregar el segundo play, se recomienda recrear el archivo con el contenido completo.

    Importante: Para evitar errores de indentación YAML al agregar el segundo play, elimine el archivo apache.yml existente y cree uno nuevo con el contenido completo de dos plays que se muestra a continuación.

    rm apache.yml
nano apache.yml

  2. Agregará un segundo play al playbook. Un segundo play le permite organizar tareas que se dirigen a diferentes hosts o tienen diferentes propósitos.

    • name: Test web server: Un nombre descriptivo para el nuevo play.
    • hosts: localhost: Este play se ejecutará en localhost, el propio nodo de control.
    • become: false: Esta prueba no requiere privilegios de root, por lo que deshabilitamos explícitamente la escalada de privilegios.
    • Tarea: Verificar contenido web. Esta tarea utiliza el módulo ansible.builtin.uri para realizar una solicitud HTTP al servidor web. Comprueba que el servidor devuelve un código de estado 200 (OK) y que el contenido devuelto contiene la cadena "Ansible-managed". Esto automatiza la verificación con curl y grep que ha estado haciendo manualmente.

  3. Copie y pegue el contenido completo del playbook apache.yml a continuación, que ahora incluye ambos plays:

    ---
- name: Install and start Apache web server
  hosts: webservers
  become: true
  tasks:
    - name: Install httpd package
      ansible.builtin.dnf:
        name: httpd
        state: present

    - name: Deploy custom index.html
      ansible.builtin.copy:
        src: index.html
        dest: /var/www/html/index.html

    - name: Start and enable httpd service
      ansible.builtin.service:
        name: httpd
        state: started
        enabled: true

- name: Test web server from localhost
  hosts: localhost
  become: false
  tasks:
    - name: Verify web server is serving correct content
      ansible.builtin.uri:
        url: http://localhost
        return_content: yes
        status_code: 200
      register: result
      failed_when: "'Ansible-managed' not in result.content"

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

  4. Ejecute el playbook completo. Ansible ejecutará el primer play, encontrará que todas las tareas ya están en su estado deseado (ok), y luego procederá al segundo play para ejecutar la prueba.

    ansible-playbook apache.yml

    La salida mostrará ambos plays ejecutándose. Todas las tareas deberían completarse con éxito con un estado ok.

    PLAY [Install and start Apache web server] *************************************

TASK [Gathering Facts] *********************************************************
ok: [localhost]

TASK [Install httpd package] ***************************************************
ok: [localhost]

TASK [Deploy custom index.html] ************************************************
ok: [localhost]

TASK [Start and enable httpd service] ******************************************
ok: [localhost]

PLAY [Test web server from localhost] ******************************************

TASK [Gathering Facts] *********************************************************
ok: [localhost]

TASK [Verify web server is serving correct content] ****************************
ok: [localhost]

PLAY RECAP *********************************************************************
localhost                  : ok=6    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Al agregar un segundo play, ha creado un flujo de trabajo de automatización más robusto que no solo configura un servicio, sino que también incluye una prueba integrada para verificar que el despliegue fue exitoso.

Resumen

En este laboratorio, aprendió a preparar un entorno RHEL para la automatización con Ansible instalando el paquete ansible-core y estructurando un directorio de proyecto. Creó un archivo de inventario estático fundamental para definir un grupo de nodos administrados, especificando localhost con una conexión local. También configuró el entorno de Ansible utilizando un archivo ansible.cfg para apuntar a su inventario personalizado, estableciendo un espacio de trabajo limpio y organizado para ejecutar playbooks.

Luego, redactó un playbook de Ansible completo para automatizar el despliegue de un servidor web Apache. Esto implicó escribir tareas para instalar el paquete httpd utilizando el módulo ansible.builtin.dnf y para asegurar que el servicio se iniciara y habilitara con el módulo ansible.builtin.service. El playbook se mejoró para desplegar una página web index.html personalizada utilizando el módulo ansible.builtin.copy. Finalmente, implementó un segundo play dentro del mismo playbook para validar el despliegue, utilizando el módulo ansible.builtin.uri para probar la conectividad con el servidor web recién desplegado, demostrando un flujo de trabajo completo de configuración y verificación.

Relacionado Ansible Cursos
Laboratorios de Certificación de Automatización de Red Hat Enterprise Linux con Ansible (RH294)

Laboratorios de Certificación de Automatización de Red Hat Enterprise Linux con Ansible (RH294)

rhelansiblelinux
Ansible para Principiantes

Ansible para Principiantes

ansibledevopslinux