Este libro sobre Ansible está dirigido a los administradores de sistemas Unix que quieran descubrir las distintas funcionalidades específicas de esta herramienta DevOps que permiten la configuración centralizada de servidores y de aplicaciones. El autor, apoyándose en ejemplos concretos, aporta al lector los conocimientos necesarios para entender el interés de su utilización.

Algunos requisitos sobre el lenguaje YAML, así como sobre el protocolo SSH, serán una ventaja para un uso eficaz de Ansible. En los primeros capítulos, el autor ayuda al lector a adquirir dichos requisitos para que pueda sacar el mayor partido posible de la lectura del libro.

Los capítulos siguientes versan sobre los diferentes mecanismos de Ansible, con una dificultad progresiva.

Los primeros mecanismos permiten administrar de manera clásica los servidores (Unix o Windows) mientras que para los siguientes se necesitan nociones más avanzadas, especialmente para la programación Python. El lector descubrirá cómo crear un inventario, cómo reinyectar información proveniente de fuentes existentes (ESX, AWS, Docker…) o cómo crear playbooks. En este libro se trata también la creación de roles Ansible, así como el uso de algunas buenas prácticas (análisis de código y test con Molecule/Docker).

Junto con algunas nociones puramente orientadas Ansible, algunos capítulos están dedicados al desarrollo de la implementación de una aplicación MediaWiki. El lector estudiará, de esta manera, los problemas de la paralelización de tareas, la introducción de un balanceo de carga Haproxy y la ejecución secuencial de las operaciones que permite realizar actualizaciones con un impacto mínimo (rolling update) en los entornos de producción. La optimización de las tareas será un punto importante para tener en cuenta en la implementación de Mitogen.

Más adelante, en el libro se detalla particularmente la personalización de Ansible. Se estudiarán la restitución de información (mecanismos de callback y de descubrimiento de ARA), la escritura de módulos para la gestión de operaciones, los filtros Jinja o incluso la creación de acciones.

Finalmente, en los últimos capítulos, el autor presentará el problema de la creación de máquinas virtuales, clásicas (usando el hipervisor ESX/VMware/vCenter) o en la nube (con AWS), el uso de contenedores Docker con Ansible, el pilotaje de aplicaciones en un clúster Kubernetes, así como la creación de un operador.

Algunos elementos complementarios pueden descargarse en el sitio web www.ediciones-eni.com.


¡Nuevo! Rondas de preguntas disponibles con la versión online.

¡Ronda de preguntas
incluida en
la versión online !

• Ponga a prueba sus conocimientos al final de cada capítulo
• Evalúe sus competencias

Descargas

• Descargar los ejemplos del libro (129 Ko)

Prefacio

1. ¿De dónde viene el término DevOps?
2. Los primeros productos DevOps
3. Público y objetivos de la obra
4. Requisitos técnicos y recursos de documentación
   1. 1. Requisitos técnicos
   2. 2. Recursos de documentación
5. Presentación general
   1. 1. Los requisitos
   2. 2. El uso de Ansible
   3. 3. La personalización de Ansible
   4. 4. Convenciones empleadas en la obra

Iniciarse en Ansible

1. Objetivos del capítulo y requisitos
   1. 1. Contexto y requisitos
   2. 2. Versión de Python
   3. 3. Entorno de trabajo
   4. 4. Archivos para descargar
2. Instalación de Ansible
   1. 1. Contexto
   2. 2. Instalación detrás de un proxy
   3. 3. Instalación a través de paquetesdel sistema
      1. a. Instalación en Debian/Ubuntu
      2. b. Instalación en RHEL, CentOS o Fedora
   4. 4. Instalación usando pip
   5. 5. Uso de los paquetes releases
   6. 6. Uso de virtualenv
   7. 7. Comprobación de la versión de Ansible
3. El protocolo SSH
   1. 1. Introducción a SSH
   2. 2. Clave pública y clave privada
   3. 3. Generación de la clave
   4. 4. Etapas de la autenticación
   5. 5. Parque de máquinas voluminoso o alojamientoen la nube
   6. 6. Intercambio de clave mediante contraseña
   7. 7. Intercambio de clave sin contraseña
   8. 8. Gestión de una passphrase con Ansible

Uso de Ansible

