Vagrant in OpenSUSE

Qui vediamo cosa sia questo Vagrant e quanto vi è costato non conoscerlo!

Uso come base questo bellissimo articolo:

https://www.html.it/articoli/vagrant-virtualizzazione-e-provisioning-senza-sforzo/

Logicamente non è che una introduzione che spiega i concetti base, per poi espanderli leggendovi la guida di Vagrand.

Quando ci troviamo ad amministrare una sistema cloud ovvero con molte macchine, il rischio di dover aggiungere una macchina in più e doverla poi configurare in poco tempo per il deploy e la messa in produzione insieme a tutte le altre è la consuetudine.

In più, se siamo all’interno di un’architettura che deve scalare rapidamente per rispondere in modo agile alle esigenze degli utenti e azienda, dover attendere l’installazione del sistema operativo e poi del software è una rogna e tempo perso, per noi e per il nostro capo che aspetta di mandare dire “tutto risolto”. Se poi abbiamo del Cloud…

Per tutte queste esigenze, Vagrant è la mano santa.

In effetti Vagrant è un gestore di macchine virtuali che può usare parecchi hypervisor (sistemi di virtualizzazione) tra cui ​​ VirtualBox (di base), VMWare, KVM, ecc. Infatti non è un motore ma un “gestore” di macchine virtuali.

Grazie a Vagrant infatti è possibile costruire delle macchine virtuali che utilizzano le stesse configurazioni e possono essere create, modificate e cancellate con facilità.

Storia

Vagrant nasce nel 2010 come progetto personale del giovane Mitchell Hashimoto che ​​ nell’ottobre del 2010 la società Engine Hard Ha, famosa nello sviluppo di applicazioni Ruby, decide di sponsorizzare il creatore. Esattamente 2 anni dopo esce la prima versione stabile di Vagrant, la versione 1.0, ottenendo molto successo. Inizialmente Vagrant era utilizzabile solamente attraverso Virtual Box, ma grazie alla creazione della società HashiCorp, fondata dallo stesso Hashimoto per lo sviluppo unico del suo progetto, adesso può essere utilizzato anche con altri software di virtualizzazione, quali VMware e KVM e altri. Vagrant dato che è open-source (licenza MIT), la HashiCorp propone corsi di formazione e interventi di manutenzione per aziende private e pubbliche.

Vagrant nella versione 1.6 si lega ai container di Docker e permette di essere eseguito a sua volta in un ambiente completamente virtualizzato.

Nel 2013 viene pubblicato dal creatore Mitchell un libro sul funzionamento di Vagrant, dal titolo: Vagrant: Up and Running: Create and Manage Virtualized Development Environments pubblicato da O’Reilly Media.

Installare da

https://software.opensuse.org/package/vagrant

Consiglio la versione di home:ojkastl_buildservice:Branch_Virtu… (Comunità)

Vagrant è fatto in Ruby, quindi aspettatevi che vi scarica un sacco di pacchetti Ruby, in OpenSUSE si parte in vantaggio in questo caso.

Per base usa il motore di VirtualBox e quindi installatelo.

-BOX

Cosa sono i BOX di Vagrant?

Una Box è una vera e propria scatola degli attrezzi che contiene il sistema operativo, e tutto quello di cui abbiamo bisogno come i software di base ed ogni loro configurazione di base.

Per base abbiamo già delle BOX ma possiamo definirle delle nostre, alcune sono qui:

http://www.vagrantbox.es/

Come installarle? La sintassi è questa:

$ vagrant box add name url

Quindi partiamo con un esempio:

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

Ecco ora abbiamo una Box di Ubuntu 12.04 a 32 bit.

-Vagrantfile

Il file Vagrantfile definisce come e cosa vogliamo fare del nostro Box ed usa sintassi Ruby, anche se non elevata, quindi non vi necessita conoscere Ruby ma almeno un pochino di programmazione.

In esso sono contenute tutte le configurazioni del box stesso, inclusa l’immagine da utilizzare, le specifiche hardware, file e cartelle condivise e indirizzi d’uscita e d’entrata.

Ogni volta che eseguiamo un comando Vagrant, il Vagrantfile viene cercato in tutte le directory di livello superiore nell’albero:

/home/blaster/projects/foo/Vagrantfile

/home/blaster/projects/Vagrantfile

/home/blaster/Vagrantfile

/home/Vagrantfile

/Vagrantfile

Vediamo un esempio di questo Vagrantfile:

# 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

​​ 

Mamma mia non si può fare più facile? Però un programmatore, specie Ruby, già capisce le potenzialità del caso.

Partiamo da una base:

# Una singola Box.

#

Vagrant.configure(“2”) do |config|

 ​​ ​​ ​​​​ config.vm.box = “precise32”

end

Qui semplicemente gli diciamo solo di usare “precise32” che è la BOX che abbiamo scaricato nell’esempio precedente.

Per renderlo effettivo lo dobbiamo “archiviare” e per questo abbiamo come archivio il GIT che permette di gestire pure le versioni e rami di versione. Ma per adesso archiviamolo e basta:

$ vagrant up

Adesso che abbiamo il nostro progetto archiviato, per il via, basterà dare

$ vagrant ssh

–Provisioning

Vagrant non è solo un sistema per avviare velocemente delle macchine virtuali, infatti ci permette anche di controllarle anche le impostazioni nel tempo, insieme al software installato.

Per questo 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.

Un esempio di script di configurazione in Vagrantfile 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

Vagrant permette di usare plugin che estendono le potenzialità, in tantissime occasioni, ad esempio siamo partiti usando VirtualBox ma grazie ad altri plugin possiamo usare altri motori di virtualizzazione fin sistemi complessi di virtualizzazione.

Esempio, vogliamo VMware fusion? Ci basta fare:

$ vagrant plugin install vagrant-vmware-fusion

o con Workstation?

$ vagrant plugin install vagrant-vmware-workstation

Attenzione: Specificate che volete usare il plugin nel ​​ Vagrantfile, esempio:

# Da http://puppetlabs.com/blog/new-vmware-provider-gives-vagrant-a-boost

config.vm.provider :vmware_workstation do |v|

 ​​ ​​ ​​​​ v.vmx[“memsize”] = “2048”

end

Adesso vediamo alcuni comandi base di Vagrant per gestire la macchina virtuale.

  • vagrant status vi da informazioni sulla macchina virtuale attuale (nella cartella in cui vi trovate).

     ​​​​ $ vagrant status

     ​​​​ Current machine states:

     ​​ ​​ ​​ ​​ ​​ ​​ ​​​​ 

     ​​​​ default  ​​ ​​ ​​ ​​ ​​ ​​ ​​ ​​ ​​ ​​ ​​ ​​ ​​ ​​ ​​ ​​ ​​​​ running (virtualbox)

     ​​ ​​ ​​ ​​ ​​ ​​ ​​​​ 

     ​​​​ The VM is running. To stop this VM, you can run `vagrant halt` to

     ​​​​ shut it down forcefully, or you can run `vagrant suspend` to simply

     ​​​​ suspend the virtual machine. In either case, to restart it again,

     ​​​​ simply run `vagrant up`.

  • vagrant global-status è molto utile se avete più di una macchiana virtuale Vagrant da gestire, in quanto vi da informazioni su tutte le macchine installate sul vostro computer

     ​​​​ $ vagrant global-status

     ​​​​ id  ​​ ​​ ​​ ​​ ​​​​ name  ​​ ​​​​ provider  ​​​​ state  ​​ ​​​​ directory

     ​​​​ —————————————————————–

     ​​​​ f8b13dd ​​ default virtualbox saved  ​​ ​​​​ /Users/ludus/code/projects/dotbot/vagrant

     ​​​​ 96c2ff0 ​​ default virtualbox aborted ​​ /Users/ludus/code/dotbot_ws/emulations/dotbot_emu1

     ​​​​ 9b1f914 ​​ default virtualbox poweroff /Users/ludus/code/virtualmachines/ubuntu_ros

     ​​​​ 85e93d5 ​​ default virtualbox poweroff /Users/ludus/code/virtualmachines/cloud_platform

     ​​​​ 6ff7199 ​​ default virtualbox running ​​ /Users/ludus/develop/vagrant_machines/ubuntu-xenial64

     ​​ ​​ ​​ ​​ ​​ ​​ ​​​​ 

     ​​​​ The above shows information about all known Vagrant environments

     ​​​​ on this machine. This data is cached and may not be completely

     ​​​​ up-to-date. To interact with any of the machines, you can go to

     ​​​​ that directory and run Vagrant, or you can use the ID directly

     ​​​​ with Vagrant commands from any directory. For example:

     ​​​​ “vagrant destroy 1a2b3c4d”  ​​ ​​​​ 

  • vagrant suspend e vagrant halt servono rispettivamente per sospendere e spegnere la nostra macchina virtuale.

  • vagrant reload riavvia la macchiana virtuale.

  • vagrant destroy serve per cancellare definitivamente la macchina (non eseguite questo comando a meno che non siate certi di quello che fate!!!).

Logicamente non è che una introduzione che spiega i concetti base, per poi espanderli leggendovi la guida di Vagrand che trovate qui:

https://www.vagrantup.com/docs/index.html

Il sito:

https://www.vagrantup.com/

Libri:

https://www.amazon.com/gp/product/1449335837/ref=as_li_qf_sp_asin_il_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1449335837&linkCode=as2&tag=vagrant-20

Adesso potete capire che il compito dell’amministratore di sistemi e quello del programmatore stanno convergendo insieme, al programmatore si richiede sempre più di essere amministratore e al amministratore di essere un vero programmatore e non solo di Bash o Powershell, ma fin Perl, Java e ora Vagrant.

Fonte: Source

Potrebbero interessarti anche...

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

Questo sito usa Akismet per ridurre lo spam. Scopri come i tuoi dati vengono elaborati.