Dans mon précèdent article, je vous parlais de l’installation de Docker. Vous savez que je suis réticent à tout ça, moi qui ne vis que par la souris, et qui en fait le moins possible par le shell.
Aussi, Docker, c’est clair que c’est pas mon domaine. Pourtant je m’y mets tranquillement, mais surtout parce que j’ai trouvé le moyen d’en simplifier mon usage : Lando, le manager Docker pour les nuls.

Dans ce billet, on va voir ce qu’est Lando, à quoi ça sert, et surtout comment ça peut simplifier l’utilisation de Docker.

Lando ?

Ouais, Lando.
Si vous ne connaissez pas, Lando est un outil pensé pour les développeurs, afin de simplifier la mise en place de projets sur Docker. J’insiste bien sur le fait qu’il est fait pour les dévs, et je les en remercie. Suis pas développeur back-end hein, qu’on soit d’accord, moi je fais ça en amateur. Mais quand je vois la galère que c’est pour mettre en place un serveur local qui soit un peu hype (ouais mon Xampp c’est trop cheap :p ), ben j’ai tout de même l’impression qu’il faut être sysadmin avant de pouvoir toucher la moindre ligne de code.
Et là est mon réel problème : Si je passe des heures à essayer de mettre en place un truc à la mode (qui fonctionne, certes), combien de temps j’ai perdu, temps que j’aurai dû passer sur mon éditeur, et pas devant des tutos ou une console…

Bref, du coup j’ai gratté un peu et j’ai trouvé Lando, qui se défend d’être une simple surcouche ou une abstraction supplémentaire à Docker. Dans les faits, ça l’est ^^, mais c’est vraiment un chouette outil.
A noter que ce logiciel existe pour Linux, Windows et Mac. Testons cela ensemble.

Installation de Lando

Tout d’abord, on va aller télécharger la dernière version de Lando. Si les exécutables Windows et Mac sont plus lourds, c’est parce qu’elles contiennent de quoi installer Docker. Pour les utilisateurs Linux, il faudra au préalable installer Docker à la main.
Notez que je ne détaillerai ici que l’installation sous Linux, les .exe ou .dmg étant objectivement très faciles à appréhender.

Vous avez installé Docker et récupéré le package pour votre distro (.deb, .rpm ou .pacman) ? C’est parti, on va procéder à l’installation de Lando.

Important : Sur Linux, il faut impérativement que l’utilisateur courant ait été ajouté au groupe Docker, sans quoi Lando ne pourra être exécuté correctement.

Si vous pouvez l’ouvrir avec le gestionnaire de logiciels de votre distro, c’est facile, sinon on va faire ça à coup de CLI. Ouvrez un terminal dans le dossier de téléchargement de Lando et lancez l’install.

Arch :

sudo pacman -U lando*.pacman 

Debian, *buntu :

sudo dpkg -i lando*.deb

Fedora :

sudo dnf install lando*.rpm

On va finir par un petit test, histoire de voir si tout s’est bien passé. Tapez dans une console :

lando version
lando version

Si Lando vous affiche sa version, c’est que ça commence à sentir bon. On va pouvoir tester ça en réel maintenant 🙂

Assurez-vous que docker soit fonctionnel (lancez un docker version par exemple), et passons aux choses sérieuses.

Hello World

Comme dans la programmation, on va se faire un petit test, le classique Hello World.
Le test sera tout bête : On va installer un serveur LAMP (Linux Apache MySQL PHP), et tenter d’exécuter un petit script.
On va commencer par se choisir un répertoire qui contiendra nos différents projets. Pour ma part, j’ai choisi /home/$USER/sites

Mise en place de l’arborescence

On ouvre un terminal, et on se place dedans :

cd /home/$USER/sites

Puis dans celui-ci, on va créer un dossier ‘hello’, qui contiendra les fichiers de notre test, puis on se place dedans :

mkdir hello                                                        
cd hello

Dans ce dossier ‘hello’, on va créer un simple fichier php, destiné à voir la version php, les extensions installées, etc.
On va juste mettre un phpinfo() dans un fichier, index.php, toujours grâce à la console :

echo "<?php phpinfo();" > index.php

Générer un fichier .lando.yml

Enfin, on va initialiser un container LAMP grâce à lando :

lando init \                                                 
  --source cwd \
  --recipe lamp \
  --webroot . \     
  --name hello-world

