首页 > 其他分享 >Docker

Docker

时间：2022-08-19 10:40:42浏览次数：71  
标签：容器 -- 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

和上面一样

启动后运行

image-20220809204939296

查看hello-world镜像

image-20220809205031621

了解：卸载docker

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

阿里云镜像加速

1.登录阿里云

2.找到服务

image-20220809205446771

image-20220809205554865

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命令)

image-20220809204939296

image-20220809210429160

底层原理

Docker是怎么工作的？

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

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

问！

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

image-20220809210739345

为什么Docker比Vm快

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

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

效率上有明显优势

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

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

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

image-20220809210935850

因此,当新建一个 容器时，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

image-20220809212144331

下载镜像

#下载镜像 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

image-20220809213004379

删除镜像

image-20220809213157753

image-20220809213428009

3.容器命令

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

docker pull centos

image-20220809213838102

新建容器并启动

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 # 容器退出到主机

image-20220809214450508

内部也是一个小的centos

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

列出所有的运行的容器

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

image-20220809214652420

退出容器

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

image-20220809215217809

删除容器

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.常用其他命令

后台启动容器

image-20220810093218660

#问题：启动后 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"

image-20220810094304754

image-20220810094411167

查看容器中进程信息：ps

top命令
docker top

image-20220810094847464

查看镜像元数据

docker inspect 容器id

image-20220810095237584

