Docker的基本使用

Docker

概念

Docker架构

docker分为客户端，Docker服务端，仓库

客户端

Docker 是一个客户端-服务器（C/S）架构程序。Docker 客户端只需要向 Docker 服务端发起请求，服务端将完成所有的工作并返回相应结果。

Docker 提供了一个命令行工具 docker 以及一整套 RESTful API。

Docker服务端

Docker服务端 又称为Docker主机，Docker引擎，Docker守护进程。

依托于宿主机，守护进程，用于管理镜像，容器，执行客户端命令等。

仓库Registry

Docker有两个重要的概念镜像和容器。

镜像可以理解为就是软件安装包，容器就是软件安装完成后可运行的状态。

镜像

镜像可以理解为软件安装包，一个Docker镜像是一个完整的操作系统的描述。

容器

镜像（Image）和容器（Container）的关系，就像是面向对象程序设计中的类和实例一样，镜像是静态的定义，容器是镜像运行时的实体。

容器可以被创建、启动、停止、删除、暂停等。

注意：容器运行需要指定镜像，当容器运行后，一个容器就相当于一个虚拟的完整的操作系统，比如你通过mysql的镜像来安装mysql，当mysql的容器启动后，就相当于开启了一个操作系统，mysql只是安装在此容器内部的操作系统中，我们可以进入容器内部操作mysql（和正常操作系统一致），也可以通过docker命令来操作

安装Docker

1. 卸载原有的版本

 sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine

2. 安装yum-utils

   sudo yum install -y yum-utils
   

3. 添加阿里云镜像

   yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
   

4. 安装

   sudo yum install docker-ce docker-ce-cli containerd.io
   

5. 启动并加入开机启动

   sudo systemctl start docker
   
   sudo systemctl enable docker
   

Docker常用命令

查看镜像

docker images

• REPOSITORY：镜像在仓库中的名称
• TAG：镜像标签(一般是软件的版本号)
• IMAGE ID：镜像 ID
• CREATED：镜像的创建日期（不是获取该镜像的日期）
• SIZE：镜像大小

搜索镜像

如果需要下载镜像，但是又不知道docker有没有，可以通过搜索镜像命令进行查看。

docker search 镜像名称

• NAME：镜像名称
• DESCRIPTION：镜像描述
• STARS：用户评价，反映一个镜像的受欢迎程度
• OFFICIAL：是否为官方构建
• AUTOMATED：自动构建，表示该镜像由 Docker Hub 自动构建流程创建的。

拉去镜像

拉取镜像就是从中央仓库下载镜像到本地。

docker pull 镜像名称:tag

比如我们要下载centos7的镜像：

docker pull centos:7

配置镜像加速（centos）

针对Docker客户端版本大于 1.10.0 的用户

您可以通过修改daemon配置文件/etc/docker/daemon.json来使用加速器

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://2bewljww.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

删除镜像

docker rmi 镜像id
docker rmi 镜像名称
docker rmi 镜像名称:tag

使用镜像id删除的时候，输入id的前几位即可

删除镜像的时候，必须保证没有镜像被使用，也就是说没有通过镜像创建容器，如果有，则必须先删除容器

docker images -q 可以查询到所有镜像的 ID

#以下命令可以删除 所有镜像
docker rmi `docker images -q`

查看正在运行的容器

docker ps

• ONTAINER ID：容器 ID
• IMAGE：所属镜像
• COMMAND：命令
• CREATED：创建时间
• STATUS：容器状态 Up运行 Exited退出
• PORTS：端口
• NAMES：容器名称

查询所有容器

docker ps -a

容器启动命令

docker run [OPTIONS] IMAGE [COMMAND] [ARG...]

• -i：表示运行容器；
• -t：表示容器启动后会进入其命令行。加入这两个参数后，容器创建就能登录进去。即分配一个伪终端；
• --name：为创建的容器命名；
• -v：表示目录映射关系（前者是宿主机目录，后者是映射到宿主机上的目录），可以使用多个 -v 做多个目录或文件映射。注意：最好做目录映射，在宿主机上做修改，然后共享到容器上；
• -d：在 run 后面加上 -d 参数，则会创建一个守护式容器在后台运行（这样创建容器后不会自动登录容器，如果只加 -i -t 两个参数，创建容器后就会自动进容器里）；
• -p：表示端口映射，前者是宿主机端口，后者是容器内的映射端口。可以使用多个 -p 做多个端口映射。
• -P：随机使用宿主机的可用端口与容器内暴露的端口映射。

