Créer un cluster Azure Container Service en mode Swarm

Auteur du billet de blog : Nicolas Hilaire - Neotech Solutions

Nicolas Hilaire

Consultant .NET
  Publié le mardi 14 février 2017

Artisan logiciel particulièrement intéressé par les technologies .NET. Polyvalent et curieux, je suis néanmoins à l'écoute des autres technologies du marché. MVP (Microsoft Most Valuable Professional) de 2007 à 2014, je suis également auteur d'un ouvrage pour apprendre le C#, à destination des débutants et de plusieurs MOOCs sur le C#, Windows Phone ou ASP.NET MVC...

Dans ce billet, nous allons parler d’Azure Container Service et nous allons voir comment y déployer des applications ASP.NET Core. Pour réaliser les applications de démonstrations, j’utiliserai la RC de Visual Studio 2017, mais ce n’est pas une obligation car cela fonctionne aussi avec VS2015.


Qu’est-ce qu’Azure Container Service (ACS) ?

Azure Container Service va vous permettre de créer très facilement un cluster de machines virtuelles, complètement configurées et prêtes à l’emploi où vous pourrez déployer vos applications conteneurisées avec Docker. ACS est compatible avec les orchestrateurs open-source Swarm, DC/OS et Kubernates (ce dernier est encore en preview à l’heure actuelle).
ACS est l’outil idéal si vous avez envie d’éviter de passer plusieurs jours à configurer correctement un cluster de machines et en plus, on peut bénéficier de l’Azure scale set pour faciliter la mise à l’echelle de votre cluster.
La documentation officielle se trouve ici : https://docs.microsoft.com/en-us/azure/container-service/.


Création du cluster

Pour démarrer, nous allons créer un cluster. Pour cela, ouvrez le portail Azure ; puis recherchez Azure Container Service :

 

 

Choisissez Azure Container Service, publié par Microsoft :

 

 

Puis, cliquez sur Create :

 

 

Comme souvent avec Azure, on débute avec l’assistant qui va nous permettre de configurer notre cluster. Dans un premier temps, il faut donner un nom d’utilisateur pour pouvoir se connecter, dans mon cas je mets acsuser :

 

 

Ensuite, vous allez avoir besoin d’une clé SSH publique. Si comme moi vous êtes sous Windows, vous allez devoir utiliser un logiciel comme Puttygen (http://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html) pour y parvenir :

 

 

Cliquez sur Generate et bougez la souris dans le cadre blanc pour aider à la génération aléatoire :

 

 

Cliquez ensuite sur Save public key et sur save private key pour enregistrer les clés sur votre disque dur (pas besoin de passphrase pour la clé privée).
Maintenant, copiez la clé publique et mettez-là dans le portail Azure, puis choisissez un groupe de ressources et un emplacement :

 

 

Choisissez maintenant un orchestrateur, dans cet exemple je vais utiliser Swarm :

 

 

Rappel : Kubernetes est pour l’instant en preview.

Il faut maintenant choisir le nombre d’agents pour le cluster, choisissez 2 et le nombre de maîtres pour le cluster, choisissez 1. Comme c’est pour un test, les valeurs ne sont pas importantes. Choisissez la taille des machines virtuelles pour les agents. Là c’est comme vous voulez aussi, mais pour un test je vais partir sur la moins chère, à savoir la DS1.
Vous devrez enfin fournir un préfixe DNS :

 


Cliquez sur Purchase pour démarrer la génération du cluster. Ne vous inquiétez pas, si vous avez une subscription MSDN, il n’y aura pas de frais supplémentaires.

 

 

Le cluster va mettre une quinzaine de minutes à se mettre en place, il est temps d’aller boire un petit thé vert plein d’antioxydants :).

 

Docker Swarm

Pendant que cela déploie, je vais vous parler un peu de Swarm.
Swarm est un outil d’orchestration qui permet d’utiliser les capacités de clustering natives pour transformer un groupe de Docker Engine en un unique engine virtuel. Grosso-modo, une ou plusieurs VM maitres contrôlent un « essaim (swarm) » de VM agents. Les agents hébergent les containers Docker qui exécutent notre code.

 

 

