Docker i sve, sve, sve

TL;DR: vodič koji uspoređuje okruženja za pokretanje aplikacija unutar kontejnera. Razmotrit će se mogućnosti Docker-a i drugih sličnih sustava.

Docker i sve, sve, sve

Malo povijesti, odakle je sve to počelo

Povijest

Prvi opće poznati način izolacije aplikacije je chroot. Isti sustavni poziv omogućava promjenu korijenske mape - na taj način programu koji ga pozove daje pristup samo datotekama unutar te mape. No, ako se programu unutar dodijele administratorska prava, potencijalno može "pobjeći" iz chroot-a i dobiti pristup osnovnom operacijskom sustavu. Također, osim promjene korijenske mape, druge resurse (operativna memorija, procesor) i pristup mreži nikako nije moguće ograničiti.

Sljedeći način je pokretanje punog operacijskog sustava unutar kontejnera, uz pomoć mehanizama jezgre operacijskog sustava. U raznim operacijskim sustavima ovaj način nazivaju različito, no suština je ista - pokretanje više neovisnih operacijskih sustava, od kojih svaki radi s istom jezgrom na kojoj radi i osnovni operacijski sustav. Ovdje se ubrajaju FreeBSD Jails, Solaris Zones, OpenVZ i LXC za Linux. Osigurava se izolacija ne samo po disku, već i drugim resursima; tako svaki kontejner može imati ograničenja po procesorskom vremenu, operativnoj memoriji i propusnosti mreže. U usporedbi s chroot-om, izlazak iz kontejnera je teži, budući da administrator u kontejneru ima pristup samo unutrašnjosti kontejnera, no zbog potrebe da se operacijski sustav unutar kontejnera drži ažurnim i korištenja starih verzija jezgra (što je važno za Linux, a manje za FreeBSD) postoji određena vjerojatnost 'probijanja' sustava izolacije jezgre i dobivanja pristupa osnovnom operacijskom sustavu.

Umjesto pokretanja pune operativne sistemske instance unutar kontejnera (sa sistemom inicijalizacije, upraviteljem paketa itd.), aplikacije se mogu pokretati odmah; važno je osigurati aplikacijama potrebne resurse (dostupne biblioteke i ostale datoteke). Ova ideja je bila osnova za kontejnersku virtualizaciju aplikacija, čiji je najpoznatiji predstavnik Docker. U usporedbi s prethodnim sistemima, fleksibilniji mehanizmi izolacije zajedno s ugrađenom podrškom za virtualne mreže između kontejnera i praćenje stanja aplikacije unutar kontejnera omogućili su izgradnju jedinstvenog okruženja od velikog broja fizičkih servera za pokretanje kontejnera — bez potrebe za ručnim upravljanjem resursima.

Docker

Docker je najpoznatiji softver za kontejnerizaciju aplikacija. Napisan je na programskom jeziku Go, koristi standardne mogućnosti Linux jezgre — cgroups, namespaces, capabilities itd., kao i datotečne sisteme poput Aufs i druge slične za uštedu diskovnog prostora.

Docker i sve, sve, sve
Izvor: wikimedia

Arhitektura

Do verzije 1.11 Docker je radio kao jedinstvena usluga koja je obavljala sve operacije s kontejnerima: preuzimanje slika kontejnera, pokretanje kontejnera, obrada API zahtjeva. Počevši od verzije 1.11, Docker je razdvojen na nekoliko delova koji međusobno komuniciraju: containerd, koji upravlja celokupnim životnim ciklusom kontejnera (dodeljivanje diskovnog prostora, preuzimanje slika, upravljanje mrežom, pokretanje, instalacija i praćenje stanja kontejnera) i runC, okruženje za izvršavanje kontejnera koje se oslanja na cgroups i druge mogućnosti Linux jezgre. Sama usluga Docker ostala je, ali sada služi samo za obradu API zahtjeva koji se prevode u containerd.

Docker i sve, sve, sve

Instalacija i postavljanje

Moj omiljeni način instalacije Dockera je docker-machine, koji osim direktne instalacije i podešavanja Dockera na udaljenim serverima (uključujući različite oblake) omogućava rad s datotečnim sistemima udaljenih servera, kao i pokretanje raznih komandi.

Međutim, od 2018. godine projekt se gotovo ne razvija, pa ćemo instalaciju izvršiti standardno za većinu Linux distribucija — dodavanjem repozitorija i instalacijom potrebnih paketa.

Ova metoda se također primjenjuje i prilikom automatizirane instalacije, primjerice uz pomoć Ansibla ili drugih sličnih sustava, ali je u ovom članku neću razmatrati.

Instalacija će se izvoditi na CentOS 7, a kao server ću koristiti virtualnu mašinu. Za instalaciju je dovoljno izvršiti dolje navedene komande:

# yum install -y yum-utils
# yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
# yum install docker-ce docker-ce-cli containerd.io

Nakon instalacije potrebno je pokrenuti servis i postaviti ga da se automatski pokreće:

# systemctl enable docker
# systemctl start docker
# firewall-cmd --zone=public --add-port=2377/tcp --permanent

Dodatno, možete stvoriti grupu docker, čiji korisnici mogu raditi s docker bez sudo, postaviti logiranje, omogućiti pristup API-ju izvana, ne zaboravite preciznije postaviti firewall (sve što nije dopušteno je zabranjeno, u primjerima iznad i ispod — ovo sam izostavio radi jednostavnosti i preglednosti), ali se ovdje neću detaljnije zadržavati.

Druge mogućnosti

Osim spomenutih docker machine, postoji i docker registry, alat za pohranu slika za kontejnere, kao i docker compose — alat za automatizaciju implementacije aplikacija u kontejnerima, koristeći YAML datoteke za izgradnju i konfiguraciju kontejnera i drugih povezanih stvari (poput mreža, trajnih datotečnih sustava za pohranu podataka).

