Docker使用

目录

• 介绍
  • 与虚拟机的区别
  • 一次构建、到处运行，DevOps
  • Docker架构
• Docker安装与卸载
• Docker常用命令
• Docker镜像
• Docker容器数据卷
  • 添加数据卷：
  • 通过Dockerfile构建镜像
  • 使用数据卷容器
• Dockerfile使用
  • Dockerfile构建过程
  • Dockerfile命令
  • Dockerfile打包微服务
• Docker常用镜像
  • 本地镜像发布到阿里云
  • 使用本地私服仓库
• Docker 网络
  • bridge模式
  • host模式
  • none模式
  • container模式
  • 自定义网络
  • 网络连通
• Docker compose 容器编排
• 可视化
  • 容器监控（CIG）

官网：https://www.docker.com/
官网镜像：https://github.com/docker-library/docs ，https://github.com/docker-library/official-images

介绍

• 为什么会有docker：开发与运维之间的矛盾，不仅打包代码，环境也一并打包
  • 给出了标准的解决方案：系统平滑移植，容器虚拟化技术
  • 解决了运行环境和配置问题的软件容器，方便做持续集成，并有助于整体发布的虚拟化技术
• 为什么用docker：基于容器的虚拟化，仅包含业务运行所需要的runtime环境
  • 更高效：无操作系统虚拟化开销
    • 计算：轻量，无额外开销
    • 存储：系统盘aufs/dm/overlayfs；数据盘volume
    • 网络：宿主机网络，NS隔离
  • 更敏捷、更灵活
• 分层的存储和包管理、devops理念
  • 支持多种网络配置
• docker理念：一次封装，到处运行，解决运行环境和配置问题的软件容器，方便做持续集成并有助于整体发布的虚拟化技术，基于Go语言，C/S架构
  • 主要目标是“Build,Ship and Run Any App, Anywhere”，也就是通过对应用组件的封装、分发、部署、运行等生命周期的管理，使用户的app以及运行环境能过做到一次镜像，处处运行。
  • Linux容器技术的出现就解决了这样一个问题，而Docker就是在它的基础上发展过来的，将应用打成镜像，通过镜像称为运行在Docker容器上面的实例，而Docker容器在任何操作系统上都是一致的，这就实现了跨平台、跨服务器，只需要一次配置好环境，在别的服务器上可以一键部署，大大简化了操作。
• 基本组成：镜像、容器、仓库

与虚拟机的区别

虚拟机：在一个操作系统上运行另一种操作系统，包含了应用程序、操作系统、硬件，三者的逻辑不变，先虚拟出硬件（Hypervisor），再在上面运行操作系统，再在操作系统上运行所需要的进程。占用资源多、冗余多、启动慢

Linux虚拟化技术（Linux Containers, LXC）：Linux容器，是与系统其它部分隔离开的系列进程，从另一个镜像运行，并由镜像提供支持的进程所需要的全部文件。容器提供的镜像包含了应用的所有依赖项，因而在从开发到测试再到生产的整个过程中，它都具有可移植性和一致性。

Linux容器不是模拟一个操作系统，而是对进程进行隔离，有了容器，就可以将软件运行所需要的资源打包到一个隔离的容器中，与虚拟机不同，它不需要捆绑一整套操作系统，只需要软件运行的库资源和设置，系统因此变得高效轻量并保证在任何环境中的软件都能始终如一的运行。

Docker容器在操作系统层面上实现虚拟化，直接复用本地主机的操作系统，而传统的虚拟机则是在硬件层面实现虚拟化，与传统的虚拟机相比，Docker优势体现在速度快、占用体积小。

容器内的进程直接运行与宿主的内核，容器内没有自己的内核，而且也没有硬件虚拟

每个容器相互隔离，每个容器有自己的文件系统，容器之间的进程不会相互影响，能区分计算资源

比较：