Plus d’info sur swarm https://docs.docker.com/engine/swarm/.

 

Se connecter à Docker Swarm

Une fois le cluster déployé, vous vous retrouvez avec un groupe de ressources plein de bonnes choses :

 

 

Cherchez la machine virtuelle, dont le nom contient master :

 

 

Et cliquez dessus pour obtenir son nom DNS :

 

 

Note : si vous ne voulez plus travailler sur le cluster, vous pouvez arrêter cette VM pour économiser quelques précieux euros et la rallumer plus tard.

Pour la suite, nous allons avoir besoin de Putty pour nous connecter au cluster et créer un tunnel SSH.
Démarrez Putty et renseignez le nom de domaine, préfixé par votre nom de user avec un @. Dans mon exemple, ça sera : acsuser@demoacsmgmt.westeurope.cloudapp.azure.com. Changez également le port à 2200 (on peut voir sur le schéma que le port 2200 est transposé sur le port 22, qui est le port SSH par défaut) :

 

 

Allez ensuite dans l’options Connection/SSH/Auth et chargez la clé privée précédemment générée :

 

 

Puis allez dans SSH/Tunnels pour créer le tunnel. Saisissez 22375 dans le port source (port docker) puis dans destination 127.0.0.1:2375 (2375 est le port Swarm sur le cluster) et cliquez sur Add :

 

 

Ensuite, vous pouvez retourner dans Session, pour donner un nom à la session afin de la sauvegarder et ne pas avoir à la recréer à chaque fois :

 

 

Enfin, cliquez sur Open pour ouvrir la connection SSH. Faites confiance au host, et vous voilà avec un terminal ouvert dont la connexion est sécurisée grâce aux clés précédemment générées :

 

 

Laissez le terminal ouvert, nous ne nous en servirons plus.
A partir de ce point, le cluster est disponible, nous nous sommes connectés au cluster et nous avons créé un tunnel sécurisé.
Il vous faut maintenant un client docker, que vous pouvez télécharger sur https://get.docker.com/builds/Windows/x86_64/docker-latest.zip. Une fois décompréssé, vous obtenez le client docker dont vous devrez ajouter l’emplacement au path (soit dans une invite de commande, soit dans les variables d’environnement).


Ouvrez maintenant une commande DOS, et définissez le HOST Docker pour pouvoir pointer sur le port du tunnel SSH, à savoir set DOCKER_HOST=tcp://127.0.0.1:22375 :

Nous allons pouvoir vérifier que la liaison au cluster est bonne en tapant docker version :

 

 

Si vous n’avez pas d’erreur dans la partie serveur, c’est que c’est gagné ! (les versions peuvent être légèrement différentes).

 

Créer une application ASP.NET Docker

Créons maintenant un projet ASP.NET Core, j’utilise pour ma part VS2017 en version RC :

 

 

De type API Web :

 

 

Si vous avez VS2017, vous pouvez - si vous le souhaitez - cocher la case Activer la prise en charge de Docker, mais ce n’est pas une obligation car vous pouvez aussi ajouter simplement un fichier Dockerfile plus tard. Vous n’avez pas Docker pour Windows ? Ce n’est pas grave, cela ne compilera pas dans Visual Studio mais nous pourrons quand même compiler en ligne de commande.

Une fois le projet créé, ajoutons un fichier Dockerfile (si ce n’est pas déjà fait) contenant :

 

 

Nous allons modifier le contrôleur pour avoir :

 

 

Faites un F5 histoire de vérifier que tout bien, vous devez avoir le json suivant, en naviguant sur http://localhost:xxx/api/values :

 

 

Retournez dans la console, et positionnez-vous dans le répertoire racine de votre projet (dans mon cas : C:\Users\nhilaire\Documents\visual studio 2017\Projects\DemoWebApi\DemoWebApi) et faites :

 

 

