🥇Dokeris un viss, viss, viss

TL;DR: Pārskata raksts — ceļvedis vides salīdzināšanai lietojumprogrammu darbināšanai konteineros. Tiks izskatītas Docker un citu līdzīgu sistēmu iespējas.

Neliela vēsture, no kurienes tas viss nācis

Stāsts

Pirmais labi zināmais lietojumprogrammas izolēšanas veids ir chroot. Tāda paša nosaukuma sistēmas izsaukums nodrošina izmaiņas saknes direktorijā - tādējādi nodrošinot piekļuvi programmai, kas to izsauca, piekļuvi tikai failiem šajā direktorijā. Bet, ja programmai tiek piešķirtas superlietotāja tiesības, tā potenciāli var "aizbēgt" no chroot un iegūt piekļuvi galvenajai operētājsistēmai. Tāpat papildus saknes direktorija maiņai nav ierobežoti arī citi resursi (RAM, procesors), kā arī piekļuve tīklam.

Nākamais veids ir palaist pilnvērtīgu operētājsistēmu konteinera iekšpusē, izmantojot operētājsistēmas kodola mehānismus. Šo metodi dažādās operētājsistēmās sauc atšķirīgi, taču būtība ir viena – darbojas vairākas neatkarīgas operētājsistēmas, no kurām katra darbojas vienā kodolā, kurā darbojas galvenā operētājsistēma. Tas ietver FreeBSD Jails, Solaris zonas, OpenVZ un LXC operētājsistēmai Linux. Izolācija tiek nodrošināta ne tikai diska vietai, bet arī citiem resursiem, jo īpaši katram konteineram var būt ierobežojumi procesora laikam, RAM, tīkla joslas platumam. Salīdzinot ar chroot, konteinera atstāšana ir grūtāka, jo konteinera superlietotājam ir piekļuve tikai konteinera iekšpusei, tomēr tāpēc, ka konteinerā ir jāatjaunina operētājsistēma un tiek izmantots vecs kodols. versijām (attiecas uz Linux, mazākā mērā FreeBSD), pastāv nulles varbūtība “izlauzties cauri” kodola izolācijas sistēmai un piekļūt galvenajai operētājsistēmai.

Tā vietā, lai konteinerā palaistu pilnvērtīgu operētājsistēmu (ar inicializācijas sistēmu, pakotņu pārvaldnieku utt.), lietojumprogrammas var palaist nekavējoties, galvenais ir nodrošināt lietojumprogrammām šo iespēju (vajadzīgo bibliotēku klātbūtne un citi faili). Šī ideja kalpoja par pamatu konteinerizētajai lietojumprogrammu virtualizācijai, kuras redzamākais un pazīstamākais pārstāvis ir Docker. Salīdzinājumā ar iepriekšējām sistēmām, elastīgāki izolācijas mehānismi, kā arī iebūvēts atbalsts virtuālajiem tīkliem starp konteineriem un lietojumprogrammas statusu konteinera iekšienē, ļāva izveidot vienotu holistisku vidi no liela skaita fizisko serveru, lai darbinātu konteinerus – bez nepieciešamība pēc manuālas resursu pārvaldības.

dokers

Docker ir vispazīstamākā lietojumprogrammu konteinerizācijas programmatūra. Rakstīts Go valodā, tas izmanto parastās Linux kodola iespējas – cgroups, namespaces, iespējas utt., kā arī Aufs failu sistēmas un citas līdzīgas, lai ietaupītu vietu diskā.

Avots: wikimedia

Arhitektūra

Pirms versijas 1.11 Docker strādāja kā vienots pakalpojums, kas veica visas darbības ar konteineriem: konteineru attēlu lejupielādi, konteineru palaišanu, API pieprasījumu apstrādi. Kopš versijas 1.11 Docker ir sadalīts vairākās daļās, kas mijiedarbojas viena ar otru: konteineros, lai apstrādātu visu konteineru dzīves ciklu (diska vietas piešķiršana, attēlu lejupielāde, tīkla izveide, palaišana, instalēšana un konteineru stāvokļa uzraudzība) un runC. , konteinera izpildlaiki, pamatojoties uz cgroups un citu Linux kodola līdzekļu izmantošanu. Pats doka pakalpojums paliek, taču tagad tas kalpo tikai API pieprasījumu apstrādei, kas tiek pārraidīti konteineros.

Uzstādīšana un konfigurēšana

Mans iecienītākais docker instalēšanas veids ir docker-machine, kas papildus tiešai docker instalēšanai un konfigurēšanai attālos serveros (arī dažādos mākoņos), ļauj strādāt ar attālo serveru failu sistēmām, kā arī var palaist dažādas komandas.

