Utilisation de Docker

Portainer

Installation

Pour lancer une instance de Portainer, utilisez la commande suivante afin de créer un volume

docker volume create portainer_data

Puis cette commande afin de lancer Portainer

docker run -d -p 8000:8000 -p 9000:9443 --name portainer \\
    --restart=always \\
    -v /var/run/docker.sock:/var/run/docker.sock \\
    -v portainer_data:/data \\
    portainer/portainer-ce:latest

Enfin, Portainer est accessible via ip_de_votre_serveur:9000

Volumes

Il existe deux types de déclaration de volume sur Docker, les volumes et les bind

Volume

Si vous ne spécifiez aucun volume lors du lancement d'une application, Docker ne créera aucun volume persistant (≠ éphémère) et les données seront perdues.

Vous pouvez créer un volume avec la commande

docker volume create <NOM DU VOLUME>

Pour le supprimer, utilisez la commande

docker volume rm <NOM DU VOLUME>

Dans un fichier docker-compose, un volume s'utilise de la manière suivante

nom_du_container:
	# Utilisation d'un volume dans un service
	volumes:
	  - nom_du_volume:/chemin/à/l'intérieur/du/container

# Déclaration du volume dans la stack	
volumes:
  nom_du_volume:

Bind

Les bind sont simplement une manière de dire à Docker où stocker les données, par exemple, imaginez que vous avez un container MariaDB. Par défaut, MariaDB stocke ses données dans /var/lib/mysql et vous pouvez dire à Docker de faire pointer ce dossier vers le dossier /home/votre_utilisateur/mariadb_data (ou tout autre dossier) afin de pouvoir accéder à ces données et les modifier depuis l'hôte (votre serveur)

Dans un fichier docker-compose, un bind s'utilise de la manière suivante

# Déclaration d'un bind dans un service
nom_du_container:
	volumes:
	  - /chemin/vers/le/dossier/sur/l'hôte:/chemin/à/l'intérieur/du/container

Stacks

Lorsque vous lancez une application sur Docker, un container est créé. L'objectif d'un conteneur est le même que pour un serveur dédié virtuel : héberger des services sur un même serveur physique tout en les isolant les uns des autres. Un conteneur est cependant moins figé qu'une machine virtuelle en matière de taille de disque et de ressources allouées.

Une stack est une pile de containers, imaginez cela comme un porte-conteneurs. Une stack est un espace où l'on peut déclarer des containers, leur configuration, les ports qu'ils exposent vers votre réseau, l'image utilisée, les volumes utilisés, et chaque container peut communiquer avec n'importe quel autre container de la stack.

Prenons l'exemple d'une stack Wordpress :

version: "3.9"
    
services:
  db:
    image: mysql:5.7
    volumes:
      - db_data:/var/lib/mysql
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: somewordpress
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: wordpress
    
  wordpress:
    depends_on:
      - db
    image: wordpress:latest
    volumes:
      - wordpress_data:/var/www/html
    ports:
      - "8000:80"
    restart: always
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: wordpress
      WORDPRESS_DB_NAME: wordpress
volumes:
  db_data: {}
  wordpress_data: {}
Notes:

Au sein de cette stack, plusieurs services sont présents : db et wordpress.

Par défaut, wordpress est le seul service à pouvoir communiquer avec db, car vous pouvez remarquer que db n'a aucune déclaration de ports, seul wordpress est aussi accessible depuis votre réseau.

Nginx Proxy Manager

Installation

Nginx Proxy Manager est un service qui permet de créer des proxys Nginx. Pour l'expliquer de manière simple, si vous avez des services qui utilisent un port spécifique, par exemple 8080, et que vous voulez y accéder depuis internet, un proxy permet de créer une redirection depuis un nom de domaine vers une ip et un port, exemple :

portainer.example.xyz redirige vers le container Portainer, disponible sur 127.0.0.1:9000