Također, pomoću njega možete organizirati cijevi za CICD. Druga zanimljiva mogućnost je rad u klasterskom načinu, tzv. swarm mode (do verzije 1.12 bio je poznat kao docker swarm), koji omogućuje stvaranje jedinstvene infrastrukture za pokretanje kontejnera od više servera. Pruža podršku za virtualnu mrežu iznad svih servera, uključuje ugrađeni balansirnik opterećenja, kao i podršku za tajne za kontejnere.

YAML datoteke iz docker compose s malim promjenama mogu se koristiti za takve klastere, potpuno automatizirajući održavanje malih i srednjih klastera za različite svrhe. Za velike klastere, poželjno je koristiti Kubernetes, jer troškovi održavanja swarm mode-a mogu nadmašiti one za Kubernetes. Osim runC, za izvršno okruženje kontejnera može se instalirati, na primjer, Kata containers

Rad s Dockerom

Nakon instalacije i postavke, pokušat ćemo sastaviti klaster u kojem ćemo postaviti GitLab i Docker Registry za tim programera. Kao poslužitelje koristit ću tri virtualne mašine, na kojima ću dodatno razmjestiti distribuirani sustav datoteka GlusterFS, koji ću koristiti kao pohranu za docker volumen, na primjer za pokretanje otporne verzije docker registry. Ključne komponente za pokretanje: Docker Registry, Postgresql, Redis, GitLab s podrškom za GitLab Runner kroz Swarm. Postgresql ćemo pokretati s klasterizacijom. Stolon, stoga za pohranu podataka Postgresql ne treba koristiti GlusterFS. Ostali kritični podaci bit će pohranjeni na GlusterFS.

Za razmještanje GlusterFS na svim poslužiteljima (koji se nazivaju node1, node2, node3) potrebno je instalirati pakete, omogućiti rad vatrozida, stvoriti potrebne direktorije:

# yum -y install centos-release-gluster7
# yum -y install glusterfs-server
# systemctl enable glusterd
# systemctl start glusterd
# firewall-cmd --add-service=glusterfs --permanent
# firewall-cmd --reload
# mkdir -p /srv/gluster
# mkdir -p /srv/docker
# echo "$(hostname):/docker /srv/docker glusterfs defaults,_netdev 0 0" >> /etc/fstab

Nakon instalacije rad na konfiguraciji GlusterFS treba nastaviti s jednog čvora, na primjer node1:

# gluster peer probe node2
# gluster peer probe node3
# gluster volume create docker replica 3 node1:/srv/gluster node2:/srv/gluster node3:/srv/gluster force
# gluster volume start docker

Zatim treba montirati dobiveni volumen (komandu treba izvesti na svim poslužiteljima):

# mount /srv/docker

Postavka swarm moda odvija se na jednom od poslužitelja, koji će biti lider, ostali se trebaju pridružiti klasteru, stoga treba kopirati rezultat izvođenja komande na prvom poslužitelju i izvesti na ostalima.

Prvotna postavka klastera, pokrećem komandu na node1:

# docker swarm init
Swarm initialized: current node (a5jpfrh5uvo7svzz1ajduokyq) is now a manager.

To add a worker to this swarm, run the following command:

    docker swarm join --token SWMTKN-1-0c5mf7mvzc7o7vjk0wngno2dy70xs95tovfxbv4tqt9280toku-863hyosdlzvd76trfptd4xnzd xx.xx.xx.xx:2377

To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.
# docker swarm join-token manager

Kopiramo rezultat druge komande, izvodimo na node2 i node3:

# docker swarm join --token SWMTKN-x-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-xxxxxxxxx xx.xx.xx.xx:2377
This node joined a swarm as a manager.

Time je preliminarna postavka poslužitelja završena, prelazimo na postavu servisa, komande za izvođenje će se pokretati s node1, osim ako nije drugačije navedeno.

Prvo ćemo stvoriti mreže za kontejnere:

# docker network create --driver=overlay etcd
# docker network create --driver=overlay pgsql
# docker network create --driver=overlay redis
# docker network create --driver=overlay traefik
# docker network create --driver=overlay gitlab

Zatim označavamo poslužitelje, to je potrebno za vezivanje nekih servisa uz poslužitelje:

# docker node update --label-add nodename=node1 node1
# docker node update --label-add nodename=node2 node2
# docker node update --label-add nodename=node3 node3

Sljedeće stvaramo direktorije za pohranu podataka etcd, KV-skladišta koje je potrebno za Traefik i Stolon. Slično Postgresql, ovo će biti vezani kontejneri uz poslužitelje, stoga ovu komandu izvodimo na svim poslužiteljima:

# mkdir -p /srv/etcd

Zatim stvaramo datoteku za postavku etcd i primjenjujemo je:

00etcd.yml

verzija: '3.7'

usluge:
  etcd1:
    slika: quay.io/coreos/etcd:latest
    naziv: etcd1
    komanda:
      - etcd
      - --name=etcd1
      - --data-dir=/data.etcd
      - --advertise-client-urls=http://etcd1:2379
      - --listen-client-urls=http://0.0.0.0:2379
      - --initial-advertise-peer-urls=http://etcd1:2380
      - --listen-peer-urls=http://0.0.0.0:2380
      - --initial-cluster=etcd1=http://etcd1:2380,etcd2=http://etcd2:2380,etcd3=http://etcd3:2380
      - --initial-cluster-state=new
      - --initial-cluster-token=etcd-cluster
    mreže:
      - etcd
    volumeni:
      - etcd1vol:/data.etcd
    raspored:
      replikati: 1
      pozicija:
        ograničenja: [node.labels.nodename == node1]
  etcd2:
    slika: quay.io/coreos/etcd:latest
    naziv: etcd2
    komanda:
      - etcd
      - --name=etcd2
      - --data-dir=/data.etcd
      - --advertise-client-urls=http://etcd2:2379
      - --listen-client-urls=http://0.0.0.0:2379
      - --initial-advertise-peer-urls=http://etcd2:2380
      - --listen-peer-urls=http://0.0.0.0:2380
      - --initial-cluster=etcd1=http://etcd1:2380,etcd2=http://etcd2:2380,etcd3=http://etcd3:2380
      - --initial-cluster-state=new
      - --initial-cluster-token=etcd-cluster
    mreže:
      - etcd
    volumeni:
      - etcd2vol:/data.etcd
    raspored:
      replikati: 1
      pozicija:
        ograničenja: [node.labels.nodename == node2]
  etcd3:
    slika: quay.io/coreos/etcd:latest
    naziv: etcd3
    komanda:
      - etcd
      - --name=etcd3
      - --data-dir=/data.etcd
      - --advertise-client-urls=http://etcd3:2379
      - --listen-client-urls=http://0.0.0.0:2379
      - --initial-advertise-peer-urls=http://etcd3:2380
      - --listen-peer-urls=http://0.0.0.0:2380
      - --initial-cluster=etcd1=http://etcd1:2380,etcd2=http://etcd2:2380,etcd3=http://etcd3:2380
      - --initial-cluster-state=new
      - --initial-cluster-token=etcd-cluster
    mreže:
      - etcd
    volumeni:
      - etcd3vol:/data.etcd
    raspored:
      replikati: 1
      pozicija:
        ograničenja: [node.labels.nodename == node3]