#测试
[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
#测试

image-20220810095713093

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

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

从容器内拷贝内容到主机

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

image-20220810100837368

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

image-20220810101036558

docker命令帮助文档

image-20220810101312180

image-20220810101338450

作业练习

安装nignx

image-20220810101803494

image-20220810102538723

[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

image-20220810102929277

外网访问截图

image-20220810103532293

关闭容器

image-20220810103725585

image-20220810103736074

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

部署tomcat

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

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

image-20220810104740992

#下载在启动
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

image-20220810111711844

思考：我们以后部署项目，如果每次都要进入容器，十分麻烦？要是可以在容器外提供一个映射路径，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图形化界面！提供一个后台面板供我们操作

image-20220810142005396

选择本地

image-20220810142320271

平时不用

Docker镜像讲解

image-20220810142416304

如何得到镜像？

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

Docker镜像原理

image-20220810143226193

多个容器共享一个内核

image-20220810143505268

image-20220810143950390

image-20220810144016203

image-20220810144046869

image-20220810144105529

image-20220810144720537

commit镜像

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

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

实战测试

#1.启动默认tomcat

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

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

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

image-20220810150143534

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

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

到这里才算是入门

容器数据卷

什么是容器数据卷

docker的理念回顾

将应用打包成一个镜像！

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

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

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

image-20220810153434616

*使用数据卷吧

方式一：直接使用命令挂载 -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

image-20220810154431171

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

image-20220810154914982

image-20220810160612428

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

image-20220810160656680

实战：安装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.

image-20220810164923118

image-20220810165021247

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

image-20220810165720863

具名挂载和匿名挂载

#匿名挂在
-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 #显示一个或多个卷的详细信息

image-20220810171359421

image-20220810171720228

image-20220810172019366

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

#如何确定是具名还是匿名，还是指定路径
-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 .

image-20220810175335051

#启动自己的容器

image-20220810180128099

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

#查看数据
[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

image-20220810180612949

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

image-20220810180935646

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

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

数据卷容器

image-20220811090841602

启动三个容器

image-20220811090457599

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

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

image-20220811091353387

#在centos01增加一个文件

image-20220811092041378

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

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

image-20220811094851078

多个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镜像的文件！命令参数脚本！

构建步骤：

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

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

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

dockerfile构建过程

基础知识：

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

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

3.#表示注释

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

image-20220811133144370

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

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

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

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

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

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

DockerFile的指令

image-20220811133228563

实战测试

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

创建自己的centos

创建一个目录

image-20220811134508703

书写文件

FROM centos:7
LABEL author=yhd<[email protected]>
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

image-20220811140141478

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

启动后发现命令生效

image-20220811142020435

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

image-20220811142228232

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

CMD和ENTRYPOINT的区别

image-20220811144030778

构建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<[email protected]>

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端口

image-20220811165221662

在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)

我的第一个标题

我的第一个段落。

image-20220811165429917

我们以后开发的步骤：需要掌握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登陆成功

image-20220811170432166

#错误示范
[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

image-20220811171422134

分层是docker的最重要的思想

image-20220811172421104

发布镜像到阿里云容服务

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

image-20220811172046616

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:[镜像版本号]

image-20220811173713649

压缩：docker save

压缩包load：docker load

小结：

image-20220811174159700

Docker网络

理解网络

清空环境

测试：

image-20220811175338141

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

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

image-20220811175615427

[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

image-20220818103234142

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

image-20220818103818898

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

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

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

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

image-20220818104422005

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

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

image-20220818105308149

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

image-20220818110630033

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

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

小结：

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

image-20220818111956818

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

image-20220818115034179

image-20220818120319718

本质探究：--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

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

image-20220818135419208

[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-不同的集群使用不同的网络，保证集群的安全和健康

网络联通

image-20220818141843892

image-20220818140957423

image-20220818141050393

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

image-20220818141434412

image-20220818141505976

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
From： https://www.cnblogs.com/yhdxx/p/16601128.html

相关文章

  • Docker安装Redis
    1.下载Redis镜像sudodockerpullredis 2.启动Redissudomkdir-p/mydata/redis/confsudotouch/mydata/redis/conf/redis.confsudodockerrun-p63......
  • Docker镜像的导出导入
    1.import+export1.1导出示例dockerexport-onginx-test.tarnginx-test*-o表示输出到文件*nginx-test.tar为目标文件*nginx-test是源容器名（na......
  • Docker快速入门--刘清政
    转载：https://www.cnblogs.com/liuqingzheng/p/16315254.html1Docker简介1.1什么是虚拟化​在计算机中，虚拟化（英语：Virtualization）是一种资源管理技术，是将计算机的各......
  • Dockers安装Oracle 11g
    1，下载Oracle镜像dockerpullregistry.cn-hangzhou.aliyuncs.com/helowin/oracle_11g 2，启动容器dockerrun-d-p1521:1521--nameoracleregistry.cn-hangzh......
  • Docker安装MySQL
    1，docker仓库搜索mysqldockersearchmysql  2，docker仓库拉取mysql8.0dockerpullmysql:8.0  3，查看本地仓库镜像是否下载成功dockerimagesmysql:8.0......
  • Docker安装nacos
    1.下载Nacos镜像sudodockerpullnacos/nacos-server:1.3.2 2.创建数据库/**Copyright1999-2018AlibabaGroupHoldingLtd.**LicensedundertheApac......
  • Docker Compose
    简介之前使用docker时，写完一个项目之后需要定义一个dockerfile，再通过dockerbuild生成一个镜像，并通过dockerrun执行；都是通过手动操作，用于单个容器，非常麻烦，现在想要的效......
  • docker compose搭建redis7.0.4高可用一主二从三哨兵集群并整合SpringBoot【图文完整版
    一、前言redis在我们企业级开发中是很常见的，但是单个redis不能保证我们的稳定使用，所以我们要建立一个集群。redis有两种高可用的方案：HighavailabilitywithRedisSen......
  • macOS+vagrant+vmware搭建centos7下的docker环境
    下载vagrant#方法一：命令行安装brewinstallvagrant#方法二：下载镜像安装https://releases.hashicorp.com/vagrant/2.3.0/vagrant_2.3.0_darwin_amd64.dmg下载vmw......
  • docker 安装和使用
    目录安装配置镜像仓库配置安装配置镜像仓库配置Desktop配置......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99