• 传统虚拟机技术是虚拟出一套硬件后，在其上运行一个完整的操作系统，在该系统上再运行所需要的应用进程。
• 容器内的应用进程直接运行与宿主机的内核，容器内没有自己的内核且也没有进行硬件虚拟，因此容器要比传统虚拟机更快
• 每个容器之间相互隔离，每个容器有自己的文件系统，容器之间进程不会相互影响，能区分计算资源

一次构建、到处运行，DevOps

更快速的应用交付：传统应用开发后，需要提供一堆安装程序和配置说明文档，安装部署后需要根据配置文档进行繁杂的配置才能正确运行。Docker容器化之后只需要交付少量的容器镜像文件，在正式生产环境加载镜像并运行即可，应用安装配置在镜像里已经内置好，大大节省了部署配置和测试验证的时间。

更便捷的升级和扩缩容：随着微服务架构和Docker的发展，大量的应用会使用微服务方式架构，应用的开发构建将变成搭乐高积木一样，每个Docker容器将变成一块积木，应用的升级将变得非常容易，当现有的容器不足以支撑业务时，可通过镜像运行新的容器进行快速扩缩容。

更简单的系统运维：应用容器化运行后，生产环境运行的应用可与开发、测试环境的应用高度一致，容器会将应用程序相关的环境和状态完全封闭起来，不会因为底层基础架构和操作系统的不一致性给应用带来影响，产生新的bug，当程序出现异常时，也可以通过测试环境的相同容器进行快速定位和修复。

更高效的计算资源利用：Docker是内核级虚拟化，不像传统虚拟化技术一样需要额外的Hypervisor支持，所以在一台物理机上可以运行很多个容器实例，大大提升了物理服务器的cpu和内存的利用率

Docker架构

Docker 是一个用于开发、发布和运行应用程序的开放平台，将应用和基础设施分离开，以进行快速的软件交付，可以像管理基础设施一样管理应用，利用Docker发布、测试和部署代码的方法，可以极大的减少写代码和让代码在生产中跑起来的延迟。

Docker使用client-server架构，Docker client与Docker Daemon交互，它负责构建、运行和分发 Docker 容器的繁重工作。Docker客户端和Daemon可以运行在同一个系统上，或者可以通过客户端连接远程Daemon。客户端通过Rest API在unix socker或网络接口上通信。另一个Docker客户端是Docker Compose, 让你与一组容器组成的应用一起工作。

The Docker daemon（Dockerd）：监听Docker API的请求，管理Docker对象，如镜像、容器、网络、volume，它可以与其他Daemon通信来管理Docker服务。

The Docker client：与Docker交互的主要方式，可以与多个Daemon交互

Docker Desktop：包含了Docker daemon、Docker client、Docker compose、Docker Content Trust, Kubernetes, and Credential Helper.

Docker registries：存储Docker镜像，

Docker objects：

• 镜像
• 容器：一个容器是一个镜像的运行实例，可以启动、停止、重启、删除一个容器，与其他容器隔离

底层技术：Docker使用go语言编写，利用了linux内核的一些功能，使用namespaces提供容器隔离，当运行一个容器时，Docker会为这个容器创建一组namespaces

Docker安装与卸载

Docker并非是一个通用的容器工具，它依赖于已存在并运行的Linux内核环境。Docker本质上是在已经运行的Linux下创建了一个隔离的文件环境，因此它的效率几乎等同于所部署的Linux主机。因此Docker必须部署在Linux内核的系统上，如果其他系统想要部署Docker就必须安装一个虚拟Linux环境

Linux内核在3.8以上，64位

https://www.cnblogs.com/bingmous/p/15643682.html

Docker常用命令

命令汇总：https://www.cnblogs.com/bingmous/p/17811353.html

Docker镜像

镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和开发的软件，它包含运行某个软件所需要的所有内容，包括代码、运行时、库、环境变量和配置文件，docker镜像实际上是由一层一层的文件系统组成（UnionFS）

UnionFS（联合文件系统）：是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时将不同目录挂载到同一个虚拟文件系统下，unionfs是docker镜像的基础，镜像可以通过分层来进行继承，基于基础镜像，可以制作各种具体的应用镜像。特性：一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，最终的文件系统会包含所有底层的文件和目录。

