Creazione di un cluster CoreOS con Vagrant

Noi di MMUL siamo innamorati di CoreOS! Ne abbiamo già parlato (qui e qui) ed ora vogliamo tastare con mano le sue innovative funzionalità. Ci siamo documentati ed abbiamo scoperto che è possibile creare un nostro cluster, in maniera veramente semplice, sfruttando la virtualizzazione con Vagrant. Io ho scelto di usare Vagrant con VirtualBox ma nulla vieta di sfruttare la virtualizzazione con VMware.

Cos’è Vagrant ? Vagrant è qualcosa di magico: praticamente basandosi su tecnologie di virtualizzazione esistenti (Virtualbox, VMware o AWS) fornisce un ambiente, facile e altamente personalizzabile, per la creazione e gestione delle macchine virtuali. E’ possibile configurare, mediante un banale file di testo ruby-style, macchine virtuali e automaticamente gestirne l’installazione di tutto ciò che vogliamo. Ad esempio è possibile, con qualche riga di codice, creare e configurare una macchina virtuale Linux (ad esempio una Ubuntu) e automaticamente installarci Apache.

La prima cosa da fare è, ovviamente, installare Vagrant. La procedura è praticamente lineare e disponibile su quasi tutte le piattaforme, indi vi rimando al sito ufficiale per ulteriori approfondimenti e/o tutorial.

Cosa buona e giusta, ma non fondamentale, è quella di installare in locale, sul nostro sistema host, anche fleetctl perché in seguito ci tornerà comodo amministrare il cluster dalla nostra macchina, senza doverci collegare per forza ad un nodo.

Premesse

Fleet è il sistema di init distribuito del cluster. Lega insieme gli altri due mattoni fondamentali di un cluster basato su CoreOS : systemd e etcd. Pensate a fleet come ad un’estensione di systemd che opera a livello di cluster e non a livello di singola macchina. Fleetctl è l’utility a linea di comando che dialoga con fleet così come systemctl dialoga con systemd e etcdctl dialoga con etcd.

Spendiamo qualche parola, per chi ancora non lo conosce, su systemd: innovativo demone di sistema introdotto ormai in quasi tutte le nuove release delle maggiori distribuzioni e che tante discussioni ha suscitato e sta ancora suscitando. Ma, fondamentalismi a parte che, purtroppo, ancora oggi affliggono la comunità, bisogna essere aperti al cambiamento e alle novità, soprattutto quando queste portano dei benefici così evidenti.

Systemd rimpiazza il demone principale di ogni sistema Unix-like, quasi ovunque denominato init, il famoso demone con il PID pari a 1. Uno dei grossi difetti di questo demone, dovuto sicuramente alla sua anzianità, era la sua lentezza e tale difetto si evidenziava chiaramente in fase di boot. Systemd risolve questo grave difetto in maniera netta, cambiando approccio durante l’avvio dei demoni di sistema parallelizzandoli e posticipando le altre attività, come l’inizializzazione delle socket, a quando saranno realmente necessarie. Ovviamente questo è solo un rapidissimo flash di quello che è systemd, per ulteriori approfondimenti vi invito a consultare la relativa documentazione.

Etcd è un key-value store distribuito e affidabile per la gestione centralizzata delle configurazioni e il service discovery. Massivamente utilizzato in CoreOS, ha tanti vantaggi:

Semplice – le sue API possono essere utilizzate mediante curl.
Sicuro – può essere configurato per utilizzare certificati SSL per l’autenticazione dei client.
Veloce – raggiunge performance di circa 1000 scritture/sec per istanza.
Affidabile – utilizza l’algoritmo Raft per l’alta affidabilità.

Ovviamente per ulteriori approfondimenti vi rimando alla documentazione ufficiale su github.

Preparazione dell’ambiente

Abbiamo quindi installato in locale sia Vagrant che fleetctl:

Kartone@kAir:~/Vagrant$ vagrant --version
Vagrant 1.7.2
Kartone@kAir:~/Vagrant$ fleetctl --version
fleetctl version 0.9.1

