Configuración automatizada de Ansible Lab con Vagrant y Virtualbox en Linux

Ansible es una plataforma de automatización utilizada en el área de orquestación, gestión de configuración, implementaciones, aprovisionamiento, etc. Si es un principiante que quiere aprender ansible o alguien que planea obtener la certificación ansible, entonces necesita tener una configuración de laboratorio en casa para practicar ansible . Configurar un laboratorio doméstico manualmente es una tarea que requiere mucho tiempo. Hay un par de soluciones automatizadas como Estibador , Vagabundo , Cloud soluciones que se pueden utilizar para construir el laboratorio ansible. En esta guía, aprenderemos una forma automatizada de configurar Ansible lab con Vagrant y VirtualBox en linux

Vagrant es una excelente herramienta para configurar rápidamente su entorno de desarrollo. Si eres nuevo en Vagrant, te sugiero que le eches un vistazo a nuestra guía de introducción a Vagrant.

  • Tutorial de Vagrant – Primeros pasos con Vagrant en Linux

A los efectos de esta guía, utilizaremos Vagrant con VirtualBox como proveedor para construir nuestro laboratorio ansible. También puede usar KVM en lugar de VirtualBox. Si desea utilizar KVM como proveedor, consulte el siguiente artículo sobre cómo utilizar vagrant con KVM.

  • Cómo usar Vagrant con el proveedor KVM de Libvirt

Configuración de Ansible Lab

Como requisito previo, debe tener Vagrant y Virtualbox instalados en su máquina Linux. Si aún no ha instalado Vagrant, consulte la siguiente guía para instalar Vagrant en diferentes distribuciones de Linux.

  • Cómo instalar Vagrant en Linux

Construiremos una configuración de laboratorio ansible de tres nodos. Un nodo actuará como nodo maestro/controlador y dos nodos actuarán como nodos administrados. Para fines de demostración, estoy usando ubuntu/focal64 caja vagabunda.

Estos son los detalles de la configuración de mi laboratorio Ansible.

TIPO DE NODO NOMBRE DEL NODO DIRECCIÓN IP LOS SABORES
Nodo de control controlador.anslab.com 192.168.10.3 ubuntu /focal64
Nodo administrado gestionado1.anslab.com 192.168.10.4 ubuntu/focal64
Nodo administrado gestionado2.anslab.com 192.168.10.5 ubuntu/focal64

Configuración de Ansible Lab de tres nodos

Aquí estoy configurando solo tres nodos para mi laboratorio, pero puede agregar tantos nodos administrados como desee al configurar su propio laboratorio.

Clonar repositorio de proyectos

He alojado todos los archivos necesarios para configurar Ansible lab en mi repositorio de GitHub. Ejecute el siguiente comando para clonar el repositorio localmente.

                      $ git clone --recursive https://github.com/KarthickSudhakar/Ansible_lab_vagrant_virtualbox.git
                    

Naveguemos dentro del directorio del proyecto para ver qué archivos están presentes.

Estructura del proyecto

Permítanme darles una breve introducción a cada archivo.

1. archivo vagabundo

Todas las configuraciones relacionadas con la VM se almacenan en este archivo. Aquí está el contenido de este archivo.

                      # -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|
  
  config.vm.provider "virtualbox" do |rs|
    rs.memory = 2048
    rs.cpus = 2
  end

  # Will not check for box updates during every startup.
  config.vm.box_check_update = false


  # Master node where ansible will be installed
  config.vm.define "controller" do |controller|
    controller.vm.box = "ubuntu/focal64"
    controller.vm.hostname = "controller.anslab.com"
    controller.vm.network "private_network", ip: "192.168.10.3"
    controller.vm.provision "shell", path: "bootstrap.sh"
    controller.vm.provision "file", source: "key_gen.sh", destination: "/home/vagrant/"
  end

  # Managed node 1.
  config.vm.define "m1" do |m1|
    m1.vm.box = "ubuntu/focal64"
    m1.vm.hostname = "managed1.anslab.com"
    m1.vm.network "private_network", ip: "192.168.10.4"
    m1.vm.provision "shell", path: "bootstrap.sh"
  end

  # Managed node 2.
  config.vm.define "m2" do |m2|
    m2.vm.box = "ubuntu/focal64"
    m2.vm.hostname = "managed2.anslab.com"
    m2.vm.network "private_network", ip: "192.168.10.5"
    m2.vm.provision "shell", path: "bootstrap.sh"
  end