pour restaurer les packages de la solution. (note, la première fois cela peut être un peu long).

Puis compilez la solution avec : 

 

 

et enfin, publiez le projet avec :

 

 

Passons à la containeurisation de notre API Web et exécutez la commande :

 

 

(attention au point à la fin) 

 

 

Nous construisons une image s’appelant demo_acs directement sur le cluster.
Maintenant, exécutez la commande docker images où nous voyons notre image, ainsi que celle d’ASP.NET Core :

 

 

Il n’y a plus qu’à démarrer notre image, avec :

 

 

(note : ici nous mappons le port 80 de notre API sur le port 8080 qui sera celui accessible depuis l’extérieur).
Nous pouvons voir avec un docker ps que l’image tourne :

 

 

Remarquez que l’image est sur la machine 10.0.0.4.

 

Vérifions que ça fonctionne !

Il faut maintenant vérifier que notre API Web est accessible. Allez dans le groupe de ressources Azure et cherchez l’ip publique des agents :

 

 

Récupérez le nom DNS :

 

 

Et allez sur http://demoacsagents.westeurope.cloudapp.azure.com:8080/api/values (n’oubliez pas, nous avons mappé le port 80 sur le port 8080). Nous obtenons notre JSON :

 

 

Déployer d’autres conteneurs

Allez, pour le plaisir, nous allons démarrer un autre conteneur.
Vous pouvez créer un nouveau projet pour ce faire. Pour ma part je vais juste modifier mon projet et créer une nouvelle image. Pour qu’ils soient identifiables, je vais modifier le code du contrôleur pour avoir :

 

 

Je repasse par dotnet build, puis dotnet publish, puis je crée une nouvelle image avec par exemple 

 

 

Puis je la démarre sur un autre port, le 80 :

 

 

un petit docker ps me donne :

 

 

Notez que cette fois-ci, l’image est sur la machine 10.0.0.6, Swarm gère la densité.
L’image est démarrée, je peux naviguer sur http://demoacsagents.westeurope.cloudapp.azure.com/api/values et j’obtiens :

 

 

Allez, un petit troisième pour la route ?
Oui, car il va falloir faire une manipulation supplémentaire car nous allons sortir des ports 80 et 8080 qui sont exposés par défaut. Exposons une nouvelle API Web sur le port 5000, voici le code :

 

 

Construisons la nouvelle image :

 

 

puis :

 

 

puis docker ps

 

 

L’image est démarrée, tout va bien. Sauf que maintenant, naviguez sur http://demoacsagents.westeurope.cloudapp.azure.com:5000/api/values. Catastrophe, un timeout.
Vous l’aurez compris, il faut aller ouvrir les ports sur le load balancer.
Cherchez le load balancer agent :

 

 

Puis allez sur Health probes :

 

 

Il faut définir un endpoint à surveiller sur le port 5000 :

 

 

Puis allez sur Load balancing rules :

 

 

Et ajoutez une règle pour le port 5000, en choisissant le endpoint de surveillance que l’on vient de créer :

 

 

Une fois les règles créées, il ne reste plus qu’à retourner sur http://demoacsagents.westeurope.cloudapp.azure.com:5000/api/values et nous aurons notre API Web accessible :

 

 

Bravo, victoire de l’homme sur le firewall !
Maintenant, exécutez un petit docker info :

 

 

Nous pouvons voir plusieurs informations sur le cluster ; le nombre de containers qui tournent, le nombre de nœuds, la santé des nœuds, etc.

 

Conclusion

Voilà pour cette petite démo. Nous avons réussi à déployer très facilement des conteneurs sur un cluster orchestré par Swarm. ACS nous aide énormément dans la mise en place de la solution. Nous n’avons pas à nous soucier de la configuration du cluster, elle a été faite par des experts de Microsoft pour nous.
ACS est une option sérieuse quand il s’agit de déployer des conteneurs dans Azure. On pourra juste regretter que les versions mises en place commencent à dater, comme c’est le cas pour Swarm. Mais ceci devrait bientôt évoluer.

 

Commentaires