Tutorial Ansible para principiantes en Linux

Un administrador del sistema, en la gran mayoría de los casos, tiene que ocuparse de más de un servidor, por lo que a menudo tiene que realizar tareas repetitivas en todos ellos. En estos casos, la automatización es imprescindible. Ansible es un software de código abierto propiedad de Red Hat; Está escrito en la lanagua de programación de Python, y es un software de gestión de aprovisionamiento y configuración que nos ayuda en los casos antes mencionados. En este tutorial veremos cómo instalarlo y los conceptos básicos detrás de su uso.

En este tutorial aprenderás:

• Cómo instalar Ansible en las distribuciones de Linux más utilizadas
• Cómo configurar Ansible
• ¿Cuál es el inventario ansible?
• ¿Cuáles son los módulos ansibles?
• Cómo ejecutar un módulo desde la línea de comando
• Cómo crear y ejecutar un libro de jugadas

Requisitos y convenciones de software utilizados

Instalación de Ansible

El paquete Ansible está contenido en los repositorios oficiales de las distribuciones de Linux más utilizadas para que se pueda instalar fácilmente utilizando sus administradores de paquetes nativos. Para instalarlo en Debian podemos ejecutar:

$ sudo apt-get update && apt-get install ansible 

Para instalar Ansible en Fedora, en su lugar:

$ sudo dnf install ansible 

Ansible está en el repositorio de "comunidad" de Archlinux; Podemos instalarlo usando Pacman:

$ sudo Pacman -Sy Ansible 

Si queremos instalar Ansible en CentOS8, tenemos que agregar el liberación de epel fuente de software para nuestro sistema, ya que el paquete no está disponible en los repositorios predeterminados. Para hacerlo, ejecutamos el siguiente comando:

$ sudo dnf install https: // dl.federaproject.org/pub/epel/epel-liber-latest-8.noarch.rpm 

Después de eso, simplemente podemos ejecutar:

$ sudo dnf install ansible 

Para otras instrucciones de instalación específicas de distribución podemos consultar la página dedicada
de la documentación oficial ansible.

Introducir Ansible

La peculiaridad fundamental de Ansible es que es un sin agente sistema de aprovisionamiento. Esto significa que no necesitamos instalar ningún agente o demonio de software en los servidores que queremos controlar. Todo lo que necesitamos es instalar y configurar Ansible en el llamado máquina de control. El tareas Configuramos se realizará, en la gran mayoría de los casos, a través de un simple ssh conexión.

El archivo de configuración ansible

Ansible se puede configurar especificando parámetros y sus valores en uno o más archivos de configuración. La aplicación, en orden de prioridad, busca los siguientes archivos:

1. El archivo especificado a través de la variable ANSIBLE_CONFIG
2. El ansible.CFG Archivo en el directorio de trabajo actual
3. El .ansible.CFG Archivo en el directorio de inicio del usuario
4. El /etc/ansible/ansible.CFG archivo

El /etc/ansible/ansible.CFG es el último, por lo que se usa como alternativo y el valor predeterminado. Por razones obvias, este no es el lugar apropiado para describir todos los parámetros posibles que se pueden especificar en un archivo de configuración, sin embargo, aquí hay un extracto del contenido del archivo:

[predeterminados] #Algunos valores predeterminados básicos ... #inventory =/etc/ansible/hosts #library =/usr/share/my_modules/#module_utils =/usr/share/my_module_utils/#remote_tmp = ~//////#mode.ansible/tmp #local_tmp = ~/.ansible/tmp #plugin_filters_cfg =/etc/ansible/plugin_filters.yml #forks = 5 #Poll_interval = 15 #sudo_user = root #ask_sudo_pass = true #ask_pass = true #transport = smart #remote_port = 22 #module_lang = c #module_set_locale = false 

Los que están en el ejemplo son parámetros comentados que se definen con sus valores predeterminados. Entre ellos, puedes ver el inventario parámetros, que tiene el /etc/ansible/hosts valor. Veremos qué es esto en la siguiente sección.

El archivo "hosts" o "inventario"

El archivo "hosts" ansible, es donde básicamente establecemos la dirección IP o los nombres de host de las máquinas que queremos controlar con Ansible (este es el "inventario" en la jerga Ansible). En una instalación estándar, el archivo se encuentra en el /etc/ansible directorio. Dentro del archivo de inventario, los hosts pueden ser agrupado o desanimado. Podemos especificar un host por sí mismo, por ejemplo:

servidor 1 

Sin embargo, cuando queremos realizar operaciones en más de un anfitrión, es muy útil poner a los anfitriones en grupos, creados, por ejemplo, utilizando su "rol" como criterios. Suponiendo que los hosts con los que estamos tratando se usan como servidores web, podríamos escribir:

[servidor de servidor web] servidor2 

Módulos ansibles

Los módulos ansibles son básicamente pequeños programas utilizados para realizar las tareas que necesitamos; Cada uno de ellos está diseñado para realizar una sola operación básica para garantizar la granularidad. Se pueden ejecutar desde la línea de comando o dentro libros de jugadas. La lista completa de todos los módulos se puede encontrar en la página dedicada de la documentación oficial. Una vez más, aquí no podemos examinar todos los módulos, pero aquí hay algunos ejemplos.

