Docker从初级到进阶看这一篇就够了_限器好fec28d

一、Docker的基本概念

1.1、镜像Image是一个封装好的静态的软件运行文件。（静态的镜像）

1.2、容器Container是基于某一个镜像正在运行的程序、服务。（动态容器）

比如SpringMVC项目依赖Tomcat、依赖JDK、JDK依赖操作系统
Docker的设计架构基于分层设计、通过分层的镜像达到课复用。分层设计师镜像之间的解耦。
1
2

二、Docker的安装

2.1、第一步：查看操作系统，获取ip

$ cat /etc/os-release
$ dhclient
1
2

2.2 、第二步：关闭Cent-OS操作系统

$ systemctl stop firewalld.service
$ systemctl disable firewalld.service
1
2

2.3、第三步：删除旧的版本

$ sudo yum remove docker  \
								docker-client  \
								docker-client-latest  \
								docker common  \
								docker latest  \
								docker-latest-logrotate  \
								docker-logrotate  \
								docker-engine
1
2
3
4
5
6
7
8

2.4、第四步：安装依赖包

$ yum install -y yum-utils device-mapper-persistent-data lvm2		
1

2.5、第五步：添加 标准仓库

$ yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo	
1

2.6、第六步：安装docker客户端，也是最重要最耗时的一步

$ yum install docker-ce docker-ce-cli containerd.io		
1

2.7、启动docker服务

$ systemctl start docker
$ systemctl enable docker.service
1
2

2.8、重启docker服务

$ systemctl restart docker
1

2.9、查看Docker 运行状态

$ systemctl status docker
# 关闭docker运行
$ systemctl stop docker
1
2
3

三、Docker的镜像

3.1、镜像简介：

①Docker的镜像类似一个壳子，对软件或项目进行标准化的封装。
②Docker的镜像由多个层构成，每层对应一个Dockerfile中的指令。
③一个软件可以构建多个版本的镜像。
④一个特定版本的镜像可构建多个不同名称的容器。
⑤一个唯一名称的容器可以运行一个服务。【容器等价于服务】
1
2
3
4
5

3.2、查找镜像

$ docker search mysql
1

3.3、拉取镜像

$ docker pull mysql...
#仓库可以自己配置，若不配置，则默认使用官方仓库(https://hub.docker.com/)
#**配置仓库的方法：
1
2
3

#配置仓库
	$ vi /etc/docker/daemon.json
	{
		"register-mirrors":["https://registry.docker-cn.com"]
	}

	#使变更生效
	$ systemctl daemon-reload
	
	#重启Docker 服务
	$ systemctl restart docker
	#也可以本地架构局域网HUB，或者配置国内的HUB镜像仓库。
1
2
3
4
5
6
7
8
9
10
11
12

3.4、基于镜像运行容器（运行改语句后会得到一个容器id）

#运行mysql带密码设置
$ docker run -p 3306:3306 --name dyg_mysql -e MYSQL_ROOT_PASSWORD=123456 -d docker.io/mysql
#运行nginx
$ docker run -p 80:80 --name mynginx -d nginx.io   (web通过80端口访问)
#--name：给运行的容器取名 
#-e：设置密码
#-d 表示可以后台运行（关闭shell窗口后仍然运行）
1
2
3
4
5
6
7

3.5、Docker、镜像、容器、HUB之间的关系图

3.6、查看历史镜像

$ docker history mysql(早期版本)
$ docker image history mysql
1
2

3.7、查看镜像详情

$ docker image inspect  nginx
1

3.8、删除多余镜像

#(加-f 强制删除：注意，此时镜像虽然被强制删除，但是运行的容器还在运行)
$ docker image rm -f nginx

3.9、标记镜像版本

 #k8s服务编排的时候
 #软件项目镜像化、标记版本的时候
1
2

	$ docker image tag <镜像的名称>:<镜像的tag>
	#改tag名
	$ docker image tag <镜像的名称>:<镜像的tag>  <新镜像的名称>:<新镜像的tag>
1
2
3

3.10、存储镜像

#离线情况下，想要把某些镜像保存成文件。复制转移。
#离线情况下，

#docker image save <镜像的名称>:<镜像的tag> > <文件的名称>
#> 表示重定向到什么位置
$ docker image nginx > nginx.tar

[root@localhost ~]# docker image save mynginx > mynginx.tar
[root@localhost ~]# ls
docker  mynginx.tar  opt  spark
[root@localhost ~]# du -sh mynginx.tar
140M    mynginx.tar
1
2
3
4
5

3.11、Docker 加载镜像

	# < 反向加载镜像
	$ docker image load < mynginx.tar 
1
2

3.12、Docker 导入镜像

#一般而言，导入镜像和导出镜像一起使用
#从镜像保存的.tar文件中导入镜像（注意：此处）
#导入后的镜像大小变大，说明导入镜像和加载镜像不一样，大小不一样
#docker image import <文件.tar>
1
2
3
4

