8. Orquestração de contêineres Docker-compose

1. O que é a composição do Docker?

Compose é um software ferramenta lançado pela Docker Company, que pode gerenciar vários contêineres Docker para formar um aplicativo. Você precisa definir um arquivo de configuração docker-compose.yml no formato YAML e escrever os relacionamentos de chamada entre vários contêineres. Então, com apenas um comando, você pode iniciar/parar esses contêineres simultaneamente.

Docker Compose é o projeto oficial de código aberto do Docker, responsável por realizar a rápida orquestração de clusters de contêineres Docker.

2. O que o Docker compose pode fazer?
O Docker recomenda que executemos apenas um serviço em cada contêiner. Como o contêiner do Docker em si ocupa muito poucos recursos, é melhor separar cada serviço separadamente. Mas então enfrentamos outro problema?

Se eu precisar implantar vários serviços ao mesmo tempo, terei que escrever um Dockerfile separado para cada serviço e, em seguida, construir a imagem e o contêiner?Isso é exaustivo, então o docker nos fornece oficialmente a ferramenta de implantação de vários serviços docker-compose .

Por exemplo, para implementar um projeto de microsserviço da Web, além do próprio contêiner de serviço da Web, muitas vezes é necessário adicionar o contêiner de serviço mysql do banco de dados de back-end, o servidor redis, o centro de registro eureka e até mesmo contêineres de balanceamento de carga, etc.

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).

Você pode definir facilmente um aplicativo de vários contêineres com um arquivo de configuração e, em seguida, usar um único comando para instalar todas as dependências do aplicativo e concluir a construção. Docker-Compose resolve o problema de como gerenciar e orquestrar contêineres.

3. Instale o Compose

1. Docker Compose 环境安装
Docker Compose 是 Docker 的独立产品，因此需要安装 Docker 之后在单独安装 Docker Compose
#下载
curl -L https://github.com/docker/compose/releases/download/1.21.1/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
#安装
chmod +x /usr/local/bin/docker-compose
#查看版本
docker-compose --version

Componha os conceitos principais

4. Componha o conceito central
Um arquivo
docker-compose.yml

Dois elementos
: serviço: cada instância de contêiner de aplicativo, como microsserviço de pedido, microsserviço de inventário, contêiner mysql, contêiner nginx ou contêiner redis

Projeto: Uma unidade de negócios completa que consiste em um conjunto de contêineres de aplicativos associados, definidos no arquivo docker-compose.yml.

5. Três etapas para usar o Compose:
escreva o Dockerfile, defina cada aplicativo de microsserviço e crie o arquivo de imagem correspondente.
Use docker-compose.yml para definir uma unidade de negócios completa e organizar cada serviço de contêiner no aplicativo geral.
Por fim, execute o docker compose comando up. para iniciar e executar todo o aplicativo e concluir a implantação com um clique e ficar on-line

6. Componha comandos comuns

docker compose -h         # 查看帮助

docker compose up         # 启动所有docker-compose服务


docker compose up -d      # 启动所有docker-compose服务并后台运行


docker compose down       # 停止并删除容器、网络、卷、镜像。

docker compose exec  yml里面的服务id      # 进入容器实例内部  docker-compose exec docker-compose.yml文件中写的服务id /bin/bash

docker compose ps   # 展示当前docker-compose编排过的运行的所有容器

docker compose top    # 展示当前docker-compose编排过的容器进程

docker compose logs  yml里面的服务id      # 查看容器输出日志

docker compose config        # 检查配置

docker compose config -q    # 检查配置，有问题才有输出


docker compose restart      # 重启服务


docker compose start        # 启动服务

docker compose stop         # 停止服务

Escreva docker-compose.yml para implementar etapas de publicação de microsserviços

1. Crie a pasta /app no ​​diretório raiz
2. Crie um novo arquivo docker-compose.yml e três pastas nacos, user e order no diretório app
3. Crie o serviço nacos nas três pastas nacos, user e imagem, imagem de serviço do usuário, imagem de serviço de pedido, tome a construção da imagem do serviço nacos como exemplo, crie um novo arquivo dockerfile na pasta nacos e carregue o pacote jar executável do serviço naco para este diretório (Nota: Por padrão, Compose usa o nome do serviço porque o nome do host é acessado por outros contêineres), o conteúdo do arquivo dockerfile é o seguinte

