Depuis quelques temps déjà on entend parler de Serverless et plus particulièrement de Function As A Service (Faas). Ce nouveau concept nous offre la possibilité d’exécuter du code sans avoir à mettre en service ou gérer des serveurs. En outre, on ne se souci « que » du développement du code, sans se soucier de la gestion de systèmes de serveurs.
Aujourd’hui on trouve nombre de solutions proposées par les géants du cloud ( Lambda pour AWS, Cloud Functions pour Google, Azure Functions chez Microsoft, …) mais d’autres ont également émergé et méritent qu’on s’y intéresse. Nous allons découvrir au travers de cet article OpenFaas, un framework pour Docker permettant de construire des fonctions serverless.

Cet article sera divisé en deux parties :

la première aura pour objectif de décrire l’installation d’Openfaas
la seconde fera un focus sur le développement et le déploiement de quelques fonctions.

Un petit laïus sur OpenFaas avant de commencer

OpenFaas est un projet opensource créé par Alex Ellis lors du DockerCon 2017, et commence déjà à se faire un nom au sein des entreprises (il est notamment utilisé par Contiamo et Citrix). Par ailleurs c’est le projet GitHub qui a obtenu le plus d’étoiles en 2017 (à l’heure où j’écris ces lignes, il en est à 12 000).
OpenFaas présente les avantages suivants :

Open source sous licence MIT
Il est portable et peut facilement être installé au sein d’un cluster Kubernetes ou Docker Swarm existant
Il offre la possibilité d’écrire des fonctions en Java, Python, Go, Ruby, Node, PHP, … qui seront packagées et exécutées dans de petits conteneurs Docker
Le scaling est automatique

Outre le fait qu’ OpenFaas soit déployable dans un cluster Kubernetes ou Swarm, il est possible de monitorer facilement l’activité de nos fonctions puisque la solution intègre Prometheus. Les métriques sont entre autres utilisées pour détecter les pics de charge, afin d’effectuer le scaling nécessaire, et peuvent être intégrées au tableau de bord.

Le Function As A Service selon OpenFaas, source https://docs.openfaas.com

Enfin un client en ligne de commande permet de déployer de nouvelles fonctions sans passer par l’interface web.

Une petite introduction et quelques démos ont été faites par Alex Ellis lors d’une conférence à Londres en 2017 intitulée “Faas and Furious – 0 to Serverless in 60 seconds“).

Installation d’OpenFaas

Comme stipulé un peu plus haut OpenFaas est un framework s’appuyant sur Docker, nécessitant d’être déployé au sein d’un cluster Kubernetes ou Docker Swarm. Dans cet article nous utiliserons Docker Swarm, nous verrons donc en premier lieu comment créer ce type de cluster. Afin de rendre les manipulations plus ludiques, notre cluster sera composé de Raspberry PI.

Pour être suivi à la lettre, ce tutoriel nécessite d’avoir du matériel un peu coûteux : à minima trois Raspberry (un master et deux workers), des câbles rj45 et un switch pour les interconnecter, et les alimentations. Ce matériel peut être facilement commandé sur Internet (prévoyez un budget de 210 € environ).

Si vous n’avez pas la possibilité d’utiliser des Raspberry, j’ai mis à disposition un VagrantFile et quelques Playbook Ansible facilitant le déploiement d’un cluster Docker Swarm et l’installation d’OpenFaas sur une machine locale (le lecteur devra uniquement avoir VirtualBox sur sa machine). Vous pouvez directement vous rendre au chapitre Déploiement en local.

FICHE TECHNIQUE

Pour la version virtualisée :

VirtualBox 5.2.18

Ansible 2.6.4

Pour la version Raspberry :

Un minimum de trois Raspberry PI 3

Raspbian Stretch

Trois câbles RJ45

Un switch

Trois câbles USB et un power hub.

Trois cartes MicroSD

Déploiement sur le cluster Raspberry PI

Assemblage du cluster

Construire un cluster de Raspberry PI est relativement trivial :

On applique les dissipateurs thermiques sur les processeurs des Raspberry (cette étape est facultative mais fortement recommandée pour éviter la surchauffe des cartes).
On rassemble les Raspberry via quelques entretoises en plastique.
On branche chaque Raspberry au Power Hub via les câbles fournis avec ce dernier.
On relie le switch aux Raspberry avec les câbles rj45 prévus à cet effet.

