TL;DR: áttekintő cikk, amely összehasonlítja az alkalmazásokat futtató környezeteket. Megvizsgáljuk a Docker és más hasonló rendszerek lehetőségeit.
Egy kis történelem, honnan indult minden
Történet
Az első közismert módszer az alkalmazás izolálására a chroot. Az azonos nevű rendszerhívás biztosítja a gyökérkönyvtár megváltoztatását — ezzel biztosítva, hogy a program, amelyik ezt hívta, csak a fájlokhoz férjen hozzá ebben a könyvtárban. De ha a program számára superuser jogokat adunk, potenciálisan el tud 'szöktetni' a chroot-ból, és hozzáférhet az alapvető operációs rendszerhez. A gyökérkönyvtár megváltoztatásán kívül más erőforrások (memória, processzor) és a hálózathoz való hozzáférés sincs korlátozva.
A következő módszer — teljes operációs rendszer futtatása a konténeren belül a rendszer kernel mechanizmusainak segítségével. Különböző operációs rendszereken ezt a módszert különböző neveken emlegetik, de a lényeg ugyanaz — több független operációs rendszer futtatása, amelyek mindegyike ugyanazzal a kernellel működik, mint az alap operációs rendszer. Ide tartozik a FreeBSD Jails, Solaris Zones, OpenVZ és LXC a Linux számára. Az izoláció biztosítva van, nemcsak a lemezterületre, hanem más erőforrásokra is, például minden konténernek lehetnek korlátozásai a processzorteljesítményre, a memóriahasználatra és a sávszélességre. A chroot-hoz képest nehezebb kijutni a konténerből, mivel a konténer superuser-e csak a konténer összetevőihez fér hozzá, azonban az operációs rendszer folyamatos frissítése és régi kernel verziók használata (ami a Linuxra vonatkozik, a FreeBSD-re kisebb mértékben) miatt fennáll a lehetőség a kernel izolációs rendszerének átszakítására és az alap operációs rendszerhez való hozzáférésre.
A teljes operációs rendszer futtatása helyett egy konténerben (kezdeti rendszerrel, csomagkezelővel, stb.) közvetlenül alkalmazásokat lehet futtatni, a legfontosabb, hogy a szükséges könyvtárak és egyéb fájlok rendelkezésre álljanak az alkalmazások számára. Ez az ötlet adta az alapját az alkalmazáskonténerizálásnak, amelynek legkiemelkedőbb és legismertebb képviselője a Docker. Az előző rendszerekhez képest rugalmasabb izolációs mechanizmusok, a konténerek közötti virtuális hálózatok beépített támogatása, valamint a konténeren belüli alkalmazásállapot nyomon követése lehetővé tette egy kiterjedt, fizikai szerverekből álló integrált környezet létrehozását konténerek futtatásához — anélkül, hogy manuális erőforráskezelésre lenne szükség.
Docker
A Docker a legismertebb szoftver az alkalmazások konténerizálására. A Go nyelven íródott, és a Linux kernel natív képességeit — cgroups, namespaces, capabilities stb. —, valamint az Aufs fájlrendszereket és hasonlókat használ a lemezterület megtakarítására.
Forrás: wikimedia
Architektúra
Az 1.11-es verzió előtt a Docker egyetlen szolgáltatásként működött, amely minden konténerrel kapcsolatos műveletet ellátott: konténerképek letöltését, konténerek indítását, API-kérések kezelését. Az 1.11-es verziótól a Dockert több részre osztották, amelyek egymással kommunikálnak: a containerd a konténerek teljes életciklusát kezeli (tárolóhely kiosztása, képek letöltése, hálózati működés, indítás, telepítés és a konténerek állapotának figyelése), a runC pedig a konténerek futtatási környezete, amely a cgroups és a Linux kernel egyéb képességein alapul. Maga a Docker szolgáltatás megmaradt, de most már csak az API-kérések kezelésére szolgál, amelyeket a containerd-hez közvetít.
Telepítés és beállítás
A kedvenc módszerem a Docker telepítésére a docker-machine, amely nemcsak a Docker telepítését és konfigurálását teszi lehetővé távoli szervereken (beleértve a különféle felhőszolgáltatásokat), hanem a távoli szerverek fájlrendszereivel való munkát is biztosít, és különböző parancsok indítására is képes.
Azonban 2018 óta a projekt szinte nem fejlődik, ezért a telepítést a legtöbb Linux disztribúcióban szokásos módon, a tároló hozzáadásával és a szükséges csomagok telepítésével fogjuk végezni.
Ez a módszer automatizált telepítésnél is alkalmazható, például Ansible vagy hasonló rendszerek segítségével, de ebben a cikkben nem fogom tárgyalni.
A telepítés CentOS 7-re fog történni, a szerverem egy virtuális gép lesz, a telepítéshez csupán az alábbi parancsokat kell végrehajtani:
# 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.ioA telepítés után el kell indítani a szolgáltatást, és be kell állítani az automatikus indítást:
# systemctl enable docker
# systemctl start docker
# firewall-cmd --zone=public --add-port=2377/tcp --permanentTovábbá létrehozható egy docker csoport, amelynek felhasználói sudo nélkül is tudnak dolgozni a dockerrel, beállítható a naplózás, biztosítani kell a külső API-hozzáférést, és pontosan be kell állítani a tűzfalat (megengedni csak azt, ami szükséges, az egyszerűség és áttekinthetőség kedvéért a fenti és az alábbi példákban ezt kihagytam), de erről most nem szeretnék részletesebben beszélni.
Egyéb lehetőségek
A fent említett docker machine mellett van még a docker registry, amely a konténerekhez szükséges képek tárolására szolgáló eszköz, valamint a docker compose — az alkalmazások konténerekbe való automatizált telepítésére szolgáló eszköz, amely YAML fájlokat használ a konténerek és egyéb kapcsolódó dolgok (például hálózatok, állandó fájlrendszerek adatok tárolásához) összeállításához és beállításához.
Ezen felül lehetőség van CICD folyamatok szervezésére is. Egy másik érdekes lehetőség a klaszteres üzemmód, az úgynevezett swarm mód (1.12-es verzió előtt docker swarm néven volt ismert), amely lehetővé teszi, hogy több szerverből egyetlen infrastruktúrát alakítsunk ki a konténerek futtatására. Támogatott a virtuális hálózatok létrehozása az összes szerver fölött, van beépített terheléselosztó, valamint titkosítási lehetőségek is a konténerek számára.
A docker compose YAML fájlok kis módosításokkal használhatók az ilyen klaszterekhez, teljesen automatizálva a kicsi és közepes klaszterek karbantartását különböző célokra. Nagy klaszterek esetén előnyösebb a Kubernetes használata, mivel a swarm mód karbantartási költségei meghaladhatják a Kubernetes költségeit. A runC mellett például más konténer futtatási környezetet is telepíthetünk.
Dockerrel való munkavégzés
Telepítés és beállítás után próbáljunk összeállítani egy klasztert, amelyen a GitLab-ot és a Docker Registry-t futtatjuk a fejlesztőcsapat számára. Három virtuális gépet fogok használni, amelyeken egy elosztott fájlrendszert, a GlusterFS-t is telepítek, ezt a docker volume-ok tárolására fogom használni, például a redundáns docker registry indításához. A kulcsfontosságú komponensek a következők: Docker Registry, Postgresql, Redis, GitLab GitLab Runner támogatással Swarm környezetben. A Postgresql-t klaszterezéssel fogjuk futtatni. , ezért a Postgresql adatok tárolására nem szükséges a GlusterFS használata. A többi kritikus adat a GlusterFS-en lesz tárolva.
A GlusterFS telepítéséhez minden szerveren (node1, node2, node3 néven) csomagokat kell telepíteni, engedélyezni kell a tűzfal működését, létre kell hozni a szükséges könyvtárakat:
# 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/fstabA GlusterFS beállítási munkálatait egy csomópontból, például node1-ből kell folytatni:
# 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 dockerEzután csatolni kell az elkészített volume-ot (a parancsot minden szerveren végre kell hajtani):
# mount /srv/dockerA swarm mód beállítását az egyik szerveren, amely a Leader lesz, kell elvégezni, a többi csatlakozni fog a klaszterhez, így az első szerveren végrehajtott parancs eredményét le kell másolni, és a többi szerveren is végre kell hajtani.
A klaszter kezdeti beállítása, a parancsot node1-en indítom:
# 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 managerÁtmásoljuk a második parancs eredményét, végrehajtjuk node2-n és node3-on:
# docker swarm join --token SWMTKN-x-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-xxxxxxxxx xx.xx.xx.xx:2377
This node joined a swarm as a manager.Ezzel a szerverek előzetes beállítása befejeződött, most a szolgáltatások beállításához kezdünk hozzá, a végrehajtandó parancsokat node1-ről indítjuk, ha másként nincs megadva.
Először létrehozunk hálózatokat a konténerek számára:
# 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 gitlabEzután megjelöljük a szervereket, ez szükséges néhány szolgáltatás szerverekhez való hozzárendeléséhez:
# docker node update --label-add nodename=node1 node1
# docker node update --label-add nodename=node2 node2
# docker node update --label-add nodename=node3 node3Ezután létrehozunk könyvtárakat az etcd adatok tárolásához, a KV-tárolóhoz, amely a Traefik és a Stolon számára szükséges. Hasonlóan a Postgresql-hez ezek a szerverekhez hozzárendelt konténerek lesznek, ezért ezt a parancsot minden szerveren végre kell hajtani:
# mkdir -p /srv/etcdEzután létrehozunk egy fájlt az etcd beállításához és alkalmazzuk:
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 etcdEgy kis idő elteltével ellenőrizzük, hogy az etcd klaszter működik-e:
# 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 healthyLétrehozzuk a könyvtárakat a Postgresql számára, a parancsot minden szerveren végrehajtjuk:
# mkdir -p /srv/pgsqlEzután létrehozzuk a Postgresql beállításához szükséges fájlt:
01pgsql.yml
verzió: '3.7'
szolgáltatások:
pgsentinel:
kép: sorintlab/stolon:master-pg10
parancs:
- 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
hálózatok:
- etcd
- pgsql
telepítés:
replikák: 3
frissítési_config:
párhuzamosság: 1
késleltetés: 30s
sorrend: stop-first
hiba_akció: pause
pgkeeper1:
kép: sorintlab/stolon:master-pg10
hoszt_név: pgkeeper1
parancs:
- 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
hálózatok:
- etcd
- pgsql
környezet:
- PGDATA=/var/lib/postgresql/data
kötetek:
- pgkeeper1:/var/lib/postgresql/data
titkok:
- pgsql
- pgsql_repl
telepítés:
replikák: 1
elhelyezés:
korlátozások: [node.labels.nodename == node1]
pgkeeper2:
kép: sorintlab/stolon:master-pg10
hoszt_név: pgkeeper2
parancs:
- 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
hálózatok:
- etcd
- pgsql
környezet:
- PGDATA=/var/lib/postgresql/data
kötetek:
- pgkeeper2:/var/lib/postgresql/data
titkok:
- pgsql
- pgsql_repl
telepítés:
replikák: 1
elhelyezés:
korlátozások: [node.labels.nodename == node2]
pgkeeper3:
kép: sorintlab/stolon:master-pg10
hoszt_név: pgkeeper3
parancs:
- 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
hálózatok:
- etcd
- pgsql
környezet:
- PGDATA=/var/lib/postgresql/data
kötetek:
- pgkeeper3:/var/lib/postgresql/data
titkok:
- pgsql
- pgsql_repl
telepítés:
replikák: 1
elhelyezés:
korlátozások: [node.labels.nodename == node3]
postgresql:
kép: sorintlab/stolon:master-pg10
parancs: 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
hálózatok:
- etcd
- pgsql
telepítés:
replikák: 3
frissítési_config:
párhuzamosság: 1
késleltetés: 30s
sorrend: stop-first
hiba_akció: rollback
kötetek:
pgkeeper1:
meghajtó: helyi
meghajtó_opciók:
típus: none
o: bind
eszköz: "/srv/pgsql"
pgkeeper2:
meghajtó: helyi
meghajtó_opciók:
típus: none
o: bind
eszköz: "/srv/pgsql"
pgkeeper3:
meghajtó: helyi
meghajtó_opciók:
típus: none
o: bind
eszköz: "/srv/pgsql"
titkok:
pgsql:
fájl: "/srv/docker/postgres"
pgsql_repl:
fájl: "/srv/docker/replica"
hálózatok:
etcd:
külső: igaz
pgsql:
külső: igazTitkokat generálunk, alkalmazzuk a fájlt:
# </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 pgsqlEgy kis idő elteltével (megtekintjük a parancs kimenetét: docker service ls, hogy minden szolgáltatás elindult) inicializáljuk a Postgresql klasztert:
# 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 initEllenőrizzük a Postgresql klaszter készenlétét:
# 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
Beállítjuk a traefik-et a konténerek külső hozzáférésének megnyitásához:
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 traefikElindítjuk a Redis klasztert, ehhez minden csomóponton létrehozunk egy tárolási könyvtárat:
# 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 redisHozzáadjuk a Docker Registry-t:
06registry.yml
verzió: '3.7'
szolgáltatások:
registry:
kép: registry:2.6
hálózatok:
- traefik
kötetek:
- registry_data: /var/lib/registry
telepítés:
replikák: 1
elhelyezés:
korlátozások: [node.role == manager]
újraindítási_állapot:
feltétel: on-failure
címkék:
- traefik.enable=true
- traefik.http.routers.registry.rule=Host(`registry.example.com`)
- traefik.http.services.registry.loadbalancer.server.port=5000
- traefik.docker.network=traefik
követek:
registry_data:
meghajtó: local
meghajtó_opciók:
típus: none
o: bind
eszköz: "/srv/docker/registry"
hálózatok:
traefik:
külső: true# mkdir /srv/docker/registry
# docker stack deploy --compose-file 06registry.yml registryÉs végül — GitLab:
08gitlab-runner.yml
verzió: '3.7'
szolgáltatások:
gitlab:
kép: gitlab/gitlab-ce:latest
hálózatok:
- pgsql
- redis
- traefik
- gitlab
portok:
- 22222:22
környezet:
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
kötetek:
- gitlab_conf:/etc/gitlab
- gitlab_logs:/var/log/gitlab
- gitlab_data:/var/opt/gitlab
telepítés:
mód: replikált
replikák: 1
elhelyezés:
korlátozások:
- node.role == manager
címkék:
- 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:
kép: gitlab/gitlab-runner:latest
hálózatok:
- gitlab
kötetek:
- gitlab_runner_conf:/etc/gitlab
- /var/run/docker.sock:/var/run/docker.sock
telepítés:
mód: replikált
replikák: 1
elhelyezés:
korlátozások:
- node.role == manager
követek:
gitlab_conf:
meghajtó: local
meghajtó_opciók:
típus: none
o: bind
eszköz: "/srv/docker/gitlab/conf"
gitlab_logs:
meghajtó: local
meghajtó_opciók:
típus: none
o: bind
eszköz: "/srv/docker/gitlab/logs"
gitlab_data:
meghajtó: local
meghajtó_opciók:
típus: none
o: bind
eszköz: "/srv/docker/gitlab/data"
gitlab_runner_conf:
meghajtó: local
meghajtó_opciók:
típus: none
o: bind
eszköz: "/srv/docker/gitlab/runner"
hálózatok:
pgsql:
külső: true
redis:
külső: true
traefik:
külső: true
gitlab:
külső: 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 gitlabA klaszter és a szolgáltatások végső állapota:
# 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/tcpMi mást lehetne még javítani? Kötelező beállítani a Traefik működését a konténerekhez https alatt, hozzáadni a tls titkosítást a Postgresql és Redis számára. De összességében már átadható a fejlesztőknek PoC-ként. Most nézzük meg a Docker alternatíváit.
Podman
Még egy elég ismert engine konténerek futtatásához, amelyeket podokba (pods, a közösen telepített konténerek csoportjai) csoportosítanak. Eltérően a Dockertől, nem igényel semmilyen szolgáltatást a konténerek futtatásához, az egész munka a libpod könyvtáron keresztül zajlik. Emellett Go nyelven íródott, és OCI-kompatibilis futási környezetre van szüksége a konténerek futtatásához, például a runC-re.
A Podman használata általában hasonlít a Dockerhez, egészen odáig, hogy meg lehet csinálni ezt (sokan próbálva ezt állították, beleértve a cikk szerzőjét is):
$ alias docker=podmanés folytathatjuk a munkát. Összességében a Podman helyzete nagyon érdekes, hiszen míg a Kubernetes korai verziói a Dockert használták, 2015 körül, a konténer világának standardizálása (OCI - Open Container Initiative) és a Docker containerd-re és runC-re való felosztása után, alternatíva alakult ki a Docker számára a Kubernetes környezetben: a CRI-O. Ebben a tekintetben a Podman a Docker alternatívája, amely a Kubernetes elvein alapul, beleértve a konténerek csoportosítását is, de a projekt fő célja a konténerek Docker-stílusú futtatása további szolgáltatások nélkül. Érthető okokból nincs swarm üzemmód, mivel a fejlesztők egyértelműen kijelentik, hogy ha klaszterre van szükség, akkor használjuk a Kubernetest.
Telepítés
Centos 7 alatt a telepítéshez elegendő aktiválni az Extras tárolót, majd az összes telepíthető a következő paranccsal:
# yum -y install podmanEgyéb lehetőségek
A Podman képes generálni egységeket a systemd számára, ezáltal megoldva a konténerek indításának problémáját a szerver újraindítása után. Továbbá kijelentették, hogy a systemd helyes működése pid 1-ként a konténerben. A konténerek összeszereléséhez külön eszköz, a buildah használatos, ezen kívül léteznek harmadik féltől származó eszközök - docker-compose megfelelői, amelyek konfigurációs fájlokat is generálnak, a Kubernetes-kompatibilis fájlokat, így a Podmanről a Kubernetesre való átmenet annyira egyszerűsített, amennyire lehetséges.
A Podman használata
Mivel nincs swarm üzemmód (az feltételezi a Kubernetre való átmenetet, ha klaszterre van szükség) - különálló konténereket fogunk összeszerelni.
Telepítjük a podman-compose-t:
# yum -y install python3-pip
# pip3 install podman-composeA podman számára készült végeredmény konfigurációs fájl kicsit eltér, például a külön szakaszok áthelyezésére volt szükség a szolgáltatások szekciójába.
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 upA munka eredménye:
# 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_1Nézzük meg, mit generál a systemd és a kubernetes számára, ehhez meg kell tudnunk a pod nevét vagy az ID-ját:
# 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.targetSajnos, a konténerek indításán kívül a systemd-hez generált egység másra nem szolgál (például régi konténerek törlésére egy ilyen szolgáltatás újraindításakor), ezért ezeket a dolgokat magunknak kell hozzáadnunk.
Alapvetően a Podman elég ahhoz, hogy megismerkedjünk a konténerekkel, áthelyezzük a régi konfigurációkat a docker-compose-ból, majd ha a klaszter szükséges, áttérjünk a Kubernetes-re, vagy egy egyszerűbben kezelhető alternatívát kapjunk a Docker helyett.
rkt
Projekt körülbelül fél évvel ezelőtt, mivel a RedHat megvásárolta, ezért nem fogok többet beszélni róla. Egyébként elég jó benyomást keltett, de a Dockerhez és különösen a Podmanhoz képest egy kombájn. Létezett egy CoreOS disztribúció is, amely a rkt alapjaira épült (bár kezdetben volt Docker is), de a támogatása is véget ért a RedHat felvásárlása után.
Plash
További , amelynek szerzője csak konténereket akart gyűjteni és futtatni. A dokumentáció és a kód alapján – a szerző nem követte a szabványokat, hanem egyszerűen úgy döntött, hogy megírja a saját megvalósítását, amit lényegében meg is tett.
Következtetések
A Kubernetes megléte érdekesen alakul: egyrészt a Docker segítségével klasztert lehet felépíteni (swarm mód), amellyel akár termelési környezeteket is indíthatunk az ügyfelek számára, ez különösen releváns a kis csapatok (3-5 fő) esetében, vagy kis terhelés esetén, vagy ha nincs kedv arra, hogy a Kubernetes részleteivel foglalkozzunk, beleértve a magas terhelésekhez szükséges beállításokat is.
A Podman nem garantál teljes kompatibilitást, de van egy fontos előnye - a Kubernetes-kompatibilitás, beleértve a kiegészítő eszközöket (buildah és mások). Ezért az eszköz kiválasztásához így közelítek: kis csapatok számára, vagy korlátozott költségvetés esetén - Docker (lehetséges swarm móddal), személyes localhoston való fejlesztéshez - Podman a barátokkal, míg mindenki másnak - Kubernetes.
Nem vagyok biztos benne, hogy a Docker helyzete a jövőben nem változik meg, végül is ők a pionírok, és lépésről lépésre fokozatosan standardizálódnak, de a Podman-tel, bár mindkét hátrányával (csak Linuxon működik, nincs klaszterezés, összeállítás és egyéb feladatok - külső megoldásokkal) a jövő világosabb, ezért arra hívok minden érdeklődőt, hogy vitassuk meg ezeket a következtetéseket a kommentekben.
P.S. Augusztus 3-án elindítjuk a "", ahol részletesebben megismerkedhet a működésével. Megvizsgáljuk az összes eszközét: az alapvető absztrakcióktól kezdve a hálózati paraméterekig, az operációs rendszerekkel és programozási nyelvekkel kapcsolatos részletekig. Megismerkedik a technológiával és megérti, hol és hogyan érdemes a Dockert használni. Emellett megosztunk best practice eseteket is.
A megjelenés előtti előrendelés ára: 5000 Ft. A "Videokurzus a Docker-ről" programját itt lehet áttekinteni .
Forrás: habr.com