镜像是一个只读的模板，用来创建容器，一个镜像可以创建多个容器，相当于一个root文件系统，比如官方的centos7，就包含了一套完整的centos7最小系统的root文件系统，相当于容器的源代码

容器是一个简易版的linux环境，包括root用户权限，进程空间，用户空间和网络空间等，以及运行在其中的应用程序

Docker本身是一个容器运行载体或称为管理引擎，我们把应用程序和配置依赖打包好形成一个可交付的运行环境，这个打包好的运行环境就是image镜像文件，只有通过这个镜像文件才能生成Docker容器实例。

bootfs：主要包含bootloader和kernel，bootloader主要引导加载kernel，linux刚启动时加载bootfs，在docker镜像的最底层是bootfs，这一曾与典型了linux系统一样，包含boot加载器和内核，boot加载完之后整个内核就都在内存中了，此时内存的使用权已由bootfs转交给内核，此时系统会卸载bootfs

rootfs：在bootfs之上，包含的是典型linux系统的中的/dev等标准目录和文件，rootfs就是各种不同的操作系统的发行版，比如ubuntu。对于一个精简的OS，rootfs可以很小，只需要包括最基本的命令、工具和程序就可以了，底层直接用主机的内核，自己只提供rootfs，因此，不同发行版可以公用bootfs

为什么要采用这种分层结构：共享资源，如果多个镜像都从相同的bas镜像构建，那么宿主机只需提供磁盘上的一份base镜像，同时内存中也只需加载一份base镜像，就可以为所有容器服务了，而且镜像的每一层都可以共享

镜像特点：docker镜像都是只读的；当容器启动时，一个新的可写层被加载到镜像的顶部，这一层通常被称为容器层，容器之下的都叫镜像层

提交容器副本使之成为一个新的镜像：docker commit -a="author" -m="description of this version image" id/name newName[:TAG]

仓库名和标签都是none的镜像是虚悬镜像，该部分镜像的存在没有意义，需要及时清除

Docker容器数据卷

• 是什么：使用卷来保存docker中的数据，如果没有commit生成新的镜像，作为新的镜像的一部分，当容器删除后，数据自然也就没有了
• 作用：容器的持久化、容器间继承和共享数据

卷就是目录或文件，存在于一个或多个容器中，由docker挂载到容器，但不属于联合文件系统，因此能够绕过联合文件系统，提供一些用于持续存储或共享数据的特性。卷的设计就是数据的持久化，完全独立于容器的生命周期，因此docker不会在容器删除时删除其挂载的数据卷。

特点：

• 数据卷可在容器之间共享或重用数据
• 卷中的更改可以直接生效
• 数据卷中的更改不会包含在镜像的更新中
• 数据卷的生命周期一直持续到没有容器使用它为止

添加数据卷：

# 直接命令添加，ro表示read only容器内只能读宿主机目录内文件，不可修改
docker run -it -v /宿主机目录:/容器内目录[:ro] id/name

# DockerFile添加
# 出于可移植和分享的考虑，这种方法不能直接在Dockerfile中实现，宿主机目录依赖于特定主机，不能保证所有宿主机都存在这样的目录，Docker会在宿主机上指定目录，具体目录可以通过docker inspect container_name/id查看
# VOLUME ["/dataVolumeContainer1","/dataVolumeContainer2"]

通过Dockerfile构建镜像

# a Dockerfile demo
FROM centos
VOLUME ["/dataVolumeContainer1","/dataVolumeContainer2"]
CMD echo "finished"
CMD /bin/bash

# 构建镜像
docker build -f /dockerFile -t imageName . # .表示在当前目录创建，不写-f默认读取Dockerfile

# 运行这个镜像会在容器中添加相应的卷，使用docker inspect id/name查看，在宿主机中会有默认的对应目录：/var/lib/docker/volumes/volume_id/_data/

如果遇到docker访问出现cannot open directory .:Permission denied，解决办法：在挂载目录后多加一个 --privileged=true