1. Objetivo del capítulo y requisitos
   1. 1. Contexto y requisitos
   2. 2. Archivos para descargar
2. Ansible en modo ad hoc
   1. 1. Creación de un archivo de inventario
   2. 2. Usuario no root
   3. 3. Usuario SSH diferente a root y mecanismo sudo
3. Las otras herramientas de Ansible: playbook y doc
4. Algunas nociones sobre el formato YAML
   1. 1. Declaración de variables simples
   2. 2. Las tablas en YAML
   3. 3. Las estructuras clave/valor
   4. 4. Tabla de tablas de hash
   5. 5. Inventario en formato YAML
5. Introducción a la noción de playbook
   1. 1. Estructura de un playbook
   2. 2. Ejecución de un playbook
6. Combinación con Git
   1. 1. Creación del depósito
   2. 2. Comandos básicos
      1. a. Obtención de un depósito Git
      2. b. Rama de trabajo
      3. c. Estado de su repository
      4. d. Añadir un archivo
      5. e. Modificar un archivo
      6. f. Actualización del repository remoto
      7. g. Obtención de las modificaciones remotas
   3. 3. Mecanismo de hook
      1. a. Comprobación de los playbooks con ansible-lint
      2. b. Creación de un hook pre-commit
      3. c. Test del funcionamiento del hook

Descubriendo el inventario

1. Objetivos del capítulo y requisitos
   1. 1. Contexto y requisitos
   2. 2. Archivos descargables
2. Estructura de un inventario
   1. 1. Grupos por defecto
   2. 2. Modo de conexión a las máquinas
   3. 3. Reagrupamiento de máquinas
   4. 4. Variables de inventario
   5. 5. Jerarquía de las variables
   6. 6. Gestión de los diferentes inventarios
   7. 7. Creación de grupos temporales
3. Fusión de inventarios

Inventarios: nociones avanzadas

1. Objetivos del capítulo y requisitos
   1. 1. Contexto y requisitos
   2. 2. Archivos descargables
2. Cifrado de archivos
   1. 1. Contexto
   2. 2. Almacenamiento de los nombres de usuario  paralas conexiones
   3. 3. Cifrado de un archivo entero
      1. a. Usando una contraseña
      2. b. Uso de un archivo
      3. c. Descifrado de un archivo
      4. d. Cambio de la contraseña de cifrado
   4. 4. Cifrado de un campo
3. Los inventarios dinámicos
   1. 1. Contexto
   2. 2. Máquinas AWS
      1. a. Requisitos
      2. b. Obtención del script ec2.py
      3. c. Configuración
      4. d. Test del script
   3. 3. Comunicación con Docker
      1. a. Descarga del script de inventario
      2. b. Configuración de la comunicacióncon Docker
      3. c. Test del script de inventario
      4. d. Comunicación con los contenedores Docker
      5. e. Algunas notas sobre la elección de la imagenDocker
   4. 4. Extracción de información procedentede ESX
   5. 5. Extracción de información de Nagios/Naemon/Shinken
4. Funcionamento de los plugins  de inventarios genéricos
   1. 1. Contexto
   2. 2. Conector soportado por el formato auto
   3. 3. Ejemplos de archivos de inventario en formato auto
   4. 4. Uso del comando ansible-inventory
   5. 5. Inventario de las instancias ec2
5. Escribir su propio inventario dinámico
   1. 1. Contexto
   2. 2. Formato de entrada
   3. 3. Estructura del programa
      1. a. Encabezado del programa
      2. b. Carga del archivo
      3. c. Transformación y alimentación delinventario
      4. d. Test del script de inventario
      5. e. Test del inventario dinámico con Ansible

Administración en Windows

1. Objetivos del capítulo y requisitos
   1. 1. Contexto y requisitos
   2. 2. Archivos para descargar
2. Ansible y las máquinas Windows
   1. 1. Contexto
   2. 2. Requisitos
   3. 3. Configuración de la máquina
   4. 4. Creación de un archivo de inventario
   5. 5. Test de la comunicación con Windows
   6. 6. Instalación de un paquete
3. Gestión de servicio Windows
   1. 1. Contexto
   2. 2. Instalación de Prometheus
   3. 3. Creación del playbook
   4. 4. Inicio de la instalación
   5. 5. Consulta de la consola Prometheus
