TL; DR: Un articulu generale - una guida per paragunà l'ambienti per eseguisce l'applicazioni in cuntenituri. E pussibilità di Docker è altri sistemi simili seranu cunsiderate.
Un pocu di storia di induve vene tuttu
История
U primu modu ben cunnisciutu per isolà una applicazione hè chroot. A chjama di u sistema di u listessu nome furnisce un cambiamentu à u repertoriu radicali - cusì furnisce l'accessu à u prugramma chì l'hà chjamatu, accessu solu à i schedari in stu cartulare. Ma se u prugramma hè datu i diritti di superuser in l'internu, pò esse "scappatu" da u chroot è accede à u sistema operatore principale. Inoltre, in più di cambià u repertoriu radicali, altre risorse (RAM, processore), è ancu l'accessu à a reta, ùn sò micca limitati.
A prossima manera hè di lancià un sistema operatore cumpletu in u cuntinuu, utilizendu i miccanismi di u kernel di u sistema operatore. Stu metudu hè chjamatu in modu diversu in diversi sistemi operativi, ma l'essenza hè a listessa - eseguisce parechji sistemi operativi indipendenti, ognuna di e quali corre nantu à u stessu kernel chì gestisce u sistema operatore principale. Questu include FreeBSD Jails, Solaris Zones, OpenVZ è LXC per Linux. L'isolamentu hè furnitu micca solu per u spaziu di discu, ma ancu per altri risorse, in particulare, ogni cuntinuu pò avè restrizioni à u tempu di u processatore, RAM, larghezza di banda di rete. Comparatu à chroot, lascià u cuntinuu hè più difficiuli, postu chì u superuser in u cuntinuu hà accessu solu à l'internu di u cuntinuu, però, per a necessità di mantene u sistema operatore in u cuntinuu aghjurnatu è l'usu di u vechju kernel. versioni (pertinenti per Linux, in una misura più menu FreeBSD), ci hè una probabilità micca zero di rompe u sistema di isolamentu di u kernel è accede à u sistema operatore principale.
Invece di lancià un sistema upirativu cumpletu in un containeru (cun un sistema di inizializazione, un gestore di pacchetti, etc.), l'applicazioni ponu esse lanciate immediatamente, u principale hè di furnisce l'applicazioni cù questa opportunità (a prisenza di e librerie necessarie è altri schedari). Questa idea hà servitu cum'è a basa per a virtualizazione di l'applicazioni containerizzate, u rappresentante più prominente è cunnisciutu di quale hè Docker. In cunfrontu à i sistemi precedenti, i meccanismi di isolamentu più flessibili, inseme cù un supportu integratu per e rete virtuale trà i cuntenituri è u statutu di l'applicazione in un containeru, anu risultatu in a capacità di custruisce un ambiente olisticu unicu da un gran numaru di servitori fisici per eseguisce cuntenituri - senza a necessità di gestione manuale di risorse.
Docker
Docker hè u software di containerizazione di l'applicazioni più cunnisciutu. Scritta in a lingua Go, usa e capacità regulare di u kernel Linux - cgroups, namespaces, capacità, etc., è ancu sistemi di schedari Aufs è altri simili per salvà u spaziu di discu.
Fonte: wikimedia
architettura
Prima di a versione 1.11, Docker hà travagliatu cum'è un serviziu unicu chì hà realizatu tutte l'operazioni cù cuntenituri: scaricamentu di l'imaghjini per cuntenituri, lanciari cuntenituri, processà e dumande API. Dapoi a versione 1.11, Docker hè statu divisu in parechje parti chì interagiscenu cù l'altri: containerd, per trattà tuttu u ciculu di vita di i cuntenituri (allocazione di spaziu di discu, scaricamentu di l'imaghjini, networking, lanciamentu, installazione è monitoraghju di u statu di cuntenituri) è runC. , runtimes di container, basatu annantu à l'usu di cgroups è altre funziunalità di u kernel Linux. U serviziu docker stessu ferma, ma avà serve solu per processà e dumande API trasmesse à containerd.
Stallazione è cunfigurazione
U mo modu preferitu di stallà docker hè docker-machine, chì, in più di installà direttamente è cunfigurà docker in i servitori remoti (cumprese diverse nuvole), vi permette di travaglià cù i sistemi di schedarii di servitori remoti, è ponu ancu eseguisce diversi cumandamenti.
In ogni casu, dapoi u 2018, u prugettu hè pocu sviluppatu, cusì l'installeremu in u modu di solitu per a maiò parte di e distribuzioni Linux - aghjunghjendu un repository è installendu i pacchetti necessarii.
Stu metudu hè ancu usatu per a stallazione automatizata, per esempiu, cù Ansible o altri sistemi simili, ma ùn aghju micca cunsideratu in questu articulu.
A stallazione serà realizatu nantu à Centos 7, aduprà una macchina virtuale cum'è servitore, per installà, basta à eseguisce i cumandamenti sottu:
# 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.ioDopu a stallazione, avete bisognu di inizià u serviziu, mette in autoload:
# systemctl enable docker
# systemctl start docker
# firewall-cmd --zone=public --add-port=2377/tcp --permanentInoltre, pudete creà un gruppu docker, chì l'utilizatori puderanu travaglià cù docker senza sudo, cunfigurà logging, attivà l'accessu à l'API da l'esternu, ùn vi scurdate di fine-tune u firewall (tuttu ciò chì ùn hè micca permessu hè pruibitu in l'esempii sopra è quì sottu - aghju omessi questu per simplicità è visualizazione), ma ùn andaraghju in più dettagliu quì.
Altre caratteristiche
In più di a macchina docker sopra, ci hè ancu un registru docker, un strumentu per almacenà l'imaghjini per i cuntenituri, è ancu di docker compose - un strumentu per automatizà a implementazione di l'applicazioni in cuntenituri, i schedari YAML sò usati per custruisce è cunfigurà cuntenituri è altre cose cunnesse (per esempiu, rete, sistemi di schedari persistenti per almacenà dati).
Pò esse ancu usatu per urganizà pipelines per CICD. Un'altra funzione interessante hè di travaglià in u modu di cluster, u cusì chjamatu modu swarm (prima di a versione 1.12 era cunnisciutu com'è docker swarm), chì permette di assemblà una sola infrastruttura da parechji servitori per eseguisce cuntenituri. Ci hè un supportu per una reta virtuale nantu à tutti i servitori, ci hè un equilibratore di carica integratu, è ancu un supportu per i secreti per i cuntenituri.
I fugliali YAML da docker compose ponu esse aduprati per tali clusters cù mudificazioni minori, automatizendu cumplettamente u mantenimentu di clusters chjuchi è mediani per diversi scopi. Per i grandi clusters, Kubernetes hè preferibile perchè i costi di mantenimentu di u modalità swarm ponu sopra à quelli di Kubernetes. In più di runC, cum'è un ambiente di esecutivu per i cuntenituri, pudete installà, per esempiu
U travagliu cù Docker
Dopu a stallazione è a cunfigurazione, pruveremu di custruisce un cluster in quale implementeremu GitLab è Docker Registry per u squadra di sviluppu. Cum'è servitori, aghju aduprà trè macchine virtuali, nantu à quale aghju implementatu in più u FS distribuitu GlusterFS, l'utilizaraghju cum'è un almacenamentu di volumi docker, per esempiu, per eseguisce una versione sicura di u registru docker. Cumpunenti chjave per eseguisce: Docker Registry, Postgresql, Redis, GitLab cù supportu per GitLab Runner in cima à Swarm. Postgresql serà lanciatu cù clustering , perchè ùn avete micca bisognu di utilizà GlusterFS per almacenà e dati Postgresql. U restu di e dati critichi seranu guardati in GlusterFS.
Per implementà GlusterFS in tutti i servitori (sò chjamati node1, node2, node3), avete bisognu di installà pacchetti, attivà u firewall, creà i cartulari necessarii:
# 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/fstabDopu a stallazione, u travagliu nantu à a cunfigurazione di GlusterFS deve esse cuntinuatu da un node, per esempiu 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 dockerAllora avete bisognu di muntà u voluminu risultatu (u cumandamentu deve esse eseguitu in tutti i servitori):
# mount /srv/dockerU modu Swarm hè cunfiguratu in unu di i servitori, chì serà Leader, u restu duverà unisce à u cluster, cusì u risultatu di eseguisce u cumandamentu in u primu servitore deve esse copiatu è eseguitu nantu à u restu.
Configurazione iniziale di cluster, aghju eseguitu u cumandimu nantu à u 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 managerCopia u risultatu di u sicondu cumandamentu, eseguite nantu à u node2 è u node3:
# docker swarm join --token SWMTKN-x-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-xxxxxxxxx xx.xx.xx.xx:2377
This node joined a swarm as a manager.Questu compie a cunfigurazione prelimiunale di i servitori, cuminciamu à cunfigurà i servizii, i cumandamenti da esse eseguiti seranu lanciati da u node1, salvu s'ellu ùn hè micca specificatu.
Prima di tuttu, creemu rete per i cuntenituri:
# 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 gitlabAllora marcamu i servitori, questu hè necessariu per ligà certi servizii à i servitori:
# docker node update --label-add nodename=node1 node1
# docker node update --label-add nodename=node2 node2
# docker node update --label-add nodename=node3 node3In seguitu, creamu cartulari per almacenà dati etcd, l'almacenamiento KV chì Traefik è Stolon necessitanu. Simile à Postgresql, questi seranu cuntenituri ligati à i servitori, cusì eseguimu stu cumandamentu in tutti i servitori:
# mkdir -p /srv/etcdDopu, crea un schedariu per cunfigurà etcd è appricà:
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 etcdDopu qualchì tempu, cuntrollemu chì u cluster etcd hè risuscitatu:
# 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 healthyCrea cartulari per Postgresql, eseguite u cumandimu in tutti i servitori:
# mkdir -p /srv/pgsqlDopu, crea un schedariu per cunfigurà Postgresql:
01pgsql.yml
version: '3.7'
services:
pgsentinel:
image: sorintlab/stolon:master-pg10
command:
- gosu
- stolon
- stolon-sentinel
- --cluster-name=stolon-cluster
- --store-backend=etcdv3
- --store-endpoints=http://etcd1:2379,http://etcd2:2379,http://etcd3:2379
- --log-level=debug
networks:
- etcd
- pgsql
deploy:
replicas: 3
update_config:
parallelism: 1
delay: 30s
order: stop-first
failure_action: pause
pgkeeper1:
image: sorintlab/stolon:master-pg10
hostname: pgkeeper1
command:
- gosu
- stolon
- stolon-keeper
- --pg-listen-address=pgkeeper1
- --pg-repl-username=replica
- --uid=pgkeeper1
- --pg-su-username=postgres
- --pg-su-passwordfile=/run/secrets/pgsql
- --pg-repl-passwordfile=/run/secrets/pgsql_repl
- --data-dir=/var/lib/postgresql/data
- --cluster-name=stolon-cluster
- --store-backend=etcdv3
- --store-endpoints=http://etcd1:2379,http://etcd2:2379,http://etcd3:2379
networks:
- etcd
- pgsql
environment:
- PGDATA=/var/lib/postgresql/data
volumes:
- pgkeeper1:/var/lib/postgresql/data
secrets:
- pgsql
- pgsql_repl
deploy:
replicas: 1
placement:
constraints: [node.labels.nodename == node1]
pgkeeper2:
image: sorintlab/stolon:master-pg10
hostname: pgkeeper2
command:
- gosu
- stolon
- stolon-keeper
- --pg-listen-address=pgkeeper2
- --pg-repl-username=replica
- --uid=pgkeeper2
- --pg-su-username=postgres
- --pg-su-passwordfile=/run/secrets/pgsql
- --pg-repl-passwordfile=/run/secrets/pgsql_repl
- --data-dir=/var/lib/postgresql/data
- --cluster-name=stolon-cluster
- --store-backend=etcdv3
- --store-endpoints=http://etcd1:2379,http://etcd2:2379,http://etcd3:2379
networks:
- etcd
- pgsql
environment:
- PGDATA=/var/lib/postgresql/data
volumes:
- pgkeeper2:/var/lib/postgresql/data
secrets:
- pgsql
- pgsql_repl
deploy:
replicas: 1
placement:
constraints: [node.labels.nodename == node2]
pgkeeper3:
image: sorintlab/stolon:master-pg10
hostname: pgkeeper3
command:
- gosu
- stolon
- stolon-keeper
- --pg-listen-address=pgkeeper3
- --pg-repl-username=replica
- --uid=pgkeeper3
- --pg-su-username=postgres
- --pg-su-passwordfile=/run/secrets/pgsql
- --pg-repl-passwordfile=/run/secrets/pgsql_repl
- --data-dir=/var/lib/postgresql/data
- --cluster-name=stolon-cluster
- --store-backend=etcdv3
- --store-endpoints=http://etcd1:2379,http://etcd2:2379,http://etcd3:2379
networks:
- etcd
- pgsql
environment:
- PGDATA=/var/lib/postgresql/data
volumes:
- pgkeeper3:/var/lib/postgresql/data
secrets:
- pgsql
- pgsql_repl
deploy:
replicas: 1
placement:
constraints: [node.labels.nodename == node3]
postgresql:
image: sorintlab/stolon:master-pg10
command: gosu stolon stolon-proxy --listen-address 0.0.0.0 --cluster-name stolon-cluster --store-backend=etcdv3 --store-endpoints http://etcd1:2379,http://etcd2:2379,http://etcd3:2379
networks:
- etcd
- pgsql
deploy:
replicas: 3
update_config:
parallelism: 1
delay: 30s
order: stop-first
failure_action: rollback
volumes:
pgkeeper1:
driver: local
driver_opts:
type: none
o: bind
device: "/srv/pgsql"
pgkeeper2:
driver: local
driver_opts:
type: none
o: bind
device: "/srv/pgsql"
pgkeeper3:
driver: local
driver_opts:
type: none
o: bind
device: "/srv/pgsql"
secrets:
pgsql:
file: "/srv/docker/postgres"
pgsql_repl:
file: "/srv/docker/replica"
networks:
etcd:
external: true
pgsql:
external: trueGeneremu sicreti, applicà u schedariu:
# </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 pgsqlQualchì tempu dopu (guardate a pruduzzioni di u cumandimu serviziu docker lschì tutti i servizii sò aumentati) inizializza u cluster Postgresql:
# docker exec $(docker ps | awk '/pgkeeper/ {print $1}') stolonctl --cluster-name=stolon-cluster --store-backend=etcdv3 --store-endpoints=http://etcd1:2379,http://etcd2:2379,http://etcd3:2379 initVerificate a preparazione di u cluster Postgresql:
# docker exec $(docker ps | awk '/pgkeeper/ {print $1}') stolonctl --cluster-name=stolon-cluster --store-backend=etcdv3 --store-endpoints=http://etcd1:2379,http://etcd2:2379,http://etcd3:2379 status
=== Active sentinels ===
ID LEADER
26baa11d false
74e98768 false
a8cb002b true
=== Active proxies ===
ID
4d233826
9f562f3b
b0c79ff1
=== Keepers ===
UID HEALTHY PG LISTENADDRESS PG HEALTHY PG WANTEDGENERATION PG CURRENTGENERATION
pgkeeper1 true pgkeeper1:5432 true 2 2
pgkeeper2 true pgkeeper2:5432 true 2 2
pgkeeper3 true pgkeeper3:5432 true 3 3
=== Cluster Info ===
Master Keeper: pgkeeper3
===== Keepers/DB tree =====
pgkeeper3 (master)
├─pgkeeper2
└─pgkeeper1
Avemu cunfiguratu traefik per apre l'accessu à i cuntenituri da l'esternu:
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 traefikCuminciamu Redis Cluster, per questu avemu creatu un repertoriu di almacenamiento in tutti i nodi:
# 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 redisAggiungi 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 registryÈ infine - 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 gitlabU statu finali di u cluster è i servizii:
# 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/tcpChì altru pò esse migliuratu? Assicuratevi di cunfigurà Traefik per travaglià cù cuntenituri https, aghjunghje l'encryption tls per Postgresql è Redis. Ma in generale, pudete digià dà à i sviluppatori cum'è PoC. Fighjemu avà l'alternative à Docker.
podman
Un altru mutore abbastanza notu per u funziunamentu di cuntenituri raggruppati da baccelli (pods, gruppi di cuntenituri disposti inseme). A cuntrariu di Docker, ùn hà micca bisognu di alcun serviziu per eseguisce cuntenituri, tuttu u travagliu hè fattu attraversu a biblioteca libpod. Scrittu ancu in Go, hà bisognu di un runtime conforme à l'OCI per eseguisce cuntenituri cum'è runC.
U travagliu cù Podman in generale s'assumiglia à quellu di Docker, à u puntu chì pudete fà cusì (reclamatu da parechji chì anu pruvatu, cumpresu l'autore di questu articulu):
$ alias docker=podmanè pudete cuntinuà à travaglià. In generale, a situazione cù Podman hè assai interessante, perchè se e prime versioni di Kubernetes anu travagliatu cù Docker, dapoi circa 2015, dopu à standardizà u mondu di u containeru (OCI - Open Container Initiative) è splitting Docker in containerd è runC, una alternativa à Docker hè sviluppatu per eseguisce in Kubernetes: CRI-O. Podman in questu sensu hè una alternativa à Docker, custruitu nantu à i principii di Kubernetes, cumpresu u raggruppamentu di cuntenituri, ma u scopu principale di u prugettu hè di eseguisce cuntenituri in stile Docker senza servizii supplementari. Per ragioni evidenti, ùn ci hè micca un modu swarm, postu chì i sviluppatori dicenu chjaramente chì se avete bisognu di un cluster, pigliate Kubernetes.
rimarchevuli
Per installà in Centos 7, basta à attivà u repository Extras, è dopu installate tuttu cù u cumandimu:
# yum -y install podmanAltre caratteristiche
Podman pò generà unità per systemd, risolve cusì u prublema di inizià i cuntenituri dopu un reboot di u servitore. Inoltre, systemd hè dichjaratu per travaglià currettamente cum'è pid 1 in u cuntinuu. Per custruisce cuntenituri, ci hè un strumentu di buildah separatu, ci sò ancu strumenti di terzu - analoghi di docker-compose, chì genera ancu schedarii di cunfigurazione cumpatibili Kubernetes, cusì a transizione da Podman à Kubernetes hè u più simplice pussibule.
U travagliu cù Podman
Siccomu ùn ci hè micca un modu swarm (si deve passà à Kubernetes se un cluster hè necessariu), l'assembleremu in cuntenituri separati.
Installa podman-compose:
# yum -y install python3-pip
# pip3 install podman-composeU schedariu di cunfigurazione resultanti per podman hè ligeramente sfarente, cum'è per esempiu avemu avutu à spustà una sezione di volumi separata direttamente à a sezione di servizii.
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 upRisultatu di u travagliu:
# 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_1Videmu ciò chì generà per systemd è kubernetes, per questu avemu bisognu di truvà u nome o l'id di u pod:
# 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.targetSfurtunatamente, fora di lanciari cuntenituri, l'unità generata per systemd ùn face nunda d'altru (per esempiu, pulizziari vechji cuntenituri quandu un tali serviziu hè riavviatu), cusì vi tuccherà à aghjunghje tali cose tù stessu.
In principiu, Podman hè abbastanza per pruvà ciò chì i cuntenituri sò, trasfiriri vechji cunfigurazioni per docker-compose, è poi andà versu Kubernetes, se ne necessariu, in un cluster, o uttene una alternativa più faciule d'utilizà à Docker.
rkt
U prugettu circa sei mesi fà per via di u fattu chì RedHat l'hà compru, per quessa, ùn aghju micca aspittà in più in dettagliu. In generale, hà lasciatu una impressione assai bona, ma paragunatu à Docker, è ancu più à Podman, s'assumiglia à una combinazione. Ci era ancu una distribuzione CoreOS custruita nantu à rkt (ancu s'ellu avianu urigginariamente Docker), ma chì hè ancu finitu dopu a compra di RedHat.
Flash
Più , l'autore di quale vulia solu custruisce è eseguite cuntenituri. A ghjudicà da a documentazione è u codice, l'autore ùn hà micca seguitu i normi, ma solu decisu di scrive a so propria implementazione, chì, in principiu, hà fattu.
scuperti
A situazione cù Kubernetes hè assai interessante: da una banda, cù Docker, pudete assemblà un cluster (in modalità swarm), cù quale pudete ancu eseguisce ambienti di produzzione per i clienti, questu hè soprattuttu veru per i picculi squadre (3-5 persone). ), o cù una piccula carica generale , o a mancanza di vuluntà di capisce l'intricacies di stallà Kubernetes, ancu per carichi elevati.
Podman ùn furnisce micca una cumpatibilità cumpleta, ma hà un vantaghju impurtante - cumpatibilità cù Kubernetes, cumprese strumenti supplementari (buildah è altri). Per quessa, avvicinaraghju à l'scelta di un strumentu per u travagliu cum'è seguente: per i picculi squadre, o cù un budgetu limitatu - Docker (cù un modu di swarm pussibule), per sviluppà per mè stessu nantu à un host persunale - Podman camaradi, è per tutti l'altri. - Kubernetes.
Ùn sò micca sicuru chì a situazione cù Docker ùn hà micca cambiatu in u futuru, dopu à tuttu, sò i pionieri, è sò ancu pianu pianu standardizing step by step, ma Podman, cù tutti i so difetti (funziona solu in Linux, senza clustering, assemblea). è altre azzioni sò decisioni di terzu) u futuru hè più chjaru, cusì invitu à tutti à discutiri sti risultati in i cumenti.
PS U 3 d'Aostu lancemu "induve pudete amparà più nantu à u so travagliu. Avemu da analizà tutti i so strumenti: da l'astrazioni basi à i paràmetri di a rete, sfumature di travaglià cù diversi sistemi operativi è linguaggi di prugrammazione. Puderete cunnosce a tecnulugia è capisce induve è cumu megliu aduprà Docker. Partaremu ancu i casi di e migliori pratiche.
Costu di pre-ordine prima di a liberazione: 5000 rubles. U prugramma "Docker Video Course" pò esse trovu .
Source: www.habr.com