• docker-compose概述与简单编排部署

    引言

    现有 docker 进行项目部署存在的问题：

    1、为了完成一个完整项目势必用到N多个容器（一个容器只运行一个进程）配合完成项目中业务开发，一旦引入N多个容器，容器之间就会形成某种依赖，也就意味某个容器或某些容器的运行需要其他容器优先启动之后才能正常运行。容器的编排显得至关重要，容器的运行一定要有先后顺序。

    2、现在这种方式使用容器，没有办法站在项目的角度将一个项目用到的一组容器划分到一起，日后难点在于项目的多服务器部署。比如项目在当前服务器上运行成功，需要将项目再部署到另一台服务器上，但我们不清楚哪组容器是项目引用的，哪组容器是别的引用的。

    一、compose概述

    Compose 项目是 Docker 官方的开源项目，负责实现对 Docker 容器集群的快速编排。从功能上看，跟 OpenStack 中的 Heat 十分类似。

    Compose项目来源于之前的fig项目，使用python语言编写,与docker/swarm配合度很高。

    docker-compose是基于docker的编排工具，使容器的操作能够批量的，可视的执行，是一个管理多个容器的工具，比如可以解决容器之间的依赖关系，当在宿主机启动较多的容器时候，
    如果都是手动操作会觉得比较麻烦而且容器出错，这个时候推荐使用 dockerd的单机编排工具 docker-compose。

    • compose是一个用于定义及允许多个Docker容器的工具，主要是通过一个YAML文件进行服务配置

    • 使用Docker Compose不再需要使用Shell脚本来启动容器

    • Docker Compose非常适合组合使用多个容器进行开发的场景

    Compose有2个重要的概念：

    • 项目（Project）：由一组关联的应用容器组成的一个完整业务单元，在 docker-compose.yml 文件中定义。
    • 服务（Service）：一个应用的容器，实际上可以包括若干运行相同镜像的容器实例。

    使用Compose 基本上分为三步：

    1. Dockerfile      定义应用的运行环境
    2. docker-compose.yml 定义组成应用的各服务
    3. docker-compose up 启动整个应用

    1.1  YAML简介

    AML（语言）的设计目标，就是方便人类读写，它实质上是一种通用的数据串行化格式

    它的基本语法规则如下：

    • 大小写敏感
    • 使用缩进表示层级关系
    • 缩进时不允许使用Tab键，只允许使用空格
    • 缩进的空格数目不重要，只要相同层级的元素左侧对齐即可

    #表示注释

    1.2  YAML支持的数据结构

    • 对象，键值对的集合
    • 数组，一组按次序排列的值，又称序列
    • 纯量，单个的，不可再分的值

    1.3  docker-compose.yml文件的常用字段

    具体使用会在下面的docker-compose部署中展示：

                    字段                                                     描述
    build  docker   filecontext指定Dockerfile文件名构建镜像上下文路径
    image指定镜像
    command执行命令，覆盖默认命令
    container name指定容器名称，由于容器名称是唯一的，如果指定自定义名称，则无法scale
    deploy指定部署和运行服务相关配置，只能在Swarm模式使用
    environment添加环境变量
    networks加入网络
    ports暴露容器端口，与-p相同，但端口不能低于60
    volumes挂载宿主机路径或命令卷
    restart重启策略，默认no，always，no-failure，unless-stoped
    hostname容器主机名

    1.4  Docker Compose常用命令

    1. docker-compose -h                           # 查看帮助
    2. docker-compose up                           # 创建并运行所有容器
    3. docker-compose up -d                        # 创建并后台运行所有容器
    4. docker-compose ps                           # 显示所用容器信息
    5. docker-compose -f docker-compose.yml up -d  # 指定模板
    6. docker-compose down                         # 停止并删除容器、网络、卷、镜像。
    7. docker-compose rm                           # 删除容器
    8. docker-compose logs                         # 查看容器输出日志
    9. docker-compose pull                         # 拉取依赖镜像
    10. dokcer-compose config                       # 检查配置
    11. dokcer-compose config -q                    # 验证yaml配置文件是否正确，有问题才有输出
    12. docker-compose pause                        # 暂停容器
    13. docker-compose unpause                      # 恢复暂停
    14. docker-compose restart                      # 重启服务
    15. docker-compose start                        # 启动服务
    16. docker-compose stop                         # 停止服务
               字段                                                    描述
    build重新构建服务
    ps列出容器
    up创建和启动
    exec在容器里执行命令
    scale指定一个一定服务容器启动数量
    top显示容器进程
    logs查看容器输出
    down删除容器、网络、数据卷和镜像
    stop/start/restart停止/启动/重启服务

    1. docker-compose [options] [COMMAND] [ARG...]
    2.  
    3. //docker-compose选项：
    4.   --verbose输出更多调试信息
    5.   --version打印版本并退出
    6.   -f, -file FILE使用特定的compose模板文件，默认为docker-compose.yml
    7.   -p, --project-name NAME指定项目名称，默认使用目录名称
    8. //举例：
    9. docker-compose -f docker-compose.yml up -d

    1.4.1  命令使用说明

    up

    • 该命令十分强大，它将尝试自动完成包括构建镜像，（重新）创建服务，启动服务，并关联服务相关容器的一系列操作。
    • 链接的服务都将会被自动启动，除非已经处于运行状态。
    • 可以说，大部分时候都可以直接通过该命令来启动一个项目。
    • 默认情况，docker-compose up 启动的容器都在前台，控制台将会同时打印所有容器的输出信息，可以很方便进行调试。
    • 当通过 Ctrl-C 停止命令时，所有容器将会停止。
    • 如果使用 docker-compose up -d，将会在后台启动并运行所有的容器。一般推荐生产环境下使用该选项。
    • 如果服务容器已经存在，docker-compose up 将会尝试停止容器，然后重新创建（保持使用 volumes-from 挂载的卷），以保证新启动的服务匹配 docker-compose.yml 文件的最新内容。
    • 当使用 docker-compose up 服务id，就是对当前项目中的容器服务进行操作

    命令格式为 ：

    docker-compose up [options] [SERVICE...]

    选项说明：

    • -d 在后台运行服务容器。
    • --no-color 不使用颜色来区分不同的服务的控制台输出。
    • --no-deps 不启动服务所链接的容器。
    • --force-recreate 强制重新创建容器，不能与 --no-recreate 同时使用。
    • --no-recreate 如果容器已经存在了，则不重新创建，不能与 --force-recreate 同时使用。
    • --no-build 不自动构建缺失的服务镜像。
    • -t, --timeout TIMEOUT 停止容器时候的超时（默认为 10 秒）。

    down

    docker-compose down：

    此命令将会停止 up 命令所启动的容器，并移除网络，但不会移除数据卷。

    docker-compose down 服务id：

    停止某个服务。

    exec

    进入指定的容器。

    docker-compose exec 服务id /bin/bash

    ps

    列出项目中目前的所有容器。

    docker-compose ps [options] [SERVICE...]

    选项说明：

    • -q 只打印容器的 ID 信息。

    restart

    重新启动所有已停止并正在运行的服务。

    docker-compose restart [options] [SERVICE...]

    选项：

    • -t, --timeout TIMEOUT 指定重启前停止容器的超时（默认为 10 秒）。

    rm

    删除所有（停止状态的）服务容器。推荐先执行 docker-compose stop 命令来停止容器。

    docker-compose rm [options] [SERVICE...]

    选项：

    • -f, --force 强制直接删除，包括非停止状态的容器。一般尽量不要使用该选项。
    • -v    删除容器所挂载的数据卷。

    top

    查看项目中各个服务容器内运行的进程。

    如果加上服务id，就是查看项目中指定服务容器的进程

    logs

    查看服务容器的输出。默认情况下，docker-compose 将对不同的服务输出使用不同的颜色来区分。可以通过 --no-color 来关闭颜色。

    查看项目中指定服务的日志：

    docker-compose logs 服务id

    注：上面的 服务id 代表 docker-compose.yml 文件中的服务名

    unpause 和 pause

    pause：暂停一个服务容器。

    docker-compose pause [SERVICE...]

    unpause ：恢复处于暂停状态中的服务。

    docker-compose unpause [SERVICE...]

    扩展一：Compose 模板文件指令

    模板文件是使用 Docker Compose 的核心，涉及到的指令关键字也比较多。默认的模板文件名称为 docker-compose.yml ，格式为YAML 格式。一个 docker-compose.yml 文件可以分为三层：

    1. #第一层 版本号
    2. version: "3"  #代表使用docker-compose项目的版本号
    3. #第二层：services 服务配置
    4. services:
    5.   web:
    6.     build: .
    7.     ports:  #宿主机和容器的端口映射
    8.       - "5000:5000"
    9.     volumes:
    10.       - .:/code
    11.   redis:
    12.      image: "redis:alpine"
    13. # 第三层 其他配置 网络、卷、全局规划

    build 指令

    指定 Dockerfile 所在文件夹的路径（可以是绝对路径，或者相对 docker-compose.yml 文件的路径）。 Compose 将会利用它自动构建这个镜像，然后使用这个镜像。

    1. version: "3.8" 
    2. services:
    3.   web:
    4.     build: .  #指定Dockerfile的上下文目录为当前目录

    你也可以使用 context 指令指定 Dockerfile 所在文件夹的路径。

    使用 dockerfile 指令指定 Dockerfile 文件名。

    使用 arg 指令指定构建镜像时的变量。

    1. version: '3'
    2. services:
    3.  
    4.   webapp:
    5.     build:
    6.       context: ./dir #定Dockerfile的上下文目录为当前目录的dir目录下
    7.       dockerfile: Dockerfile-alternate
    8.       args: 
    9.         buildno: 1

    command 指令

    覆盖容器启动后默认执行的命令，类似于docker run image 命令

    以下面的Dockerfile文件为例，容器启动后执行的是 java -jar apps.jar

    1. FROM openjdk:8-jre
    2. EXPOSE 8081
    3. ENV APP_PATH=/apps
    4. WORKDIR $APP_PATH
    5. COPY apps.jar $APP_PATH
    6. ENTRYPOINT ["java","-jar"]
    7. CMD ["apps.jar"]

    如果我们想要容器启动后执行的是 java -jar test.jar，在docker-compose.yml文件中使用指令 command: [“test.jar”]

    1. version: '3'
    2. services:
    3.   webapp:
    4.     build:
    5.       context: ./dir #定Dockerfile的上下文目录为当前目录的dir目录下
    6.       dockerfile: Dockerfile-alternate
    7.       args: 
    8.         buildno: 1
    9.     command: ["test.jar"]

    container   name 指令（不推荐使用）

    指定容器名称。默认将会使用 项目名称_服务名称_序号 这样的格式。

    注意: 指定容器名称后，该服务将无法进行扩展（scale），因为 Docker 不允许多个容器具有相同的名称。

    depends_on 指令

    解决容器的依赖、启动先后的问题。以下例子中会先启动 redis 、db 再启动 web：

    1. version: '3'
    2. services:
    3.   web:
    4.     build: .
    5.     depends_on: # web服务依赖于db和web服务
    6.       - db
    7.       - redis
    8.   redis:
    9.     image: redis
    10.   db:
    11.     image: postgres

    注意：在启动web服务时，并不会等待 redis 、db 服务进入ready状态，而只是等到它们被启动状态(running状态)了。

    environment 指令

    设置环境变量，相当于 docker run -e。你可以使用数组或字典两种格式。

    只给定名称的变量会自动获取运行 Compose 主机上对应变量的值，可以用来防止泄露不必要的数据。

    1. version: '3'
    2. services:
    3.   mysql:
    4.     image: mysql:5.7
    5.     ports:
    6.       - "3306:3306"
    7.     environment:
    8.       MYSQL_ROOT_PASSWORD: root  #字典格式 
    9. #====================================================
    10.     environment:
    11.       - "MYSQL_ROOT_PASSWORD=root"  #数组格式
    12.       - "SESSION_SECRET"

    image 指令

    指定为镜像名称或镜像 ID。如果镜像在本地不存在，Compose 将会尝试拉取这个镜像，相当于 docker run image（镜像名）。

    networks 指令

    指定启动容器时使用的网络，相当于 docker run --network

    1. version: "3"
    2. services:
    3.   some-service:
    4.     networks:
    5.      - some-network  #指定使用的网络
    6.      - other-network
    7. networks:   #创建网络
    8.   some-network:
    9.   other-network:

    ports 指令

    指定宿主机和容器端口映射，或者仅仅指定容器的端口（宿主将会随机选择端口）都可以。

    注意：当使用 HOST:CONTAINER 格式来映射端口时，如果你使用的容器端口小于 60 并且没放到引号里，可能会得到错误结果，因为YAML会自动解析 xx:yy 这种数字格式为 60 进制。为避免出现这种问题，建议数字串都采用引号包括起来的字符串格式。

    volumes 指令

    用来指定宿主机目录和容器目录映射或挂载宿主机路径或命令卷

    1. version: "3"
    2.  
    3. services:
    4.   my_src:
    5.     image: mysql:8.0
    6.     volumes:  #数据卷名称挂载
    7.       - mysql_data:/var/lib/mysql
    8.          宿主机目录：容器目录
    9. volumes:  #定义数据卷名称
    10.   mysql_data:

    restart 指令

    指定容器退出后的重启策略为始终重启。该命令对保持服务始终运行十分有效。

    restart: always

    二、安装Docker Compose工具

    2.1    安装docker环境

    docker 部署在这里不做介绍，有需要的可以看我博客：

    2.2、下载docker-compose安装包

    从github上下载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

    2.3、部署docker-compose

    1. //可以在任何目录下使用compose命令
    2. cp -p docker-compose /usr/local/bin
    3. chmod +x docker-compose
    4. [root@localhost /]# docker-compose -v
    5. docker-compose version 1.21.1, build 5a3f1a3

    ​

    首先创建一个总目录，再根据下图配置相关内容。

    1. mkdir /root/compose_nginx
    2. cd /root/compose_nginx
    3.  
    4. yum install -t tree
    5. [root@server1 compose_nginx]# tree
    6. .
    7. ├── docker-compose.yml
    8. ├── nginx
    9. │   ├── Dockerfile
    10. │   ├── nginx-1.12.2.tar.gz
    11. │   └── run.sh
    12. └── wwwroot
    13.     └── index.html

    • 添加docker-compose.yml
    1. [root@server1 compose_nginx]# vi docker-compose.yml 
    2. version: '3'
    3. services:
    4.   nginx:
    5.     hostname: nginx
    6.     build:
    7.       context: ./nginx
    8.       dockerfile: Dockerfile
    9.     ports:
    10.       - 1233:80
    11.       - 1255:443
    12.     networks:
    13.       - abc
    14.     volumes:
    15.       - ./wwwroot:/usr/local/nginx/html
    16. networks:
    17.   abc:

    • 添加Nginx目录中的配置文件
    1. [root@server1 compose_nginx]# cd nginx/
    2. [root@server1 nginx]# cat Dockerfile 
    3. FROM centos:7
    4. MAINTAINER this is nginx
    5. RUN yum -y update
    6. RUN yum install -y gcc gcc-c++ make pcre-devel zlib-devel
    7. RUN useradd -M -s /sbin/nologin nginx
    8. ADD nginx-1.12.2.tar.gz /opt/
    9. WORKDIR /opt/nginx-1.12.2/
    10. RUN ./configure --prefix=/usr/local/nginx --user=nginx --group=nginx --with-http_stub_status_module && make && make install
    11. ENV PATH /usr/local/nginx/sbin:$PATH
    12. EXPOSE 443
    13. EXPOSE 80
    14. RUN echo "daemon off;" >> /usr/local/nginx/conf/nginx.conf
    15. ADD run.sh /run.sh
    16. RUN chmod 775 /run.sh
    17. CMD ["/run.sh"]
    1. [root@server1 nginx]# cat run.sh 
    2. #!/bin/bash
    3. /usr/local/nginx/sbin/nginx
    • 添加网页
    [root@server1 compose_nginx]# cat wwwroot/index.html

    2.4   验证

     使用compose编排 安装运行nginx容器

    docker-compose -f docker-compose.yml up -d

    查看镜像和容器显示创建成功，我们可以访问服务。

    三、使用compose编排 安装运行tomcat容器

    软件包：apache-tomcat-9.0.16.tar.gz、jdk-8u91-linux-x64.tar.gz
    提取码：a9p6

    1. cd /opt
    2. mkdir compose-tomcat
    3. cd compose-tomcat
    4. mkdir tomcat
    5. cd tomcat
    6. ==拖入安装包apache-tomcat-9.0.16.tar.gz 、jdk-8u91-linux-x64.tar.gz==
    7.  
    8. vim Dockerfile
    9. FROM centos:7
    10. MAINTAINER LIC:<935704787@qq.com>
    11.  
    12. ADD apache-tomcat-9.0.16.tar.gz /usr/local
    13. ADD jdk-8u91-linux-x64.tar.gz /usr/local
    14.  
    15. WORKDIR /usr/local
    16.  
    17. RUN mv apache-tomcat-9.0.16 tomcat
    18. RUN mv jdk1.8.0_91 java
    19.  
    20. ENV JAVA_HOME /usr/local/java
    21. ENV CLASSPATH $JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar
    22. ENV PATH $JAVA_HOME/bin:$PATH
    23.  
    24. EXPOSE 8080
    25. CMD ["/usr/local/tomcat/bin/catalina.sh","run"]
    26.  
    27. ====>:wq
    28.  
    29. cd ..
    30. vim tomcat-compose.yml
    31.  
    32. version: '3'
    33. services:
    34.  tomcat:
    35.   hostname: tomcat
    36.   build :
    37.    context: ./tomcat
    38.    dockerfile: Dockerfile
    39.   ports:
    40.    - 7788:8080
    41.   networks:
    42.    - cluster
    43. networks:
    44.  cluster:
    45.  
    46. ====>:wq
    47.  
    48. docker-compose -f tomcat-compose.yml up -d
    49.  
    50. ==真机访问http://IP:7788==

     四、总结

    docker-compose默认的模板文件是 docker-compose.yml，其中定义的每个服务都必须通过 image 指令指定镜像或 build 指令（需要 Dockerfile）来自动构建。

    其它大部分指令都跟 docker run 中的类似。

    如果使用 build 指令，在 Dockerfile 中设置的选项(例如：CMD, EXPOSE, VOLUME, ENV 等) 将会自动被获取，无需在 docker-compose.yml 中再次设置。 

    使用Compose 基本上分为三步：

    1. Dockerfile 定义应用的运行环境
    2. docker-compose.yml 定义组成应用的各服务
    3. docker-compose up 启动整个应用


     

  • 相关阅读:
    运算符【Java基础】
    Python-pip镜像源配置及国内常用镜像源
    【论文阅读笔记】Detecting AI Trojans Using Meta Neural Analysis
    委派设计模式
    1.索引的本质
    为什么我建议在复杂但是性能关键的表上所有查询都加上 force index
    【C++高阶】3.1 string容器
    【Ubuntu20.04+gcc-9.4.0】Openface在linux下的详细环境配置（2024.4月）
    2024的开放式耳机排行榜，看这六个耳机选购的小Tips
    多测师肖sir_高级金牌讲师___python之json模块
  • 原文地址：https://blog.csdn.net/WuDan_1112/article/details/125878728