🥇Docker 및 모든 것, 모든 것, 모든 것

핵심요약: 컨테이너에서 애플리케이션을 실행하기 위한 프레임워크를 비교하는 개요 가이드입니다. Docker 및 기타 유사한 시스템의 기능이 고려됩니다.

모든 것이 어디서 왔는지에 대한 작은 역사

이야기

애플리케이션을 분리하는 잘 알려진 첫 번째 방법은 chroot입니다. 동일한 이름의 시스템 호출은 루트 디렉토리가 변경되도록 보장합니다. 따라서 루트 디렉토리를 호출한 프로그램은 해당 디렉토리 내의 파일에만 액세스할 수 있습니다. 그러나 프로그램에 내부적으로 루트 권한이 부여되면 잠재적으로 chroot를 "탈출"하여 기본 운영 체제에 액세스할 수 있습니다. 또한 루트 디렉터리 변경 외에도 기타 리소스(RAM, 프로세서)는 물론 네트워크 액세스도 제한되지 않습니다.

다음 방법은 운영 체제 커널의 메커니즘을 사용하여 컨테이너 내에서 본격적인 운영 체제를 시작하는 것입니다. 이 방법은 운영 체제마다 다르게 호출되지만 본질은 동일합니다. 즉, 여러 개의 독립적인 운영 체제를 실행하고 각 운영 체제는 기본 운영 체제가 실행되는 것과 동일한 커널을 실행합니다. 여기에는 FreeBSD Jails, Solaris Zones, OpenVZ 및 Linux용 LXC가 포함됩니다. 디스크 공간뿐만 아니라 다른 리소스를 통해서도 격리가 보장됩니다. 특히 각 컨테이너에는 프로세서 시간, RAM 및 네트워크 대역폭에 대한 제한이 있을 수 있습니다. chroot에 비해 컨테이너를 떠나는 것이 더 어렵습니다. 컨테이너의 수퍼유저는 컨테이너의 내용에만 액세스할 수 있기 때문입니다. 그러나 컨테이너 내부의 운영 체제를 최신 상태로 유지해야 하고 이전 버전을 사용해야 하기 때문입니다. 커널(Linux와 관련이 있고 FreeBSD와 관련이 있음)의 경우 커널 격리 시스템을 "돌파"하여 기본 운영 체제에 액세스할 가능성이 XNUMX이 아닙니다.

컨테이너(초기화 시스템, 패키지 관리자 등 포함)에서 본격적인 운영 체제를 시작하는 대신 애플리케이션을 즉시 시작할 수 있습니다. 가장 중요한 것은 애플리케이션에 그러한 기회(필요한 라이브러리가 있음)를 제공하는 것입니다. 및 기타 파일). 이 아이디어는 컨테이너화된 애플리케이션 가상화의 기반이 되었으며, 그 중 가장 유명하고 잘 알려진 대표자는 Docker입니다. 이전 시스템에 비해 보다 유연한 격리 메커니즘과 컨테이너 간 가상 네트워크에 대한 기본 제공 지원 및 컨테이너 내 애플리케이션 상태 추적을 통해 컨테이너 실행을 위해 다수의 물리적 서버에서 일관된 단일 환경을 구축할 수 있게 되었습니다. 수동으로 리소스를 관리할 필요가 없습니다.

도커

Docker는 가장 유명한 애플리케이션 컨테이너화 소프트웨어입니다. Go 언어로 작성되었으며 Linux 커널의 표준 기능(cgroup, 네임스페이스, 기능 등)은 물론 Aufs 파일 시스템 및 이와 유사한 기능을 사용하여 디스크 공간을 절약합니다.

출처: 위키미디어

구조

버전 1.11 이전에는 Docker는 컨테이너 이미지 다운로드, 컨테이너 실행, API 요청 처리 등 컨테이너와 관련된 모든 작업을 수행하는 단일 서비스로 작동했습니다. 버전 1.11부터 Docker는 서로 상호 작용하는 여러 부분으로 나누어졌습니다. 컨테이너의 전체 수명 주기를 처리하기 위한 컨테이너d(디스크 공간 할당, 이미지 다운로드, 네트워크 작업, 컨테이너 실행, 설치 및 상태 모니터링) 그리고 Linux 커널의 cgroup 및 기타 기능 사용을 기반으로 하는 컨테이너 실행 환경인 runC가 있습니다. Docker 서비스 자체는 그대로 유지되지만 이제는 컨테이너로 변환된 API 요청을 처리하는 역할만 합니다.

설치 및 구성

제가 가장 좋아하는 docker 설치 방법은 docker-machine인데, 이는 원격 서버(다양한 클라우드 포함)에 docker를 직접 설치하고 구성하는 것 외에도 원격 서버의 파일 시스템과 작업이 가능하고 다양한 명령을 실행할 수도 있습니다.

그러나 2018년 이후에는 프로젝트가 거의 개발되지 않았기 때문에 대부분의 Linux 배포판에 대한 표준 방식(리포지토리 추가 및 필요한 패키지 설치)으로 설치할 것입니다.

이 방법은 예를 들어 Ansible 또는 기타 유사한 시스템을 사용하는 자동 설치에도 사용되지만 이 기사에서는 고려하지 않습니다.

설치는 Centos 7에서 수행됩니다. 가상 머신을 서버로 사용하여 설치하려면 아래 명령을 실행하면 됩니다.

# 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

설치 후에는 서비스를 시작하고 시작 모드에 두어야 합니다.

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

또한 사용자가 sudo 없이 docker로 작업하고, 로깅을 설정하고, 외부에서 API에 대한 액세스를 활성화하고, 방화벽을 보다 정확하게 구성하는 것을 잊지 않는 docker 그룹을 생성할 수 있습니다(허용되지 않는 모든 것). 위와 아래의 예에서는 금지되어 있습니다. 단순성과 명확성을 위해 생략했습니다. 그러나 여기서는 더 자세히 설명하지 않겠습니다.

다른 특징들

위에서 언급한 도커 머신 외에도 컨테이너용 이미지를 저장하는 도구인 도커 레지스트리(Docker Registry)와 컨테이너에 애플리케이션 배포를 자동화하는 도구인 도커 작성(Docker Compose)도 있으며, YAML 파일은 컨테이너를 구축하고 구성하는 데 사용됩니다. 및 기타 관련 사항(예: 네트워크, 스토리지 데이터용 영구 파일 시스템)

CICD용 컨베이어를 구성하는 데에도 사용할 수 있습니다. 또 다른 흥미로운 기능은 소위 스웜(swarm) 모드(버전 1.12 이전에는 docker swarm으로 알려짐)인 클러스터 모드에서 작동하는 것입니다. 이 모드를 사용하면 컨테이너를 실행하기 위해 여러 서버에서 단일 인프라를 조립할 수 있습니다. 모든 서버 위에 가상 네트워크가 지원되고 로드 밸런서가 내장되어 있으며 컨테이너에 대한 비밀도 지원됩니다.

약간의 수정을 거쳐 docker compose의 YAML 파일을 이러한 클러스터에 사용할 수 있어 다양한 목적으로 중소 규모 클러스터의 유지 관리를 완전히 자동화할 수 있습니다. 대규모 클러스터의 경우 스웜 모드의 유지 관리 비용이 Kubernetes의 유지 관리 비용을 초과할 수 있으므로 Kubernetes가 선호됩니다. runC 외에도 컨테이너 실행 환경 등을 설치할 수 있습니다. 카타 컨테이너

도커로 작업하기

설치 및 구성 후에는 개발 팀을 위해 GitLab 및 Docker Registry를 배포할 클러스터를 어셈블해 보겠습니다. 세 개의 가상 머신을 서버로 사용하고 여기에 분산형 FS GlusterFS를 추가로 배포할 것입니다. 예를 들어 내결함성 버전의 Docker 레지스트리를 실행하기 위해 이를 Docker 볼륨 스토리지로 사용할 것입니다. 실행할 주요 구성 요소: Docker Registry, Postgresql, Redis, Swarm 기반의 GitLab Runner를 지원하는 GitLab. 클러스터링을 갖춘 Postgresql을 시작하겠습니다 스톨론, 따라서 Postgresql 데이터를 저장하기 위해 GlusterFS를 사용할 필요가 없습니다. 나머지 중요한 데이터는 GlusterFS에 저장됩니다.

모든 서버(node1, node2, node3라고 함)에 GlusterFS를 배포하려면 패키지를 설치하고 방화벽을 활성화하고 필요한 디렉터리를 생성해야 합니다.

# 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

설치 후 GlusterFS 구성 작업은 하나의 노드(예: 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

그런 다음 결과 볼륨을 마운트해야 합니다(명령은 모든 서버에서 실행되어야 함).

# mount /srv/docker

Swarm 모드는 리더가 될 서버 중 하나에 구성되고 나머지는 클러스터에 참여해야 하므로 첫 번째 서버에서 명령을 실행한 결과를 복사하여 다른 서버에서 실행해야 합니다.

초기 클러스터 설정, 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 manager

두 번째 명령의 결과를 복사하여 node2 및 node3에서 실행합니다.

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

이제 서버의 예비 구성이 완료되었으니 서비스 설정을 진행해 보겠습니다. 달리 지정하지 않는 한 실행할 명령은 node1에서 시작됩니다.

우선 컨테이너용 네트워크를 만들어 보겠습니다.

# 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

그런 다음 서버를 표시합니다. 이는 일부 서비스를 서버에 바인딩하는 데 필요합니다.

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

다음으로 Traefik 및 Stolon에 필요한 etcd 데이터, KV 스토리지를 저장하기 위한 디렉터리를 만듭니다. Postgresql과 마찬가지로 서버에 연결된 컨테이너이므로 모든 서버에서 다음 명령을 실행합니다.

# mkdir -p /srv/etcd

다음으로 etcd를 구성하기 위한 파일을 생성하고 사용합니다.

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

잠시 후 etcd 클러스터가 작동되는지 확인합니다.

# 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

Postgresql용 디렉터리를 만들고 모든 서버에서 다음 명령을 실행합니다.

# mkdir -p /srv/pgsql

다음으로 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

비밀을 생성하고 파일을 사용합니다.

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

잠시 후(명령 출력 참조) 도커 서비스 ls모든 서비스가 작동 중인지 확인) 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 init

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

외부에서 컨테이너에 대한 액세스를 열도록 traefik을 구성합니다.

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

Redis 클러스터를 시작하고 이를 위해 모든 노드에 스토리지 디렉터리를 생성합니다.

# 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

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 registry

그리고 마지막으로 - 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

클러스터 및 서비스의 최종 상태:

# 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

또 어떤 점을 개선할 수 있나요? https를 통해 컨테이너를 실행하도록 Traefik을 구성하고 Postgresql 및 Redis에 대한 TLS 암호화를 추가해야 합니다. 그러나 일반적으로 이미 PoC로 개발자에게 제공될 수 있습니다. 이제 Docker의 대안을 살펴보겠습니다.

포드 맨

포드(포드, 함께 배포된 컨테이너 그룹)별로 그룹화된 컨테이너를 실행하기 위한 꽤 잘 알려진 또 다른 엔진입니다. Docker와 달리 컨테이너를 실행하는 데 서비스가 필요하지 않으며 모든 작업은 libpod 라이브러리를 통해 수행됩니다. 또한 Go로 작성되었으며 runC와 같은 컨테이너를 실행하려면 OCI 호환 런타임이 필요합니다.

Podman으로 작업하는 것은 일반적으로 다음과 같이 수행할 수 있다는 점에서 Docker의 작업을 연상시킵니다(이 기사의 저자를 포함하여 이를 시도한 많은 사람들이 언급했듯이).

$ alias docker=podman

계속 일할 수 있습니다. 일반적으로 Podman의 상황은 매우 흥미롭습니다. 왜냐하면 초기 버전의 Kubernetes가 Docker와 함께 작동했다면 2015년경 컨테이너 세계(OCI - Open Container Initiative)가 표준화되고 Docker가 컨테이너d와 runC로 분할된 후, Kubernetes에서 실행하기 위한 Docker의 대안인 CRI-O가 개발되었습니다. 이런 점에서 Podman은 컨테이너 그룹화를 포함하여 Kubernetes의 원칙을 기반으로 구축된 Docker의 대안이지만 프로젝트의 주요 목적은 추가 서비스 없이 Docker 스타일 컨테이너를 시작하는 것입니다. 분명한 이유로 스웜 모드는 없습니다. 개발자가 클러스터가 필요하면 Kubernetes를 사용한다고 분명히 말했기 때문입니다.

설치

Centos 7에 설치하려면 Extras 저장소를 활성화한 후 다음 명령을 사용하여 모든 것을 설치하십시오.

# yum -y install podman

다른 특징들

Podman은 systemd용 단위를 생성하여 서버 재부팅 후 컨테이너 시작 문제를 해결할 수 있습니다. 또한 systemd는 컨테이너에서 pid 1로 올바르게 작동하도록 선언되었습니다. 컨테이너 구축을 위한 별도의 빌드 도구가 있고, Kubernetes와 호환되는 구성 파일을 생성하는 docker-compose와 유사한 타사 도구도 있으므로 Podman에서 Kubernetes로의 전환이 최대한 단순화됩니다.

