狂神Docker入门笔记总结

最新推荐文章于 2023-07-10 17:40:22 发布

st卧龙

最新推荐文章于 2023-07-10 17:40:22 发布

阅读量2.1k

点赞数

分类专栏： docker 文章标签： docker

本文链接：https://blog.csdn.net/qq_41751249/article/details/121592646

版权

docker 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文章目录

Docker概述
- Docker为什么出现？
- Docker能干嘛
Docker安装
Docker的常用命令
Docker镜像讲解
*容器数据卷
*DockerFile
*Docker网络

视频地址：https://www.bilibili.com/video/BV1og4y1q7M4?p=17&spm_id_from=pageDriver

Docker概述

官网文档仓库

Docker为什么出现？

解决本地可以运行，上线不行–环境一致性
安装环境费时费力----容器化
开发、运维一体化

以前：开发人员生成 jar|war 包，运维人员准备环境进行发布

现在：开发人员将 jar|war包 + 运行环境打包进行发布

打包项目+环境----> Docker仓库 —> 下载发布的镜像 —>直接运行

JRE – 多个应用（端口冲突)-- 原来都是交叉的

隔离 : Docker 核心思想！打包装箱！每个箱子是相互隔离的

Docker 通过隔离机制，将服务器利用到极致！

Docker能干嘛

之前的虚拟机技术

缺点：

资源占用十分多
冗余步骤多
启动很慢

容器化技术

容器化技术不是模拟的一个完整的操作系统

Docker 和虚拟机技术的不同：

传统虚拟机，虚拟出一条硬件，运行一个完整的操作系统，然后在这个系统上安装和运行软件
容器内的应用直接运行在宿主机的内存，容器没有自己的内核，也没有虚拟硬件，很轻便
每个容器间是互相隔离的，每个容器内都有一个属于自己的文件系统，互不影响

DevOps (开发、运维)

应用更快速的交付和部署

传统：一堆帮助文档，安装程序

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

更便捷的升级和扩缩容

更简单的系统运维

环境一致性

更高效的计算资源利用

内核级别的虚拟化！将服务器的性能压榨到极致

Docker安装

Docker的基本组成

镜像（image）：

类似一个模板，通过这个模板来创建容器服务；

比如 tomcat 镜像 —> run —> tomcat01容器

通过这个镜像可以创建多个容器（最终服务运行或者项目运行是在容器中）

容器（container）：

独立运行一个或者组操作，通过镜像来创建的。（可以简单立即为一个 linux系统）

仓库（repository）：

存放镜像的地方；分为公有和私有仓库；Docker Hub（默认）、阿里云等—> 有点类似Maven

安装Docker

官方文档

环境准备

一台 Center OS7

# 系统内核是 3.10 以上的
[root@h1 /]# uname -r
3.10.0-1062.12.1.el7.x86_64

# 系统版本 
[root@h1 /]# cat /etc/os-release 
NAME="CentOS Linux"
VERSION="7 (Core)"
ID="centos"
ID_LIKE="rhel fedora"
VERSION_ID="7"
PRETTY_NAME="CentOS Linux 7 (Core)"
ANSI_COLOR="0;31"
CPE_NAME="cpe:/o:centos:centos:7"
HOME_URL="https://www.centos.org/"
BUG_REPORT_URL="https://bugs.centos.org/"

CENTOS_MANTISBT_PROJECT="CentOS-7"
CENTOS_MANTISBT_PROJECT_VERSION="7"
REDHAT_SUPPORT_PRODUCT="centos"
REDHAT_SUPPORT_PRODUCT_VERSION="7"

安装

# 1、卸载旧docker服务

# 2、需要的安装包
yum install -y yum-utils

# 3、设置镜像的仓库-默认是国外的-推荐使用阿里云的
yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo
    
# 更新yum 软件包索引
    
# 4、安装docker  ce社区 ee企业版
yum install docker-ce docker-ce-cli containerd.io

# 5、启动docker
systemctl start docker

# 6、使用docker version 查看是否安装成功

# 7、经典 Hello World
docker run hello-world

# 7、查看下载的镜像
docker iamges

[root@h1 ~]# docker images
REPOSITORY           TAG                 IMAGE ID            CREATED             SIZE
hello-world          latest              feb5d9fea6a5        6 weeks ago         13.3kB

卸载步骤

# 1、卸载依赖
yum remove docker-ce docker-ce-cli containerd.io

# 2、删除资源  默认路径 /var/lib/docker
rm -rf /var/lib/docker
rm -rf /var/lib/containerd

配置阿里云地址

回顾HelloWorld流程

底层原理

Docker是怎么工作的？

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

DockerServer 接收到 Docker-Client的指令，就会执行这个命令

Docker为什么比VM快

Docker有着比虚拟机更少的抽象层
Docker 利用的是宿主机的内核，VM 需要是 Guest OS

所以说，新建一个容器的时候，Docker 不需要像虚拟机一样重新加载一个操作系统内核，避免引导。VM 是加在 Guest OS，分钟级别的，而Docker 是利用宿主机的操作系统，省略了加载过程

Docker的常用命令

官方文档

帮助命令

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

镜像命令

docker images 显示所有的镜像

docker images #显示所有的镜像

[root@h1 /]# docker images
REPOSITORY           TAG                 IMAGE ID            CREATED             SIZE
hello-world          latest              feb5d9fea6a5        6 weeks ago         13.3kB

# 解释
REPOSITORY	镜像的仓库源
TAG			镜像的标签
IMAGE ID	镜像的id
CREATED		镜像的创建时间
SIZE		镜像的大小

# 可选项
  -a, --all             Show all images (default hides intermediate images) 显示所有镜像
  -q, --quiet           Only show numeric IDs 只显示镜像id

docker search 搜索镜像

[root@h1 /]# docker search mysql
NAME                              DESCRIPTION                                     STARS               OFFICIAL            AUTOMATED
mysql                             MySQL is a widely used, open-source relation…   11647               [OK]                
mariadb                           MariaDB Server is a high performing open sou…   4436                [OK]                

# 可选项
  -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

eg: 根据收藏量过滤-收藏3000以上的
docker search mysql --filter=stars=3000

docker pull 下载镜像