在镜像启动后会在容器中创建这两个目录，容器停止后，在宿主机中会依然存在_data目录保留着容器的数据，当容器被停止并被删除后，依然存在，不过此时该卷没有被任何容器使用，可以通过docker volume prune删除所有不再被任何容器使用的卷

使用数据卷容器

创建的容器挂载了数据卷，其他容器通过挂载这个容器实现共享挂载容器的数据，挂载数据卷的容器称为数据卷容器。如container1有数据卷/d1，在运行container2时使用--volumes-from container1，那么container2就可以看到container1挂载的/d1，如果卷路径相同，则后启动的容器的这个路径为前一个容器的路径（共享）

数据卷的生命周期一直持续到没有容器使用它为止（匿名卷，type是volume，且手动使用docker volume proune删除），挂载到宿主机上的目录（type是bind），与宿主机上的其他目录没区别

Dockerfile使用

dockerfile是用来构建docker镜像的构建文件，是由一系列命令和参数构成的脚本。使用方法：编写构建文件、构建（docker build）、运行（docker run）

scratch镜像是一个空的镜像，主要是用来构建最初的镜像的

Dockerfile构建过程

Dockerfile是软件原材料、镜像是交付品、容器则是软件的运行态。dockerfile面向开发，docker镜像成为i交付标准，docker容器则涉及部署与运维，三者缺一不可，合力充当docker体系的基石

Dockerfile：需要定义一个dockerfile，定义了进程需要的一切东西，包括执行代码、文件、环境变量、依赖包、运行时环境、动态链接库、操作系统的发行版、服务进程和内核进程等等（当应用进程与系统服务和内核进程打交道时，需要考虑如何设计namespace的权限控制）

docker镜像：dockerfile定义一个文件后，docker build会产生一个docker镜像，当运行镜像时，开始提供服务

docker容器：容器时直接提供服务的

Dockerfile基础知识

• 每条保留字指令都必须大写，后面都要跟至少一个参数
• 指令从上到下，顺序执行
• 表示注释
• 每条指令都会创建一个新的镜像层，并对镜像进行提交

docker执行Dockerfile的大致流程

• docker从基础镜像运行一个容器
• 执行一条指令并对容器做出修改
• 执行类似docker commit的操作提交一个新的镜像层
• docker再基于刚提交的镜像运行一个新容器
• 执行dockerfile中的下一条指令直到所有的指令都执行完成

Dockerfile命令

编写参考：hub.docker.com

FROM scratch  # 当前镜像基于哪个镜像，scratch镜像是空镜像，是所有镜像的基础镜像
MAINTAINER The Centos Project <cloud-ops@centos.org>  # 维护者信息
RUN groupadd -r redis && useradd -r -g redis redis  # 容器构建时需要运行的命令
EXPOSE 6389  # 当前容器对外暴露的端口
WORKDIR /data  # 指定在创建容器后，终端默认登陆进来的工作目录，默认/
ENV MY_ENV1 /my/path  # 用来在构建环境变量中设计环境变量，可以在后续的其他指令中使用
ADD centos-7-docker.tar.xz /  # 将宿主机目录下的文件拷贝进镜像，且ADD会解压tar包、自动处理url
COPY docker-entrypoint.sh /usr/local/bin/  # 类似ADD，但是不解析，只是拷贝，或COPY ["src", "dest"]
VOLUME /data  # 容器数据卷，用于数据保存和持久化工作，或VOLUME ['/d1', '/d2']
CMD echo hello # shell格式，指定一个容器启动时要运行的命令，可以有多个，但只有最后一个生效，CMD会被docker run之后的命令覆盖，如执行tomcat镜像，如果使用docker run -it tomcat bash，那么tomcat就不会启动server，因为Dockerfile最后一行是CMD启动catalina.sh run，上面的bash替代了这个命令
	# 或者exec格式，CMD ["可执行文件", "参数1", ...]
	# 或者参数列表格式 CMD ["参数1", ...]，在指定了ENTRYPOINT指令后，用这个指定具体的参数