end
                    

2. bootstrap.sh

Este es un script de shell que es responsable de configurar ansible en el nodo del controlador, instalar paquetes y modificar las configuraciones del sistema.

El contenido de este archivo se proporciona a continuación:

                      #!/usr/bin/env bash

# vagrant by default creates its own keypair for all the machines. Password based authentication will be disabled by default and enabling it so password based auth can be done.

sudo sed -i 's/PasswordAuthentication no/PasswordAuthentication yes/' /etc/ssh/sshd_config
sudo systemctl restart sshd

# Supressing the banner message everytime you connect to the vagrant box.

touch /home/vagrant/.hushlogin

# Updating the hosts file for all the 3 nodes with the IP given in vagrantfile

# 192.168.10.3 controller.ansible.com controller
# 192.168.10.4 managed1.ansible.com managed1
# 192.168.10.5 managed2.ansible.com managed2

echo -e "192.168.10.3 controller.anslab.com controllern192.168.10.4 managed1.anslab.com managed1n192.168.10.5 managed2.anslab.com managed2" >> /etc/hosts

# Installing necessary packages 

sudo apt update && sudo apt -y install curl wget net-tools iputils-ping python3-pip sshpass

# Install ansible using pip only in controller node

if [[ $(hostname) = "controller" ]]; then
  sudo pip3 install ansible
fi

                    

3. key_gen.sh

Este script debe activarse manualmente una vez que se complete la compilación de las tres máquinas virtuales. Este script se encargará de generar un par de claves ssh, distribuyéndolo entre los tres nodos. También ejecutará un comando ad-hoc de ansible de muestra para la validación.

El contenido de este archivo se da a continuación:

                      #!/usr/bin/env bash

# THIS SCRIPT WILL CREATE SSH KEYPAIR AND DISTRIBUTE ACROSS ALL NODES

ssh-keygen -b 2048 -t rsa -f /home/vagrant/.ssh/id_rsa -q -N ""

# LOOPING THROUGH AND DISTRIBUTING THE KEY

for val in controller managed1 managed2; do 
	echo "-------------------- COPYING KEY TO ${val^^} NODE ------------------------------"
	sshpass -p 'vagrant' ssh-copy-id -o "StrictHostKeyChecking=no" [email protected]$val 
done

# CREATE THE INVENTORY FILE

PROJECT_DIRECTORY="/home/vagrant/ansible_project/"

mkdir -p $PROJECT_DIRECTORY
cd $PROJECT_DIRECTORY

# Creating the inventory file for all 3 nodes to run some adhoc command.

echo -e "controllernn[ubuntu1]nmanaged1nn[ubuntu2]nmanaged2" > inventory
echo -e "[defaults]ninventory = inventory" > ansible.cfg
echo -e "-------------------- RUNNING ANSBILE ADHOC COMMAND - UPTIME ------------------------------"
echo

# running adhoc command to see if everything is fine

ansible all -i inventory -m "shell" -a "uptime"
echo
                    

Todos estos tres archivos están alojados en mi repositorio de GitHub. Siéntete libre de contribuir y mejorarlo.

Comprender la configuración de Vagrantfile

Antes de construir el laboratorio de Ansible, debe comprender las configuraciones dentro de Vagrantfile y los scripts de shell.

1. Asignación de memoria y Vcore

Para las tres cajas vagabundas, necesitamos configurar la memoria y el valor de la CPU. Aquí la memoria está configurada para 2GB y la CPU está configurada para 2 . Si desea aumentar o disminuir el límite, simplemente ajuste los parámetros resaltados en el Vagrantfile.

Memoria y Vcore