3.13、image镜像关键词

[root@localhost ~]# docker image --help

Usage:  docker image COMMAND

Manage images

Options:
      --help   Print usage

Commands:
  build       Build an image from a Dockerfile
  history     Show the history of an image
  import      Import the contents from a tarball to create a filesystem image
  inspect     Display detailed information on one or more images
  load        Load an image from a tar archive or STDIN
  ls          List images
  prune       Remove unused images
  pull        Pull an image or a repository from a registry
  push        Push an image or a repository to a registry
  rm          Remove one or more images
  save        Save one or more images to a tar archive (streamed to STDOUT by default)
  tag         Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE

Run 'docker image COMMAND --help' for more information on a command.
[root@localhost ~]#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

四、Docker的容器

4.1、容器简介

#容器是基于镜像而生成的某个运行的任务，这个任务可以停止，也可以运行；
#*容器既可以是静态化的，也可以是动态运行的*。
1
2

4.2、容器和镜像的区别

#容器运行时的参数配置已经确定，*而且包含了程序运行时的更新数据*
#问：如果对MySQL新增了一张表，增加了N条数据，那么容器重启后，这些跟新数据还在么？
#答：还在（包含了程序运行时的更新数据）
#一般而言，我们不用容器跟新数据（保存持久化数据）。*按照无状态的规范使用容器。*，不用就直接销毁，用了重新生成，一些需要持久化的日志，容器销毁了，它也就销毁了。
1
2
3
4

4.3、Container容器关键词

[root@localhost ~]# docker container --help

Usage:  docker container COMMAND

Manage containers

Options:
      --help   Print usage

Commands:
  attach      Attach to a running container
  commit      Create a new image from a container's changes
  cp          Copy files/folders between a container and the local filesystem
  create      Create a new container
  diff        Inspect changes on a container's filesystem
  exec        Run a command in a running container
  export      Export a container's filesystem as a tar archive
  inspect     Display detailed information on one or more containers
  kill        Kill one or more running containers
  logs        Fetch the logs of a container
  ls          List containers
  pause       Pause all processes within one or more containers
  port        List port mappings or a specific mapping for the container
  prune       Remove all stopped containers
  rename      Rename a container
  restart     Restart one or more containers
  rm          Remove one or more containers
  run         Run a command in a new container
  start       Start one or more stopped containers
  stats       Display a live stream of container(s) resource usage statistics
  stop        Stop one or more running containers
  top         Display the running processes of a container
  unpause     Unpause all processes within one or more containers
  update      Update configuration of one or more containers
  wait        Block until one or more containers stop, then print their exit codes

Run 'docker container COMMAND --help' for more information on a command.
[root@localhost ~]#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

4.4、Docker运行容器，官方文档：https://docs.docker.com/engine/reference/commandline/container_run/

有了镜像，需要启动容器
	$ docker run [OPTIONS] IMAGE [COMMAND] [ARG...]	
	$ docker container run [OPTIONS] IMAGE [COMMAND] [ARG...]	
1
2
3

4.5、options

#-p 3306:3306暴露端口，做宿主机和容器端口映射
# -P 将容器内部的端口随机映射到宿主机
#–name：给运行的容器取名 ，名称唯一
# -e MYSQL_ROOT_PASSWORD=123456 #设置mysql的用户root的密码
#-d 表示可以后台运行（关闭shell窗口后仍然运行）
# -i 以交互模型运行容器，通常和-t一起使用
#-t 为容器分配一个伪终端
# --env-file #中文件中读取环境变量

#k8s扩容，docker的扩容
# --cpus 1  #设置容器可以使用多少个cpu
# -m 512m  #设置内存为512M

# --link  #添加链接到另一个容器，来发需要重点掌握

#  --expose  #开放、暴露一个端口出来

# --volume , -v  #绑定一个数据卷

#  --restart，默认为no  #配置容器的重启策略
#默认为no，容器退出时不重启
#  always  ,容器退出时，总是重启，docker重启了，配置的容器默认开机重启
#  on-failure  #容器非正常退出会重启
#  on-failure:4  #容器非正常退出会重启，重启四次
$  systemctl restart docker
#  unless-stoped  #容器退出时总是重启，但是docker重启了不会重启


$ docker run -it -p 3306:3306 --name dyg_mysql -e MYSQL_ROOT_PASSWORD=123456 -d docker.io/mysql
#如果不添加-d，会直接进入容器的伪终端，操控我们的容器
# docker run -it --name centos centos  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

[root@localhost ~]# docker run -it --name centos centos
[root@6a9500440eef /]# ls
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
[root@6a9500440eef /]#
1
2
3
4

4.6、显示容器

