TL;DR: ülevaateartikkel konteinerites rakenduste käivitamise keskkondade võrdlemiseks. Vaatluse all on Docker'i ja teiste sarnaste süsteemide võimalused.
Veidi ajalugu, kuidas see kõik algas
Ajalugu
Esimene tuntud viis rakenduse isoleerimiseks on chroot. Samat nimetav süsteemikõne tagab juurkatse muutmise — lubades seega programmile, kes selle esitas, juurdepääsu ainult sellele kataloogile. Kuid kui programmil sees anda superkasutaja õigused, võib see potentsiaalselt "põgeneda" chroot'ist ja saada juurdepääsu põhiosale. Samuti ei piirduta ainult juurkatalooge, vaid ka muid ressursse (mälu, protsessor) ning juurdepääsuga võrgule.
Järgmine meetod on täieliku operatsioonisüsteemi käivitamine konteineris, kasutades operatsioonisüsteemi tuuma mehhanisme. Erinevates operatsioonisüsteemides nimetatakse seda meetodit erinevalt, kuid põhimõte on sama - mitme sõltumatu operatsioonisüsteemi käivitamine, millest igaüks töötab sama tuumaga, millega töötab ka põhiooperatsioonisüsteem. Siia kuuluvad FreeBSD Jails, Solaris Zones, OpenVZ ja LXC Linuxi jaoks. Tagatakse isoleeritus mitte ainult kettaruumi osas, vaid ka teiste ressursside osas, sealhulgas igal konteineril võivad olla piirangud protsessoriaja, RAM-i ja võrgu läbilaskevõime osas. Võrreldes chrootiga on konteinerist väljumine keerulisem, kuna konteineri superkasutajal on juurdepääs ainult konteineri sisule, kuid kuna on vajalik hoida konteeri sees operatsioonisüsteem ajakohasena ja kasutada vanemaid tuumaversioone (see kehtib enim Linuxi, vähemal määral FreeBSD kohta), on eksisteeriv võimalus tuuma isoleerimise süsteemi 'läbistamiseks' ja põhiooperatsioonisüsteemi juurdepääsu saamiseks.
Kuna täisväärtusliku operatsioonisüsteemi käivitamise asemel konteineris (koos initsialiseerimissüsteemi, paketihalduri jne) on võimalik kohe käivitada rakendusi, oluline on tagada rakendustele vajalikud tingimused (vajalikud teekid ja muud failid). Just see idee tõi kaasa rakenduste konteineriseerimise, mille kõige silmapaistvam ja tuntum esindaja on Docker. Võrreldes eelnevate süsteemidega võimaldavad paindlikumad isolatsiooni mehhanismid koos konteinerite vahelise sisseehitatud virtuaalvõrkude toega ning rakenduse oleku jälgimisega konteineris luua ühe tervikliku keskkonna suurest hulgast füüsilistest serveritest konteinerite käitamiseks — ilma manuaalse ressursihalduse vajaduseta.
Docker
Docker on kõige tuntum rakenduste konteinerimise tarkvara. See on kirjutatud Go keeles, kasutab Linuxi tuuma loomulikke omadusi — cgroups, namespaces, capabilities jne, samuti failisüsteeme nagu Aufs ja muud sarnased, et säästa ketta ruumi.
Allikas: wikimedia
Architecture
Versioonist 1.11 alates töötas Docker ühe teenusena, mis haldas kõiki konteineritega seotud toiminguid: konteineripiltide allalaadimist, konteinerite käivitamist, API-päringute töötlemist. Alates versioonist 1.11 on Docker jagatud mitmeks osaks, mis suhtlevad omavahel: containerd, mis haldab konteinerite kogu elutsüklit (valib kettaruumi, laadib alla pilte, hallates võrke, käivitab, installib ja jälgib konteinerite olekut) ja runC, konteinerite käituskeskkond, mis põhineb cgroups'i ja teiste Linuxi kernel'i omaduste kasutamisel. Docker teenus jäi alles, kuid nüüd teenib see ainult API-päringute töötlemiseks, mis suunatakse containerd'le.
Installeerimine ja seadistamine
Minu lemmikmeetod Docker'i installimiseks on docker-machine, mis mitte ainult ei installi ja seosta dockerit kaugserverites (sh erinevates pilvedes), vaid võimaldab ka töötada kaugserverite failisüsteemidega ning käivitada erinevaid käske.
Kuid alates 2018. aastast ei ole projekt praktiliselt arenenud, seetõttu teostame installatsiooni enamiku Linuxi distributsioonide jaoks tavapärasel viisil — lisades repot ja installides vajalikud paketid.
Seda meetodit kasutatakse ka automatiseeritud installatsiooni puhul, näiteks Ansible või sarnaste süsteemide abil, kuid seda artiklis ma käsitlema ei hakka.
Installatsioon toimub CentOS 7-s, serverina kasutan virtuaalmasinat. Installimiseks piisab, kui täita allolevad käsud:
# 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.ioPärast installatsiooni tuleb teenus käivitada ja seada see automaatseks käivitamiseks:
# systemctl enable docker
# systemctl start docker
# firewall-cmd --zone=public --add-port=2377/tcp --permanentLisaks võib luua docker'i grupi, mille kasutajad saavad docker'iga töötada ilma sudo'ta, seadistada logimist, lubada API juurdepääsu väljastpoolt, mitte unustada paremini konfigureerida tulemüüri (keelatud on kõik, mis ei ole lubatud; eespool ja allpool toodud näidetes olen selle lihtsuse ja selguse huvides välja jätnud), kuid siin ma ei peatu detailsemalt.
Teised võimalused
Lisaks eespool mainitud docker machine'ile on olemas ka docker registry, mis on konteinerite piltide salvestamise vahend, ning docker compose — vahend rakenduste konteinerites paigaldamise automatiseerimiseks, kasutades YAML-faile konteinerite ja teiste seotud asjade (näiteks võrgud, püsiv failisüsteem andmete salvestamiseks) koostamiseks ja seadistamiseks.
Selle abil on võimalik korraldada ka CICD torujuhtmeid. Veel üks huvitav võimalus on tööd teha klastrirežiimis, tuntud kui swarm mode (kuni versioonini 1.12 tuntud kui docker swarm), mis võimaldab ühendada mitmest serverist ühe infrastruktuuri konteinerite käitamiseks. Toetatakse virtuaalvõrku kõikide serverite kohal, olemas on sisseehitatud koormuse tasakaalustaja ning konteinerite jaoks ka saladuste toetamist.
Docker Compose'i YAML-failide väikeste muudatustega saab kasutada selliste klastrite jaoks, automatiseerides täielikult väikeste ja keskmiste klastrite hooldust erinevateks eesmärkideks. Suurte klastrite puhul on eelistatud kasutada Kubernetes't, kuna hoolduskulud swarm-režiimis võivad ületada need, mis on seotud Kubernetes'ega. Lisaks runC-le saab konteinerite käitamiseks paigaldada näiteks
Töötamine Dockeriga
Pärast installimist ja seadistamist proovime üles ehitada klastrit, kus paigaldame GitLabi ja Docker Registry arendajate meeskonnale. Serveriteks kasutan kolme virtuaalmasinat, millele paigaldan täiendavalt jaotatud failisüsteemi GlusterFS, mida kasutan docker volumes'ite salvestamiseks, näiteks tõrkepea vältimise versiooni docker registry käitamiseks. Käitamiseks vajalikud põhikomponendid: Docker Registry, Postgresql, Redis, GitLab koos GitLab Runner'iga Swarm'i peal. Postgresql käivitame klasterdatult , seetõttu ei tohiks Postgresql'i andmete salvestamiseks kasutada GlusterFS'i. Ülejäänud kriitilised andmed salvestatakse GlusterFS-i.
GlusterFS-i käivitamiseks kõigil serveritel (mille nimed on node1, node2, node3) tuleb installida pakett, lubada tulekindel töö ja luua vajalikud kataloogid:
# 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/fstabPärast installimist tuleb GlusterFS-i seadistamisega jätkata ühelt sõlme, näiteks 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 dockerSeejärel tuleb loodud mahtu mountida (käsku tuleb täita kõigil serveritel):
# mount /srv/dockerSwarm mode'i seadistamine toimub ühel serveritest, mis saab juhtimisse, teised peavad liituma klastri. Seetõttu tuleb esimese serveri käsu väljundi kopeerida ja täita teistel.
Klastri esialgne seadistamine, käsk on käivitatud node1-l:
# 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 managerKopeerime teise käsu tulemuse, täidame node2-l ja node3-l:
# docker swarm join --token SWMTKN-x-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-xxxxxxxxx xx.xx.xx.xx:2377
This node joined a swarm as a manager.Sellega on serverite esmane seadistamine lõpetatud, alustame teenuste seadistamist. Käskude täitmine toimub node1-l, kui ei ole erinõudeid.
Esiteks loome konteinerite võrgud:
# 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 gitlabSeejärel märgistame serverid, see on vajalik teatud teenuste serveritega seostamiseks:
# docker node update --label-add nodename=node1 node1
# docker node update --label-add nodename=node2 node2
# docker node update --label-add nodename=node3 node3Järgnevalt loome kaustad andmete salvestamiseks etcd, KV-lao, mida on vaja Traefiki ja Stoloniga. Nagu PostgreSQL-i puhul, on need serveritega seotud konteinerid, seega täidame selle käsu kõigil serveritel:
# mkdir -p /srv/etcdJärgnevalt loome konfiguratsioonifaili etcd jaoks ja rakendame selle:
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 etcdMõne aja pärast kontrollime, et etcd klaster on üles tõusnud:
# 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 healthyLoome Postgresql'i jaoks katalooge, käsu täidame kõigil serveritel:
# mkdir -p /srv/pgsqlSeejärel loome Postgresql'i seadistuse faili:
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: trueGenerime salajasi, rakendame faili:
# </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 pgsqlMõne aja pärast (vaatame käsu väljundit docker service ls, et kõik teenused on üles tõusnud) initsialiseerime Postgresql klastrit:
# 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 initKontrollime Postgresql klastrite valmidust:
# 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
Konfigureerime traefik'i konteinerite välised juurdepääsuks:
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 traefikKäivitame Redis klastrit, selleks loome kõikidesse sõlmedesse salvestamise katalooge:
# 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 redisLisame Docker Registry:
06registry.yml
versioon: '3.7'
teenused:
registri:
pilt: registry:2.6
võrgud:
- traefik
maht:
- registry_data:/var/lib/registry
jõud:
koopiad: 1
paigutus:
piirangud: [node.role == manager]
taaskäivitamise_poliitika:
tingimus: on-failure
sildid:
- traefik.enable=true
- traefik.http.routers.registry.rule=Host(`registry.example.com`)
- traefik.http.services.registry.loadbalancer.server.port=5000
- traefik.docker.network=traefik
mahud:
registry_data:
draiver: local
draiver_valikud:
tüüp: none
o: bind
seade: "/srv/docker/registry"
võrgud:
traefik:
väline: true# mkdir /srv/docker/registry
# docker stack deploy --compose-file 06registry.yml registryJa lõpuks — 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'] = "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
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 gitlabKlastri ja teenuste lõppolek:
# 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/tcpMida veel võiks parandada? Traefikis tuleb kindlasti seadistada konteinerite töö https üle, lisada Postgresql ja Redis jaoks tls krüpteerimine. Kuid tervikuna võib juba anda arendajatele PoC-ina. Vaatame nüüd Dockerile alternatiive.
Podman
Veel üks tuntud engine konteinerite käitamiseks, mis on rühmitatud podide (pods, koos töötama paigaldatud konteineritest) järgi. Erinevalt Dockerist ei vaja see konteinerite käitamiseks mingit teenust, kogu töö toimub läbi libpod'i teegi. Samuti on see kirjutatud Go-s ja vajab konteinerite jooksutamiseks OCI-ühilduvat runtime'i, näiteks runC.
Töö Podmaniga meenutab üldiselt Dockeri kasutamist, isegi nii kaugele, et on võimalik teha nii (nagu on väitnud paljud katsetajad, sealhulgas ka artikli autor):
$ alias docker=podmanja saab jätkata tööd. Üldiselt on olukord Podmaniga väga huvitav, kuna varasemad Kubernetes'i versioonid töötasid Dockeriga, siis umbes 2015. aastast, pärast konteinerite maailma standardiseerimist (OCI — Open Container Initiative) ja Docker'i jagunemist containerd ja runC'ks, on arendatud Docker'i alternatiivi Kubernetes'i käivitamiseks: CRI-O. Podman on selles osas Docker'i alternatiiv, mis on üles ehitatud Kubernetes'e põhimõtete järgi, sealhulgas konteinerite rühmitamise osas, kuid projekti peamine eesmärk on käivitada konteinerid Docker'i stiilis ilma lisateenusteta. Arusaadavatel põhjustel ei ole swarm mode'i, kuna arendajad ütlevad selgelt, et kui vajate klastrit — võtke Kubernetes.
Installimine
Centos 7 installimiseks piisab, kui aktiveerida Extras repositoorium, peale mida saab kõik installida käsuga:
# yum -y install podmanTeised võimalused
Podman suudab genereerida üksusi systemd jaoks, lahendades seega konteinerite käivitamise probleemi pärast serveri taaskäivitamist. Lisaks on kinnitatud, et systemd töötab õigesti pid 1 rollis konteineris. Konteinerite koostamiseks kasutatakse eraldi tööriista buildah, eksisteerivad ka kolmandate osapoolte tööriistad – sarnased docker-compose'ile, mis genereerib sealhulgas Kubernetes'ega ühilduvaid konfiguratsioonifaile, muutes ülemineku Podmanilt Kubernetes'ele võimalikult lihtsaks.
Töötamine Podmaniga
Kuna puudub swarm mode (eeldatakse üleminekut Kubernetes'ile, kui on vajalik klaster) – kogume eraldi konteinerite kaupa.
Installime podman-compose:
# yum -y install python3-pip
# pip3 install podman-composeTekkinud konfiguratsioonifail podmani jaoks on veidi erinev, näiteks tuli eraldi sektsioon volumes otse viia teenuste sektsiooni.
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 upTulemused:
# 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_1Vaadakem, mida ta generaatoritele systemd ja Kubernetes genereerib, selleks on vaja teada podi nime või ID-d:
# 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.targetKahjuks generatsiooni systemd ühtki muud funktsiooni peale konteinerite käivitamise ei paku (näiteks vanade konteinerite puhastamine selle teenuse taaskäivitamisel), seetõttu tuleb need asjad ise juurde kirjutada.
Üldiselt on Podman piisav, et proovida, mis on konteinerid, kanda üle vanad konfiguratsioonid docker-compose'ist ning seejärel liikuda Kubernetes'e poole, kui on vaja klastrit, või saada lihtsam alternatiiv Docker'ile.
rkt
Projekt umbes kuus kuud tagasi, kuna selle ostis RedHat, seega ei jää ma sellel edasi peatuma. Üldiselt jättis see üsna hea mulje, kuid võrreldes Dockeriga ja veel enam Podmaniga tundub see olevat kombineeritud lahendus. Samuti eksisteeris CoreOS jaotur, mis põhines rkt-l (kuigi algselt oli neil Docker), kuid selle tugi lõppes samuti pärast RedHati ostu.
Plash
Veel , mille autor soovis lihtsalt konteinerite kogumist ja käivitamist. Koos dokumentatsiooni ja koodiga – autor ei järgitud standardeid, vaid otsustas lihtsalt kirjutada oma rakenduse, mida ta põhimõtteliselt ka tegi.
Järeldused
Kubernetes oleva olukord on väga huvitav: ühelt poolt saab Dockerit kasutada klastrite loomiseks (swarm mode'is), millega saab isegi käivitada klientidele toote keskkondi, see on eriti oluline väikeste meeskondade (3-5 inimest) jaoks või väikese koormuse korral, või juhul kui ei soovi süveneda Kubernetes'i seadistamise peensustesse, sealhulgas kõrge koormuse jaoks.
Podman ei taga täielikku ühilduvust, kuid sellel on üks oluline eelis – ühilduvus Kubernetes'iga, sealhulgas ka lisatööriistade (buildah ja teised) kasutamise võimalus. Seetõttu lähen tööriista valikule nii: väikeste meeskondade või piiratud eelarve korral – Docker (võimaliku swarm režiimiga), enda arendamiseks isiklikul localhost'il – Podman kolleegidega, ja kõigile teistele – Kubernetes.
Ma ei ole kindel, et Docker'i olukord tulevikus ei muutu, nad on ikkagi pioneerid ja standardiseeruvad järk-järgult, kuid Podman'il, kõikide oma puuduste (töö ainult Linuxil, klasterdamine puudub, ehitamine ja muud toimingud – kolmandate osapoolte lahendustega) juures on tulevik selgem, seetõttu kutsub ma kõiki huvilisi kommenteerima neid järeldusi.
P.S. 3. augustil käivitame „“, kus saab lähemalt tutvuda selle tööga. Uurime kõiki selle tööriistu: alates põhiabstraktsioonidest kuni võrguparameetrite, erinevate opsüsteemide ja programmeerimiskeelte nüanssideni. Te tutvute tehnoloogiaga ja saate aru, kus ja kuidas on parim kasutada Docker'it. Jagame ka parimaid praktikakatsed.
Eelkäitmise hind enne väljaandmist: 5000 r. Programmiga „Videokursus Dockerist“ saate tutvuda .
Allikas: habr.com
