首页 > 其他分享> 文章详细

Docker

2022-08-19 10:34:51 阅读：103 来源： 互联网

标签：容器 -- redis Docker root docker izt25qi5ewm4jpz

Docker

docker是什么

为什么需要docker

【1】安装软件不容易

docker的用途

【1】构建

【2】分享

【3】运行

docker的特点

【1】标准

【2】轻量级

【3】安全

docker核心概念

【1】镜像Images:镜像类似于Java的类，而容器是实例

【2】容器：一个镜像有多个容器，之间是相互隔离

【3】仓库：集中存储，hub.docker.com(官方仓库)，hub.daocloud.io(国内)

安装

生成和运行docker容器

后台运行和端口映射

dockerflile

docker在Linux下的安装

在Cent OS安装docker
【1】先有一个Cent OS 7.6系统
这个很重要，不同版本按照的时候是不一样的。
查看CentOS版本 cat /etc/redhat-release 

【2】用root账户登录进去

【3】配置国内yum源
wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo

yum clean all
yum makecache

【4】卸载旧版本
较旧的Docker版本称为docker或docker-engine。如果已安装这些程序，请卸载它们以及相关的依赖项。
yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine
如果yum报告未安装这些软件包，也没问题。

【5】更新yum
yum check-update
yum update

【6】安装所需的软件包
yum install -y yum-utils \
  device-mapper-persistent-data \
  lvm2
  
【7】使用以下命令来设置稳定的存储库。
sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

【8】查看docker版本
yum list docker-ce --showduplicates | sort -r

【9】安装指定的版本 ce社区版，ee企业版
yum install docker-ce-18.09.0 docker-ce-cli-18.09.0 containerd.io

【10】Docker 是服务器----客户端架构。命令行运行docker命令的时候，需要本机有 Docker 服务。用下面的命令启动
systemctl start docker

【11】安装完成后，运行下面的命令，验证是否安装成功。
docker version
或者
docker info

生成并运行docker容器

【Help】查看常用命令

Linux换源

【1】执行

vim /etc/docker/daemon.json

【输入】

{
"registry-mirrors":[
  "http://hub-mirror.c.163.com",
  "http://docker.mirrors.ustc.edu.cn"
]
}

【重启】

【下载，启动一个容器】

docker pull ubuntu

【运行】

docker run -i -t ubuntu /bin/bash //-i -t 将本机地址映射，如果没有下载ubuntu，会自动帮你下载

【Search，搜索查看】

 docker search redis

后台运行容器

举例：Redis实操

涉及命令：

docker run -i -t redis /bin/bash//进入镜像内部

-d

【执行】

redis-server//启动redis

【开新终端查看容器号】容器号：d295738bc99d

[root@iZt25qi5ewm4jpZ admin]# docker container ls
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS               NAMES
d295738bc99d        redis               "docker-entrypoint.s…"   12 minutes ago      Up 12 minutes       6379/tcp            brave_cocks

【执行】

docker exec -it d295738bc99d bash //进入正在运行的容器中

【执行命令进入redis】

root@d295738bc99d:/data# redis-cli
127.0.0.1:6379>

如果我们关掉之前的终端发现这边链接也断了，我们希望它能够在后台运行

【执行】

[root@iZt25qi5ewm4jpZ admin]# docker run -d redis
12dac8ef26b2f27c94ac38035196809118aa26fc6f0fb1b62ad6537022802aef

【关闭容器】docker container kill 容器号

[root@iZt25qi5ewm4jpZ admin]# docker container kill d295738bc99d 
d295738bc99d
[root@iZt25qi5ewm4jpZ admin]# docker container kill 12dac8ef26b2 
12dac8ef26b2

访问自定义容器

先关闭所有容器

[root@iZt25qi5ewm4jpZ admin]# docker run -d -p 8888:6379 redis
-p是将里面的容器和外部进行连接，8888:6379是将外部的8888端口映射到本部的6379
执行redis-cli -p 8888
[root@iZt25qi5ewm4jpZ admin]# redis-cli -p 8888
127.0.0.1:8888> 
发现可以连接

遇到的问题：redis-cli not found

原因：在centOS中没有安装redis

解决:yum install redis

127.0.0.1:8888> keys *
(empty list or set)
127.0.0.1:8888> set a b
OK
127.0.0.1:8888> keys a
1) "a"
127.0.0.1:8888> get a
"b"
127.0.0.1:8888> 
这是两个独立的redis

dockerfile

【作用】帮助开发者制作成自己的镜像

方便推广

无需考虑环境问题

制作自己的docker镜像，dockerfile实战

[admin@iZt25qi5ewm4jpZ ~]$ mkdir Dockerfile //创建文件夹
[admin@iZt25qi5ewm4jpZ ~]$ cd ./Dockerfile 
[admin@iZt25qi5ewm4jpZ Dockerfile]$ ls
[admin@iZt25qi5ewm4jpZ Dockerfile]$ vim Dockerfile //创建文件
输入内容为：
FROM ubuntu
CMD echo "imooc-java"

[admin@iZt25qi5ewm4jpZ Dockerfile]$ ls
Dockerfile

【制作过程】

[root@iZt25qi5ewm4jpZ Dockerfile]# docker build -t myimage .  //制作语句
Sending build context to Docker daemon  2.048kB
Step 1/2 : FROM ubuntu
 ---> 27941809078c
Step 2/2 : CMD echo "imooc-java"
 ---> Using cache
 ---> 5c78252418e9
Successfully built 5c78252418e9
Successfully tagged myimage:latest
[root@iZt25qi5ewm4jpZ Dockerfile]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
image               latest              5c78252418e9        5 minutes ago       77.8MB
myimage             latest              5c78252418e9        5 minutes ago       77.8MB
redis               latest              2e50d70ba706        2 weeks ago         117MB
ubuntu              latest              27941809078c        4 weeks ago         77.8MB
[root@iZt25qi5ewm4jpZ Dockerfile]# docker run myimage  //运行语句
imooc-java

狂神说docker

Docker容器学习笔记一（狂神说Java****）

狂神说B站视频：https://www.bilibili.com/video/BV1og4y1q7M4?p=1