[root@localhost ~]# docker container ls  #标准指令
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                               NAMES
6a9500440eef        centos              "/bin/bash"              2 hours ago         Up 2 hours                                              centos
1278a2b6c7ad        nginx               "/docker-entrypoin..."   6 hours ago         Up 6 hours          0.0.0.0:80->80/tcp                  mynginx
1a17ddfb26d8        docker.io/mysql     "docker-entrypoint..."   8 hours ago         Up 8 hours          0.0.0.0:3306->3306/tcp, 33060/tcp   dygmysql
[root@localhost ~]# docker ps  #老版本指令
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                               NAMES
1278a2b6c7ad        nginx               "/docker-entrypoin..."   6 hours ago         Up 6 hours          0.0.0.0:80->80/tcp                  mynginx
1a17ddfb26d8        docker.io/mysql     "docker-entrypoint..."   8 hours ago         Up 8 hours          0.0.0.0:3306->3306/tcp, 33060/tcp   dygmysql
1
2
3
4
5
6
7
8
9

#显示所有容器，包括未运行的
	$ docker container ls  -a
	$ docker container ls  -all
	$ docker ps -a  #老版本指令
#显示正常容器
	$ docker container ls
1
2
3
4
5
6

五、docker容器日志

5.1、项目的开发、测试。运行的服务启动的成功或失败、查询日志，排障、验证

	# CONTAINER 容器的ID
	#容器的控制日志在宿主机的特定目录下
	$ docker container logs [OPTIONS] CONTAINER #老版本
	$ docker logs dygmysql  #新版，dygmysql为容器的名称
1
2
3
4

5.2、容器的日志地址

	$ /var/lib/docker/containers/<container*id*>
1

5.3、容器运行时间过长会占用磁盘，需要任务去清理

5.4、Docker 容器状态

$  docker container stats [OPTIONS] [CONTAINER...]
#显示正在运行的container的一些相关信息CPU 内存 网络
$ docker container stats  
1
2
3

六、Docker Nginx简介

6.1、Nginx反向代理、web静态服务器

6.2、**网页运行看到的index.html在容器里面

# docker container exec -it mynginx bash  #进入到容器里面（mynginx为容器name）
1

	[root@localhost ~]# docker container exec -it mynginx bash
	root@1278a2b6c7ad:/# cd /usr/share/nginx/html/
	root@1278a2b6c7ad:/usr/share/nginx/html# ls
	50x.html  index.html
	root@1278a2b6c7ad:/usr/share/nginx/html# cat index.html
	<!DOCTYPE html>
	<html>
	<head>
	<title>Welcome to nginx!</title>
	<style>
	html { color-scheme: light dark; }
	body { width: 35em; margin: 0 auto;
	font-family: Tahoma, Verdana, Arial, sans-serif; }
	</style>
	</head>
	<body>
	<h1>Welcome to nginx!</h1>
	<p>If you see this page, the nginx web server is successfully installed and
	working. Further configuration is required.</p>
	
	<p>For online documentation and support please refer to
	<a href="http://nginx.org/">nginx.org</a>.<br/>
	Commercial support is available at
	<a href="http://nginx.com/">nginx.com</a>.</p>
	
	<p><em>Thank you for using nginx.</em></p>
	</body>
	</html>
	root@1278a2b6c7ad:/usr/share/nginx/html#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

七、容器的启动、停止、创建

7.1、容器的启动

	$ docker run -p 80:80 --name mynginx -d nginx.io   (web通过80端口访问)
1

7.2、正在运行容器的显示

$ docker container ls
 docker container ls -a (显示所有已经运行和停止运行的容器)
1
2

7.3、删除多余的容器

$ docker rm -f mynginx2
1

7.4、容器的停止

$ docker container stop mynginx
1

7.5、重启已经停止的容器

$ docker container start mynginx
$ docker container restart mynginx
1
2

7.6、Docker创建容器（run和create的主要区别，就是一个会主动，另一个不会主动运行）

# mynginx2 创建了容器 + 运行容器
$ docker run -itd --name mynginx2 -p 8801:80 mynginx:v1  (web通过8801端口访问)

#创建容器（注意：不会自动运行）（返回创建的容器的id）
$ docker create -it --name mynginx2 -p 8802:80 mynginx:v1  (web通过8802端口访问)
1
2
3
4
5

八、容器进阶

8.1、容器详情信息

#运维、系统架构师，查看容器的信息（id、网络、数据卷的挂载信息）
#非常重要，可以查看数据卷信息，窥测到容器很多细节
# docker container inspect [OPTIONS] CONTAINER [CONTAINER...]
$ docker container inspect mynginx
$ docker inspect mynginx
1
2
3
4
5