ENTRYPOINT ["docker-entrypoint.sh"]  # 与CMD一样，但是不会被覆盖，docker run后的命令追加到ENTRYPOINT里面
ONBUILD RUN echo hello  # 当前镜像作为基础镜像被继承构建时，会首先执行该命令，再执行Dockerfile中的内容

# EXPOSE只是展示性的，为了方便不同开发人员维护！！不用EXPOSE也可以使用-p命令指定端口，但是如果使用了，在使用-P命令时可以随机映射到主机的端口，因为是随机的，所以也没什么用

Dockerfile打包微服务

将微服务打包后（包含依赖项）添加到基础镜像中，基础镜像中要包含jdk

如果微服务有很多是不是要打很多镜像？基础镜像如何只占用一份空间？可以同时将多个镜像打入一个tar包，这样所有的基础镜像只会占用一份空间，docker save <image:tag> <image:tag> -o all-in-one.tar

Docker常用镜像

安装新镜像流程，或者下载后进行load

docker search name  # 搜索镜像
docker pull name  # 拉取镜像
docker images [name]  # 查看镜像
docker run -it -p host_port:cotainter_port -d -e Env1=Value1 -v /path1:/path1 image_name/id  # 启动镜像
docker stop container_name/id  # 停止容器
docker rm container_name/id  # 移除容器，完全删除容器使用-f

常用镜像：

# tomcat
docker search tomcat
docker pull tomcat
docker images
docker run -it -p 8080:8080 tomcat

# mysql（以及主从模式）
docker search mysql:5.7
docker pull mysql:5.7
docker run -p 3306:3306 --name mysql \
    -v /xxx/mysql/conf:/etc/mysql \
    -v /xxx/mysql/logs:/var/log/mysql \
    -v /xxx/mysql/data:/var/lib/mysql \
    -e MYSQL_ROOT_PASSWORD=999999 \
    -d mysql:5.7
docker exec -it contaner_name/id /bin/bash  # 进入容器 执行 mysql -uroot -p999999 登录mysql
# 注意容器中字符集问题，查看数据库字符集：show variables like 'character%'
# 需要在/etc/mysql/conf.d/下手动配置 my.cnf，修改完成后重启容器，进行建库建表
[client]
default_character_set=utf8
[mysqld]
collation_server=utf8_general_ci
character_set_server=utf8

# redis（以及主从模式）
docker pull redis:6.0.8
docker run -p 6379:6379 \
    -v /xxx/data:/data \
    -v /xxx/conf:/etc/redis/redis.conf \
    -d redis redos-server /etc/redis/redis.conf \
    --appendonly yes
docker exec -it contaner_name/id redic-cli # 连接客户端

# Alpine linux是一款独立、非商业的通用linux发行版，专为追求安全性、简单性和资源效率的用户设计，镜像非常小巧，不到6M，所以特别适合容器打包

本地镜像发布到阿里云

# 1 - 生成镜像
docker build -f Dockerfile -t name .
docker commit -a xxx -m xxx id/name:xxx

# 2 - 在dev.aliyun.com创建仓库、命名空间
# 3 - 推送
docker login --username=registry.cn-hangzhou.aliyuncs.com
docker tag id registry.cn-hangzhou.aliyuncs.com/xxx/xxx:xxx
docker push registry.cn-hangzhou.aliyuncs.com/xxx/xxx:xxx

# 4 - 使用：在dev.aliyun.com上搜索，复制地址docker pull
docker pull registry.cn-hangzhou.aliyuncs.com/xxx/xxx:xxx

使用本地私服仓库

先下载registry镜像，并允许，作为仓库服务

docker pull registry
docker run -d -p 5000:5000 -v /path/to/host/registry:/var/lib/registry --privileged=true registry

修改镜像名为符合私服规范的tag：ip:5000/name:tag

默认私服不支持http，可以配置取消，在/etc/docker/daemon.json中添加配置：如果不生效可以重启下docker