volumeni:
  etcd1vol:
    vozač: lokalni
    opcije_vozača:
      tip: none
      o: bind
      uređaj: "/srv/etcd"
  etcd2vol:
    vozač: lokalni
    opcije_vozača:
      tip: none
      o: bind
      uređaj: "/srv/etcd"
  etcd3vol:
    vozač: lokalni
    opcije_vozača:
      tip: none
      o: bind
      uređaj: "/srv/etcd"

mreže:
  etcd:
    spoljašnje: true

# docker stack deploy --compose-file 00etcd.yml etcd

Nakon nekog vremena provjeravamo da li je etcd klaster podignut:

# docker exec $(docker ps | awk '/etcd/ {print $1}')  etcdctl member list
ade526d28b1f92f7: name=etcd1 peerURLs=http://etcd1:2380 clientURLs=http://etcd1:2379 isLeader=false
bd388e7810915853: name=etcd3 peerURLs=http://etcd3:2380 clientURLs=http://etcd3:2379 isLeader=false
d282ac2ce600c1ce: name=etcd2 peerURLs=http://etcd2:2380 clientURLs=http://etcd2:2379 isLeader=true
# docker exec $(docker ps | awk '/etcd/ {print $1}')  etcdctl cluster-health
member ade526d28b1f92f7 is healthy: got healthy result from http://etcd1:2379
member bd388e7810915853 is healthy: got healthy result from http://etcd3:2379
member d282ac2ce600c1ce is healthy: got healthy result from http://etcd2:2379
cluster is healthy

Kreiramo direktorije za Postgresql, komandu izvršavamo na svim serverima:

# mkdir -p /srv/pgsql

Zatim kreiramo datoteku za podešavanje Postgresql:

01pgsql.yml

verzija: '3.7'

usluge:
  pgsentinel:
    slika: sorintlab/stolon:master-pg10
    naredba:
      - gosu
      - stolon
      - stolon-sentinel
      - --ime-klastera=stolon-cluster
      - --store-backend=etcdv3
      - --store-endpoints=http://etcd1:2379,http://etcd2:2379,http://etcd3:2379
      - --log-level=debug
    mreže:
      - etcd
      - pgsql
    implementacija:
      replikati: 3
      konfiguracija_azuriranja:
        paralelnost: 1
        kašnjenje: 30s
        redoslijed: stop-first
        akcija_u_slucaju_greške: pauza
  pgkeeper1:
    slika: sorintlab/stolon:master-pg10
    naziv_domaćina: pgkeeper1
    naredba:
      - gosu
      - stolon
      - stolon-keeper
      - --pg-listen-address=pgkeeper1
      - --pg-repl-username=replica
      - --uid=pgkeeper1
      - --pg-su-username=postgres
      - --pg-su-passwordfile=/run/secrets/pgsql
      - --pg-repl-passwordfile=/run/secrets/pgsql_repl
      - --data-dir=/var/lib/postgresql/data
      - --ime-klastera=stolon-cluster
      - --store-backend=etcdv3
      - --store-endpoints=http://etcd1:2379,http://etcd2:2379,http://etcd3:2379
    mreže:
      - etcd
      - pgsql
    okruženje:
      - PGDATA=/var/lib/postgresql/data
    volumeni:
      - pgkeeper1:/var/lib/postgresql/data
    tajne:
      - pgsql
      - pgsql_repl
    implementacija:
      replikati: 1
      raspored:
        ograničenja: [node.labels.nodename == node1]
  pgkeeper2:
    slika: sorintlab/stolon:master-pg10
    naziv_domaćina: pgkeeper2
    naredba:
      - gosu
      - stolon 
      - stolon-keeper
      - --pg-listen-address=pgkeeper2
      - --pg-repl-username=replica
      - --uid=pgkeeper2
      - --pg-su-username=postgres
      - --pg-su-passwordfile=/run/secrets/pgsql
      - --pg-repl-passwordfile=/run/secrets/pgsql_repl
      - --data-dir=/var/lib/postgresql/data
      - --ime-klastera=stolon-cluster
      - --store-backend=etcdv3
      - --store-endpoints=http://etcd1:2379,http://etcd2:2379,http://etcd3:2379
    mreže:
      - etcd
      - pgsql
    okruženje:
      - PGDATA=/var/lib/postgresql/data
    volumeni:
      - pgkeeper2:/var/lib/postgresql/data
    tajne:
      - pgsql
      - pgsql_repl
    implementacija:
      replikati: 1
      raspored:
        ograničenja: [node.labels.nodename == node2]
  pgkeeper3:
    slika: sorintlab/stolon:master-pg10
    naziv_domaćina: pgkeeper3
    naredba:
      - gosu
      - stolon 
      - stolon-keeper
      - --pg-listen-address=pgkeeper3
      - --pg-repl-username=replica
      - --uid=pgkeeper3
      - --pg-su-username=postgres
      - --pg-su-passwordfile=/run/secrets/pgsql
      - --pg-repl-passwordfile=/run/secrets/pgsql_repl
      - --data-dir=/var/lib/postgresql/data
      - --ime-klastera=stolon-cluster
      - --store-backend=etcdv3
      - --store-endpoints=http://etcd1:2379,http://etcd2:2379,http://etcd3:2379
    mreže:
      - etcd
      - pgsql
    okruženje:
      - PGDATA=/var/lib/postgresql/data
    volumeni:
      - pgkeeper3:/var/lib/postgresql/data
    tajne:
      - pgsql
      - pgsql_repl
    implementacija:
      replikati: 1
      raspored:
        ograničenja: [node.labels.nodename == node3]
  postgresql:
    slika: sorintlab/stolon:master-pg10
    naredba: gosu stolon stolon-proxy --listen-address 0.0.0.0 --ime-klastera stolon-cluster --store-backend=etcdv3 --store-endpoints http://etcd1:2379,http://etcd2:2379,http://etcd3:2379
    mreže:
      - etcd
      - pgsql
    implementacija:
      replikati: 3
      konfiguracija_azuriranja:
        paralelnost: 1
        kašnjenje: 30s
        redoslijed: stop-first
        akcija_u_slucaju_greške: rollback