CoreOS è disponibile interamente su Github ed i suoi creatori hanno messo a disposizione un repository specifico per il Vagrant. Il primo passo è clonarlo con git:

Kartone@kAir:~/Vagrant$ git clone https://github.com/coreos/coreos-vagrant.git
Cloning into 'coreos-vagrant'...
remote: Counting objects: 351, done.
remote: Total 351 (delta 0), reused 0 (delta 0), pack-reused 351
Receiving objects: 100% (351/351), 79.37 KiB | 0 bytes/s, done.
Resolving deltas: 100% (152/152), done.
Checking connectivity... done.

Una volta clonato il repository, entriamo nell’ambiente:

 
Kartone@kAir:~/Vagrant/coreos-vagrant$ ll
total 80
drwxr-xr-x  11 Kartone  staff   374B  9 Mar 16:54 .
drwxr-xr-x   3 Kartone  staff   102B  9 Mar 16:54 ..
drwxr-xr-x  13 Kartone  staff   442B  9 Mar 16:54 .git
-rw-r--r--   1 Kartone  staff   117B  9 Mar 16:54 .gitattributes
-rw-r--r--   1 Kartone  staff    35B  9 Mar 16:54 .gitignore
-rw-r--r--   1 Kartone  staff   2,4K  9 Mar 16:54 CONTRIBUTING.md
-rw-r--r--   1 Kartone  staff   104B  9 Mar 16:54 MAINTAINERS
-rw-r--r--   1 Kartone  staff   4,1K  9 Mar 16:54 README.md
-rw-r--r--   1 Kartone  staff   4,3K  9 Mar 16:54 Vagrantfile
-rw-r--r--   1 Kartone  staff   2,3K  9 Mar 16:54 config.rb.sample
-rw-r--r--   1 Kartone  staff   722B  9 Mar 16:54 user-data.sample

In questa cartella c’è tutto quello di cui abbiamo bisogno per la creazione del nostro cluster. Innanzitutto, visto che siamo prudenti, copiamo i due file .sample ed editiamoli singolarmente.

Configurazione del cluster

 vim user-data

In questo file bisogna sostituire la riga:

 #discovery: https://discovery.etcd.io/ <token>

con quella restituita da:

 
Kartone@kAir:~$ curl -w "\n" https://discovery.etcd.io/new
https://discovery.etcd.io/33558a4d0617de1a90ed897f7a94d4ab

Se conosciamo a priori la dimensione massima del nostro cluster potremo anche ottenere un token con questa url:

curl -w "\n" https://discovery.etcd.io/new?size=3

dove il parametro size passato nella url è il numero di nodi del cluster.

Ma cos’è questo token ? Praticamente CoreOS usa etcd per coordinare i vari nodi del cluster, quindi in un cluster CoreOS è necessario che le varie istanze di etcd, che girano sui vai nodi, siano connesse. In maniera semplicistica possiamo quindi pensare che un cluster sia formato da tutti i nodi che hanno lo stesso token. Per questo motivo è molto comodo che tutti nodi possano accedere ad internet. Ovviamente questa condizione non è strettamente necessaria e, nel caso specifico, sul sito di CoreOS, è possibile sapere come configurare un cluster i cui nodi non possono accedere ad internet.

Nel nostro caso specifico, vogliamo essere liberi di scalare il nostro cluster a quanti nodi vogliamo, la riga nel file user-data sarà quindi:

 discovery: https://discovery.etcd.io/33558a4d0617de1a90ed897f7a94d4ab

Il secondo file da editare è, come abbiamo detto, config.rb. Questo file indicherà a Vagrant quante macchine macchine virtuali dovrà creare e con quali versioni del sistema operativo. Vediamo come:

 vim config.rb

La sezione che ci interessa è questa:

#$num_instances=1

Vogliamo creare un cluster da 5 nodi, quindi la precedente riga diventa:

 $num_instances=5

