TL;DR: 'n Oorsigartikel - 'n gids om omgewings te vergelyk om toepassings in houers te laat loop. Die moontlikhede van Docker en ander soortgelyke stelsels sal oorweeg word.
'n Bietjie geskiedenis van waar dit alles vandaan kom
Story
Die eerste bekende manier om 'n toepassing te isoleer, is chroot. Die stelseloproep met dieselfde naam verskaf 'n verandering aan die wortelgids - verskaf dus toegang tot die program wat dit genoem het, toegang slegs tot lêers binne hierdie gids. Maar as die program supergebruikerregte binne kry, kan dit moontlik uit die chroot "ontsnap" en toegang tot die hoofbedryfstelsel kry. Benewens die verandering van die wortelgids, is ander hulpbronne (RAM, verwerker), sowel as toegang tot die netwerk, ook nie beperk nie.
Die volgende manier is om 'n volwaardige bedryfstelsel binne die houer te begin, deur die meganismes van die bedryfstelselkern te gebruik. Hierdie metode word verskillend in verskillende bedryfstelsels genoem, maar die essensie is dieselfde - loop verskeie onafhanklike bedryfstelsels, wat elkeen op dieselfde kern loop wat die hoofbedryfstelsel bestuur. Dit sluit FreeBSD Jails, Solaris Zones, OpenVZ en LXC vir Linux in. Isolasie word nie net vir skyfspasie verskaf nie, maar ook vir ander hulpbronne, veral elke houer kan beperkings hê op verwerkertyd, RAM, netwerkbandwydte. In vergelyking met chroot, is dit moeiliker om die houer te verlaat, aangesien die supergebruiker in die houer slegs toegang het tot die binnekant van die houer, maar as gevolg van die behoefte om die bedryfstelsel binne die houer op datum te hou en die gebruik van ou kern weergawes (relevant vir Linux, tot 'n mindere mate FreeBSD), is daar 'n nie-nul die waarskynlikheid om die kernisolasiestelsel te "breek" en toegang tot die hoofbedryfstelsel te verkry.
In plaas daarvan om 'n volwaardige bedryfstelsel in 'n houer te begin (met 'n inisialiseringstelsel, 'n pakketbestuurder, ens.), kan toepassings onmiddellik geloods word, die belangrikste ding is om toepassings van hierdie geleentheid te voorsien (die teenwoordigheid van die nodige biblioteke en ander lêers). Hierdie idee het gedien as die basis vir houer-toepassingsvirtualisering, waarvan die mees prominente en bekende verteenwoordiger Docker is. In vergelyking met vorige stelsels, het meer buigsame isolasiemeganismes, tesame met ingeboude ondersteuning vir virtuele netwerke tussen houers en toepassingstaatlikheid binne 'n houer, gelei tot die vermoë om 'n enkele holistiese omgewing uit 'n groot aantal fisiese bedieners te bou om houers te laat loop - sonder die behoefte aan handmatige hulpbronbestuur.
Docker
Docker is die bekendste toepassingshouer-sagteware. Geskryf in die Go-taal, gebruik dit die gewone vermoëns van die Linux-kern - cgroups, naamruimtes, vermoëns, ens., sowel as Aufs-lêerstelsels en ander soortgelyke om skyfspasie te bespaar.
Bron: wikimedia
Argitektuur
Voor weergawe 1.11 het Docker as 'n enkele diens gewerk wat alle bewerkings met houers uitgevoer het: die aflaai van beelde vir houers, die bekendstelling van houers, die verwerking van API-versoeke. Sedert weergawe 1.11 is Docker opgedeel in verskeie dele wat met mekaar in wisselwerking is: containerd, om die hele lewensiklus van houers te hanteer (toewysing van skyfspasie, aflaai van beelde, netwerk, bekendstelling, installering en monitering van die toestand van houers) en runC , houerlooptye, gebaseer op die gebruik van cgroups en ander kenmerke van die Linux-kern. Die docker-diens self bly, maar nou dien dit net om API-versoeke wat na containerd uitgesaai word, te verwerk.
Installasie en konfigurasie
My gunsteling manier om docker te installeer, is docker-masjien, wat, benewens die direk installeer en konfigureer van docker op afgeleë bedieners (insluitend verskeie wolke), jou toelaat om met die lêerstelsels van afgeleë bedieners te werk, en ook verskeie opdragte kan uitvoer.
Sedert 2018 is die projek egter skaars ontwikkel, so ons sal dit op die gewone manier vir die meeste Linux-verspreidings installeer - deur 'n bewaarplek by te voeg en die nodige pakkette te installeer.
Hierdie metode word ook gebruik vir outomatiese installasie, byvoorbeeld deur Ansible of ander soortgelyke stelsels te gebruik, maar ek sal dit nie in hierdie artikel oorweeg nie.
Installasie sal op Centos 7 uitgevoer word, ek sal 'n virtuele masjien as 'n bediener gebruik, om te installeer, voer net die opdragte hieronder uit:
# 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.ioNa die installasie moet u die diens begin, plaas dit in outolaai:
# systemctl enable docker
# systemctl start docker
# firewall-cmd --zone=public --add-port=2377/tcp --permanentBoonop kan u 'n docker-groep skep, wie se gebruikers sonder sudo met docker sal kan werk, logging opstel, toegang tot die API van buite moontlik maak, moenie vergeet om die firewall te verfyn nie (alles wat nie toegelaat word nie, is verbied in die voorbeelde hierbo en hieronder - ek het dit vir eenvoud en visualisering weggelaat), maar ek gaan nie hier in meer besonderhede nie.
Ander eienskappe
Benewens die bogenoemde docker-masjien, is daar ook 'n docker-register, 'n instrument vir die stoor van beelde vir houers, sowel as docker compose - 'n instrument vir die outomatisering van die implementering van toepassings in houers, YAML-lêers word gebruik om houers te bou en op te stel en ander verwante dinge (byvoorbeeld netwerke, aanhoudende lêerstelsels vir die stoor van data).
Dit kan ook gebruik word om pypleidings vir CICD te organiseer. Nog 'n interessante kenmerk is om in cluster-modus te werk, die sogenaamde swermmodus (voor weergawe 1.12 was dit bekend as docker swarm), wat jou toelaat om 'n enkele infrastruktuur van verskeie bedieners saam te stel om houers te laat loop. Daar is ondersteuning vir 'n virtuele netwerk bo-op alle bedieners, daar is 'n ingeboude lasbalanseerder, asook ondersteuning vir geheime vir houers.
Die YAML-lêers van docker compose kan gebruik word vir sulke groepe met geringe wysigings, wat die instandhouding van klein en medium groepe vir verskeie doeleindes ten volle outomatiseer. Vir groot trosse is Kubernetes verkieslik omdat swermmodus-onderhoudskoste dié van Kubernetes kan oorskry. Benewens runC, as 'n uitvoeringsomgewing vir houers, kan u byvoorbeeld installeer
Werk saam met Docker
Na die installasie en konfigurasie, sal ons probeer om 'n groep te bou waarin ons GitLab en Docker Registry vir die ontwikkelingspan sal ontplooi. As bedieners sal ek drie virtuele masjiene gebruik, waarop ek ook die GlusterFS-verspreide FS sal ontplooi, ek sal dit gebruik as 'n docker-volume-berging, byvoorbeeld, om 'n mislukte weergawe van die docker-register te laat loop. Sleutelkomponente om te hardloop: Docker Registry, Postgresql, Redis, GitLab met ondersteuning vir GitLab Runner bo-op Swarm. Postgresql sal met groepering bekendgestel word , so jy hoef nie GlusterFS te gebruik om Postgresql-data te stoor nie. Die res van die kritieke data sal op GlusterFS gestoor word.
Om GlusterFS op alle bedieners te ontplooi (dit word node1, node2, node3 genoem), moet u pakkette installeer, die firewall aktiveer, die nodige gidse skep:
# 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/fstabNa die installasie moet werk aan die opstel van GlusterFS vanaf een nodus voortgesit word, byvoorbeeld 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 moet jy die resulterende volume monteer (die opdrag moet op alle bedieners uitgevoer word):
# mount /srv/dockerSwermmodus is gekonfigureer op een van die bedieners, wat Leier sal wees, die res sal by die groep moet aansluit, so die resultaat van die uitvoer van die opdrag op die eerste bediener sal gekopieer en op die res uitgevoer moet word.
Aanvanklike groepopstelling, ek voer die opdrag op node1 uit:
# 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 managerKopieer die resultaat van die tweede opdrag, voer uit 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 voltooi die voorlopige konfigurasie van die bedieners, kom ons begin die dienste konfigureer, die opdragte wat uitgevoer moet word, sal vanaf node1 geloods word, tensy anders gespesifiseer.
Kom ons skep eerstens netwerke vir houers:
# 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 merk ons die bedieners, dit is nodig om sommige dienste aan die bedieners te bind:
# docker node update --label-add nodename=node1 node1
# docker node update --label-add nodename=node2 node2
# docker node update --label-add nodename=node3 node3Vervolgens skep ons gidse vir die stoor van ens data, die KV-berging wat Traefik en Stolon benodig. Soortgelyk aan Postgresql, sal dit houers wees wat aan bedieners gebind is, so ons voer hierdie opdrag op alle bedieners uit:
# mkdir -p /srv/etcdSkep dan 'n lêer om etcd te konfigureer en pas dit toe:
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 etcdNa 'n rukkie kyk ons of die etcd-groepering gestyg het:
# 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 healthySkep gidse vir Postgresql, voer die opdrag op alle bedieners uit:
# mkdir -p /srv/pgsqlSkep dan 'n lêer om Postgresql op te stel:
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: trueOns genereer geheime, pas die lêer toe:
# </dev/urandom tr -dc 234567890qwertyuopasdfghjkzxcvbnmQWERTYUPASDFGHKLZXCVBNM | head -c $(((RANDOM%3)+15)) > /srv/docker/replica
# </dev/urandom tr -dc 234567890qwertyuopasdfghjkzxcvbnmQWERTYUPASDFGHKLZXCVBNM | head -c $(((RANDOM%3)+15)) > /srv/docker/postgres
# docker stack deploy --compose-file 01pgsql.yml pgsql'n Ruk later (kyk na die uitvoer van die opdrag docker diens lsdat alle dienste gestyg het) inisialiseer die 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 initKontroleer die gereedheid van die Postgresql-groepering:
# 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
Ons stel traefik op om toegang tot houers van buite af oop te maak:
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 traefikOns begin Redis Cluster, hiervoor skep ons 'n bergingsgids op alle nodusse:
# 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 redisVoeg Docker-register by:
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 laastens - 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 gitlabDie finale toestand van die groepering en dienste:
# 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 anders kan verbeter word? Maak seker dat u Traefik instel om met https-houers te werk, voeg tls-kodering by vir Postgresql en Redis. Maar oor die algemeen kan u dit reeds as 'n PoC aan ontwikkelaars gee. Kom ons kyk nou na alternatiewe vir Docker.
podman
Nog 'n redelik bekende enjin vir die bestuur van houers gegroepeer deur peule (peule, groepe houers saam ontplooi). Anders as Docker, benodig dit geen diens om houers uit te voer nie, alle werk word deur die libpod-biblioteek gedoen. Ook geskryf in Go, benodig 'n OCI-voldoende looptyd om houers soos runC te laat loop.
Werk met Podman in die algemeen lyk soos dié van Docker, in die mate dat jy dit so kan doen (wat beweer word deur baie wat dit probeer het, insluitend die skrywer van hierdie artikel):
$ alias docker=podmanen jy kan aanhou werk. Oor die algemeen is die situasie met Podman baie interessant, want as die vroeë weergawes van Kubernetes saam met Docker gewerk het, dan sedert ongeveer 2015, na die standaardisering van die houerwêreld (OCI - Open Container Initiative) en die verdeling van Docker in containerd en runC, 'n alternatief vir Docker word ontwikkel om in Kubernetes: CRI-O te loop. Podman in hierdie verband is 'n alternatief vir Docker, gebou op die beginsels van Kubernetes, insluitend houergroepering, maar die hoofdoel van die projek is om Docker-styl houers sonder bykomende dienste te laat loop. Om ooglopende redes is daar geen swermmodus nie, aangesien die ontwikkelaars duidelik sê dat as jy 'n groep nodig het, neem Kubernetes.
installasie
Om op Centos 7 te installeer, aktiveer net die Extras-bewaarplek en installeer dan alles met die opdrag:
# yum -y install podmanAnder eienskappe
Podman kan eenhede vir systemd genereer en sodoende die probleem oplos om houers te begin na 'n bediener herlaai. Daarbenewens word systemd verklaar om korrek te werk as pid 1 in die houer. Om houers te bou, is daar 'n aparte buildah-instrument, daar is ook derdeparty-instrumente - analoë van docker-compose, wat ook Kubernetes-versoenbare konfigurasielêers genereer, so die oorgang van Podman na Kubernetes is so eenvoudig as moontlik.
Werk saam met Podman
Aangesien daar geen swermmodus is nie (dit is veronderstel om na Kubernetes oor te skakel as 'n cluster nodig is), sal ons dit in aparte houers bymekaarmaak.
Installeer podman-compose:
# yum -y install python3-pip
# pip3 install podman-composeDie gevolglike konfigurasielêer vir podman is effens anders, aangesien ons byvoorbeeld 'n aparte volume-afdeling direk na die dienste-afdeling moes skuif.
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 van werk:
# 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_1Kom ons kyk wat dit sal genereer vir systemd en kubernetes, hiervoor moet ons die naam of ID van die peul uitvind:
# 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: {}stelseld:
# 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.targetOngelukkig, behalwe om houers te laat loop, doen die gegenereerde eenheid vir systemd niks anders nie (byvoorbeeld om ou houers skoon te maak wanneer so 'n diens herbegin word), so jy sal self sulke goed moet byvoeg.
In beginsel is Podman genoeg om te probeer wat houers is, ou konfigurasies oor te dra vir docker-compose, en dan na Kubernetes te gaan, indien nodig, op 'n cluster, of 'n makliker-om-te gebruik alternatief vir Docker te kry.
rkt
Project sowat ses maande gelede as gevolg van die feit dat RedHat dit gekoop het, so ek sal nie meer daaroor uitwei nie. Oor die algemeen het dit 'n baie goeie indruk gelaat, maar in vergelyking met Docker, en selfs meer so met Podman, lyk dit soos 'n kombinasie. Daar was ook 'n CoreOS-verspreiding bo-op rkt gebou (alhoewel hulle oorspronklik Docker gehad het), maar dit het ook geëindig na die RedHat-aankoop.
Plas
Meer , waarvan die skrywer net houers wou bou en bestuur. Te oordeel aan die dokumentasie en kode het die skrywer nie die standaarde gevolg nie, maar bloot besluit om sy eie implementering te skryf, wat hy in beginsel gedoen het.
Bevindinge
Die situasie met Kubernetes is baie interessant: aan die een kant, met Docker, kan u 'n groepering saamstel (in swermmodus), waarmee u selfs produksie-omgewings vir kliënte kan bestuur, dit is veral waar vir klein spanne (3-5 mense) ), of met 'n klein algehele vrag , of die gebrek aan begeerte om die ingewikkeldhede van die opstel van Kubernetes te verstaan, insluitend vir hoë vragte.
Podman bied nie volle versoenbaarheid nie, maar dit het een belangrike voordeel - verenigbaarheid met Kubernetes, insluitend bykomende gereedskap (buildah en ander). Daarom sal ek die keuse van 'n hulpmiddel vir werk soos volg benader: vir klein spanne, of met 'n beperkte begroting - Docker (met 'n moontlike swermmodus), om vir myself op 'n persoonlike plaaslike gasheer te ontwikkel - Podman-kamerade, en vir almal anders - Kubernetes.
Ek is nie seker dat die situasie met Docker nie in die toekoms sal verander nie, hulle is immers pioniers, en standaardiseer ook stadig stap vir stap, maar Podman, met al sy tekortkominge (werk net op Linux, geen groepering, samestelling en ander aksies is derdeparty-besluite) die toekoms is duideliker, so ek nooi almal uit om hierdie bevindings in die kommentaar te bespreek.
PS Op 3 Augustus begin ons "waar jy meer oor sy werk kan leer. Ons sal al sy gereedskap ontleed: van basiese abstraksies tot netwerkparameters, nuanses van werk met verskeie bedryfstelsels en programmeertale. Jy sal kennis maak met die tegnologie en verstaan waar en hoe om Docker die beste te gebruik. Ons sal ook beste praktykgevalle deel.
Voorafbestellingskoste voor vrystelling: 5000 roebels. Die program "Docker Video Course" kan gevind word .
Bron: will.com