Recherche de site Web

Mettre en place un laboratoire Ansible en 20 minutes

Créez un environnement pour soutenir l’apprentissage et l’expérimentation de nouveaux logiciels.

Être capable de créer et de démolir un environnement de cloud public est très utile, mais la plupart d’entre nous n’ont pas facilement accès à un cloud public. La meilleure solution serait d'avoir un laboratoire sur votre machine locale, mais même l'exécution sur une machine locale apporte des performances, de la flexibilité et d'autres défis. La plupart du temps, les charges de travail supplémentaires sur nos machines locales interfèrent avec notre travail quotidien et empêchent certainement de disposer d'un environnement facilement disponible pour jouer et expérimenter de nouveaux logiciels.

Mon équipe et moi avons rencontré ce défi il y a quelques années lorsque nous commencions à apprendre Ansible. Nous ne parvenions pas à trouver un environnement que nous pourrions utiliser individuellement, et notre frustration face à la situation a poussé certains d’entre nous à arrêter d’expérimenter. Nous savions que nous devions trouver une solution.

Nous avons passé beaucoup de temps à rechercher les options et avons mis au point un ensemble d'outils qui permettent à notre curiosité d'apprendre dans un environnement que nous contrôlons entièrement. Nous pouvons démarrer et détruire l'environnement de laboratoire sur nos machines locales sans avoir besoin d'accéder aux laboratoires sur site ou aux cloud publics.

Cet article explique comment déployer votre propre environnement de laboratoire sur votre ordinateur local en seulement 20 minutes de manière entièrement automatisée.

Vous pouvez retrouver tout le code de cet exercice dans mon dépôt GitHub.

Outils et logiciels

Cette solution utilise les outils et logiciels suivants :

  • Ansible est notre outil d'automatisation de choix car il est facile à utiliser et suffisamment flexible pour répondre aux exigences du laboratoire.
  • Vagrant est facile à utiliser pour créer et maintenir des machines virtuelles.
  • VirtualBox est un hyperviseur hébergé qui fonctionne dans les environnements Windows et Linux.
  • Fedora v30+ est le système d'exploitation sur ma machine locale.

Vous devez disposer de la configuration suivante pour créer l'environnement :

  • Une connexion internet
  • Prise en charge de la technologie de virtualisation activée dans votre BIOS (voici la procédure pour mon ordinateur portable Lenovo)
  • Vagabond v2.2.9
  • La dernière version d'Ansible
  • La dernière version de VirtualBox
  • Système d'exploitation hôte Fedora v30+

Qu’y a-t-il dans l’environnement du laboratoire ?

Ce projet vise à déployer un hôte Ansible avec un moteur Ansible et plusieurs nœuds Linux ainsi que des applications préchargées et préconfigurées (httpd et MySQL). Il active également Cockpit afin que vous puissiez surveiller l'état des machines virtuelles (VM) pendant les tests. La raison d’utiliser une application pré-déployée est l’efficacité (vous n’avez donc pas à passer du temps à installer ces composants). Cela vous permet de vous concentrer sur la création de rôles et de playbooks et sur les tests par rapport aux environnements déployés par les outils répertoriés ci-dessus.

Nous avons déterminé que le meilleur scénario pour notre cas d'utilisation était un environnement Vagrant multi-machines. Le Vagrantfile crée trois machines virtuelles CentOS pour simuler deux hôtes cibles et une machine de contrôle Ansible :

  • Hôte 1 : pas d'interface utilisateur graphique (GUI), avec httpd et MySQL installés
  • Host2 : pas d'interface graphique, avec httpd et MySQL installés
  • Ansible-host : pas d'interface graphique, avec le moteur Ansible installé

Activer plusieurs hyperviseurs

Certains hyperviseurs peuvent ne pas vous permettre d'afficher des machines virtuelles si plusieurs hyperviseurs sont utilisés. Pour résoudre ce problème, suivez ces étapes (basées sur les instructions d'installation de Vagrant).

Tout d’abord, recherchez le nom de l’hyperviseur :

