Automatisierte Ansible Lab-Einrichtung mit Vagrant und Virtualbox unter Linux

Ansibel ist eine Automatisierungsplattform, die im Bereich der Orchestrierung, des Konfigurationsmanagements, der Bereitstellung, der Bereitstellung usw. verwendet wird. Wenn Sie ein Anfänger sind, der Ansible lernen möchte, oder jemand, der eine Ansible-Zertifizierung anstrebt, benötigen Sie ein Heimlabor, um Ansible zu üben . Die manuelle Einrichtung eines Heimlabors ist eine zeitaufwändige Aufgabe. Es gibt einige automatisierte Lösungen wie Docker , Landstreicher , Cloud-Lösungen, die zum Aufbau des Ansible-Labs verwendet werden können. In diesem Leitfaden lernen wir eine automatisierte Methode zum Einrichten von Ansible Lab mit Vagrant und VirtualBox unter Linux kennen.

Vagrant ist ein hervorragendes Tool, um Ihre Entwicklungsumgebung schnell einzurichten. Wenn Sie neu bei Vagrant sind, schlage ich vor, dass Sie sich unsere Einführung in den Vagrant-Leitfaden ansehen.

• Vagrant-Tutorial – Erste Schritte mit Vagrant unter Linux

Für die Zwecke dieses Leitfadens verwenden wir Vagrant mit VirtualBox als Anbieter, um unser Ansible-Lab zu erstellen. Sie können auch KVM anstelle von VirtualBox verwenden. Wenn Sie KVM als Anbieter verwenden möchten, lesen Sie den folgenden Artikel zur Verwendung von Vagrant mit KVM.

• So verwenden Sie Vagrant mit dem Libvirt KVM-Anbieter

Ansible Lab-Setup

Als Voraussetzung müssen Sie Vagrant und Virtualbox auf Ihrem Linux-Rechner installiert haben. Wenn Sie Vagrant noch nicht installiert haben, lesen Sie bitte die folgende Anleitung, um Vagrant auf verschiedenen Linux-Distributionen zu installieren.

• So installieren Sie Vagrant unter Linux

Wir werden ein Ansible-Lab-Setup mit drei Knoten erstellen. Ein Knoten fungiert als Master-/Controller-Knoten und zwei Knoten fungieren als verwaltete Knoten. Zu Demonstrationszwecken verwende ich ubuntu/focal64 vagabundierende Kiste.

Hier sind die Details meines Ansible-Lab-Setups.

KNOTENTYP	KNOTENNAME	IP-ADRESSE	OS-GESCHMACK
Kontrollknoten	controller.anslab.com	192.168.10.3	ubuntu/focal64
Verwalteter Knoten	managed1.anslab.com	192.168.10.4	ubuntu/focal64
Verwalteter Knoten	managed2.anslab.com	192.168.10.5	ubuntu/focal64

Hier richte ich nur drei Knoten für mein Lab ein, aber Sie können beliebig viele verwaltete Knoten hinzufügen, wenn Sie Ihr eigenes Lab einrichten.

Projekt-Repository klonen

Ich habe alle erforderlichen Dateien zum Einrichten von Ansible Lab in meinem GitHub-Repository gehostet. Führen Sie den folgenden Befehl aus, um das Repository lokal zu klonen.

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

Lassen Sie uns im Projektverzeichnis navigieren, um zu sehen, welche Dateien vorhanden sind.

Lassen Sie mich Ihnen eine kurze Einführung in jede Datei geben.

1. Vagrantfile

Alle Konfigurationen, die sich auf die VM beziehen, werden in dieser Datei gespeichert. Hier ist der Inhalt dieser Datei.

# -*- 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

Dies ist ein Shell-Skript, das für das Einrichten von Ansible im Controller-Knoten, das Installieren von Paketen und das Ändern von Systemkonfigurationen verantwortlich ist.

Der Inhalt dieser Datei ist unten angegeben:

#!/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

Dieses Skript sollte manuell ausgelöst werden, sobald alle drei VM-Builds abgeschlossen sind. Dieses Skript kümmert sich um die Generierung eines SSH-Schlüsselpaars und verteilt es auf alle drei Knoten. Es wird auch einen ansiblen Ad-hoc-Beispielbefehl zur Validierung ausführen.

Der Inhalt dieser Datei ist unten angegeben:

#!/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

Alle diese drei Dateien werden in meinem GitHub-Repository gehostet. Fühlen Sie sich frei, dazu beizutragen und es zu verbessern.

Vagrantfile-Konfiguration verstehen

Bevor Sie das Ansible-Lab erstellen, müssen Sie die Konfigurationen in den Vagrantfile- und Shell-Skripten verstehen.

1. Speicher- und Vcore-Zuweisung

Für alle drei Vagrant-Boxen müssen wir den Speicher- und CPU-Wert einrichten. Hier ist der Speicher auf 2GB eingestellt und die CPU ist auf 2 eingestellt . Wenn Sie das Limit erhöhen oder verringern möchten, passen Sie einfach die hervorgehobenen Parameter in der Vagrant-Datei an.

2. OS-Geschmack

Alle drei Knoten (Controller und Managed) verwenden das Ubuntu 20.04 LTS-Image. Wenn Sie also die Datei „vagrant up " Der Befehl vagrant wird nach dem folgenden Parameter Ausschau halten und versuchen, das Image abzurufen, wenn es lokal nicht verfügbar ist.

3. Netzwerkeinstellungen

Standardmäßig verwendet Vagrant NAT an der ersten Schnittstelle (Adapter1). Vagrant verwendet die Portweiterleitung über NAT, um eine Verbindung zur virtuellen Maschine herzustellen. Hier legen wir den Hostnamen und die statischen IP-Adressen für alle drei VMs über das private Netzwerk fest.

Eine separate Schnittstelle (Adapter2) wird erstellt und ihr wird die statische IP-Adresse zugewiesen. VMs, die Teil des privaten Netzwerks sind, können miteinander kommunizieren.

In der Multi-VM-Umgebung behebt der Vagrant automatisch die Portkollision.

==> 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. Benutzername und SSH-Kommunikation

Es gibt einen Standardbenutzer namens „vagrant“ mit dem Passwort „vagrant“. Der Vagrant-Benutzer hat standardmäßig die passwortlose Sudo-Berechtigung in der VM konfiguriert.

Standardmäßig ist die kennwortbasierte Authentifizierung für die VM deaktiviert. Vagrant erstellt ein SSH-Schlüsselpaar und verwendet den privaten Schlüssel, um sich mit der VM zu verbinden, wenn Sie „vagrant ssh“ ausführen " Befehl.

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

Die passwortbasierte Authentifizierung wird über bootstrap.sh aktiviert Datei, damit Sie sich mit der IP-Adresse und passwortbasierter Authentifizierung anstelle der schlüsselbasierten Authentifizierung mit dem Knoten verbinden können.

5. Bootstrap-Skript

Verantwortlich dafür ist das Skript bootstrap.sh

• Kennwortbasierte Authentifizierung aktivieren.
• Erstellen Sie eine .huhlogin Datei, um die Standard-Bannernachricht zu unterdrücken.
• Fügen Sie die Hosteinträge in /etc/hosts hinzu Datei für alle drei Knoten.
• Erforderliche Pakete installieren.
• Installieren von Ansible über den Python-Paketmanager (Pip) nur auf dem Controller-Knoten.

Ich verwende Shell Provisioner, wo bootstrap.sh in /tmp/ kopiert wird Speicherort in allen drei VMs und das Skript wird mit Root-Rechten ausgeführt.

Vorsicht: Wenn Sie ein RHEL-basiertes Lab erstellen, sollten Sie den Paketinstallationsbefehl aus bootstrap.sh bearbeiten Datei nach dnf oder rpm . Der Rest wird über alle Distributionen hinweg ähnlich sein.

6. Schlüsselpaar generieren

