Comment Docker Swarm met-il en œuvre le partage de volume?

Docker Swarm peut gérer deux types de stockage:

volume et bind

Bien que la binddocumentation Docker ne soit pas suggérée car elle crée une liaison entre un répertoire local (sur chaque nœud swarm) et une tâche, l' volumeimplémentation n'est pas mentionnée, donc je ne comprends pas comment les volumes sont partagés entre les tâches?

• Comment Docker Swarm partage-t-il les volumes entre les nœuds?
• Où sont enregistrés les volumes (sur un gestionnaire? Et s'il y a plus d'un gestionnaire?)
• N'y a-t-il pas de problème entre les nœuds s'il s'exécute sur différentes machines sur différents réseaux?
• Crée-t-il un VPN?

Ce que vous demandez est une question courante. Les données de volume et les fonctionnalités de ce que ce volume peut faire sont gérées par un pilote de volume. Tout comme vous pouvez utiliser différents pilotes de réseau comme overlay, bridgeou host, vous pouvez utiliser des pilotes de volume différents.

Docker et Swarm sont uniquement livrés avec le localpilote standard prêt à l'emploi. Il n'a aucune connaissance de Swarm et crée simplement de nouveaux volumes pour vos données sur le nœud sur lequel vos tâches de service sont planifiées. Ce n'est généralement pas ce que vous voulez.

Vous voulez un plug-in de pilote tiers compatible Swarm, et vous assurerez que le volume que vous avez créé pour une tâche de service est disponible sur le bon nœud au bon moment. Les options incluent l'utilisation de «Docker for AWS / Azure» et de son pilote CloudStor inclus , ou de la solution populaire REX-Ray open source .

Il existe de nombreux pilotes de volume tiers, que vous pouvez trouver sur le Docker Store .

Le mode Swarm lui-même ne fait rien de différent avec les volumes, il exécute toute commande de montage de volume que vous fournissez sur le nœud sur lequel le conteneur est exécuté. Si votre montage de volume est local sur ce nœud, vos données seront enregistrées localement sur ce nœud. Il n'y a pas de fonctionnalité intégrée pour déplacer automatiquement les données entre les nœuds.

Il existe des solutions de stockage distribué basées sur des logiciels comme GlusterFS, et Docker en a une appelée Infinit qui n'est pas encore GA et le développement sur qui a pris un siège arrière à l'intégration de Kubernetes dans EE.

