TL;DR: pregledni članak-vodič o poređenju okruženja za pokretanje aplikacija u kontejnerima. Računaće se mogućnosti Docker-a i drugih sličnih sistema.

Malo istorije, odakle sve potiče
Istorija
Prvi poznati način izolacije aplikacija je chroot. Istoimeni sistemski poziv obezbeđuje promenu korenskog direktorijuma - na taj način obezbeđuje se pristup programu, koji ga je pozvao, samo datotekama unutar tog direktorijuma. Međutim, ako programu unutar dodelite privilegije superkorisnika, potencijalno može "pobeći" iz chroot-a i dobiti pristup glavnom operativnom sistemu. Takođe, osim promene korenskog direktorijuma, ne ograničavaju se drugi resursi (operativna memorija, procesor), kao ni pristup mreži.
Sledeći način je pokretanje potpunog operativnog sistema unutar kontejnera, putem mehanizama jezgra operativnog sistema. U različitim operativnim sistemima ovaj način se naziva različito, ali suština je ista - pokretanje više nezavisnih operativnih sistema, od kojih svaki radi sa istim jezgrom kao i glavni operativni sistem. Ovo uključuje FreeBSD Jails, Solaris Zones, OpenVZ i LXC za Linux. Obezbeđuje se izolacija ne samo po prostorima na disku, već i drugim resursima, posebno svaki kontejner može imati ograničenja po procesorskom vremenu, operativnoj memoriji i propusnosti mreže. U poređenju sa chroot, izlazak iz kontejnera je teži, budući da superkorisnik u kontejneru ima pristup samo unutrašnjosti kontejnera, međutim, zbog potrebe da se operativni sistem unutar kontejnera održava ažurnim i koristi starije verzije jezara (što važi za Linux, u manjoj meri FreeBSD), postoji nula verovatnoća "probivanja" sistema izolacije jezgra i pristupa glavnom operativnom sistemu.
Umjesto pokretanja pune operativne sistem u kontejneru (sa sistemom inicijalizacije, upraviteljem paketa itd.) možete odmah pokretati aplikacije, a najvažnije je omogućiti aplikacijama tu mogućnost (prisustvo potrebnih biblioteka i drugih datoteka). Ova ideja je postavila osnovu za kontejnersku virtualizaciju aplikacija, čiji je najistaknutiji i najpoznatiji predstavnik Docker. U poređenju sa prethodnim sistemima, fleksibilniji mehanizmi izolacije zajedno sa ugrađenom podrškom za virtuelne mreže između kontejnera i praćenjem stanja aplikacije unutar kontejnera omogućili su stvaranje jedinstvenog koherentnog 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 jeziku Go, koristi standardne mogućnosti Linux jezgra — cgroups, namespaces, capabilities itd., kao i datotečne sisteme Aufs i druge slične za uštedu prostora na disku.

Izvor: wikimedia
Arhitektura
Do verzije 1.11, Docker je radio kao jedinstvena usluga koja je obavljala sve operacije sa kontejnerima: preuzimanje slika za kontejnere, pokretanje kontejnera, obrada API zahteva. Počevši od verzije 1.11, Docker je podeljen na nekoliko delova koji međusobno komuniciraju: containerd, za upravljanje celokupnim životnim ciklusom kontejnera (dodeljivanje prostora na disku, preuzimanje slika, rad sa mrežom, pokretanje, instalacija i praćenje stanja kontejnera) i runC, okruženje za pokretanje kontejnera zasnovano na korišćenju cgroups i drugih mogućnosti Linux jezgra. Sama usluga docker je ostala, ali sada služi samo za obradu API zahteva koji se prevode u containerd.

