În contextul Docker Swarm, nu mai există o singură gazdă, ci multiple noduri conectate în rețea. Acest lucru face ca folosirea volumelor locale să nu fie recomandată, deoarce orchestrarea unui task pe un nod care nu are volumul cerut de container va rezulta în respingerea acelui task.

Există două posibilități principale de rezolvare a acestei probleme. Prima variantă presupune constrângerea unor servicii astfel încât să ruleze doar pe noduri manager, astfel:

services:
    example:
        deploy:
            placement:
                constraints: [node.role == manager]

Această practică este utilă doar atunci când există un singur nod manager și astfel suntem siguri că taskurile ale căror containere au nevoie de volumele definite în configurație vor rula doar pe managerul unde exista volumele.

În cazul în care există mai multe noduri manager și dorim, de exemplu, să rulăm o bază de date într-un serviciu, dacă aceasta va fi orchestrată să ruleze pe alt nod față de cel pe care a fost prima oară orchestrată, nu va mai avea acces la volumul unde a stocat date inițial. În acest caz, va crea un volum nou pe noul nod, ajungându-se astfel la inconsistență.

Cea de-a doua variantă pentru a rezolva problema descrisă mai sus este configurarea volumelor astfel încât să folosească un sistem de stocare extern (cum ar fi NFS, GlusterFS, Samba, Amazon S3, etc).

Cea mai facilă metodă de a adăuga stocare externă în Docker este prin intermediul NFS (Network File System). Pentru aceasta, este în primul rând nevoie de existența unui server NFS, care poate fi rulat fie nativ (pe una din mașinile din cluster-ul Docker sau undeva în exterior), fie prin intermediul unui container Docker. Există multiple soluții de rulare a unui server NFS folosind Docker, însă noi vă recomandăm această soluție populară bazată pe Alpine Linux.

Soluția de mai sus reprezintă un container care rulează în mod privilegiat, având acces la resursele gazdei. Înainte să rulați containerul, trebuie să vă creați un director ce va fi partajat în rețea prin intermediul NFS.

Dupa ce s-a creat directorul ce va reține datele partajate în rețea, se execută comanda de mai jos pentru pornirea serverului de NFS și exportul directorului partajat:

$ docker run -d --name nfs --privileged -v /cale/director/partajat:/nfsshare \
      -e SHARED_DIRECTORY=/nfsshare itsthenetwork/nfs-server-alpine:latest

Odată ce serverul NFS a fost pornit, se pot crea volume peste NFS în mai multe moduri. O variantă este crearea de volume prin intermediul API-ului din linia de comandă. Astfel, dacă se dorește crearea unui volum numit mynfsvol, care apoi poate fi atașat la alte containere sau servicii, se poate executa următoarea comandă:

$ docker volume create --driver local --opt type=nfs --opt o=nfsvers=3,addr=192.168.99.1,rw --opt device=:/nfsshare mynfsvol

În comanda de mai sus, IP-ul serverului NFS este 192.168.99.1 și se folosește versiunea 3 de NFS. Se poate inspecta volumul nou-creat pentru a se observa caracteristicile sale:

$ docker volume inspect mynfsvol
[
    {
        "CreatedAt": "2021-03-31T17:26:11Z",
        "Driver": "local",
        "Labels": {},
        "Mountpoint": "/mnt/sda1/var/lib/docker/volumes/mynfsvol/_data",
        "Name": "mynfsvol",
        "Options": {
            "device": ":/nfsshare",
            "o": "nfsvers=3,addr=192.168.99.1,rw",
            "type": "nfs"
        },
        "Scope": "local"
    }
]

Un astfel de volum extern poate fi dat ca parametru la pornirea unui container din linia de comandă, astfel:

$ docker run -v mynfsvol:/test -it alpine

În comanda de mai sus, se mapează volumul NFS la calea /test din interiorul containerului. Acest lucru se poate face simultan pe mai multe containere de pe mașini diferite, toate având aceeași mapare și deci acces la aceleași fișiere.

Putem folosi un volum creat în linia de comandă chiar într-un fișier de Docker Compose, fie la rularea locală, fie la rularea folosind Docker Swarm. Pentru acest lucru, este nevoie de câteva modificări în configurația volumelor din cadrul fișierelor YAML. Ca exemplu, presupunem că avem un serviciu de bază de date care are nevoie de volume pentru scriptul de configurație și pentru persistența datelor (pe modelul temelor de casă din laboratoarele precedente):

services:
    db:
        image: postgres:12
        volumes:
            - db-data-nfs:/var/lib/postgresql/data
            - db-config-nfs:/docker-entrypoint-initdb.d

volumes:
    db-data-nfs:
        external: true
    db-config-nfs:
        external: true

În exemplul de mai sus, se presupune că volumele db-data-nfs și db-config-nfs au fost create în prealabil folosind comenzile prezentate anterior. Este totuși posibil să se creeze volumele direct în fișierul Docker Compose, așa cum s-a prezentat și în laboratoarele precedente. În acest caz, volumele nu vor mai fi declarate ca fiind externe, ci trebuie configurate pentru a funcționa peste NFS, astfel:

volumes:
    db-data-nfs:
        driver: local
        driver_opts:
           type: nfs
           o: "nfsvers=3,addr=192.168.99.1,nolock,soft,rw"
           device: :/database/data
    db-config-nfs:
        driver: local
        driver_opts:
           type: nfs
           o: "nfsvers=3,addr=192.168.99.1,nolock,soft,rw"
           device: :/database/config

În exemplul de mai sus, s-a folosit același IP pentru serverul NFS (192.168.99.1), iar directoarele /database/data și /database/config trebuie să existe în interiorul directorului partajat de gazda containerului de server NFS (/cale/director/partajat din exemplul de pornire a serverului NFS).

Laboratorul se va desfasura, din nou, pe Play With Docker si va avea suport de cod repo-ul din laboratorul precedent, peste care am mai adaugat 2 fisiere .yml in plus (stack-nfs.yml si stack-kong.yml).

TODO