2. Sabor del sistema operativo

Los tres nodos (controlador y administrado) usan la imagen de Ubuntu 20.04 LTS. Así que cuando ejecutas el “ vagrant up ” el comando vagabundo buscará el siguiente parámetro e intentará extraer la imagen si no está disponible localmente.

Sabor del sistema operativo Sabor del sistema operativo

3. Configuración de red

Por defecto, vagabundo usa NAT en la primera interfaz (adaptador 1). Vagrant utiliza el reenvío de puertos a través de NAT para conectarse a la máquina virtual. Aquí estamos configurando el nombre de host y las direcciones IP estáticas para las tres máquinas virtuales en la red privada.

Se creará una interfaz separada (Adapter2) y se le asignará la dirección IP estática. Las máquinas virtuales que forman parte de la red privada pueden comunicarse entre sí.

En el entorno de múltiples máquinas virtuales, el vagabundo corregirá automáticamente la colisión del puerto.

                      
                        ==> m2: Fixed port collision for 22 => 2222. Now on port 2201.
                      
                      
==> m2: Clearing any previously set network interfaces...

                      
                        ==> m2: Preparing network interfaces based on configuration...
    m2: Adapter 1: nat
    m2: Adapter 2: hostonly
                      
                      
==> m2: Forwarding ports...
    m2: 22 (guest) => 2201 (host) (adapter 1)
==> m2: Running 'pre-boot' VM customizations...
==> m2: Booting VM...
==> m2: Waiting for machine to boot. This may take a few minutes...
    m2: SSH address: 127.0.0.1:2201
                    
Red y nombre de host Red y nombre de host

4. Nombre de usuario y comunicación SSH

Hay un usuario predeterminado llamado “vagabundo” con contraseña “vagabundo”. El usuario vagabundo no tiene contraseña sudo privilegio configurado en la máquina virtual por defecto.

De forma predeterminada, la autenticación basada en contraseña está deshabilitada para la máquina virtual. Vagrant creará un par de claves ssh y usará la clave privada para conectarse a la máquina virtual cuando ejecute “ vagrant ssh ” mando.

                      $ vagrant ssh controller
                      
$ vagrant ssh m1
$ vagrant ssh m2

La autenticación basada en contraseña se habilita a través de la bootstrap.sh para que pueda conectarse al nodo utilizando la dirección IP y la autenticación basada en contraseña en lugar de la autenticación basada en clave.

5. Guión de arranque

El script bootstrap.sh es responsable de

  • Habilitación de la autenticación basada en contraseña.
  • Crear un .huhlogin archivo para suprimir el mensaje de banner predeterminado.
  • Agregue las entradas de host en el /etc/hosts archivo para los tres nodos.
  • Instalación de paquetes necesarios.
  • Instalación de ansible a través del administrador de paquetes de python (pip) solo en el nodo del controlador.

Estoy usando el aprovisionador de shell, donde bootstrap.sh se copiará en el /tmp/ ubicación en las tres máquinas virtuales y el script se ejecutará con privilegios de root.

Comisiones Shell Comisiones Shell

Aviso: Si está creando un laboratorio basado en RHEL, debe editar el comando de instalación del paquete desde el bootstrap.sh archivo de acuerdo a dnf o rpm . El resto será similar en todas las distribuciones.

6. Generar par de claves

Ansible usa un par de claves SSH para comunicarse con los nodos administrados y ejecutar la tarea. Las nuevas claves deben generarse desde el nodo del controlador y compartirse con todos los nodos administrados para que ansible pueda comunicarse con los nodos administrados sin solicitar contraseñas cada vez.

La secuencia de comandos key_gen.sh se encargará de crear claves ssh y distribuir las claves a todos los nodos. El script también creará un directorio de proyecto con ansible.cfg archivo y archivo de inventario. los ad hoc El comando se activará como parte del script para validar la conectividad.

Aviso: Este script debe activarse manualmente desde el nodo del controlador una vez que se aprovisionan las tres máquinas virtuales.

Crear la configuración de laboratorio de Ansible