4. Creación de servicio
   1. 1. Instalación de Grafana
      1. a. Presentación de Grafana
      2. b. Creación del playbook
      3. c. Inicio de la instalación
   2. 2. Creación de un servicio Windows
      1. a. Búsqueda del programa de inicio de Grafana
      2. b. Sistema de gestión de servicios NSSM
      3. c. Creación del servicio Grafana
      4. d. Playbook completo de instalación de Grafana
   3. 3. Mecanismos de emergencia
   4. 4. Consulta de la interfaz de Grafana

Funcionamiento de un playbook

1. Objetivos del capítulo y requisitos
   1. 1. Contexto y requisitos
   2. 2. Archivos descargables
2. El motor de plantillas Jinja: principio de funcionamiento
3. Plantilla Jinja
   1. 1. Mecanismo de bucle en una tabla con Jinja
   2. 2. Buscando la buena variable Ansible
   3. 3. Visualización de las interfaces de red
4. Delegación de la tarea
   1. 1. Cambio de tipo de conexión en una tarea
   2. 2. Delegación de una tarea
   3. 3. Tarea que se ejecutará solo una vez
5. Gestión de un servidor Apache
6. Reducción de operaciones que causan impacto
   1. 1. Mecanismo de los tags
      1. a. Declaración de un tag
      2. b. ¿Cómo hacer una lista de los tagsde un playbook?
      3. c. Selección o exclusión de un tag
      4. d. Gather facts y el tag always
   2. 2. Uso de una variable en una tarea
   3. 3. Uso de un handler
      1. a. ¿Por qué usar un handler?
      2. b. Declaración de un handler
      3. c. Ejemplo de ejecución

Introducción a la noción de rol

1. Objetivos del capítulo y requisitos
   1. 1. Contexto y requisitos
   2. 2. Archivos descargables
2. Introducción a los roles Ansible
   1. 1. Estructura de un rol
   2. 2. Su primer rol: instalación de Apache
   3. 3. Configuración del servidor Apache
3. Instalación de MediaWiki
   1. 1. Filtros Jinja e instalación de Apache
   2. 2. Gestión de las variables en un rol
   3. 3. Instalación de MariaDB/MySQL
   4. 4. Instalación de MediaWiki
   5. 5. Configuración de MediaWiki
      1. a. Descompresión del archivo
      2. b. Mutualización de la base MariaDB y del servidorApache (SELinux)
      3. c. Comando de configuración de MediaWiki
      4. d. Dependencias y variables que puedan faltar
      5. e. Lanzamiento de la instalación y configuraciónde MediaWiki
      6. f. Cambio de versión de PHP
      7. g. Bucle y afectación de los accesos remotoshacia la base MariaDB
4. Finalización de la instalación de MediaWiki
   1. 1. Reentrada y script shell
   2. 2. Problema de redirección

Playbooks, roles y nociones avanzadas

1. Objetivos del capítulo y requisitos
   1. 1. Contexto y requisitos
   2. 2. Archivos descargables
2. Gestión de Python en las máquinas remotas
   1. 1. Introducción
   2. 2. Preparación del inventario
   3. 3. Gestión de una máquina sin Python
   4. 4. Detección automática del intérprete
   5. 5. Posicionamiento de la ubicación del intérpretede Python
   6. 6. Python3 y Ansible
3. Escalabilidad y reparto de carga
   1. 1. Contexto
   2. 2. Origen de la necesidad
   3. 3. Incorporación de nuevos servidores Apache
   4. 4. Ejecución de una operación de manerasecuencial
4. Incorporación de un reparto de carga
   1. 1. ¿Por qué deberíamos incorporarun reparto de carga?
   2. 2. Diferencias entre Ubuntu/Debian y Centos/RedHat
   3. 3. Instalación del servidor Haproxy
      1. a. Configuración del servidor Haproxy
      2. b. Preparación del rol
5. Algunos consejos
   1. 1. Controlar la ejecución de los handlers
   2. 2. Reducir el tiempo de no disponibilidad de un servicio
6. Actualización y reentrada de script
   1. 1. Contexto
   2. 2. Gestión de la actualización de laversión del esquema