# 下载镜像 docker pull 镜像名[:tag]
[root@h1 /]# docker pull mysql
Using default tag: latest	# 如果不写 tag，默认latest
latest: Pulling from library/mysql
b380bbd43752: Downloading 	# 分层下载，docker image的核心 联合文件系统
f23cbf2ecc5d: Download complete 
30cfc6c29c0a: Download complete 
b38609286cbe: Download complete 
8211d9e66cd6: Download complete 
2313f9eeca4a: Download complete 
7eb487d00da0: Download complete 
4d7421c8152e: Download complete 
77f3d8811a28: Download complete 
cce755338cba: Download complete 
69b753046b9f: Download complete 
b2e64b0ab53c: Download complete 
latest: Pulling from library/mysql
b380bbd43752: Pull complete 
f23cbf2ecc5d: Pull complete 
30cfc6c29c0a: Pull complete 
b38609286cbe: Pull complete 
8211d9e66cd6: Pull complete 
2313f9eeca4a: Pull complete 
7eb487d00da0: Pull complete 
4d7421c8152e: Pull complete 
77f3d8811a28: Pull complete 
cce755338cba: Pull complete 
69b753046b9f: Pull complete 
b2e64b0ab53c: Pull complete 
Digest: sha256:6d7d4524463fe6e2b893ffc2b89543c81dec7ef82fb2020a1b27606666464d87	# 签名
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest	# 真实地址

# docker.io/library/mysql:latest 等价于 docker pull mysql

docker rml 删除镜像