volumeni:
  pgkeeper1:
    vozač: local
    opcije_vozača:
      tip: none
      o: bind
      uređaj: "/srv/pgsql"
  pgkeeper2:
    vozač: local
    opcije_vozača:
      tip: none
      o: bind
      uređaj: "/srv/pgsql"
  pgkeeper3:
    vozač: local
    opcije_vozača:
      tip: none
      o: bind
      uređaj: "/srv/pgsql"

tajne:
  pgsql:
    datoteka: "/srv/docker/postgres"
  pgsql_repl:
    datoteka: "/srv/docker/replica"

mreže:
  etcd:
    vanjsko: true
  pgsql:
    vanjsko: true

Generiramo tajne, primjenjujemo datoteku:

# </dev/urandom tr -dc 234567890qwertyuopasdfghjkzxcvbnmQWERTYUPASDFGHKLZXCVBNM | head -c $(((RANDOM%3)+15)) > /srv/docker/replica
# </dev/urandom tr -dc 234567890qwertyuopasdfghjkzxcvbnmQWERTYUPASDFGHKLZXCVBNM | head -c $(((RANDOM%3)+15)) > /srv/docker/postgres
# docker stack deploy --compose-file 01pgsql.yml pgsql

Nakon nekog vremena (gledamo izlaz naredbe docker service ls, koji prikazuje da su svi servisi pokrenuti) inicijaliziramo PostgreSQL klaster:

# docker exec $(docker ps | awk '/pgkeeper/ {print $1}') stolonctl --cluster-name=stolon-cluster --store-backend=etcdv3 --store-endpoints=http://etcd1:2379,http://etcd2:2379,http://etcd3:2379 init

Provjeravamo spremnost PostgreSQL klastera:

# docker exec $(docker ps | awk '/pgkeeper/ {print $1}') stolonctl --cluster-name=stolon-cluster --store-backend=etcdv3 --store-endpoints=http://etcd1:2379,http://etcd2:2379,http://etcd3:2379 status
=== Active sentinels ===

ID      LEADER
26baa11d    false
74e98768    false
a8cb002b    true

=== Active proxies ===

ID
4d233826
9f562f3b
b0c79ff1

=== Keepers ===

UID     HEALTHY PG LISTENADDRESS    PG HEALTHY  PG WANTEDGENERATION PG CURRENTGENERATION
pgkeeper1   true    pgkeeper1:5432         true     2           2
pgkeeper2   true    pgkeeper2:5432          true            2                   2
pgkeeper3   true    pgkeeper3:5432          true            3                   3

=== Cluster Info ===

Master Keeper: pgkeeper3

===== Keepers/DB tree =====

pgkeeper3 (master)
├─pgkeeper2
└─pgkeeper1

Konfiguriramo Traefik za omogućavanje pristupa kontejnerima s vanjske strane:

03traefik.yml

version: '3.7'

services:
  traefik:
    image: traefik:latest
    command: >
      --log.level=INFO
      --providers.docker=true
      --entryPoints.web.address=:80
      --providers.providersThrottleDuration=2
      --providers.docker.watch=true
      --providers.docker.swarmMode=true
      --providers.docker.swarmModeRefreshSeconds=15s
      --providers.docker.exposedbydefault=false
      --accessLog.bufferingSize=0
      --api=true
      --api.dashboard=true
      --api.insecure=true
    networks:
      - traefik
    ports:
      - 80:80
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    deploy:
      replicas: 3
      placement:
        constraints:
          - node.role == manager
        preferences:
          - spread: node.id
      labels:
        - traefik.enable=true
        - traefik.http.routers.traefik.rule=Host(`traefik.example.com`)
        - traefik.http.services.traefik.loadbalancer.server.port=8080
        - traefik.docker.network=traefik

networks:
  traefik:
    external: true

# docker stack deploy --compose-file 03traefik.yml traefik

Pokrećemo Redis klaster, za to kreiramo direktorij za pohranu na svim čvorovima:

# mkdir -p /srv/redis

05redis.yml

version: '3.7'