# 基于哪个镜像
From java:8
# 将本地文件夹挂载到当前容器
VOLUME /tmp
# 复制文件到容器
ADD nacos-server-0.0.1-SNAPSHOT.jar /app.jar
# 声明需要暴露的端口
EXPOSE 8761
# 配置容器启动后执行的命令
ENTRYPOINT ["java","-jar","/app.jar"]

Copiar após login

version: '2'              #docker的文件格式版本
services:
  eureka:                 #docker服务名
    image: nacos    #docker镜像
    ports:
      - "8848:8848"
  user: 
    image: user
    ports:  
      - "8000:8000" 
  order:    
    image: order
    ports: 
      - "8010:8010"

Inicie todos os microsserviços

Adicione -d após o comando para iniciá-lo em segundo plano:
　　docker-compose up

Exemplo

1. Empacote um projeto springboot como uma imagem
1. Prepare um projeto springboot
e escreva um controlador de teste para teste.

@RestController
@RequestMapping
public class TestController {
    
    

    @GetMapping("/test")
    public String test(){
    
    
        return "启动成功 ===================test";
    }
}

2. Construa manualmente o pacote jar.
Usamos o comando maven package para empacotá-lo manualmente e carregá-lo no servidor.

[root@localhost ~]# cd mydocker/
[root@localhost mydocker]# ll
total 17084
-rw-r--r--. 1 root root 17491177 Apr  9 14:18 demo-0.0.1-SNAPSHOT.jar

3. Escreva Dockerfile

# 基础镜像使用java
FROM centosjava8:1.0
# 作者
MAINTAINER cxf
# VOLUME 指定临时文件目录为/tmp，在主机/var/lib/docker目录下创建了一个临时文件并链接到容器的/tmp
VOLUME /tmp
# 将jar包添加到容器中并更名为cxf_docker.jar
ADD demo-0.0.1-SNAPSHOT.jar /cxf_docker.jar
# 运行jar包
RUN bash -c 'touch /cxf_docker.jar'
ENTRYPOINT ["java","-jar","/cxf_docker.jar"]
#暴露6001端口作为微服务
EXPOSE 8088

4. Construa a imagem

docker build -t mydemo:1.0 .

[root@localhost mydocker]# docker images
REPOSITORY                    TAG       IMAGE ID       CREATED          SIZE
mydemo                        1.0       7124eca083ad   26 seconds ago   764MB
centosjava8                   1.0       4dbff0755585   7 hours ago      747MB

5. Execute o contêiner
docker run -d -p 8088:8088 7124eca083ad

2. Escrever o arquivo docker-compose.yml
requer uma pasta separada! É equivalente a cada parâmetro do comando docker run correspondente e é muito simples de entender!

# 版本
version: "3"
# 写死，所有的服务
services:
  # 服务名，这是我们的springboot项目，需要使用redis+mysql
  microService:
    # 镜像名
    image: cxf_docker:1.0
    # 如果不加的话，会目录前缀+服务名+1
    container_name: ms01
    ports:
      - "6001:6001"
    # 容器数据卷映射
    volumes:
      - /app/microService:/data
    # 网络，会默认加上目录前缀
    networks: 
      - my_network
    # 依赖于mysql与redis
    depends_on: 
      - redis
      - mysql
  # 服务名，可以用该名字访问网络
  redis:
    image: redis:6.0.8
    ports:
      - "6379:6379"
    volumes:
      - /app/redis/redis.conf:/etc/redis/redis.conf
      - /app/redis/data:/data
    networks: 
      - my_network
    command: redis-server /etc/redis/redis.conf
  mysql:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: '123456'
      MYSQL_ALLOW_EMPTY_PASSWORD: 'no'
      MYSQL_DATABASE: 'db2021'
      MYSQL_USER: 'zzyy'
      MYSQL_PASSWORD: 'zzyy123'
    ports:
       - "3306:3306"
    volumes:
       - /app/mysql/db:/var/lib/mysql
       - /app/mysql/conf/my.cnf:/etc/my.cnf
       - /app/mysql/init:/docker-entrypoint-initdb.d
    networks:
      - my_network
    command: --default-authentication-plugin=mysql_native_password #解决外部无法访问
# 网络，会默认加上目录前缀
networks: 
   my_network: 

3. Inicie docker-compose
e execute-o no diretório onde docker-compose.yml está localizado.

# 检查配置，有问题才有输出
docker-compose config -q
# 执行 
docker-compose up
# 或者后台执行 
docker-compose up -d

Se a imagem não existir localmente, ela será automaticamente extraída e executada! Muito conveniente!

4. Pare

# 停止服务
docker-compose stop