Docker 容器技术，让你不再为环境而烦恼

Docker 是一个开源的应用容器引擎，使用容器化技术，让开发者可以打包他们的应用以及依赖包到一个可移植的容器中，然后发布到任何流行的 Linux 或 Windows 操作系统的机器上。实质上，容器内的应用还是直接运行在宿主机上，各个容器之间相互隔离。

Docker 是内核级别的虚拟化，可以在一个物理机上可以运行很多的容器实例。

Docker 安装

官网：https://www.docker.com/

官方文档：https://docs.docker.com/

安装

yum 包更新到最新
```
yum update
```
注：若 Linux 虚拟机未配置网络，则可以通过查看另一篇博客配置网络：在 VM 虚拟机中 Linux 动态网络配置_ZOOM_Jie -CSDN博客。
安装需要的软件包，yum-util 提供 yum-config-manager 功能，另外两个是 devicemapper 驱动依赖
```
yum install -y yum-utils device-mapper-persistent-data lvm2
```

设置 yum 源为阿里云

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

安装 Docker 社区版
```
yum -y install docker-ce
```
查看 Docker 版本号
```
docker -v
```

设置 USTC 镜像

编辑 /etc/docker/daemon.json 文件
```
mkdir -p /etc/docker
vim /etc/docker/daemon.json
```
注：通过 yum 安装 vim：yum -y install vim* 。

在 daemon.json 文件中输入以下内容：

{
"registry-mirrors":["https://docker.mirrors.ustc.edu.cn"]
}

启动 Docker

启动 docker
```
systemctl start docker
```
停止 docker
```
systemctl stop docker
```
查看 docker 状态
```
systemctl status docker
```
查看 docker 具体信息
```
docker info
```
查看 docker 帮助文档
```
docker --help
```
设置开机自动启动 docker
```
systemctl enable docker
```

Docker 常用命令镜像命令

查看镜像
```
docker images
```
搜索镜像
```
docker search centos
```
拉取镜像
```
docker pull 镜像名称(repository):版本(tag)
```
注：拉取镜像不加版本 (:7) 即默认拉取最后一个版本。
删除镜像

按镜像 ID 删除镜像
```
docker rmi ImageID
```
删除所有镜像
```
docker rmi docker images -q
```

容器命令

启动容器
```
docker start [容器名/id]
```
停止容器
```
docker stop [容器名/id]
```
查看正在运行的容器
```
docker ps
```
删除容器
```
docker rm [容器名/id]
```
查看所有容器
```
docker ps -a
```
查看最后一次运行的容器
```
docker ps -l
```
查看停止的容器
```
docker ps -f status=exited
```
查看停止的容器
```
docker ps -f status=exited
```
创建容器
```
docker run
```
-i：表示运行容器。
-t：表示容器启动后会进入其命令行。加入这两个参数后，容器创建就能登录进去。即分配一个伪终端。
--name：为创建的容器命名（唯一）。
-v：表示目录映射关系（前者是宿主机目录，后者是映射到宿主机上的目录），可以使用多个 -v 做多个目录或文件映射。注意：最好做目录映射，在宿主机上做修改，然后共享到容器上。
-d：在 run 后面加上 -d 参数，则会创建一个守护式容器在后台运行（这样创建容器后不会自动登录容器，如果只加 -i，-t 两个参数，创建后就会自动进去容器）。
-p：表示端口映射，前者是宿主机端口，后者是容器内的映射端口。可以使用多个 -p 做多个端口映射。
- 交互式方式创建容器
```
docker run -it --name=容器名 [镜像名称]:[版本] /bin/bash
```
  这时我们通过 ps 命令查看，发现可以看到启动的容器，状态为启动状态
- 守护式方式创建容器（后台运行)
```
docker run -di --name=容器名 [镜像名称]:[版本]
```
  进入命令行
```
docker exec -it [容器名/id] /bin/bash
```
退出当前容器
```
exit
```

拷贝主机文件到容器

docker cp [文件] [容器名/id]:[目录]

拷贝容器文件到主机

docker cp [容器名/id]:[文件路径] [copy文件重命名]

容器目录挂载（映射）

docker run -di -v [主机目录]:[容器目录] --name=容器名 [镜像名称]:[版本]

查看容器详细信息

docker inspect [容器名/id]

过滤信息

docker inspect --format='{{.[字段].[key]}}' [容器名/id]

Docker 应用部署 MySQL

查询 MySQL 镜像
```
docker search mysql
```
拉取 MySQL 镜像，以 MySQL 5.7 版本为例
```
docker pull mysql:5.7
```

创建 MySQL 容器

docker run -di --name=[容器名] -p [主机端口]:[容器端口] -e MYSQL_ROOT_PASSWROD=[管理员账户密码] [镜像名称]:[版本]

docker run -di --name=mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=root mysql:5.7

-di：守护方式创建容器

-p：主机与容器的端口映射

-e：直接设置容器的用户名密码

进入 MySQL 容器命令行

docker exec -it [容器名] /bin/bash

docker exec -it mysql /bin/bash

