Docker 虚拟化技术学习笔记

这是根据B站 遇见狂神说 Docker 的学习笔记

需要学习的Docker的技术

• Docker概述

• Docker安装

• Docker命令

  • 镜像命令
  • 容器命令
  • 操作命令

• Docker镜像

• Docker数据卷

• DockerFile

• Docker网络原理

• IDEA中整合Docker

• Docker Compose(集群)

• Docker Swarm

• CI\CD jenkins

注意事项：

在win10中安装docker的时候，会自动启用hyperV，但VMware无法使用HyperV启动虚拟机，会导致虚拟机无法使用

解决方法：

• 当使用Docker For Window，且不使用VMware时，请以管理员身份运行PowerShell，并输入 命令：

  bcdedit /set hypervisorlaunchtype auto
  

  然后重启电脑；此时Docker For Window运行Ok。

• 当需要WMware而不是用Docker For WIndow时，请以管理员身份运行PowerShell，并输入 命令：

  bcdedit /set hypervisorlaunchtype off 
  

  回车，然后重启电脑；此时WMware运行Ok。

每次修改后都得需要重启电脑，这么麻烦，那我还是直接在虚拟机使用docker吧，哈哈

Docker 概述

Docker为什么会出现：

为了解决“在我的电脑上运行是正常的”等问题，解决程序在不同环境中出现的问题

传统的部署方式：开发jar包，运维来部署

现在的部署方法：开发打包部署上线，一套流程就可以完成整个部署过程

Docker 解决的问题：

JRE：多个应用之间可能会有端口冲突，使用Docker安装即可用（Tomcat、mysql等内容）

隔离：Docker的核心思想，每个箱子是相互隔离的

本质上：所有的技术都是因为出现了一些问题，我们需要去解决才会去学习

虚拟机：在一台电脑上使用虚拟机软件虚拟出多台电脑中；虚拟机也是属于虚拟化技术，也是一种虚拟化技术。

容器：隔离，镜像（最核心的镜像一般都很小，一般是4M左右）

Docker是基于Go语言开发的，

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

Docker的文档地址：https://docs.docker.com/

Docker的仓库地址：https://hub.docker.com/

Docker能做些什么

虚拟机的缺点：

1. 资源占用十分多
2. 冗余步骤多
3. 启动很慢

容器化技术：并不是模拟的整个操作系统，而是形成一个个容器，相互之间互不干扰

虚拟机和容器的比较：

• 传统的虚拟机模拟的是整个硬件换件，然后在这个系统上安装和运行软件
• 容器内容的应用直接运行在宿主机中，容器没有自己的内核，也不模拟硬件，占用的资源小
• 容器之间相互隔离，每个容器中都有一个属于自己的文件系统，互不影响