En substance, il faut simplement passer de ceci (avec 5 Raspberry) …

… à ce résultat :

Installation de Raspbian

C’est certainement la partie rébarbative lors de la mise en place d’un cluster sur Raspberry : l’installation de l’OS sur chaque noeud.

On télécharge Raspbian depuis ce lien https://www.raspberrypi.org/downloads/raspbian. Pour la version, je vous laisse le choix mais il serait certainement plus judicieux d’utiliser la version Lite (beaucoup plus légère que la Desktop).
On installe l’OS sur une carte micro SD (l’opération sera répétée autant de fois qu’il y a de Raspberry composant le cluster). Pour simplifier cette opération je vous conseille d’utiliser l’outil Win32Disk Imager, qui permet d’installer une image sur microSD en quelques clics.

N’oublions pas d’activer ssh sur chaque noeud, cela nous sera très utile pour la suite des opérations.

L’ activation du SSH sur Raspbian se fait via l’outil “Raspberry Pi Configuration”, accessible via le bouton Menu > Préférences > “Raspberry Pi Configuration”. Il suffit ensuite d’activer SSH depuis l’onglet “Interface”, puis de redémarrer Raspbian pour appliquer les changements.

Installation de Docker Swarm

Installation de Docker-CE

Cette opération doit être répétée sur chaque Raspberry.

Avant de nous lancer dans Docker Swarm il nous faut installer Docker-CE. La version de Docker proposée par défaut sur les dépôts Raspbian est loin d’être la plus récente. Nous allons donc installer Docker manuellement. Pour cela :

1 – On met à jour la liste des paquets disponibles dans les dépôts APT

sudo apt-get update

2 – On installe les paquets nécessaires à APT, afin qu’il puisse contacter les repos via HTTPS

sudo apt-get install ca-certificates software-properties-common apt-transport-https

3 – On ajoute la clé GPG Docker

curl -fsSL https://deb.dockerproject.org/gpg | sudo apt-key add -

4 – On ajoute le repository qui sera utilisé pour installer Docker

sudo add-apt-repository "deb https://apt.dockerproject.org/repo/ raspbian-$(lsb_release -cs) main"

5 – On installe Docker

sudo apt-get update
sudo apt-get install docker-ce

Nous pouvons à présent passer à l’installation de Docker Swarm.

Nous allons passer à l’installation de Docker Swarm. Il est cependant possible de remplacer Docker Swarm par Kubernetes, dont l’installation est simplifiée par kubeadm. Si vous avez une préférence pour Kubernetes, vous pourrez également opter pour l’outil rak8s.

Installation du noeud master

Un cluster swarm fonctionne avec un noeud master, et plusieurs noeuds slaves. Nous devons donc sélectionner un Raspberry qui fera office de master, et exécuter la commande suivante sur ce dernier :

docker swarm init

Celle-ci nous renverra une commande du type

docker swarm join --token TOKEN IP:PORT

Gardez précieusement cette commande, nous la réutiliserons à l’étape suivante.

Installation des noeuds slaves

Chaque Raspberry qui reste à notre disposition sera donc un slave dans notre cluster. Ces slaves doivent être référencés auprès du noeud master. Pour cela nous allons exécuter la commande obtenue à l’étape précédente sur chaque slave :

docker swarm join --token SWMTKN-1-20nfsdusb4680anbc6un8rdysu4m44ah13b4udvqdcfxk8wqvj-22qhchrgbvuf7ra6pithna2vf 10.0.3.2:2377

Et c’est terminé, le cluster Docker Swarm est opérationnel. Pour vérifier que tout fonctionne correctement nous pouvons exécuter la commande suivante sur le noeud/Raspberry master :

sudo docker node ls

Celle-ci devrait nous renvoyer un résultat similaire à ceci :

Déploiement d’OpenFaas

Dernière étape de la procédure d’installation : le déploiement d’OpenFaas. Cette partie est relativement simple :

1 – On se connecte en ssh au Raspberry Pi faisant office de master node.

ssh pi@10.0.3.2

2 – On clone le repo Git du projet.

git clone https://github.com/openfaas/faas.git

3 – On lance le script d’installation, repris des sources que nous venons de cloner.