Docker容器学习笔记二（狂神说Java）：https://blog.csdn.net/qq_41822345/article/details/107123

141

学习docker：https://www.runoob.com/docker/docker-tutorial.html

使用docker：https://labs.play-with-docker.com/

一、Docker概述

1.Docker****为什么会出现？

一款产品：开发–上线两套环境！应用环境，应用配置！

开发 — 运维。问题：我在我的电脑上可以允许！版本更新，导致服务不可用！对于运维来说考验十分

大？

环境配置是十分的麻烦，每一个机器都要部署环境(集群Redis、ES、Hadoop…) !费事费力。

发布一个项目( jar + (Redis MySQL JDK ES) )，项目能不能带上环境安装打包！

之前在服务器配置一个应用的环境 Redis MySQL JDK ES Hadoop 配置超麻烦了，不能够跨平台。

开发环境Windows，最后发布到Linux！

传统：开发jar，运维来做！

现在：开发打包部署上线，一套流程做完！

安卓流程：java — apk —发布（应用商店）一张三使用apk一安装即可用！

docker流程： java-jar（环境） — 打包项目帯上环境（镜像） — ( Docker仓库：商店）-----

Docker给以上的问题，提出了解决方案！

Docker****的思想就来自于集装箱！

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

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

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

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

2.Dcoker****的历史

2010年，几个的年轻人，就在美国成立了一家公司 dotcloud

做一些pass的云计算服务！LXC（Linux Container容器）有关的容器技术！

Linux Container容器是一种内核虚拟化技术，可以提供轻量级的虚拟化，以便隔离进程和资源。

他们将自己的技术（容器化技术）命名就是 Docker。

Docker刚刚延生的时候，没有引起行业的注意！dotCloud，就活不下去！

开源2013年，Docker开源！

越来越多的人发现docker的优点！火了。Docker每个月都会更新一个版本！

2014年4月9日，Docker1.0发布！

docker为什么这么火？十分的轻巧！

在容器技术出来之前，我们都是使用虚拟机技术！

虚拟机：在window中装一个VMware，通过这个软件我们可以虚拟出来一台或者多台电脑！笨重！

虚拟机也属于虚拟化技术，Docker容器技术，也是一种虚拟化技术！

vm : linux centos 原生镜像（一个电脑！）隔离、需要开启多个虚拟机！几个G 几分钟

docker: 隔离，镜像（最核心的环境 4m + jdk + mysql）十分的小巧，运行镜像就可以了！小巧！

几个M 秒级启动！

Docker基于Go语言开发的！开源项目！

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

文档：https://docs.docker.com/ Docker的文档是超级详细的！

仓库：https://hub.docker.com/

3.Docker能做什么？

比较Docker和虚拟机技术的不同：

传统虚拟机，虚拟出一条硬件，运行一个完整的操作系统，然后在这个系统上安装和运行软件

容器内的应用直接运行在宿主机的内容，容器是没有自己的内核的，也没有虚拟我们的硬件，所以

就轻便了

每个容器间是互相隔离，每个容器内都有一个属于自己的文件系统，互不影响

4.DevOps（开发、运维）

应用更快速的交付和部署

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

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

更便捷的升级和扩缩容

使用了 Docker之后，我们部署应用就和搭积木一样

项目打包为一个镜像，扩展服务器A！服务器B

更简单的系统运维

更高效的计算资源利用

Docker是内核级别的虚拟化，可以在一个物理机上可以运行很多的容器实例！服务器的性能可以被压榨

到极致。

二：docker的安装

#系统内核3.10以上
[root@izt25qi5ewm4jpz ~]# uname -r
3.10.0-514.26.2.el7.x86_64

一：查看系统版本

[root@izt25qi5ewm4jpz ~]# 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"

二：卸载旧版本

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

和上面一样

启动后运行

查看hello-world镜像

了解：卸载docker

1.卸载依赖
yum remove docker-ce docker-ce-cli containerd.io
2.删除资源
rm -rf /war/lib/docker

阿里云镜像加速

1.登录阿里云

2.找到服务

3.配置使用

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

回顾hello-world流程(run命令)

底层原理

Docker是怎么工作的？

Docker是一个Client-Server结构的系统，Docker的守护进程运行在主机上

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

问！

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

为什么Docker比Vm快

1、docker有着比虚拟机更少的抽象层。由于docker不需要Hypervisor实现硬件资源虚拟化,运行在

docker容器上的程序直接使用的都是实际物理机的硬件资源。因此在CPU、内存利用率上docker将会在

效率上有明显优势

2、docker利用的是宿主机的内核,而不需要Guest OS。

GuestOS： VM（虚拟机）里的的系统（OS）;

HostOS：物理机里的系统（OS）；

因此,当新建一个容器时，docker不需要和虚拟机一样重新加载一个操作系统内核。然而避免引导、加

载操作系统内核是个比较费时费资源的过程，当新建一个虚拟机时，虚拟机软件需要加载GuestOS，返

个新建过程是分钟级别的。而docker由于直接利用宿主机的操作系统,则省略了这个复杂的过程，因此

新建一个docker容器只需要几秒钟。

Docker常用命令

1.帮助命令

docker version #显示docker的版本信息。 
docker info #显示docker的系统信息，包括镜像和容器的数量 
docker 命令 --help #帮助命令 
#帮助文档的地址：https://docs.docker.com/engine/reference/commandline/build/

2.镜像命令

[root@izt25qi5ewm4jpz ~]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
hello-world         latest              feb5d9fea6a5        10 months ago       13.3kB
# 解释 
#REPOSITORY # 镜像的仓库源 
#TAG # 镜像的标签 
#IMAGE ID # 镜像的id 
#CREATED # 镜像的创建时间 
#SIZE # 镜像的大小
# 可选项
Options:
-a, --all Show all images (default hides intermediate images) #列出 所有镜像 
-q, --quiet Only show numeric IDs # 只显示镜像的id

# 搜索镜像：docker serach
docker serach mysql
# 可选项
--filter=STARS=3000

下载镜像

#下载镜像 docker pull 镜像名[:tag]
[root@izt25qi5ewm4jpz ~]# docker pull mysql
Using default tag: latest  #如果不指定版本，默认使用罪行版
latest: Pulling from library/mysql
72a69066d2fe: Pull complete  # 分层下载：docker image的核心 联合文件系统
93619dbc5b36: Pull complete 
99da31dd6142: Pull complete 
626033c43d70: Pull complete 
37d5d7efb64e: Pull complete 
ac563158d721: Pull complete 
d2ba16033dad: Pull complete 
688ba7d5c01a: Pull complete 
00e060b6d11d: Pull complete 
1c04857f594f: Pull complete 
4d7cfa90e6ea: Pull complete 
e0431212d27d: Pull complete 
Digest: sha256:e9027fe4d91c0153429607251656806cc784e914937271037f7738bd5b8e7709 #签名
Status: Downloaded newer image for mysql:latest 

#指定版本下载
[root@izt25qi5ewm4jpz ~]# docker pull mysql:5.7
5.7: Pulling from library/mysql
72a69066d2fe: Already exists    #和前面的可以公用
93619dbc5b36: Already exists 
99da31dd6142: Already exists 
626033c43d70: Already exists 
37d5d7efb64e: Already exists 
ac563158d721: Already exists 
d2ba16033dad: Already exists 
0ceb82207cd7: Pull complete 
37f2405cae96: Pull complete 
e2482e017e53: Pull complete 
70deed891d42: Pull complete 
Digest: sha256:f2ad209efe9c67104167fc609cca6973c8422939491c9345270175a300419f94
Status: Downloaded newer image for mysql:5.7

删除镜像

3.容器命令

说明：我们有了镜像才可以创建容器，下载一个centos镜像来学习

docker pull centos

新建容器并启动

docker run [可选参数] image

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


#测试
#启动并进入容器
[root@izt25qi5ewm4jpz ~]# docker run -it centos /bin/bash  #run命令会自动下载镜像
[root@e902e50296e6 /]# 
[root@e902e50296e6 /]# exit # 容器退出到主机

内部也是一个小的centos

退出exit，推出后查看在在运行的

列出所有的运行的容器

#docker ps
   #列出正在运行的容器
-a #列出正在运行的容器，顺带出历史运行过的容器
-n=? #显示最经创建的容器
-q #只显示编号

退出容器

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  #强制停止容器

4.常用其他命令

后台启动容器

#问题：启动后 docker ps，发现cenos停止了
#常见的坑：docker，容器使用后台运行，就必须要有一个前台进程，docker发现没有应用，就会自动停止
#nignx，容器启动后，发现自己没有提供服务，就会立即停止，就没有程序了

查看日记

docker logs -tf --tail
-tf #显示日志
--tail number#显示指定数量 
#自己写一段脚本执行
[root@izt25qi5ewm4jpz ~]# docker run -d centos /bin/sh -c "while true;do echo yhd ;sleep 1;done"

查看容器中进程信息：ps

top命令
docker top

查看镜像元数据

docker inspect 容器id

#测试
[root@izt25qi5ewm4jpz ~]# docker inspect d20deae384d5
[
    {
        "Id": "d20deae384d53a53ef3042eea8b299f15ea89a830fa9eab724d6e6f836d2b366",
        "Created": "2022-08-10T01:42:46.240007263Z",
        "Path": "/bin/sh",
        "Args": [
            "-c",
            "while true;do echo yhd ;sleep 1;done"
        ],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 30843,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2022-08-10T01:42:46.506450045Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:5d0da3dc976460b72c77d94c8a1ad043720b0416bfc16c52c45d4847e53fadb6",
        "ResolvConfPath": "/var/lib/docker/containers/d20deae384d53a53ef3042eea8b299f15ea89a830fa9eab724d6e6f836d2b366/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/d20deae384d53a53ef3042eea8b299f15ea89a830fa9eab724d6e6f836d2b366/hostname",
        "HostsPath": "/var/lib/docker/containers/d20deae384d53a53ef3042eea8b299f15ea89a830fa9eab724d6e6f836d2b366/hosts",
        "LogPath": "/var/lib/docker/containers/d20deae384d53a53ef3042eea8b299f15ea89a830fa9eab724d6e6f836d2b366/d20deae384d53a53ef3042eea8b299f15ea89a830fa9eab724d6e6f836d2b366-json.log",
        "Name": "/affectionate_colden",
        "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,
            "Dns": [],
            "DnsOptions": [],
            "DnsSearch": [],
            "ExtraHosts": null,
            "GroupAdd": null,
            "IpcMode": "shareable",
            "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,
            "DiskQuota": 0,
            "KernelMemory": 0,
            "MemoryReservation": 0,
            "MemorySwap": 0,
            "MemorySwappiness": null,
            "OomKillDisable": false,
            "PidsLimit": 0,
            "Ulimits": null,
            "CpuCount": 0,
            "CpuPercent": 0,
            "IOMaximumIOps": 0,
            "IOMaximumBandwidth": 0,
            "MaskedPaths": [
                "/proc/acpi",
                "/proc/kcore",
                "/proc/keys",
                "/proc/latency_stats",
                "/proc/timer_list",
                "/proc/timer_stats",
                "/proc/sched_debug",
                "/proc/scsi",
                "/sys/firmware"
            ],
            "ReadonlyPaths": [
                "/proc/asound",
                "/proc/bus",
                "/proc/fs",
                "/proc/irq",
                "/proc/sys",
                "/proc/sysrq-trigger"
            ]
        },
        "GraphDriver": {
            "Data": {
                "LowerDir": "/var/lib/docker/overlay2/d86e92ab29f9bee37b65b1978cd8733e890034201cb2a8e6b36bd5b8f2bf7e44-init/diff:/var/lib/docker/overlay2/b97010639396e59f7124d93818067709036d368fd330ab4c7e430a83a0a9b182/diff",
                "MergedDir": "/var/lib/docker/overlay2/d86e92ab29f9bee37b65b1978cd8733e890034201cb2a8e6b36bd5b8f2bf7e44/merged",
                "UpperDir": "/var/lib/docker/overlay2/d86e92ab29f9bee37b65b1978cd8733e890034201cb2a8e6b36bd5b8f2bf7e44/diff",
                "WorkDir": "/var/lib/docker/overlay2/d86e92ab29f9bee37b65b1978cd8733e890034201cb2a8e6b36bd5b8f2bf7e44/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [],
        "Config": {
            "Hostname": "d20deae384d5",
            "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 yhd ;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": "851bd7001c4bf97b40aff4b6b8839922589a0200a5d972bc9b4aafd23357dfb9",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {},
            "SandboxKey": "/var/run/docker/netns/851bd7001c4b",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "37d7c4ccbbc4719fd7f59f8170031a863192c6eb7bdf646a1b662a2233bd1e9a",
            "Gateway": "172.17.0.1",
            "GlobalIPv6Address": "",
            "GlobalIPv6PrefixLen": 0,
            "IPAddress": "172.17.0.2",
            "IPPrefixLen": 16,
            "IPv6Gateway": "",
            "MacAddress": "02:42:ac:11:00:02",
            "Networks": {
                "bridge": {
                    "IPAMConfig": null,
                    "Links": null,
                    "Aliases": null,
                    "NetworkID": "c874c8a030eab42d536980c8eb0b1188ac6464ba251d7f5f9d8a58bea94c8986",
                    "EndpointID": "37d7c4ccbbc4719fd7f59f8170031a863192c6eb7bdf646a1b662a2233bd1e9a",
                    "Gateway": "172.17.0.1",
                    "IPAddress": "172.17.0.2",
                    "IPPrefixLen": 16,
                    "IPv6Gateway": "",
                    "GlobalIPv6Address": "",
                    "GlobalIPv6PrefixLen": 0,
                    "MacAddress": "02:42:ac:11:00:02",
                    "DriverOpts": null
                }
            }
        }
    }
]

进入当前正在运行的容器

#通常容器使用后台方式运行，需要进入容器，比如修改一些配置

#命令
docker exec -it 容器id bashShell
#测试

#方式2
docker attach 容器id #进去是正在执行

#docker exec #进入容器后开启一个新的终端
#docker attach #进入容器正在执行的终端，不会启动新的进程

从容器内拷贝内容到主机

docker cp 容器id：容器内路径 目的的主机

学习方式：将所有命令敲一遍

docker命令帮助文档

作业练习

安装nignx

[root@izt25qi5ewm4jpz home]# docker run -d --name nginx01 -p 3344:80 nginx
#-d 后台运行
#--name 给容器起别名
#-p 宿主机：容器内部


#开启阿里云安全组3344端口，使用外网访问3344端口





#测试通过
[root@izt25qi5ewm4jpz home]# docker exec -it nginx01 /bin/bash
root@4ed06a579732:/# whereis nginx
nginx: /usr/sbin/nginx /usr/lib/nginx /etc/nginx /usr/share/nginx

外网访问截图

关闭容器

思考问题：每次我们改动nginx配置文件，都需要进入容器内部？十分的麻烦，我要是可以在容器外部提供一个映射路径，达到在容i外部修改文件，容器内部就可以自动修改? -v 数据卷

部署tomcat

#官方使用
docker run -it --rm tomcat:9.0

#我们之前的启动都是后台，停止了容器之后，容器还是可以查到 docker run -it -rm一般用来测试，用完就删除
#截图

#下载在启动
docker pull tomcat:9.0
#启动
docker run -d -p 3355:8080 tomcat
#测试外网可以访问

#进入容器
[root@izt25qi5ewm4jpz home]# docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS                    NAMES
53b31a983588        tomcat              "catalina.sh run"   13 minutes ago      Up 13 minutes       0.0.0.0:3355->8080/tcp   epic_meitner
[root@izt25qi5ewm4jpz home]# docker exec -it 53b31a983588  /bin/bash
#发现是阉割版：1.linux命令少了，2.没webapps，阿里云镜像的原因，默认最小的镜像，所有不必要的剔除掉
#保证最小运行环境
#将webapps.dist/的文件复制到webapps
root@53b31a983588:/usr/local/tomcat# cp -r webapps.dist/* webapps
root@53b31a983588:/usr/local/tomcat# cd webapps
root@53b31a983588:/usr/local/tomcat/webapps# ls
ROOT  docs  examples  host-manager  manager
root@53b31a983588:/usr/local/tomcat/webapps# clear
root@53b31a983588:/usr/local/tomcat/webapps# ls
ROOT  docs  examples  host-manager  manager

思考：我们以后部署项目，如果每次都要进入容器，十分麻烦？要是可以在容器外提供一个映射路径，webapps，我们在外部部署的项目自动同步到内部就好了

docker容器 tomcat+网站 docker mysql,删除容器就等于删库跑路

部署ES和kibana（以后学）

# es 暴露端口多
# es 十分耗内存
#es的数据一般需要放置到安全目录!挂载

可视化

portainer（先用这个）

docker run -d -p8088:9000 \
--restart=always -v /var/run/docker.sock:/var/run/docker.sock --pricileged=true portainer/portainer

Rancher(CI/CD再用)

什么是portainer？

Docker图形化界面！提供一个后台面板供我们操作

选择本地

平时不用

Docker镜像讲解

如何得到镜像？

从远程仓库下载
朋友拷贝给你
自己制作一个镜像 DockerFile

Docker镜像原理

多个容器共享一个内核

commit镜像

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

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

实战测试

#1.启动默认tomcat

#2.发现这个默认的tomcat是没有Webapps应用的，镜像原因，官方默认的webapps没有文件

#3.我自己拷贝进去基本文件

#4.将操作过的容器通过commit提交为一个镜像，我们以后就使用我们修改过的镜像即可

学习方式说明：理解概念，但一定实践

就相当于，把容器快照弄成镜像

到这里才算是入门

容器数据卷

什么是容器数据卷

docker的理念回顾

将应用打包成一个镜像！

数据？如果数据都在容器中，把容器删除，数据就会丢失 == 需求：数据持久化

Mysql,把mysql容器删了，删库跑路！==需求：mysql数据可以保存在本地！

容器之间有数据共享技术！Docker容器中产生的数据同步到本地！这就是卷的技术！将容器内的目录挂载在到linux上

*使用数据卷吧

方式一：直接使用命令挂载 -v
[root@izt25qi5ewm4jpz ~]# docker run -it -v 主机目录:容器目录
#启动并挂载
[root@izt25qi5ewm4jpz home]# docker run -it -v /home/ceshi:/home centos /bin/bash
#查看容器信息
[root@izt25qi5ewm4jpz home]# docker inspect 117ec7b12f5b

测试文件同步（容器-->宿主）

停止容器，宿主修改，启动容器，查看容器文件

实战：安装mysql

思考：mysql数据持久化的问题，

#拉去镜像
[root@izt25qi5ewm4jpz /]# docker pull mysql:5.7
#运行容器，需要做数据挂载，#安装启动mysql：需要配置密码

#-d:后台运行 -v路径映射 -p:端口映射 -e:配置文件  --name容器名字
[root@izt25qi5ewm4jpz /]# 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


##navicat链接测试

#进入mysql命令
[root@izt25qi5ewm4jpz mall]# docker exec -it mysql01 bash
root@d2d91ea07c38:/# mysql -uroot -p
Enter password: 
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 23
Server version: 8.0.27 MySQL Community Server - GPL

Copyright (c) 2000, 2021, Oracle and/or its affiliates.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

用navicat创建一个数据库test,在主机的data下可以看见

具名挂载和匿名挂载

#匿名挂在
-v 容器内路径
docke run -d -P --name nginx01 -v /etc/nginx nginx

[root@izt25qi5ewm4jpz /]#docke run -d -P --name nginx01 -v /etc/nginx nginx
#查看所有volume的情况
[root@izt25qi5ewm4jpz /]# docker volume ls
DRIVER              VOLUME NAME
local               077ccc108eb659170d00b17ee34cb1a0841c5556357f31b7e1cdd1b14f8a1996
# 这里发现，这种就是匿名挂在，我们在-v只写了容器内的路径，没有写容器外的路径
[root@izt25qi5ewm4jpz /]# docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx
# 通过 -v 卷名:容器内路径
#查看这个卷
docker volume inspect #显示一个或多个卷的详细信息

我们通过具名挂载可以方便找到我们的一个卷，大多数情况在使用具名挂载

#如何确定是具名还是匿名，还是指定路径
-v 容器路径 #匿名挂载
-v 卷名：容器路径 #具名挂载
-v /宿主路径:容器路径  #指定路径挂载

拓展

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

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

#ro 只要看到ro就说明这个路径只能通过宿主机来操作，服务器内部无法操作

初识Dockerfile

Dockerfile就是用来构建docker镜像的构建文件！命令脚本！先体验一下

通过这个脚本生成镜像，镜像是一层一层，脚本是一个命令，每个命令就是一层！

#创建一个dockerfile文件，名字可以随机，建议dockfile
#文件中内容
FROM centos

VOLUME ["volume01","volume02"]  #匿名挂在

CMD echo "---end----"

CMD /bin/bash

#这里的每个命令，就是镜像的一层

# -f是表示一个dockerfile文件
#-t target代表的是一个目标路径
# 最后的 .  代表的是当前对象路径下

docker build -f dockerfile全路径 -t 宿主机下的/镜像名：版本 .

docker build -f /home/docker-test-volumn/dockerfile1 -t vm-4-15-centos/centos:1.0 .

#启动自己的容器

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

#查看数据
[root@izt25qi5ewm4jpz ~]# docker ps
CONTAINER ID        IMAGE                 COMMAND                  CREATED             STATUS              PORTS                               NAMES
85fc19e1bed0        yhd/centos            "/bin/bash"              4 minutes ago       Up 4 minutes                                            xenodochial_spence
881f76852db7        nginx                 "/docker-entrypoint.…"   About an hour ago   Up About an hour    0.0.0.0:32769->80/tcp               nginx02
fda0960c7bac        nginx                 "/docker-entrypoint.…"   About an hour ago   Up About an hour    0.0.0.0:32768->80/tcp               nginx01
c87012ef1f86        mysql:5.7             "docker-entrypoint.s…"   About an hour ago   Up About an hour    33060/tcp, 0.0.0.0:3310->3306/tcp   mysql01
4c87fb6f4930        portainer/portainer   "/portainer"             6 hours ago         Up 4 hours          0.0.0.0:8088->9000/tcp              mystifying_mendeleev

[root@izt25qi5ewm4jpz ~]# docker inspect 85fc19e1bed0

查看内容是否同步，注意对应挂在卷的路径

这种用的很多，因为我们同幻刺那个会构建自己的镜像

假设构建镜像没有挂在卷，要手动镜像挂载

数据卷容器

启动三个容器

启动第二个容器挂载到容器1

[root@izt25qi5ewm4jpz ~]# docker run -it --name centos02 --volumes-from centos01 84d74e3df145

#在centos01增加一个文件

#测试:可以删除docker01，查看一下docker02和docker03是否还可以访问这个文件，发现依旧可以访问

查看挂载信息发现，都是挂载在宿主机的同一个文件

多个mysql实现数据共享

[root@izt25qi5ewm4jpz /]# docker run -d -p 3310:3306 -v /etc/mysql/conf.d -v /var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7

[root@izt25qi5ewm4jpz /]# docker run -d -p 3310:3306 -v /etc/mysql/conf.d -v /var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 --volumes-form mysql:5.7
#这个时候：可以实现两个容器数据同步

总结：容器之间配置的信息传递，数据卷容器的生命周期一直持续到没有容器使用为止

但是一旦你持久化到本地，这个时候，本地的数据是不会删除的

DockerFile

dockerfile是用来构建docker镜像的文件！命令参数脚本！

构建步骤：

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

很多官方镜像都是基础包，很多功能都没有。我们通常会自己搭建环境

官方既然可以制作，我们也可以！

dockerfile构建过程

基础知识：

1.没和指令都是大写字母

2.执行从上到下顺序执行

3.#表示注释

4.每一个指令都会创建提交一个镜像

docker是面向开发的，以后我们发布项目，就需要一个dockerfile文件，这个文件十分简单！

Docker镜像逐渐成为企业交付标准，必须要掌握

步骤：开发，部署，运维。。。缺一不可

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

DockerImages：通过dockefile构建生成的镜像，最终发布和运行的产品，原来是jar，war。

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

DockerFile的指令

实战测试

DockerHub大多数镜像都是从scratch开始,然后配置需要的软件和配置来进行构建

创建自己的centos

创建一个目录

书写文件

FROM centos:7
LABEL author=yhd<1451053372@qq.com>
ENV MYPATH /usr/local 
WORKDIR $MYPATH     #pwd后进入的目录
RUN yum -y install vim
RUN yum -y install net-tools

EXPOSE 80

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

#构建命令
[root@izt25qi5ewm4jpz dockerfile]# docker build -f mudockerfile -t mycentos:0.1 .

启动后发现命令生效

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

我们平时拿到一个镜像可以研究他是怎么做的

CMD和ENTRYPOINT的区别

构建cmdtest镜像

#编写dockerfile文件
[root@izt25qi5ewm4jpz dockerfile]# vim dockerfile-cmd-test

FROM centos:7
CMD ["ls","-a"]

#构建镜像
[root@izt25qi5ewm4jpz dockerfile]# docker build -f dockerfile-cmd-test -t cmdtest .
  
#执行镜像
[root@izt25qi5ewm4jpz dockerfile]# docker run 6e08931ea75a
.
..
.dockerenv
anaconda-post.log
bin
dev
etc
home
lib
lib64
media
mnt
opt
proc
root
run
sbin
srv
sys
tmp
usr
var


#想追加一个命令-l 变成ls-al
[root@izt25qi5ewm4jpz dockerfile]# docker run 6e08931ea75a -l
docker: Error response from daemon: OCI runtime create failed: runc create failed: unable to start container process: exec: "-l": executable file not found in $PATH: unknown.
ERRO[0000] error waiting for container: context canceled 
#cmd的清理下 -l 替换了CMD["ls","-a"] 命令，-l不是命令

#编写dockerfile
FROM centos:7
ENTRYPOINT ["ls","-a"]

#执行
[root@izt25qi5ewm4jpz dockerfile]# docker run d48eeae412e4 
.
..
.dockerenv
anaconda-post.log
bin
dev
etc
home
lib
lib64
media
mnt
opt
proc
root
run
sbin
srv
sys
tmp
usr
var

#追加-l-->ls-al
[root@izt25qi5ewm4jpz dockerfile]# docker run d48eeae412e4 -l
total 64
drwxr-xr-x  1 root root  4096 Aug 11 07:05 .
drwxr-xr-x  1 root root  4096 Aug 11 07:05 ..
-rwxr-xr-x  1 root root     0 Aug 11 07:05 .dockerenv
-rw-r--r--  1 root root 12114 Nov 13  2020 anaconda-post.log
lrwxrwxrwx  1 root root     7 Nov 13  2020 bin -> usr/bin
drwxr-xr-x  5 root root   340 Aug 11 07:05 dev
drwxr-xr-x  1 root root  4096 Aug 11 07:05 etc
drwxr-xr-x  2 root root  4096 Apr 11  2018 home
lrwxrwxrwx  1 root root     7 Nov 13  2020 lib -> usr/lib
lrwxrwxrwx  1 root root     9 Nov 13  2020 lib64 -> usr/lib64
drwxr-xr-x  2 root root  4096 Apr 11  2018 media
drwxr-xr-x  2 root root  4096 Apr 11  2018 mnt
drwxr-xr-x  2 root root  4096 Apr 11  2018 opt
dr-xr-xr-x 94 root root     0 Aug 11 07:05 proc
dr-xr-x---  2 root root  4096 Nov 13  2020 root
drwxr-xr-x 11 root root  4096 Nov 13  2020 run
lrwxrwxrwx  1 root root     8 Nov 13  2020 sbin -> usr/sbin
drwxr-xr-x  2 root root  4096 Apr 11  2018 srv
dr-xr-xr-x 13 root root     0 Apr 11  2018 sys
drwxrwxrwt  7 root root  4096 Nov 13  2020 tmp
drwxr-xr-x 13 root root  4096 Nov 13  2020 usr
drwxr-xr-x 18 root root  4096 Nov 13  2020 var

实战Tomcat

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

2.编写dockerfile文件，官方命名Dockerfile，build会自动寻找这个文件，就不需要-f制定了

FROM centos:7
LABEL author=yhd<1451053372@qq.com>

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

#ADD会自动解压,两个压缩包需要在文件同一目录里
ADD jdk-8u161-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-9.0.34.tar.gz /usr/local/

RUN yum -y install vim

ENV MYPATH /usr/local
WORKDIR $MYPATH

ENV JAVA_HOME /usr/local/jdk1.8.0_161
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools/jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.34
ENV CATALINA_BASE /usr/local/apache-tomcat-9.0.34
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

EXPOSE 8080

CMD /usr/local/apache-tomcat-9.0.34/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.34/bin/logscataline.out

3.构建成环境

[root@izt25qi5ewm4jpz tomcat]# docker build -t diytomcat .

4.运行，启动同时完成挂载

docker run -d -p 9090:8080 --name yhdtomcat -v /home/tomcat/test:/usr/local/apache-tomcat-9.0.34/webapps/test -v /home/tomcat/tomcatlogs/:/usr/local/apache-tomcat-9.0.34/logs diytomcat

5.访问9090端口

在webapps下创建test

test里面创建WEB-INF，里面创建web.xml

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" 
		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
		xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
		http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" id="WebApp_ID" version="4.0">

</web-app>

test创建index.html

菜鸟教程(runoob.com)

我的第一个标题

我的第一个段落。

我们以后开发的步骤：需要掌握dockerfile的编写，我们之后都是是使用我们的docker镜像发布运行

发布自己的镜像

DockerHUb

1.注册自己的账号

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

3.在我们服务器上提交镜像

[root@izt25qi5ewm4jpz tomcat]# docker login --help

Usage:	docker login [OPTIONS] [SERVER]

Log in to a Docker registry

Options:
  -p, --password string   Password
      --password-stdin    Take the password from stdin
  -u, --username string   Username

首先保证dockerhub登陆成功

#错误示范
[root@izt25qi5ewm4jpz tomcat]# docker push diytomcat
The push refers to repository [docker.io/library/diytomcat]
9828fbee4bf2: Preparing 
a4ada86dcbe7: Preparing 
0193b8b6f60e: Preparing 
33daad06f63e: Preparing 
174f56854903: Preparing 
denied: requested access to the resource is denied
[root@izt25qi5ewm4jpz tomcat]# 

#官方要求yuehaidong/diytomcat:1.0
#所以我们先增加标签
[root@izt25qi5ewm4jpz tomcat]# docker tag diytomcat yuehaidong/diytomcat:1.0
[root@izt25qi5ewm4jpz tomcat]# docker push yuehaidong/diytomcat:1.0

分层是docker的最重要的思想

发布镜像到阿里云容服务

登录到阿里云
找到容器金镜像服务
创建命名空间
创建容器镜像

5.浏览

开始操作

docker login --username=岳海东222 registry.cn-hangzhou.aliyuncs.com

docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/yuehaidong/yuehaidong-test:[镜像版本号]

docker push registry.cn-hangzhou.aliyuncs.com/yuehaidong/yuehaidong-test:[镜像版本号]

压缩：docker save

压缩包load：docker load

小结：

Docker网络

理解网络

清空环境

测试：

三个网络代表是三个不同的环境

#问题：docker是如何处理容器网络服务的

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

#查看容器内部网络地址 ip addr 发现容器启动的时候会得到一个eth0@if159 IP地址，docker分配的！
[root@izt25qi5ewm4jpz ~]# docker exec -it 1587cd757aaec83fb7b321122e72298170ce9d8551f1c4ed385146fab5ea047a  ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1
    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
158: eth0@if159: <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

#思考，linux服务器能不能ping通容器内部
[root@izt25qi5ewm4jpz ~]# ping 172.17.0.2
PING 172.17.0.2 (172.17.0.2) 56(84) bytes of data.
64 bytes from 172.17.0.2: icmp_seq=1 ttl=64 time=0.119 ms
64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.051 ms
64 bytes from 172.17.0.2: icmp_seq=3 ttl=64 time=0.048 ms

#Linux可以ping通docker容器内部

原理

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

#我们再次ip addr

在启动一个测试，发现又多了一堆网卡

我们发现这个容器带来的网卡，都是一对一对的

veth-pair-->就是一对的虚拟设备接口，他们都是成对出现的，一端连着协议，一端彼此相连

正因为这个特性，用来充当一个桥梁,来凝结各种虚拟网络设备

openStack，Docker容器之间的链接，OVS，都是使用veth-pair技术

3.我们来测试tomcat01和tomcat02是否可以ping通？

可以ping通，因为他们都是连接着docker0

结论：容器之间可以ping通，下图为Tomcat01pingTomcat02

结论：tomcat01和tomcat02是共用一个路由器，docker0

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

小结：

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

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

只要容器删除，对应的网桥一对就没了

--link

思考一个场景，我们编写一个微服务，database url=ip:,项目不重启，数据库ip换了，我们希望可以处理这个问题，通过名字访问容器？

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

#如何解决
[root@izt25qi5ewm4jpz ~]# docker run -d -P --name tomcat03 --link tomcat02 tomcat:7
17331081a9ac81e044bcd8d00e3c7e3372ed1084d9aee36d86b5a2058a03f350
[root@izt25qi5ewm4jpz ~]# docker exec -it tomcat03 ping tomcat02
PING tomcat02 (172.17.0.3) 56(84) bytes of data.
64 bytes from tomcat02 (172.17.0.3): icmp_seq=1 ttl=64 time=0.244 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=2 ttl=64 time=0.092 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=3 ttl=64 time=0.084 ms
^C
--- tomcat02 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 2ms
rtt min/avg/max/mdev = 0.084/0.140/0.244/0.073 ms
#通过--link可以解决网络连通发问题

#反向可以ping通吗？
[root@izt25qi5ewm4jpz ~]# docker exec -it tomcat02 ping tomcat03
ping: tomcat03: Name or service not known

探究：inspect

本质探究：--link就是我们再hosts配置文件中增加了一个172.12.0.3 tomcat02 87690ed7f49e

现在不同--link

自定义网络！不适合Docker0!

docker0问题：它不支持荣启铭连接访问

自定义网络

容器互联：

查看搜有的docker网络

[root@izt25qi5ewm4jpz ~]# docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
c874c8a030ea        bridge              bridge              local
e2d445dcbc81        host                host                local
440c7445cee2        none                null                local

网络模式

bridge:桥接docker(默认，自己创建也使用桥接模式)

none：不配置网络

host: 和宿主机共享网络

container:容器网络联通！（用的少，局限性大！）

测试：

# 我们直接启动的命令， --net bridge.而这个就是我们的docker0
[root@izt25qi5ewm4jpz ~]# docker run -d -P --name tomcat01 --net bridge tomcat

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

#我们可以自定义一个网络
# --driver bridge
# --subnet 192.168.0.0/16
# --gateway 192.168.0.1
[root@izt25qi5ewm4jpz ~]# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
7b69cdf24f67c9640304f269d1cc1f60aa884209ea3fdb5cbd7cc4fed9c7a146
[root@izt25qi5ewm4jpz ~]# docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
c874c8a030ea        bridge              bridge              local
e2d445dcbc81        host                host                local
7b69cdf24f67        mynet               bridge              local
440c7445cee2        none                null                local

我们自己的网络就创建好了

[root@izt25qi5ewm4jpz ~]# docker run -d -P --name tomcat01 --net mynet tomcat:7
d0368da9b346f9dea4b08f579b7c42fc3ea5e20d31bcbcee738f0418a687dad6
[root@izt25qi5ewm4jpz ~]# docker run -d -P --name tomcat02 --net mynet tomcat:7
4c80dc4b4a301485ac867229ace20ed8d5afa99c482657c3ce8c8f82381172ab
[root@izt25qi5ewm4jpz ~]# docker network inspect mynet
[
    {
        "Name": "mynet",
        "Id": "7b69cdf24f67c9640304f269d1cc1f60aa884209ea3fdb5cbd7cc4fed9c7a146",
        "Created": "2022-08-18T13:50:59.035459214+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": {
            "4c80dc4b4a301485ac867229ace20ed8d5afa99c482657c3ce8c8f82381172ab": {
                "Name": "tomcat02",
                "EndpointID": "f40700b81c22785ff05ef6add8d287d2414361ba277f563bfb168a62cc390ae3",
                "MacAddress": "02:42:c0:a8:00:03",
                "IPv4Address": "192.168.0.3/16",
                "IPv6Address": ""
            },
            "d0368da9b346f9dea4b08f579b7c42fc3ea5e20d31bcbcee738f0418a687dad6": {
                "Name": "tomcat01",
                "EndpointID": "5794f0eae995b8843967541a730922586ce1752949174f6cb903a9adda9efe1c",
                "MacAddress": "02:42:c0:a8:00:02",
                "IPv4Address": "192.168.0.2/16",
                "IPv6Address": ""
            }
        },
        "Options": {},
        "Labels": {}
    }
]

#再次测试ping链接
[root@izt25qi5ewm4jpz ~]# docker exec tomcat01 ping 192.168.0.3
PING 192.168.0.3 (192.168.0.3) 56(84) bytes of data.
64 bytes from 192.168.0.3: icmp_seq=1 ttl=64 time=0.091 ms
64 bytes from 192.168.0.3: icmp_seq=2 ttl=64 time=0.058 ms
64 bytes from 192.168.0.3: icmp_seq=3 ttl=64 time=0.062 ms
64 bytes from 192.168.0.3: icmp_seq=4 ttl=64 time=0.107 ms

#现在不使用--link也可以ping通
[root@izt25qi5ewm4jpz ~]# docker exec tomcat01 ping tomcat02
PING tomcat02 (192.168.0.3) 56(84) bytes of data.
64 bytes from tomcat02.mynet (192.168.0.3): icmp_seq=1 ttl=64 time=0.050 ms
64 bytes from tomcat02.mynet (192.168.0.3): icmp_seq=2 ttl=64 time=0.062 ms
64 bytes from tomcat02.mynet (192.168.0.3): icmp_seq=3 ttl=64 time=0.062 ms

我们自定义的网络docker都已经帮我们维护好了对应的关系，推荐我们平时这样使用网络

好处：

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

网络联通

#测试打通 tomcat01 - mynet
#联通之后，将tomcat01-docker0放置mynet网络下
#一个容器两个地址
[root@izt25qi5ewm4jpz ~]# docker network connect mynet tomcat01-docker0
[root@izt25qi5ewm4jpz ~]# docker network inspect mynet

tomat02容器没有打通到docker0,所以ping不了tomcat01-docker0

结论：假设要跨网络操作别人，就需要使用docker network connect联通

实战：部署redis集群

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

# 通过脚本创建6个redis
for port in $(seq 1 6); \
do \
mkdir -p /mydata/redis/node-${port}/conf/redis-conf
cat << EOF >/mydata/redis/node-${port}/conf/redis.conf
port 6379
bind 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
#启动服务
[root@izt25qi5ewm4jpz conf]# docker run -p 6371:6379 -p 16371:16379 --name redis-1 -v /mydata/redis/node-1/data:/data -v /mydata/redis/node-1/conf/redis.conf:/etc/redis/redis.conf -d --net redis --ip 172.38.0.12 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

[root@izt25qi5ewm4jpz conf]# docker run -p 6372:6379 -p 16372:16379 --name redis-2 -v /mydata/redis/node-2/data:/data -v /mydata/redis/node-2/conf/redis.conf:/etc/redis/redis.conf -d --net redis --ip 172.38.0.12 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

[root@izt25qi5ewm4jpz conf]# docker run -p 6373:6379 -p 16373:16379 --name redis-3 -v /mydata/redis/node-3/data:/data -v /mydata/redis/node-3/conf/redis.conf:/etc/redis/redis.conf -d --net redis --ip 172.38.0.13 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

[root@izt25qi5ewm4jpz conf]# docker run -p 6374:6379 -p 16374:16379 --name redis-4 -v /mydata/redis/node-4/data:/data -v /mydata/redis/node-4/conf/redis.conf:/etc/redis/redis.conf -d --net redis --ip 172.38.0.14 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

[root@izt25qi5ewm4jpz conf]# docker run -p 6375:6379 -p 16375:16379 --name redis-5 -v /mydata/redis/node-5/data:/data -v /mydata/redis/node-5/conf/redis.conf:/etc/redis/redis.conf -d --net redis --ip 172.38.0.15 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

[root@izt25qi5ewm4jpz conf]# docker run -p 6376:6379 -p 16376:16379 --name redis-6 -v /mydata/redis/node-6/data:/data -v /mydata/redis/node-5/conf/redis.conf:/etc/redis/redis.conf -d --net redis --ip 172.38.0.16 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

部署springboot

打包，写Dockerfile

标签：容器,--,redis,Docker,root,docker,izt25qi5ewm4jpz
来源： https://www.cnblogs.com/yhdxx/p/16601128.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

Docker

Docker

docker在Linux下的安装

生成并运行docker容器

Linux换源

后台运行容器

访问自定义容器

dockerfile

制作自己的docker镜像，dockerfile实战

狂神说docker

4.DevOps（开发、运维）

二：docker的安装

阿里云镜像加速

回顾hello-world流程(run命令)

底层原理

Docker常用命令

1.帮助命令

2.镜像命令

下载镜像

删除镜像

3.容器命令

4.常用其他命令

作业练习

安装nignx

部署tomcat

部署ES和kibana（以后学）

可视化

Docker镜像讲解

Docker镜像原理

commit镜像

容器数据卷

实战：安装mysql

具名挂载和匿名挂载

初识Dockerfile

数据卷容器

DockerFile

dockerfile构建过程

DockerFile的指令

实战测试

实战Tomcat

我的第一个标题

发布自己的镜像

Docker网络

veth-pair-->就是一对的虚拟设备接口，他们都是成对出现的，一端连着协议，一端彼此相连

--link

自定义网络

网络联通

实战：部署redis集群

部署springboot