"Mounts": [
            {
                "Type": "volume",
                "Name": "ebb9789d47ddc812c37e4ca2b4ce0661b75f0edd096afe3ebb7c492595db305e",
                "Source": "/var/lib/docker/volumes/ebb9789d47ddc812c37e4ca2b4ce0661b75f0edd096afe3ebb7c492595db305e/_data",
                "Destination": "/var/lib/mysql",
                "Driver": "local",
                "Mode": "",
                "RW": true,
                "Propagation": ""
            }
        ],
1
2
3
4
5
6
7
8
9
10
11
12

	"Name": 容器ID
	"Source": 数据库信息存放地址 #该文件路径可以共享给宿主机，防止删除容器后数据丢失
	"Destination":容器内部的路径
1
2
3

8.2、Docker更新容器

#update是实时生效的
#云计算（伸缩性非常好）
#开发、运维、测试、生产都可能对容器的CPU或者内存进行调整（扩容、收缩）
#线上的服务、也就是集群，也就是有多个容器，支持多个容器批量处理和提交
# docker container update [OPTIONS] CONTAINER [CONTAINER...]
#其中-m和 --cpus非常常见
1
2
3
4
5
6

Name, shorthand	Default	Description
--blkio-weight		Block IO (relative weight), between 10 and 1000, or 0 to disable (default 0)
--cpu-period		Limit CPU CFS (Completely Fair Scheduler) period
--cpu-quota		Limit CPU CFS (Completely Fair Scheduler) quota
--cpu-rt-period		Limit the CPU real-time period in microseconds
--cpu-rt-runtime		Limit the CPU real-time runtime in microseconds
--cpu-shares , -c		CPU shares (relative weight)
--cpus		Number of CPUs
--cpuset-cpus		CPUs in which to allow execution (0-3, 0,1)
--cpuset-mems		MEMs in which to allow execution (0-3, 0,1)
--kernel-memory		Kernel memory limit
--memory , -m		Memory limit
--memory-reservation		Memory soft limit
--memory-swap		Swap limit equal to memory plus swap: '-1' to enable unlimited swap
--pids-limit		API 1.40+
Tune container pids limit (set -1 for unlimited)
--restart		Restart policy to apply when a container exits
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#跟新内存
$ docker container update --memory 1024m --memory-swap 1028m dygmysql

# 注意：交换内存--memory-swap要比内存 --memory 大，否则报错
1

8.3、Docker 删除容器

#docker rm -f mynginx
1

8.4、删除所有的容器（不管有没有用）####仅限于开发和测试的时候使用

#docker container rm -f $(docker ps -a -q)
1

8.5、查看容器进程

$ docker container top mynginx3
1

[root@localhost mysql]# docker container top mynginx3
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                44590               44573               0                   01:43               ?                   00:00:00            nginx: master process nginx -g daemon off;
101                 44637               44590               0                   01:43               ?                   00:00:00            nginx: worker process
1
2
3
4

8.6、Docker 查看容器的端口

	#docker container port  mynginx3
1

8.7、Docker 进入容器

#方式一：
#attach表示将标准的输入输出附加到容器，容器前台正在运行任务，那么命令会被阻塞
#被阻塞表现为  进入容器被卡住了
$ docker container attach mynginx3  (实时显示运行产生的log)
#ctrl + p + q三个键退出，ctrl +c会关闭运行的容器，太暴力！！

#方式二  被推荐的方式
#执行容器内部的shell（会进入到nginx）
#Nginx的文件路径在 /usr/share/nginx/html
$ docker exec -it mynginx3 bash（不会显示运行产生的log）
$ docker exec -it mynginx3 sh （不建议使用）
1
2
3
4
5
6
7
8
9
10
11

[root@localhost mysql]# docker container exec -it mynginx3 bash
root@301b35ca9e0e:/# cd /usr/share/nginx/html
root@301b35ca9e0e:/usr/share/nginx/html# ls
50x.html  index.html
root@301b35ca9e0e:/usr/share/nginx/html#
1
2
3
4
5

8.8、Docker 复制文件到容器

#项目、宿主机和容器进行项目文件的复制
#docker cp [OPTIONS]  SRC_PATH <container名称> :DEST_PATH
#SRC_PATH 源文件
#DEST_PATH 容器内目录
$ docker cp dygnginx.html mynginx3:/usr/share/nginx/html
1
2
3
4
5

[root@localhost ~]# docker cp dygnginx.html mynginx3:/usr/share/nginx/html
[root@localhost ~]# docker container exec -it mynginx3 bash
root@301b35ca9e0e:/# ls
bin  boot  dev  docker-entrypoint.d  docker-entrypoint.sh  etc  home  lib  lib64  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
root@301b35ca9e0e:/# cd /usr/share/nginx/html
root@301b35ca9e0e:/usr/share/nginx/html# ls
50x.html  dygnginx.html  index.html
root@301b35ca9e0e:/usr/share/nginx/html#
1
2
3
4
5
6
7
8

