docker快速入门

文章目录

简介：

Docker是基于Go语言实现的云开源项目。

Docker的主要目标是"Build，Ship and Run Any App,Anywhere"，也就是通过对应用组件的封装、分发、部署、运行等生命周期的管理，使用户的APP（可以是一个WEB应用或数据库应用等等）及其运行环境能够做到"一次镜像，处处运行"。

Linux容器技术的出现就解决了这样一个问题，而 Docker 就是在它的基础上发展过来的。将应用打成镜像，通过镜像成为运行在Docker容器上面的实例，而 Docker容器在任何操作系统上都是一致的，这就实现了跨平台、跨服务器。只需要一次配置好环境，换到别的机子上就可以一键部署好，大大简化了操作。

解决了运行环境和配置问题的软件容器，方便做持续集成并有助于整体发布的容器虚拟化技术。

组成：

镜像(image)

Docker 镜像（Image）就是一个只读的模板。镜像可以用来创建 Docker 容器，一个镜像可以创建很多容器。

它也相当于是一个root文件系统。比如官方镜像 centos:7 就包含了完整的一套 centos:7 最小系统的 root 文件系统。

相当于容器的"源代码"，docker镜像文件类似于Java的类模板，而docker容器实例类似于java中new出来的实例对象。

容器(container)

从面向对象角度

Docker 利用容器（Container）独立运行的一个或一组应用，应用程序或服务运行在容器里面，容器就类似于一个虚拟化的运行环境，容器是用镜像创建的运行实例。就像是Java中的类和实例对象一样，镜像是静态的定义，容器是镜像运行时的实体。容器为镜像提供了一个标准的和隔离的运行环境，它可以被启动、开始、停止、删除。每个容器都是相互隔离的、保证安全的平台

从镜像容器角度

可以把容器看做是一个简易版的Linux环境（包括root用户权限、进程空间、用户空间和网络空间等）和运行在其中的应用程序

仓库(repository)

仓库（Repository）是集中存放镜像文件的场所。

类似于

Maven仓库，存放各种jar包的地方；

github仓库，存放各种git项目的地方；

Docker公司提供的官方registry被称为Docker Hub，存放各种镜像模板的地方。

仓库分为公开仓库（Public）和私有仓库（Private）两种形式。