Los módulos APT, DNF y YUM se utilizan para administrar los paquetes con los administradores de archivos. Tomen su nombre
de. El módulo Seboolean se utiliza para administrar el estado de los booleanos de Selinux, el módulo de usuario se utiliza para administrar cuentas de usuario, etc.

Uso de módulos desde la línea de comando

Como dijimos en la sección anterior, los módulos se pueden usar desde la línea de comando o desde los libros de jugadas. Nos centraremos en este último en la siguiente sección; Aquí demostraremos cómo usar un módulo desde la línea de comandos, con el ansible dominio. En este ejemplo usaremos el silbido módulo. Este módulo no tiene nada que ver con el comando ping, pero se usa para verificar que podamos iniciar sesión en los servidores remotos, y que un intérprete de python está instalado en ellos. El módulo devuelve el valor "pong" sobre el éxito:

$ Ansible Webservers -M ping --Sk -Pass 

Invocamos el comando Ansible que especifica que queremos ejecutar la tarea en los miembros de los hosts del grupo "WebServers" y con el -metro Opción Pasamos el nombre del módulo que queremos usar. También usamos el --pasaje de solicitud Opción, por qué? Aunque anteriormente agregué la huella digital de los servidores remotos al archivo de "hosts conocidos" de la máquina de control SSH, no configuré el acceso SSH a través de la clave pública, por lo que se debe proporcionar una contraseña SSH cuando ejecutamos una tarea. El --pasaje de solicitud La opción hace para que la contraseña se solicite de manera interactiva. Aquí está la salida del comando
arriba:

Contraseña SSH: servidor2 | Succes => "ansible_facts": "descubrido_interpreter_python": "/usr/bin/python", "cambiado": falso, "ping": "pong" servidor1 | Éxito => "ansible_facts": "descubrido_interpreter_python": "/usr/bin/python", "cambiado": falso, "ping": "pong" 

Ansible Playbooks

¿Qué es un libro de jugadas?? Los libros de jugadas de Ansible no son otros archivos YAML donde especificamos las tareas que queremos realizar usando Ansible, y los hosts en los que deben realizarse. Veamos un ejemplo de libro de jugadas. En el siguiente archivo configuramos una tarea para asegurar que el editor de texto VIM esté instalado y a la última versión disponible:

--- - Nombre: Actualizar WebServers Hosts: WebServers Remote_user: EGDOC Conviértete: Sí Tareas: - Nombre: Asegúrese de que VIM esté instalado y en la última versión DNF: Nombre: Estado VIM: Último .. 

Analicemos lo anterior. El --- y … Podemos ver, respectivamente al principio y al final del archivo, son parte de la sintaxis YAML estándar: son opcional y marque el comienzo y el final del archivo. Las instrucciones y sus valores se representan en un formato de diccionario, como valor clave pares.

Un libro de jugadas puede contener múltiples llamados obras de teatro; En este caso acabamos de definir uno. De hecho, lo primero que hicimos fue especificar su nombre, ¿Cuál es en este ejemplo "Actualizar servidores web"?. La segunda clave que usamos es Hospedadores: Con él podemos definir el grupo de host en que las tareas deben realizarse. En este caso especificamos servidores web como valor, que comprende las máquinas que definimos en los ejemplos anteriores (Server1 y Server2).

La siguiente clave que usamos fue Remote_User. Con él, podemos especificar cuál es el usuario que debemos iniciar sesión como, a través de SSH, en los servidores remotos. Después de eso, usamos el convertirse llave. Esta clave acepta un valor booleano y con él especificamos si
escalada de privilegios debe usarse para realizar las tareas o no. En este caso, dado que iniciamos sesión en las máquinas remotas utilizando el usuario "EGDOC", y necesitamos privilegios raíz para instalar un paquete, lo configuramos en Sí. Es importante notar
que la escalada de privilegios se configura en el /etc/ansible/ansible.CFG archivo de configuración, en la sección dedicada. En este caso, los valores predeterminados son los siguientes:

[Privilege_escalation] #convertirse = true #convertirse en_method = sudo #convertirse en_user = root #convertirse_ask_pass = falso 

Después de definir el jugar información, comenzamos a especificar nuestra lista de tareas. Para hacerlo usamos el tareas palabra clave. Cada tarea tiene un nombre que se utiliza para la documentación y en los manejadores de tareas.

Con DNF: Especificamos que queremos usar el módulo "DNF", que, como vimos antes, se utiliza para administrar paquetes utilizando el Administrador de paquetes predeterminado en la familia de distribuciones Red Hat. Dentro de esta sección, con el nombre palabra clave
Especificamos el nombre de los paquetes. En este ejemplo, solo estamos interesados ​​en un solo paquete, pero se pueden especificar múltiples paquetes utilizando una lista. Por ejemplo:

DNF: Nombre: [Vim, Nano] 