8.9、Docker容器提交

	#将容器提交为一个镜像   ！！！**容器之前的变更都会保存到镜像内部**！！！
	# mynginx2 : 容器名称
	#mynginx666：要保存的镜像的名称
	#v666：要保存的惊险的版本
	$ docker commit mynginx2 mynginx666:v666
	#测试：根据生成的镜像生成并运行容器
	# docker run -itd -p 8088:80  --name nginx666 mynginx666:v666
1
2
3
4
5
6
7

[root@localhost ~]# docker commit mynginx3 mynginx3:v3
sha256:13e0f81fc1ddca2cc22b17b3701b4fc2dda811cfd4b60a272fad0482b395ada8
[root@localhost ~]# docker run -itd -p 8089:80  --name nginx333 mynginx3:v3
7b63db926ae0c24ff5767bcaad6bcc3bd378361bbf0c3038c3e56efb7e0a0a3d
[root@localhost ~]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                               NAMES
7b63db926ae0        mynginx3:v3         "/docker-entrypoin..."   5 seconds ago       Up 5 seconds        0.0.0.0:8089->80/tcp                nginx333
c455b1172476        mynginx2:v2         "/docker-entrypoin..."   2 minutes ago       Up 2 minutes        0.0.0.0:8088->80/tcp                nginx666
301b35ca9e0e        docker.io/nginx     "/docker-entrypoin..."   About an hour ago   Up 56 minutes       0.0.0.0:80->80/tcp                  mynginx3
4ec81bc5d361        docker.io/nginx     "/docker-entrypoin..."   About an hour ago   Up About an hour    0.0.0.0:8081->80/tcp                mynginx1
f37185812c31        docker.io/nginx     "/docker-entrypoin..."   About an hour ago   Up About an hour    0.0.0.0:8082->80/tcp                mynginx2
4aa80735f9e7        docker.io/mysql     "docker-entrypoint..."   About an hour ago   Up About an hour    0.0.0.0:3306->3306/tcp, 33060/tcp   mymysql
[root@localhost ~]#
1
2
3
4
5
6
7
8
9
10
11
12
13

九、数据卷

#使用场景：U盘插入电脑的时候，会显示提示符，这个提示符就是一个数据卷
#数据卷是将一个外来的存储设备接入当前的系统
#Docker容器是一种动态伸缩、即开即用的的技术。这个特征（飘）决定了容器不适合做数据持久化！！！！！！！！！！！！！

#实际工作场景：MYSQL数据库的事务需要持久化、项目的线上日志持久化（日志是定责、排障的重要依据）（日志放到数据库中，性能非常差，也不划算，所以基本不用）

#docker必须具备持久化的能力！！！！！！！！！！
#数据卷就是用来做应用程序数据持久化的！！！！！！！！！！
#将宿主机的数据接入（挂载）到容器。（*宿主机和容器数据共享*，容器销毁后宿主机的数据还保留）
1
2
3
4
5
6
7
8
9

9.1、Docker提供了三种数据卷：

①Volumes：数据卷。
#由 Docker（/var/lib/docker/volumes/在 Linux 上）管理的主机文件系统的一部分中。非 Docker 进程不应修改文件系统的这一部分。卷是在 Docker 中持久化数据的最佳方式。

②Bind mounts：绑定挂载。
#可以存储在主机系统的任何位置。它们甚至可能是重要的系统文件或目录。Docker 主机或 Docker 容器上的非 Docker 进程可以随时修改它们。

③tmpfs ：数据放在宿主机内存。
#挂载仅存储在主机系统的内存中，永远不会写入主机系统的文件系统。
1
2
3
4
5
6
7
8

#由上图可知volumes和bind mounts数据都存储在文件系统（宿主机）,volumes是官方推荐的数据卷形式
#volumes类似于宿主机和容器之间的数据共享，bind mounts类似于宿主机对容器数据的覆盖
#volumn共享数据在文件系统的docker自己管理的区域【持久化、自由度小，安全】
#bind mount共享数据存储在文件系统【持久化、自由度大，不安全】
#tmpfs 共享数据放在内存、而不是主机的文件系统【不持久、大数据量的共享不合适】
1
2
3
4
5

使用volumes能读到1.file和2.file，而使用bind mounts的时候，只能读到2.file（2.file会把1.file覆盖，见下图）

9.2、Docker 新增和管理volumes

#volume由docker管理的区域

#创建volume
$ docker volume create my-volume

#显示所有的volume
$ docker volume ls

#删除全部的volume
$ docker volume rm $(docker volume ls -q)

# inspect一个volume
$ docker volume inspect my-vol
1
2
3
4
5
6
7
8
9
10
11
12
13

[root@localhost ~]# docker volume inspect my-volume2
[
    {
        "Driver": "local",
        "Labels": {},
        #挂载点volume宿主机的位置
        "Mountpoint": "/var/lib/docker/volumes/my-volume2/_data",
        "Name": "my-volume2",
        "Options": {},
        "Scope": "local"
    }
]
1
2
3
4
5
6
7
8
9
10
11
12