Instalacija i konfiguracija
Moj omiljeni način instalacije dockera je docker-machine, koji osim same instalacije i podešavanja dockera na udaljenim serverima (uključujući različite oblake) omogućava rad sa datotečnim sistemima udaljenih servera, a takođe može izvoditi razne komande.
Međutim, od 2018. godine projekat se skoro nije razvijao, pa ćemo instalaciju vršiti standardnim načinom za većinu distribucija Linuxa — dodavanjem repozitorijuma i instalacijom potrebnih paketa.
Ova metoda se takođe primenjuje i prilikom automatizovane instalacije, na primer, koristeći Ansible ili slične sisteme, ali je u ovom članku neću detaljno obraditi.
Instalacija će se sprovesti na CentOS 7, a kao server koristiću virtuelnu mašinu; da biste postavili, dovoljno je izvršiti komande u nastavku:
# 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.ioNakon 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 --permanentDodatno, možete kreirati grupu docker, čiji korisnici mogu raditi sa docker-om bez sudo privilegija, konfigurisati logovanje, omogućiti pristup API-ju izvana, ne zaboravite da preciznije podesite firewall (sve je zabranjeno osim onoga što je dozvoljeno, u primerima iznad i ispod to sam izostavio radi jednostavnosti i preglednosti), ali ovde se neću više zadržavati.
Druge mogućnosti
Pored imenovane docker mašine, postoji i docker registry, alat za skladištenje slika za kontejnere, kao i docker compose — alat za automatizaciju postavljanja aplikacija u kontejnerima, koriste se YAML fajlovi za izgradnju i konfiguraciju kontejnera i ostalih povezanih stavki (kao što su mreže, trajni datotečni sistemi za skladištenje podataka).
Takođe, uz njegovu pomoć mogu se organizovati cevovodi za CICD. Druga zanimljiva mogućnost je rad u klaster modu, takozvanom swarm modu (do verzije 1.12 poznatom kao docker swarm), koji omogućava kombinovanje više servera u jedinstvenu infrastrukturu za pokretanje kontejnera. Postoji podrška za virtuelnu mrežu iznad svih servera, ugrađeni balansir iznenađenja, kao i podrška za tajne za kontejnere.
YAML fajlovi iz docker compose-a, uz mala podešavanja, mogu se koristiti za takve klastere, potpuno automatizujući održavanje malih i srednjih klastera za razne svrhe. Za velike klastere, prednost ima Kubernetes, s obzirom na to da troškovi održavanja swarm mode-a mogu premašiti troškove s Kubernetesom. Pored runC, kao sredinu za izvršavanje kontejnera možete instalirati, na primer,
Rad s Dockerom
Nakon instalacije i podešavanja, pokušat ćemo da okupimo klaster u kojem ćemo postaviti GitLab i Docker Registry za tim programera. Kao servere koristiću tri virtuelne mašine, na kojima ću dodatno postaviti distribuiranu FС GlusterFS, koju ću koristiti kao skladište docker volumena, na primer za pokretanje otporne verzije docker registry. Ključne komponente za pokretanje: Docker Registry, Postgresql, Redis, GitLab uz podršku GitLab Runner-a na Swarm-u. Postgresql ćemo pokrenuti sa klasterizacijom. , stoga za skladištenje podataka Postgresql ne treba koristiti GlusterFS. Ostali kritični podaci će se čuvati na GlusterFS.
Za postavljanje GlusterFS na svim serverima (koji se nazivaju node1, node2, node3) potrebno je instalirati pakete, omogućiti rad firewall-a, i kreirati potrebne direktorijume:
# 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/fstabNakon instalacije, rad na konfiguraciji GlusterFS treba nastaviti sa jednog čvora, na primer 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 dockerZatim treba montirati dobijeni volumen (komandu treba izvršiti na svim serverima):
# mount /srv/dockerPodešavanje swarm moda vrši se na jednom od servera, koji će biti vođa, ostali se moraju pridružiti klasteru, stoga treba kopirati rezultat izvršene komande sa prvog servera i izvršiti na ostalima.
Početno podešavanje klastera, komandu pokrećem 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 managerKopiramo rezultat druge komande, a zatim izvršavamo 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.Ovim je završena preliminarna konfiguracija servera, prelazimo na podešavanje servisa, komande za izvršavanje će se pokretati sa node1, osim ako nije drugačije navedeno.
Prvo ćemo kreirati 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 gitlabZatim označavamo servere, što je potrebno za vezivanje nekih servisa za servere:
# docker node update --label-add nodename=node1 node1
# docker node update --label-add nodename=node2 node2
# docker node update --label-add nodename=node3 node3Nakon toga kreiramo direktorijume za skladištenje podataka etcd, KV-skladišta koje je potrebno za Traefik i Stolon. Slično kao i za Postgresql, to će biti vezani kontejneri za servere, pa ovu komandu izvršavamo na svim serverima:
# mkdir -p /srv/etcdZatim kreiramo datoteku za podešavanje etcd i primenjujemo je:
00etcd.yml
verzija: '3.7'
usluge:
etcd1:
slika: quay.io/coreos/etcd:latest
naziv domaćina: 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 domaćina: 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 domaćina: 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:
drajver: local
drajver_opts:
tip: none
o: bind
uređaj: "/srv/etcd"
etcd2vol:
drajver: local
drajver_opts:
tip: none
o: bind
uređaj: "/srv/etcd"
etcd3vol:
drajver: local
drajver_opts:
tip: none
o: bind
uređaj: "/srv/etcd"
mreže:
etcd:
spoljašnje: true# docker stack deploy --compose-file 00etcd.yml etcdNakon nekog vremena proveravamo 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 healthyKreiramo direktorijume za Postgresql, komandu izvršavamo na svim serverima:
# mkdir -p /srv/pgsqlZatim kreiramo datoteku za podešavanje Postgresql:
01pgsql.yml
verzija: '3.7'
usluge:
pgsentinel:
slika: sorintlab/stolon:master-pg10
komanda:
- gosu
- stolon
- stolon-sentinel
- --cluster-name=stolon-cluster
- --store-backend=etcdv3
- --store-endpoints=http://etcd1:2379,http://etcd2:2379,http://etcd3:2379
- --log-level=debug
mreže:
- etcd
- pgsql
implementacija:
replike: 3
update_config:
paralelizacija: 1
kašnjenje: 30s
redosled: stop-first
failure_action: pause
pgkeeper1:
slika: sorintlab/stolon:master-pg10
hostname: pgkeeper1
komanda:
- 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
- --cluster-name=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
zapremine:
- pgkeeper1:/var/lib/postgresql/data
tajne:
- pgsql
- pgsql_repl
implementacija:
replike: 1
placement:
ograničenja: [node.labels.nodename == node1]
pgkeeper2:
slika: sorintlab/stolon:master-pg10
hostname: pgkeeper2
komanda:
- 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
- --cluster-name=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
zapremine:
- pgkeeper2:/var/lib/postgresql/data
tajne:
- pgsql
- pgsql_repl
implementacija:
replike: 1
placement:
ograničenja: [node.labels.nodename == node2]
pgkeeper3:
slika: sorintlab/stolon:master-pg10
hostname: pgkeeper3
komanda:
- 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
- --cluster-name=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
zapremine:
- pgkeeper3:/var/lib/postgresql/data
tajne:
- pgsql
- pgsql_repl
implementacija:
replike: 1
placement:
ograničenja: [node.labels.nodename == node3]
postgresql:
slika: sorintlab/stolon:master-pg10
komanda: gosu stolon stolon-proxy --listen-address 0.0.0.0 --cluster-name stolon-cluster --store-backend=etcdv3 --store-endpoints http://etcd1:2379,http://etcd2:2379,http://etcd3:2379
mreže:
- etcd
- pgsql
implementacija:
replike: 3
update_config:
paralelizacija: 1
kašnjenje: 30s
redosled: stop-first
failure_action: rollback
zapremine:
pgkeeper1:
drajver: local
drajver_opts:
tip: none
o: bind
uređaj: "/srv/pgsql"
pgkeeper2:
drajver: local
drajver_opts:
tip: none
o: bind
uređaj: "/srv/pgsql"
pgkeeper3:
drajver: local
drajver_opts:
tip: none
o: bind
uređaj: "/srv/pgsql"
tajne:
pgsql:
datoteka: "/srv/docker/postgres"
pgsql_repl:
datoteka: "/srv/docker/replica"
mreže:
etcd:
eksterni: true
pgsql:
eksterni: trueGenerišemo tajne, primenjujemo 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 pgsqlNakon nekog vremena (provjeravamo izlaz komande docker service ls, da li su svi servisi pokrenuti) inicijalizujemo 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 initProveravamo 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
Podešavamo traefik za omogućavanje pristupa kontejnerima sa spolja:
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 traefikPokrećemo Redis klaster, za to pravimo direktorijum za skladištenje na svim čvorovima:
# mkdir -p /srv/redis05redis.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 redisDodajemo Docker Registry:
06registry.yml
verzija: '3.7'
servisi:
registry:
slika: registry:2.6
mreže:
- traefik
volumeni:
- registry_data: /var/lib/registry
implementacija:
replikati: 1
raspored:
ograničenja: [node.role == manager]
pravila_restart:
stanje: 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:
drajver: lokalni
opcije_drajvera:
tip: none
o: bind
uređaj: "/srv/docker/registry"
mreže:
traefik:
eksterni: true# mkdir /srv/docker/registry
# docker stack deploy --compose-file 06registry.yml registryI na kraju — GitLab:
08gitlab-runner.yml
verzija: '3.7'
servisi:
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:
režim: 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:
režim: replicated
replikati: 1
raspored:
ograničenja:
- node.role == manager
volumeni:
gitlab_conf:
drajver: lokalni
opcije_drajvera:
tip: none
o: bind
uređaj: "/srv/docker/gitlab/conf"
gitlab_logs:
drajver: lokalni
opcije_drajvera:
tip: none
o: bind
uređaj: "/srv/docker/gitlab/logs"
gitlab_data:
drajver: lokalni
opcije_drajvera:
tip: none
o: bind
uređaj: "/srv/docker/gitlab/data"
gitlab_runner_conf:
drajver: lokalni
opcije_drajvera:
tip: none
o: bind
uređaj: "/srv/docker/gitlab/runner"
mreže:
pgsql:
eksterni: true
redis:
eksterni: true
traefik:
eksterni: true
gitlab:
eksterni: 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 gitlabKonačno stanje klastera i servisa:
# 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Šta još možemo poboljšati? Obavezno podesite rad kontejnera u Traefiku preko https, dodajte TLS enkripciju za Postgresql i Redis. No, u celini već možemo da predamo developerima kao PoC. Sada ćemo razmotriti alternative Dockeru.
Podman
Još jedan prilično poznat engine za pokretanje kontejnera, grupisanih po podovima (pods, grupe kontejnera koji su zajednički raspoređeni). Za razliku od Dockera, ne zahteva nikakvu uslugu za pokretanje kontejnera, sav rad se obavlja kroz biblioteku libpod. Takođe je napisan na Go-u, zahteva OCI-kompatibilan runtime za pokretanje kontejnera, kao što je runC.