services:
  redis-master:
    image: 'bitnami/redis:latest'
    networks:
      - redis
    ports:
      - '6379:6379'
    environment:
      - REDIS_REPLICATION_MODE=master
      - REDIS_PASSWORD=xxxxxxxxxxx
    deploy:
      mode: global
      restart_policy:
        condition: any
    volumes:
      - 'redis:/opt/bitnami/redis/etc/'

  redis-replica:
    image: 'bitnami/redis:latest'
    networks:
      - redis
    ports:
      - '6379'
    depends_on:
      - redis-master
    environment:
      - REDIS_REPLICATION_MODE=slave
      - REDIS_MASTER_HOST=redis-master
      - REDIS_MASTER_PORT_NUMBER=6379
      - REDIS_MASTER_PASSWORD=xxxxxxxxxxx
      - REDIS_PASSWORD=xxxxxxxxxxx
    deploy:
      mode: replicated
      replicas: 3
      update_config:
        parallelism: 1
        delay: 10s
      restart_policy:
        condition: any

  redis-sentinel:
    image: 'bitnami/redis:latest'
    networks:
      - redis
    ports:
      - '16379'
    depends_on:
      - redis-master
      - redis-replica
    entrypoint: |
      bash -c 'bash -s <<EOF
      "/bin/bash" -c "cat < /opt/bitnami/redis/etc/sentinel.conf
      port 16379
      dir /tmp
      sentinel monitor master-node redis-master 6379 2
      sentinel down-after-milliseconds master-node 5000
      sentinel parallel-syncs master-node 1
      sentinel failover-timeout master-node 5000
      sentinel auth-pass master-node xxxxxxxxxxx
      sentinel announce-ip redis-sentinel
      sentinel announce-port 16379
      EOF"
      "/bin/bash" -c "redis-sentinel /opt/bitnami/redis/etc/sentinel.conf"
      EOF'
    deploy:
      mode: global
      restart_policy:
        condition: any

volumes:
  redis:
    driver: local
    driver_opts:
      type: 'none'
      o: 'bind'
      device: "/srv/redis"

networks:
  redis:
    external: true

# docker stack deploy --compose-file 05redis.yml redis

Dodajemo Docker Registry:

06registry.yml

verzija: '3.7'

usluge:
  registry:
    slika: registry:2.6
    mreže:
      - traefik
    volumeni:
      - registry_data:/var/lib/registry
    implementacija:
      replikati: 1
      raspored:
        ograničenja: [node.role == manager]
      politika_restart:
        uvjet: on-failure
      oznake:
        - traefik.enable=true
        - traefik.http.routers.registry.rule=Host(`registry.example.com`)
        - traefik.http.services.registry.loadbalancer.server.port=5000
        - traefik.docker.network=traefik

volumeni:
  registry_data:
    vozač: local
    vozač_opcije:
      tip: none
      o: bind
      uređaj: "\/srv\/docker\/registry"

mreže:
  traefik:
    vanjski: true

# mkdir /srv/docker/registry
# docker stack deploy --compose-file 06registry.yml registry

I na kraju — GitLab:

08gitlab-runner.yml

verzija: '3.7'

usluge:
  gitlab:
    slika: gitlab/gitlab-ce:latest
    mreže:
      - pgsql
      - redis
      - traefik
      - gitlab
    portovi:
      - 22222:22
    okruženje:
      GITLAB_OMNIBUS_CONFIG: |
        postgresql['enable'] = false
        redis['enable'] = false
        gitlab_rails['registry_enabled'] = false
        gitlab_rails['db_username'] = "gitlab"
        gitlab_rails['db_password'] = "XXXXXXXXXXX"
        gitlab_rails['db_host'] = "postgresql"
        gitlab_rails['db_port'] = "5432"
        gitlab_rails['db_database'] = "gitlab"
        gitlab_rails['db_adapter'] = 'postgresql'
        gitlab_rails['db_encoding'] = 'utf8'
        gitlab_rails['redis_host'] = 'redis-master'
        gitlab_rails['redis_port'] = '6379'
        gitlab_rails['redis_password'] = 'xxxxxxxxxxx'
        gitlab_rails['smtp_enable'] = true
        gitlab_rails['smtp_address'] = "smtp.yandex.ru"
        gitlab_rails['smtp_port'] = 465
        gitlab_rails['smtp_user_name'] = "noreply@example.com"
        gitlab_rails['smtp_password'] = "xxxxxxxxx"
        gitlab_rails['smtp_domain'] = "example.com"
        gitlab_rails['gitlab_email_from'] = 'noreply@example.com'
        gitlab_rails['smtp_authentication'] = "login"
        gitlab_rails['smtp_tls'] = true
        gitlab_rails['smtp_enable_starttls_auto'] = true
        gitlab_rails['smtp_openssl_verify_mode'] = 'peer'
        external_url 'http:\/\/gitlab.example.com\/'
        gitlab_rails['gitlab_shell_ssh_port'] = 22222
    volumeni:
      - gitlab_conf:\/etc\/gitlab
      - gitlab_logs:\/var\/log\/gitlab
      - gitlab_data:\/var\/opt\/gitlab
    implementacija:
      način: replicated
      replikati: 1
      raspored:
        ograničenja:
        - node.role == manager
      oznake:
        - traefik.enable=true
        - traefik.http.routers.gitlab.rule=Host(`gitlab.example.com`)
        - traefik.http.services.gitlab.loadbalancer.server.port=80
        - traefik.docker.network=traefik
  gitlab-runner:
    slika: gitlab/gitlab-runner:latest
    mreže:
      - gitlab
    volumeni:
      - gitlab_runner_conf:\/etc\/gitlab
      - \/var\/run\/docker.sock:\/var\/run\/docker.sock
    implementacija:
      način: replicated
      replikati: 1
      raspored:
        ograničenja:
        - node.role == manager

volumeni:
  gitlab_conf:
    vozač: local
    vozač_opcije:
      tip: none
      o: bind
      uređaj: "\/srv\/docker\/gitlab\/conf"
  gitlab_logs:
    vozač: local
    vozač_opcije:
      tip: none
      o: bind
      uređaj: "\/srv\/docker\/gitlab\/logs"
  gitlab_data:
    vozač: local
    vozač_opcije:
      tip: none
      o: bind
      uređaj: "\/srv\/docker\/gitlab\/data"
  gitlab_runner_conf:
    vozač: local
    vozač_opcije:
      tip: none
      o: bind
      uređaj: "\/srv\/docker\/gitlab\/runner"