在 MySQL 容器中进行操作（以下命令皆是在==容器的命令行【root@b2494be91470:/#】==执行）
1. 登录 MySQL
```
mysql -uroot -proot --default-character-set=utf8
```
2. SQLYog 连接容器中的 MySQL
到此 MySQL 容器就部署完成了

Nginx

查询 Nginx 镜像
```
docker search nginx
```
拉取 Nginx 镜像
```
docker pull nginx
```

创建 Nginx 容器

docker run -di --name=[容器名] -p [主机端口]:[容器端口] [镜像名称]:[版本]

docker run -di --name=nginx -p 80:80 nginx

-di：守护方式创建容器

-p：主机与容器的端口映射

Windows 浏览器访问【主机IP地址:80 】
到此 Nginx 容器就部署完成了

修改 Nginx 容器的配置文件

将容器中的 nginx 目录复制到主机，改完再复制回去

docker cp [容器名/id]:[文件路径]

docker cp [文件] [容器名/id]:[目录]

将容器目录挂载到主机（需要在创建容器的时候挂载）

docker run -di --name=容器名 -p [主机端口]:[容器端口] -v [主机目录]:[容器目录]  [镜像名称]:[版本]

docker run -di --name=nginx -p 80:80 -v /usr/local/mydata/conf/:/etc/nginx nginx

Redis

查询 Redis 镜像
```
docker search redis
```
拉取 Redis 镜像
```
docker pull redis
```

创建 Redis 容器

docker run -di --name=[容器名] -p [主机端口]:[容器端口] [镜像名称]:[版本]

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

-di：守护方式创建容器

-p：主机与容器的端口映射

使用 Another Redis Desktop Manager 连接 Redis
1. 输入主机 IP 地址与容器映射的端口号，点击 OK
2. 成功连接，查看信息
到此 Redis 容器就部署完成了

修改 Redis 容器的配置文件

将容器中的 Redis 目录复制到主机，改完再复制回去

docker cp [容器名/id]:[文件路径]

docker cp [文件] [容器名/id]:[目录]

将容器目录挂载到主机（需要在创建容器的时候挂载）

docker run -di --name=容器名 -p [主机端口]:[容器端口] -v [主机目录]:[容器目录]  [镜像名称]:[版本]

RabbitMQ

查询 RabbitMQ 镜像
```
docker search rabbitmq
```
拉取 RabbitMQ 镜像（以 3.7.12 版本为例)
```
docker pull rabbitmq:3.7.12
```

创建 RabbitMQ 容器

docker run -di --name=[容器名] -p [主机端口]:[容器端口] [镜像名称]:[版本]

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

-di：守护方式创建容器

-p：主机与容器的端口映射

进入容器，启动 UI 插件

docker exec -it rabbitmq /bin/bash

rabbitmq-plugins enable rabbitmq_management

浏览器访问【主机IP地址:15672 】

登录
到此 RabbitMQ 容器就部署完成了

Elasticsearch

查询 Elasticsearch 镜像
```
docker search elasticsearch
```
拉取 Elasticsearch 镜像（以 7.5.0 版本为例)
```
docker pull elasticsearch:7.5.0
```
修改虚拟内存大小
```
sysctl -w vm.max_map_count=262144
```

创建 Elasticsearch 容器

docker run -di --name=elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e "cluster.name=elasticsearch" -v /usr/local/mydata/elasticsearch/plugins:/usr/share/elasticsearch/plugins elasticsearch:7.5.0

-e "discovery.type=single-node"：设置单节点

-e "cluster.name=elasticsearch"：设置集群名

进入 Elasticsearch 容器，安装 IK 分词器

docker exec -it elasticsearch /bin/bash

elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.5.0/elasticsearch-analysis-ik-7.5.0.zip

退出 Elasticsearch 容器，重启 Elasticsearch 容器
```
exit
```
```
docker restart elasticsearch
```
浏览器访问【主机IP地址:9200】
到此 Elasticsearch 容器就部署完成了

Zookeeper

查询 Zookeeper 镜像
```
docker search zookeeper
```
拉取 Zookeeper 镜像（以 3.4.13 版本为例)
```
docker pull zookeeper:3.4.13
```

创建 Zookeeper 容器

docker run -di --name=zookeeper -p 2181:2181 zookeeper:3.4.13

到此 Zookeeper 容器就部署完成了

迁移与备份

容器保存为镜像

docker commit [容器名] [保存的镜像名]

镜像备份

docker save -o [镜像备份名.tar] [镜像]

镜像恢复与迁移
```
docker load -i [镜像备份名.tar]
```

Docker 私有仓库私有仓库搭建与配置

拉取私有仓库镜像
```
docker pull registry
```
启动私有仓库容器
```
docker run -di --name=registry -p 5000:5000 registry
```
打开浏览器访问地址：【主机 IP:5000/v2/_catalog】

修改 daemon.json

vim /etc/docker/daemon.json

添加以下内容，保存退出

{"insecure-registries":["主机 IP:5000"]}

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

此步是用于让 docker 信任私有仓库地址