J’explique. La commande lando init va initialiser simplement un fichier .lando.yml. J’ai ensuite posé 4 options sur la commande :

  • source cwd : indique que la source des fichiers à utiliser est le dossier de travail courant (Current Working Directory). On verra plus tard qu’il est possible d’utiliser une archive en ligne ou un dépôt Git
  • recipe lamp : les recipes ou recettes sont des images toutes prêtes, avec des services et outils déjà configurés. Bien entendu, il est possible de les modifier.
    lamp est une recette un peu passe-partout, cependant sachez qu’il en existe d’autres déjà incluses.
  • webroot . : chemin relatif vers la source des fichiers. En y mettant un simple ‘.’, lando prendra le répertoire courant comme base du serveur, ici /home/max/sites/hello. Si par exemple vous souhaitez une zone publique, mettez simplement htdocs, public ou encore www. N’oubliez pas de créer le dossier et y mettre vos fichiers publics bien sûr.
  • name hello-world : le nom de votre application, ici hello-world.

Si tout s’est bien passé, un beau message flashy doit apparaître dans la console, avec quelques infos sur l’application créée :

lando init
Le violet sur fond gris n’est pas des plus visibles chez moi 🙂

On peut vérifier dans notre dossier hello, on doit avoir un fichier .lando.yml avec pour contenu :

name: hello-world
recipe: lamp
config:
  webroot: .

Ce fichier, à la manière de docker-compose, permet de composer nous-même notre stack, notre serveur, notre ensemble de briques à installer pour faire tourner notre projet.
On verra plus tard comment le modifier.

Lancement du conteneur

Pour démarrer notre ‘hello-world’, nous n’avons maintenant plus qu’à lancer :

lando start

Comme pour Docker, vous en avez maintenant pour un petit moment : Lando va télécharger les images nécessaires à notre LAMP, puis décompresser et orchestrer tout ça.
A la fin, vous verrez un petit récapitulatif de votre application :

   ___                      __        __        __     __        ______
  / _ )___  ___  __ _  ___ / /  ___ _/ /_____ _/ /__ _/ /_____ _/ / / /
 / _  / _ \/ _ \/  ' \(_-</ _ \/ _ `/  '_/ _ `/ / _ `/  '_/ _ `/_/_/_/ 
/____/\___/\___/_/_/_/___/_//_/\_,_/_/\_\\_,_/_/\_,_/_/\_\\_,_(_|_|_)  
                                                                       

Your app has started up correctly.
Here are some vitals:

 NAME            hello-world                    
 LOCATION        /home/max/sites/hello          
 SERVICES        appserver, database            
 APPSERVER URLS  https://localhost:32801        
                 http://localhost:32802         
                 http://hello-world.lndo.site/  
                 https://hello-world.lndo.site/ 

Tout s’est bien passé, on est au top.
En bas on a 4 URL qui permettent d’accéder à notre application.
Allez, on ouvre Firefox, et on va tenter de voir ce qui se passe sur http://hello-world.lndo.site/

Si vous avez bien fait ça, vous devriez tomber sur votre fichier créé précédemment, index.php :

lando php

Votre conteneur est opérationnel 🙂
Notez que les URL en https provoqueront une alerte de sécurité de votre navigateur, étant donné qu’il n’y a pas de certificat SSL.

Informations sur l’application

Ça fonctionne oui, mais avouez que c’est un peu léger pour que ce soit réellement utilisable.
On va tenter d’en savoir un peu plus, histoire de pouvoir par exemple se connecter à la base de données.
Lancez un lando info dans la même console :

lando info                                                   
[ { service: 'appserver',
    urls:
     [ 'https://localhost:32801',
       'http://localhost:32802',
       'http://hello-world.lndo.site/',
       'https://hello-world.lndo.site/' ],
    type: 'php',
    healthy: true,
    via: 'apache',
    webroot: '.',
    config: {},
    version: '7.3',
    meUser: 'www-data',
    hasCerts: true,
    hostnames: [ 'appserver.helloworld.internal' ] },
  { service: 'database',
    urls: [],
    type: 'mysql',
    healthy: true,
    internal_connection: { host: 'database', port: '3306' },
    external_connection: { host: '127.0.0.1', port: '32798' },
    healthcheck: 'bash -c "[ -f /bitnami/mysql/.mysql_initialized ]"',
    creds: { database: 'lamp', password: 'lamp', user: 'lamp' },
    config: {},
    version: '5.7',
    meUser: 'www-data',
    hasCerts: false,
    hostnames: [ 'database.helloworld.internal' ] } ]

On a quelques informations intéressantes, notamment sur la connexion à la BDD :

  • internal_connection: { host: 'database', port: '3306' } : Hôte du Système de Gestion de Base de Données. A noter que ce n’est pas localhost
  • creds: { database: 'lamp', password: 'lamp', user: 'lamp' } Informations de connexion à la BDD

Plus haut, on retrouve les URL permettant d’accéder à notre appli.

Modification