docker rmi 镜像id # 删除指定镜像
docker rmi 镜像id 镜像id 镜像id # 删除多个镜像
# 删除全部镜像 删库跑路ing
docker rmi -f $(docker images -aq

容器命令

说明：有了镜像才能创建容器

eg: 下载一个 linux

docker pull centos

新建容器并启动

docker run [可选参数] image

# 参数说明
--name="Name"	容器名字 tomcat01 tomcat02 用来区分容器
-d				后台方式运行 
-it				使用交互方式运行，进入容器查看内容
-p				指定容器的端口 -p	8080:8080
	-p ip:主机端口:容器端口
	-p 主机端口:容器端口（常用）
	-p 容器端口
	容器端口
-P				随机指定端口

# 测试，启动并进入容器
[root@h1 /]# docker run -it centos /bin/bash
[root@97ec2d2a05c4 /]# ls    #查看容器内的centos，但是是基础版本
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var

列出正在运行的容器

docker ps 
-a		#列出当前正在运行的容器+历史运行过的容器
-n=?	#列出最近创建的容器
-q		#只显示容器的编号

[root@h1 /]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                                        NAMES
a503b09876c3        nginx:1.10          "nginx -g 'daemon of…"   6 months ago        Up 6 months         0.0.0.0:80->80/tcp, 443/tcp                  nginx


[root@h1 /]# docker ps -a
CONTAINER ID        IMAGE                     COMMAND                  CREATED             STATUS                         PORTS                                        NAMES
97ec2d2a05c4        centos                    "/bin/bash"              5 minutes ago       Exited (0) 3 minutes ago                                                    epic_elion
d4f53683900a        hello-world               "/hello"                 About an hour ago   Exited (0) About an hour ago                                                naughty_keller

退出容器

exit	# 直接容器停止并退出
Ctrl + p + q	# 容器不停止退出

删除容器

docker rm 容器id				   # 删除指定容器（不能删除正在运行的容器，可以用 /f 强制）
docker rm -f $(docker images)	# 删除全部容器
docker ps -a -q|xargs docker rm 	# 删除所有的容器

启动和停止容器的操作

docker start 容器id		# 启动容器
docker restart 容器id		# 重启容器
docker stop 容器id		# 停止当前正在运行的容器
docker kill 容器id		# 强制停止当前容器

常用的其他命令

后台启动容器

# 命令 docker run -d 容器id
[root@h1 /]# docker run -d centos

# 问题：docker ps 发现centos停止了

# 常见的坑：docker 使用后台运行，就必须要有一个前台进程，docker发现没有应用，就会自动停止
# eg: nginx没有任何应用，发现自己没有提供服务，就会立刻停止

# 自己编写一段shell脚本
"while true;do echo kuangshen;sleep 1;done"

docker run -d centos /bin/sh -c "while true;do echo kuangshen;sleep 1;done"
# 此时会发现 docker ps能看到启动的容器了

查看日志

docker logs -f -t --tail 10 容器 

eg:
docker logs -f -t --tail 10 47f7c19769b3


# 参数说明
-f # 跟追日志
-t # 显示时间戳
--tail number # 末尾的number条

查看容器中的进程信息

# docker top 容器id

[root@h1 /]# docker top 47f7c19769b3
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                29722               29707               0                   18:32               ?                   00:00:00            /bin/sh -c while true;do echo kuangshen;sleep 1;done
root                30356               29722               0                   18:37               ?                   00:00:00            /usr/bin/coreutils --coreutils-prog-shebang=sleep /usr/bin/sleep 1

查看容器的元数据

docker inspect 容器id

# 测试
[root@h1 /]# docker inspect 47f7c19769b3
[
    {
        "Id": "47f7c19769b320f8edcdf2630e39ecbd4794f3fecd45349fe982692c107cf70d",
        "Created": "2021-11-07T10:32:46.740538413Z",
        "Path": "/bin/sh",
        "Args": [
            "-c",
            "while true;do echo kuangshen;sleep 1;done"
        ],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 29722,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2021-11-07T10:32:47.953706603Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:5d0da3dc976460b72c77d94c8a1ad043720b0416bfc16c52c45d4847e53fadb6",
        "ResolvConfPath": "/var/lib/docker/containers/47f7c19769b320f8edcdf2630e39ecbd4794f3fecd45349fe982692c107cf70d/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/47f7c19769b320f8edcdf2630e39ecbd4794f3fecd45349fe982692c107cf70d/hostname",
        "HostsPath": "/var/lib/docker/containers/47f7c19769b320f8edcdf2630e39ecbd4794f3fecd45349fe982692c107cf70d/hosts",
        "LogPath": "/var/lib/docker/containers/47f7c19769b320f8edcdf2630e39ecbd4794f3fecd45349fe982692c107cf70d/47f7c19769b320f8edcdf2630e39ecbd4794f3fecd45349fe982692c107cf70d-json.log",
        "Name": "/xenodochial_lalande",
        "RestartCount": 0,
        "Driver": "overlay2",
        "Platform": "linux",
        "MountLabel": "",
        "ProcessLabel": "",
        "AppArmorProfile": "",
        "ExecIDs": null,
        "HostConfig": {
            "Binds": null,
            "ContainerIDFile": "",
            "LogConfig": {
                "Type": "json-file",
                "Config": {}
            },
            "NetworkMode": "default",
            "PortBindings": {},
            "RestartPolicy": {
                "Name": "no",
                "MaximumRetryCount": 0
            },
            "AutoRemove": false,
            "VolumeDriver": "",
            "VolumesFrom": null,
            "CapAdd": null,
            "CapDrop": null,
            "Capabilities": null,
            "Dns": [],
            "DnsOptions": [],
            "DnsSearch": [],
            "ExtraHosts": null,
            "GroupAdd": null,
            "IpcMode": "private",
            "Cgroup": "",
            "Links": null,
            "OomScoreAdj": 0,
            "PidMode": "",
            "Privileged": false,
            "PublishAllPorts": false,
            "ReadonlyRootfs": false,
            "SecurityOpt": null,
            "UTSMode": "",
            "UsernsMode": "",
            "ShmSize": 67108864,
            "Runtime": "runc",
            "ConsoleSize": [
                0,
                0
            ],
            "Isolation": "",
            "CpuShares": 0,
            "Memory": 0,
            "NanoCpus": 0,
            "CgroupParent": "",
            "BlkioWeight": 0,
            "BlkioWeightDevice": [],
            "BlkioDeviceReadBps": null,
            "BlkioDeviceWriteBps": null,
            "BlkioDeviceReadIOps": null,
            "BlkioDeviceWriteIOps": null,
            "CpuPeriod": 0,
            "CpuQuota": 0,
            "CpuRealtimePeriod": 0,
            "CpuRealtimeRuntime": 0,
            "CpusetCpus": "",
            "CpusetMems": "",
            "Devices": [],
            "DeviceCgroupRules": null,
            "DeviceRequests": null,
            "KernelMemory": 0,
            "KernelMemoryTCP": 0,
            "MemoryReservation": 0,
            "MemorySwap": 0,
            "MemorySwappiness": null,
            "OomKillDisable": false,
            "PidsLimit": null,
            "Ulimits": null,
            "CpuCount": 0,
            "CpuPercent": 0,
            "IOMaximumIOps": 0,
            "IOMaximumBandwidth": 0,
            "MaskedPaths": [
                "/proc/asound",
                "/proc/acpi",
                "/proc/kcore",
                "/proc/keys",
                "/proc/latency_stats",
                "/proc/timer_list",
                "/proc/timer_stats",
                "/proc/sched_debug",
                "/proc/scsi",
                "/sys/firmware"
            ],
            "ReadonlyPaths": [
                "/proc/bus",
                "/proc/fs",
                "/proc/irq",
                "/proc/sys",
                "/proc/sysrq-trigger"
            ]
        },
        "GraphDriver": {
            "Data": {
                "LowerDir": "/var/lib/docker/overlay2/a1e777bfaca4e493e9dc908a5a187316e58e654f65f3f8c2575bb2a3a56c626b-init/diff:/var/lib/docker/overlay2/8560d7629b61854e347dc4867d3ebe75e55eba2e0b5dfa35df719536ffb7f9e0/diff",
                "MergedDir": "/var/lib/docker/overlay2/a1e777bfaca4e493e9dc908a5a187316e58e654f65f3f8c2575bb2a3a56c626b/merged",
                "UpperDir": "/var/lib/docker/overlay2/a1e777bfaca4e493e9dc908a5a187316e58e654f65f3f8c2575bb2a3a56c626b/diff",
                "WorkDir": "/var/lib/docker/overlay2/a1e777bfaca4e493e9dc908a5a187316e58e654f65f3f8c2575bb2a3a56c626b/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [],
        "Config": {
            "Hostname": "47f7c19769b3",
            "Domainname": "",
            "User": "",
            "AttachStdin": false,
            "AttachStdout": false,
            "AttachStderr": false,
            "Tty": false,
            "OpenStdin": false,
            "StdinOnce": false,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
            ],
            "Cmd": [
                "/bin/sh",
                "-c",
                "while true;do echo kuangshen;sleep 1;done"
            ],
            "Image": "centos",
            "Volumes": null,
            "WorkingDir": "",
            "Entrypoint": null,
            "OnBuild": null,
            "Labels": {
                "org.label-schema.build-date": "20210915",
                "org.label-schema.license": "GPLv2",
                "org.label-schema.name": "CentOS Base Image",
                "org.label-schema.schema-version": "1.0",
                "org.label-schema.vendor": "CentOS"
            }
        },
        "NetworkSettings": {
            "Bridge": "",
            "SandboxID": "acdba74473ab57cf170f1bd9dd0aa75e61a50b6a83369683f4ed1fa99ff87471",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {},
            "SandboxKey": "/var/run/docker/netns/acdba74473ab",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "fdd361db06efc9a35d38cd8b5d3cceef6413cd3c8a555d7b13cea423f27cb688",
            "Gateway": "172.17.0.1",
            "GlobalIPv6Address": "",
            "GlobalIPv6PrefixLen": 0,
            "IPAddress": "172.17.0.6",
            "IPPrefixLen": 16,
            "IPv6Gateway": "",
            "MacAddress": "02:42:ac:11:00:06",
            "Networks": {
                "bridge": {
                    "IPAMConfig": null,
                    "Links": null,
                    "Aliases": null,
                    "NetworkID": "6e648e4e727e19c197bf98d1eee39f5076a47d1254dff82aae4e1244dcdcf410",
                    "EndpointID": "fdd361db06efc9a35d38cd8b5d3cceef6413cd3c8a555d7b13cea423f27cb688",
                    "Gateway": "172.17.0.1",
                    "IPAddress": "172.17.0.6",
                    "IPPrefixLen": 16,
                    "IPv6Gateway": "",
                    "GlobalIPv6Address": "",
                    "GlobalIPv6PrefixLen": 0,
                    "MacAddress": "02:42:ac:11:00:06",
                    "DriverOpts": null
                }
            }
        }
    }
]

进入当前正在运行的容器

# 我们通常容器都是使用后台方式运行

# 方式一
# 命令
docker exec -it

# 测试
[root@h1 /]# docker exec -it 47f7c19769b3 /bin/bash
[root@47f7c19769b3 /]# 

# 方式二
docker attach 容器id
正在执行当前的代码...


# docker exec		# 进入容器后开启一个新的终端，可以在里面操作
#docker attach		# 进入容器正在执行的终端，不会启动新的线程

从容器内拷贝文件到主机上

docker cp 容器id:容器内路径 目标主机路径

# 测试
[root@h1 home]# docker cp c6b6701c4e11:/home/test.java /home/temp/

# 拷贝是一个手动过程，未来可以使用 -v 卷的技术，可以实现自动

小结

attach    Attach to a running container  #当前shell下attach连接指定运行镜像
build     Build an image from a Dockerfile  #通过Dockerfile定制镜像
commit    Create a new image from a containers changes  #提交当前容器为新的镜像
cp    Copy files/folders from a container to a HOSTDIR or to STDOUT  #从容器中拷贝指定文件或者目录到宿主机中
create    Create a new container  #创建一个新的容器，同run 但不启动容器
diff    Inspect changes on a containers filesystem  #查看docker容器变化
events    Get real time events from the server#从docker服务获取容器实时事件
exec    Run a command in a running container#在已存在的容器上运行命令
export    Export a containers filesystem as a tar archive  #导出容器的内容流作为一个tar归档文件(对应import)
history    Show the history of an image  #展示一个镜像形成历史
images    List images  #列出系统当前镜像
import    Import the contents from a tarball to create a filesystem image  #从tar包中的内容创建一个新的文件系统映像(对应export)
info    Display system-wide information  #显示系统相关信息
inspect    Return low-level information on a container or image  #查看容器详细信息
kill    Kill a running container  #kill指定docker容器
load    Load an image from a tar archive or STDIN  #从一个tar包中加载一个镜像(对应save)
login    Register or log in to a Docker registry#注册或者登陆一个docker源服务器
logout    Log out from a Docker registry  #从当前Docker registry退出
logs    Fetch the logs of a container  #输出当前容器日志信息
pause    Pause all processes within a container#暂停容器
port    List port mappings or a specific mapping for the CONTAINER  #查看映射端口对应的容器内部源端口
ps    List containers  #列出容器列表
pull    Pull an image or a repository from a registry  #从docker镜像源服务器拉取指定镜像或者库镜像
push    Push an image or a repository to a registry  #推送指定镜像或者库镜像至docker源服务器
rename    Rename a container  #重命名容器
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(s) to a tar archive#保存一个镜像为一个tar包(对应load)
search    Search the Docker Hub for images  #在docker
hub中搜索镜像
start    Start one or more stopped containers#启动容器
stats    Display a live stream of container(s) resource usage statistics  #统计容器使用资源
stop    Stop a running container  #停止容器
tag         Tag an image into a repository  #给源中镜像打标签
top       Display the running processes of a container #查看容器中运行的进程信息
unpause    Unpause all processes within a container  #取消暂停容器
version    Show the Docker version information#查看容器版本号
wait         Block until a container stops, then print its exit code  #截取容器停止时的退出状态值

作业练习

docker 安装nginx

# 1、搜索镜像
# 2、下载镜像
# 3、运行镜像
# -d 后台运行
# -name 给容器命名
# -p 宿主机端口:容器内端口
[root@h1 ~]# docker run -d --name nginx01 -p 80:80 nginx
dc97786c7c08037074c52b49598e4f1e62648989a748d7a94eab07667992a91e

# 进入容器
[root@h1 ~]# docker exec -it dc97786c7c08 /bin/bash
root@dc97786c7c08:/# 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@dc97786c7c08:/#

端口暴露：

作业: docker 装一个tomcat

# 官方的使用 docker run -it --rm 用完即删除且当前窗口运行
$ docker run -it --rm -p 8888:8080 tomcat:9.0

# 进入容器
[root@h1 ~]# docker exec -it e156bccb6420 /bin/bash
root@e156bccb6420:/usr/local/tomcat# ls
BUILDING.txt	 LICENSE  README.md	 RUNNING.txt  conf  logs	    temp     webapps.dist
CONTRIBUTING.md  NOTICE   RELEASE-NOTES  bin	      lib   native-jni-lib  webapps  work
root@e156bccb6420:/usr/local/tomcat# 

# 发现问题：1、linux命令少 2、没有webapps。阿里云默认是最小的镜像，所有不必要的全部删除
# 保证最小的运行环境

作业: 部署es+kibana

# 需要暴露的端口很多
# es十分耗费内存
# es 的数据一般需要放置到安全目录
# --net somenetwork 网络配置

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

# -e 环境配置修改
$ docker run -d --name elasticsearch --net somenetwork -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.6.2

可视化

portainer
Rancher (CI/CD)

什么是portainer？

Docker 图形化界面管理工具

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

# 访问测试 http://119.3.166.78:8088/#/init/endpoint
创建用户、选择Local

Docker镜像讲解

镜像是什么

镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，它包含运行某个软件所需要的所有内容，包括代码，运行时（一个程序在运行或者在被执行的依赖）、库，环境变量和配置文件。

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

如何获得镜像

从远程仓库下载
拷贝
自己制作一个镜像 Dockerfile

Docker镜像加载原理

UnionFS (联合文件系统) -> 下载时一层一层的就是这个

**理解：**如果不同的镜像利用到了相同的小模块，则无需下载，直接拿过去就行

UnionFS(联合文件系统): Union文件系统( UnionFS)是一种分层、轻量级并且高性能的文件系统,它支持对文件系统的修改作为一次提交来一层层的叠加,同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into single virtual filesystem) Union文件系统是 Docker镜像的基础。镜像可以通过分层来进行继承,基于基础镜像(没有父镜像),可以制作各种具体的应用镜像。

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

分层理解

分层的镜像

latest: Pulling from portainer/portainer
94cfa856b2b1: Pull complete 
49d59ee0881a: Pull complete 
a2300fd28637: Pull complete 
Digest: sha256:fb45b43738646048a0a0cc74fcee2865b69efde857e710126084ee5de9be0f3f
Status: Downloaded newer image for portainer/portainer:latest
39e2046f46502d9496598ff8676382d8bdde83302f8acd865aa50f16de235f91

为什么要采用分层

最大的好处：莫过于是资源共享了!比如有多个镜像都从相同的Base镜像构建而来,那么宿主机只需在磁盘上保留一份base镜像,同时内存中也只需要加载一份base镜像,这样就可以为所有的容器服务了,而且镜像的每一层都可以被共享。
查看镜像分层的方式可以通过 docker image inspect命令

docker image inspect nginx

"RootFS": {
            "Type": "layers",
            "Layers": [
                "sha256:e1bbcf243d0e7387fbfe5116a485426f90d3ddeb0b1738dca4e3502b6743b325",
                "sha256:37380c5830feb5d6829188be41a4ea0654eb5c4632f03ef093ecc182acf40e8a",
                "sha256:ff4c727794302b5a0ee4dadfaac8d1233950ce9a07d76eb3b498efa70b7517e4",
                "sha256:49eeddd2150fbd14433ec1f01dbf6b23ea6cf581a50635554826ad93ce040b68",
                "sha256:1e8ad06c81b6baf629988756d90fd27c14285da4d9bf57179570febddc492087",
                "sha256:8525cde30b227bb5b03deb41bda41deb85d740b834be61a69ead59d840f07c13"
            ]
        },

理解：

特点

Docker镜像都是只读的,当容器启动时一个新的可写层被加载到镜像的顶部!

这一层就是我们通常说的容器层,容器之下的都叫镜像层!

下载的都是镜像层，运行起来的是容器

如何commit镜像

docker commit 提交容器成为一个新的副本

# 命令和git原理类似
docker commit -m="提交的描述信息" -a="作者" 容器id 目标镜像名:[tag]

实战测试

# 启动一个默认的nginx

# 默认是初始化的文件
/usr/share/nginx/html
# 自己创建一个 hello.html 放入

# 提交->保存当前容器到新的镜像
[root@h1 ~]# docker commit -m="test commit" -a="javaboy" dc97786c7c08 nginx02:1.0
sha256:6f16afc62457e61d2e8a31d664240c72286c0843ee8f48b69757ef7a06297177

# 以后就可以直接使用自己提交的镜像
[root@h1 ~]# docker images
REPOSITORY            TAG                   IMAGE ID            CREATED             SIZE
nginx02               1.0                   6f16afc62457        8 seconds ago       141MB

自我小结

镜像=最小运行环境+应用
可以通过远程仓库、DockerFile获取镜像
镜像加载用到的是 UnionFS，将需要用到的组件抽成小的模块，多个镜像是不同模块的组成
镜像加载->bootfs（最底层的，包含boot加载器和内核）->bootloader+kernel
bootloader加载kernel，Linux启动时加载bootfs文件系统，boot加载完成后，整个内核都在内存中，内存的使用权由boofs交给内核，系统卸载boofs
roots（root file system）包含linux等标准目录和文件和命令；像centos，其实使用的还是本机的kernel
每个镜像都是由多层叠加起来的->方便复用和扩展（每次新版本都是在原版本上叠加一层或在新一层上进行原有文件的替换和增加）
下载的都是镜像，运行起来的是容器->容器只不过是在镜像上面新增了一层，之后的所有操作都在容器内进行，原有镜像是可读不可变的
可以通过commit 或 dockerFile 来创建新的镜像

*容器数据卷

是什么

为了容器的持久化和同步操作，实现容器间的数据共享

Docker的理念：将应用和环境打包成一个镜像

数据如果都在容器中，则容器删除那数据也会丢失-> 数据需要持久化->需要容器之间的一个数据共享的技术

eg：MySql->容器删了->数据也都没了

Docker容器中产生的数据，同步到本地；也就是目录的挂载；使容器内的目录挂载到 linux 本机上；

使用数据卷

双向绑定

容器内、主机内做任何操作都会同步过去
容器只要不删除，在主机内进行任何操作，再次start，文件都会同步过去
如果挂载的是已经存在的目录，则会完全按照本机的格式；如果是空目录，则本机和容器内都是空的

方式一：直接使用命令去实现挂载 -v

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

docker inspect 容器id

    "Mounts": [
        {
            "Type": "bind",
            "Source": "/tmp", # 主机内的地址 
            "Destination": "/home", # docker内的地址 
            "Mode": "",
            "RW": true,
            "Propagation": "rprivate"
        }
    ]

实战：安装Mysql

# -d 后台运行 -p 端口映射 -v 目录挂载 -e环境配置 --name 命名
[root@h1 ~]# docker run -d -p 3310:3306 -v /tmp/docker/mysql/conf:/etc/mysql/conf.d -v /tmp/docker/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name MYSQL01 b05128b000dd

# 即使容器删除后，挂载的目录也不会消失

具名和匿名挂载

# 匿名挂载
-v 容器内路径
docker run -d -P --name nginx03 -v /etc/nginx nginx

# 查看所有 volume 情况
[root@h1 ~]# docker volume ls
DRIVER              VOLUME NAME
local               0fc9ec9570072b6a0346a2445b1f9c63e0c74f14eec56666c261f09a475c1d13

# -v只写容器内的路径，没写容器外的路径都是上面的这种长名字

# 具名挂载
-v 卷名:容器内路径
[root@h1 ~]# docker run -d -P --name nginx04 -v juming-nginx:/etc/nginx nginx

# 查看所有 volume 情况
[root@h1 ~]# docker volume ls
DRIVER              VOLUME NAME
local               juming-nginx

# 查看卷
[root@h1 ~]# docker volume inspect juming-nginx
[
    {
        "CreatedAt": "2021-11-21T15:56:01+08:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/juming-nginx/_data",
        "Name": "juming-nginx",
        "Options": null,
        "Scope": "local"
    }
]
所有docker容器内的卷，没有指定目录的情况下都是在 /var/lib/docker/volumes/xxx/_data 下

通过具名挂载可以很方便的找到设置的卷

具名、匿名、指定挂载

-v 容器内路径匿名挂载
-v 卷名:容器内路径具名挂载
-v /目录:容器内路径指定挂载

# 通过 -v 容器内路径 ：ro rw 改变读写权限
ro 	readonly 只读
rw  readwrite 可读写

# 一旦设定了容器权限，容器对挂载出来的内容就有限定了
docker run -d -P --ame nginx -v juming-nginx:/etc/nginx:ro nginx

# ro 只能通过宿主机来操作，容器内无法操作

DockerFile初识

用来构建 docker 镜像的构建文件 -> 命令脚本

通过这个脚本可以生成镜像；镜像是一层一层的，脚本的命令也是一层一层的

# dockerfile文件； 指令都是大写的；此处的每个命令就是一层
[root@h1 docker-test-volume]# cat dockerfile1 
FROM centos

VOLUME ["volume01","volume02"]

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

# 构建过程
[root@h1 docker-test-volume]# docker build -f dockerfile1 -t kuangshen/centos:1.0 .
Sending build context to Docker daemon  2.048kB
Step 1/4 : FROM centos
 ---> 5d0da3dc9764
Step 2/4 : VOLUME ["volume01","volume02"]
 ---> Running in ff5a20e07135
Removing intermediate container ff5a20e07135
 ---> a04886db6adc
Step 3/4 : CMD echo "--------end-------"
 ---> Running in 30a3f8c924bd
Removing intermediate container 30a3f8c924bd
 ---> 9f31205f2d87
Step 4/4 : CMD /bin/bash
 ---> Running in 8ed405512cb3
Removing intermediate container 8ed405512cb3
 ---> 344f2429b066
Successfully built 344f2429b066
Successfully tagged kuangshen/centos:1.0

# 查看成果

这个卷和外部一定有一个同步的目录；

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

数据卷容器

eg：多个容器同步数据

# 启动父容器
docker run -it --name docker01 344f2429b066

# 挂载 -> 实现了容器内的数据共享 -> 其实挂载的还是本机（快捷方式？）
[root@h1 mysql]# docker run -it --name docker02 --volumes-from docker01 344f2429b066

eg: 多个mysql数据共享

docker run -d -p 3310:3306 -v /tmp/docker/mysql/conf:/etc/mysql/conf.d -v /tmp/docker/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name MYSQL01 b05128b000dd

docker run -d -p 3311:3306 -v /tmp/docker/mysql/conf:/etc/mysql/conf.d -v /tmp/docker/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name MYSQL02 --volume-from MYSQL01 b05128b000dd

结论：

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

自我小结

容器数据卷->目录的挂载->实现持久化和同步以及多个容器间的数据共享->双向绑定
挂载方式
- 匿名挂载 -v docker要挂载的目录
- 具名挂载 -v 数据卷(名字):docker要挂载的目录
- 指定挂载 -v /本机目录:docker要挂载的目录
-v 可以通过 ro 只读、rw可读写来设定容器权限->读写针对的是docker容器
- ro 代表只能在主机内修改文件，docker中只读
挂载后可以通过 volume 查看挂载情况，具有长乱字母数字的就是匿名、有实际名字的是具名、没显示的都是指定挂载；可以通过 docker volume inspect 数据卷名字查看具体的挂载目录
数据卷容器 -> 有点类似快捷方式或者说是共享目录

*DockerFile

DockerFile：是用来构建docker镜像的文件 -> 一个脚本 ->构建了全部步骤

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

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

构建步骤

编写一个 dockerfile 文件
docker build 构建成为一个镜像
docker run 运行镜像
docker push 发布镜像（DockerHub、阿里云镜像仓库）

官网示例

很多官方的镜像都是基础包，很多功能都没有；

构建过程

基础知识

每个保留关键字（指令）必须是大写字母
执行从下到下顺序执行
# 表示注释
每一个指令都会创建提交一个新的镜像层

DockerFile指令

FROM		# 基础镜像
MAINTAINER 	# 镜像是谁写的，姓名+邮箱
RUN			# 镜像构建时需要运行的命令
ADD			# 添加内容
WORKDIR		# 镜像的工作目录 -> /bin/bash
VOLUME		# 挂载卷
EXPOSE		# 指定默认暴露端口
CMD			# 指定这个容器启动时要运行的命令->如果启动时输入了其他命令，会替换原本的命令而不会追加
ENTRYPOINT	# 指定这个容器启动时要运行的命令->可以追加命令
ONBUILD		# 当构建一个被继承 DockerFile 这个时候就会运行 ONBUILD 指令 ->相当于触发
COPY		# 类似ADD，将文件拷贝到镜像中
ENV			# 构建时设置环境变量

实战测试

Docker Hub中 99% 镜像都是从基础镜像来的 FROM scratch，然后配置需要的软件和配置来进行构建的

创建一个自己的CentOS

# 1、编写自己的DockerFile文件
[root@h1 temp]# cat dockerfile 
FROM centos
MAINTAINER kuangshen<123@qq.com>

ENV MYPATH /usr/local
WORKDIR $MYPATH

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

EXPOSE 10809

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

# 2、构建镜像
# docker build -f dockerfile -t mycentos:0.01 .
# docker buile -f dockerfile文件路径 -t 名称:版本号 生成的路径

Successfully built 84c7ab302f88
Successfully tagged mycentos:0.01

[root@h1 ~]# docker images
REPOSITORY            TAG                   IMAGE ID            CREATED              SIZE
mycentos              0.01                  84c7ab302f88        About a minute ago   322MB

# 3、测试运行

查看镜像构建历史 docker history 镜像id

ENTRYPOINT和CMD的区别

测试CMD

# 编写dockerfile文件
[root@h1 temp]# cat dockerfile-ceshi 
FROM centos
CMD ["ls","-a"]

# 构建镜像
[root@h1 temp]# docker build -f dockerfile-ceshi -t cmdtest:0.1 .
Sending build context to Docker daemon  3.072kB
Step 1/2 : FROM centos
 ---> 5d0da3dc9764
Step 2/2 : CMD ["ls","-a"]
 ---> Running in c7aabc922c48
Removing intermediate container c7aabc922c48
 ---> 6eaf3890fa0d
Successfully built 6eaf3890fa0d
Successfully tagged cmdtest:0.1

# run运行 -> ls -a 生效
[root@h1 temp]# docker run cmdtest:0.1
.
..
.dockerenv
bin
dev
root
run
tmp
usr
var

# 启动时追加命令出错
[root@h1 temp]# docker run cmdtest:0.1 -l
docker: Error response from daemon: OCI runtime create failed: container_linux.go:349: starting container process caused "exec: \"-l\": executable file not found in $PATH": unknown.

# cmd的情况下 -l替换掉了CMD ["-l", "-a"]
# -l不是命令 换成 ls -al成功
[root@h1 temp]# docker run cmdtest:0.1 ls -al
total 56
drwxr-xr-x   1 root root 4096 Nov 27 03:17 .
drwxr-xr-x   1 root root 4096 Nov 27 03:17 ..
-rwxr-xr-x   1 root root    0 Nov 27 03:17 .dockerenv
lrwxrwxrwx   1 root root    7 Nov  3  2020 bin -> usr/bin

测试 ENTRYPOINT

[root@h1 temp]# cat dockerfile-entrypoint 
FROM centos

ENTRYPOINT ["ls", "-a"]


[root@h1 temp]# docker build -f dockerfile-entrypoint -t entrypointtest .

[root@h1 temp]# docker run entrypointtest
.
..
.dockerenv
bin
dev
etc

# 追加的命令可以之间拼接在 ENTRYPOINT 命令后面
[root@h1 temp]# docker run entrypointtest -l
total 56
drwxr-xr-x   1 root root 4096 Nov 27 03:20 .
drwxr-xr-x   1 root root 4096 Nov 27 03:20 ..
-rwxr-xr-x   1 root root    0 Nov 27 03:20 .dockerenv
lrwxrwxrwx   1 root root    7 Nov  3  2020 bin -> usr/bin
drwxr-xr-x   5 root root  340 Nov 27 03:20 dev
drwxr-xr-x   1 root root 4096 Nov 27 03:20 etc

实战测试：Tomcat镜像

准备镜像文件 tomcat 压缩包，jdk压缩包

[root@h1 myfile]# ls
apache-tomcat-8.5.73.tar.gz  jdk-8u311-linux-x64.tar.gz

编写dockerfile文件，命名为 Dockerfile，build就会自动寻找文件，而不用指定-f

[root@h1 tomcat]# cat Dockerfile 
FROM centos
MAINTAINER kuangshen<123@qq.com>

COPY readme.txt /usr/local/readme.txt

ADD jdk-8u311-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-8.5.73.tar.gz /usr/local/

RUN yum -y install vim 

ENV MYPATH /usr/local

WORKDIR $MYPATH

ENV JAVA_HOME /usr/local/jdk1.8.0_311
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-8.5.73
ENV CATALINA_BASH /usr/local/apache-tomcat-8.5.73
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

EXPOSE 8080

CMD /usr/local/apache-tomcat-8.5.73/bin/startup.sh && tail -F /usr/local/apache-tomcat-8.5.73/logs/catalina.out

构建镜像

docker build -t mytomcat .

启动镜像

docker run -d -p 8080:8080 --name diytomcat -v /tmp/tomcat/test:/usr/local/apache-tomcat-8.5.73/webapps/test -v /tmp/tomcat/logs:/usr/local/apache-tomcat-8.5.73/logs mytomcat:latest

访问测试 curl localhost:8080
发布项目

ps: 直接写个index.html 就可以

[root@h1 test]# cat index.html 
<html>
<h1>hello mytomcat</h1>

</html>

发布自己的镜像

dockerhub官网注册账号
在服务器上登录后提交自己的镜像 ----类似github

[root@h1 tomcat]# docker login -u nanshoudabaojian 
Password: 
WARNING! Your password will be stored unencrypted in /root/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store

Login Succeeded

提交镜像 docker push 镜像:tag

ps: 要想提交到dockerhub，需要将自己的镜像名称变为 dockerhub用户名/镜像名:tag，否则就会拒绝请求

docker tag 本地镜像名称 新名称:tag
docker tag mytomcat:1.0 nanshoudabaojian/mytomcat:1.0

提交镜像 
root@h1 tomcat]# docker push nanshoudabaojian/mytomcat:1.0
The push refers to repository [docker.io/nanshoudabaojian/mytomcat]
61269a6ba27f: Pushing [==================>                                ]  23.78MB/63.87MB
fcb212df0baf: Pushing [===========================>                       ]   8.02MB/14.78MB
87dd72eeda99: Pushing [=>                                                 ]  9.338MB/365.3MB
f41958f431fe: Pushed 
74ddd0ec08fa: Pushing [===>                                               ]   15.3MB/231.3MB

