TL;DR: In oersjochartikel - in hantlieding foar it fergelykjen fan omjouwings foar it útfieren fan applikaasjes yn konteners. De mooglikheden fan Docker en oare ferlykbere systemen sille wurde beskôge.
In bytsje skiednis fan wêr't it allegear wei kaam
История
De earste bekende manier om in applikaasje te isolearjen is chroot. De systeemoprop mei deselde namme jout in wiziging yn 'e root-map - dus tagong ta it programma dat it neamde, tagong allinich ta bestannen yn dizze map. Mar as it programma superuser-rjochten binnen kriget, kin it mooglik "ûntkommen" út 'e chroot en tagong krije ta it haadbestjoeringssysteem. Ek, neist it feroarjen fan de root-map, binne oare boarnen (RAM, prosessor), lykas tagong ta it netwurk, net beheind.
De folgjende manier is om in folweardich bestjoeringssysteem yn 'e kontener te lansearjen, mei de meganismen fan' e kernel fan it bestjoeringssysteem. Dizze metoade wurdt oars neamd yn ferskate bestjoeringssystemen, mar de essinsje is itselde - it útfieren fan ferskate ûnôfhinklike bestjoeringssystemen, elk fan dat rint op deselde kearn dy't it haadbestjoeringssysteem rint. Dit omfettet FreeBSD Jails, Solaris Zones, OpenVZ, en LXC foar Linux. Isolaasje wurdt foarsjoen net allinnich foar skiif romte, mar ek foar oare boarnen, yn it bysûnder, eltse container kin hawwe beheinings op prosessor tiid, RAM, netwurk bânbreedte. Yn ferliking mei chroot is it ferlitten fan 'e kontener dreger, om't de superbrûker yn' e kontener allinich tagong hat ta de binnenkant fan 'e kontener, lykwols, troch de needsaak om it bestjoeringssysteem yn' e kontener by de tiid te hâlden en it gebrûk fan âlde kernel ferzjes (relevant foar Linux, yn mindere mate FreeBSD), is d'r in net-nul de kâns dat it kernel-isolaasjesysteem "trochbrekke" en tagong krije ta it haadbestjoeringssysteem.
Yn stee fan it lansearjen fan in folweardich bestjoeringssysteem yn in kontener (mei in inisjalisaasjesysteem, in pakketbehearder, ensfh.), kinne applikaasjes fuortendaliks lansearre wurde, it wichtichste is om applikaasjes dizze kâns te jaan (de oanwêzigens fan de nedige biblioteken en oare bestannen). Dit idee tsjinne as basis foar containerisearre applikaasje-virtualisaasje, wêrfan de meast foaroansteande en bekende fertsjintwurdiger Docker is. Yn ferliking mei eardere systemen resultearren fleksibeler isolaasjemeganismen, tegearre mei ynboude stipe foar firtuele netwurken tusken konteners en tapassing fan tapassing yn in kontener, yn 'e mooglikheid om ien holistyske omjouwing te bouwen fan in grut oantal fysike servers om konteners út te fieren - sûnder de needsaak foar hânmjittich resource management.
Havenarbeider
Docker is de meast bekende applikaasje-containerisaasjesoftware. Skreaun yn 'e Go-taal, brûkt it de reguliere mooglikheden fan' e Linux-kernel - cgroups, nammeromten, mooglikheden, ensfh., lykas Aufs-bestânsystemen en oaren ferlykber om skiifromte te besparjen.
Boarne: wikimedia
arsjitektuer
Foarôfgeand oan ferzje 1.11 wurke Docker as ienige tsjinst dy't alle operaasjes útfierde mei konteners: ôfbyldings downloade foar konteners, konteners lansearje, API-oanfragen ferwurkje. Sûnt ferzje 1.11 is Docker opdield yn ferskate dielen dy't mei-inoar ynteraksje: containerd, om de heule libbenssyklus fan konteners te behanneljen (tawizing fan skiifromte, download fan ôfbyldings, netwurking, lansearje, ynstallearje en kontrolearjen fan de steat fan konteners) en runC , container runtimes, basearre op it brûken fan cgroups en oare funksjes fan de Linux kernel. De docker-tsjinst sels bliuwt, mar tsjinnet no allinich foar it ferwurkjen fan API-oanfragen útstjoerd nei containerd.
Ynstallaasje en konfiguraasje
Myn favorite manier om docker te ynstallearjen is docker-masine, dy't, neist it direkt ynstallearjen en konfigurearjen fan docker op servers op ôfstân (ynklusyf ferskate wolken), jo kinne wurkje mei de triemsystemen fan servers op ôfstân, en ek ferskate kommando's kinne útfiere.
Sûnt 2018 is it projekt lykwols amper ûntwikkele, dus wy sille it op 'e gewoane manier ynstallearje foar de measte Linux-distribúsjes - troch in repository ta te foegjen en de nedige pakketten te ynstallearjen.
Dizze metoade wurdt ek brûkt foar automatisearre ynstallaasje, bygelyks mei Ansible of oare ferlykbere systemen, mar ik sil it net beskôgje yn dit artikel.
Ynstallaasje sil wurde útfierd op Centos 7, ik sil in firtuele masine brûke as server, om te ynstallearjen, útfiere gewoan de kommando's hjirûnder:
# 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.ioNei ynstallaasje moatte jo de tsjinst begjinne, set it yn autoload:
# systemctl enable docker
# systemctl start docker
# firewall-cmd --zone=public --add-port=2377/tcp --permanentDerneist kinne jo in docker-groep oanmeitsje, waans brûkers sûnder sudo mei docker kinne wurkje, logging ynstelle, tagong ta de API fan bûten ynskeakelje, ferjit net om de firewall te fine-tunen (alles wat net tastien is is ferbean yn 'e foarbylden hjirboppe en hjirûnder - ik haw dit weglitten foar ienfâld en fisualisaasje), mar ik sil hjir net mear yngean.
Oare mooglikheden
Neist de boppesteande docker-masine is d'r ek in docker-register, in ark foar it opslaan fan ôfbyldings foar konteners, lykas docker-komponearje - in ark foar it automatisearjen fan de ynset fan applikaasjes yn konteners, YAML-bestannen wurde brûkt om konteners te bouwen en te konfigurearjen en oare relatearre dingen (Bygelyks netwurken, persistente triemsystemen foar it bewarjen fan gegevens).
It kin ek brûkt wurde om pipelines te organisearjen foar CICD. In oare nijsgjirrige funksje wurket yn klustermodus, de saneamde swarmmodus (foar ferzje 1.12 wie it bekend as docker swarm), wêrtroch jo in inkele ynfrastruktuer fan ferskate servers kinne gearstalle om konteners út te fieren. D'r is stipe foar in firtuele netwurk boppe op alle servers, d'r is in ynboude loadbalancer, lykas ek stipe foar geheimen foar konteners.
De YAML-bestannen fan docker compose kinne brûkt wurde foar sokke klusters mei lytse oanpassings, folslein automatisearjen fan it ûnderhâld fan lytse en middelgrutte klusters foar ferskate doelen. Foar grutte klusters is Kubernetes de foarkar, om't de ûnderhâldskosten fan swarmmodus dy fan Kubernetes opweidzje kinne. Neist runC, as in útfieringsomjouwing foar konteners, kinne jo bygelyks ynstallearje
Wurkje mei Docker
Nei ynstallaasje en konfiguraasje sille wy besykje in kluster te bouwen wêryn wy GitLab en Docker Registry sille ynsette foar it ûntwikkelteam. As tsjinners sil ik trije firtuele masines brûke, wêrop ik ek de GlusterFS-ferdielde FS sil ynsette, ik sil it brûke as opslach foar docker-voluminten, bygelyks om in feilige ferzje fan it docker-register út te fieren. Wichtige komponinten om te rinnen: Docker Registry, Postgresql, Redis, GitLab mei stipe foar GitLab Runner boppe op Swarm. Postgresql sil wurde lansearre mei klustering , dus jo hoege GlusterFS net te brûken om Postgresql-gegevens op te slaan. De rest fan 'e krityske gegevens wurde opslein op GlusterFS.
Om GlusterFS op alle servers yn te setten (se wurde node1, node2, node3 neamd), moatte jo pakketten ynstallearje, de firewall ynskeakelje, de nedige mappen oanmeitsje:
# 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/fstabNei ynstallaasje moat it wurk oan it konfigurearjen fan GlusterFS fuortset wurde fan ien node, bygelyks 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 dockerDan moatte jo it resultearjende folume mount (it kommando moat wurde útfierd op alle servers):
# mount /srv/dockerSwarmmodus is konfigureare op ien fan 'e tsjinners, dy't Leader wêze sil, de rest sil by it kluster moatte komme, dus it resultaat fan it útfieren fan it kommando op 'e earste tsjinner sil moatte wurde kopieare en útfierd op 'e rest.
Inisjele kluster opset, ik rin it kommando op node1:
# docker swarm init
Swarm initialized: current node (a5jpfrh5uvo7svzz1ajduokyq) is now a manager.
To add a worker to this swarm, run the following command:
docker swarm join --token SWMTKN-1-0c5mf7mvzc7o7vjk0wngno2dy70xs95tovfxbv4tqt9280toku-863hyosdlzvd76trfptd4xnzd xx.xx.xx.xx:2377
To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.
# docker swarm join-token managerKopiearje it resultaat fan it twadde kommando, útfiere op node2 en node3:
# docker swarm join --token SWMTKN-x-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-xxxxxxxxx xx.xx.xx.xx:2377
This node joined a swarm as a manager.Dit foltôget de foarriedige konfiguraasje fan 'e tsjinners, litte wy begjinne mei it konfigurearjen fan de tsjinsten, de út te fieren kommando's wurde lansearre fan node1, útsein as oars oanjûn.
Litte wy earst netwurken meitsje foar konteners:
# 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 gitlabDan markearje wy de servers, dit is nedich om guon tsjinsten te binen oan de servers:
# docker node update --label-add nodename=node1 node1
# docker node update --label-add nodename=node2 node2
# docker node update --label-add nodename=node3 node3Dêrnei meitsje wy mappen foar it bewarjen fan etcd-gegevens, de KV-opslach dy't Traefik en Stolon nedich binne. Fergelykber mei Postgresql sille dit konteners wêze bûn oan servers, sadat wy dit kommando útfiere op alle servers:
# mkdir -p /srv/etcdMeitsje dan in bestân om etcd te konfigurearjen en tapasse it:
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 etcdNei in skoftke kontrolearje wy dat it etcd-kluster opstien is:
# 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 healthyMeitsje mappen foar Postgresql, fier it kommando út op alle servers:
# mkdir -p /srv/pgsqlMeitsje dan in bestân om Postgresql te konfigurearjen:
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: trueWy generearje geheimen, tapasse it bestân:
# </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 pgsqlIn skoft letter (sjoch nei de útfier fan it kommando docker tsjinst lsdat alle tsjinsten opstien binne) inisjalisearje it Postgresql-kluster:
# 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 initKontrolearje de reewilligens fan it Postgresql-kluster:
# 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
Wy konfigurearje traefik om tagong te iepenjen foar konteners fan bûten:
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 traefikWy begjinne Redis Cluster, hjirfoar meitsje wy in opslachmap op alle knopen:
# 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 redisAdd Docker Registry:
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 registryEn as lêste - 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 gitlabDe definitive steat fan it kluster en tsjinsten:
# 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/tcpWat kin noch ferbettere wurde? Wês wis dat jo Traefik konfigurearje om te wurkjen mei https-containers, foegje tls-fersifering ta foar Postgresql en Redis. Mar yn 't algemien kinne jo it al jaan oan ûntwikkelders as in PoC. Litte wy no sjen nei alternativen foar Docker.
podman
In oare frij bekende motor foar it rinnen fan konteners groepearre troch pods (pods, groepen fan konteners dy't tegearre ynset binne). Oars as Docker hat it gjin tsjinst nedich om konteners út te fieren, al it wurk wurdt dien fia de libpod-bibleteek. Ek skreaun yn Go, hat in OCI-kompatibele runtime nedich om konteners lykas runC út te fieren.
It wurkjen mei Podman liket yn 't algemien op dat fan Docker, foarsafier't jo it sa kinne dwaan (bewearde troch in protte dy't it hawwe besocht, ynklusyf de skriuwer fan dit artikel):
$ alias docker=podmanen jo kinne trochgean mei wurkjen. Yn 't algemien is de situaasje mei Podman tige nijsgjirrich, om't as de iere ferzjes fan Kubernetes mei Docker wurken, dan sûnt sawat 2015, nei it standerdisearjen fan de kontenerwrâld (OCI - Open Container Initiative) en it splitsen fan Docker yn containerd en runC, in alternatyf foar Docker wurdt ûntwikkele om te rinnen yn Kubernetes: CRI-O. Podman yn dit ferbân is in alternatyf foar Docker, boud op 'e prinsipes fan Kubernetes, ynklusyf kontenergroepearring, mar it haaddoel fan it projekt is om Docker-styl konteners út te fieren sûnder ekstra tsjinsten. Om dúdlike redenen is d'r gjin swarmmodus, om't de ûntwikkelders dúdlik sizze dat as jo in kluster nedich binne, nim Kubernetes.
ynstelling
Om te ynstallearjen op Centos 7, aktivearje gewoan it Extras-repository, en ynstallearje dan alles mei it kommando:
# yum -y install podmanOare mooglikheden
Podman kin ienheden generearje foar systemd, sadat it probleem oplost fan it starten fan konteners nei in tsjinner opnij opstart. Derneist wurdt systemd ferklearre om goed te wurkjen as pid 1 yn 'e kontener. Om konteners te bouwen, is d'r in apart buildah-ark, d'r binne ek ark fan tredden - analogen fan docker-compose, dy't ek Kubernetes-kompatibele konfiguraasjebestannen genereart, sadat de oergong fan Podman nei Kubernetes sa ienfâldich mooglik is.
Wurkje mei Podman
Om't d'r gjin swarmmodus is (it moat wikselje nei Kubernetes as in kluster nedich is), sille wy it yn aparte konteners gearstalle.
Ynstallearje podman-compose:
# yum -y install python3-pip
# pip3 install podman-composeIt resultearjende konfiguraasjebestân foar podman is wat oars, om't wy bygelyks in aparte dielen seksje direkt nei de tsjinsten seksje moasten ferpleatse.
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 upResultaat fan wurk:
# 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_1Litte wy sjen wat it sil generearje foar systemd en kubernetes, hjirfoar moatte wy de namme of id fan 'e pod fine:
# 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.targetSpitigernôch docht de generearre ienheid foar systemd, útsein konteners, neat oars (bygelyks it opromjen fan âlde konteners as sa'n tsjinst op 'e nij opstart is), dus jo moatte sokke dingen sels tafoegje.
Yn prinsipe is Podman genôch om te besykjen wat konteners binne, âlde konfiguraasjes oer te dragen foar docker-compose, en gean dan nei Kubernetes, as nedich, op in kluster, of krije in makliker te brûken alternatyf foar Docker.
rkt
It projekt sa'n seis moanne lyn fanwege it feit dat RedHat it kocht, dus ik sil der net mear oer yngean. Yn 't algemien liet it in heul goede yndruk, mar yn ferliking mei Docker, en noch mear mei Podman, liket it op in kombinearje. D'r wie ek in CoreOS-distribúsje boud boppe op rkt (hoewol't se oarspronklik Docker hiene), mar dat einige ek nei de oankeap fan RedHat.
Plasj
Mear , wêrfan de skriuwer krekt konteners bouwe en rinne woe. Troch de dokumintaasje en koade te oardieljen, folge de skriuwer de noarmen net, mar besleat gewoan syn eigen útfiering te skriuwen, wat hy yn prinsipe die.
befinings
De situaasje mei Kubernetes is heul ynteressant: oan 'e iene kant, mei Docker, kinne jo in kluster gearstalle (yn swarmmodus), wêrmei jo sels produksjeomjouwings foar kliïnten kinne útfiere, dit is benammen wier foar lytse teams (3-5 minsken) ), of mei in lytse totale lading , of it gebrek oan winsk om te begripen de kompleksjes fan it opsetten fan Kubernetes, ynklusyf foar hege loads.
Podman jout gjin folsleine kompatibiliteit, mar it hat ien wichtich foardiel - kompatibiliteit mei Kubernetes, ynklusyf ekstra ark (buildah en oaren). Dêrom sil ik de kar fan in ark foar wurk as folgjend benaderje: foar lytse teams, of mei in beheind budzjet - Docker (mei in mooglike swarmmodus), foar it ûntwikkeljen foar mysels op in persoanlike lokale host - Podman-kameraden, en foar elkenien oars - Kubernetes.
Ik bin der net wis fan dat de situaasje mei Docker yn 'e takomst net sil feroarje, ommers, se binne pioniers, en wurde ek stadichoan standardisearjend stap foar stap, mar Podman, mei al syn tekoartkommingen (wurket allinich op Linux, gjin klustering, assemblage en oare aksjes binne beslúten fan tredden) de takomst is dúdliker, dus ik noegje elkenien út om dizze befinings te besprekken yn 'e kommentaren.
PS Op 3 augustus lansearje wy "wêr kinne jo mear leare oer syn wurk. Wy analysearje al har ark: fan basisabstraksjes oant netwurkparameters, nuânses fan wurkjen mei ferskate bestjoeringssystemen en programmeartalen. Jo sille yn 'e kunde komme mei de technology en begripe wêr en hoe't jo Docker it bêste kinne brûke. Wy sille ek best practice gefallen diele.
Pre-order kosten foar frijlitting: 5000 roebel. It programma "Docker Video Course" is te finen .
Boarne: www.habr.com