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.

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.

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.

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.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 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,
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. , 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/fstabNakon 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 dockerZatim treba montirati dobiveni volumen (komandu treba izvesti na svim poslužiteljima):
# mount /srv/dockerPostavka 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 managerKopiramo 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 gitlabZatim 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 node3Sljedeć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/etcdZatim 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 etcdNakon 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 healthyKreiramo direktorije 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
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: trueGeneriramo 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 pgsqlNakon 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 initProvjeravamo 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 traefikPokrećemo Redis klaster, za to kreiramo direktorij za pohranu 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'
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 registryI 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 gitlabKonač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.

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=podmani 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 podmanDruge 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-composeRezultantna 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 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 š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 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, 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 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 , č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 „”, 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 .
Izvor: habr.com