On va à présent modifier un peu notre stack, nos briques, pour tenter d’appréhender un peu mieux le fichier .lando.yml.
Ouvrez donc le fichier que lando avait créé, et on va le modifier un peu :

name: hello-world
recipe: lamp
config:
  webroot: .
  php: '7.2'
  database: mariadb
  xdebug: true

Rien de bien compliqué ici. J’ai indiqué dans la config que je souhaitais utiliser la version 7.2 de php, mariadb au lieu de mysql, et activer l’extension xdebug de php.
Pour que les modifications soient prises en compte, il faut faire un rebuild du conteneur :

lando rebuild

Lando va télécharger la version 7.2 de php, mariadb et la dernière version de xdebug, puis relancer la machine. On peut retourner sur notre serveur apache à l’adresse http://hello-world.lndo.site/ et voir que les changements ont bien été effectués :

Si on descend, on peut voir que xdebug est activé également.

Note : Lorsque vous spécifiez une version dans le fichier config, assurez-vous au préalable que l’image existe dans le Docker hub. Ici pour php 7.2, lando a téléchargé cette image :

lando php 7.2

Commandes utiles

Avant de laisser notre application et de passer à autre chose, on va voir quelques commandes utiles :

  • lando list : permet de lister les conteneurs et applications en fonctionnement. L’option --all permettra d’afficher également celles qui ne sont pas en fonction.
  • lando stop : Stoppe l’application en cours, ainsi que les services et conteneurs associés.
  • lando start : Lance l’application et les services associés.
  • lando restart : Besoin de vous l’expliquer ? ^^ A noter qu’un restart, au même titre que Docker, ne fait pas un rebuild des conteneurs
  • lando destroy : Après validation, l’application sera inaccessible. Les fichiers ne sont pas supprimés, mais les données des bases de données par exemple seront perdues. Il faudra faire un lando start pour réinitialiser tout ça.

WordPress

Avant de vous laisser partir, on va voir comment il peut être facile d’installer le CMS WordPress en local, avec quelques arrangements du coté de notre pile.

Dans le dossier sites qu’on a utilisé plus haut, on va créer un autre répertoire, que j’appellerai wp-local.
Dans ce dossier, on ouvre un terminal, et on entre :

lando init \
  --source remote \
  --remote-url https://wordpress.org/latest.tar.gz \
  --recipe wordpress \
  --webroot wordpress \
  --name mon-wp-en-local

Ici, on a indiqué la source à remote, car les fichiers n’étaient pas dans le CWD mais sur le web. Dans l’option remote-url, j’ai indiqué l’adresse de l’archive de WordPress.
Contrairement à tout à l’heure, j’ai utilisé la recette wordpress et pas lamp : Lando prévoit tout ^^
Enfin, le webroot n’est plus le dossier courant (wp-local), mais wordpress, simplement parce que dans l’archive de WordPress, les fichiers du CMS se trouvent dans un dossier wordpress. Forcément à la décompression, tout sera dans ce dossier.
Puis j’ai mis un nom d’application à la noix 😀

Vous pouvez aller voir dans le dossier wp-local, il existe maintenant un dossier wordpress qui contient tous les fichiers de l’archive, que lando a décompressé :

lando wordpress

Puis on va modifier le fichier .lando.yml que lando a généré, et on va le modifier (étape complètement facultative).

name: mon-wp-en-local
recipe: wordpress
config:
  webroot: wordpress
  database: mariadb:10.3
  via: nginx
  php: '7.2'

Vous ne devriez pas avoir de soucis ici. Seul élément notable, j’ai décidé d’utiliser le serveur Nginx et non celui par défaut, Apache.

Faites un lando rebuild afin de mettre à jour les conteneurs et que lando télécharge les images nécessaires (ça peut être long ^^).
Puis lancez lando start afin de démarrer l’application :

lando wordpress start

En allant à l’adresse du serveur (ici http://mon-wp-en-local.lndo.site/ ), on se retrouve bien avec la page d’installation de WordPress).

Pour les identifiants de connexion à la base de données, n’oubliez pas de lancer un lando info afin de récupérer ce qui nous intéresse :

lando info wordpress

Le mot de la fin

Je vais m’arrêter là pour ce billet, déjà assez long mais pas compliqué, du moins je le crois.
Si vous souhaitez aller plus loin, la doc de Lando est extrêmement fournie et bien faite.

N’hésitez pas à commenter si certains passages ne sont pas assez détaillés. J’essayerai de faire un autre post dès que le temps le permettra. En attendant, j’espère que ce billet aura été utile à certains qui, comme moi, trouvent que les méthodes à la mode ne sont pas adaptées aux particuliers.