7. Actualización continua (rolling update)
   1. 1. Contexto
   2. 2. Presentación del mecanismo
   3. 3. Actualización continua en el MediaWiki
   4. 4. Desactivación de las máquinas antesde la actualización
      1. a. Configuración de Haproxy
      2. b. Desactivación de la instancia Apache antesde la actualización
      3. c. Uso de la instrucción include_role
      4. d. Demasiadas líneas en los archivos de registrode Apache
8. Inclusión y reutilización
   1. 1. Contexto
   2. 2. Inclusión estática de tareas
   3. 3. Inclusión dinámica de las tareas
   4. 4. Gestión del comportamiento de la instrucciónde bucle
      1. a. Control del nombre de la variable de bucle
      2. b. Otras palabras clave interesantes
9. Ansible Galaxy
   1. 1. Presentación del sitio
   2. 2. Búsqueda de un rol
   3. 3. Uso de un rol de Ansible Galaxy
   4. 4. Uso de un archivo de requisitos
   5. 5. ¿Cómo listar los roles de AnsibleGalaxy?
   6. 6. Eliminación de un rol
   7. 7. Colecciones Ansible
      1. a. Origen de la necesidad
      2. b. Búsqueda de colecciones
      3. c. Instalación de una colección
      4. d. Consulta de la lista de las colecciones
      5. e. Uso de una versión específica
      6. f. Uso de un archivo de dependencias
      7. g. Gestión de los datasources Grafana

Estrategia de ejecución y optimización

1. Objetivo del capítulo y requisitos
2. Estrategia de ejecución
   1. 1. Contexto
   2. 2. Gestión del número de tareas ejecutadasen paralelo
   3. 3. Estrategia de ejecución: free
3. Depurado con Ansible
   1. 1. Contexto
   2. 2. Activar el depurador
   3. 3. Consultar información
   4. 4. Modificación de un elemento
   5. 5. Ejecutar de nuevo una tarea
   6. 6. Definición de una variable
4. Estudio del funcionamiento de Ansible
   1. 1. Contexto
   2. 2. Playbook de test
   3. 3. Operaciones ejecutadas por Ansible
5. Presentación de Mitogen
   1. 1. Contexto
   2. 2. Presentación de Mitogen
   3. 3. Principio de funcionamiento de Mitogen
   4. 4. Activación de Mitogen
   5. 5. Ganancia de tiempo potencial y limitaciones

Tests en Ansible

1. Objetivos del capítulo y requisitos
2. Linter Ansible
   1. 1. Contexto
   2. 2. Ejecución del análisis
   3. 3. Reglas disponibles
   4. 4. Desactivación de las reglas
   5. 5. Creación de nuevas reglas
3. Presentación de Molecule
   1. 1. Contexto
   2. 2. Requisitos e instalación de Molecule
   3. 3. Instalación de Docker
      1. a. Instalación de Docker Community Edition enUbuntu
      2. b. Instalación alternativa
      3. c. Configuración de los accesos a Docker
      4. d. Comprobación de la instalación deDocker
4. Uso de Molecule
   1. 1. Archivo de configuración molecule.yml
   2. 2. Creación de un rol Apache
      1. a. Inicialización del rol
      2. b. Estructura del rol
      3. c. Integración del rol Apache
      4. d. Playbook de convergencia
      5. e. Comprobación de la instalación
   3. 3. Ejecución de los tests
   4. 4. Depuración del problema
      1. a. Ejecución de Molecule en modo depuración
      2. b. Conexión al contenedor de tests
   5. 5. Configuración para el funcionamiento conSystem D
      1. a. Modificación de la definición dela plataforma (campo platforms)
      2. b. Nueva ejecución de los tests
   6. 6. Gestión de escenarios de Molecule

Salida Ansible y centralización de registros

1. Objetivos del capítulo y requisitos
   1. 1. Contexto y requisitos
   2. 2. Archivos para descargar
2. Gestión del retorno estándar de Ansible
   1. 1. Contexto
   2. 2. Archivo de configuración y cowsay
   3. 3. Gestión de la coloración del resultado
3. Gestión del callback de visualización
   1. 1. Contexto
   2. 2. Algunos plugins alternativos de visualización
   3. 3. Profiling de las operaciones