mreže:
  pgsql:
    vanjski: true
  redis:
    vanjski: true
  traefik:
    vanjski: true
  gitlab:
    vanjski: true

# mkdir -p /srv/docker/gitlab/conf
# mkdir -p /srv/docker/gitlab/logs
# mkdir -p /srv/docker/gitlab/data
# mkdir -p /srv/docker/gitlab/runner
# docker stack deploy --compose-file 08gitlab-runner.yml gitlab

Konačno stanje klastera i usluga:

# docker service ls
ID                  NAME                   MODE                REPLICAS            IMAGE                          PORTS
lef9n3m92buq        etcd_etcd1             replicated          1/1                 quay.io/coreos/etcd:latest
ij6uyyo792x5        etcd_etcd2             replicated          1/1                 quay.io/coreos/etcd:latest
fqttqpjgp6pp        etcd_etcd3             replicated          1/1                 quay.io/coreos/etcd:latest
hq5iyga28w33        gitlab_gitlab          replicated          1/1                 gitlab/gitlab-ce:latest        *:22222->22/tcp
dt7s6vs0q4qc        gitlab_gitlab-runner   replicated          1/1                 gitlab/gitlab-runner:latest
k7uoezno0h9n        pgsql_pgkeeper1        replicated          1/1                 sorintlab/stolon:master-pg10
cnrwul4r4nse        pgsql_pgkeeper2        replicated          1/1                 sorintlab/stolon:master-pg10
frflfnpty7tr        pgsql_pgkeeper3        replicated          1/1                 sorintlab/stolon:master-pg10
x7pqqchi52kq        pgsql_pgsentinel       replicated          3/3                 sorintlab/stolon:master-pg10
mwu2wl8fti4r        pgsql_postgresql       replicated          3/3                 sorintlab/stolon:master-pg10
9hkbe2vksbzb        redis_redis-master     global              3/3                 bitnami/redis:latest           *:6379->6379/tcp
l88zn8cla7dc        redis_redis-replica    replicated          3/3                 bitnami/redis:latest           *:30003->6379/tcp
1utp309xfmsy        redis_redis-sentinel   global              3/3                 bitnami/redis:latest           *:30002->16379/tcp
oteb824ylhyp        registry_registry      replicated          1/1                 registry:2.6
qovrah8nzzu8        traefik_traefik        replicated          3/3                 traefik:latest                 *:80->80/tcp, *:443->443/tcp

Što još možemo poboljšati? Obavezno postaviti rad kontejnera putem https u Traefiku, dodati tls enkripciju za Postgresql i Redis. Ali u cjelini se već može predati developerima kao PoC. Pogledajmo sada alternative Dockeru.

Podman

Još jedan prilično poznati engine za pokretanje kontejnera, grupiranih po podovima (pods, grupe kontejnera koje se zajedno implementiraju). Za razliku od Dockera, ne zahtijeva nikakav servis za pokretanje kontejnera, cijeli rad se obavlja putem biblioteke libpod. Također je napisan na Go-u, zahtijeva OCI-kompatibilan runtime za pokretanje kontejnera, poput runC.

Docker i sve, sve, sve

Rad s Podmanom u cjelini podsjeća na rad s Dockerom, sve do toga da se može napraviti ovako (navodi se od mnogih koji su probali, uključujući i autora ovog članka):

$ alias docker=podman

i možemo nastaviti raditi. U cjelini, situacija s Podmanom je vrlo zanimljiva, jer ako su rane verzije Kubernetes-a radile s Dockerom, otprilike od 2015. godine, nakon standardizacije svijeta kontejnera (OCI — Open Container Initiative) i podjele Dockera na containerd i runC, razvija se alternativa Dockeru za pokretanje u Kubernetes-u: CRI-O. Podman u tom smislu predstavlja alternativu Dockeru, izgrađenu prema načelima Kubernetes-a, uključujući grupiranje kontejnera, a osnovni cilj postojanja projekta je pokretanje kontejnera u stilu Dockera bez dodatnih servisa. Iz razumljivih razloga ne postoji swarm mode, jer developeri jasno govore da ako je potrebno klaster — uzmite Kubernetes.

Instalacija

Za instalaciju na Centos 7 dovoljno je aktivirati Extras repozitorij, nakon čega se sve može instalirati pomoću naredbe:

# yum -y install podman

Druge mogućnosti

Podman može generirati jedinice za systemd, na taj način rješavajući problem pokretanja kontejnera nakon ponovnog pokretanja servera. Dodatno se navodi ispravna funkcionalnost systemd-a kao pid 1 u kontejneru. Za izgradnju kontejnera postoji zaseban alat buildah, a postoje i alati trećih strana — analogi docker-compose, koji generiraju i konfiguracijske datoteke kompatibilne s Kubernetesom, tako da je prijelaz s Podmana na Kubernetes pojednostavljen koliko god to moguće.

Rad s Podmanom

Budući da nema swarm mode (predviđa se prijelaz na Kubernetes, ako je potreban klaster) — skupljat ćemo ih u zasebnim kontejnerima.

Instaliramo podman-compose:

# yum -y install python3-pip
# pip3 install podman-compose

Rezultantna konfiguracijska datoteka za podman malo se razlikuje, tako da je, na primjer, bilo potrebno premjestiti zasebnu sekciju volumena izravno u sekciju sa servisima.

gitlab-podman.yml

verzija: '3.7'

usluge:
  gitlab:
    slika: gitlab/gitlab-ce:latest
    hostname: gitlab.example.com
    restart: osim ako nije zaustavljeno
    okruženje:
      GITLAB_OMNIBUS_CONFIG: |
        gitlab_rails['gitlab_shell_ssh_port'] = 22222
    portovi:
      - "80:80"
      - "22222:22"
    volumeni:
      - /srv/podman/gitlab/conf:/etc/gitlab
      - /srv/podman/gitlab/data:/var/opt/gitlab
      - /srv/podman/gitlab/logs:/var/log/gitlab
    mreže:
      - gitlab

  gitlab-runner:
    slika: gitlab/gitlab-runner:alpine
    restart: osim ako nije zaustavljeno
    ovisi o:
      - gitlab
    volumeni:
      - /srv/podman/gitlab/runner:/etc/gitlab-runner
      - /var/run/docker.sock:/var/run/docker.sock
    mreže:
      - gitlab

