Abile è una piattaforma di automazione utilizzata nell'area dell'orchestrazione, della gestione della configurazione, delle implementazioni, del provisioning, ecc. Se sei un principiante che vuole imparare ansible o qualcuno che intende prendere la certificazione ansible, allora devi disporre di una configurazione di laboratorio a casa per esercitarti in ansible . L'impostazione manuale di un laboratorio domestico è un'attività che richiede tempo. Esistono un paio di soluzioni automatizzate come Docker , Vagabondo , Soluzioni cloud che possono essere utilizzate per costruire il laboratorio ansible. In questa guida impareremo un modo automatico per configurare Ansible lab con Vagrant e VirtualBox in Linux.
Vagrant è uno strumento eccellente per configurare rapidamente il tuo ambiente di sviluppo. Se non conosci il vagabondo, ti suggerisco di dare un'occhiata alla nostra introduzione alla guida di Vagrant.
- Tutorial Vagrant - Iniziare con Vagrant in Linux
Ai fini di questa guida, utilizzeremo Vagrant con VirtualBox come provider per creare il nostro laboratorio ansible. Puoi anche usare KVM invece di VirtualBox. Se desideri utilizzare KVM come provider, fai riferimento al seguente articolo su come utilizzare Vagrant con KVM.
- Come utilizzare Vagrant con il provider KVM Libvirt
Impostazione di Ansible Lab
Come prerequisito, devi avere Vagrant e Virtualbox installati sulla tua macchina Linux. Se non hai ancora installato Vagrant, fai riferimento alla seguente guida per installare Vagrant su diverse distribuzioni Linux.
- Come installare Vagrant su Linux
Costruiremo una configurazione di laboratorio ansible a tre nodi. Un nodo fungerà da nodo master/controller e due nodi fungeranno da nodi gestiti. A scopo dimostrativo, sto usando ubuntu/focal64 casella vagabondo.
Ecco i dettagli della configurazione del mio laboratorio Ansible.
| TIPO DI NODO | NOME DEL NODO | INDIRIZZO IP | OS FLAVOUR |
| Nodo di controllo | controller.anslab.com | 192.168.10.3 | ubuntu/focal64 |
| Nodo gestito | managed1.anslab.com | 192.168.10.4 | ubuntu/focal64 |
| Nodo gestito | managed2.anslab.com | 192.168.10.5 | ubuntu/focal64 |
Qui sto configurando solo tre nodi per il mio lab, ma puoi aggiungere tutti i nodi gestiti che desideri quando configuri il tuo lab.
Clone del repository del progetto
Ho ospitato tutti i file necessari per configurare Ansible Lab nel mio repository GitHub. Esegui il comando seguente per clonare il repository in locale.
$ git clone --recursive https://github.com/KarthickSudhakar/Ansible_lab_vagrant_virtualbox.git
Navighiamo all'interno della directory del progetto per vedere quali file sono presenti.
Lascia che ti dia una breve introduzione a ciascun file.
1. Vagrantfile
Tutte le configurazioni relative alla VM sono archiviate in questo file. Ecco il contenuto di questo file.
# -*- 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
Questo è uno script di shell che è responsabile della configurazione di ansible nel nodo controller, dell'installazione dei pacchetti, della modifica delle configurazioni del sistema.
Il contenuto di questo file è riportato di seguito:
#!/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
Questo script deve essere attivato manualmente una volta completata la compilazione di tutte e tre le macchine virtuali. Questo script si occuperà di generare una coppia di chiavi ssh, distribuendola su tutti e tre i nodi. Verrà inoltre eseguito un comando ad-hoc di esempio ansible per la convalida.
Il contenuto di questo file è riportato di seguito:
#!/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 Tutti questi tre file sono ospitati nel mio repository GitHub. Sentiti libero di contribuire e migliorarlo.
Comprendere la configurazione di Vagrantfile
Prima di creare Ansible lab, devi comprendere le configurazioni all'interno di Vagrantfile e gli script della shell.
1. Allocazione di memoria e Vcore
Per tutte e tre le caselle vaganti, dobbiamo impostare la memoria e il valore della CPU. Qui la memoria è impostata su 2 GB e la CPU è impostata su 2 . Se desideri aumentare o diminuire il limite, regola semplicemente i parametri evidenziati nel Vagrantfile.
2. Sapore del sistema operativo
Tutti e tre i nodi (controller e gestiti) utilizzano l'immagine LTS di Ubuntu 20.04. Quindi, quando esegui il "vagrant up " command vagrant cercherà il parametro seguente e proverà a estrarre l'immagine se non è disponibile localmente.
3. Impostazioni di rete
Per impostazione predefinita, il vagabondo utilizza NAT nella prima interfaccia (adattatore 1). Vagrant utilizza il port forwarding su NAT per connettersi alla macchina virtuale. Qui stiamo impostando il nome host e gli indirizzi IP statici per tutte e tre le VM sulla rete privata.
Verrà creata un'interfaccia separata (Adapter2) a cui verrà assegnato l'indirizzo IP statico. Le VM che fanno parte della rete privata possono comunicare tra loro.
Nell'ambiente multi-VM, il vagabondo risolverà automaticamente la collisione della porta.
==> 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 
4. Nome utente e comunicazione SSH
C'è un utente predefinito chiamato "vagabondo" con password "vagabondo". L'utente Vagrant ha il privilegio sudo senza password configurato nella macchina virtuale per impostazione predefinita.
Per impostazione predefinita, l'autenticazione basata su password è disabilitata per la macchina virtuale. Vagrant creerà una coppia di chiavi ssh e utilizzerà la chiave privata per connettersi alla macchina virtuale quando esegui "vagrant ssh " comando.
$ vagrant ssh controller
$ vagrant ssh m1
$ vagrant ssh m2
L'autenticazione basata su password è abilitata tramite bootstrap.sh file in modo da poterti connettere al nodo utilizzando l'indirizzo IP e l'autenticazione basata su password anziché l'autenticazione basata su chiave.
5. Script Bootstrap
Lo script bootstrap.sh è responsabile di
- Abilitazione dell'autenticazione basata su password.
- Crea un
.huhloginper eliminare il messaggio banner predefinito. - Aggiungi le voci dell'host nel
/etc/hostsfile per tutti e tre i nodi. - Installazione dei pacchetti richiesti.
- Installazione di ansible tramite python package manager(pip) solo sul nodo controller.
Sto usando il provisioner della shell, dove bootstrap.sh verrà copiato in /tmp/ posizione in tutte e tre le VM e lo script verrà eseguito con il privilegio di root.
Avviso: Se stai creando un lab basato su RHEL, dovresti modificare il comando di installazione del pacchetto da bootstrap.sh file secondo dnf o rpm . Resto tutto sarà simile in tutte le distribuzioni.
6. Genera coppia di chiavi
Ansible utilizza la coppia di chiavi SSH per comunicare con i nodi gestiti ed eseguire l'attività. Le nuove chiavi dovrebbero essere generate dal nodo controller e condivise con tutti i nodi gestiti in modo che ansible possa comunicare con i nodi gestiti senza richiedere password ogni volta.
Lo script key_gen.sh si occuperà di creare chiavi ssh e distribuire le chiavi a tutti i nodi. Lo script creerà anche una directory di progetto con ansible.cfg file e file di inventario. Il ad hoc il comando verrà attivato come parte dello script per convalidare la connettività.
Avviso: Questo script deve essere attivato manualmente dal nodo controller una volta eseguito il provisioning di tutte e tre le VM.
Crea configurazione di Ansible Lab
Vai alla directory del progetto ed esegui il comando "vagrant up" e il resto sarà curato dallo script vagrant e bootstrap.
$ cd Ansible_lab_vagrant_virtualbox
$ vagrant up
Risultato di esempio:
Bringing machine 'controller' up with 'virtualbox' provider…
Bringing machine 'm1' up with 'virtualbox' provider…
Bringing machine 'm2' up with 'virtualbox' provider…
………
Script post-installazione
Una volta eseguito il provisioning di tutte e tre le VM, accedi al nodo controller per eseguire /home/vagrant/key_gen.sh per creare coppie di chiavi ssh e convalidare eseguendo un comando ad-hoc ansible.
$ vagrant ssh controller
$ cd /home/vagrant/
$ bash key_gen.sh
Comandi Vagrant per gestire VM
I seguenti comandi ti aiuteranno a mantenere il ciclo di vita delle macchine vagabonde.
Per iniziare a costruire le macchine virtuali, esegui il seguente comando dalla directory in cui si trova il file vagrant.
$ vagrant up
Se vuoi portare in alto un solo nodo, puoi aggiungere il nome host a "vagrant up " comando.
$ vagrant up controller
Per controllare lo stato della macchina, esegui il comando seguente.
$ vagrant status Current machine states: controller running (virtualbox) m1 running (virtualbox) m2 running (virtualbox)
Puoi anche usare il comando seguente che fornirà maggiori informazioni sulla VM.
$ 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
Per connetterti alla macchina virtuale puoi eseguire "vagrant ssh " comando. Devi passare il nome vm altrimenti genererà il seguente errore.
$ vagrant ssh
This command requires a specific VM name to target in a multi-VM environment.
Per accedere a m1 VM, il comando sarebbe:
$ vagrant ssh m1
Oppure,
$ vagrant ssh cf2e302
Puoi anche connetterti utilizzando il nome utente e la password se l'autenticazione basata su password è abilitata.
$ ssh [email protected]
[email protected]'s password:
[email protected]:~$
Per arrestare una particolare macchina virtuale, eseguire il comando halt con vm name.
$ vagrant halt controller
Per arrestare tutte le macchine virtuali, esegui il comando seguente.
$ vagrant halt
==> m2: Attempting graceful shutdown of VM…
==> m1: Attempting graceful shutdown of VM…
==> controller: Attempting graceful shutdown of VM…
Per distruggere tutte le macchine virtuali incluso il relativo disco, eseguire il comando seguente.
$ vagrant destroy -f
==> m2: Destroying VM and associated drives…
==> m1: Destroying VM and associated drives…
==> controller: Destroying VM and associated drives…
Conclusione
In questo articolo, ho mostrato il modo automatico per configurare ansible lab utilizzando Vagrant e VirtualBox. Il lab viene creato con uno stack Ubuntu 20.04 LTS.
Se hai intenzione di prendere una certificazione ansible e vuoi esercitarti in un laboratorio, ti suggerisco di modificare il file vagrant puntando il nome della casella su RHEL sapore e sostituire apt comando per appropriarsi di dnf /yum comando nel bootstrap.sh file.
Leggi il prossimo:
- Inventario Ansible e file di configurazione