发布到阿里云镜像服务

登录阿里云，创建自己的镜像仓库
按照操作指南做就完了

自我小结

DockerFile 更像是一个命令的集合，用于生成镜像; 编写->build->run->push
DockerFile 每一个指令都会创建提交一个新的镜像层
ENTRYPOINT可以追加命令和参数；CMD不能追加，会直接替代

*Docker网络

Docker0

测试

docker是如何处理容器网络访问的？

[root@h1 tomcat]# docker run -d -P --name tomcat01 tomcat
b51967a6fca25f3d307f792a49d51b5b805e04ed3ac71d9236454a64e052662a

# 查看容器的内部网络地址    eth0@if1352 docker分配的IP地址
[root@h1 tomcat]# docker exec -it tomcat01 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
1351: eth0@if1352: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:ac:11:00:0b brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 172.17.0.11/16 brd 172.17.255.255 scope global eth0
       valid_lft forever preferred_lft forever

# 容器内部和本机网络连接通畅
[root@h1 tomcat]# ping 172.17.0.11
PING 172.17.0.11 (172.17.0.11) 56(84) bytes of data.
64 bytes from 172.17.0.11: icmp_seq=1 ttl=64 time=0.150 ms
64 bytes from 172.17.0.11: icmp_seq=2 ttl=64 time=0.041 ms