重启 Docker 服务
```
systemctl restart docker
```
启动 registry 容器
```
docker start registry
```

上传本地镜像

将本地镜像打包

docker tag [本地镜像名称]:[版本] [主机 IP:5000]/[镜像名]

docker tag mysql:5.7 192.168.3.39:5000/mysql

push 上传镜像到私有仓库

docker push [镜像名 REPOSITORY]

docker push 192.168.3.39:5000/mysql

浏览器访问地址：【主机 IP:5000/v2/_catalog】

Dockerfile

Dockerfile 是由一系列命令和参数组成的脚本文件。这些命令应用于基础镜像并最终创建一个新的镜像。

常用命令

命令	作用
FROM image_name:tag	定义了使用哪个基础镜像启动构建流程
MAINTAINER usr_name	声明镜像的创建者
ENV key value	设置环境变量
RUN command	是 Dockerfile 的核心部分
ADD source_dir/file dest_dir/file	将宿主机的文件复制到容器内，如果是一个压缩文件，则会在复制后自动解压
COPY source_dir/file dest_dir/file	和 ADD 类似，但是不解压压缩文件
WORKDIR path_dir	设置工作目录

制作 JDK1.8 镜像

首先，在 Linux 中创建一个 jdk8 目录，用来存放我们的 JDK 文件
```
mkdir -p /usr/local/jdk8
```
将 JDK8 的 *.tar.gz 包通过 XFTP 上传到 /usr/local/jdk8 目录下
在 /usr/local/jdk8 目录下，创建并编辑 Dockerfile 文件（也就是 JDK 包和 Dockerfile 需要在同一目录下）
```
vim Dockerfile
```
添加以下内容：
```
FROM centos:7
WORKDIR /usr
RUN mkdir /usr/local/java
ADD jdk-8u311-linux-x64.tar.gz /usr/local/java
ENV JAVA_HOME /usr/local/java/jdk1.8.0_311
ENV PATH $JAVA_HOME/bin:$PATH
```
- FROM centos:7：指定基础镜像为 Centos7
- WORKDIR /usr：工作目录
- RUN mkdir /usr/local/java：创建目录
- ADD jdk-8u311-linux-x64.tar.gz /usr/local/java：将 jdk8 包拷贝并解压到 /usr/local/java 目录
- ENV JAVA_HOME【ENV PATH】：配置环境变量
构建镜像
```
docker build -t='jdk1.8' .
```
. 表示当前目录，不能丢
等待 Docerfile 里的命令执行完成，构建成功

DockerMaven 插件进行微服务部署

DockerMaven 插件 Github 地址：https://github.com/spotify/docker-maven-plugin#specify-build-info-in-the-pom

微服务部署

手动部署：首先基于源码打包生成jar包（或war包）,将jar包（或war包）上传至虚拟机并拷贝至JDK容器

通过使用 Maven 插件实现自动部署，对于数量众多的微服务，手动部署非常麻烦且容易出错，所以建议使用自动部署。

步骤

总体步骤：

DockerMaven 先将项目打成 Jar 包
再将 Jar 包打包成 Image 镜像
之后将镜像上传到私有仓库
最后我们直接去 Doker 里面通过镜像创建容器去运行访问就可以了

修改主机配置

修改主机的 docker.service 文件，使其可以远程访问

vim /lib/systemd/system/docker.service

打开 docker.service 文件，将

ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock

修改为：

ExecStart=
ExecStart=/usr/bin/dockerd -H fd:// -H tcp://0.0.0.0:2375

重启服务
```
systemctl daemon-reload
```
重新启动 Docker
```
systemctl restart docker
```
启动私人仓库
```
docker start registry
```

修改防火墙规则

修改防火墙暴露 2375 端口（开放端口很重要，困了好久）

firewall-cmd --zone=public --add-port=2375/tcp --permanent #开放2375/tcp端口

更新防火墙，使防火墙设置生效
```
firewall-cmd --reload
```

查看防火墙开放端口

firewall-cmd --zone=public --list-ports

IDEA 插件配置

在 pom.xml 中添加 plugin 配置


    
        
            org.springframework.boot
            spring-boot-maven-plugin
        
        
            com.spotify
            docker-maven-plugin
            1.1.0
            
                
                    build-image
                    package	
                    
                        build
                    
                
            
            
                
                ${project.artifactId}:${project.version}
                
                http://192.168.3.39:2375
                
                jdk1.8
                
                ["java","-jar","-Dspring.profiles.active=dev","/${project.build.finalName}.jar"]
                
                
                    
                        /
                        ${project.build.directory}
                        ${project.build.finalName}.jar

执行 Maven 的 package 命令

等待打包完成
在宿主机上查看镜像
```
docker images
```
可以看到我们以项目名命名的镜像，版本为 pom.xml 中的版本

创建容器 test1，端口映射到 7070

docker run -di --name=test1 -p 7070:7070 dockertest:0.0.1-SNAPSHOT

浏览器访问【宿主机 IP:端口】即可以正常访问。

Docker 容器技术，让你不再为环境而烦恼

Linux相关栏目本月热门文章