TL; DR: pregledni vodnik za primerjavo ogrodij za izvajanje aplikacij v vsebnikih. Upoštevane bodo zmogljivosti Dockerja in drugih podobnih sistemov.
Malo zgodovine, od kod vse je prišlo
Zgodba
Prva dobro znana metoda za izolacijo aplikacije je chroot. Istoimenski sistemski klic poskrbi za spremembo korenskega imenika – tako zagotovi, da ima program, ki ga je poklical, dostop samo do datotek v tem imeniku. Toda če ima program interno dodeljene korenske pravice, lahko potencialno »pobegne« iz chroota in pridobi dostop do glavnega operacijskega sistema. Prav tako poleg spreminjanja korenskega imenika drugi viri (RAM, procesor) in dostop do omrežja niso omejeni.
Naslednja metoda je zagon polnopravnega operacijskega sistema znotraj vsebnika z uporabo mehanizmov jedra operacijskega sistema. Ta metoda se v različnih operacijskih sistemih imenuje drugače, vendar je bistvo enako - zagon več neodvisnih operacijskih sistemov, od katerih vsak poganja isto jedro, na katerem teče glavni operacijski sistem. Sem spadajo FreeBSD Jails, Solaris Zones, OpenVZ in LXC za Linux. Izolacija ni zagotovljena le s prostorom na disku, ampak tudi z drugimi viri; zlasti ima lahko vsak vsebnik omejitve procesorskega časa, RAM-a in pasovne širine omrežja. V primerjavi s chrootom je zapuščanje vsebnika težje, saj ima superuporabnik v vsebniku dostop le do vsebine vsebnika, vendar zaradi potrebe po posodabljanju operacijskega sistema v vsebniku in uporabe starejših različic jeder (pomembno za Linux, v manjši meri za FreeBSD), obstaja neničelna verjetnost, da bi "prebili" sistem izolacije jedra in pridobili dostop do glavnega operacijskega sistema.
Namesto zagona polnega operacijskega sistema v vsebniku (z inicializacijskim sistemom, upraviteljem paketov itd.), Lahko takoj zaženete aplikacije, glavna stvar je, da aplikacijam zagotovite takšno priložnost (prisotnost potrebnih knjižnic in druge datoteke). Ta ideja je služila kot osnova za kontejnersko virtualizacijo aplikacij, katere najvidnejši in najbolj znani predstavnik je Docker. V primerjavi s prejšnjimi sistemi so bolj prilagodljivi izolacijski mehanizmi, skupaj z vgrajeno podporo za virtualna omrežja med vsebniki in sledenjem stanja aplikacije znotraj vsebnika, omogočili izgradnjo enega samega koherentnega okolja iz velikega števila fizičnih strežnikov za izvajanje vsebnikov – brez potrebe po ročnem upravljanju virov.
Lučki delavec
Docker je najbolj znana programska oprema za shranjevanje aplikacij. Napisan je v jeziku Go in uporablja standardne funkcije jedra Linuxa - cgroups, imenske prostore, zmogljivosti itd., kot tudi datotečne sisteme Aufs in druge podobne za prihranek prostora na disku.
Vir: wikimedia
arhitektura
Pred različico 1.11 je Docker deloval kot ena sama storitev, ki je izvajala vse operacije z vsebniki: nalaganje slik za vsebnike, zagon vsebnikov, obdelava zahtev API. Od različice 1.11 je bil Docker razdeljen na več delov, ki medsebojno delujejo: vsebnik za obdelavo celotnega življenjskega cikla vsebnikov (dodeljevanje prostora na disku, prenos slik, delo z omrežjem, zagon, namestitev in spremljanje stanja vsebnikov) in runC, okolje izvajanja vsebnika, ki temelji na uporabi cgroups in drugih funkcij jedra Linuxa. Sama storitev docker ostaja, vendar zdaj služi le za obdelavo zahtev API, prevedenih v vsebnik.
Namestitev in konfiguracija
Moj najljubši način namestitve dockerja je docker-machine, ki poleg neposredne namestitve in konfiguracije dockerja na oddaljenih strežnikih (vključno z različnimi oblaki) omogoča delo z datotečnimi sistemi oddaljenih strežnikov in lahko izvaja tudi različne ukaze.
Vendar od leta 2018 projekt skorajda ni bil razvit, zato ga bomo namestili na standarden način za večino distribucij Linuxa - dodajanje repozitorija in namestitev potrebnih paketov.
Ta metoda se uporablja tudi za avtomatizirano namestitev, na primer z uporabo Ansible ali drugih podobnih sistemov, vendar je v tem članku ne bom obravnaval.
Namestitev bo izvedena na Centos 7, kot strežnik bom uporabil virtualni stroj, za namestitev samo zaženite spodnje ukaze:
# 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.ioPo namestitvi morate zagnati storitev in jo postaviti v zagon:
# systemctl enable docker
# systemctl start docker
# firewall-cmd --zone=public --add-port=2377/tcp --permanentDodatno lahko ustvarite docker skupino, katere uporabniki bodo lahko delali z dockerjem brez sudo, nastavili beleženje, omogočili dostop do API-ja od zunaj in ne pozabite natančneje konfigurirati požarnega zidu (vse, kar ni dovoljeno je prepovedano v zgornjih in spodnjih primerih - to sem zaradi enostavnosti in jasnosti izpustil), vendar tukaj ne bom šel v več podrobnosti.
Druge lastnosti
Poleg zgoraj omenjenega docker stroja je tu še docker register, orodje za shranjevanje slik za vsebnike, pa tudi docker compose, orodje za avtomatizacijo umestitve aplikacij v vsebnike, datoteke YAML se uporabljajo za gradnjo in konfiguracijo vsebnikov. in druge povezane stvari (na primer omrežja, trajni datotečni sistemi za shranjevanje podatkov).
Lahko se uporablja tudi za organizacijo transporterjev za CICD. Zanimiva lastnost je tudi delo v načinu gruče, tako imenovani način roja (pred različico 1.12 je bil znan kot docker swarm), ki omogoča sestavljanje ene same infrastrukture iz več strežnikov za poganjanje kontejnerjev. Na vrhu vseh strežnikov je podpora za virtualno omrežje, vgrajen je izravnalnik obremenitve, pa tudi podpora za skrivnosti za vsebnike.
Datoteke YAML iz docker compose se lahko z manjšimi spremembami uporabljajo za takšne gruče, kar popolnoma avtomatizira vzdrževanje majhnih in srednje velikih gruč za različne namene. Za velike grozde je bolje uporabiti Kubernetes, ker lahko stroški vzdrževanja načina roja presežejo stroške Kubernetesa. Poleg runC lahko namestite na primer kot okolje izvajanja vsebnika
Delo z Dockerjem
Po namestitvi in konfiguraciji bomo poskusili sestaviti gručo, v katero bomo za razvojno ekipo namestili GitLab in Docker Registry. Kot strežnike bom uporabil tri virtualne stroje, na katere bom dodatno namestil distribuirani FS GlusterFS, ki ga bom uporabil kot shrambo docker volumnov, na primer za poganjanje različice docker registra, ki je tolerantna na napake. Ključne komponente za zagon: Docker Registry, Postgresql, Redis, GitLab s podporo za GitLab Runner na vrhu Swarm. Zagnali bomo Postgresql z združevanjem v gruče , zato vam za shranjevanje podatkov Postgresql ni treba uporabljati GlusterFS. Preostali kritični podatki bodo shranjeni na GlusterFS.
Če želite namestiti GlusterFS na vse strežnike (imenujejo se node1, node2, node3), morate namestiti pakete, omogočiti požarni zid in ustvariti potrebne imenike:
# 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/fstabPo namestitvi je treba delo pri konfiguriranju GlusterFS nadaljevati z enega vozlišča, na primer vozlišča1:
# 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 dockerNato morate namestiti nastali nosilec (ukaz je treba izvesti na vseh strežnikih):
# mount /srv/dockerNačin roja je konfiguriran na enem od strežnikov, ki bo vodilni, ostali se bodo morali pridružiti gruči, zato bo treba rezultat izvajanja ukaza na prvem strežniku kopirati in izvesti na ostalih.
Začetna nastavitev gruče, zaženem ukaz na vozlišču1:
# 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 drugega ukaza in ga izvedemo na node2 in node3:
# docker swarm join --token SWMTKN-x-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-xxxxxxxxx xx.xx.xx.xx:2377
This node joined a swarm as a manager.Na tej točki je predhodna konfiguracija strežnikov končana, nadaljujmo z nastavitvijo storitev; ukazi, ki jih je treba izvesti, bodo zagnani iz vozlišča1, razen če ni drugače določeno.
Najprej ustvarimo omrežja za vsebnike:
# 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 gitlabNato označimo strežnike, to je potrebno za vezavo nekaterih storitev na strežnike:
# docker node update --label-add nodename=node1 node1
# docker node update --label-add nodename=node2 node2
# docker node update --label-add nodename=node3 node3Nato ustvarimo imenike za shranjevanje etcd podatkov, KV shranjevanje, ki je potrebno za Traefik in Stolon. Podobno kot pri Postgresqlu bodo to vsebniki, povezani s strežniki, zato ta ukaz izvajamo na vseh strežnikih:
# mkdir -p /srv/etcdNato ustvarite datoteko za konfiguracijo etcd in jo uporabite:
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 etcdČez nekaj časa preverimo, ali je gruča etcd pripravljena:
# 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 healthyUstvarimo imenike za Postgresql, izvedemo ukaz na vseh strežnikih:
# mkdir -p /srv/pgsqlNato ustvarite datoteko za konfiguracijo Postgresql:
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: trueUstvarimo skrivnosti in uporabimo datoteko:
# </dev/urandom tr -dc 234567890qwertyuopasdfghjkzxcvbnmQWERTYUPASDFGHKLZXCVBNM | head -c $(((RANDOM%3)+15)) > /srv/docker/replica
# </dev/urandom tr -dc 234567890qwertyuopasdfghjkzxcvbnmQWERTYUPASDFGHKLZXCVBNM | head -c $(((RANDOM%3)+15)) > /srv/docker/postgres
# docker stack deploy --compose-file 01pgsql.yml pgsqlČez nekaj časa (glejte izhod ukaza docker service lsda vse storitve delujejo) inicializiramo gručo Postgresql:
# 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 initPreverjanje pripravljenosti gruče Postgresql:
# 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 odpiranje dostopa do vsebnikov od zunaj:
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 traefikZaženemo Redis Cluster, za to ustvarimo imenik za shranjevanje na vseh vozliščih:
# 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 redisDodajte register Docker:
06registry.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 registryIn končno - 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 gitlabKončno stanje gruče in storitev:
# 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/tcpKaj je še mogoče izboljšati? Prepričajte se, da konfigurirate Traefik za izvajanje vsebnikov prek https, dodajte šifriranje tls za Postgresql in Redis. Toda na splošno ga je že mogoče dati razvijalcem kot PoC. Poglejmo zdaj alternative Dockerju.
podman
Še en dokaj dobro poznan motor za zagon vsebnikov, združenih po podih (podi, skupine vsebnikov, nameščenih skupaj). Za razliko od Dockerja ne potrebuje nobene storitve za izvajanje vsebnikov; vse delo poteka prek knjižnice libpod. Napisano tudi v Go, zahteva izvajalno okolje, združljivo z OCI, za zagon vsebnikov, kot je runC.
Delo s Podmanom na splošno spominja na delo z Dockerjem, do te mere, da lahko to storite takole (kot trdijo mnogi, ki so to poskusili, vključno z avtorjem tega članka):
$ alias docker=podmanin lahko nadaljujete z delom. Nasploh je situacija s Podmanom zelo zanimiva, kajti če so zgodnje različice Kubernetesa delovale z Dockerjem, potem je okoli leta 2015, po standardizaciji sveta vsebnikov (OCI – Open Container Initiative) in delitvi Dockerja na container in runC, prišlo do tega, da se je začelo dogajanje v zvezi s Podmanom. razvija se alternativa Dockerju za delovanje v Kubernetesu: CRI-O. Podman je v tem pogledu alternativa Dockerju, zgrajen na načelih Kubernetesa, vključno z združevanjem vsebnikov, vendar je glavni namen projekta zagon vsebnikov v slogu Docker brez dodatnih storitev. Iz očitnih razlogov ni načina roja, saj razvijalci jasno pravijo, da če potrebujete gručo, vzemite Kubernetes.
Namestitev
Za namestitev na Centos 7 samo aktivirajte repozitorij Extras in nato vse namestite z ukazom:
# yum -y install podmanDruge lastnosti
Podman lahko ustvari enote za systemd in tako reši problem zagona vsebnikov po ponovnem zagonu strežnika. Poleg tega je navedeno, da sistem pravilno deluje kot pid 1 v vsebniku. Obstaja ločeno orodje buildah za gradnjo vsebnikov, obstajajo tudi orodja tretjih oseb - analogi docker-compose, ki prav tako ustvarjajo konfiguracijske datoteke, združljive s Kubernetesom, tako da je prehod iz Podmana v Kubernetes čim bolj poenostavljen.
Delo s Podmanom
Ker ni swarm načina (če je potreben grozd naj bi preklopili na Kubernetes), ga bomo zbirali v ločenih posodah.
Namestite podman-compose:
# yum -y install python3-pip
# pip3 install podman-composeDobljena konfiguracijska datoteka za podman je nekoliko drugačna, tako da smo na primer morali premakniti ločen razdelek z nosilci neposredno v razdelek s storitvami.
gitlab-podman.yml
version: '3.7'
services:
gitlab:
image: gitlab/gitlab-ce:latest
hostname: gitlab.example.com
restart: unless-stopped
environment:
GITLAB_OMNIBUS_CONFIG: |
gitlab_rails['gitlab_shell_ssh_port'] = 22222
ports:
- "80:80"
- "22222:22"
volumes:
- /srv/podman/gitlab/conf:/etc/gitlab
- /srv/podman/gitlab/data:/var/opt/gitlab
- /srv/podman/gitlab/logs:/var/log/gitlab
networks:
- gitlab
gitlab-runner:
image: gitlab/gitlab-runner:alpine
restart: unless-stopped
depends_on:
- gitlab
volumes:
- /srv/podman/gitlab/runner:/etc/gitlab-runner
- /var/run/docker.sock:/var/run/docker.sock
networks:
- gitlab
networks:
gitlab:# podman-compose -f gitlab-runner.yml -d uprezultat:
# 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_1Poglejmo, kaj ustvari za systemd in kubernetes, za to moramo najti ime ali ID sklopa:
# 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 generirana enota za systemd razen zagona vsebnikov ne počne nič drugega (na primer čiščenje starih vsebnikov ob ponovnem zagonu takšne storitve), zato boste morali takšne stvari napisati sami.
Načeloma je Podman dovolj, da preizkusite, kaj so kontejnerji, prenesete stare konfiguracije za docker-compose in se nato premaknete na Kubernetes, če potrebujete gručo, ali pa dobite lažjo alternativo Dockerju.
rkt
Projekt pred približno šestimi meseci zaradi dejstva, da ga je kupil RedHat, zato se o njem ne bom podrobneje ukvarjal. Na splošno je pustil zelo dober vtis, vendar v primerjavi z Dockerjem in predvsem Podmanom deluje kot kombajn. Obstajala je tudi distribucija CoreOS, zgrajena na vrhu rkt (čeprav so prvotno imeli Docker), vendar se je tudi ta končala s podporo po nakupu RedHat.
Pliš
Več , katerega avtor je samo želel zgraditi in zagnati kontejnerje. Sodeč po dokumentaciji in kodi avtor ni sledil standardom, ampak se je preprosto odločil napisati svojo izvedbo, kar je načeloma tudi storil.
Ugotovitve
Situacija s Kubernetesom je zelo zanimiva: po eni strani lahko z Dockerjem zgradite gručo (v načinu roja), s katero lahko izvajate celo produktna okolja za stranke, to še posebej velja za majhne ekipe (3-5 ljudi) ali z majhno skupno obremenitvijo ali pomanjkanjem želje po razumevanju zapletenosti nastavitve Kubernetesa, vključno z velikimi obremenitvami.
Podman ne zagotavlja popolne združljivosti, ima pa eno pomembno prednost - združljivost s Kubernetes, vključno z dodatnimi orodji (buildah in drugimi). Zato bom k izbiri orodja za delo pristopil takole: za majhne ekipe ali z omejenim proračunom - Docker (z možnim načinom roja), za razvoj zase na osebnem lokalnem gostitelju - tovariši Podman in za vse ostale - Kubernetes.
Nisem prepričan, da se situacija z Dockerjem v prihodnosti ne bo spremenila, navsezadnje so pionirji in se postopoma korak za korakom tudi standardizirajo, Podman pa kljub vsem svojim pomanjkljivostim (deluje samo na Linuxu, brez gručenja, montaža in druga dejanja so rešitve tretjih oseb) prihodnost je jasnejša, zato vabim vse, da razpravljajo o teh ugotovitvah v komentarjih.
PS 3. avgusta začnemo “«, kjer lahko izveste več o njegovem delu. Analizirali bomo vsa njegova orodja: od osnovnih abstrakcij do omrežnih parametrov, odtenkov dela z različnimi operacijskimi sistemi in programskimi jeziki. Spoznali boste tehnologijo in razumeli, kje in kako najbolje uporabiti Docker. Delili bomo tudi primere najboljše prakse.
Cena prednaročila pred izdajo: 5000 rubljev. Ogledate si lahko program Docker Video Course .
Vir: www.habr.com