Vaya al directorio del proyecto y ejecute el comando “vagrant up” y el script vagrant y bootstrap se encargará del resto.

                      $ cd Ansible_lab_vagrant_virtualbox
                    
                      $ vagrant up
                    

Salida de muestra:

                      Bringing machine 'controller' up with 'virtualbox' provider…
                      
Bringing machine 'm1' up with 'virtualbox' provider…
Bringing machine 'm2' up with 'virtualbox' provider…
………

Script posterior a la instalación

Una vez que se aprovisionan las tres máquinas virtuales, inicie sesión en el nodo del controlador para ejecutar el /home/vagrant/key_gen.sh para crear pares de claves ssh y validar ejecutando un comando ad-hoc de ansible.

                      $ vagrant ssh controller
                      
$ cd /home/vagrant/
$ bash key_gen.sh
Keygen-Script Keygen-Script

Comandos vagabundos para administrar VM

Seguir los comandos lo ayudará a mantener el ciclo de vida de las máquinas vagabundas.

Para comenzar a construir las máquinas virtuales, ejecute el siguiente comando desde el directorio donde se encuentra el archivo vagabundo.

                      $ vagrant up
                    

Si desea activar solo un nodo, puede agregar el nombre de host al “ vagrant up ” mando.

                      $ vagrant up controller
                    

Para verificar el estado de la máquina, ejecute el siguiente comando.

                      $ vagrant status
Current machine states:

controller running (virtualbox)
m1 running (virtualbox)
m2 running (virtualbox)
                    

También puede usar el siguiente comando que le dará más información sobre la máquina virtual.

                      $ vagrant global-status --prune

name       provider   state    directory                                                                    
---------------------------------------------------------------------------------------------------------------------
6095cc7  controller virtualbox running  /home/karthick/Karthick_Root/Work/Vagrant/Lab/Ansible_lab_vagrant_virtualbox 
cf2e302  m1         virtualbox running  /home/karthick/Karthick_Root/Work/Vagrant/Lab/Ansible_lab_vagrant_virtualbox 
af10f7d  m2         virtualbox running  /home/karthick/Karthick_Root/Work/Vagrant/Lab/Ansible_lab_vagrant_virtualbox 
                    

Para conectarse a la máquina virtual puede ejecutar “ vagrant ssh “comando. Tienes que pasar el nombre de la máquina virtual; de lo contrario, arrojará el siguiente error.

                      $ vagrant ssh
                      
This command requires a specific VM name to target in a multi-VM environment.

Para ssh en m1 VM, el comando sería:

                      $ vagrant ssh m1
                    

O,

                      $ vagrant ssh cf2e302
                    

También puede conectarse usando el nombre de usuario y la contraseña si la autenticación basada en contraseña está habilitada.

                      $ ssh [email protected]
                      
[email protected]'s password:
[email protected]:~$

Para detener una máquina virtual en particular, ejecute el comando detener con el nombre de máquina virtual.

                      $ vagrant halt controller
                    

Para detener todas las máquinas virtuales, ejecute el siguiente comando.

                      $ vagrant halt
                      
==> m2: Attempting graceful shutdown of VM…
==> m1: Attempting graceful shutdown of VM…
==> controller: Attempting graceful shutdown of VM…

Para destruir todas las máquinas virtuales, incluido su disco, ejecute el siguiente comando.

                      $ vagrant destroy -f
                      
==> m2: Destroying VM and associated drives…
==> m1: Destroying VM and associated drives…
==> controller: Destroying VM and associated drives…

Conclusión

En este artículo, mostré la forma automatizada de configurar ansible lab usando Vagrant y VirtualBox. El laboratorio se crea con una pila Ubuntu 20.04 LTS.

Si planea obtener la certificación ansible y quiere un laboratorio para practicar, le sugiero que edite el archivo vagabundo apuntando el nombre del cuadro al sabor RHEL y reemplace el apt comando para apropiarse dnf / yum comando en el bootstrap.sh expediente.

Leer siguiente:

  • Archivos de inventario y configuración de Ansible

Related Posts