# 再次ip addr时发现多了一对网卡
1351: eth0@if1352

# 再次启动一个容器，发现又多了一对网卡
[root@h1 ~]# docker exec tomcat02 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
1357: eth0@if1358: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:ac:11:00:07 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 172.17.0.7/16 brd 172.17.255.255 scope global eth0
       valid_lft forever preferred_lft forever
       
1357: eth0@if1358

# 测试两个容器之间网络也是通的
[root@h1 ~]# docker exec -it tomcat02 ping 172.17.0.11
PING 172.17.0.11 (172.17.0.11) 56(84) bytes of data.
64 bytes from 172.17.0.11: icmp_seq=1 ttl=64 time=0.096 ms
64 bytes from 172.17.0.11: icmp_seq=2 ttl=64 time=0.049 ms

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

# docker网络命令
docker network ls # 查看全部网络
docker network inspect # 查看详情

原理

我们每启动一个docker容器，docker就会给容器分配一个ip，只要安装了docker，就会有一个网卡 docker0（桥接模式），使用的技术是 evth-pair
evth-pair就是一对的虚拟设备接口，都是成对出现，一段连着协议，一段彼此相连；充当一个桥梁连接各种虚拟网络设备
OpenStac、Docker容器之间的连接、ovs的连接都是使用 evth-pair 技术

小结

Docker 使用的是 Linux 的桥接，宿主机中是一个 Docker 容器的网桥 docker0；

Docker 中的所有网络接口都是虚拟的，虚拟的转发效率非常高

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

–link

解决容器之间通过容器名字连通，而不是ip

[root@h1 ~]# docker exec -it tomcat02 ping tomcat01
ping: tomcat01: Name or service not known

# 通过 --link 可用解决网络连通问题
[root@h1 ~]# docker run -d -P --name tomcat03 --link tomcat02 tomcat
13cdc35a2d7a8a36e17ea8e792657d9d15274ebafa00a65ec4e9139e1eee82bd
[root@h1 ~]# docker exec -it tomcat03 ping tomcat02
PING tomcat02 (172.17.0.7) 56(84) bytes of data.
64 bytes from tomcat02 (172.17.0.7): icmp_seq=1 ttl=64 time=0.103 ms
64 bytes from tomcat02 (172.17.0.7): icmp_seq=2 ttl=64 time=0.052 ms

# 反向是不行的
[root@h1 ~]# docker exec -it tomcat02 ping tomcat03
ping: tomcat03: Name or service not known

本质

实际上就是host文件配置；不建议使用

[root@h1 ~]# docker exec -it tomcat03 cat /etc/hosts
127.0.0.1	localhost
::1	localhost ip6-localhost ip6-loopback
fe00::0	ip6-localnet
ff00::0	ip6-mcastprefix
ff02::1	ip6-allnodes
ff02::2	ip6-allrouters
172.17.0.7	tomcat02 6eb99db77b81
172.17.0.9	13cdc35a2d7a