mreže:
  gitlab:

# podman-compose -f gitlab-runner.yml -d up

Rezultat rada:

# podman ps
CONTAINER ID  IMAGE                                  COMMAND               CREATED             STATUS                 PORTS                                      NAMES
da53da946c01  docker.io/gitlab/gitlab-runner:alpine  run --user=gitlab...  About a minute ago  Up About a minute ago  0.0.0.0:22222->22/tcp, 0.0.0.0:80->80/tcp  root_gitlab-runner_1
781c0103c94a  docker.io/gitlab/gitlab-ce:latest      /assets/wrapper       About a minute ago  Up About a minute ago  0.0.0.0:22222->22/tcp, 0.0.0.0:80->80/tcp  root_gitlab_1

Pogledajmo što generira za systemd i kubernetes, za to trebamo saznati ime ili id poda:

# podman pod ls
POD ID         NAME   STATUS    CREATED          # OF CONTAINERS   INFRA ID
71fc2b2a5c63   root   Running   11 minutes ago   3                 db40ab8bf84b

Kubernetes:

# podman generate kube 71fc2b2a5c63
# Generation of Kubernetes YAML is still under development!
#
# Save the output of this file and use kubectl create -f to import
# it into Kubernetes.
#
# Created with podman-1.6.4
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: "2020-07-29T19:22:40Z"
  labels:
    app: root
  name: root
spec:
  containers:
  - command:
    - /assets/wrapper
    env:
    - name: PATH
      value: /opt/gitlab/embedded/bin:/opt/gitlab/bin:/assets:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
    - name: TERM
      value: xterm
    - name: HOSTNAME
      value: gitlab.example.com
    - name: container
      value: podman
    - name: GITLAB_OMNIBUS_CONFIG
      value: |
        gitlab_rails['gitlab_shell_ssh_port'] = 22222
    - name: LANG
      value: C.UTF-8
    image: docker.io/gitlab/gitlab-ce:latest
    name: rootgitlab1
    ports:
    - containerPort: 22
      hostPort: 22222
      protocol: TCP
    - containerPort: 80
      hostPort: 80
      protocol: TCP
    resources: {}
    securityContext:
      allowPrivilegeEscalation: true
      capabilities: {}
      privileged: false
      readOnlyRootFilesystem: false
    volumeMounts:
    - mountPath: /var/opt/gitlab
      name: srv-podman-gitlab-data
    - mountPath: /var/log/gitlab
      name: srv-podman-gitlab-logs
    - mountPath: /etc/gitlab
      name: srv-podman-gitlab-conf
    workingDir: /
  - command:
    - run
    - --user=gitlab-runner
    - --working-directory=/home/gitlab-runner
    env:
    - name: PATH
      value: /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
    - name: TERM
      value: xterm
    - name: HOSTNAME
    - name: container
      value: podman
    image: docker.io/gitlab/gitlab-runner:alpine
    name: rootgitlab-runner1
    resources: {}
    securityContext:
      allowPrivilegeEscalation: true
      capabilities: {}
      privileged: false
      readOnlyRootFilesystem: false
    volumeMounts:
    - mountPath: /etc/gitlab-runner
      name: srv-podman-gitlab-runner
    - mountPath: /var/run/docker.sock
      name: var-run-docker.sock
    workingDir: /
  volumes:
  - hostPath:
      path: /srv/podman/gitlab/runner
      type: Directory
    name: srv-podman-gitlab-runner
  - hostPath:
      path: /var/run/docker.sock
      type: File
    name: var-run-docker.sock
  - hostPath:
      path: /srv/podman/gitlab/data
      type: Directory
    name: srv-podman-gitlab-data
  - hostPath:
      path: /srv/podman/gitlab/logs
      type: Directory
    name: srv-podman-gitlab-logs
  - hostPath:
      path: /srv/podman/gitlab/conf
      type: Directory
    name: srv-podman-gitlab-conf
status: {}

Systemd:

# podman generate systemd 71fc2b2a5c63
# pod-71fc2b2a5c6346f0c1c86a2dc45dbe78fa192ea02aac001eb8347ccb8c043c26.service
# autogenerated by Podman 1.6.4
# Thu Jul 29 15:23:28 EDT 2020

[Unit]
Description=Podman pod-71fc2b2a5c6346f0c1c86a2dc45dbe78fa192ea02aac001eb8347ccb8c043c26.service
Documentation=man:podman-generate-systemd(1)
Requires=container-781c0103c94aaa113c17c58d05ddabf8df4bf39707b664abcf17ed2ceff467d3.service container-da53da946c01449f500aa5296d9ea6376f751948b17ca164df438b7df6607864.service
Before=container-781c0103c94aaa113c17c58d05ddabf8df4bf39707b664abcf17ed2ceff467d3.service container-da53da946c01449f500aa5296d9ea6376f751948b17ca164df438b7df6607864.service

[Service]
Restart=on-failure
ExecStart=/usr/bin/podman start db40ab8bf84bf35141159c26cb6e256b889c7a98c0418eee3c4aa683c14fccaa
ExecStop=/usr/bin/podman stop -t 10 db40ab8bf84bf35141159c26cb6e256b889c7a98c0418eee3c4aa683c14fccaa
KillMode=none
Type=forking
PIDFile=/var/run/containers/storage/overlay-containers/db40ab8bf84bf35141159c26cb6e256b889c7a98c0418eee3c4aa683c14fccaa/userdata/conmon.pid