创建并进入容器

docker run -it --name 容器名称 镜像名称:标签 /bin/bash

Docker 容器运行必须有一个前台进程， 如果没有前台进程执行，容器认为是空闲状态，就会自动退出。

docker run -it --name mszlu_mysql mysql:5.7 /bin/bash

守护方式创建容器

docker run -di --name 容器名称 镜像名称:标签
# 此方式创建完成后，会启动容器，但不会进入容器，容器一直运行，除非使用docker stop命令关闭容器

守护方式进入容器

# 必须是容器正在运行
docker exec -it 容器名称|容器ID /bin/bash

停止与启动容器

# 停止容器
docker stop 容器名称|容器ID
# 启动容器
docker start 容器名称|容器ID

文件拷贝

如果我们需要将文件拷贝到容器内可以使用 cp 命令。

docker cp 需要拷贝的文件或目录 容器名称:容器目录

也可以将文件从容器内拷贝出来。

docker cp 容器名称:容器目录 需要拷贝的文件或目录

容器数据卷

数据卷这个概念非常重要

比如有以下场景：

1. 配置文件需要频繁修改
2. 容器内部的数据需要备份
3. 删除容器不希望删除数据

上述的需求，有了数据卷之后，变的非常容易。

我们可以在创建容器的时候，将宿主机的目录与容器内的目录进行映射，这样我们就可以通过修改宿主机某个目录的文件从而去影响容器，而且这个操作是双向绑定的，也就是说容器内的操作也会影响到宿主机，实现备份功能。

但是容器被删除的时候，宿主机的内容并不会被删除，因为底层是通过拷贝实现的。如果多个容器挂载同一个目录，其中一个容器被删除，其他容器的内容也不会受到影响，同理，底层是拷贝实现的。

容器与宿主机之间的数据卷属于引用的关系，数据卷是从外界挂载到容器内部中的，所以可以脱离容器的生命周期而独立存在，正是由于数据卷的生命周期并不等同于容器的生命周期，在容器退出或者删除以后，数据卷仍然不会受到影响，数据卷的生命周期会一直持续到没有容器使用它为止。

命令

创建容器添加 -v 参数，格式为宿主机目录:容器目录，例如：

docker run -di -v /mszlu/docker/centos/data:/usr/local/data --name centos7-01 centos:7
# 多目录挂载
docker run -di -v /宿主机目录:/容器目录 -v /宿主机目录2:/容器目录2 镜像名

注意：目录挂载操作可能会出现权限不足的提示。这是因为 CentOS7 中的安全模块 SELinux 把权限禁掉了，在 docker run 时通过 --privileged=true 给该容器加权限来解决挂载的目录没有权限的问题。

匿名挂载

匿名挂载只需要写容器目录即可，宿主机对应的目录会在 /var/lib/docker/volumes 中生成。

# 匿名挂载
docker run -di -v /usr/local/data --name centos7-02 centos:7
# 查看 volume 数据卷信息
docker volume ls

具名挂载

具名挂载就是给数据卷起了个名字，容器外对应的目录会在 /var/lib/docker/volume 中生成。

# 具名挂载
docker run -di -v docker_centos_data:/usr/local/data --name centos7-03 centos:7
# 查看 volume 数据卷信息
docker volume ls

只读/读写

# 只读。只能通过修改宿主机内容实现对容器的数据管理。
docker run -it -v /宿主机目录:/容器目录:ro 镜像名
# 读写，默认。宿主机和容器可以双向操作数据。
docker run -it -v /宿主机目录:/容器目录:rw 镜像名

数据卷容器（数据卷继承）

# 容器 centos7-01 指定目录挂载
docker run -di -v /mydata/docker_centos/data:/usr/local/data --name centos7-01 centos:7
# 容器 centos7-04 和 centos7-05 相当于继承 centos7-01 容器的挂载目录
docker run -di --volumes-from centos7-01 --name centos7-04 centos:7
docker run -di --volumes-from centos7-01 --name centos7-05 centos:7

查看容器ip地址

我们可以通过以下命令查看容器的元信息。

docker inspect 容器名称|容器ID

也可以直接执行下面的命令直接输出 IP 地址。