9.3、Docker 挂载容器

#volume和容器共享数据
#挂载容器是在容器创建和与运行的时候完成的，下面这个过程会挂载容器

#第一种  --mount的形式，官方推荐
#source=myvolume3  (volume的名称)
#target=/usr/share/nginx/html 容器的存储路径
$ docker run -p 8803:80 -d --name mynginx3 --mount source=myvolume3,target=/usr/share/nginx/html nginx:latest

#第二种  -v的形式，一般使用的频率更高
$ docker run -d --name mynginx4 -p 8804:80 -v myvolume4:/usr/share/nginx/html nginx:latest

#使用volume之后，可以使用宿主机管理数据卷
#共用数据卷，形成集群！！！！！！！！！！！！！！
$ docker run -d --name mynginx3 -p 8803:80 -v myvolume1:/usr/share/nginx/html nginx:latest
1
2
3
4
5
6
7
8
9
10
11
12
13
14

[root@localhost volumes]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                               NAMES
dd5d3b2a696e        nginx:latest        "/docker-entrypoin..."   2 minutes ago       Up 2 minutes        0.0.0.0:8083->80/tcp                mynginx3
80c05936bd7a        nginx:latest        "/docker-entrypoin..."   2 hours ago         Up 2 hours          0.0.0.0:8802->80/tcp                mynginx2
f163d410e4a8        docker.io/mysql     "docker-entrypoint..."   3 hours ago         Up 3 hours          0.0.0.0:3306->3306/tcp, 33060/tcp   dyg_mysql
34c1469c65ac        nginx:latest        "/docker-entrypoin..."   3 hours ago         Up 3 hours          0.0.0.0:8801->80/tcp                mynginx1
[root@localhost volumes]# docker volume ls
DRIVER              VOLUME NAME
local               e164b4b4fec56b0f991c090042a88e12f2e96ae9fd762c0798c37428acb1e662
local               mynginx1
local               mynginx2
[root@localhost volumes]#
1
2
3
4
5
6
7
8
9
10
11
12

[root@localhost share]# docker exec -it mynginx3 bash
root@dd5d3b2a696e:/# cd /usr/share/nginx/html/
root@dd5d3b2a696e:/usr/share/nginx/html# ls
50x.html  index.html  mynginx2.html
root@dd5d3b2a696e:/usr/share/nginx/html# exit
exit
[root@localhost share]# docker exec -it mynginx2 bash
root@80c05936bd7a:/# cd /usr/share/nginx/html/
root@80c05936bd7a:/usr/share/nginx/html# ls
50x.html  index.html  mynginx2.html
root@80c05936bd7a:/usr/share/nginx/html#
1
2
3
4
5
6
7
8
9
10
11

#如上图所示，有容器mynginx2和mynginx3，但只有数据卷mynginx2，此时容器mynginx2和mynginx3共享一个数据卷mynginx2，由此Nginx构建了一个静态网站的集群，共享了项目代码！！

9.4、Docker Volume默认的Volume目录

# Docker管理的默认目录 ：/var/lib/docker/volumes			
#查看Volume信息，数据共享，操作目录/var/lib/docker/volumes
1
2

[root@localhost volumes]# docker volume inspect mynginx2
[
    {
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/mynginx2/_data",
        "Name": "mynginx2",
        "Options": {},
        "Scope": "local"
    }
]
1
2
3
4
5
6
7
8
9
10
11

9.5、Bind mounts 绑定挂载

#容器、宿主机数据共享
1

#官方提供了两个指令的两种方式 -v 和--mount
#--mount类型，需要创建源路径，否则会报错
# -v的bind类型，会自动创建源路径
#bind mounts的--mount语法，跟随的是源路径，
$ docker run -d --name mynginx4 -p 8804:80 --mount type=bind,source=/root/mynginx4,target=/usr/share/nginx/html nginx:latest

#bind mounts的-v语法，跟随的是源路径，这是和Volume的本质和唯一区别
$ docker run -d --name mynginx5 -p 8805:80 -v /root/nginx5:/usr/share/nginx/html nginx:latest

#Volume的-v语法，跟随的是Volume名称
$ docker run -d --name mynginx1 -p 8802:80 -v myvolume1:/usr/share/nginx/html nginx:latest
#容器会读取到宿主机目录已有的静态文件
1
2
3
4
5
6
7
8
9
10
11
12

9.6、Docker Tmpfs数据卷

#将容器的数据存储到宿主机的内存中，不会持久化（不会被写到文件系统，类似于不会持久化的Redis）。
#官方没有继续对tepfs的功能做优化
#tmpfs基于内存共享，效率高(容器的全局缓存，非常高效)
#两种方式:--mount 和--tmpfs
#docker run -d -it --name tmptest --mount type=tmpfs,destination=/app nginx:latest
#docker run -d -it --name tmptest --tmpfs /app nginx:latest
1
2
3
4
5
6

