TL;DR: Panduan gambaran keseluruhan untuk membandingkan rangka kerja untuk menjalankan aplikasi dalam bekas. Keupayaan Docker dan sistem lain yang serupa akan dipertimbangkan.
Sedikit sejarah dari mana asalnya
Kisah
Kaedah pertama yang terkenal untuk mengasingkan aplikasi ialah chroot. Panggilan sistem dengan nama yang sama memastikan bahawa direktori akar ditukar - sekali gus memastikan program yang memanggilnya mempunyai akses hanya kepada fail dalam direktori tersebut. Tetapi jika program diberi keistimewaan root secara dalaman, ia berpotensi "melarikan diri" daripada chroot dan mendapat akses kepada sistem pengendalian utama. Selain itu, sebagai tambahan kepada menukar direktori akar, sumber lain (RAM, pemproses), serta akses rangkaian, tidak terhad.
Kaedah seterusnya ialah melancarkan sistem pengendalian sepenuhnya di dalam bekas, menggunakan mekanisme kernel sistem pengendalian. Kaedah ini dipanggil secara berbeza dalam sistem pengendalian yang berbeza, tetapi intipatinya adalah sama - melancarkan beberapa sistem pengendalian bebas, setiap satunya menjalankan kernel yang sama di mana sistem pengendalian utama berjalan. Ini termasuk Penjara FreeBSD, Zon Solaris, OpenVZ dan LXC untuk Linux. Pengasingan dipastikan bukan sahaja oleh ruang cakera, tetapi juga oleh sumber lain; khususnya, setiap bekas mungkin mempunyai had pada masa pemproses, RAM dan lebar jalur rangkaian. Berbanding dengan chroot, meninggalkan bekas adalah lebih sukar, kerana pengguna super dalam bekas hanya mempunyai akses kepada kandungan bekas, bagaimanapun, disebabkan keperluan untuk memastikan sistem pengendalian di dalam bekas dikemas kini dan penggunaan versi lama. kernel (berkaitan untuk Linux, pada tahap yang lebih rendah FreeBSD), terdapat kemungkinan bukan sifar untuk "memecah masuk" sistem pengasingan kernel dan mendapat akses kepada sistem pengendalian utama.
Daripada melancarkan sistem pengendalian sepenuhnya dalam bekas (dengan sistem permulaan, pengurus pakej, dsb.), anda boleh melancarkan aplikasi dengan segera, perkara utama ialah menyediakan aplikasi dengan peluang sedemikian (kehadiran perpustakaan yang diperlukan dan fail lain). Idea ini berfungsi sebagai asas untuk virtualisasi aplikasi kontena, wakil yang paling menonjol dan terkenal ialah Docker. Berbanding dengan sistem sebelumnya, mekanisme pengasingan yang lebih fleksibel, ditambah dengan sokongan terbina dalam untuk rangkaian maya antara bekas dan penjejakan keadaan aplikasi dalam bekas, menghasilkan keupayaan untuk membina satu persekitaran koheren daripada sejumlah besar pelayan fizikal untuk menjalankan kontena - tanpa memerlukan pengurusan sumber manual.
buruh pelabuhan
Docker ialah perisian kontena aplikasi yang paling terkenal. Ditulis dalam bahasa Go, ia menggunakan ciri standard kernel Linux - cgroup, ruang nama, keupayaan, dsb., serta sistem fail Aufs dan lain-lain seperti itu untuk menjimatkan ruang cakera.
Sumber: wikimedia
seni bina
Sebelum versi 1.11, Docker berfungsi sebagai perkhidmatan tunggal yang menjalankan semua operasi dengan bekas: memuat turun imej untuk bekas, melancarkan bekas, memproses permintaan API. Bermula dengan versi 1.11, Docker dibahagikan kepada beberapa bahagian yang berinteraksi antara satu sama lain: containerd, untuk memproses keseluruhan kitaran hayat bekas (memperuntukkan ruang cakera, memuat turun imej, bekerja dengan rangkaian, melancarkan, memasang dan memantau keadaan bekas) dan runC, persekitaran pelaksanaan kontena, berdasarkan penggunaan cgroup dan ciri-ciri lain kernel Linux. Perkhidmatan docker itu sendiri kekal, tetapi kini ia hanya berfungsi untuk memproses permintaan API yang diterjemahkan ke containerd.
Pemasangan dan konfigurasi
Cara kegemaran saya untuk memasang docker ialah docker-machine, yang, sebagai tambahan kepada memasang dan mengkonfigurasi docker secara terus pada pelayan jauh (termasuk pelbagai awan), memungkinkan untuk berfungsi dengan sistem fail pelayan jauh dan juga boleh menjalankan pelbagai arahan.
Walau bagaimanapun, sejak 2018, projek itu hampir tidak dibangunkan, jadi kami akan memasangnya mengikut cara standard untuk kebanyakan pengedaran Linux - menambah repositori dan memasang pakej yang diperlukan.
Kaedah ini juga digunakan untuk pemasangan automatik, contohnya menggunakan Ansible atau sistem lain yang serupa, tetapi saya tidak akan mempertimbangkannya dalam artikel ini.
Pemasangan akan dijalankan pada Centos 7, saya akan menggunakan mesin maya sebagai pelayan, untuk memasang hanya jalankan arahan di bawah:
# 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.ioSelepas pemasangan, anda perlu memulakan perkhidmatan dan meletakkannya dalam permulaan:
# systemctl enable docker
# systemctl start docker
# firewall-cmd --zone=public --add-port=2377/tcp --permanentSelain itu, anda boleh membuat kumpulan docker, yang penggunanya akan dapat bekerja dengan docker tanpa sudo, menyediakan pengelogan, membolehkan akses kepada API dari luar, dan jangan lupa untuk mengkonfigurasi firewall dengan lebih tepat (semua yang tidak dibenarkan adalah dilarang dalam contoh di atas dan di bawah - Saya meninggalkan ini untuk kesederhanaan dan kejelasan), tetapi saya tidak akan menerangkan lebih terperinci di sini.
Ciri-ciri lain
Sebagai tambahan kepada mesin docker yang disebutkan di atas, terdapat juga pendaftaran docker, alat untuk menyimpan imej untuk bekas, dan juga docker compose, alat untuk mengautomasikan penggunaan aplikasi dalam bekas, fail YAML digunakan untuk membina dan mengkonfigurasi bekas. dan perkara lain yang berkaitan (contohnya, rangkaian, sistem fail berterusan untuk data storan).
Ia juga boleh digunakan untuk mengatur penghantar untuk CICD. Satu lagi ciri menarik berfungsi dalam mod kluster, apa yang dipanggil mod swarm (sebelum versi 1.12 ia dikenali sebagai docker swarm), yang membolehkan anda memasang satu infrastruktur daripada beberapa pelayan untuk menjalankan bekas. Terdapat sokongan untuk rangkaian maya di atas semua pelayan, terdapat pengimbang beban terbina dalam, serta sokongan untuk rahsia untuk bekas.
Fail YAML daripada docker compose, dengan pengubahsuaian kecil, boleh digunakan untuk kluster sedemikian, mengautomasikan sepenuhnya penyelenggaraan kluster kecil dan sederhana untuk pelbagai tujuan. Untuk kluster besar, Kubernetes adalah lebih baik kerana kos penyelenggaraan mod swarm boleh melebihi kos Kubernetes. Sebagai tambahan kepada runC, anda boleh memasang, sebagai contoh, sebagai persekitaran pelaksanaan kontena
Bekerja dengan Docker
Selepas pemasangan dan konfigurasi, kami akan cuba memasang kluster di mana kami akan menggunakan GitLab dan Pendaftaran Docker untuk pasukan pembangunan. Saya akan menggunakan tiga mesin maya sebagai pelayan, di mana saya juga akan menggunakan FS GlusterFS yang diedarkan; Saya akan menggunakannya sebagai storan volum docker, sebagai contoh, untuk menjalankan versi pendaftaran docker yang toleran terhadap kesalahan. Komponen utama untuk dijalankan: Docker Registry, Postgresql, Redis, GitLab dengan sokongan untuk GitLab Runner di atas Swarm. Kami akan melancarkan Postgresql dengan pengelompokan , jadi anda tidak perlu menggunakan GlusterFS untuk menyimpan data Postgresql. Data kritikal yang selebihnya akan disimpan pada GlusterFS.
Untuk menggunakan GlusterFS pada semua pelayan (ia dipanggil node1, node2, node3), anda perlu memasang pakej, mendayakan firewall dan mencipta direktori yang diperlukan:
# 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/fstabSelepas pemasangan, kerja untuk mengkonfigurasi GlusterFS mesti diteruskan dari satu nod, contohnya nod1:
# 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 dockerKemudian anda perlu memasang volum yang terhasil (arahan mesti dilaksanakan pada semua pelayan):
# mount /srv/dockerMod swarm dikonfigurasikan pada salah satu pelayan, yang akan menjadi Pemimpin, selebihnya perlu menyertai kluster, jadi hasil daripada melaksanakan arahan pada pelayan pertama perlu disalin dan dilaksanakan pada yang lain.
Persediaan kluster awal, saya menjalankan arahan pada 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 managerKami menyalin hasil arahan kedua dan melaksanakannya pada node2 dan node3:
# docker swarm join --token SWMTKN-x-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-xxxxxxxxx xx.xx.xx.xx:2377
This node joined a swarm as a manager.Pada ketika ini, konfigurasi awal pelayan telah selesai, mari kita teruskan untuk menyediakan perkhidmatan; arahan yang akan dilaksanakan akan dilancarkan dari node1, melainkan dinyatakan sebaliknya.
Pertama sekali, mari buat rangkaian untuk bekas:
# 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 gitlabKemudian kami menandakan pelayan, ini perlu untuk mengikat beberapa perkhidmatan ke pelayan:
# docker node update --label-add nodename=node1 node1
# docker node update --label-add nodename=node2 node2
# docker node update --label-add nodename=node3 node3Seterusnya, kami mencipta direktori untuk menyimpan data etcd, storan KV, yang diperlukan untuk Traefik dan Stolon. Sama seperti Postgresql, ini akan menjadi bekas yang terikat pada pelayan, jadi kami menjalankan arahan ini pada semua pelayan:
# mkdir -p /srv/etcdSeterusnya, buat fail untuk mengkonfigurasi etcd dan gunakannya:
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 etcdSelepas beberapa lama, kami menyemak bahawa kluster etcd sudah siap:
# 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 healthyKami mencipta direktori untuk Postgresql, laksanakan arahan pada semua pelayan:
# mkdir -p /srv/pgsqlSeterusnya, buat fail untuk mengkonfigurasi 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: trueKami menjana rahsia dan menggunakan fail:
# </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 pgsqlSelepas beberapa lama (lihat output arahan perkhidmatan buruh pelabuhan lsbahawa semua perkhidmatan sudah siap) kami memulakan kluster 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 initMenyemak kesediaan kluster 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
Kami mengkonfigurasi traefik untuk membuka akses kepada bekas dari luar:
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 traefikKami melancarkan Redis Cluster, untuk melakukan ini, kami mencipta direktori storan pada semua nod:
# 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 redisTambah Pendaftaran Docker:
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 registryDan akhirnya - 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 gitlabKeadaan akhir kluster dan perkhidmatan:
# 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/tcpApa lagi yang boleh diperbaiki? Pastikan anda mengkonfigurasi Traefik untuk menjalankan bekas melalui https, tambahkan penyulitan tls untuk Postgresql dan Redis. Tetapi secara umum, ia sudah boleh diberikan kepada pembangun sebagai PoC. Sekarang mari kita lihat alternatif kepada Docker.
podman
Satu lagi enjin yang agak terkenal untuk menjalankan bekas yang dikumpulkan mengikut pod (pod, kumpulan bekas yang digunakan bersama). Tidak seperti Docker, ia tidak memerlukan sebarang perkhidmatan untuk menjalankan bekas; semua kerja dilakukan melalui perpustakaan libpod. Juga ditulis dalam Go, memerlukan masa jalan yang serasi dengan OCI untuk menjalankan bekas, seperti runC.
Bekerja dengan Podman secara amnya mengingatkan itu untuk Docker, sehingga anda boleh melakukannya seperti ini (seperti yang dinyatakan oleh ramai yang telah mencubanya, termasuk pengarang artikel ini):
$ alias docker=podmandan anda boleh terus bekerja. Secara umum, situasi dengan Podman sangat menarik, kerana jika versi awal Kubernetes bekerja dengan Docker, maka sekitar tahun 2015, selepas penyeragaman dunia kontena (OCI - Open Container Initiative) dan pembahagian Docker menjadi containerd dan runC, alternatif kepada Docker untuk berjalan di Kubernetes telah dibangunkan: CRI-O. Podman dalam hal ini adalah alternatif kepada Docker, dibina berdasarkan prinsip Kubernetes, termasuk mengumpulkan kontena, tetapi tujuan utama projek ini adalah untuk melancarkan kontena gaya Docker tanpa perkhidmatan tambahan. Atas sebab yang jelas, tiada mod swarm, kerana pembangun dengan jelas mengatakan bahawa jika anda memerlukan kluster, ambil Kubernetes.
Pemasangan
Untuk memasang pada Centos 7, hanya aktifkan repositori Extras, dan kemudian pasang semuanya dengan arahan:
# yum -y install podmanCiri-ciri lain
Podman boleh menjana unit untuk systemd, sekali gus menyelesaikan masalah memulakan bekas selepas but semula pelayan. Selain itu, systemd diisytiharkan berfungsi dengan betul sebagai pid 1 dalam bekas. Terdapat alat buildah yang berasingan untuk membina bekas, terdapat juga alat pihak ketiga - analog docker-compose, yang juga menjana fail konfigurasi yang serasi dengan Kubernetes, jadi peralihan dari Podman ke Kubernetes dipermudahkan sebaik mungkin.
Bekerja dengan Podman
Memandangkan tiada mod swarm (kami sepatutnya bertukar kepada Kubernetes jika kluster diperlukan), kami akan mengumpulkannya dalam bekas berasingan.
Pasang podman-compose:
# yum -y install python3-pip
# pip3 install podman-composeFail konfigurasi yang terhasil untuk podman sedikit berbeza, jadi sebagai contoh kami terpaksa mengalihkan bahagian volum berasingan terus ke bahagian dengan perkhidmatan.
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 upKeputusan:
# 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_1Mari lihat apa yang dihasilkannya untuk systemd dan kubernetes, untuk ini kita perlu mengetahui nama atau id 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.targetMalangnya, selain daripada melancarkan bekas, unit yang dijana untuk systemd tidak melakukan apa-apa lagi (contohnya, membersihkan bekas lama apabila perkhidmatan sedemikian dimulakan semula), jadi anda perlu menulis perkara sedemikian sendiri.
Pada dasarnya, Podman sudah cukup untuk mencuba apa itu bekas, memindahkan konfigurasi lama untuk karang docker, dan kemudian bergerak ke arah Kubernetes, jika anda memerlukan kluster, atau dapatkan alternatif yang lebih mudah digunakan untuk Docker.
rkt
Projek kira-kira enam bulan yang lalu disebabkan oleh fakta bahawa RedHat membelinya, jadi saya tidak akan membincangkannya dengan lebih terperinci. Secara keseluruhan, ia meninggalkan kesan yang sangat baik, tetapi berbanding dengan Docker dan terutamanya Podman, ia kelihatan seperti gabungan. Terdapat juga pengedaran CoreOS yang dibina di atas rkt (walaupun mereka pada asalnya mempunyai Docker), tetapi ini juga berakhir dengan sokongan selepas pembelian RedHat.
mewah
ΠΡΠ΅ , yang pengarangnya hanya mahu membina dan menjalankan bekas. Berdasarkan dokumentasi dan kod, pengarang tidak mengikuti piawaian, tetapi hanya memutuskan untuk menulis pelaksanaannya sendiri, yang, pada dasarnya, dia lakukan.
Penemuan
Situasi dengan Kubernetes sangat menarik: di satu pihak, dengan Docker anda boleh membina kluster (dalam mod swarm), yang mana anda juga boleh menjalankan persekitaran produk untuk pelanggan, ini terutama berlaku untuk pasukan kecil (3-5 orang) , atau dengan beban keseluruhan yang kecil, atau kekurangan keinginan untuk memahami selok-belok menyediakan Kubernetes, termasuk untuk muatan yang tinggi.
Podman tidak menyediakan keserasian penuh, tetapi ia mempunyai satu kelebihan penting - keserasian dengan Kubernetes, termasuk alat tambahan (buildah dan lain-lain). Oleh itu, saya akan mendekati pilihan alat untuk bekerja seperti berikut: untuk pasukan kecil, atau dengan anggaran terhad - Docker (dengan mod swarm yang mungkin), untuk membangunkan diri saya sendiri pada localhost peribadi - rakan seperjuangan Podman, dan untuk orang lain - Kubernetes.
Saya tidak pasti bahawa keadaan dengan Docker tidak akan berubah pada masa akan datang, lagipun, mereka adalah perintis, dan juga secara beransur-ansur diseragamkan langkah demi langkah, tetapi Podman, untuk semua kekurangannya (hanya berfungsi pada Linux, tiada pengelompokan, perhimpunan dan tindakan lain adalah penyelesaian pihak ketiga) masa depan lebih jelas, jadi saya menjemput semua orang untuk membincangkan penemuan ini dalam ulasan.
PS Pada 3 Ogos kami melancarkan "", di mana anda boleh mengetahui lebih lanjut tentang kerjanya. Kami akan menganalisis semua alatnya: dari abstraksi asas kepada parameter rangkaian, nuansa bekerja dengan pelbagai sistem pengendalian dan bahasa pengaturcaraan. Anda akan menjadi biasa dengan teknologi dan memahami tempat dan cara terbaik untuk menggunakan Docker. Kami juga akan berkongsi kes amalan terbaik.
Harga prapesanan sebelum dikeluarkan: RUB 5000. Anda boleh melihat program Kursus Video Docker .
Sumber: www.habr.com