Taču kopš 2018. gada projekts gandrīz nav izstrādāts, tāpēc instalēsim to ierastajā veidā lielākajai daļai Linux distribūciju – pievienojot repozitoriju un uzstādot nepieciešamās pakotnes.

Šo metodi izmanto arī automatizētai instalēšanai, piemēram, izmantojot Ansible vai citas līdzīgas sistēmas, taču šajā rakstā es to neapskatīšu.

Instalēšana tiks veikta Centos 7, es izmantošu virtuālo mašīnu kā serveri, lai instalētu, vienkārši palaidiet tālāk norādītās komandas:

# 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.io

Pēc instalēšanas jums jāsāk pakalpojums, jāievieto automātiskā ielāde:

# systemctl enable docker
# systemctl start docker
# firewall-cmd --zone=public --add-port=2377/tcp --permanent

Turklāt jūs varat izveidot docker grupu, kuras lietotāji varēs strādāt ar docker bez sudo, iestatīt reģistrēšanu, iespējot piekļuvi API no ārpuses, neaizmirstiet precīzi noregulēt ugunsmūri (viss, kas nav atļauts, ir aizliegts augstāk un zemāk esošajos piemēros - es to izlaidu vienkāršības un vizualizācijas labad), bet es šeit neiedziļināšos.

Citas funkcijas

Papildus iepriekš minētajai doka mašīnai ir arī doku reģistrs, rīks attēlu glabāšanai konteineriem, kā arī docker compose - rīks lietojumprogrammu izvietošanas automatizēšanai konteineros, YAML faili tiek izmantoti konteineru veidošanai un konfigurēšanai un citas saistītas lietas (piemēram, tīkli, pastāvīgas failu sistēmas datu glabāšanai).

To var izmantot arī CICD cauruļvadu organizēšanai. Vēl viena interesanta funkcija ir darbs klastera režīmā, tā sauktajā spieta režīmā (pirms versijas 1.12 tas bija pazīstams kā docker swarm), kas ļauj no vairākiem serveriem apkopot vienu infrastruktūru, lai darbinātu konteinerus. Virs visiem serveriem ir atbalsts virtuālajam tīklam, ir iebūvēts slodzes balansētājs, kā arī atbalsts konteineru noslēpumiem.

YAML failus no docker compose var izmantot šādiem klasteriem ar nelielām modifikācijām, pilnībā automatizējot mazu un vidēju klasteru uzturēšanu dažādiem mērķiem. Lieliem klasteriem ir vēlams izmantot Kubernetes, jo spieta režīma uzturēšanas izmaksas var pārsniegt Kubernetes izmaksas. Papildus runC kā konteineru izpildes vidi varat instalēt, piemēram Kata konteineri

Darbs ar Docker

Pēc instalēšanas un konfigurēšanas mēs mēģināsim izveidot klasteru, kurā izstrādes komandai izvietosim GitLab un Docker Registry. Kā serverus izmantošu trīs virtuālās mašīnas, uz kurām papildus izvietošu GlusterFS izkliedēto FS, izmantošu kā docker volumes krātuvi, piemēram, lai palaistu nevainojamu docker reģistra versiju. Galvenās palaišanas sastāvdaļas: Docker Registry, Postgresql, Redis, GitLab ar GitLab Runner atbalstu Swarm. Mēs palaižam Postgresql ar klasterizāciju Stolons, tāpēc Postgresql datu glabāšanai nav jāizmanto GlusterFS. Atlikušie kritiskie dati tiks saglabāti GlusterFS.

Lai izvietotu GlusterFS visos serveros (tos sauc par node1, node2, node3), jums ir jāinstalē pakotnes, jāiespējo ugunsmūris, jāizveido nepieciešamie direktoriji:

# 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/fstab

Pēc instalēšanas darbs pie GlusterFS konfigurēšanas jāturpina no viena mezgla, piemēram, 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 docker

Pēc tam jums jāpievieno iegūtais sējums (komanda ir jāpalaiž visos serveros):

# mount /srv/docker

Swarm režīms ir konfigurēts vienā no serveriem, kas būs Leader, pārējiem būs jāpievienojas klasterim, tāpēc komandas palaišanas rezultāts pirmajā serverī būs jāpārkopē un jāizpilda pārējā.

Sākotnējā klastera iestatīšana, es izpildu komandu mezglā1:

# docker swarm init
Swarm initialized: current node (a5jpfrh5uvo7svzz1ajduokyq) is now a manager.

To add a worker to this swarm, run the following command:

    docker swarm join --token SWMTKN-1-0c5mf7mvzc7o7vjk0wngno2dy70xs95tovfxbv4tqt9280toku-863hyosdlzvd76trfptd4xnzd xx.xx.xx.xx:2377

To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.
# docker swarm join-token manager

Kopējiet otrās komandas rezultātu, izpildiet node2 un node3:

