30 Sep 2015, 20:32

Un cluster docker avec Swam sur plateforme ARM

Docker est connu pour fonctionner sur un environnement 64 bits ; toutefois, il est possible de faire des choses avec la plateforme ARM (Raspberry,Cubietruck, etc). C'est moins immédiat et direct que la méthode 64 bits mais c'est faisable. La preuve ci-après.

Matériel en présence :

  • 1 Raspberry, utilisant l'image fournie par Hypriot ; il serait certes possible de récuperer docker des backports debian (ie jessie-backports) mais c'est une vieille version à l'échelle de docker (1.6.2 vs 1.8.2 à date)
  • 2 CubieTrucks, utilisant l'image d'armbian (compatible avec pleins de boards ARM) mais en récupérerant le paquet debian fournit par Hypriot pour avoir également une version de Docker à jour.

D'un point de vue réseau, tout ce petit monde est dans le même LAN.

Maintenant que chaque machine est sur le réseau, que docker est installé sur chacune d'entre elle en version 1.8.2, on peut commencer à bâtir notre cluster.

L'outil proposé par Docker pour gérer un cluster Docker se nomme Swarm. Sur un environnement 64 bits, l'installation est assez évidente et on peut même s'appuyer sur Docker-Machine. Pour autant, sur ARM, c'est un peu plus compliqué même si légèrement décrit dans le cadre de l'installation manuelle. Comme indiqué sur le dépot de swarm, il est possible de compiler swarm et d'utiliser alors directementle binaire swarm plutôt que de faire un docker run swarm (qui rappelons le ne fonctionne qu'en environnement 64 bits).

Installation de swarm

Cela consiste à :

  1. Installer Go 1.5 via GVM
  2. Installer Godep
  3. Compiler Swarm
$ wget https://raw.githubusercontent.com/moovweb/gvm/master/binscripts/gvm-installer
$ chmod +x gvm-installer
$ ./gvm-installer
Cloning from https://github.com/moovweb/gvm.git to /home/pi/.gvm
No existing Go versions detected
Installed GVM v1.0.22
Please restart your terminal session or to get started right away run
`source /home/pi/.gvm/scripts/gvm`
$ source /home/pi/.gvm/scripts/gvm
$ sudo apt-get install bison
# To install Go 1.5, you need first to install Go 1.4 ; cf https://github.com/moovweb/gvm/issues/155
$ gvm install go1.4
Downloading Go source...
Installing go1.4...
* Compiling...
$ gvm use go1.4
Now using version go1.4
$ export GOROOT_BOOTSTRAP=$GOROOT
$ gvm install go1.5
Installing go1.5...
* Compiling...
$ gvm use go1.5 --default
Now using version go1.5
$ go get github.com/tools/godep
$ go get github.com/docker/swarm
$ swarm -v
swarm version 0.5.0-dev (HEAD)

A ce stade, vous obtiendrez une version 0.5.0-dev de Swarm ; si vous voulez une version 0.4, il faudra se référer à la partie détaillée de la compilation de Swarm pour ne récupérer que la version voulue.

Docker, en mode j'écoute sur le réseau

Pour que les nodes de votre cluster communiquent entre elles, il faut ouvrir le port 2375 sur le réseau. Pour ce faire, il suffit d'éditer /etc/default/docker et rajouter -H tcp://0.0.0.0:2375 à DOCKER_OPTS comme ci-dessous :

DOCKER_OPTS="--storage-driver=overlay -D -H tcp://0.0.0.0:2375"

Puis redémarrer le service docker :

systemctl restart docker
systemctl restart docker.socket

Vous pouvez le vérifier ensuite avec nmap :

$ nmap <node_ip> -p 2375
Starting Nmap 6.00 ( http://nmap.org ) at 2015-09-30 21:03 CEST
Nmap scan report for 192.168.8.102
Host is up (-890s latency).
PORT     STATE SERVICE
2375/tcp open  unknown
Nmap done: 1 IP address (1 host up) scanned in 1.11 seconds

Ton utilisateur, au groupe docker, il appartiendra

Pour éviter des erreurs débiles, il faut absolument que l'utilisateur qui lancera la commande docker fasse partie du groupe docker

$ sudo gpasswd -a <user> docker

Ton cluster tu initialisera

Sur une des nodes (peu importe laquelle) : il faut créer le token de référence pour notre cluster en utilisant swarm create qui va vous retourner un token.

$ swarm create
<token_id>

Sur chaque node, il faut lancer une commande swarm pour indiquer au démon docker qui tourne sur votre node (donc en "local" mais en utilisant l'ip associée à eth0) le token du cluster :

swarm join --addr=<node_lan_ip>:2375 token://<token_id>

Cela vous donne quelque chose comme (chaque node doit voir son ip dans l'argument addr):

INFO[79212] Registering on the discovery service every 20s...  addr=192.168.8.102:2375 discovery=token://03ac974de5db2791b4c3cfe89c307655

Depuis une des nodes, vous pouvez essayer de lister les nodes de votre cluster :

swarm l token://<token_id>
<node1_lan_ip>:2375
<node2_lan_ip>:2375
<node3_lan_ip>:2375

Promouvoir un manager de cluster

Option 1 : Depuis un poste distant

Là, c'est facile et comme indiqué dans la documentation officielle ; par ex depuis mon laptop.

Lancer swarm via docker en mode "daemon" et en précisant le token de votre cluster:

docker run -d -p 2375:2375 swarm manage token://03ac974de5db2791b4c3cfe89c307655

Vous pouvez vérifier que votre process docker tourne bien :

docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                    NAMES
34c3456e0cb9        swarm               "/swarm manage token:"   22 hours ago        Up 22 hours         0.0.0.0:2375->2375/tcp   clever_feynman

Et pour avoir le statut de votre cluster :

docker -H tcp://<laptop_ip_ou_meme_localhost>:2375 info
Containers: 0
Images: 0
Role: primary
Strategy: spread
Filters: affinity, health, constraint, port, dependency
Nodes: 3
 black-pearl: 192.168.8.102:2375
  └ Containers: 0
  └ Reserved CPUs: 0 / 1
  └ Reserved Memory: 0 B / 456 MiB
  └ Labels: executiondriver=native-0.2, kernelversion=3.18.11-hypriotos+, operatingsystem=Raspbian GNU/Linux 7 (wheezy), storagedriver=overlay
 or-azur: 192.168.8.101:2375
  └ Containers: 0
  └ Reserved CPUs: 0 / 2
  └ Reserved Memory: 0 B / 2.067 GiB
  └ Labels: executiondriver=native-0.2, kernelversion=4.2.0-sunxi, operatingsystem=Debian GNU/Linux 8 (jessie), storagedriver=overlay
 thanos: 192.168.8.100:2375
  └ Containers: 0
  └ Reserved CPUs: 0 / 2
  └ Reserved Memory: 0 B / 2.065 GiB
  └ Labels: executiondriver=native-0.2, kernelversion=4.2.0-sunxi, operatingsystem=Debian GNU/Linux 8 (jessie), storagedriver=overlay
CPUs: 5
Total Memory: 4.577 GiB
Name: 34c3456e0cb9

Option 2 : lancement du manager depuis la node

Depuis une node de votre choix :

swarm manage -H <node_ip>:<port_de_votre_choix> token://<token_id>

Vous pouvez ensuite vous connecter depuis la node :

docker -H tcp://<node_ip>:<port_de_votre_choix> info

Et ensuite...

Il suffit d'utiliser docker en ligne de commande comme normalement :

docker -H tcp://<manager_ip:manager_port> info
docker -H tcp://<manager_ip:manager_port> run ...
docker -H tcp://<manager_ip:manager_port> ps
docker -H tcp://<manager_ip:manager_port> search ...
docker -H tcp://<manager_ip:manager_port> logs ...

Exemple :

docker -H tcp://localhost:2375 ps
CONTAINER ID        IMAGE                COMMAND             CREATED             STATUS              PORTS               NAMES
e79fd7deb1c6        armv7/armhf-ubuntu   "/bin/bash"         7 minutes ago       Up 7 minutes                            <node_name>/adoring_jang

Vous pouvez aussi interagir directement avec une de vos nodes :

docker -H tcp://<node_ip>:2375 ps
CONTAINER ID        IMAGE                COMMAND             CREATED             STATUS              PORTS               NAMES
e79fd7deb1c6        armv7/armhf-ubuntu   "/bin/bash"         3 minutes ago       Up 3 minutes                            adoring_jang

Mais, ce n'est pas tout à fait fini en fait

Les commandes swarm join ou swarm manage ont été lancées en ligne de commande ; donc si vous fermez vos consoles, c'en est fini. Il faut donc automatiser tout ça ; personnellement, j'aime bien supervisord.

apt(-get) install python-setuptools
easy_install supervisor
echo_supervisord_conf > /etc/supervisord.conf

A la fin de ce fichier, changer :

[include]
files = /etc/supervisor.d/*.conf

Ensuite :

Pour le premier fichier qui permet de rejoindre le cluster :

$ cat /etc/supervisor.d/docker-swarm-join.conf 
[program:docker-swarm-join]
directory=/tmp/
command=/root/.gvm/pkgsets/go1.5/global/bin/swarm join --addr=<node_lan_ip>:2375 token://<token_id>
user=root
umask=022
autostart=True
autorestart=True
redirect_stderr=True

Et le second fichier qui permet de lancer le manager (à ne faire qu'une fois) :

$ cat /etc/supervisor.d/docker-swarm-manage.conf 
[program:docker-swarm-manage]
directory=/tmp/
command=/root/.gvm/pkgsets/go1.5/global/bin/swarm manage -H <node_lan_ip>:<port_de_votre_choix> token://<token_id>
user=root
umask=022
autostart=True
autorestart=True
redirect_stderr=True

Il reste ensuite à récupérer un script d'init pour Debian ou sa version pour systemd.

Et voilà, un joli cluster Docker basé sur Swarm avec vos machines ARM.

Source : Github Docker/Swarm #1245

25 Mar 2015, 09:30

Around the Web - March 2015

Browser

Responsive Web Design (RWD)

HTML5/CSS/Javascript

  • This API is so Fetching : fetch API is to be used for asynchronous actions and is to be more resilient than a XHR (ie ajax) call. Some exemples are given in the blog post ; it can be used from Firefox 39 and Chrome 42 (currently in dev status) but a Fetch Polyfill exists to start using this API from now.
  • CSS Reference which introduces itself as an extensive CSS reference with all the important properties and info to learn CSS from the basics ; this article gives a more introduction on its purpose and how to use it.
  • Meteor, develop faster than a rocket (in French) : an introduction to Meteor  a full stack and isomorphic javascript framework in which you use Javascript both on client and server side. It also uses MongoDB (NoSQL Document Oriented database & schemaless) to store data and it's based on Node.JS. A second article will show how you can create a mobile app easily.

Thoughts

  • Your job is not to write code : Engineers' job is not to write code, Project Managers' job is not to manage project and so on. Our job is to make a better product.
  • A Bug Hero to fight against bug invasion (in French): in an agile team, in each sprint, a developper is commited to do the 1st level support, fix bug and manage incident to avoid disturbing the whole team and sacrifice the sprint. If no bugs, developer is aimed to fix small tasks that are not on the critical path for the sprint dlivery. Interesting both for the disturbing management effect and as it enforces developpers to have a global knowledge of the system, not only his own part.  

SQL

  • Understanding SQL's null : because querying null is not as easy as it may be and also null may not mean null in the way you expect.
  • PoWa (Postgresql Workload Analyser), released as a 2.0 version, provides a better (from what it is said, not tested) monitoring and performance tools on your Postgres 9.4 cluster.

Virtualisation

Compose is a way of defining and running multi-container distributed applications with Docker. Back in December we opened up its design to the community. Based on the feedback from that, Compose will be based on Fig, a tool for running development environments with Docker.

Machine takes you from “zero-to-Docker” with a single command. It lets you easily deploy Docker Engines on your computer, on cloud providers, and in your own data center

Swarm is native clustering for Docker containers. It pools together several Docker Engines into a single, virtual host. Point a Docker client or third party tool (e.g., Compose, Dokku, Shipyard, Jenkins, the Docker client, etc.) at Swarm and it will transparently scale to multiple hosts. A beta version of Swarm is now available, and we’re working on integrations with Amazon Web Services, IBM Bluemix, Joyent, Kubernetes, Mesos, and Microsoft Azure.

  • so now you can orchestrate all your process from zero to production using docker (based) solutions. Even if some products are still in beta so far, a very interesting move !