Rad sa Podman-om u suštini podseća na rad sa Docker-om, do te mere da se može uraditi sledeće (izjavili su mnogi koji su probali, uključujući i autora ovog članka):
$ alias docker=podmani možete nastaviti da radite. U celini situacija sa Podman-om je prilično interesantna, jer ako su rane verzije Kubernetes-a radile sa Docker-om, od otprilike 2015. godine, nakon standardizacije sveta kontejnera (OCI — Open Container Initiative) i podela Dockera na containerd i runC, razvija se alternativa Docker-u za pokretanje u Kubernetes-u: CRI-O. U tom smislu, Podman je alternativa Docker-u, izgrađena prema principima Kubernetes-a, uključujući i grupisanje kontejnera, a osnovna svrha postojanja projekta je pokretanje kontejnera u stilu Docker-a bez dodatnih usluga. Iz očiglednih razloga ne postoji swarm mode, jer programeri jasno govore da, ako vam treba klaster — uzmite Kubernetes.
Instalacija
Za instalaciju na Centos 7 dovoljno je aktivirati Extras repozitorijum, nakon čega instalirati sve komandom:
# yum -y install podmanDruge mogućnosti
Podman može generisati jedinice za systemd, time rešava problem pokretanja kontejnera nakon ponovnog pokretanja servera. Takođe je naglašena ispravna funkcionalnost systemd kao pid 1 unutar kontejnera. Za izgradnju kontejnera postoje posebni alati kao što je buildah, postoje i spoljni alati — alternatve docker-compose, koji generišu i konfiguracione datoteke kompatibilne sa Kubernetes-om, tako da je prelazak sa Podman-a na Kubernetes olakšan koliko god je to moguće.
Rad sa Podman-om
Pošto nema swarm mode-a (pretpostavlja se prelazak na Kubernetes, ako vam treba klaster) — sakupljaćemo pojedinačne kontejnere.
Instaliramo podman-compose:
# yum -y install python3-pip
# pip3 install podman-composeRezultantna konfiguracijska datoteka za podman se malo razlikuje, tako da je, na primer, trebalo prebaciti posebnu sekciju volumena direktno u sekciju sa uslugama.
gitlab-podman.yml
version: '3.7'
services:
gitlab:
image: gitlab/gitlab-ce:latest
hostname: gitlab.example.com
restart: unless-stopped
environment:
GITLAB_OMNIBUS_CONFIG: |
gitlab_rails['gitlab_shell_ssh_port'] = 22222
ports:
- "80:80"
- "22222:22"
volumes:
- /srv/podman/gitlab/conf:/etc/gitlab
- /srv/podman/gitlab/data:/var/opt/gitlab
- /srv/podman/gitlab/logs:/var/log/gitlab
networks:
- gitlab
gitlab-runner:
image: gitlab/gitlab-runner:alpine
restart: unless-stopped
depends_on:
- gitlab
volumes:
- /srv/podman/gitlab/runner:/etc/gitlab-runner
- /var/run/docker.sock:/var/run/docker.sock
networks:
- gitlab
networks:
gitlab:# podman-compose -f gitlab-runner.yml -d upRezultat 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_1Pogledajmo šta će generisati za systemd i kubernetes, za to treba saznati ime ili id pod-a:
# podman pod ls
POD ID NAME STATUS CREATED # OF CONTAINERS INFRA ID
71fc2b2a5c63 root Running 11 minutes ago 3 db40ab8bf84bKubernetes:
# 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.targetNažalost, osim pokretanja kontejnera, generisani jedinica za systemd ne radi ništa drugo (na primer, ne čisti stare kontejnere prilikom ponovnog pokretanja takve usluge), pa će ta podešavanja morati da se dodaju ručno.
U suštini, Podman je dovoljan da isprobate šta su kontejneri, prenesete stare konfiguracije za docker-compose, nakon čega se možete prebaciti na Kubernetes, ako vam je potreban klaster, ili dobiti jednostavniju alternativu Dockera.
rkt
Projekt prema nekih šest meseci zbog toga što ga je kupio RedHat, pa se neću dublje zadržavati na njemu. U globalu je ostavljao dobar utisak, ali u poređenju sa Docker-om, a još više sa Podman-om, izgleda kao usputno rešenje. Postojao je takođe i distribucija CoreOS, zasnovana na rkt (iako su prvobitno koristili Docker), međutim i njezina podrška je prestala nakon kupovine RedHat-a.
Plash
Još , čiji autor je želeo samo da prikuplja i pokreće kontejnere. Sudеći po dokumentaciji i kodu — autor nije pratio standarde, već je jednostavno hteo da napiše svoju implementaciju, što je zapravo i uradio.
Zaključci
Situacija sa prisustvom Kubernetes-a je prilično zanimljiva: s jedne strane, s Docker-om se može sastaviti klaster (u swarm modu), sa kojim se čak mogu pokretati produkcijska okruženja za klijente, što je posebno relevantno za male timove (3-5 ljudi), ili uz nisku ukupnu opterećenost, ili u slučaju nedostatka želje da se razumeju nijanse podešavanja Kubernetes-a, uključujući visoka opterećenja.
Podman ne osigurava potpunu kompatibilnost, ali ima jednu važnu prednost — kompatibilnost s Kubernetesom, uključujući dodatne alate (buildah i druge). Stoga ću pristupiti izboru alata na sljedeći način: za male timove ili kada je budžet ograničen — Docker (s mogućim swarm modom), za razvoj na vlastitom lokalnom računaru — Podman s kolegama, a svima ostalima — Kubernetes.
Nisam siguran hoće li se situacija s Dockerom promijeniti u budućnosti, ipak su oni pioniri i korak po korak se polako standardiziraju, ali future Podmana, uprkos svim njegovim nedostacima (radi samo na Linuxu, nema klasterizaciju, izrada i druge radnje — vanjskim rješenjima), izgleda jasnije, stoga pozivam sve zainteresovane da komentarišu ove zaključke.
P.S. 3. avgusta pokrećemo "“, gdje ćete moći saznati više o njegovom radu. Razmotrićemo sve njegove alate: od osnovnih apstrakcija do opcija mreže, nijansi rada s različitim operativnim sistemima i programskim jezicima. Upoznat ćete se s tehnologijom i shvatiti gdje i kako najbolje koristiti Docker. Također ćemo podijeliti najbolje prakse.
Cijena predbilježbe do izlaska: 5000 R. Program "Video tečaja za Docker" možete pregledati .
Izvor: habr.com