{
  "insecure-registries": ["ip:5000"]
}

查看私服库上镜像：

curl -XGET http://ip:5000/v2/_catalog

Docker 网络

ifconfig查看虚拟机ip地址，会发现有以下几个网卡：

# ens33: 虚拟机的网卡，用于连接宿主机
# lo：本地回环地址，ip为127.0.0.1
# virbr0：linux的虚拟化服务，固定ip为192.168.122.1，是做虚拟机网桥使用的，作用是为连接其上的虚拟网卡提供nat访问外网的功能。可以卸载：yum remove livirt-libs.x86_64
# docker0：172.17.0.1/16，docker的虚拟网桥，用于docker与宿主机及容器之间进行网络访问的。

使用docker network ls，查看docker网络，安装docker以后，会默认创建三个：bridge、host、none

# bridge模式：为每个容器分配、设置ip，并将容器连接到docker0虚拟网桥，默认为该模式，ip地址从172.17.0.2开始分配
# host模式：容器将不会虚拟出自己的网卡、配置自己的ip，而是使用宿主机的ip和端口
# none模式：容器有独立的network namespace，但并没有对其进行任何网络设置，如分配veth pair和网桥连接，ip等
# container模式：新创建的容器不会创建自己的网卡和配置自己的ip，而是和一个指定的容器共享ip、端口范围等

创建网络命令：docker network create --network MODE network_name

docker网络的作用：处理容器之间的网络连通及端口映射；容器ip变动的时候可以通过服务名称进行通信而不受影响

理解docker0：在内核层连通了其他的物理或虚拟的网卡，这就将所有的容器和本地主机都放在了同一个物理网络。默认指定了docker0接口的地址和子网掩码，让主机和容器之间可以通过网桥相互通信

bridge模式

# 查看ip地址
ip addr    # address， a都可以

# 原理：
# 1、每启动一个容器，docker就会给容器分配一个ip，只要安装了docker，就会有一个docker0网卡。桥接模式，使用veth-pair技术
# 2、每启动一个容器，就多了一对网络，veth-pair就是一对的虚拟设备接口，它们都是成对出现的，一端连接协议，一端连接网桥docker0，彼此相连。正因为有这个特性，veth-path充当一个桥梁，连接各种虚拟网络设备

# 容器和容器直接是可以互相ping通的
# 所有容器默认共用一个路由器docker0（网关），所有容器在不指定网络的情况下，都是docker0路由的，docker会给容器分配一个默认的可用ip

启动一个容器后查看宿主机网络ip a，会看到多了类似9: vethb09422b@if8:这种虚拟网卡，进入容器会看到8: eth0@if9，这两个是对应的，组成veth pair，容器的eth0与veth通信，veth与docker0相连，从而使得各个容器相互可以通信

host模式

直接使用宿主机的ip地址与外部通信，不在需要额外的nat转换，不会有独立的网络空间，与宿主机共用一个，使用宿主机的ip和端口

none模式

ip a查看只有lo，没有网卡、ip和路网信息，需要自己为docker容器添加配置

container模式

新创建的容器和已经存在的一个容器共享一个网络ip配置（ip、端口），两个环境除了网络配置，其他文件系统、进程列表还是隔离的。

如果共享的容器停止，那么新创建的这个也会丢失网络配置信息，只有一个lo网络配置

自定义网络

--link（已经过时）
--link后加容器名，可用直接通过容器名访问，是在hosts文件里添加了映射

自定义bridge网络
在启动容器时使用自定义的网络，会自动添加容器名称到hosts文件中，添加到自定义网络的容器之间可以通过容器名称互相访问。这个自定义网络与docker0是并列的，且与docker0的所在网络不通，它们对应的子网不通，如docker0是docker0:172.17.0.1/16，自定义创建的是br-81cbaec227be:172.19.0.1/16

# 查看所有的docker网络
docker network --help

# 网络模式
# bridge    # 桥接模式，桥接docker（默认）
# none      # 不配置网络
# host      # 和宿主机共享网络
# container # 容器网络连通（用的少，局限性很大）