docker inspect --format='{{.NetworkSettings.IPAddress}}' 容器名称|容器ID

删除容器

# 删除指定容器
docker rm 容器名称|容器ID
# 删除多个容器
docker rm 容器名称|容器ID 容器名称|容器ID

Docker部署

mysql部署

1. 拉取镜像

   docker pull mysql:5.7
   

2. 创建镜像

   docker run -id \
   -p 3307:3306 \
   --name=c_mysql \
   -v /mnt/docker/mysql/conf:/etc/mysql/conf.d \
   -v /mnt/docker/mysql/logs:/logs \
   -v /mnt/docker/mysql/data:/var/lib/mysql \
   -e MYSQL_ROOT_PASSWORD=root \
   mysql:5.7
   

3. 可以进入容器访问，也可以通过3307 外部访问

redis部署

1. 拉取镜像。

docker pull redis

2. 创建容器

docker run -di --name redis -p 6379:6379 redis

连接容器中的 Redis 时，只需要连接宿主机的 IP + 指定的映射端口即可。

RabbitMQ部署

拉取镜像

docker pull rabbitmq

创建容器

docker run -di --name rabbitmq -p 4369:4369 -p 5671:5671 -p 5672:5672 -p 15671:15671 -p 15672:15672 -p 25672:25672 rabbitmq

进入容器并开启管理功能

# 进入容器
docker exec -it rabbitmq /bin/bash
# 开启 RabbitMQ 管理功能
rabbitmq-plugins enable rabbitmq_management

1. 访问：http://ip:15672/ 使用 guest 登录账号密码

nginx部署

1. 拉取镜像

   docker pull nginx
   

2. 创建容器

   docker run -di --name nginx -p 80:80 -v /mnt/docker/nginx:/etc/nginx nginx
   

3. 访问 http://ip 即可

4. 通过nginx访问tomcat

   nginx.conf

   user  nginx;
   worker_processes  1;
   
   error_log  /var/log/nginx/error.log warn;
   pid        /var/run/nginx.pid;
   
   
   events {
       worker_connections  1024;
   }
   
   
   http {
       include       /etc/nginx/mime.types;
       default_type  application/octet-stream;
   
       log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                         '$status $body_bytes_sent "$http_referer" '
                         '"$http_user_agent" "$http_x_forwarded_for"';
   
       access_log  /var/log/nginx/access.log  main;
   
       sendfile        on;
       #tcp_nopush     on;
   
       keepalive_timeout  65;
   
       #gzip  on;
   
       server {
       	listen 80;
       	server_name localhost;
       	location / {
       		proxy_pass http://172.17.0.2:8080;
       	}
       }
   }
   

5. 访问http://ip/index.html

Docker镜像构建

Docker commit

平常我们都是从公共仓库拉取镜像，我们也可以从容器中构建我们自己的镜像。

需求：

1. 基础镜像centos
2. 安装jdk
3. 安装nginx

Dockerfile

在 Docker 中构建镜像最常用的方式，就是使用 Dockerfile。Dockerfile 是一个用来构建镜像的文本文件，文本内容包含了一条条构建镜像所需的指令和说明。

常用指令

FROM

语法：FROM :

指明构建的新镜像是来自于哪个基础镜像，如果没有选择 tag，那么默认值为 latest。

FROM centos:7

MAINTAINER

语法：MAINTAINER

指明镜像维护者及其联系方式（一般是邮箱地址）。官方说明已过时，推荐使用 LABEL。

**LABEL **

语法：LABEL = = = ...

功能是为镜像指定标签。也可以使用 LABEL 来指定镜像作者。

RUN

语法：RUN

构建镜像时运行的 Shell 命令，比如构建的新镜像中我们想在 /usr/local 目录下创建一个 java 目录。

ADD

语法：ADD ...

拷贝文件或目录到镜像中。src 可以是一个本地文件或者是一个本地压缩文件，压缩文件会自动解压。还可以是一个 url，如果把 src 写成一个 url，那么 ADD 就类似于 wget 命令，然后自动下载和解压。

**COPY **

语法：COPY ...

拷贝文件或目录到镜像中。用法同 ADD，只是不支持自动下载和解压。

EXPOSE

语法：EXPOSE [/...]

暴露容器运行时的监听端口给外部，可以指定端口是监听 TCP 还是 UDP，如果未指定协议，则默认为 TCP。

ENV