./deploy_stack.sh

L’ exécution de cette commande nous renverra, entre autre, un password que nous utiliserons pour déployer nos fonctions et administrer OpenFaas.

4 – (Optionnel) En vue de pouvoir déployer nos fonctions directement en ligne de commande, nous allons installer faas-cli sur le master node.

curl -sSL -o faas-cli.sh https://cli.openfaas.com
chmod +x faas-cli.sh && ./faas-cli.sh
cp faas-cli /usr/local/bin/faas-cli && ln -sf /usr/local/bin/faas-cli /usr/local/bin/faas

OpenFaas est désormais installé 🙂 Il ne reste plus qu’à tester l’installation en déployant notre première fonction !

Première connexion et test d’une fonction d’exemple

Vient enfin le moment de lancer notre première fonction. Connectons-nous à l’interface d’administration d’Openfaas en nous rendant à l’adresse ip_master_node:8080/ui.

Une popup nous demandera un login et un mot de passe, nous entrerons les informations remontées lors de l’exécution du script deploy_stack.sh.

Dans cet article nous allons nous limiter à tester une des fonctions fournies par défaut avec OpenFaas. Pour cela on clique simplement sur le bouton “Deploy New Function” de l’interface d’OpenFaas, puis on sélectionne la fonction souhaitée :

Une fois la fonction déployée, il ne reste qu’à la sélectionner et l’invoquer !

Nous avons bien un retour de notre fonction, le cluster OpenFaas fonctionne correctement.

Déploiement en local

Si vous n’avez pas de Raspberry sous la main, il est tout à fait possible de se familiariser avec OpenFaas sur un cluster local (basé sur des VMs).

Un Vagrantfile à été mis a disposition ici pour vous permettre de provisionner facilement trois VMs : une pour le noeud master et deux pour les workers. Une fois les VMs démarrées, des playbooks Ansible sont joués pour installer Docker Swarm et OpenFaas.

Le nombre de workers peut être augmenté en ajoutant les définitions nécessaires dans le fichier vagrant-config.yml et hosts.yml, par exemple :

...
worker-3:
        ip: "10.0.3.5"
        config: 
            cpus: 1
            memory: 512
            image: "ubuntu/xenial64"
            network: "private_network"
...

[workers]
...
10.0.3.5

Enfin pour lancer la création du cluster, rien de plus simple puisqu’il suffit simplement d’exécuter la commande suivante à la racine du répertoire où se trouve le Vagrantfile :

vagrant up

On attend ensuite quelques minutes et notre cluster est opérationnel, avec OpenFaas installé (le mot de passe permettant d’accéder à l’interface d’OpenFaas est donné par les logs d’exécution de Vagrant, dans votre terminal).

Je vous invite à consulter cet article, qui donnera plus de précision sur le couplage Vagrant/Ansible.

En résumé, le Vagrantfile et les playbooks réalisent à peu de choses près les mêmes actions que lors du déploiement sur Raspberry.

Et ensuite ?

Nous avons vu comment installer OpenFaas au sein d’un cluster Swarm. Chaque étape de l’installation a été décrite, de l’assemblage du cluster au déploiement de notre première fonction. Il est possible que certains d’entre vous restent un peu sur leur faim suite à l’utilisation de cette fonction, fournie par défaut avec OpenFaas. L’ objectif du prochain article sera de satisfaire votre appétit en démontrant comment développer et déployer nos propres fonctions. D’ici là, un peu de lecture pour les plus impatients :

Sources permettant de monter rapidement un environnement OpenFaas en local : https://github.com/mderacc/ineat-openfaas-install
Quelques précisions concernant Function As A Service, et Serverless en général : https://medium.com/@BoweiHan/an-introduction-to-serverless-and-faas-functions-as-a-service-fb5cec0417b2
Site officiel du projet OpenFaas : https://www.openfaas.com/
Présentation / démo du projet : https://www.youtube.com/watch?v=XgsxqHQvMnM
Couplage Vagrant / Ansible : https://blog.ineat-group.com/2018/09/tester-ses-playbooks-ansible-localement-avec-vagrant/
Documentation officiel de Docker Swarm : https://docs.docker.com/engine/swarm/

Serverless sur Raspberry PI avec Docker Swarm et OpenFaas : partie 1 – Installation d’OpenFaas