十、Docker网络

10.1、网络类型：

# --net 设置容器的网络 有四个枚举 bridge、host、none、container。默认的是bridge
#从大的角度来讲，分为单机网络和集群网络两种。
1
2

10.1、 单机网络：一个Docker守护程序下，外部请求容器、容器间网络请求的网络环境，和linux主机的任何应用是平权的。

10.1.1、 Host主机模式：容器和主机使用相同的网卡，使用相同的ip，共用端口范围（容器间ip相同，但是端口不同，如下图）。

#以host模式运行容器
$docker run -itd --net host mynginx7 nginx:latest
1
2

10.1.2、 Container模式（也就是容器1和已有的容器1做host模式）

# 第一步：已经有容器1
#第二段：针对某个容器使用容器模式（容器2和容器1使用相同的ip，分享所有的端口段）
#从属容器2和主容器1之间构成Host模式
1
2
3

# 第一步:以mynginx1作为主容器：docker inspect mynginx1查看Nginx
的ip为172.16.0.2

# 第二步：新增从属容器
# 新增从属容器
# container 容器模式的关键字
# container：主容器的名称
$docker run -itd --net container:mynginx1 --name centos1 centos

#第三步：进入从容器，查看从容器的ip地址，验证从容器ip也为172.17.0.2
$docker container exe -it centos1 bash
[root@localhost ~]# docker exec -it centos1 bash
[root@50929943cab0 /]# ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
53: eth0@if54: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default
    link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
       valid_lft forever preferred_lft forever
[root@50929943cab0 /]#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

10.1.3、 None 无网络模式：Docker容器没有网卡、ip、路由信息，容器和外部网络相互隔离，非常安全。

#以None模式运行容器
$docker run -itd --net host mynginx7 nginx:latest
1
2

10.1.4、 Bridge 桥接模式

#网桥的作用：网桥是一个局域网和另一个局域网互通的中间设备。
1

10.2、 集群网络：集群下，外部请求容器、容器间网络请求的网络环境（集群篇章讲）。

10.2.1、 Docker自定义网络

（虚拟了一个局域网，属于单机网络，自定义网络属于桥接类型的驱动）
```powershell
	第一步：新增自定义网络
	# selfnetwork1：自定义网络名称
	#172.18.0.0/16  :虚拟了一个局域网
	$ docker network create --subnet=172.18.0.0/16  selfnetwork1
		
	```
1
2
3
4
5
6
7
8

[root@localhost ~]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
44a373ed3958   bridge    bridge    local
4e98e0b662b6   host      host      local
950f43cabb22   none      null      local
201c8c40b2c4   spark     bridge    local
[root@localhost ~]# docker network create --subnet=172.18.0.0/16  selfnetwork1
3eb1809fc83a4c78b04f5dd608512e9f2aa817cf75760a2c7070f013f11aef92
[root@localhost ~]# docker network ls
NETWORK ID     NAME           DRIVER    SCOPE
44a373ed3958   bridge         bridge    local
4e98e0b662b6   host           host      local
950f43cabb22   none           null      local
3eb1809fc83a   selfnetwork1   bridge    local
201c8c40b2c4   spark          bridge    local
[root@localhost ~]#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

10.2.2、 查看网络连接情况

$ docker network inspect selfnetwork1   
1

10.2.3、 容器加入到自定义网络

$ docker network connect --ip 172.18.0.10 --alias selfnetwork_test selfnetwork1  mynginx1
1

	#selfnetwork_test 联合网络名称
	#selfnetwork1  自定义网络名称
	#mynginx1 容器名称
[root@localhost ~]# docker network connect --ip 172.18.0.10 --alias selfnetwork_test selfnetwork1  mynginx1
1
2
3
4

#docker inspect mynginx1 ，发现容器mynginx1有两个网络，也就是容器可以有多个网络
1

10.2.4、 移除容器的网络

#docker network disconnect selfnetwork1  mynginx1	
1

10.2.5、 删除自定义网络

#docker network rm selfnetwork1  
1

10.2.6、 创建自定义网络

# docker network create --driver bridge net100
1

10.2.7、 运行自定义网络

# docker run -itd mynginx2 --network net100
1

十一、Dockerfile

#Docker的应用是跨语言的、标准化的。通过应用做成镜像，使用标准的指令来管理这一群镜像，它给所有的App提供一个标准的壳子【Docker真正实现了所见即所得】【天然支持微服务（服务治理）、支持跨语言的服务】
1

Dockerfile文件，这个文件使用将App/应用/项目制作成镜像。

	#Docker脚本，Shell脚本，Python脚本，PHP脚本，Lua脚本，Perl脚本，都有自己独立的语法体系。
	#学习新的语言：Dockfile脚本语言。