4. Centralización de los registros de ejecución
   1. 1. Contexto
   2. 2. Centralización de registros usando Syslog
   3. 3. Centralización de registros usando Logstash  (Elasticsearch)
   4. 4. Centralización de llamadas gracias a Ara
      1. a. Origen de la creación de Ara
      2. b. Instalación de Ara
      3. c. Activación de Ara con Ansible
      4. d. Test de ejecución
      5. e. Ejecución del servidor de consulta Ara
5. Escritura de un callback de visualización
   1. 1. Contexto
   2. 2. Estructura del programa
   3. 3. Exposición del callback a Ansible
   4. 4. Nomenclatura de las funciones de callback
   5. 5. Ejemplo de una sobrecarga de la salida en caso deerror

Escritura de módulos

1. Objetivos del capítulo y requisitos
   1. 1. Contexto y requisitos
   2. 2. Archivos descargables
2. Mecanismo de ejecución de los módulos Python
   1. 1. Principio de funcionamiento
   2. 2. Activación de los registros de ejecución
   3. 3. Contenido del archivo temporal
   4. 4. Extracción del programa autosuficiente
3. ¿Por qué escribir un módulo?
   1. 1. Contexto
   2. 2. Consulta del esquema
4. Creación de un módulo
   1. 1. Ubicación del programa
   2. 2. Encabezado del programa
   3. 3. Especificación de los argumentos del módulo
   4. 4. Gestión de los argumentos del módulo
   5. 5. Obtención del valor de los argumentos
   6. 6. Conexión a la base
   7. 7. Transmisión del resultado a Ansible
   8. 8. Test del módulo
   9. 9. Tiempo de ejecución
   10. 10. Gestión de la ayuda
       1. a. Variable DOCUMENTATION
       2. b. Variable EXAMPLES
       3. c. Variable RETURN
       4. d. Variable ANSIBLE METADATA
       5. e. Test de visualización
   11. 11. El caso particular de los módulos facts
5. Reentrada en la creación de un esquema de base
   1. 1. Contexto
   2. 2. Limitaciones del módulo
   3. 3. Dependencias Python
   4. 4. Encabezado del módulo
   5. 5. Gestión de la base de datos
   6. 6. Python 2 y 3
   7. 7. Algoritmo del módulo
   8. 8. Creación de un playbook de test
6. Gestión de la opción diff de Ansible
   1. 1. Contexto
   2. 2. Principio de funcionamiento de diff
   3. 3. Implementación del diff
7. Gestión de la opción test (check mode)
   1. 1. Activación del check mode
   2. 2. Uso del modo check

Escritura de filtros Jinja y mecanismo de lookup

1. Objetivos del capítulo y requisitos
   1. 1. Contexto y requisitos
   2. 2. Archivos descargables
2. Los filtros Jinja
   1. 1. De vuelta a los filtros Jinja
   2. 2. Algunos ejemplos de uso de los filtros Jinja
      1. a. ¿Cómo comprobar un filtro?
      2. b. Valor por defecto
      3. c. Conversión de tipo simple
      4. d. Carga de YAML/JSON
      5. e. Gestión de las listas
      6. f. Cálculo de la suma de hash
      7. g. Combinación de la tabla de hash
3. Test de comparación de contraseñas  con grano de sal
   1. 1. Algunos detalles sobre el almacenamiento  delas contraseñas
   2. 2. Reentrada en una contraseña
   3. 3. Obtención del hash de la contraseña
   4. 4. Escritura del filtro de comparación
      1. a. Ubicación del programa
      2. b. Función de comparación de contraseñas
      3. c. Mapping Ansible
      4. d. Comprobación del filtro
   5. 5. Uso del filtro en el playbook
4. Generación de contraseña
   1. 1. Origen de la necesidad
   2. 2. Principio de funcionamiento del generador  de contraseñas
      1. a. Escritura del generador de contraseñas
   3. 3. Playbook de test
5. Obtención de información (lookup/query)
   1. 1. Principio de funcionamiento
   2. 2. Presentación de los lookups nativos de Ansible
      1. a. Lectura de los archivos: file
      2. b. Obtención del resultado de una plantilla
      3. c. Realización de una solicitud DNS: dig
   3. 3. El mecanismo de lookup y los bucles
6. Escribir su propio lookup: KeePass
   1. 1. Contexto
   2. 2. Dependencia Python
   3. 3. Obtención de la contraseña
   4. 4. Integración en Ansible
      1. a. Ubicación del archivo Python
      2. b. Exposición del objeto lookup
      3. c. Código del plugin
   5. 5. Test del plugin
      1. a. Contenido de la base KeePass y presentaciónde KeePassX
      2. b. Creación del test