A questo punto dobbiamo scegliere quale branch di CoreOS installare: stable, beta o alpha. Visto che siamo temerari e vogliamo avere la possibilità testare tutte le novità non appena vengono messe a disposizione, configuriamo il branch alpha. Quindi non dobbiamo far altro che decommentare la riga:

 #$update_channel='alpha'

siamo pronti per il fatidico comando ed avviare tutti nodi virtuali del cluster:

Kartone@kAir:~/Vagrant/coreos-vagrant$ vagrant up
Bringing machine 'core-01' up with 'virtualbox' provider...
Bringing machine 'core-02' up with 'virtualbox' provider...
Bringing machine 'core-03' up with 'virtualbox' provider...
Bringing machine 'core-04' up with 'virtualbox' provider...
Bringing machine 'core-05' up with 'virtualbox' provider...
==> core-01: Importing base box 'coreos-alpha'...
==> core-01: Matching MAC address for NAT networking...
==> core-01: Checking if box 'coreos-alpha' is up to date...
==> core-01: Setting the name of the VM: coreos-vagrant_core-01_1425918854628_18893
==> core-01: Clearing any previously set network interfaces...
==> core-01: Preparing network interfaces based on configuration...
    core-01: Adapter 1: nat
    core-01: Adapter 2: hostonly
==> core-01: Forwarding ports...
    core-01: 22 => 2222 (adapter 1)
==> core-01: Running 'pre-boot' VM customizations...
==> core-01: Booting VM...
==> core-01: Waiting for machine to boot. This may take a few minutes...
    core-01: SSH address: 127.0.0.1:2222
    core-01: SSH username: core
    core-01: SSH auth method: private key
    core-01: Warning: Connection timeout. Retrying...
==> core-01: Machine booted and ready!
==> core-01: Setting hostname...
==> core-01: Configuring and enabling network interfaces...
==> core-01: Running provisioner: file...
==> core-01: Running provisioner: shell...
    core-01: Running: inline script
[...]
==> core-05: Machine booted and ready!
==> core-05: Setting hostname...
==> core-05: Configuring and enabling network interfaces...
==> core-05: Running provisioner: file...
==> core-05: Running provisioner: shell...
    core-05: Running: inline script

Vagrant ha creato, automaticamente, cinque virtual machine installandoci il branch alpha di CoreOS e con le impostazioni di rete che abbiamo già configurate (io ho usato quelle di default) in Virtualbox. Per ulteriori personalizzazioni vi invito ad editare il file config.rb. Se tutto ha funzionato correttamente, dovreste avere un output del genere:

Kartone@kAir:~/Vagrant/coreos-vagrant$ vagrant status
Current machine states:

core-01                   running (virtualbox)
core-02                   running (virtualbox)
core-03                   running (virtualbox)
core-04                   running (virtualbox)
core-05                   running (virtualbox)

This environment represents multiple VMs. The VMs are all listed
above with their current state. For more information about a specific
VM, run `vagrant status NAME`.

Quello che vogliamo fare adesso è collegarci in ssh ad un nodo del cluster:

Kartone@kAir:~/Vagrant/coreos-vagrant$ vagrant ssh core-01 -- -A
CoreOS alpha (612.1.0)
core@core-01 ~ $ uname -a
Linux core-01 3.19.0 #2 SMP Fri Mar 6 00:23:51 UTC 2015 x86_64 Intel(R) Core(TM) i5-2557M CPU @ 1.70GHz GenuineIntel GNU/Linux
core@core-01 ~ $

Bene ! abbiamo creato il nostro cluster basato su CoreOS, branch alpha, con cinque nodi e siamo in grado di collegarci singolarmente in ssh ad ognuno di essi.

Nelle prossime puntate vedremo come effettuare il deploy automatico di applicazioni sul cluster sfruttando le enormi potenzialità di questa fantastica distribuzione che è CoreOS.

Stay tuned !

Mario Ciccarelli

Alto biondo e ricciolino, ecco esattamente il contrario.