语法：ENV 添加单个，ENV = ... 添加多个。

设置容器内环境变量。

CMD

语法：

• CMD ["executable","param1","param2"]，比如：CMD ["/usr/local/tomcat/bin/catalina.sh", "start"]
• CMD ["param1","param2"]，比如：CMD [ "echo", "$JAVA_HOME" ]
• CMD command param1 param2，比如：CMD echo $JAVA_HOME

启动容器时执行的 Shell 命令。在 Dockerfile 中只能有一条 CMD 指令。如果设置了多条 CMD，只有最后一条 CMD 会生效。

**ENTRYPOINT **

语法：

• ENTRYPOINT ["executable", "param1", "param2"]，比如：ENTRYPOINT ["/usr/local/tomcat/bin/catalina.sh", "start"]
• ENTRYPOINT command param1 param2，比如：ENTRYPOINT ehco $JAVA_HOME

启动容器时执行的 Shell 命令，同 CMD 类似，不会被 docker run 命令行指定的参数所覆盖。在 Dockerfile 中只能有一条 ENTRYPOINT 指令。如果设置了多条 ENTRYPOINT，只有最后一条 ENTRYPOINT 会生效。

**WORKDIR **

语法：WORKDIR /path/to/workdir

为 RUN、CMD、ENTRYPOINT 以及 COPY 和 AND 设置工作目录。

构建镜像

Dockerfile 文件编写好以后，真正构建镜像时需要通过 docker build 命令。

docker build 命令用于使用 Dockerfile 创建镜像。

# 使用当前目录的 Dockerfile 创建镜像
docker build -t mycentos:7 .
# 通过 -f Dockerfile 文件的位置创建镜像
docker build -f /usr/local/dockerfile/Dockerfile -t mycentos:7 .

• -f：指定要使用的 Dockerfile 路径；
• --tag, -t：镜像的名字及标签，可以在一次构建中为一个镜像设置多个标签。

举个例子：我的宿主机 jdk 文件在 /root 目录下，Dockerfile 文件在 /usr/local/dockerfile 目录下，文件内容如下：

ADD jdk-11.0.6_linux-x64_bin.tar.gz /usr/local/java

那么构建镜像时的命令就该这样写：

docker build -f /usr/local/dockerfile/Dockerfile -t mycentos:7 /root

再举个例子：我的宿主机 jdk 文件和 Dockerfile 文件都在 /usr/local/dockerfile 目录下，文件内容如下：

ADD jdk-11.0.6_linux-x64_bin.tar.gz /usr/local/java

那么构建镜像时的命令则这样写：

docker build -f /usr/local/dockerfile/Dockerfile -t mycentos:7 .

实例

接下来我们通过基础镜像 centos:7，在该镜像中安装 jdk 和 tomcat 以后将其制作为一个新的镜像 mscentos:7

创建目录

mkdir -p /mnt/docker/dockerfile

编写 Dockerfile 文件。

vim Dockerfile

Dockerfile 文件内容如下：

# 指明构建的新镜像是来自于 centos:7 基础镜像
FROM centos:7
# 通过镜像标签声明了作者信息
LABEL maintainer="mszlu.com"
# 设置工作目录
WORKDIR /usr/local
# 新镜像构建成功以后创建指定目录
RUN mkdir -p /usr/local/java && mkdir -p /usr/local/tomcat
# 拷贝文件到镜像中并解压
ADD jdk-11.0.8_linux-x64_bin.tar.gz /usr/local/java
ADD apache-tomcat-9.0.59.tar.gz /usr/local/tomcat
# 暴露容器运行时的 8080 监听端口给外部
EXPOSE 8080
# 设置容器内 JAVA_HOME 环境变量
ENV JAVA_HOME /usr/local/java/jdk-11.0.8/
ENV PATH $PATH:$JAVA_HOME/bin
# 启动容器时启动 tomcat
CMD ["/usr/local/tomcat/apache-tomcat-9.0.59/bin/catalina.sh", "run"]

上传jdk和tomcat到Dockerfile一样的目录下

构建镜像

[root@localhost ~]# docker build -f /usr/local/dockerfile/Dockerfile -t mscentos:7 .

使用构建的镜像创建容器

# 创建容器
docker run -di --name mscentos7 -p 8080:8080 mscentos:7
# 访问 http://192.168.200.101:8080/ 看到页面说明环境 OK!