Las acciones Ansible

1. Objetivos del capítulo y requisitos
   1. 1. Contexto y requisitos
   2. 2. Archivos para descargar
2. Descubriendo las acciones Ansible
   1. 1. Funcionamiento de las acciones Ansible
   2. 2. Certificados SSL con Java
   3. 3. Importación de un certificado con Ansible
3. Creación del módulo de acción java_cert
   1. 1. Ubicación del archivo de acción
   2. 2. Estructura del módulo de acciónjava_cert
   3. 3. Encabezado del módulo
   4. 4. Contenido del método run
   5. 5. Comprobación del módulo acción

Ansible: virtualización y nube

1. Objetivos del capítulo y requisitos
   1. 1. Contexto y requisitos
   2. 2. Archivos para descargar
2. Gestión de máquinas virtuales en ESX/VMware
   1. 1. Contexto y requisitos
   2. 2. Instalación de las bibliotecas necesarias
   3. 3. Características del ESX
   4. 4. Creación de la VM
   5. 5. Personalización de las máquinas
   6. 6. Gestión del inicio de la máquina
   7. 7. Supresión de la VM
3. Gestión de la nube AWS
   1. 1. Contexto
   2. 2. Configuración de los accesos a la API deAmazon
   3. 3. Creación de una instancia EC2
   4. 4. ¿Cómo etiquetar (tags) las instancias?
   5. 5. Supresión de una instancia
   6. 6. Acceso a la red de las máquinas
   7. 7. Configuración de la clave SSH
   8. 8. Modificación de la declaración dela instancia ec2

Comprobar Ansible con Docker

1. Objetivos del capítulo y requisitos
   1. 1. Contexto y requisitos
   2. 2. Archivos para descargar
2. Ansible, Docker y Systemd
   1. 1. ¿Cómo hacer convivir a Docker ySystemd?
   2. 2. Elección de las imágenes para lanzar
   3. 3. Alimentación del archivo de inventario
   4. 4. Playbook de creación de los contenedores
   5. 5. Playbook para la supresión de los contenedores
3. Las imágenes Docker
   1. 1. Presencia del intérprete de Python
   2. 2. Gestión de Docker con la ayuda de Ansible
      1. a. Introducción
      2. b. Idempotencia e inmutabilidad
      3. c. Imagen para desplegar
      4. d. Compilación de la imagen Docker
      5. e. Uso de la imagen Docker

Gestión de Kubernetes con ayuda de Ansible

1. Objetivos del capítulo y requisitos
2. Introducción a la implementación de elementos  en Kubernetes
   1. 1. Contenedores y pods
   2. 2. Mecanismos de despliegue en Kubernetes
   3. 3. Despliegue de pods en Kubernetes
      1. a. Keycloak
      2. b. Configuración de Keycloak
      3. c. Definición de un objeto StatefulSet
      4. d. Creación de una entrada de servicio
      5. e. Playbook de despliegue
      6. f. Comprobación del playbook de despliegue
   4. 4. Creación de un operador para Keycloak
      1. a. Contexto
      2. b. Instalación de los requisitos
      3. c. Inicialización del operador
      4. d. Descripción de la estructura del operador
   5. 5. Creación del operador
      1. a. Plantilla del objeto StatefulSet
      2. b. Variables por defecto
      3. c. Plantilla del objeto Service
      4. d. Creación de los objetos
3. Test del operador
   1. 1. Contexto
   2. 2. Definición del nuevo tipo de objeto
   3. 3. Instalación de los requisitos
   4. 4. Creación de un playbook de test
   5. 5. Comprobación y supresión de losobjetos de test
   6. 6. Lanzamiento del operador desde el exterior de un clúster
   7. 7. Test de creación de un objeto Keycloak
   8. 8. Comprobación de los objetos creados
4. Despliegue del operador
   1. 1. Contexto
   2. 2. Configuración del registro Docker
   3. 3. Construcción de la imagen del operador
   4. 4. Despliegue del operador
   5. 5. Comprobación de la instalación
   6. 6. Comprobación del operador
   7. 7. Registros de actividad del operador