[root@h1 ~]# docker inspect tomcat03

自定义网络

# --driver bridge 桥接模式
# --subnet 192.168.0.0/16 子网
# --gateway 192.168.0.1 网关
[root@h1 ~]# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
6ae6d67b007fa2b6b09e7e2e35df8e47605bacfe6e5332e6eb024fdb703924a7

# 查看所有的docker网络
[root@h1 ~]# docker network ls
NETWORK ID          NAME                   DRIVER              SCOPE
6e648e4e727e        bridge                 bridge              local
172c04d964f9        example_default        bridge              local
1facc2ab50d3        host                   host                local
6ae6d67b007f        mynet                  bridge              local
b0b32e981be7        nacosdocker2_default   bridge              local
b3c92cca4c25        nacosdocker_default    bridge              local
11289596e50f        none                   null                local

# 创建两个容器并使用自己的网络
[root@h1 ~]# docker run -d -P --name tomcat-net-01 --net mynet tomcat
[root@h1 ~]# docker run -d -P --name tomcat-net-02 --net mynet tomcat

# 查看自己创建的容器
[root@h1 ~]# docker inspect mynet
[
    {
        "Name": "mynet",
        "Id": "6ae6d67b007fa2b6b09e7e2e35df8e47605bacfe6e5332e6eb024fdb703924a7",
        "Created": "2021-11-28T10:30:06.307311998+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": {},
            "Config": [
                {
                    "Subnet": "192.168.0.0/16",
                    "Gateway": "192.168.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Ingress": false,
        "ConfigFrom": {
            "Network": ""
        },
        "ConfigOnly": false,
        "Containers": {
            "32711fbaedc4b974726ea9660d38dbe0669d32b9d24987f440cd3e4b26aaa06c": {
                "Name": "tomcat-net-01",
                "EndpointID": "8baff0c69edc806323d1ae74dbdf74a6f42c7596c8150ff2c2ebb44c0da52a60",
                "MacAddress": "02:42:c0:a8:00:02",
                "IPv4Address": "192.168.0.2/16",
                "IPv6Address": ""
            },
            "930b609fa5d18cace024987fe1c9c0e2a6ba12f7e4aaf9bdf9eb3220ceb2f84b": {
                "Name": "tomcat-net-02",
                "EndpointID": "b4ece3d4dd0e373552216eca94c8e9ee5c5930e6d299ea6ed3a3d700546eda78",
                "MacAddress": "02:42:c0:a8:00:03",
                "IPv4Address": "192.168.0.3/16",
                "IPv6Address": ""
            }
        },
        "Options": {},
        "Labels": {}
    }
]

# 再次测试两个容器网络是否连通--->可连通
# 自定义的网络，docker会自动维护好对应的关系
# 连接在同一个自定义网络的容器之间端口会自动互相暴露

从 Docker 1.10 版本开始，docker daemon 实现了一个内嵌的 DNS server，使容器可以直接通过“容器名”通信。使用默认的bridge网络，不能通过DNS server实现通过容器名通信，但是使用自定义bridge网络可以做到通过容器名互相通信。
容器中的DNS名称解析优先级顺序为：
内置DNS服务器127.0.0.11。
通过–dns等参数为容器配置的DNS服务器。
docker守护进程的–dns服务配置（默认为8.8.8.8和8.8.4.4）
宿主机上的DNS设置。

好处

不同的集群使用不同的网络，保证集群是安全和健康的

网络模式

bridge：桥接（默认）；通过中间者docker0 来连通

none：不配置网络

相当于关闭了网络

host：和宿主机共享网络

与宿主机在同一个网络中，没有独立IP地址，使用宿主机的端口资源。宿主机的ip地址就是该容器的ip地址，但是仍然使用和宿主机不同的文件系统

container：容器内网络连通（用的少）

新创建的容器和已经存在的一个容器共享一个Network Namespace，而不是和宿主机共享。新创建的容器不会创建自己的网卡，配置自己的IP，而是和一个指定的容器共享IP、端口范围等。同样，两个容器除了网络方面，其他的如文件系统、进程列表等还是隔离的。两个容器的进程可以通过lo网卡设备通信。

测试

# 默认的直接启动的命令 --net bridge 就是我们的docker0 
[root@h1 ~]# docker run -d -P --name tomcat04 --net bridge tomcat

# docker0特点：默认使用，域名不能访问；--link可打通连接

网络连通

测试打通tomcat01 - tomcat-mynet-01

# 连通之后直接将 tomcat01 放到了 mynet网络下
[root@h1 ~]# docker network connect mynet tomcat01

# 一个容器 两个ip 类似 公网ip 内网ip

# 加入之后可以连通
[root@h1 ~]# docker exec -it tomcat01 ping tomcat-net-01
PING tomcat-net-01 (192.168.0.2) 56(84) bytes of data.
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=1 ttl=64 time=0.071 ms
^C
--- tomcat-net-01 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 0.071/0.071/0.071/0.000 ms

# 未加入的仍然不可以连通
[root@h1 ~]# docker exec -it tomcat02 ping tomcat-net-01
ping: tomcat-net-01: Name or service not known

结论

如果需要跨网络操作，就需要使用 docker network connect 连通

实战：部署Redis集群

# 创建网卡
[root@h1 ~]# docker network create redis --subnet 172.38.0.0/16

# 通过脚本创建六个redis配置
for port in $(seq 1 6); \
do \
mkdir -p /mydata/docker/redis/node-${port}/conf
touch /mydata/docker/redis/node-${port}/conf/redis.conf
cat << EOF >/mydata/docker/redis/node-${port}/conf/redis.conf
port 6379
bind 0.0.0.0
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-announce-ip 172.38.0.1${port}
cluster-announce-port 6379
cluster-announce-bus-port 16379
appendonly yes
EOF
done

# 运行容器
for port in $(seq 1 6);do
    docker run -p 637${port}:6379 -p 1637${port}:16379 --name redis-${port} \
    -v /mydata/docker/redis/node-${port}/data:/data \
    -v /mydata/docker/redis/node-${port}/conf/redis.conf:/etc/redis/redis.conf \
    -d --net redis --ip 172.38.0.1${port} redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
done

# 进入容器 创建集群
docker exec -it redis-1 /bin/sh

redis-cli --cluster create 172.38.0.11:6379 172.38.0.12:6379 172.38.0.13:6379 172.38.0.14:6379 172.38.0.15:6379 172.38.0.16:6379 --cluster-replicas 1

# 查看集群信息 -三主三从
clusters nodes 

# 其中一个节点挂掉之后，从机会顶上

SpringBoot项目打包docker镜像

创建SpringBoot项目
打包应用
编写dockerfile
构建镜像
发布运行

自我小结

Docker安装之后会默认创建一个 docker0 作为网络ip分配；使用的是桥接模式，evth-pair技术；
evth-pair 是一对虚拟设备接口，成对出现，一段连接着协议，一段彼此相连；
每次启动一个容器的时候，都会新增一对网卡，并分配一个ip；容器内和宿主机网络可以通过ip连通；两个容器之间也可以通过ip连通；默认docker0 通过容器name无法ping通；
容器删除后，对应的网桥也会消失；
容器之间的通信是通过docker0 来进行路由的；
通过 --link 可以通过容器名称访问-> 实际上修改的是host文件；不推荐使用
通常要实现网络的流通（容器名）都会创建一个自定义网络； docker network
自定义网络是针对docker0的完善，不仅拥有其所有功能，更会彼此暴露添加到容器内的服务，使得可以直接通过容器名实现网络连通;->利用内置的dns
不同网络下的容器可以通过 docker network connet 添加到同一网络内，实现访问->实际上就是给其分配了一个ip（可以和公网ip、内网ip联合理解）
网络模式
- bridge 桥接，通过中间docker0 来连接；默认的；
- none 不设置网络
- host 与宿主机共享网络
- containter 容器内网络连通->两容器公用网络