Ansible – automazione IT e Configuration Management (II parte)

Ansible + Vagrant Environment

Ansible + Vagrant Environment

 

 

 

 

 

 

Nel primo articolo “Ansible per l’automazione IT ed il Configuration Management” abbiamo descritto le caratteristiche principali di questo interessante prodotto per il Configuration Management. In questo secondo articolo descriveremo con degli esempi come utilizzare nel concreto Ansible.

Per preparare il nostro ambiente di lavoro sfrutteremo un’altro software, che rappresenta, anch’esso una delle grandi novita’ del Web degli ultimi mesi come Vagrant, di cui abbiamo parlato nell’articolo “Virtualizzazione e provisioning senza sforzo“.

configuriamoci l’ambiente Vagrant:

$ vagrant box add pre http://files.vagrantup.com/precise32.box
$ vagrant init precise32
$ vagrant up

a seguito dell’ultimo comando, vedremo dei messaggi come questi:

Bringing machine 'default' up with 'virtualbox' provider...
[default] Importing base box 'precise32'...
[default] Matching MAC address for NAT networking...
[default] Setting the name of the VM...
[default] Clearing any previously set forwarded ports...
[default] Clearing any previously set network interfaces...
[default] Preparing network interfaces based on configuration...
[default] Forwarding ports...
[default] -- 22 => 2222 (adapter 1)
[default] Booting VM...
[default] Waiting for machine to boot. This may take a few minutes...
[default] Machine booted and ready!
Guest Additions Version: 4.2.0
VirtualBox Version: 4.3
[default] Mounting shared folders...
[default] -- /vagrant

Vagrant ha quindi scaricato e creato per noi una macchina virtuale Ubuntu Precise (32bit). Scorrendo i messaggi ci sono due cose importanti da notare: la prima è che il traffico sulla porta 2222 del nostro pc locale sarà inoltrato alla porta 22 della macchina virtuale; la seconda è che l’utente “vagrant” sulla macchina remota può connettersi con la password “vagrant” ed ha già i privilegi per diventare root con sudo. Aggiorniamo quindi l’inventario delle macchine che decidete di coinvolgere modificando il file /etc/ansible/hosts

Dopo aver preso confidenza con Vagrant iniziamo la configurazione dell’ambiente per Ansible, iniziando ad usarlo per automatizzare i compiti di ogni giorno.

Configuriamo il file /etc/ansible/hosts tramite comando:

# sudo bash -c 'echo [web] >> /etc/ansible/hosts'
# sudo bash -c 'echo 127.0.0.1:2222 ansible_ssh_user=vagrant ansible_ssh_pass=vagrant >> /etc/ansible/hosts'

Verifichiamo che ansible sia in grado di leggere correttamente i parametri inseriti nel file hosts usando il seguente comando:

# ansible -m ping all
127.0.0.1 | success >> {
"changed": false,
"ping": "pong"
}

Ansible facts
come possiamo essere sicuri che la macchina a cui ci stiamo connettendo sia quella giusta ? Diamo un’occhiata ai “facts”, ovvero a tutte le informazioni che Ansible raccoglie…

# ansible web -m setup | less

otteniamo cosi’ una serie di dati in formato JSON tra cui notiamo che il nostro nuovo server ha come hostname ‘localhost’.
A titolo didattico scriveremo un playbook per installare un webserver nginx sul nuovo server.

Ora apriamo un editor per iniziare a scrivere il nostro playbook che si chiamera’ nginx.yml :

--- PLAYBOOK ottimizzato su Centos Linux
- name: installa NGINX e avvia il servizio
   remote_user: root
   sudo: yes
   hosts: web
   tasks:
   - name: installazione Nginx
     apt: pkg=nginx state=installed update_cache=true
     notify:
     - start nginx
   handlers:
     - name: start nginx
     service: name=nginx state=started

Come possiamo notare nel playbook abbiamo editato una lista di task, uno per ogni “step” del nostro compito.
Se stiamo usando virtualbox come hypervisor, dobbiamo aggiungere una riga al file (bastera’ solo decommentarla) di configurazione di vagrant perché attivi il forwarding della porta 80 della guest sulla porta 8080 del nostro pc.