Le résultat typique est que vous devez soit gérer la réplication du stockage dans votre application (par exemple, etcd et d'autres algorithmes basés sur des radeaux), soit vous effectuez vos montages sur un système de stockage externe (avec un peu de chance avec son propre HA). Le montage d'un système de stockage externe comporte deux options, basées sur des blocs ou des fichiers. Le stockage basé sur des blocs (par exemple EBS) offre généralement des performances plus élevées, mais il est limité à être monté sur un seul nœud. Pour cela, vous aurez généralement besoin d'un pilote de plug-in de volume tiers pour donner à votre nœud docker l'accès à ce stockage de bloc. Le stockage basé sur des fichiers (par exemple, EFS) a des performances inférieures, mais est plus portable et peut être monté simultanément sur plusieurs nœuds, ce qui est utile pour un service répliqué.

Le stockage réseau basé sur des fichiers le plus courant est NFS (il s'agit du même protocole utilisé par EFS). Et vous pouvez monter cela sans aucun pilote de plugin tiers. Le pilote de plug-in de volume "local" malheureusement nommé qui est livré avec docker vous donne la possibilité de passer toutes les valeurs que vous voulez à la commande de montage avec les options du pilote, et sans option, il stocke par défaut les volumes dans le répertoire docker / var / lib / docker / volumes. Avec les options, vous pouvez lui transmettre les paramètres NFS, et il effectuera même une recherche DNS sur le nom d'hôte NFS (ce que vous n'avez normalement pas avec NFS). Voici un exemple des différentes manières de monter un système de fichiers NFS à l'aide du pilote de volume local:

  # create a reusable volume
  $ docker volume create --driver local \
      --opt type=nfs \
      --opt o=nfsvers=4,addr=192.168.1.1,rw \
      --opt device=:/path/to/dir \
      foo

  # or from the docker run command
  $ docker run -it --rm \
    --mount type=volume,dst=/container/path,volume-driver=local,volume-opt=type=nfs,\"volume-opt=o=nfsvers=4,addr=192.168.1.1\",volume-opt=device=:/host/path \
    foo

  # or to create a service
  $ docker service create \
    --mount type=volume,dst=/container/path,volume-driver=local,volume-opt=type=nfs,\"volume-opt=o=nfsvers=4,addr=192.168.1.1\",volume-opt=device=:/host/path \
    foo

  # inside a docker-compose file
  ...
  volumes:
    nfs-data:
      driver: local
      driver_opts:
        type: nfs
        o: nfsvers=4,addr=192.168.1.1,rw
        device: ":/path/to/dir"
  ...

Si vous utilisez l'exemple de fichier de composition à la fin, notez que les modifications apportées à un volume (par exemple, la mise à jour du chemin ou de l'adresse du serveur) ne sont pas reflétées dans les volumes nommés existants tant qu'ils existent. Vous devez renommer votre volume ou le supprimer pour permettre à swarm de le recréer avec de nouvelles valeurs.

L'autre problème courant que je vois dans la plupart des utilisations de NFS est l'activation du "root squash" sur le serveur. Cela entraîne des problèmes d'autorisation lorsque des conteneurs exécutés en tant que root tentent d'écrire des fichiers sur le volume. Vous avez également des problèmes d'autorisations UID / GID similaires où l'UID / GID du conteneur est celui qui a besoin d'autorisations pour écrire sur le volume, ce qui peut nécessiter la propriété du répertoire et des autorisations ajustées sur le serveur NFS.

Ma solution pour AWS EFS, qui fonctionne:

1. Créez EFS (n'oubliez pas d'ouvrir le port NFS 2049 au groupe de sécurité)

2. Installez le package nfs-common:

   sudo apt-get install -y nfs-common

3. Vérifiez si votre efs fonctionne:

   mkdir efs-test-point
   sudo chmod go + rw efs-test-point

   sudo mount -t nfs -o nfsvers = 4.1, rsize = 1048576, wsize = 1048576, hard, timeo = 600, retrans = 2, noresvport [YOUR_EFS_DNS]: / efs-test-point

   touchez efs-test-point / 1.txt
   sudo umount efs-test-point /
   ls -la efs-test-point /

   le répertoire doit être vide

   sudo mount -t nfs -o nfsvers = 4.1, rsize = 1048576, wsize = 1048576, hard, timeo = 600, retrans = 2, noresvport [YOUR_EFS_DNS]: / efs-test-point

   ls -la efs-test-point/

   le fichier 1.txt doit exister

4. Configurez le fichier docker-compose.yml:

   prestations de service:
     sidekiq:
       volumes:
         - uploads_tmp_efs: / home / application / public / uploads / tmp
     ...
   volumes:
     uploads_tmp_efs:
       pilote: local
       driver_opts:
         type: nfs
         o: addr = [YOUR_EFS_DNS], nfsvers = 4.1, rsize = 1048576, wsize = 1048576, hard, timeo = 600, retrans = 2
         appareil: [YOUR_EFS_DNS]: /

Ma solution pour notre swarm hébergé localement: chaque nœud worker a monté un partage nfs, fourni par notre serveur de fichiers sur /mnt/docker-data. Lorsque je définis des volumes dans mes services pour composer des fichiers, je définis le périphérique sur un chemin sous /mnt/docker-data, par exemple:

volumes:
  traefik-logs:
    driver: local
    driver_opts:
      o: bind
      device: /mnt/docker-data/services/traefik/logs
      type: none

Avec cette solution, docker crée le volume sur chaque nœud, le service est déployé sur et - surprise - il y a déjà des données, car c'est le même chemin, qui a été utilisé par le volume sur l'autre nœud.

Si vous regardez de plus près le système de fichiers des nœuds, vous voyez que les montages sur mon serveur de fichiers sont créés sous /var/lib/docker/volumes, voir ici:

root@node-3:~# df -h
Dateisystem                                                                                                   Größe Benutzt Verf. Verw% Eingehängt auf
[...]
fs.mydomain.com:/srv/shares/docker-data/services/traefik/logs                                 194G    141G   53G   73% /var/lib/docker/volumes/traefik_traefik-logs/_data