最大的公开仓库是 Docker Hub(https://hub.docker.com/)，

存放了数量庞大的镜像供用户下载。国内的公开仓库包括阿里云、网易云等

总结：

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

image文件可以看作是容器的模板。Docker 根据 image 文件生成容器的实例。同一个 image 文件，可以生成多个同时运行的容器实例。

镜像文件

* image 文件生成的容器实例，本身也是一个文件，称为镜像文件。

容器实例

* 一个容器运行一种服务，当我们需要的时候，就可以通过docker客户端创建一个对应的运行实例，也就是我们的容器

仓库

* 就是放一堆镜像的地方，我们可以把镜像发布到仓库中，需要的时候再从仓库中拉下来就可以了。

安装：

docker并非一个通用的容器工具，它依赖于已存在并运行的Linux内核环境。

docker实质上是在已经运行的Linux下制造了一个隔离的文件环境，因此它执行的效率几乎等同于所部署的Linux主机。

因此，docker必须部署在Linux内核的系统上。如果其他系统想部署docker就必须安装一个虚拟Linux环境。

在windows上部署docker的方法都是先安装一个虚拟机，并在安装Linux系统的虚拟机中运行docker。

安装地址：https://docs.docker.com/engine/install/centos/#installation-methods

步骤：

shell 复制代码

#1.安装需要的软件包
yum -y install gcc
yum -y install gcc-c++

#2.设置stable镜像仓库
yum install -y yum-utils
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

#3.更新yum软件包索引
yum makecache fast

#4.安装DOCKER CE
yum -y install docker-ce docker-ce-cli containerd.io

#5.启动docker
systemctl start docker

#6·测试
docker version

卸载：

shell 复制代码

systemctl stop docker
yum remove docker-ce docker-ce-cli containerd.io
rm -rf /var/lib/docker
rm -rf /var/lib/containerd

配置阿里云镜像加速：

运行：

运行一个镜像的一个实例：

shell 复制代码

docker run hello-world

run干了什么?

原理：

...

常用命令：

1.帮助启动类命令

启动docker： systemctl start docker
停止docker： systemctl stop docker
重启docker： systemctl restart docker
查看docker状态： systemctl status docker
开机启动： systemctl enable docker
查看docker概要信息： docker info
查看docker总体帮助文档： docker --help
查看docker命令帮助文档： docker 具体命令 --help

2.镜像命令

列出本地主机上的镜像：docker images [OPYIONS]
- OPTIONS说明：
  - -a :列出本地所有的镜像（含历史映像层）
  - -q :只显示镜像ID。
- REPOSITORY：表示镜像的仓库源
- TAG：镜像的标签版本号
- IMAGE ID：镜像ID
- CREATED：镜像创建时间
- SIZE：镜像大小
查找镜像：docker search [OPTIONS] 镜像名字
- OPTIONS说明：
  - --limit : 只列出N个镜像，默认25个
- NAME：镜像名称
- DESCRIPTION：镜像说明
- STARS：点赞数量
- OFFICIAL：是否是官方的
- AUTOMATED：是否是自动构建的
下载镜像：docker pull 镜像名字[:TAG]
查看镜像/容器/数据卷所占的空间：docker system df
删除镜像：docker rmi 某个XXX镜像名字ID
- 删除单个：docker rmi -f 镜像ID
- 删除多个：docker rmi -f 镜像名1:TAG 镜像名2:TAG
- 删除全部：docker rmi -f $(docker images -qa)

3.容器命令

新建+启动容器：docker run [OPTIONS] IMAGE [COMMAND] [ARG...]
- OPTIONS说明：
  - --name="容器新名字" 为容器指定一个名称；
  - -d: 后台运行容器并返回容器ID，也即启动守护式容器(后台运行)；
  - -i：以交互模式运行容器，通常与 -t 同时使用；
  - -t：为容器重新分配一个伪输入终端，通常与 -i 同时使用；也即启动交互式容器(前台有伪终端，等待交互)；
  - -P: 随机端口映射，大写P
  - -p: 指定端口映射，小写p
启动交互式容器(前台命令行)：docker run -it 容器名 /bin/bash
启动守护式容器(后台服务器)：docker run -d 容器名（Docker容器后台运行,就必须有一个前台进程，否则将自动退出）
列出当前所有正在运行的容器：docker ps [OPTIONS]
- OPTIONS说明：
  - -a :列出当前所有正在运行的容器+历史上运行过的
  - -l :显示最近创建的容器。
  - -n：显示最近n个创建的容器。
  - -q :静默模式，只显示容器编号。
退出容器：两种退出方式
- exit：run进去容器，exit退出，容器停止
- ctrl+p+q：run进去容器，ctrl+p+q退出，容器不停止
启动已停止运行的容器：docker start 容器ID或者容器名
重启容器：docker restart 容器ID或者容器名
停止容器：docker stop 容器ID或者容器名
强制停止容器：docker kill 容器ID或容器名
删除已停止的容器：docker rm 容器ID
- 一次性删除多个容器实例
  - docker rm -f $(docker ps -a -q)
  - docker ps -a -q | xargs docker rm
查看容器日志：docker logs 容器ID
查看容器内运行的进程：docker top 容器ID
查看容器内部细节：docker inspect 容器ID
进入正在运行的容器并以命令行交互：docker exec -it 容器ID /bin/bash
重新进入容器：docker attach 容器ID
- attach 直接进入容器启动命令的终端，不会启动新的进程用exit退出，会导致容器的停止。
- exec 是在容器中打开新的终端，并且可以启动新的进程用exit退出，不会导致容器的停止。
从容器内拷贝文件到主机上：
- 容器→主机：docker cp 容器ID:容器内路径目的主机路径
导入和导出容器：
- export 导出容器的内容留作为一个tar归档文件[对应import命令]：docker export 容器ID > 文件名.tar
- import 从tar包中的内容创建一个新的文件系统再导入为镜像[对应export]：cat 文件名.tar | docker import - 镜像用户/镜像名:镜像版本号
docker commit 容器ID 要创建的目标镜像名:[标签名]

OPTIONS说明：
- -a :提交的镜像作者；
- -m :提交时的说明文字；
提交容器副本使之成为一个新的镜像：docker commit -m="提交的描述信息" -a="作者" 容器ID 要创建的目标镜像名:[标签名]

演示：给centos安装vim命令，然后将centos容器打包为一个镜像，通过这个镜像创建的容器都是带vim命令的。

4.命令交互图

attach Attach to a running container # 当前 shell 下 attach 连接指定运行镜像

build Build an image from a Dockerfile # 通过 Dockerfile 定制镜像

commit Create a new image from a container changes # 提交当前容器为新的镜像

cp Copy files/folders from the containers filesystem to the host path #从容器中拷贝指定文件或者目录到宿主机中

create Create a new container # 创建一个新的容器，同 run，但不启动容器

diff Inspect changes on a container's filesystem # 查看 docker 容器变化

events Get real time events from the server # 从 docker 服务获取容器实时事件

exec Run a command in an existing container # 在已存在的容器上运行命令

export Stream the contents of a container as a tar archive # 导出容器的内容流作为一个 tar 归档文件[对应 import ]

history Show the history of an image # 展示一个镜像形成历史

images List images # 列出系统当前镜像

import Create a new filesystem image from the contents of a tarball # 从tar包中的内容创建一个新的文件系统映像[对应export]

info Display system-wide information # 显示系统相关信息

inspect Return low-level information on a container # 查看容器详细信息

kill Kill a running container # kill 指定 docker 容器

load Load an image from a tar archive # 从一个 tar 包中加载一个镜像[对应 save]

logout Log out from a Docker registry server # 从当前 Docker registry 退出

logs Fetch the logs of a container # 输出当前容器日志信息

port Lookup the public-facing port which is NAT-ed to PRIVATE_PORT # 查看映射端口对应的容器内部源端口

pause Pause all processes within a container # 暂停容器

ps List containers # 列出容器列表

pull Pull an image or a repository from the docker registry server # 从docker镜像源服务器拉取指定镜像或者库镜像

push Push an image or a repository to the docker registry server # 推送指定镜像或者库镜像至docker源服务器

restart Restart a running container # 重启运行的容器

rm Remove one or more containers # 移除一个或者多个容器

rmi Remove one or more images # 移除一个或多个镜像[无容器使用该镜像才可删除，否则需删除相关容器才可继续或 -f 强制删除]

run Run a command in a new container # 创建一个新的容器并运行一个命令

save Save an image to a tar archive # 保存一个镜像为一个 tar 包[对应 load]

search Search for an image on the Docker Hub # 在 docker hub 中搜索镜像

start Start a stopped containers # 启动容器

stop Stop a running containers # 停止容器

tag Tag an image into a repository # 给源中镜像打标签

top Lookup the running processes of a container # 查看容器中运行的进程信息

unpause Unpause a paused container # 取消暂停容器

version Show the docker version information # 查看 docker 版本号

wait Block until a container stops, then print its exit code # 截取容器停止时的退出状态值

5.将镜像打包发布到阿里云

步骤：

1.将本地容器制作为镜像

shell 复制代码

docker commit -m="提交的描述信息" -a="作者" 容器ID 要创建的目标镜像名:[标签名]

2.登录阿里云

https://promotion.aliyun.com/ntms/act/kubernetes.html

3.创建个人实例

4.创建镜像仓库

5.将镜像推送到阿里云registry

# 将镜像推送到阿里云
docker login --username=linging241 registry.cn-hangzhou.aliyuncs.com
docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/linging/mycentos:[镜像版本号]
docker push registry.cn-hangzhou.aliyuncs.com/linging/mycentos:[镜像版本号]

6.从阿里云下载镜像到本地

docker pull registry.cn-hangzhou.aliyuncs.com/linging/mecentos:[镜像版本号]

6.将镜像打包到私有库

官方Docker Hub地址：https://hub.docker.com/，中国大陆访问太慢了且准备被阿里云取代的趋势，不太主流。

docker容器数据卷

卷就是目录或文件，存在于一个或多个容器中，由docker挂载到容器，但不属于联合文件系统，因此能够绕过Union File System提供一些用于持续存储或共享数据的特性：

卷的设计目的就是数据的持久化，完全独立于容器的生存周期，因此Docker不会在容器删除时删除其挂载的数据卷。

将docker容器内的数据保存进宿主机的磁盘中
运行一个带有容器卷存储功能的容器实例
- docker run -it --privileged=true -v /宿主机绝对路径目录:/容器内目录镜像名
- docker run -it --privileged=true -v /usr/local/me/data:/usr/local/tmp/data centos /bin/bash
- docker run -it --privileged=true -v /宿主机绝对路径目录:/容器内目录:rw 镜像名容器目录默认是rw读写
- docker run -it --privileged=true -v /宿主机绝对路径目录:/容器内目录:ro 镜像名容器目录只读
容器卷的特点：
- 特点：
  
  1：数据卷可在容器之间共享或重用数据
  
  2：卷中的更改可以直接实时生效
  
  3：数据卷中的更改不会包含在镜像的更新中
  
  4：数据卷的生命周期一直持续到没有容器使用它为止
卷的继承和共享
- docker run -it --privileged=true --volumes-from 父容器名 --name u2 镜像名
- docker run -it --privileged=true --volumes-from u1 --name u2 镜像名
- 相当于容器1，容器2...容器n映射宿主机中的同一目录，然后共享数据，任意容器或者宿主机的内容修改都会实时同步。

docker安装常用软件

1.安装tomcat

shell 复制代码

#拉取镜像
docker pull tomcat:8.0.17
#运行容器
docker run -it -p 8080:8080 tomcat:8.0.17
或
docker run -d -p 8080:8080 tomcat:8.0.17
#访问
http://ip:8080

2.安装mysql

shell 复制代码

#拉取镜像
docker pull mysql:5.7.5
#运行容器
docker run -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7.5
#进入容器
ocker exec -it 容器ID /bin/bash
#进入mysql
mysql -uroot -p

插入中文会报错。

#查看字符编码
SHOW VARIABLES LIKE 'character%';


#将mysql的数据挂在到宿主机
docker run -d -p 3306:3306 --privileged=true -v /usr/local/mysql/log:/var/log/mysql -v /usr/local/mysql/data:/var/lib/mysql -v /usr/local/mysql/conf:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7.5

#新建配置文件
cd /usr/local/mysql/conf
vi my.cnf

输入以下内容：
[client]
default_character_set=utf8
[mysqld]
collation_server = utf8_general_ci
character_set_server = utf8

#重启mysql容器
docker restart 容器ID

插入中文不会报错。

3.安装redis

shell 复制代码

#拉取镜像
docker pull redis:6.0.8

#运行容器
docker run -p 6379:6379 --privileged=true -v /usr/local/redis/redis.conf:/etc/redis/redis.conf -v /usr/local/redis/data:/data -d redis:6.0.8 redis-server /etc/redis/redis.conf

#进入容器运行redis-cli
docker exec -it 容器ID redis-cli

4.安装nginx

复制代码

5.安装mysql主从

6.安装redis集群模式

7.docker运行微服务项目

编写微服务项目docker-boot，打成jar包

编写Dockerfile文件

shell 复制代码

#构建java8镜像
FROM centos:7
MAINTAINER linging<linging@163.com>
 
#安装java8及lib库
RUN yum -y install glibc.i686
RUN mkdir /usr/local/java
#ADD 是相对路径jar,把jdk-8u11-linux-x64.tar.gz添加到容器中,安装包必须要和Dockerfile文件在同一位置
ADD jdk-8u11-linux-x64.tar.gz /usr/local/java/
#配置java环境变量
ENV JAVA_HOME /usr/local/java/jdk1.8.0_11
ENV JRE_HOME $JAVA_HOME/jre
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib:$CLASSPATH
ENV PATH $JAVA_HOME/bin:$PATH
 
CMD ["java","-version"]

#构建命令 docker build -t java:8 .

shell 复制代码

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

#构建镜像命令  docker build -t test_java_app:1.0 .
#运行   docker run -d -p 6001:6001 test_java_app:1.0
#测试
#curl 127.0.0.1:6001/order/index
#curl 127.0.0.1:6001/order/docker
#或者打开浏览器输入：192.168.159.100:6001/order/index

8.linux下安装jdk

shell 复制代码

#上传安装包 jdk-8u11-linux-x64.tar.gz 到目录 /usr/localjava/
#解压
tar -zxvf jdk-8u11-linux-x64.tar.gz

#配置环境变量
vi /etc/profile
#写入以下内容
export JAVA_HOME=/usr/local/java/jdk1.8.0_11
export PATH=$JAVA_HOME/bin:$PATH
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

#配置文件生效
source /etc/profile
#查看版本
java -version

9.安装hugegraph

shell 复制代码

#拉取hugegraph镜像，服务
docker pull hugegraph/hugegraph:latest
#启动容器

docker run -itd --name=graph -p 8080:8080 hugegraph/hugegraph

docker run -itd -p 8080:8080 --privileged=true -v /usr/local/hugegraph/gconf:/hugegraph/conf hugegraph/hugegraph
#测试
curl 0.0.0.0:8080


#拉取hugegraph/hubble，UI界面
docker pull hugegraph/hubble:latest
#启动容器
docker run -itd --name=fe -p 8088:8088 hugegraph/hubble

10、安装tinkerpop

shell 复制代码

docker pull tinkerpop/gremlin-server:3.5.0
docker pull tinkerpop/gremlin-console:3.5.0

docker run -p 8182:8182 --privileged=true -v /usr/local/tinkerpop/conf/gremlin-server2.yaml:/opt/gremlin-server/conf/gremlin-server2.yaml -v /usr/local/tinkerpop/data:/opt/gremlin-server/data -d tinkerpop/gremlin-server:3.5.0 conf/gremlin-server2.yaml

dockerFile文件详解

1.dockerFile是什么？

Dockerfile是用来构建Docker镜像的文本文件，是由一条条构建镜像所需的指令和参数构成的脚本。

构建三步骤

编写Dockerfile文件
docker build命令构建镜像
docker run依镜像运行容器实例

2.DockerFile构建过程解析

Dockerfile内容基础知识

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

Docker执行Dockerfile的大致流程

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

DockerFile与Docker镜像与Docker容器的关系

Dockerfile，需要定义一个Dockerfile，Dockerfile定义了进程需要的一切东西。Dockerfile涉及的内容包括执行代码或者是文件、环境变量、依赖包、运行时环境、动态链接库、操作系统的发行版、服务进程和内核进程(当应用进程需要和系统服务和内核进程打交道，这时需要考虑如何设计namespace的权限控制)等等;
Docker镜像，在用Dockerfile定义一个文件之后，docker build时会产生一个Docker镜像，当运行 Docker镜像时会真正开始提供服务;
Docker容器，容器是直接提供服务的。

3.DockerFile常见保留字指令

https://docs.docker.com/engine/reference/builder/

FROM：基础镜像，当前新镜像是基于哪个镜像的，指定一个已经存在的镜像作为模板，第一条必须是from
MAINTAINER：镜像维护者的姓名和邮箱地址
RUN ：容器构建时需要运行的命令。RUN是在 docker build时运行
- shell格式：RUN <命令行命令> #<命令行命令>等同于，在终端操作的shell命令。如：RUN yum -y install vim
- exec格式：RUN ["可执行文件","参数1","参数2"] #如：RUN["./test.php","dev","offline"] <==> RUN ./test.php dev offline
EXPOSE：当前容器对外暴露出的端口
WORKDIR：指定在创建容器后，终端默认登陆的进来工作目录，一个落脚点
USER：指定该镜像以什么样的用户去执行，如果都不指定，默认是root
ENV：用来在构建镜像过程中设置环境变量
VOLUME：容器数据卷，用于数据保存和持久化工作
ADD：将宿主机目录下的文件拷贝进镜像且会自动处理URL和解压tar压缩包
COPY：类似ADD，拷贝文件和目录到镜像中。将从构建上下文目录中 <源路径> 的文件/目录复制到新的一层的镜像内的 <目标路径> 位置
- COPY src dest
- COPY ["src", "dest"]
- <src源路径>：源文件或者源目录
- <dest目标路径>：容器内的指定路径，该路径不用事先建好，路径不存在的话，会自动创建。
CMD ：指定容器启动后的要干的事情。CMD是在docker run 时运行
- Dockerfile 中可以有多个 CMD 指令，但只有最后一个生效，CMD 会被 docker run 之后的参数替换

ENTRYPOINT：也是用来指定一个容器启动时要运行的命令

类似于 CMD 指令，但是ENTRYPOINT不会被docker run后面的命令覆盖，而且这些命令行参数会被当作参数送给 ENTRYPOINT 指令指定的程序
ENTRYPOINT可以和CMD一起用，一般是变参才会使用 CMD ，这里的 CMD 等于是在给 ENTRYPOINT 传参。

当指定了ENTRYPOINT后，CMD的含义就发生了变化，不再是直接运行其命令而是将CMD的内容作为参数传递给ENTRYPOINT指令，他两个组合会变成 <ENTRYPOINT> "<CMD>"。案例如下：

shell 复制代码

FROM nginx

ENTRYPOINT ["nginx", "-c"] #定参
CMD ["/etc/nginx/nginx.conf"] #变参

是否传参	按照dockerfile编写执行	传参运行
Docker命令	docker run nginx:test	docker run nginx:test -c /etc/nginx/new.conf
衍生出的实际命令	nginx -c /etc/nginx/nginx.conf	nginx -c /etc/nginx/new.conf

如果 Dockerfile 中如果存在多个 ENTRYPOINT 指令，仅最后一个生效。

4.编写dockerfile文件

docker pull centos:7

shell 复制代码

FROM centos:7
MAINTAINER linging<linging@163.com>
 
ENV MYPATH /usr/local
WORKDIR $MYPATH
 
#安装vim编辑器
RUN yum -y install vim
#安装ifconfig命令查看网络IP
RUN yum -y install net-tools
#安装java8及lib库
RUN yum -y install glibc.i686
RUN mkdir /usr/local/java
#ADD 是相对路径jar,把jdk-8u11-linux-x64.tar.gz添加到容器中,安装包必须要和Dockerfile文件在同一位置
ADD jdk-8u11-linux-x64.tar.gz /usr/local/java/
#配置java环境变量
ENV JAVA_HOME /usr/local/java/jdk1.8.0_11
ENV JRE_HOME $JAVA_HOME/jre
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib:$CLASSPATH
ENV PATH $JAVA_HOME/bin:$PATH
 
EXPOSE 80

CMD echo $MYPATH
CMD echo "success--------------ok"
CMD /bin/bash

shell 复制代码

#构建镜像,最后的点表示当前目录，即Dockerfile文件所在的目录
docker build -t centosjava8:1.0 .
#构建完成运行
docker run -it centosjava8:1.0 /bin/bash
#运行命令
ifconfig
vim 
java -version

docker网络

docker-compose容器编排

Compose 是 Docker 公司推出的一个工具软件，可以管理多个 Docker 容器组成一个应用。你需要定义一个 YAML 格式的配置文件docker-compose.yml，写好多个容器之间的调用关系。然后，只要一个命令，就能同时启动/关闭这些容器。

1.官网：

https://docs.docker.com/compose/compose-file/compose-file-v3/

2.安装：

https://docs.docker.com/compose/install/

安装步骤：

shell 复制代码

curl -SL https://github.com/docker/compose/releases/download/v2.17.1/docker-compose-linux-x86_64 -o /usr/local/bin/docker-compose

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

docker-compose --version

卸载：

shell 复制代码

rm /usr/local/bin/docker-compose

3.核心概念

一文件
- docker-compose.yml
两要素
- 服务（service）一个个应用容器实例，比如订单微服务、库存微服务、mysql容器、nginx容器或者redis容器
- 工程（project）由一组关联的应用容器组成的一个完整业务单元，在 docker-compose.yml 文件中定义。

4.Compose使用的三个步骤

编写Dockerfile定义各个微服务应用并构建出对应的镜像文件
使用 docker-compose.yml 定义一个完整业务单元，安排好整体应用中的各个容器服务。
最后，执行docker-compose up命令来启动并运行整个应用程序，完成一键部署上线

5.Compose常用命令

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 # 停止服务

6.Compose编排微服务

1.准备镜像：blog_docker:1.0、redis:6.0.8、mysql:5.7.5

2.编写docker-compose.yml文件，如下内容：

yml 复制代码

version: "3"

services:
  microService:
    image: blog_docker:1.0
    container_name: blog
    ports:
    - "8080:8080"
    volumes:
    - /app/microService:/data
    networks:
     - linging_net
    depends_on:
      - redis
      - mysql

  redis:
    image: redis:6.0.8
    ports:
    - "6379:6379"
    volumes:
    - /usr/local/redis/redis.conf:/etc/redis/redis.conf
    - /usr/local/redis/data:/data
    networks:
     - linging_net
    command: redis-server /etc/redis/redis.conf

  mysql:
    image: mysql:5.7.5
    environment:
      MYSQL_ROOT_PASSWORD: '123456'
      MYSQL_ALLOW_EMPTY_PASSWORD: 'no'
      MYSQL_DATABASE: 'lingingblog'
      MYSQL_USER: 'root'
      MYSQL_PASSWORD: '123456'
    ports:
    - "3306:3306"
    volumes:
    - /usr/local/mysql/data:/var/lib/mysql
    - /usr/local/mysql/conf:/etc/mysql/conf.d
    - /usr/local/mysql/log:/var/log/mysql
    networks:
     - linging_net
    command: --default-authentication-plugin=mysql_native_password #解决外部无法访问

networks:
  linging_net:

3.启动docker-comppse服务

shell 复制代码

docker-compose up -d

4.查看容器

docker ps

由于ip地址可能会变，所以在微服务中可以将ip写为对应的服务名称，比如mysql，redis

docker可视化工具

docker容器监控

sql

redis:

image: redis:6.0.8

ports:

"6379:6379"

volumes:

/usr/local/redis/redis.conf:/etc/redis/redis.conf
/usr/local/redis/data:/data

networks:

linging_net

command: redis-server /etc/redis/redis.conf

mysql:

image: mysql:5.7.5

environment:

MYSQL_ROOT_PASSWORD: '123456'

MYSQL_ALLOW_EMPTY_PASSWORD: 'no'

MYSQL_DATABASE: 'lingingblog'

MYSQL_USER: 'root'

MYSQL_PASSWORD: '123456'

ports:

"3306:3306"

volumes:

/usr/local/mysql/data:/var/lib/mysql
/usr/local/mysql/conf:/etc/mysql/conf.d
/usr/local/mysql/log:/var/log/mysql

networks:

linging_net

command: --default-authentication-plugin=mysql_native_password #解决外部无法访问

networks:

linging_net:

3.启动docker-comppse服务

```shell
docker-compose up -d

4.查看容器

docker ps

由于ip地址可能会变，所以在微服务中可以将ip写为对应的服务名称，比如mysql，redis