Transcripciones
1. INTRODUCCIÓN AL CURSO: Ahora, para nuestro primer video, me gustaría darles una
cálida bienvenida al curso. Durante este curso,
descubrirás casi todo sobre
Ansible y no sólo eso, sino que también
podrás ponerlo
a buen uso en la automatización tanto de tareas de seguridad como comunes tareas de
administración del sistema. Pero antes de que hagamos todo eso, déjame contarte un
poco de mí mismo. Mi nombre es Andre balance. Soy ingeniero Alexa y
tienen una experiencia docente de
más de ocho años trabajando con grandes organizaciones de toda
Europa como formadora. Tengo experiencia tanto
en trabajar con Red Hat Enterprise
Linux como con Ansible enfocándose en Administración de
Sistemas
y Automatización. También tengo los certificados
para respaldar esto. Ya soy ingeniero certificado desde un punto de vista de seguridad, I Income Security Plus certificado n milla a CISO certificado. Por lo que cubro tanto la seguridad
como la automatización usando Ansible. Soy un ajuste perfecto para ser tu entrenador para este curso
en particular. En primer lugar, estaremos
mirando y qué es Ansible y cómo
podemos instalarlo. Estaremos mirando
cuáles son los playbooks de Ansible y también cómo crear
playbooks y gestionarlos. Después de tener una
comprensión de línea de base de los playbooks, debemos estar
mirando variables y bucles y cómo usar variables, bucles y condicionales
dentro de playbook. Entonces veremos formas
en que podemos reducir la complejidad de los playbooks
a través de la modularidad. Después,
veremos los roles de Ansible, cuáles son, cómo
podemos conseguirlos, y cómo podemos usarlos? Entonces, antes de
terminar el curso, deberíamos estar
mirando formas en que
podemos automatizar las tareas de
administración,
tanto las tareas comunes de
administración del sistema como las tareas
relacionadas con la seguridad. Por lo que ahora que tenemos
una buena visión general de lo que
vamos a estar cubriendo, veamos cuáles son los
requisitos previos para este curso. un buen entendimiento tanto
de administración de sistemas
Linux recomiendaun buen entendimiento tanto
delaadministración de sistemas
Linuxcomo de Linux para que puedas
seguir este curso fácilmente. Desde el punto de vista de los activos, necesita máquinas que ejecuten Red Hat Enterprise Linux
con conectividad de red, las máquinas pueden ser
virtuales o físicas. Simplemente no importa. Ahora que hemos terminado
con la presentación, comencemos
con el curso. Aquí vamos.
2. Introducción al curso y configuración de laboratorio: Hola y bienvenidos a la
automatización con Ansible. Mi nombre es Andre Belinda. Soy ingeniero Alexa y
tienen una experiencia docente de
más de ocho años trabajando con grandes organizaciones de toda
Europa como formadora. Tengo experiencia tanto
en trabajar con Red Hat Enterprise
Linux como con Ansible enfocándose en Administración de
Sistemas
y Automatización. También tengo estos
certificados para respaldar esto. Ya soy
ingeniero certificado y la pelirroja certificada Administración de
Sistemas. Desde un punto de vista de seguridad, I Income Security
Plus certificado n milla a CISO certificado. Por lo que cubro tanto la seguridad
como la automatización usando Ansible. Soy un ajuste perfecto para ser tu entrenador para este curso
en particular. Ahora que hemos terminado
con la presentación, comencemos
con el curso. Aquí vamos. El primer video, estaremos
hablando de lo que
es Ansible y cuáles son sus beneficios
para una organización. Así que empecemos.
Entonces, ¿por qué Ansible? Ansible se utiliza para automatizar tareas de
TI como administración de
configuración, implementación de
aplicaciones
e intereses, orquestación de
servicios
y aprovisionamiento. La automatización es crucial en
estos días con entornos de
TI que son demasiado
complejos y
a menudo necesitan escalarse demasiado rápido para que los administradores y
desarrolladores de
sistemas se mantengan al día si
tenían que hacer todo manualmente. Y simple simplifica tareas
complejas. Simplemente haciendo que los
trabajos de los desarrolladores sean más manejables, pero permitiéndoles
enfocar la atención en otras tareas que agregan
valor a una organización. En otras palabras, libera tiempo y aumenta la eficiencia. Entonces, ¿cuáles son esas
características? Bueno, Ansible es poderosa. Puedes usar anticuerpo para
automatizar casi cualquier cosa. Y tan bien, es simple
a través del uso de Playbooks, automatización se vuelve fácil de
trabajar y comprensible
para los humanos. Ansible es sin agente. No es necesario instalar
ningún agente en hosts administrados. Todos los módulos se pasan
a través de OpenSSH o cuando RM y
Ansible es versátil. Y Isabelle brinda
soporte para
dispositivos Linux, Windows y unix que se ejecutan en entornos
físicos o virtuales o
Cloud. Entonces veamos los
pasos para instalar ansible en Red Hat
Enterprise Linux. Necesitas una suscripción válida de la plataforma de
automatización de Reddit en el nodo de control,
en los hosts de gestión, si están ejecutando Linux, necesitan tener Python
3.6 o posterior instalado, o Python 2.7 o
posterior instalado. Es necesario habilitar
en el
nodo de control , el repositorio de Ansible. Después puedes usar
el comando yum para instalar ansible en
el nodo de control. Ansible necesita un usuario para conectarse
al host de gestión. Por lo que deberá
crear un usuario con privilegios
administrativos
en los hosts de gestión para ser utilizado por Ansible. Y es la mejor práctica
configurar también autenticación
basada en claves
a través de SSH para ese usuario. Ahora que hemos cubierto
los requisitos previos, me gustaría mostrarles un
diagrama de mi entorno de laboratorio. Tengo el nodo de control
conectado a un switch con acceso
a Internet al mismo switch. También he conectado mis dos servidores de nombres de host
administrados a, servidor B. Quisiera
señalar que puedes usar
máquinas físicas o virtuales para esta configuración. Realmente no
importa. Depende de tu decisión individual. Así que empecemos
con la demo. En una demo donde
estaremos instalando ansible paso a paso
y después probándolo. En primer lugar, estaré usando el comando
user add para crear un usuario llamado automatización
en el nodo de control, y también darle una
contraseña a este usuario. La contraseña para la
automatización del usuario será incivil. Ahora, seré SSH más al servidor a para crear
el mismo usuario. Volveré a usar el comando
user add. Para agregar al usuario de automatización. Como se puede ver, se
agregó el usuario y que estaremos usando el comando paths v d
para establecer la misma contraseña. La contraseña será incívil. Ahora, sí mencioné que este usuario necesitará privilegios
administrativos. Por lo que lo agregaré en
estas dos puertas dot d carpeta debajo del archivo de
automatización. Y le daré
la posibilidad de ejecutar todos los comandos como root
sin requerir ninguna contraseña poniendo la siguiente línea en la carpeta
pseudopalabras dot d. Ahora vamos a probar esto. Voy a cambiar a la automatización de usuarios mediante el uso de
estos switches o comando. Y estaré ejecutando un comando, privilegios
sudo,
sistema, estado CTL, SSH D. Y como podemos ver, se ha corrido correctamente y no se necesitaba un prompt de
contraseña. Estaré saliendo de esta sesión y haciendo
lo mismo para el servidor, estar conectando derrocó
servidor sea decir SSH, usando el comando user add
para agregar la automatización del usuario, configurando la contraseña Ansible
para la automatización del usuario. Y luego otra vez, creando
un archivo de texto en la slash, ETC recorta dos puertas directorio
Dati. Para que pueda darle a
la automatización de usuarios privilegios
administrativos para que pueda ejecutar
el comando sudo sin necesidad de ninguna contraseña. Ahora que esto se hace,
volveré a probar esto. Voy a cambiar
al usuario de automatización y ejecutar de nuevo pseudo
sistema CTL status, SSH D. Ahora alguna vez no hay mensaje de
contraseña, eso significa que funcionó bien. Ahora saldré de la
sesión y
cambiaré al nodo de control. Revisaré mis pseudo archivos en el nodo de control para ver si
la automatización del usuario puede ejecutar
comandos administrativos sin ninguna contraseña y
queda claro que puede. Por lo que ahora voy
a estar cambiando al usuario de automatización. Estaré usando el comando
cd para ir al directorio home del usuario
de automatización, usando el comando SSH key gen. Para crear una clave SSH, no
utilizaré ninguna contraseña
ni frase de paso para esta clave. Y luego estaré
usando el comando SSH copy id para enviar
la clave al servidor. Para finalizar
el intercambio de claves, necesitaré
introducir la contraseña
para la automatización del usuario. Y después, como se puede ver, las palabras clave añadidas con éxito, terminé por error
mi sesión de automatización. Volveré a iniciar sesión
al usuario de automatización, cambiar directorio de nuevo
a mi directorio de inicio. Y haré lo mismo
para que el servidor sea SSH copy id server B. Me
piden nuevamente la contraseña, la cual ingresaré con el
fin de finalizar el intercambio de claves. Bueno, eso fue un error. Se hace. Ahora veamos si funciona la
autenticación basada en claves. Me he conectado tanto al servidor a como al servidor B
sin ningún mensaje de contraseña. Entonces todo está bien para ir. Ahora salgamos de esta
sesión y volvamos
al usuario de automatización
en mi nodo de control, estaré ejecutando el sudo yum, instalamos el
comando ansible para instalar mi Ansible
en el nodo de control. Y esto tomará un tiempo. Tiene 123 megabytes, por lo que tomará un poco de tiempo. Después de que se
haya finalizado la instalación, puedo empezar a usar
Ansible de inmediato. Entonces Yum ha resuelto
todas las dependencias y todos los paquetes se instalaron
con éxito. Enhorabuena. Ahora antes de probar esto, me
gustaría mostrarte mi barra inclinada, ETC slash archivos host. Bueno, he dado nombres a mi servidor host administrado a y
más respectivamente, servidor B. Ahora, antes de ejecutar una respuesta será ad hoc comando para
probar nuestro entorno. Me gustaría
mostrarte mi fichero de inventario. Ahora, un archivo de inventario le dice Ansible en qué pruebas de
host se realizan. Es necesario contar con un fichero de
inventario o Ansible
no sabrá o cuál tiene
la tarea se debe hacer. Como se puede ver, tengo servidor
agrupado y servidor estar bajo la
categoría servidores web. Ahora ejecutaré un comando ad
hoc usando el módulo ping y la categoría de servidores
web, especificando el archivo de inventario
a través de la opción d menos i. Todo está funcionando muy bien. Verde, verde, verde. El rosa tuvo éxito. Enhorabuena.
Tienes una infraestructura laboral y
civil y un
muy buen ambiente de laboratorio para llevarnos a través de este curso.
3. Inventarios visibles: Ahora para nuestro primer video, hablaremos de archivos de inventario
ansible. Al final de este video, sabrás cuál
es el propósito de los archivos de inventario y cómo
crearlos y gestionarlos. Entonces, ¿qué son los inventarios de Ansible? Bueno, un archivo de inventario ansible define en qué hosts o
grupos de comandos de host, módulos y tareas en un libro de reproducción o
comando ad hoc se operan. El archivo de inventario puede enumerar hosts
individuales o grupos de hosts
definidos por el usuario. Esto le permite
definir grupos de dispositivos en los que
ejecutar ciertos comandos. Esa ubicación predeterminada para
el archivo de inventario es slash, ETC, slash slash hosts. Pero también puede crear archivos de inventario
específicos del proyecto en ubicaciones alternativas, que se pueden especificar ya sea
en archivos de configuración, playbooks, o usando
la opción menos i para comandos ad hoc. Un inventario se puede escribir en cualquier formato
o en formato YAML. Echemos un vistazo a un archivo
de inventario de muestra. Este
fichero de inventario específico se escribe utilizando el sencillo formato INI dentro de él, puedes listar host
por IP o nombre de host, pero debes saber que solo
debe haber uno por línea. Para crear
un grupo de hosts, es necesario declarar
el grupo utilizando los corchetes y rellenar
la
descomposición de ese grupo. Para el grupo uno, tenemos servidor, un servidor sea para el grupo dos
contamos con servidor y servidor. También podemos crear lo que se
llama grupo anidado
usando el sufijo de los niños y especificando estos subgrupos. Me gustaría añadir
que también se pueden utilizar rangos dentro de un fichero de inventario. Puede especificar rangos numéricos
o alfabéticos. Pasemos a la demo y veamos cómo se
hace esto en la práctica. Así que empecemos esta
demo creando primero un archivo de inventario con el comando de inventario
VIM. En este fichero de inventario, agregaré algo gris. Crearé un grupo
llamado grupo uno, cual contendrá el servidor B. Luego
crearé un
grupo llamado grupo dos, cual contendrá servidor a. y luego crearé un grupo
anidado llamado grupo 12, que contendrá
tanto el grupo uno
como el grupo dos mediante
el uso del sufijo hijos. Ahora que he
creado estos grupos, puedo salir de mi inventario. Y utilizaré los
comandos ad hoc de Ansible para ver si funciona. En primer lugar, haré lista de Ansible todos los hosts dentro de mi inventario, especificando el inventario
con la opción menos i. Y podemos ver
servidor y servidor b. Entonces haré listas de
Ansible todos los hosts
desagrupados
dentro de mi inventario. Y como se puede ver, no
hay hosts desagrupados porque todos ellos
están dentro de los grupos, ya sea el grupo uno, el grupo
dos o el grupo 12. Ahora, enumeraré todos los
anfitriones dentro del grupo uno. Podemos ver claramente que el
servidor B está presente. Y haré
lo mismo para el grupo dos, ansible grupo dos
menos menos hosts de lista y especificando el inventario
con esta opción menos i. Y podemos ver claramente el
servidor a está presente ahí. Ahora veamos si
el grupo anidado está funcionando adecuadamente. Al enumerar los anfitriones dentro de ella. Podemos ver tanto el servidor a, servidor B, por lo que tanto el grupo
uno como el grupo dos. Por lo que está bastante claro
ahí está mi inventario está funcionando adecuadamente. Vamos a probar esto
ejecutando un comando ad hoc ping a todos los servidores
dentro del inventario. Podemos ver que ambos servidores, así
como una especie de Birkby han respondido
con éxito con una respuesta de Pong. Y hagamos esta operación para cada artículo individual
dentro de nuestro inventario. Primero para el grupo uno, y ver si funciona. Especificar el inventario
con la opción menos i. Entonces cerebral B ha
respondido correctamente. Entonces haremos lo
mismo por el grupo dos. Febrero ha respondido
con éxito. Ahora terminemos
esta demo limpiando la pantalla y haciendo lo
mismo para el grupo 12. Como se puede ver, ambos servidores, un nombre de servidor respondido por grupo anidado funciona perfectamente. Enhorabuena. Ahora ya sabes cómo crear inventarios y administrar
el host dentro de ellos. También. En nuestro siguiente video, estaremos entrando en archivos de configuración de
Ansible. Nos vemos pronto.
4. Archivos de configuración de Ansible: Ahora veremos los archivos de
configuración de Ansible. Entonces sin más preámbulos,
comencemos. Por lo que la forma en que las personas
se comportan se especifica en el archivo de configuración de
Ansible también por defecto, tiene un archivo de configuración
ubicado en especial ETC. Slash Ansible, ansible dot CFG, que se utiliza a menos que otro
archivo de configuración tenga prioridad. Si existe un anticuerpo dot c, f, g dentro
del directorio home del usuario que lo ejecuta, tendrá prioridad sobre el
archivo de configuración predeterminado presente en slash, ETC. Si
existe un archivo de configuración de Ansible en el directorio de trabajo, entonces esto tendrá prioridad
sobre los dos de antemano. Y si se define la
variable config de Ansible, entonces esto tendrá prioridad sobre las tres mencionadas anteriormente. Los ajustes no se acumulan a partir de múltiples archivos
de configuración. Entonces todo lo que no se indique dentro del archivo de configuración de Ansible se
establecerá al valor
predeterminado. Ese valor predeterminado se
puede encontrar en el
archivo de configuración predeterminado de Ansible presente en slash, ETC, slash n sub
l Ahora hagamos las cosas un poco más prácticas y veamos el archivo de
configuración de muestra. Ahora, como se puede ver, el
archivo de configuración tiene secciones. Estas secciones se encuentran dentro de
los corchetes. Tenemos la sección predeterminada y la sección de
escalada de privilegios. En la sección por defecto, tenemos el campo de inventario, que define el inventario
que se utilizará. En la opción de usuario remoto
se especifica
el nombre del usuario y sub l deberá utilizar para conectarse a
los hosts de administración. Y la
opción de pase ASP especifica si es
necesaria
una solicitud de contraseña para la conexión. Ahora, pasemos a la sección de escalada de
privilegios. Ahora dentro de la sección de
escalada de privilegios, tenemos la opción become, lo que significa que
ansible cambiaremos usuario después de que se
haya establecido la conexión. Se convierten en método es la forma en que
cambiará a ese usuario. Esto está configurado para usar sudo. qué usuario cambiará se define por el argumento de
usuario convertido. En nuestro caso, Ansible cambiará al usuario raíz
al conectarse. Se convierten en ask pass argumento
define si es
necesaria una contraseña con el fin de facilitar y finalizar este conmutador de usuario. Entonces ahora que tenemos una
bastante buena visión general de las opciones
básicas pero importantes de los archivos de
configuración de Ansible. Vamos a seguir adelante y ponerlos
en práctica en la demo. Por lo que comenzaremos
esta demo haciendo un nuevo directorio llamado fichero de
configuración, donde crearemos nuestros propios archivos de
configuración
personalizados de Ansible. Utilizaremos el MK D o
comando para hacer esto. Ahora antes de crear nuestros
propios archivos de configuración, veamos el predeterminado
almacenado en slash, ETC slash n sub l
Como puedes ver, éste también está
agrupado en secciones, y actualmente estamos viendo
la sección por defecto. Hay muchas
más opciones de las que hemos aprendido en las diapositivas, y se puede investigar
todas y cada una de ellas en caso de que surja la necesidad. Estos valores aquí también definen la forma predeterminada en la
que Ansible se comporta. La mayoría de las opciones se
explican aquí usando comentarios, pero hemos cubierto las más importantes
dentro del curso. Como puedes ver, me estoy desplazando hacia abajo para darte una visión general de la multitud de opciones de personalización que ofrece
ansible. Así que salgamos y creemos
nuestro propio archivo de configuración. En primer lugar, utilizaré el comando
cd para cambiar el directorio de nuevo a mi directorio de archivos de
configuración. Entonces usaré el
VIM para crear un archivo llamado
ansible dot c, f, g Primero cambiaré al modo de
inserción, y especificaré
la sección por defecto. Aquí. Especificaré qué inventario me
gustaría utilizar Ansible, especificando la ruta de acceso
a mi fichero de inventario. En este caso particular, la ruta será slash
home slash automatización slash archivo de configuración
slash inventario de slash. Entonces empezaré a especificar al usuario remoto que ansible usaremos para
conectarnos al host de gestión. Y este sería
el usuario de automatización que está presente en ambos
servidor a, servidor B. Ahora, cuando se trata de escalación de
privilegios, primero
especificaré las especificaciones que sección entre paréntesis. Y voy a decir
llegar a ser igual a verdad. Eso significa que al conectarse, Ansible cambiará de usuario. Cambiará al usuario
usando el pseudo método, y cambiará a la raíz del usuario al
conectarse usando sudo. Y como no hay
necesidad de una contraseña, voy a especificar que se conviertan en
pedir pase se establece en false. Ahora voy a crear el
inventario llamado inventario. Y aquí
especificaré servidor a, servidor B, Guardar y Salir. Y probemos un comando ping
y Sibyl todo menos m rosa. Como se puede ver,
no es necesario especificar la opción menos i ya que el inventario se define en el archivo de configuración de Ansible. Probemos un comando Ansible o
menos m, menos AYUDA. Esto nos dará el ID bajo el cual Ansible se está ejecutando
en los hosts administrados. Y como podemos ver, tiene una nueva idea de 0. Eso significa que estamos corriendo
como usuario raíz. Así que editemos el archivo de
configuración de Ansible. Yo lo abriré. Y me gustaría usar
como fichero de inventario, un fichero llamado inventario también. Simplemente entraré al modo Insertar o los dos al
final, guardar y salir. Y luego crea un archivo
llamado inventario a donde acabo de especificar
servidor a, guardar y salir. Y luego ejecutemos un comando Ansible
all menos m ping. Y como se puede ver, sólo
servidor a respondió con punk. Entonces eso significa que sólo está
usando el inventario para archivar. Cambiemos nuevamente el archivo de
configuración de Ansible. Y pasemos
a ser al valor de false. Eso significa que
Ansible ya no
cambiará a los usuarios a la conexión. Y probemos esto
ejecutando un comando Ansible o menos m menos AID. Esto nos dará
la idea bajo la cual Ansible se está ejecutando en
los hosts administrados. Por lo que tiene un UID de 1001. La automatización de usuarios ya
no miró. No ha hecho ninguna escalada de
privilegios. Ahora que esto ha
funcionado perfectamente, probemos algo un
poco más interesante. Entonces primero, copiaré mi archivo de
configuración a la casa del
usuario de automatización usando el comando cp. Y luego eliminaré mi
archivo de configuración existente aquí en el directorio de trabajo
con el comando remove. Ahora, intentemos volver a ejecutar
el mismo comando. Y como se puede ver, dice
que la lista de hosts de
proveedores está vacía. No funcionó. ¿ Por qué es eso? Eso es porque lo
copié bajo el nombre Ansible CFG en lugar
de punto ansible CFG. Si no tiene el mismo
nombre que Ansible espera, no
se tendrá en
cuenta. Así que vamos a renombrar usando
el comando move M, V Ansible CFG dot ansible dot C, F, G, y ver si
funciona después. Vuelve a ejecutar el comando,
y como se puede ver, ha funcionado perfectamente. Ahora, cambiemos el directorio de
trabajo al archivo de
configuración y
ejecutemos el mismo comando. Nuevamente. Si la salida es la misma, eso significa que el archivo de
configuración, que he colocado
en el hogar de la automatización de usuarios
es utilizado por Ansible y también tiene prioridad sobre el
archivo de configuración por defecto presente en slash, ETC. Podemos ver claramente que
ambas salidas son idénticas. Y con esto, hemos
terminado nuestra demo sobre configuración y sub L. Ahora, vamos a seguir adelante con comandos ad hoc de
Ansible
en el siguiente video.
5. Comandos ad-hoc visibles: En el último video,
nos enteramos los archivos de configuración de
Ansible y ahora
vamos a poner eso a utilizar con el comando ad hoc de
Ansible. Entonces descubramos qué son, cómo crearlos,
y cómo usarlos. Los comandos ad hoc de Ansible se utilizan para la
tarea de un solo uso con Ansible, generalmente se usan para probar ciertas cosas o cambios rápidos. Sin embargo, su utilidad es
bastante limitada. Y si te gustaría
usar toda la potencia de n tupla como motor de
automatización. Lo más probable es que
vayas por playbooks. Los comandos ad hoc de Ansible pueden hacer que las tareas de administración
del sistema sean un poco fáciles y rápidas también. Entonces veamos cómo construir comandos ad hoc de
Ansible. Este es el patrón estándar
para los comandos ad hoc de Ansible. En primer lugar, hay que
elegir los hosts o el grupo de hosts a los que se dirigirá
el comando. Entonces hay que especificar
el módulo a través de la opción d menos m a ese módulo, hay
que adjuntar argumentos a
través de d menos una opción. Entonces hay que especificar
el inventario que Ansible usará con la opción
menos i. O si aún
no tienes archivo de
configuración de Ansible, no
necesitarás eso. También puede especificar al usuario
qué Ansible usará para
conectarse al host administrado a
través de la opción d menos u. Nuevamente, si eso se define en su archivo de configuración de Ansible, eso no será necesario. Me gustaría especificar
que para el argumento host, también
podemos usar la opción all, que se dirigirá a todos los hosts
dentro del inventario, o la opción desagrupada, que se dirigirá a
todos los hosts desagrupados dentro de ese inventario. Ahora, veamos
alguna respuesta de muestra. Bueno, comandos ad hoc. El primer comando
que tenemos aquí en la diapositiva, Ansible todo menos m ping,
ping a todos los hosts dentro
del inventario. El segundo comando,
Ansible server una copia m menos menos un
contenido es igual a HelloWorld, destino slash home slash automatización
slash hello-world. Copiaremos el contenido Hello
World a un archivo almacenado en slash home slash automatización slash hello-world en el servidor a. el tercer comando,
Ansible servers menos m Comando
Menos un nombre de host, ejecutará el comando
hostname en el grupo denominado servidores definidos
en el inventario. Antes de que sea el mando.
Utilizando el módulo de usuario, crearemos un usuario
llamado test en servidor, estar usando el inventario especificado a través de la opción
d menos i. El último comando, usuario de
Ansible doc, nos
dará información sobre el módulo de usuario
y cómo usarlo. También puedes obtener
esta información en línea si tienes una conexión
a Internet. Como redd proporciona bastante
buena documentación. Por lo que ahora que hemos
visto alguna muestra comandos ad hoc de
Ansible, veamos algunos
módulos que
debemos conocer a través
del módulo rosa, podemos comprobar la accesibilidad del host. A través del módulo de usuario. Podemos gestionar usuarios
en el Manage host. A través del módulo de servicio. Podemos gestionar servicios
en el host gestionado. A través del módulo de copia, podemos copiar un archivo
al host administrado, pero también crear contenido. Y a través del módulo UE, podemos gestionar paquetes
en el host gestionado. A través del módulo de archivos, podemos gestionar pilas
en el host gestionado. A través del módulo firewall d, podemos administrar el
servicio de firewall en Administrar host. Ahora que entiendes
lo que hacen los comandos ad hoc, y has visto algunos comandos ad hoc de
ejemplo. Pasemos a la demo. Ahora, voy a empezar esta
demo creando primero un directorio usando
el comando MK dir. Y luego tres
serán llamados laboratorio ad hoc. Cambiaré rápidamente
a ese directorio y crearé un archivo de
configuración de Ansible. Dentro de este archivo de
configuración de Ansible, primero
definiré
la sección por defecto, donde especificaré
primero mi fichero de inventario. Y esto se encontrará en
slash home slash automatización
slash ad hoc lab
slash inventario de slash. Entonces definiré al usuario
remoto que ansible, usaremos una conexión punk y esta será la automatización de
usuarios. Ahora que he terminado
mi sección predeterminada, iniciaré mi sección de
escalada de privilegios. Aquí, primero pondré D
llegar a ser al valor de verdadero. Se convierten en usuario será root y se convierten en
método será pseudo. Ahora se vuelven como pase, lo
pondré en
false ya que
no hay necesidad de un aviso de contraseña. Diré mi fichero
de configuración. Y ahora voy a crear mi inventario usando el comando de inventario
VIM. Este inventario,
incluiré tanto servidor, a, servidor ser, guardar y salir. Así que ahora vamos a ejecutar algunos comandos
ad hoc usando este
archivo de configuración de Ansible e inventario ansible. Voy a hacer ping a todos los anfitriones
dentro del inventario. Y como se puede ver,
tanto el servidor como el servidor B han respondido con
una respuesta de Pong. Ansible server un
comando menos m menos a para el nombre del host del
argumento. Esto ejecutará el
comando hostname en febrero. Como podemos ver, la
salida es servidor a. como es de esperar, volveré a utilizar el módulo de comando para ejecutar el comando
id en febrero, y funciona perfectamente. Despegaré la pantalla. Y ejecutar un nuevo comando, pero esta vez en el servidor B, volveré a usar
el módulo de comando, pero esta vez lo haré salir el contenido
de la slash, ETC recortar pasado archivo VDI
usando el comando cat. Como puedes ver aquí,
todos los usuarios, incluida la automatización,
están presentes. Ahora, voy a crear
un usuario usando un comando ad hoc de
Ansible con
el módulo de usuario en servidor, un servidor un usuario menos m, y especificando
el nombre del usuario y el estado en que deben
estar los usuarios el anfitrión gestionado. En mi
caso particular, estado presente. Ahora voy a hacer clic en enter. Y como se puede ver, se ha creado
el nuevo usuario y el UID es igual a 1002. Ahora, también podemos validar esto revisando nuevamente el
archivo VDI pasado usando el módulo de comando y dando salida al
contenido de la slash, ETC slash archivo de contraseña. Y podemos ver al usuario de
prueba con un UID de 1002 y
el GID de 1002. Ahora, si quisiera eliminar
al usuario, simplemente
ejecutaré el
mismo comando pero con el estado es igual a ausente. Como se puede ver, servidor, ha reportado un cambio. Y
volveremos a ejecutar el comando slash pass VD para ver
si la prueba de usuario está presente. Y se puede ver que
ya no está ahí, está ausente. Ahora, utilicemos el documento de
Ansible para que el usuario del módulo obtenga más información sobre
cómo funciona este módulo. Y podemos ver lo que hace, y podemos ver las opciones
y argumentos que tiene, como anexar, autorización,
comentar, generar, clave SSH. Ahora, me gustaría
señalar todo lo que tiene el signo igual significa que
es obligatorio, como nombre. Todo lo que tiene el signo menos
o líneas es opcional, por lo que no necesitan ser
especificados específicamente. Ahora, al final de este particular Ansible
doc para el usuario del módulo, encontraremos ejemplos. Estos ejemplos son extremadamente útiles y
nos ayudan bastante entender cómo funciona
un módulo específico y cómo
funciona un
módulo específico. Como podemos ver, los
ejemplos son fáciles de
entender y fáciles de descifrar. Además se
comentan y dicen lo que cada ejemplo está destinado
a hacer. Así que salgamos. Despejemos la pantalla
usando el comando clear. Y ahora hagamos otro hombre
ad hoc en servidor. Estar más específicamente
utilizando la copia del módulo. Vamos a crear contenido. Y el contenido será
igual a mi archivo de prueba. Y el destino de este
contenido será igual a slash home slash automatización
slash archivo de prueba. Ahora, acabaré de golpear Enter y desde la salida
del comando, podemos ver que el servidor B ha
reportado un estado de cambio. Así que vamos a seguir adelante y validar nuestro trabajo usando
un
comando ad hoc de Ansible con el
módulo de comando con el fin de
generar el contenido del testfile, que acabamos de crear
usando el módulo copy. Entonces el servidor de tazón
b menos m Comando Menos a cat slash home slash
automatización slash archivo de prueba. Y podemos ver claramente
el contenido de mi archivo de prueba que agregamos en el
anterior comando ad hoc. Por lo que funcionó perfectamente. Ahora, acabaré de borrar la pantalla
usando el comando clear. Ahora para nuestro último ejemplo, que reiniciará el firewall, el servicio tanto en
servidor como en servidor estará utilizando el módulo llamado servicio. Especificaré los argumentos
con el menos una opción, el nombre del servicio,
que es firewall, al final
se establecerá el estado para reiniciarlo. Eso significa reiniciar el
firewall, el servicio. Ahora voy a golpear Enter. Y como se puede ver
en la salida, el firewall, el servicio se
ha reiniciado. Se ha reiniciado
tanto en el servidor a como también en el servidor b. obtendremos este tipo de
salida para cada servidor. Ahora antes de terminar este módulo, déjame simplemente borrar
la pantalla y usar Ansible doc para obtener alguna información sobre
el módulo de servicio, podemos encontrar una descripción bastante
buena de lo que el módulo lo hace. ¿ Cuáles son
las opciones obligatorias y cuáles son las
opciones obligatorias para este módulo? Y al final, veremos muy buenos ejemplos de
cómo funciona este módulo. Ahora, solo saldré de los perros
Ansible volver
a borrar la pantalla. Y me gustaría agradecerles por acompañarme en esta demo. Ahora tienes una idea bastante buena de cómo
funcionan los comandos ad hoc de Ansible y cómo podemos
crearlos y ejecutarlos. Por lo que me gustaría
felicitarte por terminar esta demo. Pasaremos al siguiente
video, Playbooks de Ansible, donde podremos ver todo
el poder
del lenguaje de automatización de Ansible.
6. Libros de juego visibles: Hemos
cubierto previamente inventarios, archivos de
configuración
y comandos ad hoc. Por lo que ahora es el momento de
pasar al pan y la mantequilla de los playbooks de Ansible. Así que no esperemos
y vayamos directamente a ello. Entonces lo que nuestros playbooks, playbooks son una
secuencia de jugadas, siendo
un plato una secuencia de tareas realizadas en los anfitriones de gestión. El propósito de los playbooks
es simplificar las tareas
administrativas
en rutinas fáciles. Las tareas pueden trabajar juntas
dentro de un libro de jugadas para documentar los pasos necesarios para
lograr un resultado previsto. Y lo mejor de todo, los
playbooks son repetibles. Se pueden utilizar más de
una vez para lograr ese resultado. Ahora cuando se trata de playbooks, se
escriben en
formato YAML y se guardan generalmente con la extensión de punto
YAML o ese YAML. Utilizan el espaciado para los niños con
sangría
más que los padres. Así que mantengan el espaciado constante
o se estrellarán. Las líneas vacías no
impactan el libro de jugadas. El inicio de un playbook
es siempre de tres líneas y los comentarios se pueden agregar
usando el carácter hash. Las cadenas no tienen que
estar entre comillas. Se recomienda utilizar
cotización para legibilidad. Puedes escribir varios
jugadores dentro de un playbook y las tareas se ejecutan en
orden de arriba a abajo. Si falla una prueba, entonces el playbook se detendrá y no se
ejecutarán tareas posteriores por defecto. Hay alternativas para esto, y veremos que a medida que
avanzamos dentro del curso. Ahora, al ejecutar un playbook, la salida estará codificada por colores. Verde significa que el sistema
ya está en el estado deseado. Amarillo significa que
se ha hecho un cambio al sistema
del anfitrión gestionado con el fin llevarlo al estado deseado. Y rojo significa que algo
salió mal y la tarea no se pudo finalizar o
no se pudo realizar. El rojo suele ser malo. Ahora, con todo esto en mente, veamos el playbook de
muestra. Tenemos los tres guiones que señalaron el inicio
del playbook. Después tenemos
el nombre de la obra. En este caso particular, esta obra se llama
crear nuevo usuario. Tenemos los anfitriones a los que se aplica
este playbook. En nuestro caso particular, se aplica al servidor a. y luego tenemos las tareas. Esto indica qué tareas se
realizarán en los
hosts administrados dentro de esta jugada, cada tarea tiene un
nombre, utiliza un módulo. En nuestro caso, el nombre está
asegurado de que se cree usuario. El módulo es usuario. El nombre del usuario que se
creará es test, y el estado de ese
usuario está presente. Esta tarea asegura
que la prueba de usuario esté presente en el
host administrado, que es servidor. Ahora, echemos un vistazo a
otro libro de reproducción de muestra, que contiene múltiples tareas, la de abajo
dependiente de la
anterior del servidor de
destino B. Y al usar el módulo, se asegurarse de que
el servicio llamado firewall esté instalado en el
servidor sea después, intentará iniciar
el firewall, el servicio. Esto solo es posible
porque las pruebas se ejecutan en orden de arriba a abajo. No se podía iniciar el mal servicio del
cortafuegos si no existiera
en primer lugar. Antes de seguir adelante,
quisiera subrayar la importancia de espaciar
tanto la primera tarea, la segunda tarea, tienen la
misma cantidad de espacios porque ambos son hijos
de la sección de tareas. espaciado inadecuado puede conducir
al accidente de un libro de jugadas. Ahora, antes de pasar a la demo, me gustaría decir
que puedes personalizar algunas opciones de configuración
para playbooks individuales. Puede especificar opciones
que tendrán prioridad sobre las presentes en el archivo de configuración de
Ansible. Puede especificar el usuario remoto Ansible utiliza para conectarse
al host de administración. Puede especificar el usuario
Ansible cambia dos, y también puede especificar la forma en Ansible cambia a ese usuario. Para ejecutar un playbook, solo
necesitas ejecutar el comando Playbook de
Ansible y especificar el nombre
del playbook. Si desea revisar el
libro de reproducción antes de ejecutarlo, puede realizar una comprobación de
sintaxis usando la opción d
menos menos comprobación de sintaxis
o ejecutando una corrida seca a través de la opción d menos C
mayúscula. Así que vamos, tenemos una bastante buena
idea de cómo funcionan los playbooks. Vamos a seguir adelante y
empezar la demo. Ahora primero, para que escritura de
libros de plaga sea un poco más fácil, crearé un archivo llamado dot v Marcy en mi directorio de inicio. Esto asegurará que
cada vez que presiono tab el espaciado
sea constante. Por lo que debería escribir aquí
auto cmd tipo de archivo YAML, porque todos los playbooks
estarán en formato YAML. Establecer local Ai es igual a dos, S w es igual a e t.
Simplemente guardaré y saldré. Ahora cada vez que
creo un archivo YAML, el espaciado será un
poco más constante y
hará que escribir playbooks sea
un poco más fácil. Ahora, estaré creando
un nuevo directorio para mis ejercicios, queridos playbooks MK. Y entraré a este directorio usando el comando change
directory. Ahora, voy a crear
mi fichero de inventario. Y dentro de mi fichero de inventario, colocaré servidor a, servidor B. Y eso también creará
un grupo llamado servidores, cual contendrá tanto
servidor como servidor B. Todo lo que queda ahora
es también un
archivo de configuración de Ansible usando VIM. Empezaré la
sección por defecto y especificaré al usuario remoto que
ansible vamos a
utilizar para conectarnos
a los hosts de gestión. Y esta será
la automatización de usuarios y también el archivo de inventario, que está presente en slash
home slash automatización slash playbooks slash inventario. Ahora, pasaré a la sección de escalada de
privilegios, donde especificaré
que se conviertan en iguales a verdad. Se convierten en método se
establecerá a sudo. Y se
establecerá el usuario que se convierta en ruta. Como no hay
necesidad de una contraseña, se
convierten como
opción de pase se
establecerá false y
simplemente guardaré y saldré. Ahora, puedo seguir y
crear mi primer playbook. Se llamará
playbook dot YAML. Empezaré el playbook con
las tres líneas clásicas. Y también le daré un
nombre a mi obra específica. El nombre será crear usuario. Entonces especificaré dos que aloja este playbook aplica, y se aplicará a todos los
anfitriones dentro del inventario. Entonces ambos servidores responden para b, y luego empezaré a
escribir las tareas. Mi primera tarea se llama
asegurar que se crea el usuario. Y utilizará el módulo de usuario fin de crear un usuario
que se llame test. Y estará presente el estado de ese
usuario. Guardaré y
saldré de este playbook. Y primero haré una comprobación de sintaxis para
ver si este playbook no tiene ningún tipo de
errores o problemas de espaciado. Ansible playbook menos, menos comprobación de sintaxis
para mi playbook. Como se puede ver, no
hay errores. Entonces creo que en realidad
se ejecutará en un primer intento. Entonces ejecutaré
el playbook usando el comando Playbook de Ansible especificando el nombre
del playbook. Esperemos un poco a
Ansible juntos algunos hechos. Y como se puede ver,
ambos servidores a, servidor B han reportado
un estado de cambio. Ahora, vamos a utilizar un comando
Ansible ad hoc tanto
para servidor como para servidor estar usando el módulo de comando para generar el contenido
de la slash, ETC slash pass archivo VDI. A juzgar por la salida, podemos ver claramente que el usuario de prueba sí existe con un
nuevo ID de 1002. Así que acabaré de borrar la pantalla porque parecía que mi playbook
tiene funcionamiento correctamente. Ahora, editemos el playbook para
eliminar al usuario que
acabamos de crear
cambiando el estado
del usuario de presente a ausente,
guardar y salir. Y volvamos a ejecutarlo. Podemos ver claramente
que tanto el servidor como servidor B han reportado
ese cambio de estado, y también por el
color, es amarillo. Así que vamos a validar nuestro trabajo
ejecutando de nuevo un comando ad hoc de
Ansible para ver si el usuario de prueba todavía está presente en el archivo de video pasado. Y parece que no lo es. Así que déjame simplemente borrar
la pantalla y vamos documentarnos para opciones
adicionales para el módulo de usuario, saltaré directamente
a los ejemplos al final del módulo. Ahora, si miramos
el primer ejemplo, también
podemos especificar
el UID del usuario y también agregar un comentario.
Así que hagamos eso. Simplemente saldré del
perro Ansible usando la tecla Q y editaré mi
playbook existente para
especificar también el UID del usuario, así
como comentario para
este usuario en particular. Por lo que la UID
será de 8 mil y el comentario será I M prueba. Por lo que ahora Guardar y Salir. Y volvamos a ejecutar este
playbook. Ahora bien, si se puede ver claramente, Ansible ha informado que no
hubo cambio en ninguno de los servidores
a, servidor B, es decir porque
el estado estaba establecido ausente y
no existe la prueba de usuario. Por lo que no había necesidad de
incurrir realmente en un cambio en un
servidor o servidor B, lo
he cambiado para presentar, y ahora voy a ejecutar el
playbook una vez más. Así que esperemos un poco a
Ansible juntos son hechos. Y como podemos ver
claramente desde la salida, hubo un cambio
tanto al servidor como al servidor B. Así que vamos a ejecutar un comando
ad hoc para ver qué hay en los archivos VD pasados tanto
del servidor como del servidor B, vemos la prueba de usuario
con una nueva idea de 8 mil n con un
comentario I M test. Por lo que nuestro módulo y nuestro
juego funcionaron perfectamente. Simplemente borraré la pantalla y editaré nuestro playbook
existente. Una vez más. Cambiaré
el nombre de la tarea de Asegurar que se cree el usuario
para instalar HTTPD. Cambiaré el módulo
que se está utilizando de usuario a ñame. Cambie el nombre
de test a HTTP. Cambie el estado de
ausente a lo último, asegurándose de que estoy instalando la última versión de HTTP D. Luego
crearé una nueva tarea, que iniciará
el servicio HTTPD usando estos módulo de servicio, especificando el nombre
del servicio HTTPD y el estado
que se está iniciando. Así que lo ejecutemos usando el comando Playbook de Ansible
y veamos si funciona. Tendremos que esperar un poco a
Ansible juntos son hechos. Y como se puede
ver claramente, se ha estrellado. No pudo instalar
algunos paquetes específicos, más específicamente el HTTP. Ahora esto es porque me equivoqué el
nombre intencionalmente. Como se puede ver, no ha pasado a la
segunda tarea porque
la primera tarea se
estrelló y pudimos ver
claramente la codificación de colores de la
cuadrícula. Entonces cambiaré el
nombre de HTTP a HTTPD. Ese es el nombre correcto. Así que intentemos ejecutarlo de
nuevo con el nombre correcto. Ahora, le tomará
un poco de tiempo para Ansible tanto
recopilar hechos
como HTTPD instalado
tanto en el servidor como en el servidor B. Parece que fresa ha reportado un estado de cambio y también El servidor B ha
reportado el estado de cambio. Y las tareas para iniciar HTTPD
se realizaron con éxito. Entonces supongo que funcionó. Vamos a usar SSH para
conectarnos al servidor
a y hacer un sistema
CTL status HTTPD, que podemos ver claramente
que se está ejecutando. Hagamos
lo mismo también para que el servidor B se conecte a través de
SSH al servidor B, ejecute un estado CTL del sistema, HTTPD, y ver si se está
ejecutando, cuál es. Por lo que podemos ver claramente que nuestro playbook corrió
exactamente como estaba planeado. La automatización es bastante impresionante. Ahora, vamos a desinfectar
nuestro entorno de laboratorio eliminando los paquetes HTTPD, que abrirá nuestro playbook. Eliminó la última tarea que
inicia el servicio HTTPD y cambia el estado
del módulo yang de
litros a ausente. Si bien estamos en ello, aunque no
impacta nuestro playbook. También podemos cambiar el
nombre de
HTTPD instalado a algo así como eliminar HTTPD o
HTTPD ausente, guardar y salir. Y vamos a ejecutar el playbook usando playbook de
Ansible y
especificando el nombre. Sólo esperaremos un poco a
Ansible juntos es un hecho. Y como se puede ver, el estado de ambos servidores a, cambia
el estado de ambos servidores a,
servidor B, por lo que eso significa que la
eliminación fue exitosa. Ahora despejemos la pantalla. Enumeremos el contenido
del directorio de playbooks. Y eliminemos el archivo de
configuración de Ansible que
creamos al inicio de
la demo con el comando RM. Ahora utilicemos VIM para crear un nuevo playbook llamado
playbook to dot YAML. Ahora, empecemos
este playbook como cualquier otro playbook
con tres líneas, que nombraremos la
primera jugada por juego. Y vamos a especificar opciones
adicionales, volvernos más ser fijados a verdadero. El usuario remoto
será la automatización. El método become
será pseudo. Se convierten en pedir caminos se
establecerán a falsos. Y se conviertan en usuario se
establecerán en root. Y por último, el
host gestionado será el servidor B. Ahora podemos iniciar
la sección de tareas. Ahora dentro de la sección de prueba, crearé una tarea con el
nombre de crear prueba de usuario. Utilizaremos el
módulo de usuario para crear un usuario llamado test en el servidor B. Ahora, guardaré y saldré
del playbook e intentaré ejecutarlo usando el comando
playbook de Ansible. Ahora, necesito especificar
el archivo de inventario, pero un libro de jugadas se estrelló. ¿ Por qué se estrelló?
Porque al convertirse como pasado no es un
atributo válido para una obra de teatro. Entonces si las opciones son incorrectas, el playbook simplemente
fallará en la ejecución, y es por eso que eliminé
la opción no válida. Ahora, intentaré ejecutar nuevamente
el playbook
especificando el inventario. Y como se puede ver, ha funcionado correctamente. Así que ten en cuenta que cualquier opción
no válida dentro del playbook hará
que se bloquee de inmediato. Acabo de borrar la pantalla ahora y volver a editar el playbook. Ahora, agregaré una segunda jugada a este playbook
en particular. Nombraré esta segunda jugada. Mi segunda jugada. Vuelvo a especificar que las
opciones se hagan realidad. El usuario remoto se
ajustará a la automatización. Se convierten en método se
establecerá a pseudo. Se conviertan en usuario
se establecerán para enrutar. El host objetivo
será ambos servidor,
un servidor será a través de
los servidores de grupo. Ahora, iniciaré mi
segunda sección de tareas, donde especificaré
una tarea con el nombre de crear un segundo usuario. En ambos servidores. El segundo usuario
será nombrado prueba al estado de este
usuario en particular estará presente. Después,
crearé una segunda tarea con el nombre eliminar prueba de usuario. El módulo que voy a
utilizar será el módulo de usuario. Nuevamente, especificaré el nombre
del usuario que es prueba, que está
teniendo presente solo en el servidor B y el
estado estará ausente. Ahora, guardaré y
saldré de mi playbook y lo
ejecutaré usando el comando
Playbook de Ansible. Ahora, vamos a darle a Ansible unos segundos para
ver qué hace. Entonces a juzgar por la salida, la prueba de usuario ya estaba
presente en el servidor B. El segundo usuario fue creado
en ambos servidores, servidor DNS, y la prueba de usuario fue
eliminada en servidor be, ya que no estaba presente en
servidor a para empezar. Entonces felicitaciones. Ahora tienes una bastante buena comprensión de
base de lo que es
un archivo de inventario ansible y cómo crear uno. Puedes crear tus propios archivos de configuración de
Ansible y en ningún lugar donde colocarlos
dentro del sistema de archivos Linux, has aprendido la
utilidad de los comandos
ad hoc ansible y
cómo usarlos. Y por último, obtienes una buena comprensión
de cómo escribir un sencillo libro de jugadas de Ansible y los beneficios que los playbooks
aportan a un símbolo.
7. Variables Ansible: Ahora para nuestro primer video, estaremos
hablando de variables ansibles, que descubriremos
la utilidad de las variables y dónde
deben declararse para
acceder a ellas dentro de playbooks. Por último, que
tendrá una demo donde
deberíamos poner en práctica nuestros
conocimientos de aprendizaje. Así que empecemos. Ahora, al igual que en los lenguajes de
programación, las variables en Ansible
se utilizan para almacenar un valor. Variables proporciona
flexibilidad dentro playbooks, plantillas
e inventarios. Y
las variables incorporadas se pueden usar para proporcionar información del sistema. Las variables se pueden definir
en varios lugares y los nombres de variables
solo deben contener letras, números o guiones bajos, o cualquier combinación de lo mencionado de
antemano. Cualquier uso de otros
personajes podría conducir a un error
dentro del libro de reproducción. Ahora como se indicó anteriormente, las variables pueden declararse
en diversos lugares. Las variables de grupo se pueden
definir en el inventario o el directorio de partes del grupo
dentro del directorio de trabajo. Las variables de host siguen
el mismo patrón. También se pueden definir en el inventario o en el directorio de virus
host. También puede declarar
variables dentro un libro de jugadas que se definen en diversa
sección de un libro de jugadas. Las variables de tarea también se pueden
definir dentro de la tarea. Y las variables adicionales se
pueden definir en la línea de comando usando la opción
D menos E. Así que veamos algunos ejemplos
prácticos de cómo se pueden
definir variables dentro del libro de jugadas. Ahora, al inicio de una obra, podemos tener la sección var
donde podemos definir la
variable usando el nombre de la
variable dot, dot, y posteriormente el
valor de esa variable, cada variable tiene un
valor asociado. Ahora, también podemos usar las variables mediante
el uso las cotizaciones y reconocimientos
como se ve en la diapositiva. Las variables también
se pueden importar desde archivo de
una variable escrito en formato
YAML utilizando la sección
vars files y especificando la ruta
del archivo variable. Ahora, sigamos adelante y
veamos cómo podemos definir variables dentro del inventario. Ahora las variables
también se pueden declarar en el fichero de inventario especificando el nombre de la variable y el valor de la
variable cerca del host. O bien, puede especificar variables de
grupo
creando una nueva sección con
el nombre del grupo, puntos vars, y luego especificando el valor de cada variable dentro de
esa sección. Dentro de los archivos variables, que hemos
hablado previamente, deben definirse
en formato YAML. Ahora, también podemos
declarar matrices
siguiendo la sintaxis
en la diapositiva. Ahora, para la variable de equipo, tenemos un integrante que es Andrew, que tiene el campo de nombre, y ese nombre es Andrew y
también tiene un nuevo ID de 2001. Entonces tenemos a Alexander. Ahora que aprendimos mucho sobre declarar y
definir variables, veamos un poco las variables
mágicas. Ahora tenemos la variable
mágica del grupo, que son todos anfitriones y
grupos dentro del inventario. Los nombres de los grupos,
estos son todos los grupos. El host gestionado forma
parte de las barras anfitrionas. Estas son variables para el host administrado y el nombre del host de
inventario. Esa variable está asociada con el nombre de host tal y como se configura
dentro del inventario. Ahora, antes de
terminar nuestra sección, por último
hablaremos de hechos
ansibles y cuáles son los hechos
ansibles y
cómo podemos usarlos. Así que sigamos adelante. Entonces, ¿cuáles son los hechos ansibles? Los hechos ansibles son variables
que se
descubren automáticamente cuando ansible
se conecta a un host de gestión. Contienen información sobre los hosts administrados
como nombre de host, dirección
IP, memoria, etc. Y se pueden utilizar como
cualquier otra variable. Ahora, es útil
saber en qué estado se encuentra
el host administrado como para determinar las acciones que hay que
hacer en ese host administrado. Los hechos ansibles tienen una relación padre-hijo
con sus elementos. Entonces ahora que tenemos una comprensión
de
base de lo que son los hechos ansibles, veamos algunos
ejemplos prácticos sobre cómo usar hechos ansibles
en nuestro entorno. Ahora, el primer comando es, podemos ver aquí en la diapositiva es el servidor Ansible
una configuración menos M. Esto ejecutará el módulo de
configuración y así imprimirá todos los
hechos ansibles para el servidor a. ahora, si quisiera ver
el FQDN del host gestionado, puedo usar los hechos de
subrayado de Ansible, FQDN. Si me gustaría ver
la dirección IPV4 predeterminada, puedo usar los hechos de
subrayado de Ansible, direcciones IPV4
por defecto. Ahora, puedo establecer los
hechos recabados a sí o no, afirmando si me gustaría que el
playbook recoja hechos sobre los anfitriones administrados o no reúna hechos sobre
los anfitriones de gestión. Así que tomemos lo que
hemos aprendido sobre variables y pongamos eso en práctica durante la
demo. Nos vemos pronto. Ahora, como pueden ver, estoy en el
directorio de variables de host donde ya
he creado el archivo de configuración de
Ansible y el inventario. Como se puede ver en el archivo de
configuración, tanto la
sección sexual por defecto como la escalada de
privilegios están en orden. Dentro del inventario,
tengo servidor a, servidor B, y el grupo que contiene tanto servidor como servidor B. Así que vamos a empezar y escribir un playbook con estos
tres guiones asociados. El nombre de mi playbook
será mi obra de teatro, y eso será específicamente
apuntando al servidor a. Ahora voy a iniciar
la sección de versículo donde incluiré
mi variable. Mi variable se llamará usuario y tendremos el
valor de Andrei. Por lo que ahora puedo iniciar
la sección de tareas. Mi primera tarea se
llamará crear usuario. Estaré usando el módulo de usuario. El nombre de mi usuario
será el usuario variable. Como se puede ver, el
estado estará presente. Así que déjame simplemente guardar y salir de
este playbook usando WQ. Y ahora ejecutemos el playbook usando el comando
Playbook de Ansible, especificando el nombre
de mi playbook. El anticuerpo está recopilando hechos. Y como podemos ver en
la salida, ambos son verdes, por lo que
no hubo cambio en los hosts de gestión. Eso significa que mi usuario ya
estaba presente. Así que cambiemos el
nombre de mi variable. Ahora, el valor de mi variable ya no
será Andrei. El valor de mi variable
será usuario variable. Y
volvamos a ejecutar el playbook usando el playbook de Ansible. Como se puede ver en la salida, hubo un cambio en la encuesta. Así que veamos si ambos usuarios, Andrei así como usuario variable, sí existen en el host Manage. Entonces ejecutaré Ansible
server un comando menos m, y leeré la slash, ETC slash pass archivo VDI
usando el comando cat. Y podemos ver claramente aquí
que tenemos tanto Andre, que tiene un nuevo
ID de 1 mil, así
como el usuario variable, que tiene un nuevo ID de 1004. El libro de
jugadas ha funcionado adecuadamente. Ahora vamos a añadir otra
variable a la mezcla. A la variable se le
llamará estado y tendrá un valor de ausente. Esto destruirá a nuestro usuario. Por lo que acabaré de reemplazar el
estado
del presente a la variable de Estado que
he declarado de antemano. Guardaré anexo el
playbook y lo ejecutaré nuevo usando el comando
Playbook de Ansible. Ahora, el playbook se está
ejecutando y
tomará un poco de tiempo para
Ansible juntos o hechos. Pero como podemos ver por
el estado de la tarea, el usuario ha sido destruido
adecuadamente. Así que ahora vamos a declarar variables
dentro de un archivo variable. Voy a crear un nuevo
directorio llamado Vars. Y dentro de ese directorio, crearé un nuevo archivo
llamado variables dot YAML. Ahora, dentro de este fichero, declararé mis variables. Mi primera variable será usuario, que tendrá el
valor del archivo de prueba. Y mi segunda variable
será estado, que tendrá el
valor de presente. Guardaré y saldré de este archivo. Y voy a empezar a modificar
el playbook de nuevo. Entonces primero, eliminaré las secciones variables
que ya creé. Voy a utilizar las
teclas de acceso rápido DD dentro de VIM, y eso creará una nueva
sección llamada vars files, donde colocaré la ruta del archivo variable que previamente
creé. Entonces vars slash
variables dot YAML. Ahora guardaré y saldré de
mi archivo de playbook usando WQ. Y ejecutaré el archivo de playbook usando el comando
Playbook de Ansible. Nuevamente. Demos a Ansible
segundo juntos son hechos. Y a juzgar por la salida, ha
habido un
cambio para servir array. Vamos a usar un comando ad
hoc para ver nuevo
lo que hay en el archivo
VDI pasado. Y como se puede ver, usuario
testfile sí existe
y tiene una nueva idea de 1004. Y nuestro usuario anterior que
creamos previamente, no existe ya que cambiamos
el estado a ausente. Así que editemos nuestro
libro de jugadas una vez más. Destruiré la sección de archivos de
virus que creé previamente. Y cambiaré el
estado del usuario de estado variable a presente. Guardaré y
saldré del playbook. Y utilizaré VIM para
abrir mi fichero de inventario. Ahora en el mismo servidor de
ancho de línea a, definiré mi variable de usuario. Escribiré el nombre
de mi variable es igual al valor que
será inventario de prueba. Lo guardaré a
continuación el inventario e intento volver a ejecutar
el playbook. Ahora, vamos a dar a Ansible 1
segundo juntos son hechos. Y el servidor a ha
reportado un estado de persecución. Vamos a utilizar el comando ad hoc
para pasar CD archivo VDI. Y podemos ver que se
creó el inventario de
prueba y tiene
una nueva idea de 1005. Eso se debe a que
la variable de usuario se importó
del archivo de inventario. Ahora primero lo haré el usuario
iguala línea de inventario de prueba, y luego
crearé una nueva sección. A esta sección se
llamará servidores vars. Dentro de esta sección,
definiré mi variable de usuario
y tendrá el valor del grupo de
inventario de prueba. Guardaré y
saldré del inventario. Y modificaré el playbook para apuntar no solo al servidor a, sino a los servidores de grupo, que incluye tanto encuesta
como servidor B. Y ejecutaré el playbook usando el
playbook de Ansible comando. Ahora solo esperemos un segundo. Y a juzgar por el estado tanto
del servidor como del servidor B, hubo un cambio
y podemos ver el
usuario del grupo de inventario de prueba sí existe
tanto en el servidor a como
en el servidor, lo más probable es. Ahora para nuestro próximo ejercicio, que creará un
directorio llamado virus host, cual contendrá variables de host. Estaré usando el comando
MKDIR y luego
cambiaré de directorio dentro
del directorio host var. Voy a crear un archivo
llamado servidor a. dentro de este archivo, definiré una variable de usuario que
tenga el valor de test, var server a.
guardaré y saldré de este archivo, y luego crearé
un servidor sea archivo, que tendrá el valor
de test var server B. Voy a guardar y salir. Entonces usaré VIM para
ingresar al fichero de inventario y eliminar este
servidor var secciones que creamos previamente. Ahora, todo lo que queda es ejecutar el playbook usando el comando Playbook de
Ansible. Ahora, vamos a dar a Ansible 1
segundo juntos son hechos. Y a juzgar por la salida
de la tarea crear usuario, podemos asumir con seguridad que
los usuarios fueron creados, pero vamos a validar eso
leyendo el archivo de video pasado. Y podemos ver el
test var server, a, server a con un nuevo ID de 1007. Ahora vamos a ejecutar el mismo
comando en el servidor B. Ahora, a juzgar por la salida, podemos ver la prueba
var server be user fue creado
con éxito
y tiene un UID de 1006. Así que ahora vamos a borrar la pantalla
de todo este desorden y vamos a modificar el
libro de jugadas una última vez, que se ingresan al
playbook usando VIM. Y ahora definiré de nuevo
la sección de virus. Pero ahora voy a crear una matriz. El nombre de la matriz se
llamará array de prueba. El primer campo de la
matriz será la primera matriz. Y esto tendrá un campo de nombre con el valor de primero, y un campo llamado UID
con el valor de 1011. Mi segunda matriz
se llamará secundaria, y eso también tendrá un campo
de nombre con el valor de segundo y un nuevo ID
con un valor de 1012. Ahora, vamos a modificar el módulo, el módulo de usuario
más específicamente. Y reemplazaré la variable de
usuario con
la variable de matriz de prueba
dot primera matriz nombre de punto. Ahora dentro de este módulo, también
incluiré
el campo UID. Ese campo UID que
tenía el valor de la matriz de prueba variable
dot primera matriz ID de punto. Y ahora puedo guardarlo junto
al playbook y ejecutar el playbook usando el comando Playbook de
Ansible. Ahora, solo esperemos 1 segundo. Y a juzgar por la salida, hubo un cambio tanto en la
encuesta como en el servidor B. Ejecutemos un comando ad hoc
para ver qué se hizo. Y podemos ver que el usuario
llamado primero sí existe. Y sí tiene
una nueva ID de 1011. Por lo que ha funcionado perfectamente. Ahora, para la última
parte de nuestra demo, jugaremos un poco
con hechos ansibles. Utilizaré el módulo de
configuración de Ansible para enumerar todos los hechos asociados con host
disminuido llamado servidor. Esto toma un poco tan ansible
necesidades juntas como hecho. Y como pueden ver, tenemos todos los hechos
enumerados en nuestra pantalla. Esto no es muy útil, así que ejecutaré el
mismo comando ahora, pero canalizaré la salida a un
archivo llamado facts dot YAML. Y utilizaré VIM
para ingresar a ese archivo. Y podemos ver toda
la información que también recoge
en gestionar hosts. Ahora es importante tomar
nota del espaciado porque esto nos dice qué hijo
pertenece a qué padre, lo
cual es esencial a la hora de
trabajar con hechos ansibles. Empezaré un nuevo
playbook llamado playbook facts dot YAML. Empezaré el playbook como cualquier otro playbook
con tres espacios. El nombre de este playbook se
mostrarán hechos, y se dirigirá
específicamente al servidor B. Ahora, iniciaré
la sección de prueba donde solo tendré una tarea. El nombre de esa tarea
será mostrar hechos. Y estaré usando el módulo de debug para
mostrar un determinado mensaje. El mensaje sonará
algo así. El FQDN es. Y luego usaré la variable
de hecho de
Ansible para mostrar el FQDN del Servidor. Por lo que ahora, después de terminar, solo guardaré
y
saldré y ejecutaré el playbook usando el comando Playbook de
Ansible, especificando el nombre
de nuestro playbook,
más específicamente, los hechos del
libro de jugadas dot YAML. Ahora los mensajes, el
FQDN son hechos ansibles. Fqdn que no
resultó como se esperaba. Ten en cuenta, sí dije
que hechos o
variables ansibles porque
no incluí los reconocimientos. Ansible no sabía
que era una variable, por lo que la trató como
parte de una cuerda. Ahora, voy a modificar
el playbook en los elotes
necesarios para después guardar y salir. Y eso volverá a ejecutar el playbook usando el comando
Playbook de Ansible. Ahora, después de que Ansible haya
terminado de reunir sus tareas, podemos ver que el
mensaje es correcto y nos
muestra el FQDN del servidor ser. Por lo que felicitaciones,
Funcionó perfectamente. Entonces felicitaciones. Aprendimos sobre
variables ansibles y
cómo definirlas y utilizarlas
dentro de los playbooks, también
miramos hechos ansibles y cómo usar estos estados. Nuestros propios playbooks o tarea. Fue bastante intensivo,
tan agradable ir. En la segunda parte, estaremos aprendiendo sobre los bucles Ansible. Así que nos vemos pronto.
8. Bucles Ansible: En el video anterior,
hablamos variables
ansibles y
también hechos ansibles. Aprendemos a usarlos
dentro de playbooks y también tan altos versátiles y
útiles que pueden ser. Ahora veremos
los bucles Ansible, qué son, y cómo
usarlos dentro de los playbooks. Entonces sin más preámbulos,
comencemos. Entonces, ¿qué son los
bucles Ansible y por qué
son útiles donde los
bucles se utilizan para realizar la misma
tarea en un conjunto de datos sin
escribirlos varias veces. Ansible admite
bucles sobre datasets y también admite
bucles sobre hashes. Entonces para hacer las cosas un
poco más prácticas, veamos algunos
bucles de muestra y discutiéndolos. Ahora lo primero
que tenemos en esta diapositiva es un bucle simple. Reinicia tanto el
servicio HTTPD como este servicio. Utiliza el
módulo de servicio y el nombre
que llama es
el elemento variable. Ahora el valor de item está en bucle entre HTTPD y crone D. También
podemos usar bucles
junto con variables. Definimos las variables
en la sección var. Como se puede ver, la
variable de servicios tiene tanto
el valor de HTTPD corona D. Y luego podemos recorrer
estos servicios valiosos, ejecutando
así las
tareas para reiniciar tanto HTTPD como también como creció D. Como se indicó anteriormente, Ansible
también soporta bucles hash. Esta tarea en particular
crea la parte del usuario de un grupo específico y utiliza
el módulo de usuario para hacerlo. El nombre del usuario es
la variable item.name, y los grupos de los que forma parte
es la variable de grupos de puntos de elemento. Estos ítems toman
diferentes valores medida que los atraviesas. En la primera iteración, el nombre será Andrew y los grupos
serán automatización. En la segunda iteración, el nombre será Alexander y los grupos
serán automatización, creando
así dos usuarios, cada parte del
grupo Automatización. Así que ahora que
tenemos una bastante buena visión
teórica de los bucles, vamos por la demo. En esta demo ya tenemos nuestro archivo de configuración de Ansible y material de inventario,
como se puede ver. Así que empecemos y
creemos un playbook llamado playbook dot YAML. Empezaremos el playbook, clásico tres líneas
y el nombre de mi playbook serán bucles. Se dirigirá a todos los anfitriones
dentro del inventario. Mi primera tarea se
llamará servicios de reinicio. Y para
reiniciar los servicios, estaré usando el módulo
de servicio. Ahora, el nombre de los
servicios que voy a estar reiniciando será
el ítem variable. Y se reiniciará el estado de los
servicios. Ahora, con el fin de dar valores
a la variable ítem, pasaré a través de ambos
firewall D así como corona D. Guardaré y saldré
del playbook usando w q. y ejecutaré el playbook usando el Ansible
comando playbook. Ahora que el anticuerpo ha
terminado de recolectar, es hecho podemos ver
que en ambos servidores, un servidor sean los ítems firewall D y los ítems cultivados D,
donde empezamos. Por lo que acabaré de borrar la pantalla y modificaré
el playbook. Nuevamente. Eliminaré los valores
a través de los cuales estoy haciendo un bucle. Empezaré una nueva sección
llamada sección d bar, donde definiré
una nueva variable. Esto valioso se
llamará servicios. Y la variable de servicios
en realidad tendrá dos valores. El primer valor será corona d, y el segundo valor
será firewall el. Y en lugar de
recorrer dos valores, estaré haciendo un bucle a través de
la variable de servicios. Guardaré y
saldré del playbook. Y ejecutaré el
playbook usando el comando Playbook de Ansible. Y se ha estrellado. Y se ha estrellado porque
esta es una variable. Por lo que debería utilizar
comillas con el
fin de indicar claramente
esto a Ansible. Pongo este servicio es variable
entre comillas. Voy a guardar y salir de nuevo
el playbook e intentar ejecutarlo de nuevo con el
comando Playbook de Ansible tendrá que
esperar un poco a Ansible
juntos son hechos. Y como se puede ver, tanto en servidor
como en servidor sea la
variable item al valor de
crown D y firewall D, los mismos valores que tenían
estos servicios valor. Ahora, volveré a modificar
el playbook. Primero eliminaré la sección var que
creé previamente. Y después
eliminaré por completo este
módulo de servicio y el bucle, cambiaré el
nombre de mi tarea de reiniciar servicios
para crear usuarios. Y eso será utilizando
el módulo de usuario. Con el fin de hacer esto. Entonces el usuario de Emma será el nombre de punto de elemento variable porque estaré
usando un bucle hash. El UID de mi usuario será
el valor del ítem dot UID. Y ahora tengo que
recorrer una matriz de valores. Entonces el nombre primero
será el usuario de bucle uno, y el UID asociado al usuario de
bucle uno será 1015. Y el segundo valor
será usuario de bucle to for name. Y el UID para el
usuario de bucle dos será 1016. Guardaré y saldré y ejecutaré el playbook usando el comando Playbook de
Ansible. Ahora sólo tenemos que
esperar un segundo Ansible juntos es un hecho. Y como se puede ver, el item.name tomó el
valor del usuario de bucle uno tanto en el servicio a como en el
servicio B y el usuario de bucle dos. Y la UID tomó el valor
de 1015 y también de 1016. Podemos comprobar los resultados
haciendo un comando cat en el pasado archivo VDI del
servidor o servidor B, y podemos ver que ambas
entidades están presentes. Para que concluya nuestra demo. Así que felicitaciones ahora
entiendes qué
son los bucles responsibles y cómo usarlos dentro de los playbooks
para que
tu trabajo sea menos laborioso
y más eficiente. En la siguiente parte de nuestro curso, que estaremos aprendiendo
sobre condicionales. Por lo que espero
verte ahí.
9. Condicionales visibles: Anteriormente aprendimos tanto
sobre variables como de
bucles y su utilidad
dentro de los playbooks. En este video, estudiaremos condicionales,
manipuladores y bloqueadores de
Ansible. Entonces tenemos mucho que cubrir. Así que comencemos
como soportes opuestos evaluaciones
condicionales
antes de ejecutar una tarea específica en
el host objetivo. Si la condición
es cierta, contesta, pero seguiremos adelante
y realizaremos la tarea. Si la condición no es verdadera, Ansible omitirá
esta tarea especificada. Entonces veamos algunos
condicionales de muestra dentro de Ansible. Ahora el primer ejemplo es
un simple condicional. Dentro de la sección de barras tenemos
una variable llamada servicio, cual se define ambos. N tiene el valor de firewall D. La tarea instala un servidor está determinada por el valor de la variable
discutida anteriormente. La tarea también cuenta con
un símbolo condicional, que establece que
esta tarea se ejecuta sólo cuando se define el
servicio variable. Ahora el segundo ejemplo es
un poco más complicado. Tenemos dos variables,
condición uno, que tiene el valor de una, y condición dos, que
tiene el valor de 0. También tenemos una tarea
que creará un usuario solo cuando la condición uno tenga el valor de uno
y cuando la condición dos tenga un valor menor
o igual que uno, que es el caso. Yo mencioné al
inicio de ese video que también
conoceremos sobre los manejadores de
Ansible. Los manejadores son tareas
que se ejecutan sólo si han sido
notificados por otra tarea. Se escriben en una sección
separada
del libro de jugadas y son
notificados por su nombre. notificación solo
ocurre cuando un cambio es reportado por la tarea
encargada de notificar al manejador. Si la tarea no
informa el cambio, entonces el manejador
no será notificado. Entonces veamos el ejemplo
más práctico. Aquí tenemos tanto
la sección de tareas definida como también la sección de
manejadores. En primer lugar, agregaremos una
nueva regla al firewall d, utilizando el módulo firewall
d para permitir tráfico para el servicio HTTPD. Y esta regla
será persistente. Ahora esto notificará al
manejador llamado reinicio firewall D. Este controlador
reiniciará el firewall, este servicio utilizando
el módulo de servicio. Por último, hablaremos
un poco de bloques. Lo que nuestros bloques, bloques son
cláusulas qué tareas de grupo, y determinar cómo se ejecutan
las tareas. Bloques en combinación con rescate ayuda con el manejo de
errores. Si falla la tarea dentro
del bloque, entonces la
sección de rescate vamos a ejecutar. El siempre apartado se ejecuta
sin importar las circunstancias. Quisiera mencionar también
que los bloques también se pueden utilizar en conjunto
con cuando condicionales. Entonces ahora que tenemos una bastante buena
comprensión de manejadores, bloques y condicionales,
pasemos a la demo. Para que como pueden ver, ya
he creado el
archivo de configuración de Ansible y el inventario, y eso
creará el playbook llamado condicionales dot YAML. Empezaré este playbook como cualquier otro playbook
con las tres líneas. Y el nombre de mi primera
jugada serán condicionales, y se dirigirá a todos los anfitriones. Ahora, también
declararé una variable en diversa sección del
playbook llamado servicio. Esta variable tendrá
el valor de HTTPD. Ahora, puedo iniciar
la sección de prueba. Ahora dentro de la sección de impuestos, primero
crearé una tarea que se llama
instalar un servicio. Y usaré el módulo
yang para esto. El nombre del
servicio instalado será determinado por el valor de la variable de servicio
y el estado será más reciente. También incluiré un
condicional simple cuando se defina el
servicio. Por lo que eso significa que el
servicio sólo se
instalará es la
variable de servicio está definida. Y utilizaré el playbook de
Ansible con el
fin de ejecutar nuestro playbook condicionales
dot YAML. Ahora, esperemos un poco a
Ansible juntos son hechos. Y instalar el servicio
tomará un poco de tiempo. Así que no te preocupes si se
necesita más de lo habitual. Ahora, podemos ver que
el estado del cambio ha aparecido en el servidor B. Entonces eso significa que
el servicio HTTPD fue instalado en el
servidor sea muy probable. Y ahora también
ha aparecido el estado de cambio para servidor a.
borraré la pantalla y
comenzaré a editar
los condicionales dot YAML playbook, que creamos previamente. En primer lugar, eliminaré la sección versículo del
playbook y luego simplemente eliminaré todo y renombraré la tarea que creamos previamente desde el servicio de instalador
para crear un nuevo archivo. Voy a utilizar el
módulo de copia para esto. El contenido que estoy
colocando es un mensaje. Y este mensaje establece
que este es servidor, un destino donde se colocará este
contenido es en slash home slash automatización
slash condicionales. Ahora esta tarea sólo se ejecutará en una situación
específica. Sólo cuando el nombre de
host de Ansible sea el mismo que el servidor de valores a. guardaré y saldré de
mi playbook y
borraré la pantalla y
ejecutaré mi playbook. Así que esperemos un poco a
Ansible juntos son hechos. Y podemos ver que el
servidor B fue omitido, pero hay un cambio de
estado en el servidor a, que se conectará usando SSH al servidor una lista de deseos los contenidos. Y ahora cuando
leemos el contenido de los
archivos condicionales, se sirve array. Entonces funcionó perfectamente. Entonces felicitaciones,
hemos aprendido a usar condicionales de una manera
más práctica. Y a continuación estaremos
mirando a los manejadores y cómo usarlos. Primero crearé un playbook
llamado handlers dot YAML. Nuestro inicio este playbook como
cualquier otro playbook con tres líneas para señalar el
inicio del playbook. El nombre de mi primera
jugada será manejadores, y se dirigirá a todos los
anfitriones dentro de mi inventario. Ahora puedo iniciar mi sección de pruebas. Aquí, voy a crear una nueva tarea, y la tarea tendrá el
nombre de agregar nueva regla de firewall. Estaré usando el cortafuegos. El módulo para este
servicio es HTTP, y el estado de mi
regla está presente. Y también lo
haré permanente. Eso significa que persistirá después del reinicio o después de que se
haya reiniciado el servicio. Ahora lo notificaré a nuestro manejador. El manejador se
llamará reinicio firewall D. Y la palabra clave
aquí es notificada. Entonces crearé
la sección de manejadores. Dentro de esta sección,
voy a crear un nuevo manejador con el nombre de
reiniciar firewall D. Así que es lo mismo que el
que está siendo notificado. El manejador usará
el módulo de servicio y reiniciaremos el servicio llamado firewall D.
Entonces el nombre será firewall D y se
reiniciará el estado. Ahora guardaré y saldré. Y veamos si esto
funciona como se pretendía. Ejecutaré el playbook usando los manejadores de
comandos de Ansible playbook dot YAML. Ahora,
esperaremos juntos a Ansible. Son hechos y como
se puede ver, ha fracasado. Y esto fue intencional. Ahora esto es porque
escribí erróneamente el estado del módulo d
firewall. Pero lo que quería
mostrarles es que si la tarea ha fallado o no se informa de
estado de cambio, el manejador no será notificado y
no se ejecutará. Por lo que ahora voy a modificar el
playbook para que funcione. Cambiaré el estado
del módulo firewall d del
presente equivocado A habilitado. Guardaré y
saldré del playbook. Y borraré la
pantalla e intentaré volver a ejecutar el playbook usando el comando Playbook de
Ansible. Como se puede ver, la
recolección de anticuerpos engorda. La primera tarea
se ejecutó sin errores y se ejecutó el controlador. Entonces eso significa que el firewall, el servicio fue
reiniciado y notificado. Si volvemos a ejecutar el playbook porque
no hay cambio de estado, entonces el manejador no
fue notificado. Por lo tanto, el mango no fue corrido. Por lo que ten en cuenta, solo
se notifica a un manejador si la tarea encargada de
notificarlo reporta un estado de cambio. Así que ahora pasemos a las cuadras. Primero, crearé un playbook
llamado blocker dot YAML. Lo empezaré como cualquier otro
playbook con tres líneas. Y voy a nombrar mi primer uso de
jugadas de bloqueadores. Ahora, voy a apuntar a todos los anfitriones y puedo
iniciar la sección de tareas. Ahora dentro de la sección fiscal, primero
definiré mi bloque. El nombre se
instalará HTTPD, y luego incluiré
el bloque de palabras clave. Ahora las primeras tareas
dentro de mi bloque
intentarán iniciar
el servicio HTTPD. Se llamará Start HTTPD, y usaremos el módulo
de servicio. El nombre del servicio es HTTPD y se inicia el estado. Ahora puedo iniciar la sección de
rescate. Si algo sale mal
en la sección del blog, la sección de rescate iniciará
automáticamente esta tarea. El apartado de rescate
tendrá una tarea con el nombre de instalar HTTPD. Utilizará el módulo yum. El nombre del servicio
que se instalará es HTTPD y el estado es más reciente. Ahora antes de salir de mi playbook, me gustaría señalar que la
sección de bloque y rescate debe tener el mismo nivel de
sangría parece bien ahora, así que solo voy a guardar
y salir e intentar para ejecutar el playbook usando el comando Playbook de
Ansible, que tendrá que esperar un poco
a Ansible juntos son hechos Start falló, claro. Y como se puede ver, la tarea HTTPD instalada comenzó
la tarea HTTPD instalada
dentro de la
sección de rescate. Si intento volver a ejecutar
el playbook, en este punto, la sección de
rescate no
debería comenzar
mientras empiezan. tarea Httpd debe comenzar. Entonces veamos si eso
realmente sucede y podemos ver que
es exactamente como se esperaba. Esto concluye nuestra demo. Así que muchas gracias. Enhorabuena.
Hemos terminado esta parte de nuestra sección. Y en la siguiente sección, que será el buceo profundo en plantillas
ansibles. Nos vemos pronto.
10. Plantillas ansible: Anteriormente aprendimos sobre
bucles y condicionales. Así que terminemos esta sección
discutiendo plantillas. Al final de esta
lección, tendrás una buena comprensión
de qué son las plantillas, cómo crearlas,
y su utilidad en gestión de archivos usando Ansible. Así que empecemos. Entonces, ¿qué hace que las plantillas sean
tan importantes? Bueno, el uso de plantillas facilita la
administración de archivos, además de personalizar esos
archivos para el host administrado. Se escriben en jengibre a la sintaxis y se despliegan
utilizando el módulo de plantilla. Las plantillas pueden utilizar tanto nuestros hechos y variables
ansible, y también soportan
bucles y condicionales. Hagamos las cosas un
poco más prácticas al mirar
primero el módulo de
plantilla, y después veremos algunos archivos de ejemplo de plantillas. Ahora se trata de un simple uso
del módulo de plantilla. Tenemos el CRC que indica la fuente de donde es la
plantilla, el destino, dónde colocar el archivo de plantilla
en el host Manage. Y también podemos establecer
cosas como propietario, grupo y permisos para
ese archivo en el host Administrar. Ahora estas no son
las únicas opciones que ofrece el módulo de plantilla y puedes usar el documento de
Ansible para obtener más información al respecto. Ahora, veamos un archivo de plantilla de
ejemplo. La primera línea
emitirá el mensaje por FQDN es y el FQDN
del host administrado. Puedo hacer esto usando la variable hechos
ansible,
la segunda variable de salida de línea. Esta variable tiene
el valor de n, el valor de mi variable. Como se puede ver,
esta es claramente una variable por los reconocimientos. El tercer ejemplo está
destinado a mostrarle cómo funciona un bucle
for
dentro de cambio que para sintaxis el bucle de
servicio variable a través los valores de estas
superficies variable. El cuarto ejemplo
es también un bucle, pero el servicio variable solo
pasa por el valor de la variable services
excepto el valor de HTTPD. Y el último ejemplo te
muestra cómo crear un si condicional usando
ginger a la sintaxis. Entonces ahora que
entendemos cómo
se ven las plantillas y cómo implementarlas
usando el módulo de plantilla, hagamos algo
más práctico dentro de la demo. Nos vemos pronto. Ahora. Como se puede ver, ya
he creado
un
fichero de configuración y el inventario. Así que lleguemos a
crear el playbook. Lo nombraré
playbook dot YAML. Ahora, iniciaré el
playbook con tres líneas y el nombre de mi primera jugada se
llamará plantillas. Estaré apuntando a todos los
anfitriones dentro de mi inventario. Y ahora iniciaré
la sección de prueba. Ahora el nombre de mi primera tarea se llamará colocación
de plantilla. Y estaré usando
el módulo de plantilla. En primer lugar, voy a especificar el
origen de la plantilla, que será en slash
home slash automatización slash plantillas slash slash template. El destino donde se colocará en
el anfitrión gestionado. El destino será slash
home slash automatización slash plantillas de
slash. Guardaré y saldré
del playbook usando WQ. Entonces crearé
el archivo de plantilla. Por lo que el archivo de plantilla
contendrá el siguiente contenido. Mi nombre de host es, y utilizaré la variable hechos
ansible para personalizar
este mensaje. Para cada gestionar hosts
dentro del inventario, guardaré y saldré de
la plantilla usando WQ. Y luego intentaré
ejecutar el playbook usando el comando
Playbook de Ansible. Así que esperemos
un poco a Ansible juntos son hechos
y veamos el resultado. Aunque Ansible ha reportado el estado del cambio tanto en el
servidor como en el servidor B. Así que utilicemos un comando ad hoc de
Ansible para ver el contenido
del archivo de plantillas. Primero veremos el servidor
a usando el módulo de comando para ejecutar
un comando cat en slash, home slash automatización
slash plantillas. Y como se puede ver en el mensaje,
mi nombre
de host es servidor a. ejecutemos el mismo comando, pero ahora en el servidor B y C, si el nombre del host es el servidor B, que es, nuestro
archivo de plantilla ha funcionado perfectamente. Felicidades. Ahora
acabaré de borrar la pantalla y
reanudaremos la demo. Ahora, editemos
nuestro archivo de plantilla. Eliminaré lo que
escribimos anteriormente, y
lo reemplazaré por un bucle for. Por lo que usaré d para
host en grupos. Todo esto significa que
la variable host pasará por todos estos
servidores dentro de mi inventario. Voy a cerrar los reconocimientos y
escribiré la
variable host vars,
host, ansible, hechos, nombre de host. Y terminaré los cuatro
Usando el final para la declaración. Guardaré y
saldré del playbook, e
intentaré ejecutar el playbook usando el comando
Playbook de Ansible. Ahora,
esperemos un segundo para Ansible juntos son hechos. Y a juzgar por la salida, ha reportado un estado de cambio tanto
en el servidor como en el servidor b Así que vamos a ver qué hay en los archivos de
plantilla en el servidor. El mensaje es
servidor a, servidor B. Y el mismo mensaje
también está presente en el servidor a. ahora eso es porque
dentro de mi inventario, sólo
tengo servidor y
servidor ser la variable host que va los bucles a través de todos los
hosts dentro de mi inventario, que nuestro servidor y servidor B. Y los escribe dentro
del archivo de plantilla. Ahora, voy a crear un nuevo
grupo llamado Just server a. e intentaré
cambiar el archivo de plantilla. Nuevamente. Cambiaré
los grupos a solo servidor un nuevo grupo
que acabo de crear. Y ahora guardaré y
saldré de este cambio e intentaré ejecutar el playbook usando el comando
Playbook de Ansible. Ahora el mensaje que
debería estar presente en ese archivo debe ser
ahora servidor a. así que validemos
esto ejecutando previamente
el comando ad hoc. Y podemos ver que sólo el
servidor a está dentro de ese archivo, tanto en servidor
como en servidor. Porque ese es el grupo al
que me dirigía dentro mi archivo de plantilla usando
la variable groups. Así que ahora eliminemos todo lo
que escribimos previamente. Y ahora haré una declaración
condicional. Empezaré mi
declaración condicional con la
palabra clave if y luego
escribiré mi condición. Mi condición
será la siguiente. Si el nombre de host
del host administrado está en el grupo
llamado Just server a, entonces emitiré
un mensaje específico. Ahora, mi mensaje
será el siguiente. Ese servidor está en el
grupo, solo servidor a. terminaré mi
condición con el final si palabra clave y voy
a empezar una segunda. Esta segunda
condición, veremos el nombre de host
del host administrado. Y si no está en el
grupo llamado Just server a, entonces emitirá
un mensaje diferente. El nuevo mensaje
será el siguiente. Yo no estoy en el grupo. Y también terminaré con
esta if-cláusula. Ahora, solo guardaré y
saldré del playbook e intenté ejecutarlo usando el comando Playbook de
Ansible. Ahora esperaremos un poco para que el
asfalto recoja hechos. Y vamos a validar nuestro archivo que creamos usando
el
comando ad hoc de Ansible con el módulo de comando fin de generar el contenido
del archivo de plantillas. El servidor está en el grupo,
sólo sirve array. Y hagamos esto por el servidor sea, no
estoy en el grupo, por lo que ha funcionado perfectamente. Ahora, borraré la pantalla y editaré la plantilla.
Una última vez. Eliminaré todo lo
que escribimos previamente y
escribiré un nuevo mensaje. El mensaje
será el siguiente. Voy a crear un nuevo usuario llamado N, llamar a una variable
llamada usuario. Entonces escribiré una segunda línea que contenga el
siguiente mensaje. Este usuario shell el comentario y invoca el valor
del comentario variable. Y por último, escribiré una tercera línea
que contiene al usuario se coloca en D y llamaré a
la variable del servidor. Guardaré y saldré
del archivo de plantilla y comenzaré a editar el archivo de playbook. Entonces, lo que voy a hacer, agregaré una nueva sección que
se llama Vars. Bueno, declararé las
variables mencionadas anteriormente. Los usuarios deben tener
el valor de Andrei, comentario tendrá el
valor de mi comentario, y el servidor tendrá
el valor del servidor. Ver. Ahora, intentaré
ejecutar el playbook usando el
comando Playbook de Ansible. Esperemos un poco. Y a juzgar por la salida, no ha
habido un cambio tanto en el servidor como en el servidor B.
Así que vamos
a validar nuestro trabajo usando el comando ad hoc para comprobar
el contenido del archivo de plantillas. Por lo que voy a crear un
usuario llamado Andre. Esta habitual
tendrá el comentario,
mi comentario que el usuario se
coloca en el servidor ver, pero esto está presente
tanto en salario como en el servidor B. Así que llamé variables de mi playbook, que
funcionó perfectamente . Felicidades.
Ahora ya sabes cómo usar
archivos de plantilla, desplegarlos, crear bucles usando la sintaxis de actitudes de
cambio, crear condicionales
usando sintaxis Shadow y llamar a variables
dentro de las plantillas. Muchas gracias.
11. Importar libros de juego y tareas: Ahora, para nuestra primera lección, aprenderemos sobre libros de jugadas
importantes. Con este conocimiento,
podemos evitar crear grandes playbooks y simplemente crear otros más
pequeños, más específicos, que luego podemos importar
dentro de uno más grande y usar eso para lograr
nuestros resultados deseados. Entonces sin más preámbulos, no tiene sentido esperar, así que empecemos. Ahora, ¿por qué es importante
los playbooks importantes? Al escribir
libros largos los hace difíciles de seguir y entender. Dividir un
libro de jugadas grande en una serie de libros de juego
más pequeños
significa que también se pueden reutilizar en otros
proyectos. Ahora, los playbooks más pequeños,
como puedes imaginar, son más fáciles de manejar
y entender. Entonces importar un libro de jugadas
es una tarea estática, lo que significa que el contenido
importante se procesa antes de que comience
la reproducción. importación de un libro de
jugadas no se puede incluir dentro de la obra, y se ejecutan en orden
de arriba a abajo. Así que veamos algunos comandos
prácticos que
nos permiten usar la función de importación de
playbook. Ahora como se puede ver
en la diapositiva, para importar el playbook, estamos utilizando el
comando import playbook para nuestro primer ejemplo, estamos importando a playbooks, el playbook install dot YAML, y empiezan el playbook de puntos
YAML. Ahora, nuestro segundo ejemplo
está destinado a mostrarnos que la
función de libro de reproducción de importación se puede utilizar en conjunto
con condicionales. A modo de ejemplo, este playbook
llamado instalado que YAML es importante sólo cuando se define el servicio
variable. Nuestro último ejemplo está
destinado a mostrarnos que podemos mezclar
importaciones con juego. En este ejemplo particular, las tareas de mi obra
correrán primero y después. Las tareas importadas de mi
obra dos correrán después. Entonces ahora que tenemos una buena visión
teórica de cómo
funcionan los libros de jugadas importantes dentro de ansible. Hagamos algo
más práctico dentro de la demo. Nos vemos pronto. Como pueden ver, ya
he creado el archivo de
configuración de Ansible y el inventario dentro
del archivo de configuración, ya
tenía la configuración de sección
predeterminada y la sección de
escalada de privilegios. Y dentro del inventario, tenemos servicio a y servicio B y un grupo llamado servidores, y un pequeño grupo
llamado Just server a, que contiene servidor a. Ahora primero,
copiaré la slash, ETC slash HTTPD slash archivo
HTTPD de su fuente
original a mi directorio de trabajo. Ahora, utilizaré VIM
para editar mi copia local del archivo de configuración
HTTPD. Lo que estoy tratando de lograr
es conseguir que HTTPD obtenga su contenido no
del directorio de log de
slash var slash estándar . Pero voy a crear un nuevo directorio
personalizado llamado sitio web desde el que
obtendrá su contenido. Ahora, para hacer esto, agregaré algunas
líneas con el fin relajar el acceso a la raíz del documento
predeterminado. Y lo reemplazaré todo
por web flash. Por lo que también voy a reemplazar
el documento que escribió con
sitios web de slash slash HTML. Ahora puedo guardar y
salir y continuar. En primer lugar, crearé
un nuevo playbook llamado Install dot YAML, que tiene el propósito
de instalar el servicio HTTPD
en hosts administrados. Empezaré el playbook
con tres líneas. El principio estándar
que por nombre de mi primera jugada se
llamará HTTPD instalado. Se dirigirá a todos los anfitriones
dentro de mi inventario, e iniciaré
la sección de impuestos. El nombre de mi primera tarea
se instalará HTTPD. Estaré usando el módulo D
Yammer para esto. El nombre de mi servicio
será HTTPD, por
supuesto, y el
estado será más reciente. Guardaré y saldré de
este playbook y pasaré a la siguiente. Entonces crearé
un nuevo libro de jugadas. Entonces tu playbook, que
estaré creando se
llamará Content dot YAML. Ahora,
volveré a empezar este playbook con las tres líneas
estándar. El nombre de mi obra
se llamará nuevo contenido, y se dirigirá a todos los
anfitriones dentro del inventario. Ahora puedo iniciar mi sección de pruebas. Ahora dentro de mi sesión de tareas, tendré una primera tarea
llamada crear ruta. Esto creará el formulario de ruta donde mi servidor web obtendrá su contenido y usaré el módulo de archivos para
crear esta ruta. El camino será slash
sitio web slash HTML, y el estado será directorio, ya que este será un
directorio, por supuesto. Ahora la segunda tarea se
llamará colocación de plantilla. Y utilizaré el módulo
de
plantilla para colocar una
plantilla en ese camino. Voy a especificar la fuente, que se llamará plantilla, y el destino
será slash sitio web slash HTML
slash index.html. Guardaré y saldré y crearé
otro nuevo playbook. Este playbook se
llamaría HTTPD dot YAML. Empezaré este playbook
como cualquier otro playbook. El nombre de mi primera jugada
será HTTPD configure, y se dirigirá a todos los
hosts dentro de mi inventario. Ahora, empecemos
la sección de prueba. Ahora la primera tarea que tendré
se llamará copiar
archivo de configuración HTTPD o copiar HTTPD tos. Y estaré usando el
módulo de copia para transferir el archivo de
configuración HTTPD desde
mi directorio de trabajo a mis hosts administrados
en la slash, ETC. Slash HTTP slash
com slash HTTPD. Directorio. Entonces notificaré a
un manejador específico. El manejador se
llamará reinicio. Y voy a empezar la sección de
manipuladores. Ahora dentro de la sección del manejador, crearé el manejador
que estoy notificando. Entonces lo nombraré reinicio, y usará
el módulo de servicio para reiniciar el
servicio llamado HTTPD. Se reiniciará el estado. Guardaré y saldré usando WQ. Y luego crearé
otro playbook. Ahora este playbook se
llamará SELinux dot YAML. El propósito de este
playbook será establecer los contextos SELinux correctos a mi nueva ruta de sitio web de slash. Entonces nombraré la primera
jugada como una solución de Linux. Se dirigirá a todos los hosts dentro mi inventario y dentro de
la sección de prueba, tendré dos tareas. Ahora el, el nombre de mi primera
tarea se establecerá SELINUX, y utilizaré el
módulo de comandos para hacer esto. Ahora el comando
que ejecutaré en el host administrado
es el siguiente. Se administra contexto F
menos a para anexar, menos T para tipo, especificando el HTTPD
dice el tipo de contenido T. Y el camino que estoy
apuntando, en nuestro caso, estoy apuntando a d slash
ruta del sitio web y todos los directorios. El
camino del sitio web d slash. Esto se hace. Voy a crear una nueva tarea con
el nombre de restore con, usando nuevamente el módulo de comando para ejecutar el siguiente comando, restore con menos r para recursivo en d
slash website path. Esto relablará
todos los contenidos de la ruta del sitio web de slash
al nuevo contexto SELINUX. Ahorraré y saldré. Y ahora puedo iniciar mi plantilla. Ahora que mi plantilla
contendrá el siguiente mensaje. Hola, mi nombre es, y luego usaré la variable hechos
ansible para enumerar el nombre
de host del host administrado. Entonces para el servidor a, servidor, a, servidor B, eso sería plata B. Y voy a guardar y salir este archivo de plantilla
llamado plantilla. Ahora todo está hecho. Vamos a crear
nuestro libro de jugadas maestro. Vamos a llamarlo. Utilizaré VIM para crear un playbook
llamado playbook dot YAML. Y voy a empezar este playbook
como cualquier otro playbook. Y ahora voy a importar todos los playbooks que
creamos previamente. En primer lugar, voy a importar el playbook
instalado porque
necesitamos instalar HTTPD antes de
que podamos hacer cualquier otra cosa. Tan importante, playbook
instalar dot YAML. Entonces importaré el
playbook de contenido porque necesito contenido
dentro de mi servidor HTTPD. Así que importar
contenido de playbook dot YAML. Entonces importaré
el playbook llamado Ixe Linux dot YAML con el
fin de establecer el
contexto SELinux correcto a mi ruta. Más específicamente sitio web de slash. Tan importante playbook,
SELinux dot YAML. Y por último, importaré el
playbook llamado HTTPD dot YAML para
configurar correctamente mi servicio HTTPD. Ahora que todo ha sido
teóricamente importante, guardaré y saldré e
intentaré ejecutar el playbook. Tenemos todos los incendios aquí
presentes y contabilizados. Tenemos la plantilla, lo
tenemos todo. Así que utilicemos el comando
Playbook de Ansible para ejecutar el
playbook dot gamma, que creamos previamente. Ahora, esto tomará
un poco de tiempo. Ansible ha
recogido con éxito sus hechos. Ahora, está instalando el servicio HTTPD tanto en el
servidor como en el servidor B. Como puedes ver ahora se está ejecutando el segundo playbook y
colocando el contenido, creando la ruta,
colocando la plantilla, establecer los contextos SELinux, restaurar el contexto y hacer frente la configuración HTTPD y
también notificar al controlador. Vamos a probarlo con el comando actual y
podemos ver el mensaje,
Hola, mi nombre es salival y
hola, mi nombre es servidor B. Así que funcionó perfectamente. Enhorabuena. Ahora sabemos dividir un libro de jugadas grande en un
conjunto de playbooks más pequeños, que luego podemos importar en un playbook maestro y
hacerlos reutilizables. Entonces eso es bastante impresionante. Para que pueda importar
o incluir tareas en un play desde un archivo de texto al
usar la función de importación, las tareas son importantes
dentro del libro de reproducción. Cuando se analiza el libro de reproducción, al usar la función de importación, tampoco
se pueden usar bucles. Al usar la función
import junto con una declaración
condicional, entonces la
instrucción condicional se aplicará a todas las rutas que se importen. Ahora incluye esto un poco diferente al usar
la función include, las tareas se agregan a la jugada cuando se alcanza
ese punto
mientras se ejecuta la reproducción. Al usar la función
include en conjunción con una declaración
condicional. Entonces la
declaración condicional
decidirá si las tareas
están incluidas o no. Al usar la función include, no
puede notificar a
ningún manejador por dinero incluido archivo de tarea. Entonces ahora que
tenemos una bastante buena visión
teórica
de la diferencia entre incluir una
tarea importante de un archivo de texto. Vamos a seguir adelante y ver algunos comandos
prácticos
para hacer esto. Ahora para poder importar
tareas dentro de nuestro playbook, necesitaremos utilizar la función Importar
tarea especificando la ruta de nuestro archivo de tareas
escrito en formato YAML. En nuestro segundo ejemplo, las tareas dentro del archivo YAML de
mi tarea dot, o solo se ejecutan cada una de
forma individual cuando el servicio variable se define como los estados
condicionales. Y si
quisiéramos incluir tareas, necesitamos usar la función
include task. Y esto incluirá
dinámicamente tareas mientras la jugada se está ejecutando. Entonces vamos a entender cómo incluir
ambas tareas importantes. Podemos pasar a la demo.
Así que empecemos. Ahora, como pueden ver, ya
he creado el
fichero de configuración de Ansible y el inventario. Simplemente borraré la pantalla y ahora podremos crear nuestro archivo de tareas. El archivo de prueba se
llamará Crear punto YAML. Y comenzaremos con las tres líneas
clásicas. No tendrá nombre, pero usaremos el
módulo de usuario para crear un usuario el cual se define por
la variable de nombre de usuario, el estado del usuario
estará, por supuesto, presente. Entonces guardaré y
saldré de este archivo de texto
usando el comando w q. Y ahora voy a crear un nuevo archivo de tarea con el
nombre de plantilla dot YAML. También se iniciará con
las tres líneas clásicas. El nombre de mi tarea se
colocará archivo de plantilla. Utilizará el módulo de plantilla. Tal y como se esperaba. El origen se definirá
mediante el archivo de plantilla variable D. Ahora el destino
será un poco más único. Será un archivo
llamado mi archivo, pero la ruta a ese será definida por la variable d nombre de usuario. Entonces slash home, nombre de usuario
recorta mi archivo. Ahora, dependiendo del nombre de usuario, la ruta se ajustará
como se podría esperar. Así que ahora vamos a crear
mi archivo de plantilla. Lo llamaré plantilla, y el mensaje dentro de mi
plantilla será el siguiente, colocado por Ansible encendido, y luego usaré la
variable de nombre de host hechos
ansible para ajustarla y personalízalo al host de gestión. Incluyamos también un signo de
exclamación solo por diversión. Por lo que sólo voy a guardar
y salir y enumeraré el contenido
de mi directorio de trabajo. Y tenemos todos los archivos aquí para que
podamos trabajar en el archivo de playbook. Voy a empezar con las
clásicas tres líneas. El nombre de mi primera
jugada se creará usuario, final, lugar, plantilla. Uy, creo que hice el error, así que déjame simplemente
corregir que va a
apuntar a todos los anfitriones
dentro del inventario. Y ahora podemos iniciar
la sección de prueba. Ahora, dentro de la sección de prueba, crearé una tarea que
se llama include tarea, que utilizará la función de
tarea include
para incluir el archivo Crear
punto YAML. Y también definiré aquí
algunas variables locales, más específicamente la variable
nombre de usuario, que tendrá el
valor de usuario uno. Ahora voy a crear una segunda tarea que se llama plantilla de lugar. Aquí usaré también la función
include task con el
fin de incluir el fichero de tarea de punto
YAML plantilla que
creamos previamente. Especificando de nuevo la
variable nombre de usuario con el
valor de usuario uno. Y ahora solo
saldré y saldré. Y ejecutaré el
playbook usando el comando Playbook de Ansible
especificando la ruta de mi playbook. Así que esperemos un poco a
Ansible juntos son hechos. Como se puede ver, ambas pruebas
fueron incluidas dentro de la jugada y han reportado
estados de cambio en ambos servidores en
lugar de a o B. Así que me conectaré con
SSH en cerebral se emita el contenido de mi
usando el comando cat, slash
cat, usuarios de
slash home slash myfile colocado por Ansible en el servidor ser usuario uno sí existe. Entonces todo
salió bien. Enhorabuena. Ahora hemos incluido
archivos de tareas dentro de nuestros playbooks. Entonces felicitaciones. Ahora sabemos cómo importar
playbooks y también incluir o
archivos de tareas importantes dentro de nuestros playbooks. En el siguiente video y último
video de nuestra sección, veremos cómo apuntar a
un host específico usando comodines, patrones de
host, o enumerándolos. Muchas gracias
y nos vemos pronto.
12. Organizadores orientados: En las
lecciones anteriores,
aprendimos a importar playbooks y también cómo incluir o importar archivos de
tareas dentro de
nuestros playbooks. Terminaremos la Sección cinco de la automatización de seguridad con curso de
Ansible
aprendiendo a orientar a host
específico dentro de
nuestro inventario. Así que no esperemos
y empecemos. Entonces hasta ahora acabamos de utilizar
un objeto a la Ansible, que objetivo dentro
del inventario. Ahora el aceite del grupo contiene todos los agujeros dentro del inventario, y el desagrupamiento del grupo contiene todos los servidores no presentes
dentro de un grupo. Podemos especificar mejor a
quién estamos apuntando a través del uso de
comodines y listas. Los elementos dentro de las listas
están separados por comas. Los elementos se pueden excluir
mediante el uso del signo de
exclamación frente al patrón anfitrión que hemos definido previamente. Así que veamos algunos ejemplos prácticos antes
de pasar a la demo. Ahora para nuestro primer ejemplo, tenemos a los anfitriones todos declaración. Ahora, si hacemos esto,
eso significa que estamos apuntando a todos los anfitriones
dentro del inventario. Si en cambio reemplazamos
todos por ungroup, eso significa que estamos dirigidos a todos los anfitriones Janet parte de un
grupo dentro del inventario. También podemos especificar y
objetivos IP específicos es como 192168 punto uno, punto uno. Ahora el asterisco es un carácter
comodín. Eso significa que es un
titular de lugar para cualquier cosa. En nuestro cuarto ejemplo, estamos apuntando a todos los hosts con una IP que va desde el
1 noveno hasta el
punto uno, punto uno punto 0 hasta
192168 punto un punto 255. Lo mismo va con los
quinto ejemplos. Estamos dirigidos a todos los anfitriones con el nombre comenzando por
cerebeloso, seguido de cualquier sufijo. Que también podemos orientar
listas de host mediante el uso de una lista separada por comas. Y también podemos excluir
un host específico utilizando el signo de exclamación frente la oclusión
junto con un coma. Entonces ahora que hemos visto algunos patrones casuales y
comunes de host, pongámoslos en práctica dentro de la demo. Nos vemos pronto. Ahora como se puede ver,
he creado tanto el fichero de inventario,
cualquier fichero de configuración. Dentro del
archivo de inventario tenemos servidor, un servidor ser un rango de
IPs y dos grupos, solo subarray y solo servidor B. Así que vamos a usar un
comando ad hoc especificando la toda la categoría y decirle a la policía de
Ansible Casa de peaje. Y los tenemos a todos ahí. Tenemos todas las IPs así
como servidor y servidor B. Enumeremos todos los hosts desagrupados. Y sólo podemos encontrar la
IP es porque el servidor a, servidor b están en sus
propios grupos separados. Ahora, utilicemos un carácter
comodín para enumerar todos los hosts que tienen una IP comenzando con 192168 y
seguidos de cualquier otra cosa. Y podemos ver que se
han mostrado correctamente. Ahora vamos a aplicar
el mismo principio para mostrar que un servidor y servidor esté usando el carácter comodín
para mostrarnos cualquier servidor, que comienza con el servidor, seguido de cualquier sufijo. Por lo que funcionó perfectamente
como se puede ver. Así que ahora vamos a crear un libro de jugadas. El playbook se
llamará playbook dot YAML. Se iniciará con las tres líneas
clásicas. El nombre de mi primera jugada
serán los patrones de host de prueba. Se dirigirá a host específico, pero dejaré eso
vacío en este punto y podremos iniciar
la sección de prueba. Ahora, mi primera tarea se
llamará el error. Y usará el módulo de debug para mostrarnos un mensaje específico. El mensaje
será determinado por la variable de nombre de
host hechos ansible. Entonces si la tarea se
ejecuta en el servidor, se mostrará ray del servidor. Si la tarea se
ejecuta en el servidor B, mostrará el servidor B. Ahora, vamos a ir y completar
el patrón de host. Ahora para nuestro primer ejemplo, entraré al servidor un grupo y ellos
sólo servidor B grupo. Entonces apuntando a ambos grupos, y usaré el comando
Playbook de
Ansible para ejecutar
el playbook. Esperemos un poco a
Ansible juntos son hechos y a juzgar por la salida, la tarea se ejecutó en
ambos servidor a, servidor B. Así que es correcto. Vamos a editar un poco el
patrón anfitrión. Entonces eliminaré lo que
previamente escribí y escribiré el nuevo patrón de host. Más específicamente, nuestro objetivo todo tiene dentro del inventario. Aparte de todo el host
comenzando con una IP de 1 novena para apuntar tanto al
servidor como al servidor B, pero nada con la IP 192, y que funcionó adecuadamente. Ahora, hagamos esto de nuevo y borremos los patrones de host
o agreguemos otro. Ahora, voy a excluir también servir array de esta tarea en particular. Veamos si solo el
servidor responde. Y a juzgar por la salida, el patrón se interpretó
correctamente y acaba de servir a nuestro
B ha respondido. Entonces felicitaciones. Ahora sabemos cómo orientar un host específico tanto con
nuestros comandos ad hoc dentro de los playbooks usando
comodines, así como lista.
13. Roles ansible: Aprenderemos qué
es
un rol de Ansible y por qué es útil, que también descubrirá
cuáles son los componentes de un rol y dónde se pueden colocar para acceder a ellos. Entonces, sin más preámbulos, descubramos cuáles son
nuestros roles de Ansible. Entonces, ¿qué es un papel de Ansible? Bueno, empecemos con esto. playbooks pueden volverse complejos cuando son
necesarios para configurar múltiples sistemas con múltiples
tareas para cada sistema, Ansible le permite
organizar tareas en la estructura de directorios
llamada rol. En esta configuración,
los playbooks invocaron roles en lugar de roles de tarea permitidos
para recopilar plantillas, archivos
estáticos y
variables junto con sus tareas en un formato
estructurado. Roles permitidos para descomponer
un libro de jugadas complejo en trozos más pequeños
separados de los que pueden ser coordinados por un punto de entrada
central. Ahora, si el punto principal YAML
existe en un directorio, su contenido
se
agregará automáticamente al playbook
que llama al rol. Aquí es donde escribimos la mayoría
de las cosas en nuestros roles. Por último, quisiera
precisar que cuando utilizamos la sección de roles dos papeles
importantes en una obra de teatro. Los roles se ejecutarán primero antes de que se ejecuten tareas
dentro de esa jugada. Ahora que tenemos una comprensión
de línea de base de lo que son los roles, veamos la estructura del
directorio de roles a continuación. En primer lugar tenemos el directorio
predeterminado, el cual contiene
variables predeterminadas las cuales pueden ser anuladas en el
playbook o inventario. Posteriormente tenemos
el directorio de archivos, el cual contiene archivos o
scripts necesarios para el rol. A continuación tenemos el directorio de
manejadores, que contiene cualquier manejador que usted tendría
en un playbook. El directorio de la plantilla es
donde residirán las plantillas, que generarán
archivos en hosts administrados. El directorio de tareas
contiene archivos de tareas, pueden hacer referencia a
cualquier variable. Los manejadores son plantillas
sin especificar la ruta completa ya que
forman parte del rol. Aparte de lo antes mencionado, también
tenemos directorio diverso donde las variables
para un rol se pueden especificar dentro de los archivos y luego se pueden referenciar en
otro lugar de un rol, el directorio metal
se utiliza para metadatos. Por lo general, esto se hace para la gestión de
dependencias si un rol depende de otros
roles para su ejecución. Ahora, veamos un poco la colocación
Royal y
flexible por defecto
busca un directorio llamado roles en la misma ruta donde reside
tu playbook. Si Ansible no puede encontrar
el directorio roles, se verá en la
ruta especificada en el archivo de configuración de Ansible bajo la configuración roll past. ruta de los roles se puede especificar en orden separado por dos puntos. Si la ruta de roles no se especifica en el archivo de
configuración, se buscará en las
rutas por defecto que se encuentra en el directorio home
del usuario bajo roles de punto
ansible de Sasha, o en el slash usr slash share slash Ansible
slash roles ruta, o en la slash ETC slash
Ansible slash roles ruta. Ahora con el fin de crear
una estructura de directorios que discutimos en
la lección anterior, utilizaremos el comando init de Ansible
Galaxy especificando el nombre del rol. Ahora, como se mencionó en
la lección anterior, si usamos la sección de roles para incluir roles dentro de
nuestro libro de jugadas, entonces todos son ejecutados antes la sección de prueba de nuestro
playbook haga algo. Si quisiéramos hacer
algo antes de eso, podemos especificar esas pruebas en una nueva sección llamada pretests. Si desea que se
ejecuten tareas
adicionales después de la sección de prueba, lo especificamos en la sección
posterior a la prueba. Quisiera
señalar que también podemos
notificar a los manejadores dentro de
cada una de estas secciones. Ahora, si no queremos
usar la sección Rol, también
podemos importar
o incluir el rol. Ahora, como saben de lecciones
anteriores, importante es una operación estática. Eso significa que el rol se analiza antes de que se ejecute el
playbook. Si bien include es una operación
dinámica, eso significa que el
rol se analiza cuando el libro de jugadas alcanza
esa tarea específica. Por lo que ahora que tenemos
una buena visión general de los comandos necesitan ya sea
para crear, importar o roles de usuario. Pasemos a
la demo donde
haremos las cosas un
poco más prácticas. Ahora, como pueden ver, ya
he creado mi
fichero de configuración de Ansible e inventario. Por lo que ahora usaré el comando init de
Ansible Galaxy para crear mi ruta de roles. A continuación, utilizaré
el comando tree para mostrarte mi ruta de roles y ver que todas las carpetas que
mencioné anteriormente
están presentes. Tenemos la carpeta predeterminada, los archivos, los manejadores, el Metta, la tarea, las pruebas de plantillas,
y el directorio vars. Entonces este es un esqueleto de papel totalmente
funcional. Entonces empecemos a
editar nuestro papel. Primero, editaré directorio
de Vargas donde
incluiré variables
para mi rol. Ahora, la primera
variable que
incluiré se llamará servicio, y tendremos el
valor de HTTPD. También incluiré una segunda
variable llamada estado, que tendrá el
valor de presente. Guardaré y saldré y ahora pasaré a crear
un archivo de plantilla. Voy a crear este archivo temporal bajo las plantillas de
slash roles de ruta. Y voy a nombrar este contenido
de archivo de plantilla. El contenido de mi
fichero de plantilla será el siguiente. Hola mi nombre es, y
luego invocaré el nombre de host
variable hechos ansible. Entonces será hola, mi nombre es servidor a, servidor a, y hola,
mi nombre es servidor. Antes del servidor B,
guardaré y saldré. A continuación editaré
mis manejadores de roles. Entonces usaré VIM
para abrir los roles manejadores de
slash slash slash
main dot YAML archivo. Y empezaré a editar ésta para incluir
una tarea específica. El nombre de mi manejador será. Y usará el módulo de
servicio para iniciar un servicio
que tenga nombre
depende del valor de la variable llamada Servicio definido
en mi sección var, el estado se
establecerá para reiniciar. Yo guardaré y saldré de
éste también. Y ahora puedo comenzar a
editar los roles slash tareas slash
main dot YAML archivo, donde colocaré las
tareas para mi rol, se
instalará
el nombre de mi primera tarea HTTPD. Y estaré usando el módulo para instalar una
superficie cuyo nombre está determinado por el valor de la variable llamada Servicio
definido previamente. El estado también está determinado por el valor de la
variable llamada estado, que definimos en
nuestro directorio vars. Esta tarea notificará a un
manejador llamado Iniciar HTTPD. El nombre de mi segunda
tarea se llama contenido, y usaremos el módulo
de plantilla. Tomará la
plantilla de nuestro rol, que se llama contenido, por lo que esa es la fuente y la
colocaremos en la slash var slash www slash HTML slash
index.html path. Ahora puedo comenzar mi playbook. El playbook se
llamará playbook dot YAML. Se iniciará con tres líneas. Como de costumbre. Mi juego se
llamará roll HTTPD. Ahora, se dirigirá a todos los
anfitriones dentro del inventario. Y ahora puedo iniciar la sección de
roles donde
agregaré nuestro
rol creado llamado rollos. Ahorraré y saldré. Y ejecutaré el
playbook usando el comando Playbook de Ansible
y veré qué pasa. Así que primero ansible,
llegaremos ahí, son hechos. Entonces como se puede ver, el papel ha echado raíces. Se está instalando HTTPD. Para que eso podría tomar un poco. Colocó el contenido y
reinició el servicio HTTPD. Si usamos el comando clear, podemos ver que la salida es hola, mi nombre es encuesta,
y hola, mi nombre es
servidor, estar en el servidor B. Así que para resumirlo, creamos el
esqueleto de roles usando el comando init de Ansible Galaxy. Lo personalizamos a nuestras necesidades y lo hicimos
correr sin playbook. Eso es impresionante. Felicidades. En el siguiente video
de nuestra sección, que estaremos viendo
formas en las que podemos obtener roles de
terceros y utilizarlos
dentro de nuestros propios playbooks. Nos vemos pronto.
14. Galaxia ansible: En las
lecciones anteriores, aprendimos qué son los roles de Ansible y también cómo crear nuestro propio rol y desplegarlo dentro de un libro de jugadas. Ahora veamos cómo
podemos encontrar y usar roles creados por
otros terceros. Así que empecemos. Ahora, buen lugar para empezar a encontrar
roles es Ansible Galaxy. Ansible Galaxy es un gran repositorio
público
de roles de Ansible. Contiene miles
de roles de Ansible. En realidad, cuenta con una base de datos de
búsqueda que ayuda a los usuarios de Ansible a identificar los
roles que necesitan. Ansible Galaxy incluye
enlaces a documentación y videos para nuevos
usuarios de Ansible, desarrolladores inscritos. Ahora tenemos el lenguaje
es HTTPS, Ansible Galaxy. Y la herramienta de línea de
comandos de Ansible Galaxy también se
puede utilizar para buscar, mostrar e instalar, así como eliminar roles de analista
dentro de nuestro sistema. El rol de personalización se realiza
mediante el uso de variables. Y generalmente cada rol de Ansible
Galaxy contiene un Read Me explicando
qué papel hace. Ahora, veamos algunos comandos esenciales de Ansible
Galaxy. Ahora el comando de
búsqueda de Ansible Galaxy buscará el repositorio
de Ansible Galaxy un término específico
que proporcionemos. El
comando Ansible Galaxy info especificando un nombre de rol nos dará información
detallada
sobre ese rol. El Ansible Galaxy instala, vamos a instalar ese
rol y también podemos especificar la ruta con
la opción menos p. También podemos instalar un rol usando un archivo de requisitos
a una ruta especificada, nosotros d menos la opción R. Podemos listar todos los roles instalados con el comando Ansible
Galaxy list. Podemos quitar un rol con
el
comando Ansible Galaxy remove especificando
el nombre del rol que nos
gustaría eliminar. Entonces pongamos esos comandos en práctica dentro de la demo. Así que primero utilicemos el comando de búsqueda de
Ansible Galaxy para buscar un término específico. En nuestro caso, estaremos
buscando el término HTTPD. Y como pueden ver, hemos recibido una lista de roles que coinciden con
nuestro término de búsqueda. Contamos con el monitor de enrejado de dos k
lock, que instala y configura servicio de
monitoreo. En enrejado. Tenemos el AACN p dot HTTPD, que instala y configura
PHP en nuestro sistema. Por lo que tenemos múltiples roles asociados a nuestro término de búsqueda. Ahora, utilicemos el comando Ansible
Galaxy info para obtener
información detallada sobre nuestro rol. Y especificaremos el rol de punto de
pila HTTPD. Ahora desde la salida, podemos ver una descripción del rol
si está activo o no, cuándo fue creado, qué empresa lo creó, cuántas veces
se descargó. También el repositorio de GitHub, etcétera. Así que utilicemos el comando de instalación de Ansible
Galaxy para instalar este
rol específico, especificando su nombre. Ahora el rol se está descargando. Después de la descarga está completa la
extracción comenzará. Recibimos la salida
que siempre tag dot HTTPD se instaló
con éxito. Ahora vamos a cambiar directorio
a d slash home slash automatización slash dot ansible
slash roles directorio. Y ver si nuestro papel
está presente ahí. Y podemos ver el rol de
pila HTTPD es y todos los directorios
asociados a ella. Y también contiene
un archivo readme dot md que el archivo Read Me dot md nos
ayudará a entender
qué hace el rol y cómo podemos personalizarlo
para que se adapte a nuestras propias necesidades. Primero borro la pantalla, y ahora emitiré
el contenido
del archivo ReadMe usando
el comando cat. Por lo que dentro del archivo ReadMe, también
tenemos variables roll
donde se mantienen dependencias y también un
playbook de ejemplo sobre cómo funciona la regla. Ahora, usaré el comando
Ansible Galaxy y list para enumerar todos los rollos
instalados en mi sistema. Y podemos ver el rol HTTPD pila
RV que acabamos de instalar. Ahora, usaré
el comando Ansible Galaxy delete para eliminar el rol HTTPD de punto de pila de Aldi
que acabamos de instalar. Esto se estrellará porque tenga
en cuenta y tenga mucho cuidado. Es Ansible Galaxy eliminar, no Ansible Galaxy, eliminar. Entonces hagamos el comando
correcto y el rol se ha eliminado
con éxito. Entonces ahora que tenemos
una buena comprensión de la interfaz de línea de comandos, veamos el sitio web de
Ansible Galaxy. Primero, abriré mi navegador
Mozilla Firefox y buscaré Ansible
Galaxy en Google. Y como pueden ver, hemos encontrado el enlace. Ahora en el sitio web de Ansible
Galaxy, los roles están estructurados
por categorías. Contamos con roles de
desarrollo de rollos de sistema ,
redes, nube , monitoreo de
bases ,
empaque, seguridad
agrupada de playbook, etc. También
podemos utilizar la pestaña Buscar para buscar palabras clave específicas . He buscado HTTPD
y varios roles
así como sus etiquetas asociadas han aparecido. Como se puede ver. Ahora solo podemos desplazarse hacia
abajo y ver qué tipo de rol realmente necesitamos de
esta lista en particular. También podemos ver a los creadores
para cada rol individual. El
botón de documentación
nos llevará a la documentación de Ansible
Galaxy donde podemos encontrar
casi todo lo
que necesitamos saber sobre
Ansible Galaxy. Y la pestaña de comunidad
nos mostrará a todos los miembros
de esta comunidad, así
como todas sus creaciones. Ahora antes de salir de la página web de
Ansible Galaxy, vamos a ir a
ver qué podemos encontrar en una
categoría específica de roles. A modo de ejemplo,
vamos por la seguridad. Y aquí podemos encontrar
roles
asociados a temas de seguridad específicos. También podemos encontrar
la seguridad del CIS, que es un rol que nos
ayudará a endurecer nuestro Red Hat Enterprise
Linux CentOS, u otros sistemas operativos. Y podemos
descargarlo así como documentación fina, bastante buena sobre este rol específico
y cómo funciona. Entonces pasemos al
último paso de nuestra demo, donde usaremos un rol de terceros dentro de
nuestra propia infraestructura. Ahora primero instalaremos un
rol llamado Garlin guide dot MySQL usando el comando de instalación de Ansible
Galaxy. Después de que el rol se haya descargado e instalado
con éxito, podemos ver el contenido
de la carpeta de mySQL guy guy dot y contiene todos los directorios necesarios. Ahora, utilizaré VIM
para ingresar al archivo léeme
del rol y obtener una descripción detallada sobre
cómo funciona este rol. Este rol instala
una base de datos MySQL en mis hosts administrados con las siguientes contraseñas así
como nombres. Y las variables predeterminadas
se almacenan en el
archivo YAML de punto principal de la
diagonal predeterminada dentro del rol. Así que veamos un poco las variables
predeterminadas presentes en el archivo YAML de punto
principal de slash predeterminado. Todos están aquí y también con comentarios para que sea más fácil entender lo
que realmente hacen. Por lo que ahora abriré un playbook
existente y lo
modificaré para usar nuestro rol
descargado. Así VIM playbook dot YAML. Borraré el papel que
incluí anteriormente. Y usaré d Girls
Inc chico dot papel de MySQL. Voy a guardar y salir. Y ejecutaré el
playbook usando el comando Playbook de Ansible. Esperemos a que el papel
siga su rumbo. Primero, ansible,
recogeremos hechos. Después. Llevará a cabo todas las tareas que se
definieron dentro del rol. Ahora, en este punto en el tiempo, se está asegurando que
los paquetes MySQL estén instalados tanto en la encuesta
como en el ser cerebral. Ya ha definido
el error de registro de MySQL, la
etiqueta de registro de MySQL sys, el PID de MySQL. Así que ahora solo esperemos
y veamos qué pasa. Podemos ver cada tarea que el rol está desempeñando
en el host gestionado. Y al final, deberíamos tener una base de datos MySQL en funcionamiento. Así que probemos esto
conectándonos a uno de nuestros servidores host
administrados a, o más específicamente el
servidor sea a través de SSH y luego ejecutando un estado
CTL del sistema, MySQL. Y es activo y en funcionamiento. Hagamos lo mismo
también para el servidor B. Primero
limpiaré la pantalla y luego usaré SSH para conectarme al
servidor B en este punto. Y de nuevo, ejecute un estado
CTL del sistema para MySQL. Y está funcionando perfectamente. Enhorabuena, usamos
el rol de terceros, implementamos una base de datos MySQL, y funcionó perfectamente. Por lo que ahora sabemos usar un acceso y obtener roles de
terceros. Muchas gracias.
15. Manejo de usuarios: Ahora durante la primera lección,
aprenderemos a administrar usuarios y grupos utilizando módulos de
Ansible, aprenderemos a
crear usuarios con configuraciones
específicas como UID es
grupos complementarios, etc. Y también cómo
crear y administrar grupos utilizando módulos de Ansible. Entonces sin más preámbulos,
comencemos. Ahora echemos un vistazo al módulo de
usuario y sus opciones. El nombre especifica el nombre de usuario, la opción shell especifica
el shell de usuarios. En las opciones de grupos
se especifican algunos grupos
parlamentarios de
los que forma parte el usuario. Si lo uso en conjunto
con la opción append, agregará
grupos suplementarios a la lista existente. El domicilio especifica
el domicilio del usuario. Uid especifica DID
La opción de comentario como comentario que un usuario específico, mientras que la
opción Crear inicio especifica una por casa se creará o no
para ese usuario. El estado puede estar
presente o ausente. La opción de grupo especifica
el grupo principal del usuario. La opción del sistema especifica si se trata de una
cuenta de sistema o no. Si bien dice la clave SSH generada
y el archivo de clave SSH, si vas a generar
una clave SSH para ese usuario y cómo
buscará ese archivo para administrar
grupos usando Ansible, estaré usando el módulo de grupo para especificar
el nombre del grupo, estaré usando la opción name. El estado puede estar
presente o ausente, indicando si el grupo
debe estar presente o ausente en el host administrado, puedo establecer el ID de grupo
mediante la opción GID y además indicar si es
un grupo del sistema o no mediante el uso de la subasta del sistema, agregar y quitar
una clave de N
al archivo host conocido se realiza
utilizando el módulo host conocido. Entonces ahora que tenemos una visión general, vamos a entrar en la demo. Como se puede ver,
ya he creado el fichero de configuración de
Ansible y el inventario. Y el inventario contiene tanto la encuesta como el servidor B. Así que vamos a crear nuestro playbook. Lo nombraré
playbook dot YAML, e iniciaré el playbook
con tres guiones. Como es habitual, especificaré
el nombre de mi plano, que es crear usuarios, y especificaré el host y se aplicará tanto al
servidor como al servidor B. Así que dentro de la sección de prueba, crearé un nueva tarea. Ese nombre de esa tarea
será módulo de usuario, y utilizará el módulo de usuario. Ahora, voy a crear una
cuenta llamada sysadmin. El estado estará presente. Esta cuenta
también formará parte de un grupo adicional
llamado Andre. Y estoy haciendo esto usando la opción Grupos y
la opción anexar. Después,
estableceré el shell de esta nueva cuenta para
recortar bin slash bash. Le daré un UID. El UID para la
cuenta de Sys Admin será igual a 1049. También agregaré un comentario y el valor del comentario
será mi comentario. Y por último, no voy a crear
una casa para esta cuenta, así que estoy configurando la opción de
inicio disminuida para anotar, cerraré el
playbook y ejecutaré el playbook usando el comando Playbook de
Ansible. Ahora, esperemos un poco
a Ansible juntos son
hechos y salida de CD de la tarea
del módulo de usuario. Por lo que ha reportado que cambiar estado tanto
en el servidor como en el servidor B. Ahora, utilizaré
un
comando ad hoc de Ansible para
validar nuestro trabajo. Voy a generar el
contenido de la slash, ETC slash pass archivo VDI. Podemos ver claramente que la última cuenta es cuenta admin
fallecida con una nueva ID de 1049 y el
comentario de mi comentario. Por lo que ha funcionado perfectamente. Vamos a editar nuestro libro de jugadas hacia abajo. En primer lugar, editaré
la opción shell. Cambiaré de
slash bin slash bash a slash sbin
slash slash no login. Por lo que
ya no tendrá acceso terminal. Después, le
agregaré el nombre de mi usuario. Voy a crear un nuevo
usuario llamado cis user. Entonces cambiaré
el UID para que no
tengamos conflicto y el
nuevo UID será 1050. Estableceré la opción Crear
casa en sí. Por lo que se creará un hogar
para esto, este usuario. Y en ese hogar, también
generaré una clave SSH usando la opción de clave SSH degenerada. Por último, especificaré
la ruta y el nombre de mi archivo de clave SSH usando
la opción de archivo de clave SSH, el firewall reemplazado en
slash home slash user. Y tendremos el
nombre de mi I D. Después, guardaré
y saldré de este playbook. En primer lugar, vamos a validar
el pasado archivo VDI. Entonces como el usuario no existe, y vamos a ejecutar el playbook usando el comando Playbook de Ansible. Sólo esperaremos un poco
a Ansible juntos. Es hechos. Ha reportado un cambio de estado tanto
en la encuesta como en el servidor B. Y me conectaré al servidor
a. voy a ir a la slash home slash directorio de usuarios CIS
usando el comando cd. Podemos ver claramente que el
director está presente aquí. Pero primero voy a
cambiar a raíces para que pueda tener
privilegios para acceder a ella. Y podemos ver dentro de
la slash dice directorio de
usuarios que
tenemos las claves presentes, tanto la clave pública como
la privada. Si revisamos el archivo de contraseña, tenemos este usuario creado
con un nuevo ID de 150 y no
puedo acceder a su
terminal porque el shell está configurado como
se ha recortado no login. Ahora, editemos nuestro
playbook una vez más. Ahora, eliminaré
todo lo que escribimos previamente usando las teclas D, D, D. Y cambiaré el
nombre de mi obra de crear usuarios a crear grupos. Cambiaré el
nombre de mi tarea de módulo de usuario
a módulo de grupo. Y cambiaré
del módulo de usuario
al módulo de grupo. Para gestionar grupos, el nombre de mi grupo
se llamará mi nuevo grupo. El estado estará presente, por lo que estará presente
en mis anfitriones de gestión. El GID asociado a
mi nuevo grupo será 10 mil 030 y no se
considerará un grupo de sistemas. Por lo que estoy configurando la opción
del sistema para saber que guardaré y
saldré del playbook. Ejecutaré el playbook con el comando Playbook de Ansible. Ahora, esperemos un poco a que
Ansible haga sus cosas. Y ha reportado
un estado de cambio tanto
en la encuesta
como en el servidor B. Así que utilicemos un comando ad
hoc de Ansible con el fin de
validar nuestro trabajo mediante la
salida de la slash, contenido del grupo de corte
ETC. Y podemos ver claramente
que mi nuevo grupo fue creado y tiene un GID de 10 mil 030. Impresionante. Entonces felicitaciones. Ahora sabemos cómo
administrar tanto grupos
como usuarios usando Ansible. En el siguiente módulo,
estaremos buscando formas en las que
podemos gestionar los servicios utilizando
Ansible. Nos vemos pronto.
16. Gestión de servicios: Hola y bienvenidos. En esta lección,
aprenderemos a administrar servicios utilizando Ansible. Este es un tema esencial para cualquier administrador de sistemas
ya
que saber iniciar y detener los servicios es un tema clave en cualquier situación, Ansible hace que la
administración de servicios a escala sea fácil y fácil de usar. Entonces sin más preámbulos, comencemos
y veamos cómo
podemos gestionar los servicios
usando Ansible. Para la gestión de servicios
utilizando Ansible, vamos a estar utilizando
estos módulo de servicio. Ahora, vamos a cubrir el
módulo de servicio y sus opciones. Primero tenemos el
nombre que especifica el nombre del servicio que
estamos gestionando. Después, tenemos
el estado que se
puede iniciar,
detener o recargar. El estado define el estado
del servicio y a qué
se fijará. Habilitado define si el servicio comenzará en el momento del arranque o no. Y se puede ajustar
de sí a no. También tenemos estas opciones de salto. Cuántos segundos
pesará antes de reiniciar la opción de sueño va junto
con el estado reiniciado. Por último, también podemos
precisar argumentos. En el último ejemplo, reiniciamos la interfaz de red ETH one con una visión general como esta hecha, vamos a entrar en la demo. Para que como pueden ver, ya
he creado el
archivo de configuración de Ansible y el inventario, y voy a iniciar
el primer libro reproducción
llamado playbook dot YAML. Empezaré con
tres líneas y el nombre de mi primera
jugada será Servicios. Se dirigirá a todo host administrado, por lo que tanto el servidor como el servidor B. Ahora puedo iniciar mi sección de prueba. Mi primera tarea se
llamará Módulo de servicio, y estaremos usando
el módulo de servicio como su nombre indica. Estaré apuntando
al servicio HTTPD. Y voy a empezar ese servicio y le permitiré
que se inicie en el momento del arranque. Guardaré y
saldré del playbook, y ejecutaré el
playbook usando el comando Playbook de Ansible. Ahora, esperemos un poco. Como ansible necesita
reunir son hechos. Y podemos ver un
estado de cambio tanto en la encuesta como en el servidor B.
Me conectaré al servidor y usaremos el
comando status del sistema CTL con el fin ver que el servicio HTTPD es tanto funcionando así como habilitado. Ahora, saldré de la sesión y regresaré a mi anfitrión Ansible. Editaré el
playbook usando VIM. Cambiaré habilitado
de sí a no. Y cambiaré el estado
de iniciado a parar. Y ahora volveré a ejecutar
el playbook usando el comando
Playbook de Ansible. Esperemos un poco. Y como podemos ver en
la salida, ha reportado un estado de cambio. Una vez más,
volveré a conectarme a través de
SSH al servidor y usar el comando status del sistema CTL
en HTTPD para ver que el servicio está
deshabilitado tanto como detenido. Por lo que el playbook ha
funcionado perfectamente. Simplemente despejaré la pantalla
y saldré de esta sesión de nuevo. Entonces editaré el
playbook una vez más. Primero, cambiaré el estado
de detenido a reiniciado. Cambiaré la
opción Habilitado de no a sí. Y agregaré la opción de sueño, que tendrá un
cool-down de diez segundos. Por lo que debe esperar diez
segundos hasta que se reinicie. Veamos si funciona. Ahora anticuerpos y
recolección es hecho y como se puede ver, ha ignorado la función
empinada. Ahora, ¿por qué es eso? Como podemos ver en el comando de
Ansible doc, ese sleep no es realmente
soportado por el sistema. El acto de mielina está
ejecutando el sistema D, por lo que ignorará esa función
específica, pero funcionará en otras distribuciones de
Linux. Así que recordemos que si
tenemos algún problema ejecutando un módulo específico o
realmente usando sus opciones, podemos revisar los perros Ansible. Por lo que felicitaciones,
ahora sabes cómo iniciar, parar habilitado, deshabilitado, y además agregar la
función de sueño a los servicios. En el siguiente video,
aprenderemos a
gestionar el almacenamiento usando Ansible. Así que nos vemos pronto.
17. Gestión de almacenamiento: En las lecciones anteriores,
aprendimos a gestionar tanto los servicios como a
los usuarios utilizando Ansible. En esta lección,
aprenderemos a administrar el almacenamiento usando Ansible, aprenderemos a
crear volúmenes lógicos, cómo crear particiones, cómo crear grupos de volúmenes
y volúmenes físicos. Así que empecemos. Primero veamos la
forma en que podemos crear particiones usando Ansible, es
decir usando el módulo
particionado. Especifico el nombre del dispositivo, especifico el número, el estado, si debe existir o no, y la partición n, que es el tamaño de la nueva partición
que estoy creando. Puedo crear un grupo de volúmenes
utilizando el módulo LV GI, especificando el nombre del grupo
de volúmenes, especificando qué
volúmenes físicos
usarían cada uno dentro de ese
grupo de volúmenes y el tamaño de extensión. También puedo crear volúmenes
lógicos con el módulo LV O L especificando el grupo de volúmenes fur mich
espacio se recogerá especificando
el nombre del volumen lógico, el tamaño del
volumen lógico también. Entonces ahora que sabemos cómo
crear particiones, grupos de
volúmenes así
como volúmenes lógicos. Veamos cómo podemos
colocar los sistemas de archivos ahí. Podemos hacer esto usando
el módulo de sistema de archivos. Necesito especificar el tipo de sistema de
archivos y en qué dispositivo se colocará ese
sistema de archivos. Entonces puedo montar mi dispositivo
especificando la ruta. Entonces donde se va a montar, la fuente, ¿qué se
va a montar? El tipo de sistema de archivos utilizado. Si se montará o no especificará utilizando
la opción de estado. Podemos especificar opciones de montaje
usando la opción OPS y el estado DOM en este punto en nuestro ejemplo
que se establece en 0. Por lo que ahora que tenemos una visión bastante
buena de qué módulos se utilizan para la
administración del almacenamiento usando Ansible. Vamos a empezar la demo. Para que como pueden ver, ya
he creado el
fichero de configuración de Ansible y el inventario, y también he creado
el playbook de antemano. Ahora el nombre de mi primera
jugada se llama almacenamiento, y está apuntando a todos los hosts, por lo que tanto cerebri
como el servidor B. Ahora echemos un
vistazo a la sección de prueba. Ahora dentro de la sección de prueba
tenemos cuatro tareas. Ahora el nombre de mi primera
tarea es crear LV. Esto creará
un volumen lógico utilizando el módulo LV AOL. Tomará espacio
del grupo de volúmenes llamado el nombre de mi
volumen lógico será L V 02, y el tamaño
será de un gigabyte. El nombre de mi segunda
tarea es file system, que utiliza el
módulo file system para poner un sistema de archivos X EFS en el LV 0 al volumen que
creé previamente. Después,
crearé un punto de montaje, y ese es también el
nombre de mi tercera tarea. Estoy usando el
módulo de archivos para crear un directorio llamado punto de montaje de
barra inclinada. Y por último, el nombre de
mi última tarea es Mount, que utiliza el módulo de montaje. Se montará en punto de
montaje de barra inclinada mis ceros LV al volumen
lógico
con un sistema
de archivos del estado
se establecerá para presentar. Tendrá las opciones de montaje
predeterminadas y el estado DOM se establece en 0. Así que vamos a repasarlo otra vez. Primero creo un volumen lógico usando espacio del grupo de
volúmenes llamado REL. Entonces coloco allí un sistema de
archivos. Después, creo un punto de
montaje y monté persistentemente usando
el módulo de montaña. Así que vamos a guardar y salir de
este playbook y ejecutarlo. Estaré usando el comando
playbook de
Ansible para ejecutarlo. Así que esperemos un poco primero a Ansible juntos son hechos. Y veamos la salida. Por lo que ha reportado el
estado de cambio en todas las tareas. Vamos a SSH al
servidor a y usemos el comando list block device
con el fin de comprobar nuestro LV CO2. Para que como se puede ver
en la salida, LV Z12 es un volumen lógico. Claramente existe y así tiene un espacio
de un gigabyte. Se necesita un espacio del grupo de
volumen llamado rail. Ahora, también verificemos si nuestro volumen lógico está
montado persistentemente. Haremos esto
comprobando estos slash
ETC barra de archivo de pestaña FS. Tenemos el archivo absoluto
a la LV 0 al dispositivo, que está montado en punto de montaje de
barra inclinada. Cuenta con un sistema de archivos de SFS. Utiliza las opciones de
montaje predeterminadas y el
estado de volcados se establece en 0. Entonces funcionó perfectamente.
Felicidades. Ahora ya sabes cómo administrar el
almacenamiento usando Ansible. En el siguiente módulo,
aprenderemos a
administrar la configuración de red
utilizando Ansible, utilizando el módulo CLI. Muchas gracias
y nos vemos pronto.
18. Gestión de redes: Bienvenida. En las lecciones pasadas
aprendimos cómo administrar usuarios, cómo administrar el almacenamiento, y también cómo administrar
servicios utilizando Ansible. Ahora, cubriremos configuración de
red
y cómo administrar configuración de
red
usando Ansible cuando estoy hablando de configuración de
red, también incluimos aquí
la gestión del disservicio del firewall en
Red Hat Enterprise Linux. Entonces, sin más preámbulos, comencemos ahora para
administrar la configuración de red, Ansible utiliza el módulo NMC, que tiene muchas opciones. Entonces veamos
algunos importantes. El nombre actual nos permite
especificar el nombre de la conexión. El nombre nos permite
especificar el nombre de la interfaz. El tipo nos permite especificar el tipo de
conexión que es. opción Ipv4 nos permite especificar la IP utilizada así
como la máscara de subred. El gateway para la opción nos
permite especificar
la puerta de enlace usando IP para el estado puede
estar presente o ausente. Y el DNS para nos
permite especificar una dirección DNS usando
IP versión cuatro. La conexión
también se puede activar o desactivar utilizando la opción
de conexión automática. Usando el módulo de nombre de host, puedo especificar el
nombre de host de mi host administrado. Por lo que ahora que sabemos
administrar la configuración de red, veamos un poco
también en la gestión configuración del
firewall D. Utilizando el módulo firewall d, podemos especificar la
zona si la regla es persistente o no utilizando
la opción permanente, el estado de la regla
habilitada o desactivada. Y detalles sobre ese
rol como servicio,
fuente, puerto y protocolo, ritual o interfaz de red. Esta es una relación O, no una relación N. Quisiera enfatizar
que si pongo más de estos en el mismo módulo, utilizarlo se bloqueará. Por lo que ahora que tenemos
una buena visión general
tanto sobre la gestión de la
configuración del firewall como de las conexiones de red. Vamos a entrar en la demo. Para que como pueden ver, ya
he creado mi fichero de
configuración
e inventario. Así que vamos a escribir el libro de jugadas. Empezaré el playbook
con tres líneas y el nombre de mi juego
será config de red. Se dirigirá a todos los anfitriones
dentro de mi inventario. Entonces ambos sirven servidor muy final B. Ahora puedo iniciar la sección de
prueba y mi primera tarea se
llamará módulo M CLI. Estaré usando el módulo de arcilla
NM, como su nombre indica, con el fin de crear una conexión
de red. Mi conexión de red
se llamará Mike cotton. A continuación, especificaré
la interfaz. Mi nombre de interfaz será ETH 0 y el tipo será Ethernet. Después, voy a
seguir n especificar el IP. Ip será 192. No quiero punto sensato uno, punto uno con una
máscara de subred de 24 bits. Mi Gateway será 192168.1.1.2. Entonces pasaré a
especificar el DNS usando IPV4, que será 19168
punto uno, punto tres. Y el estado de
mi conexión
estará presente en los anfitriones gestionados. Permítanme simplemente modificar
el IPV4 porque es IPV4 y el
nombre de la interfaz es NEP. Y entonces guardaré y saldré. Despegaré la pantalla, y ahora ejecutaré el playbook usando el comando
Playbook de Ansible. Esperemos a Ansible
juntos son hechos y ha reportado
el estado del cambio tanto
en el servidor como en el servidor B. Así que conectemos
al servidor usando SSH. Cambiaré a la
cuenta raíz para tener privilegios. Y obtendré información sobre la conexión usando el comando
D y M CLI, a
juzgar por la salida, micrón sí existe y es tipo Ethernets como se especifica
dentro del playbook. Así que ahora vamos a utilizar el NM
click on show comando especificando mi icono
para obtener
información más detallada. Y a juzgar por la salida, tiene todos los ajustes que especificé
en el playbook, como DNS, gateway, IP. Ahora, acabaré de salir de
la sesión en el servidor a y modificar mi
playbook usando VIM. Y cambiaré el
estado de presente por encima dos epsilon para que se destruya la
conexión. Y volveré a ejecutar el
playbook usando el comando
Playbook de Ansible. Solo espera un poco a Ansible
juntos es un hecho. Y a juzgar por la salida, la conexión ha
sido destruida. Así que sigamos adelante con la configuración del
firewall
usando Ansible. Como antes que ya
he creado el fichero de configuración y el
inventario para ansible. Empecemos a crear
nuestro playbook llamado playbook dot YAML. Empezaré el playbook
con Reliance y el nombre de mi primera
jugada se configurará firewall D. Se dirigirá a todos los hosts
dentro de mi inventario. Por lo que ahora puedo iniciar
la sección de prueba. Ahora el nombre de mi tarea
será firewall d module. Utilizará el
módulo firewall d como sugiere el título. Entonces primero,
especificaré la zona, que es la zona pública, que es también la zona predeterminada. La regla no será permanente, por lo que no persistirá. Después de un reinicio, se
habilitará el estado y
especificaré el puerto 85 slash TCP
como sugiere la regla, esto significa que
permitirá el tráfico en el puerto 85 sobre el protocolo TCP. Ejecutaré el playbook usando la hora de
comando de Ansible playbook. Esperen un poco a Ansible
juntos son hechos. Y luego ha
reportado que cambio estado tanto en el
servidor como en el servidor B. Voy a cambiar de nuevo el
playbook. Voy a reemplazar la opción
de puerto por la opción de servicio, y escribiré aquí HTTP. Eso significa que
permitiré todo el tráfico al servicio HTTPD. Volveré a ejecutar el playbook usando el comando
Playbook de Ansible. Y después de que eso haya finalizado, volveré a editar el playbook. Sustituiré la opción
de servicio esta opción fuente
y especificaré una IP. El IP será 192168
punto uno punto uno, lo
que significa que permitirá
el tráfico desde esa fuente. Una vez más
correré el playbook. Esperaré a que Ansible
termine sus tareas. Y ahora me
conectaré al servidor o servidor, estar usando SSH
para validar nuestro trabajo. Voy a cambiar
a la cuenta raíz. Y estoy haciendo un firewall semi d menos lista menos todo comando. Y podemos ver que
todo lo que ponemos en nuestros playbooks está aquí, las fuentes, los servicios, y también el puerto 85 slash TCP. Por lo que funcionó perfectamente. Enhorabuena. Ahora sabe cómo crear conexiones de
red
usando el módulo arcilla NM y también cómo administrar la configuración del
firewall D usando el firewall, el módulo. En el siguiente módulo,
estaremos buscando
formas en las que
podemos llevar a cabo la
gestión de parches utilizando Ansible. Así que nos vemos pronto.
19. Gestión de parches: Bienvenido de nuevo.
Anteriormente discutimos sobre cómo administrar la configuración de
red, administrar usuarios, servicios administrados, y también cómo administrar el
almacenamiento utilizando Ansible. Ahora, aprenderemos a hacer la gestión de
parches con Ansible. Este es un
tema muy útil ya que tener sistemas y
servicios de
parches es una de las principales formas de
reducir vulnerabilidades y la
superficie de ataque de las amenazas. Entonces sin más preámbulos,
comencemos. Una de las
partes más difíciles de ser administrador
de sistemas
es los sistemas de parches. Vamos notificaciones de vulnerabilidad y
exposición, también conocidas como CVs o Information Assurance
Vulnerability alerts, también conocidas como Yarbus, son con bastante frecuencia y parches
únicos para solucionarlos y de alguna manera
puede reducir el tiempo que se tarda en aplicar parches a
los sistemas ejecutando módulos de
empaque y hechizo
hace que la implementación de parches sea fácil, rápida y amigable con la administración, así
como escalable a entornos
grandes. Entonces veamos algunos ejemplos
prácticos a continuación. Entonces tanto para parches
como para instalar servicios, podemos utilizar el módulo yang. Podemos especificar el nombre de
los servicios que se van a instalar y el estado en el
que se deben encontrar,
presentes, ausentes, o más recientes. El módulo también puede sostener
la instalación de
grupos de servicios mediante el
uso de D en carácter. Si quiero recabar
información sobre qué paquetes están instalados y en qué versiones se
instalan. Podemos utilizar el módulo packs de
paquetes y luego enumerar que
dentro de una variable, también conocida como la variable de paquetes de puntos
hechos ansible, que enumerará todos los paquetes
instalados en nuestros sistemas y su versión. Ahora con el fin de utilizar Yum para
instalar los servicios de Apache, tienes necesidades de un
repositorio
donde obtenga esos parches
o superficies. Podemos crear nuestro propio repositorio utilizando el módulo de repositorio yum, podemos especificar el nombre del repo
utilizando la opción File. Podemos especificar la descripción
del repositorio. Podemos especificar la URL base para donde
sea accesible ese repositorio. Si está habilitado o deshabilitado. Si hay un
cheque GPG o no hay cheque GPG. Si el estado de ese repositorio
está presente o ausente. Guardará este
archivo bajo slash, ETC slash sham repos dot d. Así que
ahora que tenemos una buena visión general de cómo usar el módulo yang, vamos a seguir adelante y
entrar en la demo. Para que como pueden ver, ya
he creado mi
fichero de configuración de Ansible e inventario. Así que ahora vamos a crear un libro de jugadas. Empezaré el playbook
con tres líneas. instalará el nombre de mi
primera jugada , un Servicios de Actualización. Y estaré apuntando a todos los
anfitriones dentro de mi inventario. Entonces empecemos la sección de prueba. Dentro de mi sesión de prueba, crearé una
tarea con el nombre de instalar un servicio de actualización. Estaré usando el módulo
yang para esto. Y primero indicaré el
nombre de los servicios que me gustaría tener
instalados o actualizados. Primero será HTTPD
y después, el firewall, el servicio, el estado se establecerá a más reciente. Eso significa que traerá
ambos servicios a
su última versión. Ejecutaré el playbook usando el
comando Playbook de Ansible, playbook dot YAML. Y voy a esperar a que Ansible
tanto reúna hechos como para llevar a cabo la tarea en los anfitriones de gestión. Esto podría llevar un poco
de tiempo ya que instalará o actualizará
esos dos servicios. Ahora, a juzgar por la salida, podemos ver que ambos servidores
no reportaron un estado de cambio. Entonces eso significa que mis servicios, ya
estamos en
la última versión. Primero borraré la
pantalla y después
seguiré adelante y editaré el archivo YAML de punto de
playbook. Editaré el nombre. Lo cambiaré de instalar servicios
agregados para instalar
grupos de servicios. Volveré a usar el módulo, pero cuando se trata de nombre, cambiaré el nombre para
agregar administración de contenedores. Después,
simplemente guardaré y saldré y ejecutaré el playbook usando el comando Playbook de
Ansible. Entonces veamos qué pasa, que son esperar un poco a que
Ansible recoja sus hechos y luego vea la salida. Ahora como se puede ver, tanto encuesta como servidor, hemos reportado
un estado de cambio. Por lo que las herramientas de
administración de contenedores, que quería instalar muy
probablemente
se hayan
instalado con éxito en ambos servidores
dentro de mi inventario. Por lo que ahora nuestro editar el
playbook de nuevo. Eliminaré todo
en ese playbook. Voy a crear una nueva obra que
se llama reunir hechos. Se dirigirá tanto servidor
como cerebral a ser. Entonces todos los anfitriones dentro de
mi inventario. Y mi primera tarea será nombrada reunir paquetes instalados. Y utilizaré el módulo de
datos del paquete para obtener información
detallada sobre
todos los paquetes instalados en los hosts administrados. Estableceré la
opción manager a auto. Y mi segunda tarea
se llamará list all, donde estaré usando el módulo de
debug con el fin de enumerar el contenido de la variable
ansible facts dot paquetes, voy a guardar y salir, y ejecutaré el
playbook usando el comando Playbook de Ansible. Entonces veamos la salida. Aquí podemos ver todos los paquetes que se han instalado
en los hosts administrados. Podemos ver su versión, podemos ver su nombre, podemos ver la distribución, podemos ver sus tiendas, etcétera Entonces así es como podemos
hacer un inventario en todos los paquetes instalados
en nuestro anfitriones administrados. Volveré a borrar todo
dentro de mi playbook. Y voy a crear
una nueva obra llamada configure repo con
las siguientes tareas. El nombre de mi
primera tarea se
llamará configure young repo, y usaremos el módulo de
repositorio yum. Ahora, el nombre de mi expediente
será mi nuevo repositorio. El nombre será mi repositorio, la descripción
será HelloWorld. El URL base
tendrá un valor inventado, por lo que será http, mi URL de slash test.com. El estado habilitado
se establecerá para conocer. El estatus GPG XX
se fijará en ningún fin, el estado estará presente. Ahora puedo guardar y salir
y ejecutar el playbook usando el comando
Playbook de Ansible. Ahora, esperemos dos segundos a que se ejecute la obra. Ha reportado estado de
cambio y usaremos SSH para conectarme al servidor a. estaré cambiando
al usuario por dos root, por lo que podría tener privilegios. Entraré a la slash ETC slash m dot tres posts
dot d directorio. Y aquí es donde tenemos
el nuevo archivo repo dot repo, que sí contiene todas
las opciones que mencioné anteriormente.
Entonces felicitaciones. Ahora ya sabes cómo
instalar servicios, cómo aplicar parches a los servicios,
estás usando Ansible, cómo implementar repositorios yum, y también cómo recopilar datos sobre los paquetes
instalados,
en administrar hosts.
20. Módulos Ansible importantes: Hola y bienvenidos de nuevo a la automatización de seguridad
con curso Ansible. En las lecciones anteriores, aprendimos a
usar Ansible para realizar tareas
básicas de
administración del sistema. En esta lección, repasaremos los módulos de
Ansible más importantes que podrías necesitar en tu
búsqueda para implementar la automatización dentro de
tu organización. Descubriremos
cómo archivar archivos usando Ansible y no sólo eso, sino también cómo escribir
líneas específicas dentro de archivos de texto, cómo copiar archivos de texto específicos, y también cómo crear archivos de
directorios, Terminaremos esta lección con una demo en la que pondremos en práctica algunos de los módulos
que vamos a discutir. Así que no esperemos
demasiado y
comencemos y veamos
algunos módulos principales de Ansible. Ahora primero tenemos la
línea en módulo de archivos. Ahora este módulo asegura que una línea en particular esté
en un archivo o en sustitución una línea existente utilizando una expresión
regular de referencia posterior que
ya sabemos usar usando Linux. Esto es principalmente útil. Quieres cambiar una sola
línea en un archivo solamente. Entonces, si quieres
cambiar varias líneas, ya sea usa una plantilla o crea un nuevo archivo que puedes
copiar en el host Administrar. Esto es especialmente útil si estás cambiando una configuración de un archivo de configuración SSH D de sí a no o
de no a sí. Veamos algunos ejemplos sobre cómo
funciona el archivo de revestimiento para que podamos aprender a usarlo
dentro de nuestra organización. Ahora el primer ejemplo
garantizará que el puerto Apache predeterminado sea 8080. Tenemos el archivo de
iluminación del módulo, la ruta del
archivo de configuración HTTPD, que es slash, ETC slash http slash
slash http.com. Tenemos la
expresión regular que está buscando, que es menor que. Y se insertará
la línea escuchar 8080 después de que encuentre
la palabra clave than. Siguiente ejemplo asegura que SELinux se establece en modo de
aplicación,
nuevamente, utilizando la
línea en el módulo de archivos. Primero especificamos la ruta con la barra inclinada ETC slash
SELinux config path lo
que busca la línea que contiene SELinux es igual, y vamos a cambiar esa
línea a SELinux igual. Hacer cumplir. El último ejemplo, nos aseguraremos de que
la rueda grupal no
esté en el archivo de pseudopalabras. Está buscando en la barra inclinada, ETC slash pseudowords archivo de
configuración. El estado se establece en
ausente, no presente, y está buscando la expresión
regular de una línea que empiece
con percentil. Vamos, ahora que tenemos una bastante buena visión
teórica de cómo el módulo
ilumina fuegos artificiales, pasemos al siguiente
módulo, que es encontrar,
que hace una búsqueda en tiempo real
dentro del host gestionado. Ahora el módulo find
funciona exactamente como el comando find
dentro del término null. No
busca en tiempo real y devuelve una lista de archivo
basada en criterios específicos, como nombre,
como propietario, grupo,
propietario, misiones, fecha, cuándo
último acceso, etcétera. El módulo find es extremadamente versátil y es
extremadamente útil si estamos tratando de encontrar algo en
un host gestionado y devolver el camino de
ese algo
específico que estamos buscando. Entonces, sin más preámbulos, veamos algunos ejemplos
prácticos sobre cómo usar el módulo find. Dentro. El primer ejemplo, vamos a encontrar recursivamente barra archivos
TMP o
inferiores a dos días. Podemos ver que estamos
utilizando el módulo find. Está buscando dentro
del directorio TMP slash. Se establece la edad dos días y el
recurso se establece en sí, eso significa que está
buscando
recursivamente cualquier archivo que tenga
más de dos días. El segundo ejemplo
encontraremos slash var slash archivos de
log iguales o
mayores que diez megabytes, terminando con determinación de
dot old o dot log dot g z Una vez más, usa define módulo. Está buscando dentro del directorio de log
slash var slash. El patrón que está buscando es cualquier cosa que termine con barra vieja y cualquier cosa que termine con barra de barra de registro de barra G, Z. La opción de tamaño se
establece en diez megabytes. Eso significa que todos los archivos dentro de
la barra barra var slash log bath, que tienen ese nombre y el
tamaño mayor o igual a diez megabytes
serán devueltos por el módulo find en parte
este caso particular. Ahora, en el último ejemplo, intentaremos
encontrar todos los directorios presentes dentro de slash
var slash log, excluyendo los directorios NGINX
y MySQL. El tipo de archivo se establece
en directorio y excluye, como se puede ver, NGINX y MySQL. Por lo que el módulo find es
extremadamente versátil. Ahora vamos a seguir adelante. Ahora veamos el módulo
que podemos utilizar
para programar trabajos regulares
y repetitivos. Este es el módulo de corona. Podemos utilizar este módulo para administrar crontab y entradas de
variables de entorno. Este módulo permite crear variables de
entorno y entradas de contrato
nombradas, actualizarlas o eliminarlas. Cuando se gestionan los empleos de contacto. El módulo incluye
una línea con la descripción de
la entrada crontab y nombre
Ansible
correspondiente el nombre pase a través del módulo que es utilizado por futuras
llamadas al módulo Ansible para encontrar y
revisar el estado. Cuando se administran
variables de entorno, no se agrega ninguna línea de comentario, pero cuando el módulo necesita
encontrar barra inclinada verifique el estado, utiliza el mismo
parámetro de nombre para encontrar la variable de entorno
línea de definición. Quisiera
señalar que al usar símbolos
como el percentil, deben escapar adecuadamente. Ahora para resumir lo que
he dicho anteriormente, módulo de multitudes de
anticuerpos se usa para administrar la
pestaña Chrome o administrar host. Y cuando hace
esto, también agrega una
entrada con hashtag, Ansible, y el
trabajo Cron que ha creado. Entonces veamos algunos ejemplos
prácticos de cómo funciona esto. El primer ejemplo asegura que exista un
trabajo que corre a los 25 años. Está utilizando el módulo Chrome. El nombre del trabajo
es revisar las orejas. Se está ejecutando en menos 0. Y cuando se trata
de la, nuestra opción, tenemos cinco y luego también
tenemos coma dos. Eso significa que se está ejecutando tanto en nuestro expediente como en nuestros dos. Ahora el trabajo que se está
ejecutando es un listado largo. Redirigir sus resultados a d
slash dev slash null path. También podemos usar crontab
para eliminar empleos. Podemos asegurar que todo el
trabajo ya no esté presente. Eso significa que
elimina cualquier trabajo que esté prefijado por el hashtag, Ansible y todo el
trabajo de crontab. Estamos utilizando el módulo Chrome. El nombre es un trabajo antiguo y
el estado se establece en ausente. Por último, también podemos crear un trabajo que ejecute un script
específico. Nuevamente, estamos utilizando
el módulo Chrome. El nombre del trabajo
es un trabajo para reiniciar. El tiempo especial es reiniciar
y el trabajo es ejecutar el script presente en
la ruta SH
del trabajo slash home slash
job dot SH. Entonces ahora que
sabemos cómo crear trabajo
recurrente usando
el módulo Cloud, veamos algo más simple. Más específicamente el módulo. Si bien el
módulo Chrome se utiliza para trabajos
recurrentes o repetitivos, agregan módulo se
utiliza para trabajos de una sola vez. Esto es extremadamente útil
en situaciones como cuando quiero crear un
usuario específico en un momento específico, o cuando quiero enviar un
correo electrónico en un momento específico. Entonces veamos el módulo de anuncios. El primer ejemplo,
programamos un comando para ejecutar en 20 minutos
como la raíz del usuario, el comando es el
listing, como se puede ver, que luego envía
sus resultados
a la barra barra barra de ruta nula. El recuento es de 20, y las unidades utilizadas para eso
cuentan nuestros minutos. Entonces en el segundo ejemplo, también
podemos usar el Módulo
Agregar para hacer coincidir un comando con un
trabajo existente y eliminar ese trabajo. Tenemos el mando aquí. Y si ese comando está
presente dentro de la cola de empleos, entonces el estado
será trasladado a ausente. Eso significa que el
trabajo será destruido. Dentro del primer ejemplo, podemos usar el
Módulo Agregar para programar un comando para ejecutar
en 20 minutos, asegurándonos de que sea único
en la cola de trabajos. Estamos utilizando el módulo app. Tenemos el comando,
el conteo, que es 20, las unidades que son minutos, la opción única
que se establece en sí. Eso significa que si encuentra un trabajo
similar dentro de la cola, entonces este trabajo no
será creado ni hecho. Por lo que ahora que sabemos como tanto los trabajos recurrentes
programados usando el módulo clon como los
trabajos de una sola vez usando el módulo app. Veamos ahora
el módulo de archivos, que es útil para administrar ambos directorios así
como archivos. Ahora el propósito
del módulo de archivos es principalmente establecer
atributos de archivos, enlaces
simbólicos o directorios. También puede crear o eliminar enlaces
simbólicos,
directorios o archivo. Si queremos asegurarnos de que exista
una ruta determinada, o si queremos asegurarnos de que se elimine el directorio etc, entonces necesitaremos
usar el módulo de archivos. Por lo que incluso si se trata de
un módulo simple, es una de las moléculas más
útiles presentes en Ansible. Creo que claramente podría
hacer que el top 100. Entonces, sin más preámbulos, veamos algunos
ejemplos sobre cómo usar el módulo de archivos. Entonces en el primer ejemplo, podemos utilizar el
módulo de archivos para dar permisos de
inserción de grupo
a un archivo existente. Tenemos el camino de la
pila que estamos apuntando. El propietario está configurado para enrutar, la propiedad del grupo
se establece para enrutar y los permisos
se establecen en 1777. Eso significa todas las entidades. Por lo que el propietario del usuario,
el propietario del grupo, y las
demás entidades tienen privilegios de lectura, escritura y ejecución, por lo que no es
muy seguro a partir de ese fin. En el segundo ejemplo, estamos utilizando el módulo de archivos
para crear un enlace simbólico. Tenemos la fuente de ese enlace
simbólico y la ruta es slash archivos slash para
slash link, slash dos. Y el destino donde realmente se creará
ese enlace. El propietario del enlace
se establecerá para la ruta. Se
establecerá la titularidad del grupo para enrutar, y el estado será enlace, indicando que lo que
estamos creando es un enlace simbólico a nuestro archivo. El tercer ejemplo,
que estaremos usando el módulo de archivos para crear un directorio si
no existe. Tenemos el camino donde deben estar presentes esos
directores. El estado se establece en directorio. Y también tenemos los permisos asociados a ese directorio. Entonces 755, eso significa que el propietario del
usuario tiene privilegios de lectura, escritura, ejecución, mientras que
tanto el propietario del grupo otras entidades solo tienen privilegios de
lectura y ejecución. Por lo que ahora que sabemos
crear y administrar archivos usando el módulo de archivos, veamos también
el módulo de archivos para administrar archivos. Ahora podemos utilizar el módulo de
archivo para crear o extender y archivar. El origen y el archivo
están en el host remoto y el archivo no se
copia al host local. Los archivos de origen se pueden
eliminar después del archivo especificando la opción
remove es igual a true. Por lo que podemos utilizar el
módulo de archivo para crear archivos y especificar también algoritmo de
descompresión que se utiliza para
esos archivos. Así que no
esperemos y veamos algunos ejemplos
prácticos de cómo usar el
módulo de archivo dentro de Ansible. Ahora para el primer ejemplo, estaré usando el módulo de
archivo para comprimir la barra barra de ruta de
barra inclinada del directorio para foo en el archivo presente en barra barra de ruta de
barra inclinada para cortar foo dot t, g, z. Como pueden ver, las dos
opciones que estoy usando son la ruta al directorio y el destino de mi archivo. Para el segundo ejemplo, comprimiré un archivo
regular específico y lo eliminaré. Lo estoy moviendo especificando la opción Eliminar y
configurando eso a sí. Y en el tercer ejemplo, crearé un archivo zip
de un archivo específico. Nuevamente, usando el módulo de archivo, estoy especificando el formato de
compresión a través la opción de formato
que se establece en zip. Como se puede ver. Ahora que tenemos una
buena visión general
del módulo de archivo y
cómo crear archivos utilizándolo. Veamos también lo contrario,
el módulo de desarchivar y cómo descomprimir los archivos
dentro de Ansible. El módulo de desarchivar
desempaqueta y archiva. Sin embargo, no desempaquetará
un archivo comprimido que no contenga
un archivo. Por defecto, copiará
el archivo fuente
del sistema local al
objetivo antes de desempaquetar, también
podemos establecer la opción SRC
remota en sí, para descomprimir un archivo
que ya existe en el Administrar host. Entonces ahora que entendemos lo hace
el módulo de archivo
y cómo funciona, hagamos algunos ejemplos prácticos de cómo debe verse
dentro de un playbook. Entonces, para nuestro primer ejemplo, vamos a ir por
una simple extracción. Extraeremos el archivo
food dot TGC en el directorio slash var slash
lib slash foo. Tenemos la fuente,
que es el archivo, y el destino donde se descomprimirá
ese archivo. Ahora para nuestro ejemplo, ejemplo, vamos a desarchivar un archivo que
ya está en la máquina remota. Nuevamente, usando el módulo de
desarchivar, tenemos la fuente que es el archivo zip de slash TMP slash
foo dot. Se descomprimirá
en el destino, que es slash usr
slash local slash bin. Y la fuente remota está
configurada en sí, como se puede ver. Por último, también podemos utilizar el módulo de desarchivar
para descomprimir un pequeño archivo que necesita ser descargado dentro
del campo fuente. No voy a poner una
carpeta o directorio específico, sino vincular https.example.com slash ejemplo dot zip y el destino donde se descomprimirá ese
archivo. Entonces eso significa que descargará el archivo de ese enlace
y luego lo descomprimirá. Ahora que entendemos y
sabemos cómo crear tanto archivos usando Ansible
como los descomprimimos. Pasemos al módulo
fetch y cómo podemos recuperar las cosas
de los anfitriones administrados. Ahora el módulo fetch funciona
como el módulo de copia, que hemos utilizado varias
veces dentro de las demos. Se utiliza para obtener archivos
de máquinas remotas y
almacenarlos localmente en un árbol de archivos
organizado por nombre de host. Los archivos que ya existen
en el destino serán sobrescritos si son diferentes a
los de la fuente. Ahora el módulo fetch es
extremadamente útil para las tareas
diarias de
administración del sistema. A modo de ejemplo,
digamos que quiero
centralizar todos los registros
de mi host administrado. Eso significa que
los encontraré y los traeré a mi máquina local de una manera
organizada y estructurada. Así que veamos algunos ejemplos prácticos sobre
cómo usar el módulo fetch. Ahora para nuestro primer ejemplo, primero
especificaré la fuente. Entonces, qué archivo MI fetching y el destino donde se colocará ese
archivo, la ruta será barra inclinada TMP slash pitched que el nombre
de host de la barra de host administrado TMP y el archivo que fue recogido. Ahora también puedo especificar
una ruta directamente
al módulo fetch usando la opción plana y
configurando eso a sí. Y para nuestro último ejemplo, también
puedo especificar
una ruta de destino, nuevamente usando la
opción plana establecida en sí. Entonces ahora que sabemos
cómo obtener archivos de gestionado usando
el módulo fetch. Veamos ahora
el módulo URI. Ahora para nuestro primer ejemplo, podemos usar el módulo URI para comprobar que
se puede conectar usando un comando GET a una página y
devuelve un estado de 200. Tenemos el módulo URI y la URL a la que estamos
intentando conectarnos, en nuestro caso particular, la URL http, www.example.com. Ahora, también podemos utilizar el módulo URI para comprobar la
página devuelve un estado de 200 y falla si la palabra awesome no está en
el contenido de la página. Podemos hacerlo especificando
primero la URL de la página a la que
estamos tratando de conectarnos. Luego estableciendo la opción de
contenido de retorno a sí, registrando este contenido
en una variable llamada esto, y luego especificando
una condición
fallida, falló cuando impresionante
no está en este contenido de puntos. Y por último, también podemos
utilizar el módulo URI para publicar desde contenidos de
archivos remotos especificando una URL. El método se establecerá
para publicar la fuente y la
opción de fuente remota se establecerá en. Sí. Entonces ahora que tenemos una buena visión general
del módulo URI, veamos también
el Módulo GET URL usado para descargar
cosas con Ansible. Ahora para nuestro primer ejemplo, estaré descargando
el
archivo food.com utilizando el módulo GET URL, especificando la URL de ese
archivo, el destino, donde se colocará
en el host Manage, y los permisos
asociados al nuevo archivo. En mi
caso particular, es 0440. Por lo que tanto el propietario
del usuario como el propietario del grupo tienen
privilegios de lectura mientras que otras
entidades no tienen privilegios. Ahora también podemos utilizar
el módulo GET URL para descargar el archivo y la autenticación básica
forzada. Nuevamente, especificando la URL y el destino de donde se colocará
ese fichero. Y podemos forzar la
autenticación básica
ajustando las primeras opciones básicas de
autenticación a sí. Y por último, podemos
descargar el archivo desde una ruta de archivo utilizando
el módulo GET URL, especificando la URL
y el destino. Bastante simple, ¿no? Por lo que ahora sabemos
cómo interactuar tanto con las páginas web como
descargar archivos
del entorno online usando
el URI y obtener módulos URL. Veamos el módulo de
script a continuación. Entonces el módulo script
toma el nombre del script seguido de una lista de argumentos delimitados por
espacio, ya sea un comando de formulario libre o un parámetro
Cmd. Esto lo podemos ver en
los ejemplos que se avecinan. El script local en
la ruta será transferido al nodo
remoto y luego se ejecutará ese
script dado se procesará a través del entorno de shell
en el host remoto. Entonces ahora que entendemos cómo funciona el módulo script, veamos algunos ejemplos
prácticos y cómo podemos usar esto dentro de
nuestra propia organización. Entonces para nuestro primer ejemplo, vamos a ejecutar un script
con argumentos forma libre. Tenemos el camino
al guión menos,
menos algún argumento y cuando
especificamos esos argumentos. Ahora para nuestro ejemplo de sindicato, podemos ejecutar un script
con argumentos usando el parámetro de comando. Contamos con el módulo script. El comando se establece para slash sum slash local
slash script dot SH. Y luego tenemos los
argumentos a través del menos, menos algún argumento 1234. Y por último, podemos
ejecutar un script solo si el texto del punto del archivo no
existe en el host remoto. Tenemos el enlace
hacia el script, y luego tenemos los
argumentos que detallan que el script sólo se
ejecutará si el archivo no existe en
el host gestionado. Entonces si queremos usar la sincronización de
aire usando Ansible, entonces tendremos que usar
el módulo sincronizado. Ahora, el módulo de desincronización es
un envoltorio alrededor de arcos para hacer tareas comunes en tus
playbooks rápidas y fáciles. Se ejecuta y se origina en el anfitrión local donde se está ejecutando
Ansible. Por supuesto, también podemos usar el módulo de comandos para
llamar a N'Sync nosotros mismos. Pero si hacemos eso, también
tenemos que sumar un buen
número de opciones de calderas
y alojar hechos para que eso funcione usando el módulo
sincronizado, Esto es más fácil y más rápido. Entonces veamos algunos ejemplos prácticos sobre cómo usar el módulo
sincronizado. Ahora para nuestro primer ejemplo, estaré usando el módulo
sincronizado para sincronizar la fuente en la máquina de control con el destino en
el host remoto. Esto se hace simplemente usando
el módulo sincronizado y especificando las rutas de origen
y destino. Ahora para nuestro segundo ejemplo, sincronizaré la fuente
y el destino con
el
protocolo think de la Tierra o empujaré
especificando tanto la fuente
como el destino. Y por último, voy a sincronizar usando la piscina de
protocolo de disipador de aire. Al especificar el modo, se establecerá
el modo para tirar la fuente y las rutas de
destino. Ahora dentro de respuesta, bueno, también
tenemos el módulo Agregar Host. El módulo de host de anuncios se utiliza para actualizar el inventario con el que
estamos trabajando. Utiliza variables para crear
nuevos hosts y grupos en el inventario para utilizarlos en lugar
posterior del
mismo playbook. Se necesitan variables para que podamos
definir nuevos hosts de manera más completa. Es extremadamente útil, sobre todo si queremos
actualizar nuestro inventario dentro nuestro propio playbook o
dentro de un rol específico. Entonces sin más preámbulos, veamos el
módulo Agregar Host dentro de Ansible, cómo funciona y
cómo nos puede ayudar. Ahora para nuestro primer ejemplo, agregaré un host al grupo
llamado recién creado con una variable asociada a
ese host de foo es igual a 42. Estoy usando el módulo Agregar Host. El nombre se especifica a través
de la variable IP de EC2. A los grupos
a los que se destinará se llama recién creado. Y también tenemos la variable foo con un
valor de 42 declarada. Ahora también podemos usar el módulo Agregar Host a otro
host a varios grupos. Nuevamente especificamos el
nombre de host y luego podemos especificar todos los grupos de los que el
host debe formar parte. Y por último, podemos
agregar un host con un puerto no estándar
local a sus máquinas. Esto se hace especificando primero
la nueva IP del host, así
como el puerto
a través del cual Ansible puede acceder a ese host en particular. Ahora que
entendemos cómo usar el módulo Add Host
dentro de ansible, veamos las formas
en que también podemos establecer algunos hechos ansibles personalizados
a través del módulo set fact. El módulo set fat nos permite establecer variables asociadas
al host actual. Estas variables
estarán disponibles para el lugar
posterior durante
una corrida de Playbook de Ansible, tuvimos el
crédito mayorista en estableciendo la opción cacheable dos
años para guardar variables a través de ejecuciones usando un hecho Las variables de
caché
mantendrán los precedentes de hechos establecidos
para la ejecución actual, pero se utilizarán
precedentes en caché para las posteriores. Ahora que entendemos lo hace
el hecho establecido
también módulo, veamos algunos
ejemplos prácticos sobre cómo
podemos establecer hechos personalizados
dentro de nuestros playbooks. Entonces, para nuestro primer ejemplo, vamos a poner algunos hechos
que persistirán. De hecho, en efectivo, tenemos el hecho y el
valor de ese hecho, el otro factor
y el valor de esos otros hechos y la opción
cacheable se establece en sí. Para el segundo ejemplo, también
podemos crear listas
y variables de diccionarios. Tenemos un diccionario y los
valores de ese diccionario, tenemos una lista y
los valores dentro esa lista tienen en
cuenta que también podemos hacer estos persistentes estableciendo la opción cacheable a sí. Ahora como se puede ver, ya
he creado el archivo de
configuración de Ansible, así
como el inventario. He establecido la sección predeterminada y también la sección de
escalada de privilegios. Y dentro del inventario,
tenemos servidor a, servidor b, n dos grupos, sólo un servidor muy ingest b Así que ahora vamos a empezar por mirar
dentro de estos playbooks. En primer lugar, veremos
el libro de jugadas del archivo. Aquí es donde estoy usando
el módulo de archivo para crear un archivo
en el host administrado. Entonces veamos este
playbook con más detalle. El nombre de mi primera obra
se llama módulo de archivo. Está apuntando a todos los anfitriones
dentro de mi inventario. Dentro de la sección de prueba, he definido dos tareas. El nombre de mi primera
tarea es archivo. El nombre de mi segunda
tarea es formato de archivo. Dentro de mi primera tarea, el camino es slash home slash
automation slash slash archive. Eso es una carpeta o directorio que existe en
el host administrado. A partir de esa carpeta, se
creará un archivo llamado slash home slash automatización
slash Archive dot GZ. Eso es lo que está haciendo mi
primera tarea. Dentro de mi segunda tarea, estoy creando un archivo
que tiene el formato de zip. Esto se puede ver claramente
porque he especificado la opción de formato y lo
he dicho para zip. Entonces ahora que entiendes lo hace
el playbook de archivo, lo
guardaré salido usando los comandos de teclas W
y luego ingresaré al playbook de YAML de punto desarchivar. Dentro de este playbook, solo
tengo una tarea y el nombre de mi tarea
es un módulo de archivo. Tengo aquí la fuente
de mi archivo y el destino donde se descomprimirá ese
archivo. Como se puede ver en
la sección de host, este libro de jugadas en particular está segmentando o aloja
dentro de mi inventario. Y también me
gustaría mencionar que el nombre de mi obra es un archivo para que comprendamos cómo funciona el playbook de puntos
YAML desarchivar. Guardaremos y saldremos, y
vamos a entrar en un nuevo libro de jugadas. Ahora, el playbook en el que
estamos entrando ahora se llama horario dot YAML. Veamos un poco
este libro de jugadas. Entonces el nombre de mi
juego está programado y está apuntando a todos los
anfitriones dentro de mi inventario. Entonces pero el servidor a
así como el servidor sea. Dentro de la sección de tareas. Sólo tengo una tarea. El nombre de esta tarea es crear una tarea programada y está
utilizando el módulo clon. El nombre de mi tarea se
ejecutará mi tarea. El trabajo que se está
ejecutando es eco test. Está funcionando el cuarto
mes, el quinto día, 17 horas, y cada
minuto de ese tiempo. El cada minuto parte se
realiza mediante el uso
del carácter comodín Asterix. Entonces ahora que entendemos
cómo funciona esto, guardaré y saldré de este playbook en
particular, y pasemos
al siguiente. Por lo que usaré WQ,
guardaré y saldré e ingresaré
al playbook de trabajo de una sola vez. Veamos un poco el playbook
de YAML de punto de trabajo único. El nombre de mi primera reproducción
se llama módulo de aplicación. Está apuntando a todos los anfitriones
dentro de mi inventario. Entonces tanto la encuesta
como el servidor B. Dentro de la última sección, solo
tengo una tarea definida. El nombre de mis tareas está
en y usa D en el módulo, el comando que se está
ejecutando será Echo Test, el recuento será de diez, y las unidades se establece en minutos, y el comando
tiene que ser único. Esto significa que tengo, estaré programando
un trabajo que estará funcionando en aproximadamente
diez minutos, lo que devolverá el resultado
del comando eco test. Si ya existe un trabajo con el mismo comando
al mismo tiempo, entonces este trabajo no será
creado ya que tiene que ser único. Por lo que ahora que entendemos cómo funciona este
libro de jugadas en particular, vamos a entrar en el siguiente, que se llama
directorio dot YAML. Así que veamos un poco en el
directorio dot YAML playbook. El nombre de mi primera obra
se llama módulo de fuego. Como se puede ver, está apuntando a todos los anfitriones dentro de mi inventario. Entonces tanto el servidor como el servidor estarán dentro de mi sección de prueba. Sólo tengo una tarea definir, que tiene el nombre
de creación de archivos. Utiliza el módulo de archivos. El camino asociado
con mi módulo de archivo es slash home slash automatización
slash recién creada. El estado se establece en dirigido, el propietario está configurado para enrutar, el grupo se establece en automatización. Los privilegios son 0777. Eso significa que todas
las entidades tienen privilegios de lectura, escritura y ejecución. Entonces al ejecutar este playbook
en particular, debería encontrar un
directorio llamado recién creado dentro de la ruta de automatización de slash
home slash. Por lo que ahora que entendemos cómo funciona
este
playbook en particular, simplemente guardaré y saldré
usando el comando w q dentro de
VIM e
ingresaré al siguiente
playbook llamado archivo dot YAML. Nuevamente, dentro de este playbook, tengo una jugada. El juego se llama creación de
archivos, y está apuntando a todos los
hosts dentro de mi inventario. Entonces tanto encuesta
como servidor B. Ahora dentro de la sección de prueba, nuevo, solo tengo una tarea. El nombre de mi tarea es archivo. El módulo que se
está utilizando es archivo. Ahora la ruta asociada a este archivo en particular es slash home slash automation
slash slash test file, y el estado está configurado para tocar. Eso significa que al
ejecutar este playbook, un archivo llamado testfile debe estar presente en estas ruta de automatización de barra de inicio de
barra inclinada. El archivo debe estar vacío
y no debe tener contenido. Por lo que ahora que entendemos lo que
se pretende hacer este playbook, pasemos al siguiente,
que se llama archivo de
forro punto YAML. Ahora veamos un poco
este libro de jugadas en particular. Ahora el nombre de mi
juego está habilitado SSH reenviando este objetivo a todos los hosts dentro de mi inventario. Por lo que tanto subarray como Thurber estarán dentro de
la sección de prueba. Sólo tengo una tarea definida. El nombre de esa tarea es cambiar el archivo de configuración
SSH D
o cambiar SSH D config. Esto utiliza la línea
en el módulo de archivos. Ahora el destino
es slash, ETC, slash SSH, SSH D config. Este es el
archivo de configuración para mi servicio SSH. Backup se establece en sí y está buscando una expresión regular
específica, eso significa que la línea que comienza
con el reenvío x 11. Esta línea será
reemplazada por la línea que he definido en
la sección de línea. Eso significa x 11 licitación anticipada, sí, el estado está
dispuesto a presentar. Entonces eso significa que la
nueva línea estará presente en mi archivo de configuración SSH D. Entonces al final de ejecutar este playbook,
teóricamente hablando, mi archivo de configuración SSH D debe permitir el reenvío x 11. Ahorraré y saldré. Y vamos a entrar
al nuevo playbook, que es logs dot
YAML, usando VIM. Así que veamos un poco
este libro de jugadas en particular. El nombre de mi juego
se llama logs,
y está apuntando a todos los
hosts dentro del inventario, por lo que tanto el servidor como el servidor
estén dentro de mi sección de prueba. Tengo dos tareas. Mi primera tarea se
llama encontrar cargas, y esto usa el módulo final. Estaré buscando en la ruta
llamada slash var slash log. Estoy buscando todos los archivos que tengan el registro de
puntos de terminación recursivamente. Y registraré
el resultado en una variable subyacente logs. Ahora después,
tengo mi segunda tarea. Ahora mi segunda tarea
se llama Get logs y usa el módulo fetch. Ahora, ¿qué es lo que
realmente va a buscar? Se está recuperando la variable de ruta de
punto elemento, eso es lo que la fuente
y el destino es slash home slash
automatización slash logs. Por último, pasaré
a través de los valores de la variable de archivos de
puntos de logs subyacentes. Esta variable fue definida por nuestro módulo find a través
del comando register, y es por eso que la variable item
dot path tiene la ruta de todos los registros
encontrados usando ese módulo. Por lo que ahora que entendemos
cómo funciona este playbook, simplemente
guardaré y saldré de
este playbook en particular. Y podemos empezar a
ejecutar nuestros playbooks. Por lo que primero
borraría la pantalla y ejecutaré el playbook de Ansible. Y empezaré con el playbook de trabajo de una
sola vez. Sólo tenemos que esperar un poco que
un animal reúna son hechos. Y ha reportado un estado de persecución tanto en el
servidor como en el servidor B. Me conectaré a través de SSH en el servidor y ejecutaré el comando
app q. Pero primero necesito
cambiar de usuario a
ruta para que podamos ver
el trabajo presente. Aquí. Despegaré la pantalla,
saldré, saldré de nuevo. Y ahora volveré a ejecutar
un nuevo playbook usando el comando Playbook de
Ansible. El segundo playbook
que estoy probando es el horario dot YAML playbook. Así que esperemos un poco a
Ansible juntos son hechos. Ahora usemos SSH
para conectarnos al servidor o servidor B
y probar nuestro trabajo. Cambiaré de usuario a root. Y ahora usaré el comando
crontab menos e. Y podemos ver claramente que el
trabajo ha sido
creado con éxito y también con el
hashtag y nombre adecuado. Voy a borrar la pantalla. Saldré y
cerraré mis sesiones. Y luego empezaré a ejecutar un nuevo playbook usando el comando Playbook de
Ansible. Y ejecutaré el directorio
dot YAML playbook. Esperemos un
poco a Ansible juntos son hechos y ha reportado un estado de cambio tanto
en el servidor como en el servidor B. Y podemos ver claramente el directorio recién creado
con los permisos 077. Voy a cerrar las
sesiones y de nuevo, intento ejecutar el comando Playbook de
Ansible para ejecutar un nuevo playbook. Ahora, ejecutaré el
archivo dot YAML playbook. Ahora vamos a esperar un poco a Ansible juntos son hechos,
ha reportado el
estado del cambio tanto en el servidor como en el servidor B. Voy a
usar SSH para conectarme. Y podemos ver el archivo de prueba
presente en la matriz de servidores. Y está claro que
estaría presente también en el servidor B. Ahora, de nuevo,
ejecutemos un nuevo playbook usando el
comando Playbook de Ansible, el archivo de revestimiento. Uno más específicamente. Ahora, ya tengo presente el
reenvío SSH, por lo que en realidad no
había estado de cambio presente. Pero el libro de
jugadas ha funcionado muy bien. Ahora veamos un poco el playbook de YAML de punto de
archivo. De acuerdo, entonces esos son los caminos
que tengo que crear. Voy a repasar por el servidor a. voy a crear el directorio de
archivos. Voy a crear el directorio de
formato de archivo. Entonces crearé algunos
archivos que colocaré dentro de esos directorios
usando el comando touch. Así archivar prueba y luego
archivar formato slash test. Voy a cerrar la sesión. Y ahora voy a hacer
lo mismo también por servidor,
sea para asegurarme de que en realidad
tengo algo que archivar. Así archivo MKDA, MK el formato de archivo
touch archive test, toque archivo formato slash test. Ahora cerraré la
sesión desde el servidor B, y comenzaré a ejecutar mi playbook de Ansible usando el comando Playbook de
Ansible. Sólo tendremos que esperar un
poco a Ansible juntos. Es hecho que ha reportado
el estado de persecución en el servidor B y un estado de error
en la tarea de formato de archivo. Esto es en realidad un
poco de un tema, pero esto no se debe al libro de
jugadas escrito equivocado. Así que vamos a repasar y conectarnos al
servidor a y validar
la tarea de archivo. Y podemos ver el
archivo dot GZ fue creado con éxito. Por lo que acabaré de borrar la pantalla. Y ahora vamos a ejecutar nuestro último playbook usando el comando Playbook de
Ansible. Entonces Ansible playbook registra dot
YAML que obtendrá todos los registros del
host administrado y los traerá
y los colocará en
el anfitrión local. Ahora, esto tomará un
tiempo también. Hay muchos registros para agregar el realmente recogido
desde el host administrado. Y éstos se colocarán
en el anfitrión
local manera organizada y
estructurada. Entonces veamos los registros, en realidad ls, y
podemos ver los registros. Enumeraré el contenido
del directorio Registros. Tenemos cuatro servidor un
servidor estar dentro de esta ruta. Podemos ver claramente que tenemos todos los registros que nos puedan interesar. Simplemente usaré el comando change
directory para ir
al servidor de registro o a un directorio de slash
var slash log. Y tenemos registros para auditoría de
Anaconda, María, el hash de aire,
SM, SSS, de-tune D, etc. Así que todo ha
funcionado perfectamente. Tenemos blogs
centralizados exitosamente desde nuestro host gestionado hasta nuestro anfitrión local de una manera fácil
y estructurada. Con esta demo, hemos concluido
con éxito nuestro curso. Ya sabes usar
los
módulos Ansible más populares y útiles por ahí. Enhorabuena,
te lo has ganado. Con este conocimiento, podrás optimizar muchas tareas de
administración de sistemas dentro de tu
organización y hacer que
todo sea más fácil de
manejar y administrar. Ansible tiene muchos más módulos, pero eso es algo que
cada uno de ustedes tiene que investigar individualmente
dependiendo de la necesidad y el contexto.