[Install]
WantedBy=multi-user.target
# container-da53da946c01449f500aa5296d9ea6376f751948b17ca164df438b7df6607864.service
# autogenerated by Podman 1.6.4
# Thu Jul 29 15:23:28 EDT 2020

[Unit]
Description=Podman container-da53da946c01449f500aa5296d9ea6376f751948b17ca164df438b7df6607864.service
Documentation=man:podman-generate-systemd(1)
RefuseManualStart=yes
RefuseManualStop=yes
BindsTo=pod-71fc2b2a5c6346f0c1c86a2dc45dbe78fa192ea02aac001eb8347ccb8c043c26.service
After=pod-71fc2b2a5c6346f0c1c86a2dc45dbe78fa192ea02aac001eb8347ccb8c043c26.service

[Service]
Restart=on-failure
ExecStart=/usr/bin/podman start da53da946c01449f500aa5296d9ea6376f751948b17ca164df438b7df6607864
ExecStop=/usr/bin/podman stop -t 10 da53da946c01449f500aa5296d9ea6376f751948b17ca164df438b7df6607864
KillMode=none
Type=forking
PIDFile=/var/run/containers/storage/overlay-containers/da53da946c01449f500aa5296d9ea6376f751948b17ca164df438b7df6607864/userdata/conmon.pid

[Install]
WantedBy=multi-user.target
# container-781c0103c94aaa113c17c58d05ddabf8df4bf39707b664abcf17ed2ceff467d3.service
# autogenerated by Podman 1.6.4
# Thu Jul 29 15:23:28 EDT 2020

[Unit]
Description=Podman container-781c0103c94aaa113c17c58d05ddabf8df4bf39707b664abcf17ed2ceff467d3.service
Documentation=man:podman-generate-systemd(1)
RefuseManualStart=yes
RefuseManualStop=yes
BindsTo=pod-71fc2b2a5c6346f0c1c86a2dc45dbe78fa192ea02aac001eb8347ccb8c043c26.service
After=pod-71fc2b2a5c6346f0c1c86a2dc45dbe78fa192ea02aac001eb8347ccb8c043c26.service

[Service]
Restart=on-failure
ExecStart=/usr/bin/podman start 781c0103c94aaa113c17c58d05ddabf8df4bf39707b664abcf17ed2ceff467d3
ExecStop=/usr/bin/podman stop -t 10 781c0103c94aaa113c17c58d05ddabf8df4bf39707b664abcf17ed2ceff467d3
KillMode=none
Type=forking
PIDFile=/var/run/containers/storage/overlay-containers/781c0103c94aaa113c17c58d05ddabf8df4bf39707b664abcf17ed2ceff467d3/userdata/conmon.pid

[Install]
WantedBy=multi-user.target

Nažalost, osim pokretanja kontejnera, generirana jedinica za systemd ne radi ništa drugo (na primjer, ne čisti stare kontejneri prilikom ponovnog pokretanja takve usluge), tako da ćete te stvari morati doraditi sami.

U principu, Podman je dovoljno dobar da isprobate što su kontejneri, prenesete stare konfiguracije za docker-compose, nakon čega se možete prebaciti na Kubernetes ako je potrebno za klaster, ili dobiti jednostavniju alternativu Dockeru.

rkt

Projekt je otišao u arhivu otprilike prije pola godine jer ga je kupio RedHat, tako da neću se detaljnije zadržavati na njemu. U cjelini je ostavljao prilično dobar dojam, ali u usporedbi s Dockerom, a naročito s Podmanom, izgleda kao kombajn. Postojao je i distribucijski paket CoreOS, baziran na rktu (iako su prvo imali Docker), ali je njegova podrška također završila nakon kupovine RedHat-a.

Plash

Više je jedan projekt, čiji autor je jednostavno želio sastavljati i pokretati kontejnere. Sudeći prema dokumentaciji i kodu - autor nije slijedio standarde, već je jednostavno odlučio napisati svoju implementaciju, što je u principu i učinio.

Zaključci

Situacija sa Kubernetesom postaje vrlo zanimljiva: s jedne strane, s Dockerom možete sastaviti klaster (u swarm modu), s kojim čak možete pokretati produkcijske okoline za klijente, što je posebno relevantno za male timove (3-5 ljudi), ili pri manjem ukupnom opterećenju, ili ako ne želite razmatrati finese postavljanja Kubernetesa, uključujući i visoka opterećenja.

Podman ne osigurava potpunu kompatibilnost, ali ima jednu važnu prednost — kompatibilnost s Kubernetesom, uključujući i dodatne alate (buildah i druge). Stoga ću pristupiti odabiru alata na sljedeći način: za male timove ili uz ograničen budžet — Docker (s mogućim swarm načinom), za razvoj za sebe na osobnom localhostu — Podman s kolegama, a za sve ostale — Kubernetes.

Nisam siguran hoće li se situacija s Dokerom promijeniti u budućnosti, uostalom, oni su pioniri i postepeno se standardiziraju, ali budućnost Podmana, sa svim svojim nedostacima (radi samo na Linuxu, nema klasterizacije, izgradnja i druge radnje — vanjskim rješenjima), izgleda jasnije. Stoga pozivam sve zainteresirane da rasprave ove zaključke u komentarima.

P.S. 3. kolovoza pokrećemo „Video tečaj o Dockeru”, gdje će se detaljnije raspraviti o njegovom radu. Obuhvatit ćemo sve njegove alate: od osnovnih apstrakcija do mrežnih opcija, nijansi rada s različitim operativnim sustavima i programskim jezicima. Upoznat ćete se s tehnologijom i shvatiti gdje i kako najbolje koristiti Docker. Također ćemo podijeliti najbolje prakse.

Cijena prednarudžbe do objave: 5000 kn. S programom „Video tečaja o Dockeru” možete se upoznati na stranici tečaja.

Izvor: habr.com

Kupite pouzdan hosting za web stranice s DDoS zaštitom, VPS VDS servere 🔥 Kupite pouzdan hosting za web stranice s DDoS zaštitom, VPS VDS servere | ProHoster