Tutoriales

Configuración de Ansible Labs con Vagrant y Virtualbox en Linux

Ansible Es una plataforma de automatización para orquestación, gestión de configuración, despliegue, configuración, etc. Si es un principiante que quiere aprender ansible o que planea obtener la certificación ansible, entonces necesita tener una configuración de laboratorio en casa para practicar ansible.Configurar un laboratorio en casa manualmente es una tarea que requiere mucho tiempo.Hay varias soluciones de automatización como Peón, vagabundo, una solución en la nube que se puede utilizar para crear Ansible Labs. En esta guía, aprenderemos un método automatizado para configurar Ansible Labs en Linux usando Vagrant y VirtualBox.

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

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

Configuración de laboratorio de Ansible

Como requisito previo, debe tener Vagrant y Virtualbox instalados en su máquina Linux. Si no tiene Vagrant instalado, consulte la siguiente guía para instalar Vagrant en diferentes distribuciones de 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 extraviada.

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

tipo de nodo nombre del nodo dirección IP sabor del sistema operativo
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í solo configuré tres nodos para mi laboratorio, pero puede agregar tantos nodos administrados como desee al configurar su propio laboratorio.

Clonar el repositorio del proyecto

He alojado todos los archivos necesarios para configurar Ansible Labs 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 en el directorio del proyecto para ver qué archivos existen.

Estructura del proyecto

Permítanme describir brevemente cada archivo.

1. Archivos vagabundos

Toda la configuración relacionada con la máquina virtual se almacena en este archivo. Este es 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 responsable de configurar ansible en el nodo del controlador, instalar paquetes y modificar la configuración del sistema.

El contenido del archivo es el siguiente:

#!/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 controller\n192.168.10.4 managed1.anslab.com managed1\n192.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 completen las tres compilaciones de VM. Este script será responsable de generar el par de claves ssh y distribuirlo a los tres nodos. También ejecutará un comando ad-hoc de ansible de muestra para verificar.

El contenido del archivo es el siguiente:

#!/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 "controller\n\n[ubuntu1]\nmanaged1\n\n[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

Los 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 compilar Ansible Labs, debe comprender la configuración en Vagrantfile y los scripts de shell.

1. Asignación de memoria y Vcore

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

Memoria y Vcore
Memoria y Vcore

2. Sabor del sistema operativo

Los tres nodos (controlador y alojamiento) usan la imagen de Ubuntu 20.04 LTS. Así que cuando corres «vagrant up» El comando vagabundo buscará los siguientes parámetros e intentará extraer la imagen si no está disponible localmente.

sabor del sistema operativo
sabor del sistema operativo

3. Configuración de red

De forma predeterminada, Vagrant usa NAT en la primera interfaz (adaptador 1). Vagrant utiliza el reenvío de puertos a través de NAT para conectarse a máquinas virtuales. Aquí, configuramos nombres de host y direcciones IP estáticas para las tres máquinas virtuales en la red privada.

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

En un entorno de varias máquinas virtuales, Vagrant solucionará automáticamente los conflictos de puertos.

==> 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». Los usuarios de Vagrant están configurados con privilegios sudo sin contraseña en la máquina virtual de forma predeterminada.

De forma predeterminada, la autenticación basada en contraseña está deshabilitada para las máquinas virtuales. Vagrant creará un par de claves ssh y ejecutará «vagrant ssh» Pedido.

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

Autenticación basada en contraseña superada bootstrap.sh archivo para que pueda conectarse a los nodos utilizando direcciones IP y autenticación basada en contraseña en lugar de autenticación basada en clave.

5. Guión de arranque

El script bootstrap.sh es responsable de

  • Habilite la autenticación basada en contraseña.
  • Crear .huhlogin archivo para suprimir el mensaje de banner predeterminado.
  • Agregar entrada de host a /etc/hosts Archivos de tres nodos.
  • Instale los paquetes necesarios.
  • Instale ansible a través del administrador de paquetes de python (pip) solo en el nodo del controlador.

Estoy usando el configurador de shell donde se copiará bootstrap.sh /tmp/ En las tres ubicaciones de VM, el script se ejecutará con privilegios de raíz.

proveedor de conchas
proveedor de conchas

Cuidado: Si está creando un laboratorio basado en RHEL, debe comenzar con bootstrap.sh Según el documento dnf o rpmEl resto de todas las distribuciones serán similares.

6. Generar par de claves

Ansible usa pares de claves SSH para comunicarse con nodos administrados y ejecutar tareas. Se debe generar una nueva clave desde el nodo del controlador y compartirla con todos los nodos administrados para que ansible pueda comunicarse con los nodos administrados sin solicitar una contraseña cada vez.

texto key_gen.sh Será responsable de crear claves ssh y distribuir claves a todos los nodos.El script también creará un directorio de proyecto. ansible.cfg documentos y documentos de inventario.Esta ad hoc El comando se activará como parte del script para verificar la conexión.

Cuidado: Una vez que se configuran las tres máquinas virtuales, este script debe activarse manualmente desde el nodo del controlador.

Crear la configuración de laboratorio de Ansible

Vaya al directorio del proyecto y ejecute el comando «vagrant up», el resto será manejado por los scripts vagrant y bootstrap.

$ 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…
………

secuencia de comandos posterior a la instalación

Después de configurar las tres máquinas virtuales, inicie sesión en el nodo del controlador para ejecutar /home/vagrant/key_gen.sh Cree un par de claves ssh y verifíquelo ejecutando comandos ad-hoc de ansible.

$ vagrant ssh controller
$ cd /home/vagrant/
$ bash key_gen.sh
Script de máquina de registro
Script de máquina de registro

Comandos vagabundos para administrar máquinas virtuales

Los siguientes comandos lo ayudarán a mantener el ciclo de vida de la máquina errante.

Para comenzar a construir la máquina virtual, ejecute el siguiente comando desde el directorio donde se encuentra el archivo vagabundo.

$ vagrant up

Si solo desea iniciar un nodo, puede agregar el nombre de host a «vagrant up» Pedido.

$ 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 proporcionará 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 una máquina virtual, puede ejecutar «vagrant ssh» comando. Debe pasar el nombre de la máquina virtual o se lanzará el siguiente error.

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

Para ssh en la máquina virtual m1, el comando es:

$ vagrant ssh m1

o,

$ vagrant ssh cf2e302

Si la autenticación basada en contraseña está habilitada, también puede conectarse usando un nombre de usuario y una contraseña.

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

Para detener una máquina virtual específica, 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, incluidos sus discos, 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…

En conclusión

En este artículo, muestro un método automatizado para configurar un laboratorio ansible usando Vagrant y VirtualBox. Este laboratorio se creó con la pila Ubuntu 20.04 LTS.

Si va a obtener la certificación ansible y desea practicar en el laboratorio, le sugiero que edite el archivo vagabundo para señalar el nombre del cuadro al estilo RHEL y reemplazar apt comando apropiado dnf/yum mando en bootstrap.sh documento.

Publicaciones relacionadas

Deja una respuesta

Tu dirección de correo electrónico no será publicada.

Botón volver arriba