# 默认 --net bridge
# 创建自己的网络
docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet

docker network inspect mynet    # 查看自己创建的mynet
docker run -d -P --name tomcat-net-01 --net mynet tomcat    # 使用自己创建的网络而不是docker0，不使用--link可以使用ping名字ping通

# 结论：自定义docker网络帮我们维护好了ip和名字的对应关系，推荐这样使用网络。不同集群使用不同的网络，保证集群健康

网络连通

docker0网络下的（默认）容器如何连接自定义网络下的容器？通过创建网络连接使容器有两个ip地址

docker network connect mynet <containerName>    # 本质是将容器加入网络
docker network inspect mynet    # 可以发现是直接加入的

Docker compose 容器编排

官方手册：https://docs.docker.com/compose/
参考文档：https://docs.docker.com/reference/

Docker官方的开源项目，负责实现对docker容器集群的快速编排。

管理多个docker容器组成的一个应用，需要定义yaml格式的配置文件，写好容器之间的调用关系，只要一个命令，就可以启动关闭这些容器

docker compose也可以配置进行构建镜像，不需要手动build好镜像

version: "3.8"
services:
  mysql:
    images: mysql
	container_name: mysql
	ports:
	  - "3306:3306"
	environment:
	  TZ: Asia/Shanghai
	  MYSQL_ROOT_PASSWORD: abc
	volumes:
	  - "./mysql/conf:/etc/mysql/conf.d"
	  - "./mysql/data:/var/lib/mysql"
	  - "./mysql/init:/docker-entrypoint-initdb.d"
	networks:
	  - "my_network_name"
  my_container_name:
    build:
	  context: .
	  dockerfile: Dockerfile
	container_name: my_container_name
	ports:
	  - "8080:8080"
	network:
	  - "my_network_name"
	depends_on:
	  - "mysql" # 注明依赖关系 在容器启动时会有先后顺序

docker建议每个容器只运行一个服务，docker容器本身占用的资源极少，所以最好每个将每个服务单独的分割开来。那么这样的话要为每个服务单独写Dockerfile，然后再构建镜像、构建容器？太麻烦了，docker官方提供了docker-compose多服务部署的

使用步骤：

• 编写Dockerfile，定义各个微服务并构建出镜像
• 使用docker-compose.yml，定义出完整的业务单元
• 执行docker-compose up启动整个应用程序

如果容器过多就需要k8s进行容 器编排了

可视化

portainer：docker轻量级可视化工具，提供图形化界面，方便管理docker环境，包括单机和集群
rancher

docker run -d -p 8000:8000 -p 9000:9000 --restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer

--restart参数表示在docker重启之后，容器也会随之重启

容器监控（CIG）

使用docker-compose直接必输CAdvisor、InfluxDB、Grafana

CAdvisor：容器资源监控工具，包括容器内存、cpu、网络io、磁盘io等，同时提供了web页面用于查询容器的实时运行状态。cadvisor默认存储2分钟的数据，而且只是针对单物理机。cadvisor提供了许多数据集成接口，支持influxDB、Redis、Kafka、Elasticsearch等集成，可以加上对应配置将监控数据发往这些数据库存储起来。

CAdvisor功能主要有：1，展示host和容器两个层次的监控数据，2，展示历史数据

InfluxDB：是用Go语言编写的一个开源分布式时序、事件和指标数据库，无序外部依赖。

InfluxDB主要功能：

• 基于时间序列，支持与时间有关的函数（最大、最小、求和）
• 可度量性：可以实时对大量数据进行计算
• 基于事件：支持任意的事件数据

Granfana：开源的数据监控分析可视化平台，支持多种数据源配置（influxDB、Mysql、ElasticSearch、OpenTSDB、Graphite等）和丰富的插件及模版功能，支持图表权限控制和报警

Granfana主要特性：

• 灵活丰富的图形化选项
• 可以混合多种风格
• 支持白天和夜间模式
• 多个数据源