# docker swarm join --token SWMTKN-x-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-xxxxxxxxx xx.xx.xx.xx:2377
This node joined a swarm as a manager.

Tādējādi tiek pabeigta serveru sākotnējā konfigurēšana, sāksim konfigurēt pakalpojumus, izpildāmās komandas tiks palaistas no node1, ja nav norādīts citādi.

Vispirms izveidosim tīklus konteineriem:

# 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 gitlab

Pēc tam mēs atzīmējam serverus, tas ir nepieciešams, lai saistītu dažus pakalpojumus ar serveriem:

# docker node update --label-add nodename=node1 node1
# docker node update --label-add nodename=node2 node2
# docker node update --label-add nodename=node3 node3

Tālāk mēs izveidojam direktorijus etcd datu glabāšanai, KV krātuvi, kas nepieciešama Traefik un Stolon. Līdzīgi kā Postgresql, tie būs konteineri, kas saistīti ar serveriem, tāpēc mēs izpildām šo komandu visos serveros:

# mkdir -p /srv/etcd

Pēc tam izveidojiet failu etcd konfigurēšanai un lietojiet to:

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 etcd

Pēc kāda laika mēs pārbaudām, vai etcd klasteris ir izveidots:

# 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 healthy

Izveidojiet Postgresql direktorijus, izpildiet komandu visos serveros:

# mkdir -p /srv/pgsql

Pēc tam izveidojiet failu, lai konfigurētu 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: true

Mēs ģenerējam noslēpumus, lietojam failu:

# </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

Pēc kāda laika (apskatiet komandas izvadi dokera serviss lska visi pakalpojumi ir pieauguši) inicializē Postgresql klasteru:

# 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 init

Postgresql klastera gatavības pārbaude:

# 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

Mēs konfigurējam traefik, lai atvērtu piekļuvi konteineriem no ārpuses:

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 traefik

Mēs startējam Redis Cluster, šim nolūkam visos mezglos izveidojam krātuves direktoriju:

# mkdir -p /srv/redis

05redis.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 redis

Pievienojiet Docker reģistru:

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

Un visbeidzot - 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 gitlab

Klastera un pakalpojumu galīgais stāvoklis:

# 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/tcp

Ko vēl var uzlabot? Noteikti konfigurējiet Traefik darbam ar https konteineriem, pievienojiet tls šifrēšanu Postgresql un Redis. Bet vispār jau var iedot izstrādātājiem kā PoC. Tagad apskatīsim Docker alternatīvas.

Podmans

Vēl viens diezgan labi pazīstams dzinējs konteineru darbināšanai, kas sagrupēti pēc podiņiem (pods, konteineru grupas, kas izvietotas kopā). Atšķirībā no Docker, konteineru palaišanai nav nepieciešams pakalpojums, viss darbs tiek veikts, izmantojot libpod bibliotēku. Rakstīts arī Go, ir nepieciešams ar OCI saderīgs izpildlaiks, lai palaistu konteinerus, piemēram, runC.

Darbs ar Podman kopumā līdzinās Docker darbam, ciktāl jūs to varat izdarīt šādi (to apgalvo daudzi, kas to ir mēģinājuši, tostarp šī raksta autors):

$ alias docker=podman

un jūs varat turpināt strādāt. Kopumā situācija ar Podman ir ļoti interesanta, jo, ja Kubernetes agrīnās versijas strādāja ar Docker, tad aptuveni kopš 2015. gada pēc konteineru pasaules standartizācijas (OCI - Open Container Initiative) un Docker sadalīšanas konteineros un runC, alternatīva Docker tiek izstrādāts, lai tas darbotos Kubernetes: CRI-O. Podman šajā ziņā ir alternatīva Docker, kas veidota pēc Kubernetes principiem, ieskaitot konteineru grupēšanu, taču projekta galvenais mērķis ir darbināt Docker stila konteinerus bez papildu pakalpojumiem. Acīmredzamu iemeslu dēļ spieta režīma nav, jo izstrādātāji skaidri saka, ka, ja jums ir nepieciešams klasteris, izmantojiet Kubernetes.

Uzstādīšana

Lai instalētu Centos 7, vienkārši aktivizējiet Extras repozitoriju un pēc tam instalējiet visu ar komandu:

# yum -y install podman

Citas funkcijas

Podman var ģenerēt sistēmas sistēmas vienības, tādējādi atrisinot konteineru palaišanas problēmu pēc servera pārstartēšanas. Turklāt tiek deklarēts, ka systemd konteinerā darbojas pareizi kā pid 1. Lai izveidotu konteinerus, ir atsevišķs buildah rīks, ir arī trešo pušu rīki - docker-compose analogi, kas arī ģenerē ar Kubernetes saderīgus konfigurācijas failus, tāpēc pāreja no Podman uz Kubernetes ir pēc iespējas vienkāršāka.