Con el estado Palabra clave del DNF Módulo Básicamente especificamos lo que queremos hacer con los paquetes especificados. En este caso usamos el último Como el valor: con él, nos aseguramos de que el paquete esté instalado y a la última versión disponible en la distribución utilizada en la máquina remota. Otros valores posibles que podemos usar son eliminar o ausente, lo que hace que los paquetes no estén desinstalados, o presente que solo aseguran que el paquete está instalado. Le recomiendo que verifique la documentación del módulo oficial para la lista completa de claves y valores que se pueden usar con el módulo.

Aquí vamos, acabamos de definir nuestro primer libro de jugadas. ¿Cómo podemos ejecutarlo??

Ejecutando un libro de jugadas

Para ejecutar un libro de jugadas usamos el dedicado Ansible-Playbook dominio. El comando acepta una serie de opciones y toma uno o más archivos de Playbook como argumentos. Para ejecutar el libro de jugadas que definimos en la sección anterior, por ejemplo, ejecutaríamos el siguiente comando:

$ Ansible-playbook --ask-pass --- ask-become-pass/rath/to/playbook.YML 

Puede notar que en este caso invocamos el comando con el --aservador opción. Esta opción es necesaria porque en el archivo del libro de jugadas asignamos el Sí valor para el convertirse clave, ya que necesitamos una escalada de privilegios para instalar paquetes en las máquinas remotas. El --aservador La opción hace para que el sudo Se pregunta la contraseña cuando ejecutamos el libro de jugadas. En este caso, ya que también usamos --pasaje de solicitud, La contraseña SSH se utilizará como la contraseña predeterminada para la escalada de privilegios. Aquí está el resultado que recibimos cuando ejecutamos el libro de jugadas:

Contraseña SSH: Conviértase en contraseña [predeterminada a la contraseña SSH]: reproducir [actualizar servidores web] ************************************** ************************************************************ ************************************************************ ****** Tarea [Reuniendo hechos] ****************************************** ************************************************************ ************************************************************ ** OK: [Server1] OK: [Server2] Tarea [Asegúrese de que VIM esté instalado en la última versión] **************************** ************************************************************ ********************************** Cambiado: [Server1] Cambiado: [Server2] Reproducir recapitulación **** ************************************************************ ************************************************************ ************************************************* servidor 1 : ok = 2 cambiado = 1 inundable = 0 fallido = 0 omitir = 0 rescued = 0 ignored = 0 servidor2:OK = 2 cambiado = 1 inesperable = 0 fallido = 0 omitido = 0 rescatado = 0 ignorado = 0 

Primero se nos pide que proporcionemos la contraseña de "ssh", luego la "convertirse". Como ya dijimos, la contraseña SSH se utilizará como el valor predeterminado en este caso. Como puede ver antes de la tarea que especificamos en el libro de jugadas, otra tarea es ejecutar: "Recopilar hechos". Esta tarea se ejecuta de forma predeterminada para recopilar variables útiles sobre hosts remotos que se pueden usar en los libros de jugadas.

Después de ejecutar las tareas, obtenemos un resumen de las jugadas que especificamos. En este caso podemos ver, que se han ejecutado dos tareas correctamente (OK = 2) y una tarea ha causado un cambio (cambiado = 1). Esto tiene sentido: el cambio ocurrió desde que se ha instalado el paquete VIM.

Ahora, si intentamos volver a ejecutar el libro de jugadas, podemos ver que no ocurren cambios, ya que VIM ya está instalado y en la última versión disponible:

Reproducir recapitulación *********************************************************************************************** ************************************************************ ************************************************************ ***** servidor1: OK = 2 cambiado = 0 inuxilable = 0 fallido = 0 omitido = 0 rescued = 0 ignored = 0 servidor2: ok = 2 cambiado = 0 inhantee = 0 fallado = 0 omitir = 0 rescatado = 0 ignored = 0 

Conclusiones

En este tutorial aprendimos qué es Ansible y cuáles son sus peculiaridades. Vimos cómo instalarlo en algunas de las distribuciones de Linux más utilizadas, cómo configurarlo y algunos conceptos básicos: qué es un inventario y cuáles son los
Módulos ansibles. También vimos cómo ejecutar un módulo desde la línea de comandos y cómo escribir y ejecutar un libro de jugadas. Esto se entendía solo como una introducción al mundo ansible; ensuciarse las manos, experimentar y leer la documentación oficial para un conocimiento más profundo!

Tutoriales de Linux relacionados:

• Una introducción a la automatización, herramientas y técnicas de Linux
• Cosas para instalar en Ubuntu 20.04
• Mastering Bash Script Loops
• Cosas para instalar en Ubuntu 22.04
• Cosas que hacer después de instalar Ubuntu 20.04 fossa focal Linux
• Mint 20: Mejor que Ubuntu y Microsoft Windows?
• Ubuntu 20.04 Guía
• Bucles anidados en guiones Bash
• ¿Con qué frecuencia tiene que reiniciar su servidor de Linux??
• Sistema colgado de Linux? Cómo escapar a la línea de comando y ..