$ lsmod | grep kvm
kvm_intel             204800  6
kvm                   593920  1 kvm_intel
irqbypass              16384  1 kvm

Celui qui m'intéresse est kvm_intel, mais vous en voudrez peut-être un autre (comme kvm_amd).

Exécutez ce qui suit en tant qu'utilisateur root pour mettre l'hyperviseur sur liste noire :

$ echo 'blacklist kvm-intel' >> /etc/modprobe.d/blacklist.conf

Redémarrez votre ordinateur et essayez à nouveau d'exécuter Vagrant.

Le dossier Vagabond

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

Vagrant.configure("2") do |config|
# Define VMs with static private IP addresses, vcpu, memory and vagrant-box.
  boxes = [
    {
      :name => "web1.demo.com", ⇒ Host1 this is one of the target nodes
      :box => "centos/8",	      ⇒ OS version 
      :ram => 1024,		      ⇒ Allocated memory
      :vcpu => 1,               ⇒  Allocated CPU
      :ip => "192.168.29.2"     ⇒ Allocated IP address of the node
    },
    {
      :name => "web2.demo.com", ⇒ Host2 this is one of the target nodes
      :box => "centos/8",
      :ram => 1024,
      :vcpu => 1,
      :ip => "192.168.29.3"
    },
    {
      :name => "ansible-host", ⇒ Ansible Host with Ansible Engine
      :box => "centos/8",
      :ram => 8048,
      :vcpu => 1,
      :ip => "192.168.29.4"
    }
  ]

  # Provision each of the VMs.
  boxes.each do |opts|
    config.vm.define opts[:name] do |config|
#   Only Enable this if you are connecting to Proxy server
#      config.proxy.http    = "http://usernam:password@x.y:80"⇒ Needed if you have a proxy
#      config.proxy.https   = "http://usernam:password@x.y:80"
#      config.proxy.no_proxy = "localhost,127.0.0.1"
      config.vm.synced_folder ".", "/vagrant", id: "vagrant-root", disabled: true
      config.ssh.insert_key = false
      config.vm.box = opts[:box]
      config.vm.hostname = opts[:name]
      config.vm.provider :virtualbox do |v| ⇒  Defines the vagrant provider
        v.memory = opts[:ram]
        v.cpus = opts[:vcpu]
      end
      config.vm.network :private_network, ip: opts[:ip]
      config.vm.provision :file do |file|
         file.source     = './keys/vagrant' ⇒ vagrant keys to allow access to the nodes
         file.destination    = '/tmp/vagrant' ⇒ the location to copy the vagrant key
      end
      config.vm.provision :shell, path: "bootstrap-node.sh" ⇒ script that copy hosts entry
      config.vm.provision :ansible do |ansible| ⇒ declaration to run ansible playbook
        ansible.verbose = "v"
        ansible.playbook = "playbook.yml" ⇒ the playbook used to configure the hosts
      end
        end
  end
end

Voici les fichiers importants auxquels vous devez prêter attention :

  • inventory-test.yaml : Le fichier d'inventaire pour se connecter aux nœuds
  • playbook.yaml : le fichier playbook que le provisionneur Vagrant appelle pour configurer les nœuds
  • Vagrantfile : le fichier que Vagrant utilise pour déployer l'environnement
  • clés vagrant : les clés Vagrant pour se connecter aux nœuds de votre environnement de laboratoire

Vous pouvez ajuster ces fichiers en fonction de vos besoins. La flexibilité d'Ansible vous donne le pouvoir de modifier de manière déclarative votre environnement selon vos besoins.

Déployez votre environnement de laboratoire

Tout d'abord, clonez le code du dépôt GitHub :

$ git clone https://github.com/mikecali/ansible-labs-101.git
Cloning into 'ansible-labs-101'...
remote: Enumerating objects: 15, done.
remote: Counting objects: 100% (15/15), done.
remote: Compressing objects: 100% (13/13), done.
remote: Total 15 (delta 2), reused 10 (delta 0), pack-reused 0
Unpacking objects: 100% (15/15), 6.82 KiB | 634.00 KiB/s, done.