Darbs ar Podmanu

Tā kā spieta režīma nav (ja ir nepieciešams klasteris paredzēts pārslēgties uz Kubernetes), mēs to saliksim atsevišķos konteineros.

Instalējiet podman-compose:

# yum -y install python3-pip
# pip3 install podman-compose

Iegūtais podman konfigurācijas fails ir nedaudz atšķirīgs, jo, piemēram, mums bija jāpārvieto atsevišķa sējumu sadaļa tieši uz pakalpojumu sadaļu.

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 up

Darba rezultāts:

# 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_1

Apskatīsim, ko tas ģenerēs systemd un kubernetes, šim nolūkam mums ir jānoskaidro podnieka nosaukums vai ID:

# podman pod ls
POD ID         NAME   STATUS    CREATED          # OF CONTAINERS   INFRA ID
71fc2b2a5c63   root   Running   11 minutes ago   3                 db40ab8bf84b

Kubernetes:

# 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: {}

sistēma:

# 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.target

Diemžēl, izņemot konteineru palaišanu, ģenerētā vienība systemd nedara neko citu (piemēram, iztīra vecos konteinerus, kad šāds pakalpojums tiek restartēts), tāpēc šādas lietas jums būs jāpievieno pašam.

Principā pietiek ar Podman, lai pamēģinātu, kas ir konteineri, pārsūtītu vecās konfigurācijas docker-compose un pēc tam dotos uz Kubernetes, ja nepieciešams, klasterī vai iegūtu vieglāk lietojamu alternatīvu Docker.

rkt

Projekts aizgāja uz arhīvu apmēram pirms pusgada sakarā ar to, ka RedHat to nopirka, tāpēc sīkāk par to nekavēšos. Kopumā atstāja ļoti labu iespaidu, bet salīdzinot ar Docker un vēl jo vairāk ar Podman izskatās pēc kombaina. Bija arī CoreOS izplatīšana, kas tika uzcelta uz rkt (lai gan sākotnēji viņiem bija Docker), bet arī tas beidzās pēc RedHat iegādes.

Zibspuldze

Vairāk viens projekts, kuras autors vienkārši gribēja būvēt un palaist konteinerus. Spriežot pēc dokumentācijas un koda, autors neievēroja standartus, bet vienkārši nolēma uzrakstīt savu realizāciju, ko principā arī izdarīja.

Atzinumi

Situācija ar Kubernetes ir ļoti interesanta: no vienas puses, ar Docker var salikt klasteru (swarm režīmā), ar kuru var pat palaist ražošanas vides klientiem, īpaši tas attiecas uz mazām komandām (3-5 cilvēki). ), vai ar nelielu kopējo slodzi, vai arī trūkst vēlmes izprast Kubernetes iestatīšanas sarežģījumus, tostarp lielām slodzēm.

Podman nenodrošina pilnīgu savietojamību, taču tam ir viena svarīga priekšrocība - saderība ar Kubernetes, ieskaitot papildu rīkus (buildah un citus). Tāpēc darba rīka izvēlei es ķeršos klāt šādi: mazām komandām vai ar ierobežotu budžetu - Docker (ar iespējamu spieta režīmu), attīstīšanai sev personīgā lokālā saimniekdatorā - Podman biedri un visiem pārējiem - Kubernetes.

Neesmu pārliecināts, ka ar Docker situācija nākotnē nemainīsies, galu galā viņi ir pionieri, un arī lēnām soli pa solim standartizējas, bet Podman ar visiem trūkumiem (darbojas tikai uz Linux, nav klasterēšanas, montāžas un citas darbības ir trešo pušu lēmumi) nākotne ir skaidrāka, tāpēc aicinu ikvienu apspriest šos secinājumus komentāros.

PS 3. augustā mēs uzsākam "Docker video kursskur varat uzzināt vairāk par viņa darbu. Mēs analizēsim visus tā rīkus: no pamata abstrakcijām līdz tīkla parametriem, niansēm darbā ar dažādām operētājsistēmām un programmēšanas valodām. Jūs iepazīsities ar tehnoloģiju un sapratīsiet, kur un kā vislabāk izmantot Docker. Mēs arī dalīsimies ar paraugprakses piemēriem.

Iepriekšpasūtīšanas cena pirms izlaišanas: RUB 5000. Varat apskatīt programmu Docker Video Course kursa lapā.

Avots: www.habr.com

Docker un viss, viss, viss

Stāsts

dokers

Arhitektūra

Uzstādīšana un konfigurēšana

Citas funkcijas

Darbs ar Docker

Podmans

Uzstādīšana

Citas funkcijas

Darbs ar Podmanu

rkt

Zibspuldze

Atzinumi

Pievieno komentāru Atcelt atbildi