Cela permet sur un serveur de faire tourner de nombreuses applications et sites web, avec plusieurs domaines, sans conflit au niveau des ports, et sans devoir taper dans la barre d'adresse le port manuellement. De plus, la force de Nginx Proxy Manager est qu'il est capable de générer des certificats Let's Encrypt et donc passer vos applications en HTTPS !

Pour installer Nginx Proxy Manager, rendez-vous sur le site officiel et copiez la stack docker-compose, puis collez-là dans Portainer (dans l'onglet stacks), vous devriez avoir quelque chose qui ressemble à ça

version: '3'
services:
  app:
    image: 'jc21/nginx-proxy-manager:latest'
    restart: unless-stopped
    ports:
      - '80:80'
      - '81:81'
      - '443:443'
    environment:
      DB_MYSQL_HOST: "db"
      DB_MYSQL_PORT: 3306
      DB_MYSQL_USER: "npm"
      DB_MYSQL_PASSWORD: "npm"
      DB_MYSQL_NAME: "npm"
    volumes:
      - ./data:/data
      - ./letsencrypt:/etc/letsencrypt
  db:
    image: 'jc21/mariadb-aria:latest'
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: 'npm'
      MYSQL_DATABASE: 'npm'
      MYSQL_USER: 'npm'
      MYSQL_PASSWORD: 'npm'
    volumes:
      - ./data/mysql:/var/lib/mysql

Vous pouvez modifier les mots de passe, qui ici sont "npm" par défaut pour plus de sécurité. Ici, les ports 80, 81 et 443 sont exposés afin de les rendre accessibles via votre réseau (et depuis l'extérieur si vous ouvrez les ports de votre box).

Utilisation

Pour publier un service à l'extérieur de votre réseau, rendez-vous sur l'interface de Nginx Proxy Manager (par défaut url_de_votre_serveur:81)

En haut, cliquez sur "Hosts" puis "Proxy Hosts", vous arriverez sur la page suivante

Pour ajouter un nouveau host, cliquez sur "Add Proxy Host"

Remplissez ensuite les différentes informations demandées, comme ceci

Paramètres

Une fois le proxy configuré, cliquez sur "Save", puis rendez-vous sur le panel d'administration de votre nom de domaine pour créer une redirection en A vers votre IP Externe vous pouvez la trouver sur ce site WhatsMyIp

Voilà, votre application est accessible depuis l'extérieur !

Mise à jour automatique des images

Par défaut, Docker ne gère pas les mises à jour des images de manière automatique.

Pour cela, il faut utiliser un service dédié, nous allons voir comment utiliser un de ces services.

Watchtower

Watchtower est une image docker qui s'occupe de surveiller tous les containers que vous lui indiquez afin de vérifier que leur image est bien la dernière disponible.

Pour installer Watchtower, créez une nouvelle stack avec le nom de votre choix, et copiez-collez ce docker-compose

services:
  watchtower:
    container_name: watchtower
    hostname: watchtower
    image: containrrr/watchtower:latest
    restart: always
    environment:
      TZ: "Europe/Paris"
      WATCHTOWER_CLEANUP: "true"
      WATCHTOWER_DEBUG: "false"
      WATCHTOWER_LABEL_ENABLE: "true"
      WATCHTOWER_POLL_INTERVAL: 3600
      WATCHTOWER_ROLLING_RESTART: "true"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock

La configuration que je vous fournis vérifie les containers toutes les heures, supprime les anciennes images après qu'elles aient été mises à jour, et redémarre les containers un à un.

Les différentes variables d'environnement sont disponibles ici

Pour que Watchtower surveille un container, il faut ajouter le label suivant dans le docker-compose qui contient ce container :

nom_du_service:
	labels:
	      - "com.centurylinklabs.watchtower.enable=true"

Watchtower est même capable de vous envoyer une notification lorsqu'il met à jour une image, la documentation explique comment faire ici