Ensuite, changez votre répertoire en vagrant-session-2 et affichez son contenu :

$ ls
Bootstrap-node.sh   inventory   keys   playbook.yml   README.md Vagrantfile

Vous disposez désormais de tous les artefacts et fichiers de configuration dont vous avez besoin pour votre environnement de laboratoire. Pour déployer votre environnement, exécutez :

$ vagrant up

Avec une connexion Internet décente, il ne faut que 20 minutes environ pour obtenir un environnement opérationnel :

$ vagrant up
Bringing machine 'web1.demo.com' up with 'virtualbox' provider...
Bringing machine 'web2.demo.com' up with 'virtualbox' provider...
Bringing machine 'ansible-host' up with 'virtualbox' provider...
==> web1.demo.com: Importing base box 'centos/8'...
==> web1.demo.com: Matching MAC address for NAT networking...
==> web1.demo.com: Checking if box 'centos/8' version '1905.1' is up to date...
==> web1.demo.com: Setting the name of the VM: ansible-labs_web1democom_1606434176593_70913
==> web1.demo.com: Clearing any previously set network interfaces...
==> web1.demo.com: Preparing network interfaces based on configuration...
    web1.demo.com: Adapter 1: nat
    web1.demo.com: Adapter 2: hostonly
==> web1.demo.com: Forwarding ports...
    web1.demo.com: 22 (guest) => 2222 (host) (adapter 1)
==> web1.demo.com: Running 'pre-boot' VM customizations...
==> web1.demo.com: Booting VM...
==> web1.demo.com: Waiting for machine to boot. This may take a few minutes...
    web1.demo.com: SSH address: 127.0.0.1:2222
    web1.demo.com: SSH username: vagrant
    web1.demo.com: SSH auth method: private key
[...]

Une fois l’exécution du playbook terminée, vous verrez un résultat comme celui-ci :

PLAY RECAP *********************************
Ansible-host     : ok=20 changed=11 unreachable=0 failed=0 skipped=0 rescued=0 ignored=3

Real 18m14.288s
User 2m26.978s
Sys 0m26.849s

Vérifiez que toutes les VM sont en cours d'exécution :

$ vagrant status
Current machine states:

Web1.demo.com    running (virtualbox)
Web2.demo.com    running (virtualbox)
ansible-host     running (virtualbox)
[...]

Vous pouvez approfondir vos recherches en vous connectant à l’une des machines virtuelles. Accédez à l'hôte ansible :

> vagrant ssh ansible-host
Activate the web console with: systemctl enable --now cockpit.socket

Last login: Thu Nov 26 12:21:23 2020 from 10.0.2.2
[vagrant@ansible-host ~] uptime
16:46:42 up 1:24, 1 user, load average: 0.00, 0.01, 0.04

Enfin, vous pouvez utiliser le module Ansible pour pinger les autres nœuds que vous avez créés :

[vagrant@ansible-host]$ ansible -i inventory-test.yaml \
webservers -m ping -u vagrant
192.168.29.2 | SUCCESS => {
  "Ansible-facts": {
      "Discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "Changed": false;
    "Ping": "pong"
}
[...]

Nettoyer

Nettoyez votre environnement en exécutant :

$ vagrant destroy [vagrant machine name]

Votre sortie ressemblera à ceci :

(Michael Calizo, CC BY-SA 4.0)

Soyez créatif pour apprendre

Apprendre des logiciels comme Ansible pendant votre temps libre dans votre propre laboratoire est une bonne habitude, mais cela peut être difficile en raison de contraintes qui échappent à votre contrôle.

Parfois, il faut faire preuve de créativité et trouver une autre solution. Il existe de nombreuses options parmi lesquelles choisir dans la communauté open source ; L’une des principales raisons pour lesquelles nous avons choisi ces outils est qu’ils sont couramment utilisés et familiers à de nombreuses personnes.

Veuillez également noter que ces playbooks ne sont pas aussi optimisés que je le souhaiterais. N'hésitez pas à les améliorer et à partager votre travail dans les commentaires.

Articles connexes: