Guia de implantação de orquestração de serviço de nó único do Docker (docker-compose)

Ferramenta de implantação de vários contêineres Docker-Compose

visão geral

O projeto Docker-Compose é o projeto de código aberto oficial do Docker e é uma ferramenta para definir e executar aplicativos Docker de vários contêineres. Responsável pela orquestração rápida de clusters de contêiner Docker. Com o Compose, você pode usar arquivos YML para configurar todos os serviços de que seu aplicativo precisa. Então, com um único comando, todos os serviços podem ser criados e iniciados a partir da configuração do arquivo YML.

O Docker-Compose divide os contêineres gerenciados em três camadas, a saber, projeto, serviço e contêiner. Todos os arquivos no diretório em execução do Docker-Compose (docker-compose.yml, arquivo de extensão ou arquivo de variável de ambiente, etc.) formam um projeto. Se não houver designação especial, o nome do projeto é o nome do diretório atual.

Um projeto pode conter vários serviços e cada serviço define a imagem, os parâmetros e as dependências do contêiner em execução. Um serviço pode incluir várias instâncias de contêiner. O Docker-Compose não resolve o problema de balanceamento de carga, portanto, outras ferramentas são necessárias para realizar a descoberta de serviço e o balanceamento de carga.

O arquivo de configuração de projeto padrão do Docker-Compose é docker-compose.yml, e o arquivo de configuração pode ser personalizado por meio da variável de ambiente COMPOSE_FILE ou do parâmetro -f, que define vários serviços dependentes e o contêiner em execução de cada serviço.

O uso de um arquivo de modelo Dockerfile permite que os usuários definam facilmente um contêiner de aplicativo separado. No trabalho, muitas vezes encontramos situações que exigem que vários contêineres cooperem entre si para concluir uma determinada tarefa. Por exemplo, para implementar um projeto da Web, além do próprio contêiner de serviço da Web, muitas vezes é necessário adicionar um contêiner de serviço de banco de dados de back-end e até mesmo um contêiner de balanceamento de carga.

O Compose permite que os usuários definam um conjunto de contêineres de aplicativos associados como um projeto por meio de um arquivo de modelo docker-compose.yml separado (formato YAML). O projeto Docker-Compose é escrito em Python e chama a API fornecida pelo serviço Docker para gerenciar o contêiner. Portanto, desde que a plataforma operacional suporte a API do Docker, o Compose pode ser usado para gerenciamento de orquestração nela.

Instalação e desinstalação do Docker-Compose

Instalação do Docker-compose

• Para instalar o Docker Compose, você pode baixar automaticamente a versão adaptada do Compose por meio do seguinte comando e adicionar permissões de execução ao script de instalação

# 要安装其他版本的 Compose，请替换 v2.2.2。
sudo curl -L "https://get.daocloud.io/docker/compose/releases/download/1.24.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

chmod +x /usr/local/bin/docker-compose

• Verifique se a instalação foi bem-sucedida

docker-compose -v

• Criar um link suave:

ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose

Desinstalação do Docker-compose

apt-get remove docker-compose

comandos comuns docker-compose

• ps : lista todos os contêineres em execução

docker-compose ps

• logs : visualize a saída do log de serviço

docker-compose logs [options] [SERVICE...]
# 选项包括
–no-color	关闭颜色。默认情况下，docker-compose将对不同的服务输出使用不同的颜色来区分
-f 			跟踪日志输出
。
# 示例
docker-compose logs

• up : Use o arquivo docker-compose.yaml no diretório atual para criar, iniciar e atualizar o contêiner

  • Quando a configuração de um serviço mudar, use o comando docker-compose up para atualizar a configuração

    Nesse ponto, o Compose excluirá o contêiner antigo e criará um novo contêiner. O novo contêiner ingressará na rede com um endereço IP diferente e o nome permanecerá o mesmo. Qualquer conexão com o contêiner antigo será encerrada e o novo contêiner será encontrado e conectado.

docker-compose up [options] [--scale SERVICE=NUM...] [SERVICE...]
# 选项包括：
-f					# 指定yml部署模板文件
-d 					# 在后台运行服务容器
--force-recreate 	# 强制重新创建容器，不能与-no-recreate同时使用
-no-recreate 		# 如果容器已经存在，则不重新创建，不能与–force-recreate同时使用
-no-color 		# 不用颜色来区分不同的服务的控制输出
-no-deps 		# 不启动服务所链接的容器
-no-build 		# 不自动构建缺失的服务镜像
-build 			# 在启动容器前构建服务镜像
-V, --renew-anon-volumes		# 重新创建匿名卷，而不是从以前的容器中检索数据
-abort-on-container-exit 		# 如果任何一个容器被停止，则停止所有容器。不能与-d同时使用
-t, -timeout TIMEOUT 			# 停止容器时候的超时（默认为10秒）
-remove-orphans 				# 删除服务中没有在compose.yaml文件中定义的容器
--scale SERVICE=NUM			# 将Compose.yaml中的SERVICE服务扩展到NUM个实例，快速实现一个负载均衡（单节点）
								# 该参数会覆盖Compose.yaml文件中的“scale”设置(如果存在)。
								# 注意：如果Compose.yaml中设置了ports配置（端口绑定）
								# ，当使用scale参数拓展到多个实例时，会端口冲突，需删除Compose.yaml中的ports配置

# 示例
docker-compose up --force-recreate -d

• port : Exibe a porta pública para a qual uma porta de contêiner é mapeada

docker-compose port [options] SERVICE PRIVATE_PORT
# 选项包括：
–protocol=proto		指定端口协议，TCP（默认值）或者UDP
–index=index		如果同意服务存在多个容器，指定命令对象容器的序号（默认为1）
# 示例：下面命令可以输出 eureka 服务 8761 端口所绑定的公共端口
docker-compose port eureka 8761

• build : construa ou reconstrua o contêiner de serviço.

  Depois que o contêiner de serviço for criado, ele receberá um nome de tag. Você pode executar o docker-compose build no diretório do projeto a qualquer momento para reconstruir o serviço

docker-compose build [options] [--build-arg key=val...] [SERVICE...]
# 选项包括：
–compress 	通过gzip压缩构建上下环境
–force-rm 	删除构建过程中的临时容器
–no-cache 	构建镜像过程中不使用缓存
–pull 		始终尝试通过拉取操作来获取更新版本的镜像
-m, –memory MEM		为构建的容器设置内存大小
–build-arg key=val	为服务设置build-time变量
# 示例：
docker-compose build

• stop : Para o container do serviço que já está rodando

docker-compose stop [options] [SERVICE...]
# 选项包括
-t, –timeout TIMEOUT 停止容器时候的超时（默认为10秒）
# 示例
docker-compose stop eureka

• start : Inicia o contêiner onde o serviço especificado já existe

docker-compose start [SERVICE...]
# 示例
docker-compose start eureka

• restart : reinicie o serviço no projeto

docker-compose restart [options] [SERVICE...]
# 选项包括：
-t, –timeout TIMEOUT	指定重启前停止容器的超时（默认为10秒）
# 示例：
docker-compose restart

• rm : remove todos ou os contêineres de serviço especificados (parados)

docker-compose rm [options] [SERVICE...]
# 选项包括：
–f, –force	强制直接删除，包括非停止状态的容器
-v			删除容器所挂载的数据卷
# 示例
docker-compose rm eureka

• kill : Interrompa com força o contêiner do serviço especificado enviando um sinal SIGKILL

docker-compose kill [options] [SERVICE...]
# 选项包括：
-s	来指定发送的信号
# 示例
docker-compose kill eureka
docker-compose kill -s SIGINT

• push : A imagem da qual o serviço push depende

docker-compose push [options] [SERVICE...]
# 选项包括：
–ignore-push-failures  忽略推送镜像过程中的错误

• pull : baixe o espelho do serviço

docker-compose pull [options] [SERVICE...]
# 选项包括：
–ignore-pull-failures	忽略拉取镜像过程中的错误
–parallel	多个镜像同时拉取
–quiet		拉取镜像过程中不打印进度信息
# 示例
docker-compose pull

• scale : Defina o número de contêineres em execução para o serviço especificado, especificado na forma de service=num

docker-compose scale user=3 movie=3

• run : Executa um comando em um serviço

docker-compose run web bash

• down : pare e exclua todos os contêineres, redes, volumes, imagens.

docker-compose down [options]
# 选项包括：
–rmi type		删除镜像，类型必须是：all，删除compose文件中定义的所有镜像；local，删除镜像名为空的镜像
-v, –volumes	删除已经在compose文件中定义的和匿名的附在容器上的数据卷
–remove-orphans	删除服务中没有在compose中定义的容器
# 示例
docker-compose down

• pausa : pausa um contêiner de serviço

docker-compose pause [SERVICE...]

• uppause : retoma um serviço que está em estado de pausa

docker-compose unpause [SERVICE...]

• config : verifique e visualize a configuração do arquivo de composição

docker-compose config [options]
# 选项包括：
–resolve-image-digests 	将镜像标签标记为摘要
-q, –quiet 		只验证配置，不输出。 当配置正确时，不输出任何内容，当文件配置错误，输出错误信息
–services 		打印服务名，一行一个
–volumes 		打印数据卷名，一行一个

• create : cria um contêiner para o serviço

docker-compose create [options] [SERVICE...]
# 选项包括：
–force-recreate		重新创建容器，即使配置和镜像没有改变，不兼容–no-recreate参数
–no-recreate		如果容器已经存在，不需要重新创建，不兼容–force-recreate参数
–no-build		不创建镜像，即使缺失
–build			创建容器前，生成镜像

Arquivo de modelo de composição do Docker

Introdução e modelos de amostra

O Compose permite que os usuários definam um grupo de contêineres de aplicativos associados como um projeto por meio de um arquivo de modelo docker-compose.yml (formato YAML). Um arquivo de modelo do Compose é um arquivo YAML que define serviços, redes e volumes. O caminho padrão do arquivo de modelo do Compose é docker-compose.yml no diretório atual e você pode usar .yml ou .yaml como extensão de arquivo.

O arquivo de modelo padrão do Docker-Compose deve conter três partes: versão, serviços e redes, e as partes mais críticas são serviços e redes.

modelo de amostra

version: '3'

networks:
  front-tier:
    driver: bridge
  back-tier:
    driver: bridge

services:
  web:
    image: dockercloud/hello-world
    ports:
      - 8080
    networks:
      - front-tier
      - back-tier

  redis:
    image: redis
    links:
      - web
    networks:
      - back-tier

  lb:
    image: dockercloud/haproxy
    ports:
      - 80:80
    links:
      - web
    networks:
      - front-tier
      - back-tier
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock 

Atualmente, o Compose tem três versões: Versão 1, Versão 2 e Versão 3. O Compose faz distinção entre a Versão 1 e a Versão 2 (Compose 1.6.0+, Docker Engine 1.10.0+). A versão 2 suporta mais comandos. A versão 1 será descontinuada no futuro.

iniciar aplicativo

Crie um diretório webapp, copie o arquivo docker-compose.yaml para o diretório webapp e use docker-compose para iniciar o aplicativo.

docker-compose up -d

Instruções de configuração do Docker-compose.yml

• versão : Especifique o formato de gravação do arquivo docker-compose.yml

• serviços : uma coleção de vários contêineres

• build : especificado como o caminho de contexto da imagem de build. Os caminhos relativos e absolutos são aceitáveis.

  Além da imagem especificada, o serviço também pode ser baseado em um Dockerfile e executar a tarefa de compilação ao usar up para iniciar. O rótulo de compilação é compilado e o caminho da pasta onde o Dockerfile está localizado pode ser especificado. O Compose usará o Dockerfile para criar automaticamente a imagem e, em seguida, usará a imagem para iniciar o contêiner de serviço.

  • context : caminho do contexto.
  • dockerfile : Especifique o nome do arquivo Dockerfile para criar a imagem. Ao usar o dockerfile para construir, você deve especificar o caminho de construção
  • args : adiciona argumentos de compilação, que são variáveis ​​de ambiente que só podem ser acessadas durante o processo de compilação. opcional
  • labels : Defina os rótulos da imagem construída.
  • target : construção multicamadas, você pode especificar qual camada construir.

build: ./dir
---------------
build:
    context: /path/to/build/dir
    dockerfile: Dockerfile
    args:
      buildno: 1
    labels:
      - "com.example.description=Accounting webapp"
      - "com.example.department=Finance"
      - "com.example.label-with-empty-value"
    target: prod
    
# build都是一个目录，如果要指定Dockerfile文件需要在build标签的子级标签中使用dockerfile标签指定。
# 如果同时指定image和build两个标签，那么Compose会构建镜像并且把镜像命名为image值指定的名字。

• container_name : Especifique um nome de contêiner personalizado em vez do padrão gerado (<nome do projeto><nome do serviço><número de série>).

container_name: my-web-container

• command : substitui o comando executado por padrão após o início do contêiner

  Ao executar um contêiner com a linha de comando, alguns contêineres precisam adicionar parâmetros de linha de comando adicionais ao comando, que precisa ser adicionado ao comando no serviço do arquivo de composição. Não há modo fixo para este parâmetro. Recomenda-se seguir as instruções da imagem do contêiner correspondente para determinar se e o que adicionar.

command: bundle exec thin -p 3000
----------------------------------
command: ["bundle","exec","thin","-p","3000"]

• cap_add, cap_drop : adiciona ou remove os recursos do kernel do host pertencentes ao contêiner.
• depende_on : define as dependências.
  • docker-compose up: inicia os serviços na ordem de dependência. No exemplo a seguir, db e redis são iniciados antes de web ser iniciado.
  • docker-compose SERVIÇO : inclui automaticamente as dependências do SERVIÇO. No exemplo a seguir, o docker-compose up web também criará e iniciará db e redis.
  • docker-compose stop : Interrompa os serviços na ordem de dependência. No exemplo a seguir, web para antes de db e redis.
  • Observação: o serviço da web não espera que o redis db seja totalmente iniciado antes de iniciar.

cap_add:
  - ALL # 开启全部权限

cap_drop:
  - SYS_PTRACE # 关闭 ptrace权限

version: "3.7"
services:
  web:
    build: .
    depends_on:
      - db
      - redis
  redis:
    image: redis
  db:
    image: postgres

• dns : configura o servidor dns, pode ser um valor ou uma lista

dns: 8.8.8.8
------------
dns:
    - 8.8.8.8
    - 9.9.9.9

• dns_search : Configure o domínio de pesquisa DNS, que pode ser um valor ou uma lista

dns_search: example.com
------------------------
dns_search:
    - dc1.example.com
    - dc2.example.com

• env_file : Obtenha variáveis ​​de ambiente do arquivo, você pode especificar um caminho de arquivo ou lista de caminhos, sua prioridade é menor que a variável de ambiente especificada pelo ambiente

env_file: .env
---------------
env_file:
    - ./common.env

• ambiente Adicione variáveis ​​de ambiente. Arrays ou dicionários podem ser usados, qualquer valor booleano, valores booleanos precisam ser colocados entre aspas para garantir que o analisador YML não os converta em Verdadeiro ou Falso

environment:
    RACK_ENV: development
    SHOW: 'ture'
-------------------------
environment:
    - RACK_ENV=development
    - SHOW=ture

• expor : Expor a porta, mas não mapeada para o host, acessada apenas por serviços conectados.

expose:
    - "3000"
    - "8000"

• portas : Definição de porta exposta ao mundo externo, correspondendo à exposição

  Nota: O atributo ports é um mapeamento entre a máquina física e o serviço na rede do cluster (não o ingress), quando um container acessa um endereço na rede ingress, ele não pode ser encaminhado de acordo com a porta.

  Se as portas forem usadas, o serviço gerará dois IPs virtuais, um é o IP virtual da rede de sobreposição para comunicação entre serviços e o outro é o IP virtual da rede de entrada usado para mapear as portas de serviço para as portas da máquina física. Nesse momento, o IP registrado pelo serviço para o centro de registro (como nacos) provavelmente será o IP virtual da rede de entrada, o que acabará levando à falha (tempo limite) do roteamento do gateway e chamadas falsas com base nos serviços do centro de registro.

  A solução é:

  1. Se você não precisar expor a porta à máquina física, use apenas a exposição para expor a porta à rede do cluster, que pode registrar o ip virtual correto no centro de registro

  2. Se a porta precisar ser exposta à máquina física, defina o segmento de rede virtual do contêiner no arquivo de configuração

     spring:
       application:
         name: @artifactId@
       cloud:
         inetutils:
           ignored-interfaces: eth.*
           preferred-networks: 192.168.0
     

     Para mais detalhes, consulte: https://my.oschina.net/woniuyi/blog/4984748

# 暴露端口信息。格式：- "宿主机端口:容器暴露端口"，或者只是指定容器的端口，宿主机会随机映射端口。
ports:
- "8763:8763"
- "8763:8763"

# 当使用HOST:CONTAINER格式来映射端口时，如果使用的容器端口小于60可能会得到错误得结果，因为YAML将会解析xx:yy这种数字格式为60进制。所以建议采用字符串格式。

• extra_hosts : adiciona mapeamentos de nome de host no contêiner. Semelhante ao cliente docker --add-host.

extra_hosts:
 - "somehost:162.242.195.82"
 - "otherhost:50.31.209.229"
 
 
# 以上会在此服务的内部容器中 /etc/hosts 创建一个具有 ip 地址和主机名的映射关系：
162.242.195.82  somehost
50.31.209.229   otherhost

• healthcheck : Usado para detectar se o serviço docker está funcionando corretamente.

healthcheck:
  test: ["CMD", "curl", "-f", "http://localhost"] # 设置检测程序
  interval: 1m30s # 设置检测间隔
  timeout: 10s # 设置检测超时时间
  retries: 3 # 设置重试次数
  start_period: 40s # 启动后，多少秒开始启动检测程序

• image : especifica o nome da imagem ou a ID da imagem usada pelo serviço. Se a imagem não existir localmente, o Compose tentará extrair a imagem.

# 以下格式都可以：
image: redis
image: ubuntu:14.04
image: tutum/influxdb
image: example-registry.com:4000/postgresql
image: a4bc65fd # 镜像id

• links : conecte o contêiner especificado à conexão atual e você pode definir um alias para evitar a falha de conexão causada pela alteração dinâmica da reinicialização do contêiner causada pelo método ip.

  Ao usar a linha de comando para implantar contêineres, geralmente é necessário acessar outro contêiner em um contêiner. Nesse momento, o parâmetro --link precisa ser usado. O formulário de uso geral é --link [引用的其他容器名]:[容器内代表引用容器的字段]. O contêiner A referenciado pelo formulário --link A:B aparecerá no arquivo /etc/hosts no contêiner no formato [A's ip:port]:'B'. Ou seja, outro contêiner A introduzido por --link atribui seu próprio endereço e porta ao campo B. Quando A precisa ser obtido no contêiner, o campo B pode ser usado diretamente.

  Nota: No arquivo de composição da versão v3, o atributo links será automaticamente ignorado pelo comando docker stack deploy, pois na v3 a função link foi removida. Uma alternativa é a propriedade das redes.

links:
    # 指定服务名称:别名 
    - docker-compose-eureka-server:compose-eureka
    # 仅指定服务名称（同时作为别名）
    - db

• logs : informações de saída de log

--no-color          单色输出，不显示其他颜.
-f, --follow        跟踪日志输出，就是可以实时查看日志
-t, --timestamps    显示时间戳
--tail              从日志的结尾显示，--tail=200

• logging : controle de saída de log

  No linux, os logs do contêiner geralmente são armazenados em /var/lib/docker/containers/CONTAINER_ID/, arquivos que terminam com json.log

logging:
  driver: "json-file"
  options:
    max-size: "5g"        # 日志文件的大小限制在5GB 

• network_mode : define o modo de rede

network_mode: "bridge"
network_mode: "host"
network_mode: "none"
network_mode: "service:[service name]"
network_mode: "container:[container name/id]"

• redes : configure a rede à qual o contêiner está conectado, consulte as entradas nas redes de nível superior.
  • Crie um parâmetro de rede paralelo ao parâmetro de serviços.No parâmetro de rede, uma ou mais redes podem ser configuradas para formar uma lista de redes da rede.
    • external: true : você pode usar este atributo para se referir à rede externa criada para alcançar o compartilhamento de rede cross-stack
  • O atributo redes pode ser adicionado em cada serviço, podendo este atributo incluir um ou mais nomes de rede na lista de redes previamente estabelecida, indicando que o serviço pode ser acessado em outros serviços utilizando os nomes destes serviços nestas redes. Às vezes, por vários motivos, o nome do serviço é inconsistente com os campos acessados ​​em outros contêineres. Nesse momento, você pode adicionar um nível após o nome da rede, aliases, e o alias pode desempenhar o mesmo papel do próprio nome do serviço e ser acessado por outros serviços da rede a que pertence.
    • aliases : Outros contêineres na mesma rede podem usar o nome do serviço ou este alias para se conectar ao serviço do contêiner correspondente.

networks:
  some-network:
    # 使用自定义驱动程序
    driver: custom-driver-1
  other-network:
    # 引用外部网络
    external: true
services:
  some-service:
    networks:
      some-network:
        aliases:
         - alias1
      other-network:
        aliases:
         - alias2

• reiniciar

  • no: é a estratégia de reinicialização padrão e o contêiner não será reiniciado em nenhuma circunstância.
  • always: O contêiner é sempre reiniciado.
  • on-failure: Quando o contêiner sai de forma anormal (o status de saída não é 0), o contêiner será reiniciado.
  • excepto interrompido: Sempre reinicie o contêiner quando o contêiner sair, mas não considera os contêineres que foram interrompidos quando o daemon do Docker é iniciado

  Observação: para o modo swarm cluster, use restart_policy.

restart: "no"
------------------------------
restart: always
------------------------------
restart: on-failure
------------------------------
restart: unless-stopped

• security_opt : modifique o rótulo do esquema padrão do contêiner.

security-opt：
  - label:user:USER   # 设置容器的用户标签
  - label:role:ROLE   # 设置容器的角色标签
  - label:type:TYPE   # 设置容器的安全策略标签
  - label:level:LEVEL  # 设置容器的安全等级标签

• tmpfs : Monte um sistema de arquivos temporário dentro do contêiner. Pode ser um único valor ou uma lista de vários valores.

tmpfs: /run
------------------------------
tmpfs:
  - /run
  - /tmp

• volumes : monte os volumes ou arquivos de dados do host no contêiner

  Você pode usar o formato [HOST:CONTAINER] diretamente ou usar o formato [HOST:CONTAINER:ro] Para o contêiner, o volume de dados é somente leitura, o que pode proteger efetivamente o sistema de arquivos do host. O caminho especificado do volume de dados do Compose pode ser um caminho relativo, use . ou ... para especificar um diretório relativo.

  volumes corresponde à opção -v na linha de comando e seu significado não foi alterado. No entanto, como o volume existe na forma de uma string no arquivo yml, escrever como $PWD não é aceitável e deve ser alterado para um caminho relativo ou um caminho absoluto.

# 数据卷的格式可以是下面多种形式
volumes:
  # 只是指定一个路径，Docker 会自动在创建一个数据卷（这个路径是容器内部的）。
  - /var/lib/mysql
  # 使用绝对路径挂载数据卷
  - /opt/data:/var/lib/mysql
  # 以 Compose 配置文件为中心的相对路径作为数据卷挂载到容器。
  - ./cache:/tmp/cache
  # 使用用户的相对路径（~/ 表示的目录是 /home/<用户目录>/ 或者 /root/）。
  - ~/configs:/etc/configs/:ro
  # 已经存在的命名的数据卷。
  - datavolume:/var/lib/mysql
  
# 如果不使用宿主机的路径，可以指定一个volume_driver。

• volumes_from : Monte seus volumes de dados de outro serviço ou contêiner

volumes_from:
   - service_name    
     - container_name

• ulimits : substitui os ulimits padrão do contêiner.

ulimits:
  nproc: 65535
  nofile:
    soft: 20000
    hard: 40000