포드맨과 함께 일하기

Swarm 모드가 없으므로(클러스터가 필요한 경우 Kubernetes로 전환해야 함) 별도의 컨테이너에 수집합니다.

Podman-compose를 설치합니다.

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

Podman에 대한 결과 구성 파일은 약간 다르기 때문에 예를 들어 별도의 볼륨 섹션을 서비스가 있는 섹션으로 직접 이동해야 했습니다.

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

결과:

# 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

systemd 및 kubernetes에 대해 무엇이 생성되는지 살펴보겠습니다. 이를 위해 포드의 이름이나 ID를 찾아야 합니다.

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

쿠버네티스:

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

시스템:

# 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

안타깝게도 컨테이너 실행 외에 systemd용으로 생성된 유닛은 다른 작업을 수행하지 않습니다(예: 서비스가 다시 시작될 때 이전 컨테이너 정리). 따라서 이러한 작업은 직접 작성해야 합니다.

원칙적으로 Podman은 컨테이너가 무엇인지 시험해보고, docker-compose에 대한 이전 구성을 전송한 다음 클러스터가 필요한 경우 Kubernetes로 이동하거나 Docker에 대한 사용하기 쉬운 대안을 얻는 데 충분합니다.

rkt

계획 기록 보관소에 들어갔다 약 XNUMX개월 전에 RedHat이 이를 구입했기 때문에 더 자세히 설명하지는 않겠습니다. 전반적으로 매우 좋은 인상을 주었지만 Docker, 특히 Podman과 비교하면 결합체처럼 보입니다. rkt 위에 구축된 CoreOS 배포판도 있었지만(원래는 Docker가 있었음에도 불구하고) RedHat 구매 이후 지원이 종료되었습니다.

플래쉬

다른 하나의 프로젝트, 작성자는 컨테이너를 구축하고 실행하기를 원했습니다. 문서와 코드로 판단하면 작성자는 표준을 따르지 않고 원칙적으로 자신의 구현을 작성하기로 결정했습니다.

조사 결과

Kubernetes의 상황은 매우 흥미롭습니다. 한편으로는 Docker를 사용하여 클라이언트를 위한 제품 환경을 실행할 수도 있는 클러스터(스웜 모드)를 구축할 수 있습니다. 이는 특히 소규모 팀(3~5명)에 해당됩니다. , 전체 로드가 작거나, 높은 로드를 포함하여 Kubernetes 설정의 복잡성을 이해하려는 욕구가 부족합니다.

Podman은 완전한 호환성을 제공하지는 않지만 추가 도구(buildah 및 기타)를 포함하여 Kubernetes와의 호환성이라는 한 가지 중요한 이점이 있습니다. 따라서 작업 도구 선택에 다음과 같이 접근할 것입니다. 소규모 팀 또는 예산이 제한된 경우 - Docker(스웜 모드 가능), 개인 로컬 호스트에서 개발하기 위한 경우 - Podman 동지 및 기타 모든 사람을 위한 것입니다. - 쿠버네티스.

Docker의 상황이 미래에도 변하지 않을지 확신할 수 없습니다. 결국 그들은 선구자이며 단계적으로 점차 표준화되고 있지만 Podman은 모든 단점에도 불구하고(Linux에서만 작동하고 클러스터링 없음, 조립 및 기타 작업은 타사 솔루션입니다) 미래는 더 명확하므로 의견에서 이러한 결과에 대해 모든 사람이 논의하도록 초대합니다.

PS 3월 XNUMX일에 '를 출시합니다.도커 비디오 코스"에서 그의 작품에 대해 더 자세히 알아볼 수 있습니다. 기본 추상화부터 네트워크 매개변수, 다양한 운영 체제 및 프로그래밍 언어 작업의 뉘앙스까지 모든 도구를 분석합니다. 기술에 익숙해지고 Docker를 가장 잘 사용할 수 있는 위치와 방법을 이해하게 됩니다. 우수사례도 공유하겠습니다.

출시 전 사전 주문 가격: RUB 5000. Docker Video Course 프로그램을 보실 수 있습니다. 강좌 페이지에서.

출처 : habr.com

도커와 모두, 모두, 모두

이야기

도커

구조

설치 및 구성

다른 특징들

도커로 작업하기

포드 맨

설치

다른 특징들

포드맨과 함께 일하기

rkt

플래쉬

조사 결과

코멘트를 추가 답장을 취소