TL;DR: Pregledni vodič za usporedbu okvira za pokretanje aplikacija u spremnicima. Razmotrit će se mogućnosti Dockera i drugih sličnih sustava.
Malo povijesti o tome odakle je sve došlo
Priča
Prva poznata metoda za izolaciju aplikacije je chroot. Istoimeni sistemski poziv osigurava promjenu korijenskog direktorija - čime se osigurava da program koji ga je pozvao ima pristup samo datotekama unutar tog direktorija. Ali ako se programu interno daju root povlastice, potencijalno može "pobjeći" chroot-u i dobiti pristup glavnom operativnom sustavu. Također, osim promjene korijenskog direktorija, ostali resursi (RAM, procesor), kao ni pristup mreži, nisu ograničeni.
Sljedeća metoda je pokretanje potpunog operativnog sustava unutar spremnika, koristeći mehanizme jezgre operativnog sustava. Ova se metoda u različitim operacijskim sustavima naziva različito, ali suština je ista - pokretanje nekoliko neovisnih operacijskih sustava, od kojih svaki pokreće istu jezgru na kojoj radi glavni operativni sustav. To uključuje FreeBSD Jails, Solaris Zones, OpenVZ i LXC za Linux. Izolacija je osigurana ne samo diskovnim prostorom, već i drugim resursima; posebice, svaki spremnik može imati ograničenja vremena procesora, RAM-a i propusnosti mreže. U usporedbi s chrootom, napuštanje spremnika je teže, budući da superkorisnik u spremniku ima pristup samo sadržaju spremnika, međutim, zbog potrebe da se operativni sustav unutar spremnika održava ažuriranim i korištenja starijih verzija kernela (relevantno za Linux, u manjoj mjeri za FreeBSD), postoji različita od nule vjerojatnost "probijanja" sustava izolacije kernela i dobivanja pristupa glavnom operativnom sustavu.
Umjesto pokretanja potpunog operativnog sustava u spremniku (sa sustavom za inicijalizaciju, upraviteljem paketa itd.), aplikacije možete pokrenuti odmah, glavna stvar je pružiti aplikacijama takvu priliku (prisutnost potrebnih biblioteka i druge datoteke). Ova ideja poslužila je kao osnova za kontejnersku virtualizaciju aplikacija, čiji je najistaknutiji i najpoznatiji predstavnik Docker. U usporedbi s prethodnim sustavima, fleksibilniji mehanizmi izolacije, zajedno s ugrađenom podrškom za virtualne mreže između spremnika i praćenje stanja aplikacije unutar spremnika, rezultirali su mogućnošću izgradnje jednog koherentnog okruženja od velikog broja fizičkih poslužitelja za pokretanje spremnika - bez potrebe za ručnim upravljanjem resursima.
Lučki radnik
Docker je najpoznatiji softver za kontejnerizaciju aplikacija. Napisan u Go jeziku, koristi standardne značajke Linux kernela - cgroups, namespaces, capabilities itd., kao i Aufs datotečne sustave i druge slične za uštedu prostora na disku.
Izvor: wikimedia
arhitektura
Prije verzije 1.11, Docker je radio kao jedinstvena usluga koja je obavljala sve operacije sa spremnicima: preuzimanje slika za spremnike, pokretanje spremnika, obrada API zahtjeva. Počevši od verzije 1.11, Docker je podijeljen u nekoliko dijelova koji međusobno djeluju: kontejner, za obradu cijelog životnog ciklusa kontejnera (dodjela prostora na disku, preuzimanje slika, rad s mrežom, pokretanje, instaliranje i praćenje stanja kontejnera) i runC, okruženje za izvršavanje spremnika, temeljeno na korištenju cgroups i drugim značajkama Linux kernela. Sama docker usluga ostaje, ali sada služi samo za obradu API zahtjeva prevedenih u kontejner.
Instalacija i konfiguracija
Moj omiljeni način instaliranja dockera je docker-machine, koji osim izravne instalacije i konfiguracije dockera na udaljenim poslužiteljima (uključujući razne oblake), omogućuje rad s datotečnim sustavima udaljenih poslužitelja, a također može pokretati razne naredbe.
Međutim, od 2018. projekt gotovo da i nije razvijen, pa ćemo ga instalirati na standardni način za većinu Linux distribucija - dodavanjem repozitorija i instaliranjem potrebnih paketa.
Ova metoda se također koristi za automatiziranu instalaciju, na primjer korištenjem Ansible ili drugih sličnih sustava, ali je neću razmatrati u ovom članku.
Instalacija će se izvršiti na Centos 7, koristit ću virtualni stroj kao poslužitelj, za instalaciju samo pokrenite naredbe ispod:
# 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 staviti ga u startup:
# systemctl enable docker
# systemctl start docker
# firewall-cmd --zone=public --add-port=2377/tcp --permanentDodatno, možete kreirati docker grupu, čiji će korisnici moći raditi s dockerom bez sudoa, postaviti logiranje, omogućiti pristup API-ju izvana i ne zaboravite preciznije konfigurirati firewall (sve što nije dozvoljeno je zabranjeno u primjerima iznad i ispod - ovo sam izostavio radi jednostavnosti i jasnoće), ali neću ulaziti u detalje ovdje.
Ostale značajke
Osim gore spomenutog docker stroja, tu je i docker registry, alat za pohranjivanje slika za kontejnere, kao i docker compose, alat za automatizaciju postavljanja aplikacija u kontejnere, YAML datoteke se koriste za izgradnju i konfiguraciju kontejnera i druge povezane stvari (na primjer, mreže, trajni datotečni sustavi za pohranu podataka).
Također se može koristiti za organiziranje transportera za CICD. Još jedna zanimljiva značajka je rad u cluster modu, takozvani swarm mod (prije verzije 1.12 bio je poznat kao docker swarm), koji vam omogućuje sastavljanje jedne infrastrukture od nekoliko poslužitelja za pokretanje kontejnera. Postoji podrška za virtualnu mrežu na vrhu svih poslužitelja, postoji ugrađeni balanser opterećenja, kao i podrška za tajne za kontejnere.
Za takve se klastere mogu koristiti YAML datoteke iz docker compose uz manje izmjene, potpuno automatizirajući održavanje malih i srednjih klastera za različite namjene. Za velike klastere, Kubernetes je poželjniji jer troškovi održavanja swarm načina mogu premašiti troškove Kubernetesa. Osim runC-a, možete instalirati, na primjer, okruženje za izvršavanje spremnika
Rad s Dockerom
Nakon instalacije i konfiguracije, pokušat ćemo sastaviti klaster u kojem ćemo implementirati GitLab i Docker Registry za razvojni tim. Koristit ću tri virtualna računala kao poslužitelje, na koje ću dodatno postaviti distribuirani FS GlusterFS; koristit ću ga kao pohranu docker volumena, na primjer, za pokretanje verzije docker registra otporne na greške. Ključne komponente za pokretanje: Docker Registry, Postgresql, Redis, GitLab s podrškom za GitLab Runner povrh Swarma. Pokrenut ćemo Postgresql s klasteriranjem , tako da ne morate koristiti GlusterFS za pohranu Postgresql podataka. Preostali kritični podaci bit će pohranjeni na GlusterFS.
Za implementaciju GlusterFS-a na svim poslužiteljima (oni se nazivaju node1, node2, node3), morate instalirati pakete, omogućiti firewall i 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-a mora se nastaviti s jednog čvora, na primjer čvora1:
# 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 trebate montirati rezultirajući volumen (naredba se mora izvršiti na svim poslužiteljima):
# mount /srv/dockerSwarm mod je konfiguriran na jednom od poslužitelja, koji će biti voditelj, ostali će se morati pridružiti klasteru, tako da će rezultat izvršenja naredbe na prvom poslužitelju trebati kopirati i izvršiti na ostalima.
Početno postavljanje klastera, pokrećem naredbu 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 naredbe i izvršavamo ga 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.U ovom trenutku, preliminarna konfiguracija poslužitelja je dovršena, nastavimo s postavljanjem usluga; naredbe koje će se izvršiti bit će pokrenute iz čvora1, osim ako nije drugačije navedeno.
Prije svega, stvorimo mreže za spremnike:
# 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 vezanje nekih servisa na 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 node3Zatim kreiramo direktorije za pohranu etcd podataka, KV pohranu, koja je potrebna za Traefik i Stolon. Slično kao i Postgresql, to će biti spremnici vezani uz poslužitelje, pa ovu naredbu pokrećemo na svim poslužiteljima:
# mkdir -p /srv/etcdZatim stvorite datoteku za konfiguraciju etcd i upotrijebite je:
00etcd.yml
version: '3.7'
services:
etcd1:
image: quay.io/coreos/etcd:latest
hostname: etcd1
command:
- 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
networks:
- etcd
volumes:
- etcd1vol:/data.etcd
deploy:
replicas: 1
placement:
constraints: [node.labels.nodename == node1]
etcd2:
image: quay.io/coreos/etcd:latest
hostname: etcd2
command:
- 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
networks:
- etcd
volumes:
- etcd2vol:/data.etcd
deploy:
replicas: 1
placement:
constraints: [node.labels.nodename == node2]
etcd3:
image: quay.io/coreos/etcd:latest
hostname: etcd3
command:
- 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
networks:
- etcd
volumes:
- etcd3vol:/data.etcd
deploy:
replicas: 1
placement:
constraints: [node.labels.nodename == node3]
volumes:
etcd1vol:
driver: local
driver_opts:
type: none
o: bind
device: "/srv/etcd"
etcd2vol:
driver: local
driver_opts:
type: none
o: bind
device: "/srv/etcd"
etcd3vol:
driver: local
driver_opts:
type: none
o: bind
device: "/srv/etcd"
networks:
etcd:
external: true# docker stack deploy --compose-file 00etcd.yml etcdNakon nekog vremena provjeravamo je li etcd klaster pokrenut:
# 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 healthyStvaramo direktorije za Postgresql, izvršavamo naredbu na svim poslužiteljima:
# mkdir -p /srv/pgsqlZatim izradite datoteku za konfiguraciju Postgresqla:
01pgsql.yml
version: '3.7'
services:
pgsentinel:
image: sorintlab/stolon:master-pg10
command:
- 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
networks:
- etcd
- pgsql
deploy:
replicas: 3
update_config:
parallelism: 1
delay: 30s
order: stop-first
failure_action: pause
pgkeeper1:
image: sorintlab/stolon:master-pg10
hostname: pgkeeper1
command:
- 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
networks:
- etcd
- pgsql
environment:
- PGDATA=/var/lib/postgresql/data
volumes:
- pgkeeper1:/var/lib/postgresql/data
secrets:
- pgsql
- pgsql_repl
deploy:
replicas: 1
placement:
constraints: [node.labels.nodename == node1]
pgkeeper2:
image: sorintlab/stolon:master-pg10
hostname: pgkeeper2
command:
- 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
networks:
- etcd
- pgsql
environment:
- PGDATA=/var/lib/postgresql/data
volumes:
- pgkeeper2:/var/lib/postgresql/data
secrets:
- pgsql
- pgsql_repl
deploy:
replicas: 1
placement:
constraints: [node.labels.nodename == node2]
pgkeeper3:
image: sorintlab/stolon:master-pg10
hostname: pgkeeper3
command:
- 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
networks:
- etcd
- pgsql
environment:
- PGDATA=/var/lib/postgresql/data
volumes:
- pgkeeper3:/var/lib/postgresql/data
secrets:
- pgsql
- pgsql_repl
deploy:
replicas: 1
placement:
constraints: [node.labels.nodename == node3]
postgresql:
image: sorintlab/stolon:master-pg10
command: 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
networks:
- etcd
- pgsql
deploy:
replicas: 3
update_config:
parallelism: 1
delay: 30s
order: stop-first
failure_action: rollback
volumes:
pgkeeper1:
driver: local
driver_opts:
type: none
o: bind
device: "/srv/pgsql"
pgkeeper2:
driver: local
driver_opts:
type: none
o: bind
device: "/srv/pgsql"
pgkeeper3:
driver: local
driver_opts:
type: none
o: bind
device: "/srv/pgsql"
secrets:
pgsql:
file: "/srv/docker/postgres"
pgsql_repl:
file: "/srv/docker/replica"
networks:
etcd:
external: true
pgsql:
external: trueGeneriramo tajne i koristimo 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 (pogledajte izlaz naredbe docker service lsda sve usluge rade) 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 initProvjera spremnosti 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 otvaranje pristupa spremnicima izvana:
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 Cluster, da bismo to učinili stvaramo 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 <<EOF > /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 redisDodaj Docker registar:
06registar.yml
version: '3.7'
services:
registry:
image: registry:2.6
networks:
- traefik
volumes:
- registry_data:/var/lib/registry
deploy:
replicas: 1
placement:
constraints: [node.role == manager]
restart_policy:
condition: on-failure
labels:
- traefik.enable=true
- traefik.http.routers.registry.rule=Host(`registry.example.com`)
- traefik.http.services.registry.loadbalancer.server.port=5000
- traefik.docker.network=traefik
volumes:
registry_data:
driver: local
driver_opts:
type: none
o: bind
device: "/srv/docker/registry"
networks:
traefik:
external: true# mkdir /srv/docker/registry
# docker stack deploy --compose-file 06registry.yml registryI na kraju - GitLab:
08gitlab-runner.yml
version: '3.7'
services:
gitlab:
image: gitlab/gitlab-ce:latest
networks:
- pgsql
- redis
- traefik
- gitlab
ports:
- 22222:22
environment:
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'] = "[email protected]"
gitlab_rails['smtp_password'] = "xxxxxxxxx"
gitlab_rails['smtp_domain'] = "example.com"
gitlab_rails['gitlab_email_from'] = '[email protected]'
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
volumes:
- gitlab_conf:/etc/gitlab
- gitlab_logs:/var/log/gitlab
- gitlab_data:/var/opt/gitlab
deploy:
mode: replicated
replicas: 1
placement:
constraints:
- node.role == manager
labels:
- 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:
image: gitlab/gitlab-runner:latest
networks:
- gitlab
volumes:
- gitlab_runner_conf:/etc/gitlab
- /var/run/docker.sock:/var/run/docker.sock
deploy:
mode: replicated
replicas: 1
placement:
constraints:
- node.role == manager
volumes:
gitlab_conf:
driver: local
driver_opts:
type: none
o: bind
device: "/srv/docker/gitlab/conf"
gitlab_logs:
driver: local
driver_opts:
type: none
o: bind
device: "/srv/docker/gitlab/logs"
gitlab_data:
driver: local
driver_opts:
type: none
o: bind
device: "/srv/docker/gitlab/data"
gitlab_runner_conf:
driver: local
driver_opts:
type: none
o: bind
device: "/srv/docker/gitlab/runner"
networks:
pgsql:
external: true
redis:
external: true
traefik:
external: true
gitlab:
external: 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 se još može poboljšati? Obavezno konfigurirajte Traefik za pokretanje spremnika preko https-a, dodajte tls enkripciju za Postgresql i Redis. Ali općenito, već se može dati programerima kao PoC. Pogledajmo sada alternative Dockeru.
podman
Još jedan prilično dobro poznat mehanizam za pokretanje kontejnera grupiranih po podovima (podovi, grupe spremnika raspoređenih zajedno). Za razliku od Dockera, ne zahtijeva nikakvu uslugu za pokretanje spremnika; sav se posao obavlja putem libpod biblioteke. Također napisan u Go, zahtijeva OCI-kompatibilno runtime za pokretanje spremnika, kao što je runC.
Rad s Podmanom općenito podsjeća na onaj za Docker, do te mjere da to možete učiniti ovako (kao što su izjavili mnogi koji su to isprobali, uključujući i autora ovog članka):
$ alias docker=podmani možete nastaviti s radom. Općenito, situacija s Podmanom je vrlo zanimljiva, jer ako su rane verzije Kubernetesa radile s Dockerom, onda je negdje oko 2015. godine, nakon standardizacije svijeta kontejnera (OCI - Open Container Initiative) i podjele Dockera na containerd i runC, došlo do toga da se na kraju pojavio novi koncept Kubernetesa. razvija se alternativa Dockeru za rad u Kubernetesu: CRI-O. Podman je u tom smislu alternativa Dockeru, izgrađen na principima Kubernetesa, uključujući grupiranje spremnika, ali glavna svrha projekta je pokretanje kontejnera u stilu Dockera bez dodatnih usluga. Iz očitih razloga, ne postoji swarm mod, budući da programeri jasno kažu da ako trebate klaster, uzmite Kubernetes.
Instalacija
Za instalaciju na Centos 7 samo aktivirajte Extras repozitorij, a zatim sve instalirajte naredbom:
# yum -y install podmanOstale značajke
Podman može generirati jedinice za systemd, čime se rješava problem pokretanja spremnika nakon ponovnog pokretanja poslužitelja. Osim toga, deklarirano je da systemd radi ispravno kao pid 1 u spremniku. Postoji zaseban buildah alat za izgradnju kontejnera, postoje i alati trećih strana - analozi docker-composea, koji također generiraju konfiguracijske datoteke kompatibilne s Kubernetesom, tako da je prijelaz s Podmana na Kubernetes maksimalno pojednostavljen.
Rad s Podmanom
Budući da nema swarm moda (trebali bismo se prebaciti na Kubernetes ako je potreban klaster), skupljat ćemo ga u zasebne spremnike.
Instalirajte podman-compose:
# yum -y install python3-pip
# pip3 install podman-composeRezultirajuća konfiguracijska datoteka za podman malo je drugačija, pa smo, na primjer, morali premjestiti zasebni odjeljak volumena izravno u odjeljak s 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 upProizlaziti:
# 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 ovo moramo saznati naziv ili ID modula:
# 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 spremnika, generirana jedinica za systemd ne radi ništa drugo (primjerice, čisti stare spremnike kada se takav servis ponovno pokrene), pa ćete takve stvari morati napisati sami.
U principu, Podman je dovoljan da probaš što su kontejneri, prebaciš stare konfiguracije za docker-compose, pa kreneš prema Kubernetesu, ako trebaš klaster ili dobiješ lakšu alternativu Dockeru.
rkt
Projekt prije otprilike šest mjeseci zbog činjenice da ga je kupio RedHat, pa se neću detaljnije zadržavati na njemu. Sveukupno je ostavio jako dobar dojam, ali u usporedbi s Dockerom i posebno Podmanom izgleda kao kombajn. Postojala je i distribucija CoreOS-a izgrađena na vrhu rkt-a (iako su izvorno imali Docker), ali je i to završilo s podrškom nakon kupovine RedHata.
Pljusnuti
Više , čiji je autor samo želio izgraditi i pokrenuti kontejnere. Sudeći prema dokumentaciji i kodu, autor se nije pridržavao standarda, već je jednostavno odlučio napisati vlastitu implementaciju, što je u principu i učinio.
Zaključci
Situacija s Kubernetesom je vrlo zanimljiva: s jedne strane, s Dockerom možete izgraditi klaster (u swarm modu), s kojim čak možete pokretati okruženja proizvoda za klijente, to se posebno odnosi na male timove (3-5 ljudi) , ili s malim ukupnim opterećenjem , ili nedostatkom želje za razumijevanjem zamršenosti postavljanja Kubernetesa, uključujući velika opterećenja.
Podman ne pruža punu kompatibilnost, ali ima jednu važnu prednost - kompatibilnost s Kubernetesom, uključujući dodatne alate (buildah i druge). Stoga ću izboru alata za rad pristupiti na sljedeći način: za male timove ili s ograničenim budžetom - Docker (s mogućim swarm modom), za razvoj za sebe na osobnom lokalnom hostu - Podman drugovi, i za sve ostale - Kubernetes.
Nisam siguran da se situacija s Dockerom neće promijeniti u budućnosti, uostalom, oni su pioniri, i također se postupno standardiziraju korak po korak, ali Podman, uz sve svoje nedostatke (radi samo na Linuxu, nema klasteriranja, montaža i druge radnje su rješenja trećih strana) budućnost je jasnija, pa pozivam sve da rasprave o ovim nalazima u komentarima.
PS 3. kolovoza pokrećemo ““, gdje možete saznati više o njegovom radu. Analizirat ćemo sve njegove alate: od osnovnih apstrakcija do mrežnih parametara, nijansi rada s različitim operacijskim sustavima i programskim jezicima. Upoznat ćete se s tehnologijom i razumjeti gdje i kako najbolje koristiti Docker. Također ćemo podijeliti slučajeve najbolje prakse.
Cijena predbilježbe prije izlaska: 5000 RUB. Možete pogledati program Docker Video Course .
Izvor: www.habr.com