He decidido simplificar mi proceso de actualización para los sistemas de los clientes que admito, así como para mis propios dispositivos Linux. Si bien una serie de secuencias de comandos complejas me han servido bien durante mucho tiempo, las ventajas de usar Ansible para esta tarea son demasiadas para dejarlas pasar.
En la primera parte de esta serie de artículos, analicé el proceso de actualización real, establecí la estructura de mi libro de jugadas y presenté palabras clave y comentarios. El libro de jugadas contiene tres jugadas. Cada juego gestiona una categoría de sistemas. Play 1 maneja mi dispositivo controlador Ansible (mi estación de trabajo principal), mientras que Plays 2 y 3 administran los servidores y las estaciones de trabajo restantes.
Comencemos este segundo artículo examinando la segunda obra.
La segunda jugada
Aquí está la segunda obra completa. El propósito de este juego es realizar actualizaciones en el firewall y el servidor.
El firewall debe estar en funcionamiento mientras los servidores, y todos los demás hosts, se actualizan para que puedan tener acceso a Internet para descargar los paquetes de actualización. El servidor debe ejecutarse mientras se actualizan el cortafuegos y otros hosts para proporcionar DHCP y servicios de nombres. Para lograr eso, este juego actualiza esos dos hosts uno a la vez.
Los nombres de estos dos hosts se encuentran en [all_servers] grupo en el /etc/ansible/hosts archivo de inventario.
#######################################################################
#######################################################################
# Play 2 - Do servers
#######################################################################
#######################################################################
- name: Play 2 - Install updates for servers yorktown and wally
hosts: all_servers
serial: 1
remote_user: root
vars:
run: false
reboot: false
tasks:
#######################################################################
# Do some preliminary checking
#######################################################################
- name: Install the latest version of the doUpdates script
copy:
src: /root/ansible/Updates/files/doUpdates
dest: /usr/local/bin
mode: 0774
owner: root
group: root
- name: Check for currently available updates
command: doUpdates -c
register: check
- debug: var=check.stdout_lines
#######################################################################
# Do the updates.
#######################################################################
# Install all available updates
- name: Install all current updates
dnf:
name: "*"
state: latest
when: (check.stdout | regex_search('updates ARE available')) and run == "true"
- name: Update the man database
command: mandb
when: run
- name: Reboot if necessary and reboot extra variable is true
reboot:
when: (check.stdout | regex_search('reboot will be required')) and reboot == "true" and run == "true" [ También te puede interesar: Una introducción a Ansible Tower ]
Toda esta segunda obra es casi igual a la primera, excepto por dos líneas.
serie :esta declaración adicional le dice a Ansible que ejecute este juego en un host a la vez, es decir, en serie en lugar de en paralelo. Si todos_los_servidores grupo en el inventario contenía diez servidores, podría usar un límite más alto, como dos, para que esta jugada se ejecutara contra dos servidores a la vez. En este caso, necesito wally , el cortafuegos, esté en funcionamiento para que el yorktown servidor tiene acceso a Internet para descargar los paquetes actualizados. No importa en qué secuencia se actualicen estos dos hosts, siempre que no se realicen simultáneamente.
reiniciar :Ansible tiene una capacidad de reinicio incorporada, por lo que podemos usarla en este juego en lugar del comando de apagado de Linux. La característica fundamental de la función de reinicio de Ansible es que realiza una verificación de que el reinicio se ha realizado correctamente, el host remoto está en funcionamiento y la comunicación SSH vuelve a funcionar. El tiempo de espera predeterminado para esto es de 10 minutos, luego de lo cual Ansible arroja un error.
La tercera jugada
Y aquí está la tercera jugada. Esta reproducción actualiza todos los hosts restantes en mi red. Los nombres de estos hosts se encuentran en [estaciones de trabajo] grupo de /etc/ansible/hosts archivo de inventario.
#######################################################################
#######################################################################
# Play 3 - Do all workstations except david
#######################################################################
#######################################################################
- name: Play 3 - Install updates for all workstations except david
hosts: workstations
strategy: free
remote_user: root
vars:
run: false
reboot: false
tasks:
#######################################################################
# Do some preliminary checking
#######################################################################
- name: Install the latest version of the doUpdates script
copy:
src: /root/ansible/Updates/files/doUpdates
dest: /usr/local/bin
mode: 0774
owner: root
group: root
- name: Check for currently available updates
command: doUpdates -c
register: check
- debug: var=check.stdout_lines
#######################################################################
# Do the updates.
#######################################################################
# Install all available updates
- name: Install all current updates
dnf:
name: "*"
state: latest
when: (check.stdout | regex_search('updates ARE available')) and run == "true"
- name: Reboot if necessary and reboot extra variable is true
reboot:
when: (check.stdout | regex_search('reboot will be required')) and reboot == "true" and run == "true" Solo hay un cambio en este libro de jugadas además de la lista de hosts.
estrategia :El gratis La estrategia le dice a Ansible que realice las tareas en este juego libremente. Las tareas en este juego se ejecutan en cada host tan rápido como el host puede realizarlas. Esto significa que algunos hosts pueden terminar la última tarea mucho antes de que otros hosts más lentos hayan completado incluso la primera tarea del manual. Puede parecer una especie de juego gratuito mientras lee el flujo de datos STDOUT.
Cada estrategia es un complemento separado, y hay un par de otros complementos que se pueden usar con esta palabra clave. El valor predeterminado es lineal , que realiza cada tarea en todos los hosts antes de pasar a la siguiente tarea. El host_pinned El complemento realiza todas las tareas en el juego en cada host antes de pasar al siguiente host. La depuración El complemento ejecuta tareas de forma interactiva para que la reproducción se pueda depurar.
Ejecutar el libro de jugadas
Ejecuto este libro de jugadas usando el comando:
# ansible-playbook -e "run=true reboot=true" doUpdates.yml
El -e opción significa "variables adicionales". Aquí especifica valores para las dos variables definidas en cada jugada. En este caso, establecer ambos en verdadero permite realizar las actualizaciones y reiniciar (apagar) si es necesario.
No reproduciré el STDOUT flujo de datos aquí porque es bastante largo.
Reflexiones finales
Con algunos cambios para reflejar los detalles de su red, este libro de jugadas se puede utilizar para automatizar sus tareas de actualización. Realizar actualizaciones con un libro de jugadas similar al mío es una buena manera de comenzar a usar Ansible. Aunque utiliza varias palabras clave que pueden realizar tareas complejas, este es un libro de jugadas relativamente simple. Empecé solo con la primera reproducción para actualizar mi estación de trabajo personal, y el resto fue principalmente copiar y pegar, con algunos cambios menores para adaptarme a las necesidades de los diferentes grupos de anfitriones.
Sí, hay otras formas de hacer esto. Probablemente podría haber usado diferentes tareas usando condicionales dentro de una o dos jugadas en lugar de tres jugadas. O podría haber usado condicionales y bloques para lidiar con el manejo de hosts específicos de manera diferente. Personalmente, creo que las jugadas individuales ayudan a separar la lógica lo suficiente como para que cambiar la forma en que se manejan las tareas en una jugada no afecte a las demás. En mi opinión, esta separación también es más elegante porque la lógica general es más sencilla de escribir, comprender y administrar.
[ Una guía gratuita de Red Hat:5 pasos para automatizar su negocio. ]
Recursos
El documento más completo y útil que he encontrado es la Guía del usuario de Ansible en el sitio web de Ansible. Este documento pretende ser una referencia y no un documento de instrucciones o de introducción.
Opensource.com ha publicado muchos artículos sobre Ansible a lo largo de los años y he encontrado que la mayoría de ellos son muy útiles para mis necesidades. El sitio web Red Hat Enable Sysadmin también tiene muchos artículos de Ansible que he encontrado útiles.
También hay algunas páginas man buenas pero concisas disponibles.