DevOps(开发、 运营）：应用更加快捷的交付和部署

Docker：打包镜像发布测试，一键运行

更加便捷的升级和扩缩容

更加简单的系统运维

容器化之后，我们的开发，测试环境都是高度一致的

更加高效的计算资源利用

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

Docker的安装

Docker的基本组成

镜像(image)：

docker 镜像是一个模板，通过这个模板创建容器服务，通过这个镜像可以创建多个容器（最终服务运行和项目运行都是在容器中）

容器：

Docker利用容器技术，独立运行一个或者一组应用，通过镜像来创建，容器可以理解为一个精简版的虚拟机系统。

仓库：

仓库就是用来防止镜像的地方，（就像 git的仓库）

仓库同样分为公有仓库和私有仓库，默认的仓库是位于国外的，国内可以使用阿里云容器服务器。

安装Docker

环境准备：

1、 需要Linux基础

2、 需要Linux环境

安装

1. 卸载旧版本的Docker，Docker需要centos版本以上的Linux内核

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

2. 安装软件

   sudo yum install -y yum-utils
   

3. 设置镜像仓库

   # 国外版的仓库镜像，速度十分缓慢
   sudo yum-config-manager \
       --add-repo \
       https://download.docker.com/linux/centos/docker-ce.repo
       
   # 阿里云版本的镜像，速度较为快一些
   sudo yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
   

4. 安装Docker引擎

   docker-ce : 社区版本 docker-ee：商业版

   # 更新到最新版本
   sudo yum makecache fast
   # 安装docker-ce
   sudo yum install docker-ce docker-ce-cli containerd.io
    
    # 或者安装指定版本的docker版本
    sudo yum install docker-ce-<VERSION_STRING> docker-ce-cli-<VERSION_STRING> containerd.io
   

5. 启动docker

   systemctl start docker
   

   • 使用docker version查看具体的docker版本信息

   [root@centos-2 ~]# docker version
   Client: Docker Engine - Community
    Version:           19.03.12
    API version:       1.40
    Go version:        go1.13.10
    Git commit:        48a66213fe
    Built:             Mon Jun 22 15:46:54 2020
    OS/Arch:           linux/amd64
    Experimental:      false
   
   Server: Docker Engine - Community
    Engine:
     Version:          19.03.12
     API version:      1.40 (minimum version 1.12)
     Go version:       go1.13.10
     Git commit:       48a66213fe
     Built:            Mon Jun 22 15:45:28 2020
     OS/Arch:          linux/amd64
     Experimental:     false
    containerd:
     Version:          1.2.13
     GitCommit:        7ad184331fa3e55e52b890ea95e65ba581ae3429
    runc:
     Version:          1.0.0-rc10
     GitCommit:        dc9208a3303feef5b3839f4323d9beb36df0a9dd
    docker-init:
     Version:          0.18.0
     GitCommit:        fec3683
   
   

6. 运行docker hello world

   首先判断是否存在这个镜像，如果不存在，那么从远程仓库中拉取hello-world仓库

   # docker run hello-world
   

7. 查看下载的镜像

   docker images
   

8. 卸载docker镜像

   1. 卸载安装的软件
   2. 移除安装目录

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

Docker的底层原理

Docker如何工作的

Docker是一个client-server机构的系统。Docker的守护进程运行在主机上，通过Socket从客户端访问。

DockerServer接收到Docker-Client指令，会执行这个指令！

Docker为什么比虚拟机快？

1、Docker有比虚拟机更少的抽象层

2、Docker利用的是宿主机的内核，vm需要的是Guest OS，

所以说，新建一个容器的时候，docker不需要像虚拟机一样重新加载一个操作系统的内核，避免引导。虚拟机加载Guest Os，运行时间是分钟级别的；docker是利用宿主机的操作系统，忽略了这个复杂的过程，运行时间是秒级的。

Docker 的基础命令

帮助命令

docker version 	#显示docker的版本信息
docker info		# 显示docker的系统信息，包括镜像和容器的数量
docker --help 	# 帮助命令

镜像命令

docker images

使用帮助命令查看所有的images命令

# docker images --help

Usage:	docker images [OPTIONS] [REPOSITORY[:TAG]]

List images

Options:
  -a, --all             # 列出所有的镜像
      --digests         Show digests
  -f, --filter filter   Filter output based on conditions provided
      --format string   Pretty-print images using a Go template
      --no-trunc        Don't truncate output
  -q, --quiet           # 只显示镜像id

1. docker images 命令

   # docker images
   REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
   hello-world         latest              bf756fb1ae65        6 months ago        13.3kB
   
   
   ========================命令解释=====================
   REPOSITORY： 镜像的仓库
   TAG：镜像的标签
   IMAGE ID：镜像的id
   CREATED：镜像的创建时间
   SIZE：镜像的大小
   
   
   

2. docker search 搜索镜像

   help列出所有的可选命令

   [root@centos-2 ~]# docker search --help
   
   Usage:	docker search [OPTIONS] TERM
   
   Search the Docker Hub for images
   
   Options:
     -f, --filter filter   Filter output based on conditions provided
         --format string   Pretty-print search using a Go template
         --limit int       Max number of search results (default 25)
         --no-trunc        Don't truncate output
   
   

   查找mysql

   [root@centos-2 ~]# docker search mysql
   NAME                              DESCRIPTION                                     STARS               OFFICIAL            AUTOMATED
   mysql                             MySQL is a widely used, open-source relation…   9770                [OK]                
   
   
   # 可选项，通过收藏进行过滤
   docker search mysql --filter=STARS=3000		#可以搜索出stars大于3000的选项
   

3. dockers pull

   help命令

   [root@centos-2 ~]# docker pull --help
   
   Usage:	docker pull [OPTIONS] NAME[:TAG|@DIGEST]
   
   Pull an image or a repository from a registry
   
   Options:
     -a, --all-tags                Download all tagged images in the repository
         --disable-content-trust   Skip image verification (default true)
         --platform string         Set platform if server is multi-platform capable
     -q, --quiet                   Suppress verbose output
   
   

   下载mysql镜像

   # 下载镜像：docker pull 镜像名[:tag]
   [root@centos-2 ~]# docker pull mysql
   Using default tag: latest 		# 如果不写tag，那么默认下载latest
   latest: Pulling from library/mysql	# 
   6ec8c9369e08: Pull complete 	# 分层下载，docker image的核心就是联合文件系统
   177e5de89054: Pull complete 
   ab6ccb86eb40: Pull complete 
   e1ee78841235: Pull complete 
   09cd86ccee56: Pull complete 
   78bea0594a44: Pull complete 
   caf5f529ae89: Pull complete 
   cf0fc09f046d: Pull complete 
   4ccd5b05a8f6: Pull complete 
   76d29d8de5d4: Pull complete 
   8077a91f5d16: Pull complete 
   922753e827ec: Waiting 
   
   
   # 指定版本信息
   [root@centos-2 ~]# docker pull mysql：5.6	#版本号需要在docker仓库中允许
   

4. 删除命令： docker rmi -f 镜像id

   # 删除单个镜像
    docker rmi -f  镜像id
    
    # 删除多个镜像
    docker rmi -f 镜像id  镜像id  镜像id
    docker rmi -f $(docker images -aq)		#删除所有的镜像
   

容器命令

说明：有了镜像才能创建容器，下载一个centos镜像作为练习

docker pull centos

新建容器并启动

docker run [可选参数] image

# 可选参数
--name Name 	容器名字 Tomcat01等
--d 			后台运行
--it			使用交互模式运行，进入容器查看内容
--p				指定容器端口  -p 8080:8080
	-ip:主机端口：容器端口
	-p 主机端口：容器端口（常用的方式）
	-p 容器端口
-p				随机指定端口

启动主机,主机名就是容器id

[root@centos-2 ~]# docker run -it centos /bin/bash	#这是一个基础的版本，许多命令不存在
[root@397571d3a5ef /]# exit		#退出

查看运行容器的命令:

docker ps	
docker ps -a 		#查看曾经运行过的程序

docker ps全部的命令：

[root@centos-2 ~]# docker ps --help

Usage:	docker ps [OPTIONS]

List containers

Options:
  -a, --all             Show all containers (default shows just running)
  -f, --filter filter   Filter output based on conditions provided
      --format string   Pretty-print containers using a Go template
  -n, --last int        Show n last created containers (includes all states) (default -1)
  -l, --latest          Show the latest created container (includes all states)
      --no-trunc        Don't truncate output
  -q, --quiet           Only display numeric IDs
  -s, --size            Display total file sizes

退出容器

exit   # 停止容器并退出
ctrl + P + q  # 退出容器不停止

删除容器

docker rm 容器id		#删除单个镜像，不能删除正在运行的容器，如果需要强制删除 rm -f
docker rm -f $(docker ps -aq)	#删除所有的进行
docker ps -a -q | xargs docker rm  #删除所有的容器

启动和停止容器

docker start 容器id	#启动容器
docker restart 容器id	#重新启动容器
docker stop 容器id	#停止容器
docker kill 容器id	#杀死容器

Docker的其他命令

后台启动容器：

docker run -d 容器名   #返回容器的id
# 使用docker ps 发现容器停止了
# docker 使用后台运行，必须有一个前台进程，docker发现没有应用会自动停止，

[root@centos-2 ~]# docker run -d centos /bin/sh  -c "while true; do echo hello;sleep 1;done"
3b244f33c79dc16b9f8956405a7c3553df5f01141189bcf0d90228fa17d213bc

查看日志：

docker logs

# 使用help
[root@centos-2 ~]# docker logs --help

Usage:	docker logs [OPTIONS] CONTAINER

Fetch the logs of a container

Options:
      --details        Show extra details provided to logs
  -f, --follow         Follow log output
      --since string   Show logs since timestamp (e.g. 2013-01-02T13:23:37) or relative (e.g. 42m for 42 minutes)
      --tail string    Number of lines to show from the end of the logs (default "all")
  -t, --timestamps     Show timestamps
      --until string   Show logs before a timestamp (e.g. 2013-01-02T13:23:37) or relative (e.g. 42m for 42 minutes)

查看日志

docker logs -tf --tail 10 容器id

Docker进程信息

显示docker中的进程信息

[root@centos-2 ~]# docker top --help
Usage:	docker top CONTAINER [ps OPTIONS]
Display the running processes of a container

使用方法：

docker top 容器id

Docker 查看容器内部信息

查看容器的内部信息

[root@centos-2 ~]# docker inspect --help

Usage:	docker inspect [OPTIONS] NAME|ID [NAME|ID...]

Return low-level information on Docker objects

Options:
  -f, --format string   Format the output using the given Go template
  -s, --size            Display total file sizes if the type is container
      --type string     Return JSON for specified type

使用命令：

[root@centos-2 ~]# docker inspect 3b244f33c79d
[
    {
        "Id": "3b244f33c79dc16b9f8956405a7c3553df5f01141189bcf0d90228fa17d213bc",
        "Created": "2020-07-27T23:14:11.789091289Z",
        "Path": "/bin/sh",
        "Args": [
            "-c",
            "while true; do echo hello;sleep 1;done"
        ],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
.....

进入当前运行的容器的命令

容器一般使用后台方式运行，需要进入容器，修改一些设置

[root@centos-2 ~]# docker exec --help

Usage:	docker exec [OPTIONS] CONTAINER COMMAND [ARG...]

Run a command in a running container

Options:
  -d, --detach               Detached mode: run command in the background
      --detach-keys string   Override the key sequence for detaching a container
  -e, --env list             Set environment variables
  -i, --interactive          Keep STDIN open even if not attached
      --privileged           Give extended privileges to the command
  -t, --tty                  Allocate a pseudo-TTY
  -u, --user string          Username or UID (format: <name|uid>[:<group|gid>])
  -w, --workdir string       Working directory inside the container

进入之前的centos

[root@centos-2 ~]# docker exec -it 3b244f33c79d /bin/bash
[root@3b244f33c79d /]#    		#这里的系统名称就看出来，已经进入了docker容器中

第二个进入容器中的命令：attach

[root@centos-2 ~]# docker attach --help

Usage:	docker attach [OPTIONS] CONTAINER

Attach local standard input, output, and error streams to a running container

Options:
      --detach-keys string   Override the key sequence for detaching a container
      --no-stdin             Do not attach STDIN
      --sig-proxy            Proxy all received signals to the process (default true)

和exec不同的是，attach进入的是正在运行的命令行，即正在打印hello的命令行；

exec是打开了一个新的命令行

[root@centos-2 ~]# docker attach 1428eeb235f7
hello
hello
hello
.......

Docker 从容器内拷贝到主机上

[root@centos-2 ~]# docker cp --help

Usage:	docker cp [OPTIONS] CONTAINER:SRC_PATH DEST_PATH|-
	docker cp [OPTIONS] SRC_PATH|- CONTAINER:DEST_PATH

Copy files/folders between a container and the local filesystem

Use '-' as the source to read a tar archive from stdin
and extract it to a directory destination in a container.
Use '-' as the destination to stream a tar archive of a
container source to stdout.

Options:
  -a, --archive       Archive mode (copy all uid/gid information)
  -L, --follow-link   Always follow symbol link in SRC_PATH

首先运行容器，在容器的/home中新建1.txt文件，回到主机中，使用ps查看容器的id（不管容器是启动还是关闭，只要能够拿到容器id，就可以拿到数据），

# 将容器/home/1.txt 复制到主机的 /home目录下
docker cp a7a9957c2027:/home/1.txt /home

小结

Docker命令练习

1. 安装nginx

1. 搜索镜像： docker search nginx
2. 安装镜像： docker pull nginx
3. 查看是否下载成功：	docker images
4. 运行nginx，并将容器的80端口映射到本机端口号3344, -name 重新命名  ；	
	docker run -d --name nginx01 -p 3344:80 nginx

5. 测试： curl localhost:3306

如果每次更改配置文件，都需要进入容器内部；可以使用一个映射路径，在这个映射路径中修改文件，在容器内部会自动修改（数据卷技术）

2.安装Tomcat

# 1. 搜索Tomcat版本：

# 官方的使用
docker run -it --rm tomcat:9.0
# 之前使用的是停止容器后容器依然存在， docker run -it --rm ，一般用来测试，用完即删

#1，安装Tomcat
	docker  pull tomcat:9.0
# 启动Tomcat容器
	docker run -d -p 3355:8080 --name tomcat01 tomcat
# 进入容器
	docker exec -it tomcat01 /bin/bash
	# 发现的问题：1、Linux命令少了， 2.没有webapps中的内容
	# 原因是：默认的选择最小的镜像，剔除不必要的部分，保证最小可运行环境即可

部署Es+Kibana

es 暴露的端口很多，十分耗内存，es的数据一般需要放置在安全的目录下：挂载

# 
docker run -d --name elasticsearch  -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2

# 非常占内存，使用docker stats 查看cpu的状态

可视化工具

• portainer

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

什么portainer

Docker的图形化管理工具！提供一个后台面板供我们操作

-v 是挂载命令，将容器挂载到主机上面

Docker镜像原理

镜像是什么

镜像是一种轻量级、可执行的独立软件包，可以用来打包软件运行环境和基于运行环境开发的软件，她包含某个软件所需的所有内容，包括代码、运行时的库、环境和配置文件等。

所有的应用都是直接打包成docker镜像，就可以直接跑起来！

如何得到镜像：

• 从远程仓库中下载
• 朋友拷贝
• 自己制作一个DockerFile文件

Docker镜像加载原理

UnionFs （联合文件系统）

我们下载的时候看到的一层层文件就是这种原理!

UnionFs （联合文件系统）：Union文件系统是一种分层、轻量级并且高性能的文件系统，它支持对文件的修改作为一次提交来一层层的叠加，同时也可以将不同目录挂载到同一个虚拟文件系统下。Union文件系统是Docker镜像的基础。镜像又可以通过分层来进行继承，基于基础镜像（无父镜像），可以制作各种具体应用的镜像。

特性：一次同时加载多个文件系统，但是从外边看起来，只能看到一个文件系统，联合加载会把各层文件系统都叠加起来，这样最终的文件系统会包含所有的底层文件和目录.

Docker镜像加载原理

docker的镜像就是实际上有一层一层的文件系统所组成的,这种层次的文件系统UnionFs.

bootfs(boot file system)主要包含BootLoader和kernel, BootLoader主要是引导加载kernel,Linux启动的时候会加载bootfs文件系统.docker镜像的最底层就是bootfs。这一层与我们经典的Linux/Unix系统是一样的，包含boot加载器和内核。当boot加载完成后整个内核就是在内存中了，此时内存的使用权已经有bootfs转交给内核了，此时系统也会卸载bootfs。

rootfs（root file system），在bootfs之上， 包含的典型的Linux文件系统中的/dev /prpc /bin /etc等标准的目录和文件。rootfs就是各种不同的操作系统的发行版本，例如Ubuntu和centos等

docker中安装的系统是一个精简的os，rootfs的体积可以很小，只需要包含基本的命令，工具和程序库就可以了，因为底层直接用HOST的kernel，自己只需要提供rootfs就可以了。由此可见对于不同的Linux发行版，rootfs都是基本一致的。因此不同的发行版本可以公用bootfs。

分层原理

我们在下载镜像的时候，发现镜像都是分层下载的

理解：

所有的docker镜像都有一个基础的镜像层，将进行修改或者增加新的内容时，就会在当前镜像上创建一个新的镜像层。例如使用Ubuntu创一个镜像，位于新镜像的第一层；如果在该镜像中添加Python包，就会在该基础镜像层上创建第二个镜像层；如果继续添加安全补丁，就会创建第3个镜像层。

在添加额外的镜像层的同时，竞相始终是当前所有镜像的集合，例如下图中的例子，每个镜像底层包含3个文件，而镜像中包含了来自两个镜像层的6个文件

如果是在底层的镜像总有文件需要更新，直接将更新的文件加在镜像层，这样在外边看起来文件的总数还是不变的，例如上面中文件5有一个更新为文件7，文件7位于第3层镜像层，但是在外面看来，这个镜像还是6个文件

Docker通过存储引擎（新版本采用快照机制）方式实现镜像层堆栈，并保证多镜像层对外展示为统一的文件系统。

Linux上可用的存储引擎有AFUS、Overlay2、 Device Mapper、 Btrfs以及ZFS。顾名思义，每种存储引擎都是基于Linux中对应的文件系统或者是块设备技术，并且每种存储结构都有其独特的性能特点。

Docker在Window上仅支持windowsfilter一种存储引擎，该引擎基于NTFS文件系统之上实现了分层和Cow。

下面展示的是与系统显示相同的3层镜像。所有的镜像层堆叠并合并，对外展示统一的视图

特点

Docker镜像都是只读的，当容器启动时，一个新的可写层就被加载到了镜像的顶部！这一层就是我们通常所说的容器层，容器之下都叫镜像层。

Commit 镜像

docker commit 提交一个容器成为一个新的副本
docker commit -m "提交的描述信息" -a “作者” 容器id  目标镜像名:[tag]

容器数据卷

什么是容器数据卷

数据：如果数据都在容器中，如果我们把容器删除了，那么数据就会被删除！需求：数据可以持久化

容器之间可以有一个数据共享技术，Docker容器中产生的数据，同步到本地中。这就是卷技术，目录的挂载，将我们容器内的目录挂载到Linux上面。

总结：容器的持久化和同步操作，容器之间也是可以共享数据的

使用卷技术

方法一： 使用命令挂载：-v

docker run -it -v 主机目录:容器内目录

将centos容器内部的/home目录挂载到主机的/home/test目录下面

docker run -it -v /home/test:/home centos /bin/bash

使用docker inspect查看容器内部的信息：

容器内文件夹和主机的文件夹将会同步。同步是一个双向的过程。

实战：Mysql数据同步

mysql的持久化问题；

步骤：

# 1. 搜索mysql
	docker search mysql
# 2. 安装mysql
	docker pull mysql:5.7
# 3. 启动mysql，启动的时候将配置文件和数据文件映射到主机中，并且使用 -e 配置mysql的密码
	docker run -d -p 3310:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7

具名挂载和匿名挂载

匿名挂载：

-v 容器内目录
docker run -d -P --name nginx01 -v /etc/nignx nginx

# docker volume 命令查看docker中的数据卷
[root@centos-2 test]# docker volume --help
Usage:	docker volume COMMAND
Manage volumes
Commands:
  create      Create a volume
  inspect     Display detailed information on one or more volumes
  ls          List volumes
  prune       Remove all unused local volumes
  rm          Remove one or more volumes
Run 'docker volume COMMAND --help' for more information on a command.


# 查看所有的volume的情况
[root@centos-2 test]# docker volume ls
DRIVER              VOLUME NAME
local               f32fb32afe3ffa1b3c691af07adc7b244ae225142f44849316bef56e0f69b826

# 这里发现，这种就是匿名挂载， -v的时候只写了容器内的名字没有写容器外的名字

具名挂载：(经常使用的)

就是在 -v 卷名:容器内路径

docker run -d -P --name nginx03 -v nignx-config:/etc/nignx nginx

如果没有指定绝对路径，那么就会在/var/lib/docker/volumes中

# 使用命令查看卷挂载的路径
[root@centos-2 test]# docker volume inspect nignx-config
[
    {
        "CreatedAt": "2020-07-28T13:32:36+08:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/nignx-config/_data",
        "Name": "nignx-config",
        "Options": null,
        "Scope": "local"
    }
]

# 可以看到nignx-config文件被映射到了/var/lib/docker/volumes/目录下

如何区分具名挂载和匿名挂载

-v 容器内路径			 # 匿名挂载
-v 卷名:容器内路径			# 具名挂载
-v /主机路径:容器内路径	   # 主机挂载

拓展

# 通过 -v 容器内路径，ro，rw改变读写权限
ro 	readonly 	# 只读,这个路径只能宿主机来操作，容器内部是无法操作的
rw 	readwrite	# 可读写

# 一旦设定了容器的权限，容器对我们挂载出来的内容就有限定了
docker run -d -P --name nginx03 -v nignx-config:/etc/nignx:rw nginx
docker run -d -P --name nginx03 -v nignx-config:/etc/nignx:ro nginx

DockerFile

初识DockerFile

DockerFile 就是用来构建docker镜像的构建文件。是一个命令脚本

在home目录下新建一个docker-file-test文件夹，在文件夹中创建一个文件dockerfile1写入：

# 文件中内容， 指令要大写，这里的每一个命令就是镜像的一层
FROM centos

VOLUME ["volume01", "volume02"]

CMD echo "-----end-----"
CMD /bin/bash

然后执行命令

docker build -f ./dockerfile1 -t lt/centos:0.1 .

[root@centos-2 docker-file-test]# docker build -f ./dockerfile1 -t lt/centos:0.1 .
Sending build context to Docker daemon  2.048kB
Step 1/4 : FROM centos
 ---> 831691599b88
Step 2/4 : VOLUME ["volume01", "volume02"]
 ---> Running in e7e474ee96b4
Removing intermediate container e7e474ee96b4
 ---> d1ff35b3eb7a
Step 3/4 : CMD echo "-----end-----"
 ---> Running in 1717e5164a2f
Removing intermediate container 1717e5164a2f
 ---> 83d12f6470b9
Step 4/4 : CMD /bin/bash
 ---> Running in 2952add39b0f
Removing intermediate container 2952add39b0f
 ---> 229f3e861101
Successfully built 229f3e861101
Successfully tagged lt/centos:0.1

# 查看是否生成images， 发现已经生成了image
[root@centos-2 docker-file-test]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
lt/centos           0.1                 229f3e861101        20 seconds ago      215MB

启动自己的的镜像

docker run -it 229f3e861101 /bin/bash

这个卷一定和主机内的某个目录相对应，而且这两个卷是匿名挂载的

# 使用docker inspect查看该容器的具体信息
[root@centos-2 test]# docker inspect 09714e560694  #容器id

这种方法在未来我们将会使用的非常多，因为我们会自己构建我们的镜像，

假设构建镜像的时候没有挂载卷，要手动挂载 -v 卷名：容器内路径

数据卷容器

多个mysql实现数据共享

# 父类容器
docker run -it --name docker01  镜像名称

# 子类
docker run -it --name docker02 --volumes-from docker01 镜像名称

#这样子类就会继承了父类容器，数据卷容器同步。
# 如果删除了docker01， 查看文件依然存在，文件是一种双向拷贝的方法

结论：

容器之间配置传递消息，数据卷的生命周期一直持续到没有容器使用为止，但是一旦持久化了本地，本地的数据并不会被删除。

DockerFile 构建

基础知识：

1. 每个保留关键字必须是大写字母

2. 指令是从上到下顺序执行的

3. # 表示注释

4. 每一个指定都会创建提交一个新的镜像层

   

dockerfile面向开发，我们以后要发布项目，作镜像，就要编写dockerfile文件，这个文件十分简单！

DockerFile：构建文件，定义了一切的步骤，源代码

DockerImages：通过DockerFile构建生成镜像，最终发布和运行产品

Docker容器：容器就是镜像运行起来提供服务器。

DockerFile 指令

FROM  		#基础镜像，一切从这里开始构建
MAINTAINER		# 镜像是谁写的  姓名+邮箱
RUN			# 镜像构建的时候要运行的命令
ADD			# 步骤：Tomcat镜像，这个Tomcat压缩包！添加内容
WORKDIR		# 镜像的工作目录
VOLUME		# 挂载目录
EXPOSE		# 暴露端口
CMD			# 指定容器运行的时候要运行的命令；只有最后一个有效，可以被取代
ENTERYPOINT	#指定这个容器启动的时候启动的命令，可以追加
ONBUILD		# 当构建一个被继承DockerFile 这个时候就会运行 ONBUILD指令，触发指令
COPY		# 类似于ADD,将我们的文件拷贝到镜像中
ENV			# 构建的时候设置环境变量

实战测试：

Docker Hub中的镜像都是从 基础镜像过来的 FROM scratch，然后配置其他的软件

创建一个自己的Centos

FROM centos
MAINTAINER longtao<[email protected]>

ENV MYPATH /usr/local
WORKDIR	$MYPATH

RUN yum install -y vim 
RUN yum install -y net-tools
EXPOSE 80

CMD echo %MYPATH
CMD echo "====end====="
CMD /bin/bash

通过文件构建镜像

docker build -f mydockerfile -t mycentos:0.1 .

我们可以列出本地的镜像的变更历史

docker history 镜像id

DockerFile 创建一个tomcat

1. 准备镜像文件 Tomcat压缩包， jdk压缩包

2. 编写DockerFile文件 官方命名 Docker，build的时候会自动寻找这个文件，就不需要使用 -f指定

   FROM centos
   MAINTAINER longtao<[email protected]>
   
   COPY readme /usr/local/readme
   
   ADD apache-tomcat-9.0.37.tar.gz /usr/local
   ADD jdk-8u261-linux-x64.tar.gz /usr/local
   
   ENV MYPATH /usr/local
   WORKDIR $MYPATH
   
   ENV JAVA_HOME /usr/local/jdk1.8.0_261
   ENV CLASSPATH $JAVA_HOME/lib
   ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.37
   ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.37
   ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
   
   EXPOSE 8080
   CMD /usr/local/apache-tomcat-9.0.37/bin/startup.sh && tail -f /usr/local/apache-tomcat-9.0.37/logs/catalina.out
   
   
   

3. 构建镜像

   docker build -t mytomcat
   
   

4. 启动镜像

5. 测试镜像

6. 发布项目

发布镜像

DockerHub

1. 注册账号

2. 确定这个账号可以登录

   docker login -u 用户名 -p 密码
   
   

3. 登录完成后就可以使用 docker push将镜像发送到docker Hub中

4. 如果显示没有本地版本，就可以使用tag 更改标签

Docker网络

理解Docker0网络

查看docker内部的ip地址

docker exec -it tomcat ip addr

原理

1. 我们每启动一个docker容器，docker就会给docker容器分配一个ip，我们只要安装了docker，就会有一个网卡docker0桥接模式，使用的技术是evth-pair技术！

2. 再次启动一个容器，发现又多了一个网卡

   # 我们发现这个容器带来网卡，都是一对一对的
   # evth-pair 就是一对的网络设备接口，他们都是成对出现的，一段连接着协议，一段彼此相连
   # 这个是因为这个特性，evth-pair 充当一个容器，连接着各种虚拟设备
   # OpenStack、Docker容器之间的连接 OVS连接 都是使用evth-pair技术
   
   

3. docker容器之间可以互相ping通

结论：Tomcat01和Tomcat02是共用一个路由器docker0；

所有容器在不指定网络的情况下，都是docker0路由器，docker会给我们的容器分配一个默认的可用的ip

Docker网络都是虚拟的，虚拟转发的效率高！（内网传输文件）

只要删除容器，对应的网桥就消失了。

项目不重启，数据ip更换了，我们希望可以处理这个问题，可以通过名字来访问容器？

–link

例如在Tomcat01中ping Tomcat02，但是不知道Tomcat02的ip地址，所以可以使用–link作为一种方法：

docker run  -d -P --name tomcat01 --link tomcat02 tomcat
docker exec -it tomcat01 ping tomcat02	# 现在就可以ping通了
# 反向的ping 可能不通

–link 就是我们在host配置中增加了一个Tomcat02 的信息

自定义网络

[root@centos-2 ~]# docker network --help
Usage:	docker network COMMAND
Manage networks
Commands:
  connect     Connect a container to a network
  create      Create a network
  disconnect  Disconnect a container from a network
  inspect     Display detailed information on one or more networks
  ls          List networks
  prune       Remove all unused networks
  rm          Remove one or more networks
Run 'docker network COMMAND --help' for more information on a command.

查看所有的docker网络

网络模式：

bridge：桥接模式，在docker上搭建网络连桥

none: 不配置网络

host：主机模式，和宿主机共享网络

container：容器网络连通（用的很少，局限非常大）

测试

我们之前启动的容器中，默认的模式为--net bridge

docker run -it -P --name tomcat01 --net bridge tomcat

docker0的特点，默认，域名不能访问，

自己创建网络

docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet

自己创建的网络可以不使用名字就可以访问，自定义的docker都已经帮助我们维护好对应的关系，推荐使用这样的网络。

网络互连

# 容器和网络进行连接
docker network connect mynet tomcat01
# 将Tomcat01放入到mynet网络中，一个容器两个ip

实战：部署Redis集群

步骤：

1. 创建网络

   docker network create --subnet 172.38.0.0/16  redis