1
2

11.1、Dockerfile关键字

#Dockerfile基于关键字+命令
1

11.2、Dockerfile Centos例子

		#编写dockerfile，构建镜像，基于Centos来ping 127.0.0.1
1

日志输出：

	#构建镜像的依赖镜像	
	FROM centos
	maintainer my-test
	LABEL owner='test.deng'
	RUN mkdir /root/deng
	COPY test /var/www/copy/test
	ADD test /var/www/add/
	VOLUME ["/var/www/add"]
	EXPOSE 80
	ENV CURRENT_PATH /root
	WORKDIR $CURRENT_PATH
	RUN pwd
	ENTRYPOINT ["ping"]
	ARG url=127.0.0.1
	CMD ["127.0.0.1"]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

11.3、 如何通过Dockerfile构建镜像

第一步：编写Dockerfile文件
第二步：将Dockerfile上传到Centos当前目录
第三步：执行 docker build
	#docker build有三种语法
	
	#第一种，一般不用
	#docker build .
	
	#第二种，Dockerfile文件在当前目录，比较常用【推荐】
	#-t my/ping:v1  镜像的名称和版本
	# docker build -t myimage/ping:v1 .	

	#第三种， -f指定Dockerfile文件目录，比较常用【推荐】
	#docker build -f /root/Dockerfile -t myimage/ping:v1 .
	#第四步，查看镜像
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

[root@localhost ~]# docker build -f /root/Dockerfile -t my/ping:v1 .
Sending build context to Docker daemon  36.35kB
Step 1/14 : FROM centos  #源自哪个镜像
 ---> 5d0da3dc9764
Step 2/14 : maintainer my-test  #标注作者
 ---> 6ef17df12c3f
Step 3/14 : LABEL owner='test.deng'  #标注owner
 ---> 532a338ebb38
Step 4/14 : RUN mkdir /root/deng  
 ---> f684ec38432d
Step 5/14 : COPY test /var/www/copy/test
 ---> 85c9657c3029
Step 6/14 : ADD test /var/www/add/
 ---> 2e2629ed0d0c
Step 7/14 : VOLUME ["/var/www/add"]
 ---> Running in 6a4c57434e99
Removing intermediate container 6a4c57434e99
 ---> 792fa939d250
Step 8/14 : EXPOSE 80
 ---> Running in 654260b6c394
Removing intermediate container 654260b6c394
 ---> 727ec6491293
Step 9/14 : ENV CURRENT_PATH /root
 ---> Running in de76ae474cd1
Removing intermediate container de76ae474cd1
 ---> 24ee625fdfb9
Step 10/14 : WORKDIR $CURRENT_PATH
 ---> Running in 4a301f83dcc3
Removing intermediate container 4a301f83dcc3
 ---> a55a6048d162
Step 11/14 : RUN pwd
 ---> Running in 02b63594c92c
/root
Removing intermediate container 02b63594c92c
 ---> de261e63afee
Step 12/14 : ENTRYPOINT ["ping"]
 ---> Running in 4866b6147057
Removing intermediate container 4866b6147057
 ---> 53848af3591c
Step 13/14 : ARG url=127.0.0.1
 ---> Running in f6a099946712
Removing intermediate container f6a099946712
 ---> 5e429d168345
Step 14/14 : CMD ["127.0.0.1"]
 ---> Running in 278be43558cb
Removing intermediate container 278be43558cb
 ---> f8d2e1998d47
Successfully built f8d2e1998d47
Successfully tagged my/ping:v1
[root@localhost ~]# docker images
REPOSITORY   TAG       IMAGE ID       CREATED         SIZE
my/ping      v1        f8d2e1998d47   2 minutes ago   231MB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

#相同的内容打多个镜像
#docker build -t shykes/myapp:1.0.2 -t shykes/myapp:latest .
1
2

十二、Docker仓库

#仓库是用来流传镜像的	
1

12.1、从仓库拉取下载镜像

$docker pull redis
1

12.2 、推送镜像到仓库，类似Git【公有Lab GITHUB】【公司自己搭建的GitLab】

·公有仓库 https://hub.docker.com/ 存放了全世界开放的镜像
·私有仓库
$docker push redis
第一步：准备一个待推动的镜像【myimage:v1】

第二步：在Docker软件中登录官方仓库
#docker login

#第三步：给镜像打标签，生成新的适配的官方仓库的镜像
#复制原有镜像，并重命名
#docker tag <原镜像> <新镜像>
# myimage 可以理解为hub.docker.com官方的用户名，也可以理解为命名空间
$docker tag nginx:latest 343000/myimage:v1
#第四步：推送镜像到官方仓库 hub.docker.com
$ docker push 343000/myimage:v1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15