Ansible verwendet ein SSH-Schlüsselpaar, um mit den verwalteten Knoten zu kommunizieren und die Aufgabe auszuführen. Neue Schlüssel sollten vom Controller-Knoten generiert und mit allen verwalteten Knoten geteilt werden, damit ansible mit verwalteten Knoten kommunizieren kann, ohne jedes Mal nach Passwörtern zu fragen.

Das Skript key_gen.sh kümmert sich um die Erstellung von SSH-Schlüsseln und die Verteilung der Schlüssel an alle Knoten. Das Skript erstellt auch ein Projektverzeichnis mit ansible.cfg Datei und Inventardatei. Der Adhoc Der Befehl wird als Teil des Skripts ausgelöst, um die Konnektivität zu validieren.

Vorsicht: Dieses Skript muss manuell vom Controller-Knoten ausgelöst werden, sobald alle drei VMs bereitgestellt sind.

Ansible Lab-Setup erstellen

Gehen Sie in das Projektverzeichnis und führen Sie den Befehl "vagrant up" aus, und der Rest wird von vagrant und dem Bootstrap-Skript erledigt.

$ cd Ansible_lab_vagrant_virtualbox

$ vagrant up

Beispielausgabe:

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

Post-Install-Skript

Sobald alle drei VMs bereitgestellt sind, melden Sie sich beim Controller-Knoten an, um /home/vagrant/key_gen.sh auszuführen um SSH-Schlüsselpaare zu erstellen und durch Ausführen eines ansiblen Ad-hoc-Befehls zu validieren.

$ vagrant ssh controller
$ cd /home/vagrant/
$ bash key_gen.sh

Vagrant-Befehle zum Verwalten von VMs

Die folgenden Befehle helfen Ihnen dabei, den Lebenszyklus der vagabundierenden Maschinen aufrechtzuerhalten.

Um mit dem Erstellen der virtuellen Maschinen zu beginnen, führen Sie den folgenden Befehl aus dem Verzeichnis aus, in dem sich die Vagrant-Datei befindet.

$ vagrant up

Wenn Sie nur einen Knoten nach oben bringen möchten, können Sie den Hostnamen zum "vagrant up hinzufügen " Befehl.

$ vagrant up controller

Führen Sie den folgenden Befehl aus, um den Maschinenstatus zu überprüfen.

$ vagrant status
Current machine states:

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

Sie können auch den folgenden Befehl verwenden, der weitere Informationen über die VM liefert.

$ 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 

Um sich mit der virtuellen Maschine zu verbinden, können Sie "vagrant ssh" ausführen " Befehl. Sie müssen den VM-Namen übergeben, sonst wird der folgende Fehler ausgegeben.

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

Um per SSH in die m1-VM zu gelangen, lautet der Befehl:

$ vagrant ssh m1

Oder,

$ vagrant ssh cf2e302

Sie können sich auch mit Benutzername und Passwort verbinden, wenn die passwortbasierte Authentifizierung aktiviert ist.

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

Um eine bestimmte virtuelle Maschine zu stoppen, führen Sie den Befehl halt mit vm name.

aus

$ vagrant halt controller

Um alle virtuellen Maschinen zu stoppen, führen Sie den folgenden Befehl aus.

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

Führen Sie den folgenden Befehl aus, um alle VMs einschließlich ihrer Festplatte zu zerstören.

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

Schlussfolgerung

In diesem Artikel habe ich den automatisierten Weg zum Einrichten von Ansible Lab mit Vagrant und VirtualBox gezeigt. Das Lab wurde mit einem Ubuntu 20.04 LTS-Stack erstellt.

Wenn Sie vorhaben, eine Ansible-Zertifizierung zu absolvieren, und ein Labor zum Üben wünschen, schlage ich vor, dass Sie die Vagrant-Datei bearbeiten, die den Boxnamen auf RHEL-Flavor verweist, und den apt ersetzen Befehl zum entsprechenden dnf /yum Befehl in bootstrap.sh Datei.

Weiterlesen:

• Ansible-Inventar- und Konfigurationsdateien