(vedi https://docs.vagrantup.com/v2/networking/forwarded_ports.html)

config.vm.network "forwarded_port", guest: 80, host: 8080

e dare il comando per ricaricare la virtual machine con la nuova configurazione:

vagrant reload
[default] Attempting graceful shutdown of VM...
[default] Clearing any previously set forwarded ports...
[default] Clearing any previously set network interfaces...
[default] Preparing network interfaces based on configuration...
[default] Forwarding ports...
[default] -- 22 => 2222 (adapter 1)
[default] -- 80 => 8080 (adapter 1)
[default] Booting VM...
[default] Machine booted and ready!

Ora possiamo lanciare il playbook

# ansible-playbook nginx.yml

PLAY [installa NGINX e avvia il servizio] *****************************

GATHERING FACTS ***************************************************************
ok: [127.0.0.1]

TASK: [installazione Nginx] ***************************************************
changed: [127.0.0.1]

NOTIFIED: [start nginx] *******************************************************
changed: [127.0.0.1]

PLAY RECAP ********************************************************************
127.0.0.1 : ok=3 changed=2 unreachable=0 failed=0

sulla macchina virtuale potrete visualizzare, dal syslog, quello che sta accadendo:

ansible-apt: Invoked with dpkg_options=force-confdef,force-confold upgrade=None force=False package=[‘nginx’] purge=False state=installed update_cache=True pkg=nginx default_release=None install_recommends=True deb=None cache_valid_time=None
Mar 19 15:59:33 precise32 ansible-service: Invoked with name=nginx pattern=None enabled=None state=started sleep=None arguments= runlevel=default

ora sulla macchina virtuale mi ritrovo con l’nginx attivo e rispondente all’indirizzo 127.0.0.1:8080

Welcome to nginx!

Come gia accennato nel primo articolo la curva di apprendimento di questo ottimo strumento di Management dei server e’ davvero bassa e funzionale, ed in poco tempo si e’ in grado di gestire un ambiente ad alto volume di macchine.

Questa è solo una semplice introduzione al mondo di Ansible, e prima di concludere vi faccio inoltre presente che Ansible non è solo usufruibile da linea di comando ma presso il sito ufficiale è disponibile una web dashboard che permette di controllare i job, avere report, statistiche e così via.

Esiste anche Ansible Galaxy , che è invece un repository comunitario di “ricette”, playbooks, task moduli e tutto quello che si può immaginare … Quindi se doveste installare e configurare software come tomcat, oracle, mongodb, jenkins, drupal, rabbitmq e tanti altri, troverete già tutto pronto.
Di sicuro una base di partenza molto comoda per le vostre personalizzazioni!

Se tutto ciò non bastasse ancora, Ansible ha una API estremamente chiara e flessibile per scrivere moduli custom in Python o qualsiasi altro linguaggio, un esempio concreto

#AnsibleConfigurationManagement

Virtualizzazione e provisioning senza sforzo

Vagrant Virtualization Box

Vagrant Virtualization Box

La virtualizzazione ha sicuramente cambiato il modo di lavorare e di pensare alla gestione dei sistemi informatici aziendali o dei service provider, ed il cloud ha aggiunto un’ulteriore strato, sia di liberta’, ma anche di complicazione in piu’, nella gestione dei nuovi sistemi ad alta affidabilita’ che devono essere in grado di scalare nel minor tempo possibile ecc….

Queste esigenze hanno portato alla nascita di innumerevoli sistemi di virtualizzazione, tra i piu’ conosciuti sicuramente ci sono Xen, Vmware, Kvm, Virtuozzo, Virtualbox, Openvz …..! che per certi versi si trasformano in un incubo per gli amministratori di sistema, costretti ad avere diversi ambienti di gestione delle VM su diversi sistemi e con molteplici file di configurazione da settare.

Infatti quando ci troviamo ad amministrare un ambiente cloud con molte macchine, il rischio di dover aggiungere una macchina in più e doverla successivamente configurare in poco tempo per il deploy e la messa in produzione insieme a tutte le altre è molto alto. In più, se siamo all’interno di un’architettura che deve scalare rapidamente per rispondere in modo agile alle esigenze degli utenti (e chiaramente dell’azienda), dover attendere l’installazione del sistema operativo e poi del software non è certamente divertente. Per tutte queste esigenze, Vagrant potrebbe risultare la giusta soluzione che può semplificarci la vita, permettendoci di aggirare tutte queste “rogne”

Vagrant è un gestore di macchine virtuali che può usare parecchi hypervisor tra cui VirtualBox, il predefinito, ma anche VMWare, Xen e KVM. Attraverso questo software infatti potremo basarci su una struttura di base comune a tutte le macchine, che contiene il sistema operativo (anche se poi vedremo come personalizzare questa alberatura), e mantenere degli step comuni nella configurazione delle nostre istanze virtuali, per poi dedicarci solo alle rifiniture, risparmiando tantissimo tempo grazie alle capacità di elaborazione dei datacenter che abbiamo in-house o magari in cloud.

Per inizializzare il nostro primo progetto Vagrant, abbiamo solo bisogno di spostarci in una directory vuota e dare il comando (avendo già installato il software):

Installazione Vagrant

### Verificare di aver installati i seguenti pacchetti : rubygems ruby1.9.1-dev virtualbox-4.2 (o superiori)
# sudo apt-get install vagrant
# vagrant plugin install vagrant-vbguest

Le Box di Vagrant
Il primo concetto fondamentale da fare nostro, per quanto riguarda Vagrant, è quello del concetto di Box. Una Box per quanto riguarda questo ambiente di virtualizzazione infatti è una vera e propria scatola che contiene il sistema operativo, e tutto quello di cui abbiamo bisogno come i software di base ed ogni loro configurazione di base. Al punto di partenza abbiamo delle Box rese disponibili dai server di Vagrant, ma possiamo tranquillamente aggiungerne altre: tutto quello di cui abbiamo bisogno è un po’ di fantasia coi nomi, e di conoscere l’URL remoto tramite il quale scaricare la Box (ne trovate parecchie già fatte su Vagrantbox.es oppure su Hasicorp), con questa sintassi da riga di comando.

# vagrant init
# vagrant box add name url

che, traducendolo con un esempio reale:

# vagrant box add precise32 http://files.vagrantup.com/precise32.box

Che non farà altro che aggiungere al nostro progetto Vagrant una Box Ubuntu 12.04 a 32 bit.

Il Vagrantfile
Una volta scaricata la nostra Box di partenza, possiamo cominciare a configurare il nostro progetto Vagrant tramite il Vagrantfile che abbiamo a disposizione e che si presenta essenzialmente come un file Ruby con vari namespace, ma niente paura, non è necessario conoscere direttamente Ruby per la configurazione (anche se può aiutare), ed è possibile fare riferimento alla documentazione per conoscere i vari prefissi e le possibilità che abbiamo a disposizione. Ogni volta che eseguiamo un comando Vagrant, il Vagrantfile viene cercato in tutte le directory di livello superiore nell’albero.

Il file può avere grossomodo un aspetto del genere:

Esempio di un cluster di 7 Boxes. Preso da:
### https://github.com/patrickdlee/vagrant-examples

domain   = 'example.com'
 
nodes = [
  { :hostname => 'ex7proxy',   :ip => '192.168.0.42', :box => 'precise32' },
  { :hostname => 'ex7db',      :ip => '192.168.0.43', :box => 'precise32' },
  { :hostname => 'ex7web1',    :ip => '192.168.0.44', :box => 'precise32' },
  { :hostname => 'ex7web2',    :ip => '192.168.0.45', :box => 'precise32' },
  { :hostname => 'ex7static1', :ip => '192.168.0.46', :box => 'precise32' },
  { :hostname => 'ex7static2', :ip => '192.168.0.47', :box => 'precise32' },
  { :hostname => 'ex7cache',   :ip => '192.168.0.48', :box => 'precise32' },
]
 
Vagrant::Config.run do |config|
  nodes.each do |node|
    config.vm.define node[:hostname] do |node_config|
      node_config.vm.box = node[:box]
      node_config.vm.host_name = node[:hostname] + '.' + domain
      node_config.vm.network :hostonly, node[:ip]
 
      memory = node[:ram] ? node[:ram] : 256;
      node_config.vm.customize [
        'modifyvm', :id,
        '--name', node[:hostname],
        '--memory', memory.to_s
      ]
    end
  end
 
  config.vm.provision :puppet do |puppet|
    puppet.manifests_path = 'puppet/manifests'
    puppet.manifest_file = 'site.pp'
    puppet.module_path = 'puppet/modules'
  end
end

Prima di arrivare a questo livello tuttavia, è necessario cominciare dalle basi: il primo file di configurazione di Vagrant che andremo a scrivere conterrà ben poche specifiche, e si baserà esclusivamente sulla Box che abbiamo scelto per la nostra prima macchina virtuale.

# Una singola Box.
#
Vagrant.configure(“2”) do |config|
config.vm.box = “precise32”
end

Esempio per una singola Box.

Vagrant.configure("2") do |config|
config.vm.box = "precise32"
end

Inoltre il Vagrantfile deve essere soggetto a version control (tramite git ad esempio) per tenere traccia di ogni modifica e rendere il tutto facilmente riportabile in una nuova architettura

Avviamo la Box

# sudo vagrant up
Bringing machine 'default' up with 'virtualbox' provider...
[default] Importing base box 'precise32'...
[default] Matching MAC address for NAT networking...
[default] Setting the name of the VM...
[default] Clearing any previously set forwarded ports...
[default] Clearing any previously set network interfaces...
[default] Preparing network interfaces based on configuration...
[default] Forwarding ports...
[default] -- 22 => 2222 (adapter 1)
[default] Booting VM...
[default] Waiting for machine to boot. This may take a few minutes...
[default] Mounting shared folders...
[default] -- /vagrant

Adesso che abbiamo il nostro progetto funzionante, basterà dare

# vagrant ssh
Last login: Fri Apr 15 05:43:58 2011 from 10.0.2.2
[vagrant@localhost ~]$

per collegarci ed esserne subito operativi all’interno della nostra box.

Provisioning
Vagrant non è solo un sistema per avviare velocemente delle macchine virtuali, infatti ci permette anche di controllarle, e di controllarne le impostazioni nel tempo, insieme al software installato. Possiamo quindi gestire la configurazione automatica secondo le nostre esigenze delle varie Box che abbiamo, attraverso una struttura di provisioning abbastanza flessibile che supporta normali shell script (Bash), il buon vecchio Puppet, ma anche Chef e Ansible.

Tramite questa infrastruttura possiamo modificare il Vagrantfile per eseguire quindi qualsiasi istruzione, che sia configurata per script Puppet oppure attraverso Bash. Ad esempio, possiamo utilizzare la piccola struttura riportata di seguito, che proviene direttamente dalla documentazione di Vagrant e che mostra come sia facile scriversi uno script di configurazione da mandare poi in pasto alla propria Box.

$script = <<SCRIPT
echo I am provisioning...
date > /etc/vagrant_provisioned_at
SCRIPT
Vagrant.configure("2") do |config|
config.vm.provision "shell", inline: $script
end

Non solo VirtualBox

Una volta imparato a usare Vagrant, avremo comunque basato tutto il nostro lavoro su VirtualBox. Tuttavia, potremmo anche avere qualcosa in contrario sull’uso di VirtualBox, e voler usare altri provider che ci permettano un’amministrazione più efficace o semplicemente il riciclo di competenze che già abbiamo. Ad esempio, Vagrant supporta tramite plugin anche l’integrazione con VMWare o con Xen; questi plugin sono installabili attraverso il gestore integrato nel software, semplicemente tramite un singolo comando, esattamente come in un classico gestore di pacchetti:

# vagrant plugin install vagrant-vmware-fusion

Oppure se invece di VMWare Fusion usate la variante Workstation:

# vagrant plugin install vagrant-vmware-workstation

Una volta installato il plugin, ed ovviamente il software di providing delle macchine virtuali che vogliamo testare, ci bastera’ modificare il Vagrantfile, con istruzioni come queste nell’ esempio:

Esempio tratto da [ http://puppetlabs.com/blog/new-vmware-provider-gives-vagrant-a-boost ]

config.vm.provider :vmware_workstation do |v|
v.vmx["memsize"] = "2048"
end

Vagrant può ovviamente essere configurato per essere alla base di una complessa configurazione in ambiente cloud, o della propria infrastruttura più modesta.

Se questo primo articolo vi ha incuriositi, la documentazione ufficiale, passo passo, vi sta aspettando : VAGRANT DOC

Nel prossimo articolo vedremo come sfruttare le potenzialita’ di Vagrant + Docker.

#VagrantVirtualizzazioneeProvisioning