TL;DR: Ülevaatlik artikkel – juhend keskkondade võrdlemiseks konteinerites rakenduste käitamiseks. Kaalutakse Dockeri ja teiste sarnaste süsteemide võimalusi.
Väike ajalugu, kust see kõik pärit on
Lugu
Esimene tuntud viis rakenduse isoleerimiseks on chroot. Samanimeline süsteemikutse annab muudatuse juurkataloogis - seega annab juurdepääsu programmile, mis seda kutsus, juurdepääsu ainult selles kataloogis olevatele failidele. Kuid kui programmile antakse sees superkasutaja õigused, võib see potentsiaalselt chrootist "põgeneda" ja pääseda juurde põhioperatsioonisüsteemile. Lisaks juurkataloogi muutmisele pole piiratud ka muud ressursid (RAM, protsessor), samuti juurdepääs võrgule.
Järgmine võimalus on käivitada konteineris täisväärtuslik operatsioonisüsteem, kasutades operatsioonisüsteemi tuuma mehhanisme. Seda meetodit nimetatakse erinevates operatsioonisüsteemides erinevalt, kuid olemus on sama – mitme sõltumatu operatsioonisüsteemi käivitamine, millest igaüks töötab samas tuumas, mis jookseb põhioperatsioonisüsteemi. See hõlmab FreeBSD vanglaid, Solarise tsoone, OpenVZ-i ja LXC Linuxi jaoks. Isolatsiooni pakutakse mitte ainult kettaruumi, vaid ka muude ressursside jaoks, eriti võib igal konteineril olla piiranguid protsessori ajale, RAM-ile, võrgu ribalaiusele. Võrreldes chrootiga on konteinerist lahkumine keerulisem, kuna konteineris oleval superkasutajal on juurdepääs ainult konteineri sisemusele, kuid konteineri sees olev operatsioonisüsteem tuleb ajakohasena hoida ja vana kerneli kasutamine. versioonide puhul (asjakohane Linuxi, vähemal määral FreeBSD jaoks), on nullist erinev tõenäosus tuuma isolatsioonisüsteemist "läbi murda" ja pääseda ligi põhioperatsioonisüsteemile.
Selle asemel, et käivitada täisväärtuslik operatsioonisüsteem konteineris (initsialiseerimissüsteemiga, paketihalduriga jne), saab rakendusi kohe käivitada, peaasi, et rakendustele see võimalus oleks tagatud (vajalike teekide olemasolu ja muud failid). See idee oli aluseks konteineriseeritud rakenduste virtualiseerimisele, mille silmapaistvaim ja tuntuim esindaja on Docker. Võrreldes varasemate süsteemidega võimaldasid paindlikumad isoleerimismehhanismid koos konteineritevaheliste virtuaalsete võrkude sisseehitatud toega ja konteinerisisese rakenduse olekolekuga luua ühe tervikliku keskkonna suurest hulgast füüsilistest serveritest konteinerite käitamiseks – ilma käsitsi ressursside haldamise vajadus.
laevalaadija
Docker on kõige tuntum rakenduste konteineriseerimistarkvara. Go keeles kirjutatud, kasutab see Linuxi kerneli tavalisi võimalusi – cgroup’e, nimeruume, võimalusi jne, aga ka Aufsi failisüsteeme ja muud sarnast kettaruumi säästmiseks.
Allikas: wikimedia
arhitektuur
Enne versiooni 1.11 töötas Docker ühtse teenusena, mis teostas konteineritega kõiki toiminguid: konteinerite piltide allalaadimine, konteinerite käivitamine, API päringute töötlemine. Alates versioonist 1.11 on Docker jagatud mitmeks osaks, mis omavahel suhtlevad: konteinerid, mis käsitlevad konteinerite kogu elutsüklit (kettaruumi eraldamine, piltide allalaadimine, võrgu loomine, käivitamine, installimine ja konteinerite oleku jälgimine) ja runC , konteineri käitusajad, mis põhinevad cgroupside ja muude Linuxi kerneli funktsioonide kasutamisel. Dockeri teenus ise jääb alles, kuid nüüd teenib see ainult konteinerisse edastatud API taotluste töötlemist.
Paigaldamine ja seadistamine
Minu lemmikviis dokkeri paigaldamiseks on docker-machine, mis lisaks kaugserveritesse (sh erinevatesse pilvedesse) dockeri otsesele paigaldamisele ja seadistamisele võimaldab töötada kaugserverite failisüsteemidega, samuti saab käivitada erinevaid käske.
Alates 2018. aastast pole projekti aga peaaegu üldse arendatud, mistõttu installime selle enamiku Linuxi distributsioonide puhul tavapärasel viisil – hoidla lisamise ja vajalike pakettide installimisega.
Seda meetodit kasutatakse ka automatiseeritud installimiseks, näiteks Ansible või muude sarnaste süsteemide abil, kuid ma ei käsitle seda selles artiklis.
Installimine toimub Centos 7-s, ma kasutan serverina virtuaalset masinat, installimiseks käivitage lihtsalt 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 installimist peate teenuse käivitama, panema selle automaatsesse laadimisse:
# systemctl enable docker
# systemctl start docker
# firewall-cmd --zone=public --add-port=2377/tcp --permanentLisaks saate luua dokkerite grupi, mille kasutajad saavad töötada dockeriga ilma sudota, seadistada logimist, võimaldada juurdepääsu API-le väljastpoolt, ärge unustage tulemüüri peenhäälestada (kõik, mis pole lubatud, on ülaltoodud ja allolevates näidetes keelatud - lihtsuse ja visualiseerimise huvides jätsin selle välja), kuid ma ei hakka siin üksikasjalikumalt rääkima.
Teised omadused
Lisaks ülaltoodud dokkimismasinale on olemas ka dokkeregister, tööriist konteinerite piltide salvestamiseks, samuti dockeri koostamine - tööriist rakenduste konteinerites juurutamise automatiseerimiseks, YAML-faile kasutatakse konteinerite ehitamiseks ja konfigureerimiseks ning muud seotud asjad (näiteks võrgud, püsivad failisüsteemid andmete salvestamiseks).
Seda saab kasutada ka CICD torujuhtmete korraldamiseks. Veel üks huvitav funktsioon on klastrirežiimis töötamine, nn sülemirežiim (enne versiooni 1.12 oli see tuntud kui docker swarm), mis võimaldab konteinerite käitamiseks kokku panna mitmest serverist ühe infrastruktuuri. Kõigi serverite peal on virtuaalse võrgu tugi, sisseehitatud koormuse tasakaalustaja, samuti konteinerite saladuste tugi.
Docker Compose'i YAML-faile saab selliste klastrite jaoks kasutada väikeste muudatustega, automatiseerides täielikult väikeste ja keskmiste klastrite hoolduse erinevatel eesmärkidel. Suurte klastrite jaoks on eelistatav Kubernetes, kuna sülemirežiimi hoolduskulud võivad ületada Kubernetese omad. Lisaks runC-le saab konteinerite täitmiskeskkonnana installida näiteks
Dockeriga töötamine
Pärast installimist ja seadistamist proovime luua klastri, milles juurutame arendusmeeskonna jaoks GitLabi ja Dockeri registri. Serveritena kasutan kolme virtuaalmasinat, millele lisaks juurutan GlusterFS-i hajutatud FS-i, kasutan seda näiteks dokkide mahtude salvestusruumina, et käivitada näiteks dockeri registri tõrkekindlat versiooni. Põhikomponendid, mida käitada: Docker Registry, Postgresql, Redis, GitLab koos GitLab Runneri toega Swarmi peal. Postgresql käivitatakse koos klastritega , nii et te ei pea Postgresqli andmete salvestamiseks kasutama GlusterFS-i. Ülejäänud kriitilised andmed salvestatakse GlusterFS-i.
GlusterFS-i juurutamiseks kõikides serverites (neid nimetatakse node1, node2, node3) peate installima paketid, lubama tulemüüri, looma 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 tööd GlusterFS-i seadistamisega jätkata ühest sõlmest, 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 peate installima saadud helitugevuse (käsk tuleb käivitada kõigis serverites):
# mount /srv/dockerSwarm-režiim on konfigureeritud ühes serveris, millest saab Leader, ülejäänud peavad liituma klastriga, seega tuleb esimeses serveris käsu käivitamise tulemus kopeerida ja käivitada ülejäänud serveris.
Klastri esialgne seadistamine, käivitan käsu sõlmes1:
# 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 managerKopeerige teise käsu tulemus, käivitage node2 ja node3:
# docker swarm join --token SWMTKN-x-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-xxxxxxxxx xx.xx.xx.xx:2377
This node joined a swarm as a manager.Sellega on lõpetatud serverite eelkonfigureerimine, alustame teenuste seadistamist, käivitatavad käsud käivitatakse sõlmest1, kui pole teisiti määratud.
Kõigepealt loome konteinerite jaoks 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ärgime serverid, see on vajalik mõne teenuse sidumiseks serveritega:
# docker node update --label-add nodename=node1 node1
# docker node update --label-add nodename=node2 node2
# docker node update --label-add nodename=node3 node3Järgmisena loome kataloogid etcd andmete salvestamiseks, KV salvestusruumi, mida Traefik ja Stolon vajavad. Sarnaselt Postgresqliga on need serveritega seotud konteinerid, seega täidame selle käsu kõigis serverites:
# mkdir -p /srv/etcdJärgmisena looge fail etcd konfigureerimiseks ja rakendage see:
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, kas etcd-klaster on 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 healthyLooge Postgresqli jaoks kataloogid, täitke käsk kõigis serverites:
# mkdir -p /srv/pgsqlJärgmisena looge Postgresqli konfigureerimiseks fail:
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: trueLoome saladusi, 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õni aeg hiljem (vaadake käsu väljundit dokkimisteenus lset kõik teenused on tõusnud) lähtestage 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 initPostgresql-i klastri valmisoleku kontrollimine:
# 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
Seadistame traefiku avama juurdepääsu konteineritele väljastpoolt:
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 Clusteri, selleks loome kõigis sõlmedes salvestuskataloogi:
# 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 redisDockeri registri lisamine:
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 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'] = "[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 gitlabKlastri ja teenuste lõplik olek:
# 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 saab veel parandada? Kindlasti konfigureerige Traefik töötama https-konteineritega, lisage Postgresqli ja Redise jaoks tls-krüptimine. Aga üldiselt saab selle juba PoC-na arendajatele anda. Vaatame nüüd Dockeri alternatiive.
podman
Veel üks üsna tuntud mootor kaunade järgi rühmitatud konteinerite (kaunad, konteinerite rühmad koos kasutusele võetud) käitamiseks. Erinevalt Dockerist ei vaja see konteinerite käitamiseks teenust, kogu töö tehakse libpodi teegi kaudu. Samuti on kirjas Go, vajab OCI-ga ühilduvat käitusaega, et käitada selliseid konteinereid nagu runC.
Podmaniga töötamine sarnaneb üldiselt Dockeriga, kuivõrd saate seda teha nii (väidavad paljud, kes on seda proovinud, sealhulgas selle artikli autor):
$ alias docker=podmanja saate tööd jätkata. Üldiselt on olukord Podmaniga väga huvitav, sest kui Kubernetese varased versioonid töötasid koos Dockeriga, siis alates umbes 2015. aastast, pärast konteinerimaailma standardiseerimist (OCI – Open Container Initiative) ja Dockeri jagamist konteineriteks ja runC-ks, alternatiiviks Dockerit arendatakse Kubernetesis töötamiseks: CRI-O. Podman on selles osas alternatiiv Dockerile, mis on üles ehitatud Kubernetese põhimõtetel, sealhulgas konteinerite rühmitamisel, kuid projekti põhieesmärk on Dockeri stiilis konteinerite käitamine ilma lisateenusteta. Arusaadavatel põhjustel sülemirežiimi pole, kuna arendajad ütlevad selgelt, et kui teil on vaja klastrit, võtke Kubernetes.
Paigaldamine
Centos 7 installimiseks aktiveerige lihtsalt hoidla Lisad ja installige seejärel kõik käsuga:
# yum -y install podmanTeised omadused
Podman saab genereerida systemd jaoks üksusi, lahendades nii konteinerite käivitamise probleemi pärast serveri taaskäivitamist. Lisaks deklareeritakse, et systemd töötab konteineris õigesti kui pid 1. Konteinerite ehitamiseks on eraldi buildah tööriist, on ka kolmanda osapoole tööriistu – docker-compose analooge, mis genereerib ka Kubernetesiga ühilduvaid konfiguratsioonifaile, nii et üleminek Podmanilt Kubernetesele on võimalikult lihtne.
Koostöö Podmaniga
Kuna sülemirežiimi pole (kui klastrit on vaja, peaks see lülituma Kubernetesele), siis paneme selle kokku eraldi konteineritesse.
Installige podman-compose:
# yum -y install python3-pip
# pip3 install podman-composeSaadud podmani konfiguratsioonifail on veidi erinev, kuna näiteks pidime eraldi köidete jaotise teisaldama otse 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 upTöö tulemus:
# 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_1Vaatame, mida see systemd ja kubernetes jaoks genereerib, selleks peame välja selgitama podi nime või ID:
# 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: {}süsteemne:
# 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 ei tee systemd jaoks loodud üksus peale konteinerite käitamise midagi muud (näiteks puhastab vanad konteinerid sellise teenuse taaskäivitamisel), seega peate sellised asjad ise lisama.
Põhimõtteliselt piisab Podmanist, et proovida, mis konteinerid on, vanad konfiguratsioonid docker-compose jaoks üle kanda ja siis vajadusel klastri peal Kubernetese poole minna või hankida Dockerile mõni lihtsamini kasutatav alternatiiv.
rkt
Projekt umbes kuus kuud tagasi tänu sellele, et RedHat selle ostis, nii et ma sellel pikemalt ei peatu. Üldiselt jättis see väga hea mulje, aga võrreldes Dockeriga ja veelgi enam Podmaniga näeb see välja nagu kombain. Rkt-le oli ehitatud ka CoreOS-i distributsioon (kuigi algselt oli neil Docker), kuid seegi lõppes pärast RedHati ostu.
Välklamp
Rohkem , mille autor tahtis just konteinereid ehitada ja käitada. Dokumentatsiooni ja koodi järgi otsustades ei järginud autor standardeid, vaid otsustas lihtsalt kirjutada oma teostuse, mida ta põhimõtteliselt ka tegi.
Järeldused
Kubernetesega on olukord väga huvitav: ühest küljest saab Dockeriga kokku panna (swarm-režiimis) klastri, millega saab isegi klientidele tootmiskeskkondi käivitada, see kehtib eriti väikeste (3-5 inimest) meeskondade kohta. ) või väikese üldkoormusega või soovimatus mõista Kubernetese seadistamise keerukust, sealhulgas suurte koormuste puhul.
Podman ei paku täielikku ühilduvust, kuid sellel on üks oluline eelis - ühilduvus Kubernetesiga, sealhulgas lisatööriistad (buildah ja teised). Seetõttu lähenen töövahendi valikule järgmiselt: väikestele meeskondadele või piiratud eelarvega - Docker (võimaliku sülemirežiimiga), isiklikul kohalikul hostil enda jaoks arendamiseks - Podmani seltsimehed ja kõik teised - Kubernetes.
Ma pole kindel, et Dockeriga olukord tulevikus ei muutu, nemad on ju teerajajad ja ka tasapisi samm-sammult standardiseerivad, aga Podman koos kõigi oma puudustega (töötab ainult Linuxis, klasterdamist, kokkupanekut pole ja muud tegevused on kolmanda osapoole otsused) tulevik on selgem, seega kutsun kõiki neid leide kommentaarides arutama.
PS 3. augustil käivitame "kust saate tema tööga lähemalt tutvuda. Analüüsime kõiki selle tööriistu: alates põhilistest abstraktsioonidest kuni võrguparameetriteni, erinevate operatsioonisüsteemide ja programmeerimiskeeltega töötamise nüanssideni. Saate tutvuda tehnoloogiaga ja mõistate, kus ja kuidas Dockerit kõige paremini kasutada. Jagame ka parimate tavade juhtumeid.
Ettetellimise maksumus enne vabastamist: 5000 rubla. Programm "Docker Video Course" on leitav .
Allikas: www.habr.com