龙空技术网

Docker详谈

空间星谷 101

前言:

今天各位老铁们对“docker中装docker”大概比较关怀,我们都想要分析一些“docker中装docker”的相关资讯。那么小编也在网摘上汇集了一些有关“docker中装docker””的相关内容,希望你们能喜欢,兄弟们一起来学习一下吧!

目录DockerDocker概述Docker安装Docker基本组成安装Docker回顾HelloWorld启动流程底层上原理Docker的常用命令帮助命令镜像命令容器命令常用的其他命令练习可视化Docker镜像讲解容器数据卷什么是容器数据卷?使用数据卷实战:安装MySQL具名挂载和匿名挂载初始Dockerfile数据卷容器DockerFileDockerFile构建过程DockerFile的指令实战测试实战:Tomcat发布自己的镜像Docker网络理解Docker0自定义网络网络连通实战:部署Redis集群SpringBoot微服务打包Docker镜像DockerDocker概述Docker为什么出现?我电脑上可以运行!但是其他机器上跑不起来!环境配置是十分麻烦的,每个机器都要部署环境(集群redis、ES、Hadoop...)!费时费力!发布一个项目(jar + (Redis、MySQL、jdk ES)),项目能不能都带上环境安装打包!之前:开发jar,运维来做!现在:开发打包部署上线,一套流程做完!java --- apk --- 发布(应用商店)--- 张三使用apk --- 安装即可用!java --- jar(环境)--- 打包项目带上环境(镜像) --- (Docker仓库:商店) --- 下载我们发布的镜像 --- 直接运行即可!Docker核心思想Docker的思想来自于集装箱隔离:Docker核心思想!打包装箱!每个箱子是互相隔离的。Docker通过隔离机制,可以将服务器利用到极致!Docker的历史2010年,几个搞it的年轻人,就在美国成立一家公司dotCloudDocker刚刚诞生的时候,没有引起行业的注意,救火不下去!开源2013年 Docker开源!Docker越来越多人发现优点!火了!Docker每个月都会更新一个版本!2014年4月9日,Docker1.0发布!Docker为什么这么火?十分轻巧!在容器技术出来之前,我们都是使用虚拟机技术!虚拟机:在window中装一个Vmware,通过这个软件我们可以虚拟出来一台或者多台电脑!笨重!虚拟机也是属于虚拟化技术。Docker容器技术,也是一种 虚拟机化技术!vm : linux centos原生镜像(一个电脑) 隔离:需要开启多个虚拟机! 几个G 启动几分钟docker:隔离,镜像(最核心的环境(linux) 4m + jdk + mysql)十分的小巧,运行镜像就可以了!小巧! 几个M 秒级启动!聊聊DockerDocker是基于Go语言开发的!开源项目!官方地址:文档地址: Docker的文档超级详细的!~仓库地址: git push ; git pullDocker能干嘛

之前的虚拟机技术

虚拟机技术缺点:

1、资源占用十分多

2、冗余步骤多

3、启动很慢

容器化技术

容器化技术不是模拟的一个完整的

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

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

DevOps(开发、运维)

应用更快速的交付和部署

传统:一堆帮助文档,安装程序

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

更便捷的升级和扩容

使用docker之后,我们部署应用就和搭积木一样!

Springboot 1.5 Redis 5 tomcat 8 以前一个一个升级 现在把他们都打成一个镜像

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

更简单的系统运维

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

更高效的计算资源利用

1核 2g的服务器 搞十几个redis没问题

Docker 是 内核级别的虚拟机,可以在一个物理机上可以运行很多容器实例!服务器的性能可以被压榨到极致。

Docker安装

Docker基本组成

镜像【image】:

docker镜像就好比一个模板,可以通过这个模板来创建容器服务,tomcat镜像》run》tomcat01容器(提供服务),通过这个镜像可以创建多个容器(最终服务运行或者项目运行就是在容器中的)。

容器【container】:

Docker利用容器技术,独立运行一个或者一组应用,通过镜像来创建的。

启动、停止、删除、基本命令!

目前就可以把这个容器理解为就是一个简易的linux系统

仓库【repository】:

仓库就是存放镜像的地方!

仓库分为公有仓库和私有仓库!

Docker Hub(默认是国外的)

阿里云...都有容器服务器(配置镜像加速)!

安装Docker

win10安装教程[windows 10 安装docker - 知乎 (zhihu.com)]验证安装成功1、hello-world

docker run hello-world

2、查看这个hello-world镜像

docker images

回顾HelloWorld启动流程

run的启动流程

底层上原理

Docker是怎么工作的?

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

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

Docker为什么比虚拟机快?

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

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

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

Docker的常用命令

帮助命令

docker version #显示docker的版本信息

docker info #显示docker的系统信息,包括镜像和容器的数量

docker 命令 --help #万能命令

帮助文档的地址:

镜像命令

docker images #查看本地主机上的镜像

D:\component\Docker>docker images

REPOSITORY TAG IMAGE ID CREATED SIZE

hello-world latest d1165f221234 5 months ago 13.3kB

#解释

REPOSITORY 镜像的仓库源

TAG 镜像的标签

IMAGE ID 镜像的ID

CREATED 镜像的创建时间

SIZE 镜像的 大小

#可选项

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

List images

Options:

-a, --all #列出所有的镜像

-q, --quiet #只显示镜像id

docker search 搜索镜像

D:\component\Docker>docker search mysql

NAME DESCRIPTION STARS OFFICIAL AUTOMATED

mysql MySQL is a widely used, open-source relation… 11308 [OK]

mariadb MariaDB Server is a high performing open sou… 4294 [OK]

#可选项

D:\component\Docker>docker search mysql --filter=stars=5000

NAME DESCRIPTION STARS OFFICIAL AUTOMATED

mysql MySQL is a widely used, open-source relation… 11308 [OK]

D:\component\Docker>docker search mysql --filter=stars=3000

NAME DESCRIPTION STARS OFFICIAL AUTOMATED

mysql MySQL is a widely used, open-source relation… 11308 [OK]

mariadb MariaDB Server is a high performing open sou… 4294 [OK]

docker pull 下载镜像

#下载镜像 docker pull 镜像名[:tag]

D:\component\Docker>docker pull mysql

Using default tag: latest#如果不写tag 默认就是latest

latest: Pulling from library/mysql

e1acddbe380c: Pull complete #分层下载,docker image的核心 联合文件系统

bed879327370: Pull complete

03285f80bafd: Pull complete

ccc17412a00a: Pull complete

1f556ecc09d1: Pull complete

adc5528e468d: Pull complete

1afc286d5d53: Pull complete

6c724a59adff: Pull complete

0f2345f8b0a3: Pull complete

c8461a25b23b: Pull complete

3adb49279bed: Pull complete

77f22cd6c363: Pull complete

Digest: sha256:d45561a65aba6edac77be36e0a53f0c1fba67b951cb728348522b671ad63f926 #签名 防伪

Status: Downloaded newer image for mysql:latest

docker.io/library/mysql:latest #真实地址

#等价

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

#指定版本下载

D:\component\Docker>docker pull mysql:5.7

5.7: Pulling from library/mysql

e1acddbe380c: Already exists

bed879327370: Already exists

03285f80bafd: Already exists

ccc17412a00a: Already exists

1f556ecc09d1: Already exists

adc5528e468d: Already exists

1afc286d5d53: Already exists

4d2d9261e3ad: Pull complete

ac609d7b31f8: Pull complete

53ee1339bc3a: Pull complete

b0c0a831a707: Pull complete

Digest: sha256:7cf2e7d7ff876f93c8601406a5aa17484e6623875e64e7acc71432ad8e0a3d7e

Status: Downloaded newer image for mysql:5.7

docker.io/library/mysql:5.7

D:\component\Docker>docker images

REPOSITORY TAG IMAGE ID CREATED SIZE

mysql 5.7 6c20ffa54f86 4 days ago 448MB

mysql latest 5a4e492065c7 4 days ago 514MB

hello-world latest d1165f221234 5 months ago 13.3kB

docker rmi 删除镜像

docker rmi -f 镜像ID #删除指定的镜像

docker rmi -f 镜像ID 镜像ID 镜像ID ...#删除多个镜像

docker rmi -f $(docker images -aq) #删除所有镜像

容器命令

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

docker pull centos

新建容器并启动

docker run [可选参数] image

#参数说明

--name="Name" 容器名字tomcat01 tomcat02 用来区分容器

-d 后台方式运行

-it 使用交互方式运行,进入容器查看内容

-p 指定容器的端口 -p 8080:8080

-p ip:主机端口:容器端口

-p 主机端口:容器端口 (常用)

-p 容器端口

容器端口

-P 随机指定端口(注意大P小p是有区别的)

#测试 启动并进入容器

D:\component\Docker>docker run -it centos /bin/bash

[root@2d16c66af894 /]# ls #查看容器内部的centos,基础版本,很多命令都是不完善的!

bin dev etc home lib lib64 lost+found media mnt opt proc root run sbin srv sys tmp usr var

#从容器中退回主机

[root@2d16c66af894 /]# exit

exit

列出所有运行的容器

#docker ps 命令

#列出当前正在运行的容器

-a #列出当前正在运行的容器+带出历史运行过的容器

-n=? #显示最近创建的容器

-q #只显示容器的编号

D:\component\Docker>docker ps

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

D:\component\Docker>docker ps -a

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

2d16c66af894 centos "/bin/bash" 3 minutes ago Exited (0) About a minute ago hardcore_panini

7a1d82fcfc07 hello-world "/hello" 2 hours ago Exited (0) 2 hours ago awesome_almeida

退出容器

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 #停止正在运行的容器

dokcer kill 容器id #强制杀掉正在运行的容器

常用的其他命令

后台启动容器

#命令 docker run -d 镜像名!

D:\component\Docker>docker run -d centos

31bc0b215d1aa72d8ddb1f43649a6dd3001343331f8462020a554896ace161fe

#问题 docker ps 发现 centos 停止了

D:\component\Docker>docker ps

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

#常见的坑:docker 容器使用后天运行,就必须要有一个前台进程,docker发现没有应用,就会自动停止

#nginx,容器启动后,发现自己没有提供服务,就会立刻停止,就是没有程序了

查看日志

docker logs -tf --tail 070b557c2ee3

#自己编写一段shell脚本

D:\component\Docker>docker run -d centos /bin/sh -c "while true; do echo summer;sleep 1;done"

27d74163158d8309d3b61d2b9f8ee55e2eab063b73e7f2b8ae504e7e96991835

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

27d74163158d centos "/bin/sh -c 'while t…" 2 minutes ago Up 2 minutes naughty_ritchie

#显示日志

-tf #显示所有日志

--tail [number] #要显示日志条数

docker logs -tf --tail 100 27d74163158d

查看容器中的进程信息

# docker top 容器id

D:\component\Docker>docker top 27d74163158d

UID PID PPID C STIME TTY

root 2044 2024 0 08:49 ?

root 2475 2044 0 08:55 ?

#UID 当前用户id

#PID 父id

#PPID 进程id

查看镜像的元数据

#命令

docker inspect 容器id

#测试

D:\component\Docker>docker inspect 27d74163158d

[

{

"Id": "27d74163158d8309d3b61d2b9f8ee55e2eab063b73e7f2b8ae504e7e96991835",

"Created": "2021-08-22T08:49:08.4758738Z",

"Path": "/bin/sh",

"Args": [

"-c",

"while true; do echo summer;sleep 1;done"

],

"State": {

"Status": "running",

"Running": true,

"Paused": false,

"Restarting": false,

"OOMKilled": false,

"Dead": false,

"Pid": 2044,

"ExitCode": 0,

"Error": "",

"StartedAt": "2021-08-22T08:49:08.8838869Z",

"FinishedAt": "0001-01-01T00:00:00Z"

},

"Image": "sha256:300e315adb2f96afe5f0b2780b87f28ae95231fe3bdd1e16b9ba606307728f55",

"ResolvConfPath": "/var/lib/docker/containers/27d74163158d8309d3b61d2b9f8ee55e2eab063b73e7f2b8ae504e7e96991835/resolv.conf",

"HostnamePath": "/var/lib/docker/containers/27d74163158d8309d3b61d2b9f8ee55e2eab063b73e7f2b8ae504e7e96991835/hostname",

"HostsPath": "/var/lib/docker/containers/27d74163158d8309d3b61d2b9f8ee55e2eab063b73e7f2b8ae504e7e96991835/hosts",

"LogPath": "/var/lib/docker/containers/27d74163158d8309d3b61d2b9f8ee55e2eab063b73e7f2b8ae504e7e96991835/27d74163158d8309d3b61d2b9f8ee55e2eab063b73e7f2b8ae504e7e96991835-json.log",

"Name": "/naughty_ritchie",

"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,

"CgroupnsMode": "host",

"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": [

35,

122

],

"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/d42a9289bcc5fdbe03c603fa55f4481c10da96f2a2dbfb5daae5549090d2ec08-init/diff:/var/lib/docker/overlay2/8c2b6e75bd894730e473521dfacb843e578ae938004b3d9da550a9003bb61195/diff",

"MergedDir": "/var/lib/docker/overlay2/d42a9289bcc5fdbe03c603fa55f4481c10da96f2a2dbfb5daae5549090d2ec08/merged",

"UpperDir": "/var/lib/docker/overlay2/d42a9289bcc5fdbe03c603fa55f4481c10da96f2a2dbfb5daae5549090d2ec08/diff",

"WorkDir": "/var/lib/docker/overlay2/d42a9289bcc5fdbe03c603fa55f4481c10da96f2a2dbfb5daae5549090d2ec08/work"

},

"Name": "overlay2"

},

"Mounts": [],

"Config": {

"Hostname": "27d74163158d",

"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 summer;sleep 1;done"

],

"Image": "centos",

"Volumes": null,

"WorkingDir": "",

"Entrypoint": null,

"OnBuild": null,

"Labels": {

"org.label-schema.build-date": "20201204",

"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": "70b04e3cc7e4081e118702a40d6bbb0d3e4b4143bee7eea936b51b561cfd1f38",

"HairpinMode": false,

"LinkLocalIPv6Address": "",

"LinkLocalIPv6PrefixLen": 0,

"Ports": {},

"SandboxKey": "/var/run/docker/netns/70b04e3cc7e4",

"SecondaryIPAddresses": null,

"SecondaryIPv6Addresses": null,

"EndpointID": "9e22dbccce17c8d814238d6b42eebe2102be8bec43497ef7a65a60e60a62e8b4",

"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": "6249d12665277ae8bdc8a67de3558072a7ac79704b469bc9db992a0673964143",

"EndpointID": "9e22dbccce17c8d814238d6b42eebe2102be8bec43497ef7a65a60e60a62e8b4",

"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 /bin/bash

#方式二:

docker attach 容器id

正在执行当前的代码

#区别

docker exec #进入容器后开启一个新的终端,可以在里面操作(常用)

docker attach #进入容器正在执行的终端,不会启动新的进程

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

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

#测试

D:\component\Docker>docker exec -it 1231abb1bc75 /bin/bash

[root@1231abb1bc75 /]# cd /home/

[root@1231abb1bc75 home]# ls

[root@1231abb1bc75 home]# touch summer.java

[root@1231abb1bc75 home]# ls

summer.java

[root@1231abb1bc75 home]# exit

D:\component\Docker>docker ps

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

1231abb1bc75 centos "/bin/bash" 3 minutes ago Up 3 minutes stupefied_engelbart

D:\component\Docker>docker cp 1231abb1bc75:/home/summer.java D:\component\Docker

#拷贝是一个手动过程,未来我们使用-v 卷的技,可以实现

练习

Docker来安装nginx

#搜索镜像

docker search nginx

#下载镜像

docker pull nginx

#启动容器

docker run -d --name nginx01 -p 3344:80 nginx

# 输入localhost:3344验证

端口暴露的概念

外网3344--》通过阿里云映射linux3344 --》 linux宿主机上3344和docker中的容器80映射上

#测试 可以看到nginx的配置

D:\component\Docker>docker exec -it 84aa0c78ee53 /bin/bash

root@84aa0c78ee53:/# whereis nginx

nginx: /usr/sbin/nginx /usr/lib/nginx /etc/nginx /usr/share/nginx

root@84aa0c78ee53:/# cd /etc/nginx

root@84aa0c78ee53:/etc/nginx# ls

conf.d fastcgi_params mime.types modules nginx.conf scgi_params uwsgi_params

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

Docker装Tomcat

#官方推荐

docker run -it --rm tomcat:9.0

#我们之前的启动都是后台,停止了容器之后,容器还是可以查到 docker run -it --rm 一般用来测试 用完就删除【我们一开始不建议这么用】

#下载在启动

docker pull tomcat

docker run -d --name tomcat01 -p 3355:8080 tomcat

docker exec -it tkmcat01 /bin/bash

#发现问题?

#1、linux命令少了;2、没有webapps

#因为只是保证了最小可运行环境

可以把webapps.dist 目录下文件 复制到webapps 就能显示出html了

思考问题:我们以后要部署项目,如果每次都要进入容器是不是十分麻烦?我们要是可以在容器外部提供一个映射路径,webapps,我们在外部放置项目,就自动同步到内部就好了!

部署 ES + kibana

#es 暴露的接口很多

#es 十分的耗内存

#es 的数据一般需要放置到安全目录!挂载!

#启动 elasticsearch

#--net somenetwork 网络配置之后讲

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

D:\component\Docker>docker ps

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

4d38bc435f48 elasticsearch "/docker-entrypoint.…" About a minute ago Up About a minute 0.0.0.0:9200->9200/tcp, :::9200->9200/tcp, 0.0.0.0:9300->9300/tcp, :::9300->9300/tcp elasticsearch

#启动了 就卡主了 docker stats 查看CPU的状态 启动成功了看下图localhost:9200

#es 是十分耗内存的 1点几个G

#停止整个docker

# docker stats 查看CPU的状态

D:\component\Docker>docker stats

CONTAINER ID NAME CPU % MEM USAGE / LIMIT MEM % NET I/O BLOCK I/O PIDS

4d38bc435f48 elasticsearch 0.24% 2.228GiB / 24.93GiB 8.94% 906B / 0B 0B / 0B 58

CONTAINER ID NAME CPU % MEM USAGE / LIMIT MEM % NET I/O BLOCK I/O PIDS

4d38bc435f48 elasticsearch 0.12% 2.228GiB / 24.93GiB 8.94% 906B / 0B 0B / 0B 58

#测试一下es是否成功

#测试完赶快关掉,增加内存的限制

#赶紧关闭,增加内存的限制,修改配置文件 -e 环境配置修改 ES_JAVA_OPTS="-Xms 64m -Xmx512m"限制内存

docker run -d --name elasticsearch01 -p 9200:9200 -p 9300:9300 -e ES_JAVA_OPTS="-Xms64m -Xmx512m" -e "discovery.type=single-node" elasticsearch

#查看 docker stats

思考:使用kibana链接es?通过docker 网络才能链接过去

可视化

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

Docker镜像讲解

镜像是什么?

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

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

如何得到镜像:

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

Docker镜像加载原理

UnionFS(UFS联合文件系统)

我们下载的时候看到的一层层就是这个!

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

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

docker的镜像实际上有一层一层的文件系统组成,这个层级的文件系统UFS。

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

e.g. 装机 ==== 黑屏---加载---开机进入系统(加载系统以及开机了 就可以把加载卸载掉了)

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

平时我们安装进虚拟机的Centos都是好几个G,为什么docker这里才200M?

对于一个精简的OS,rootfs可以很小,只需要包含最基本的命令,工具和程序库就可以了,因为底层直接用Host的kernel,自己只需要提供rootfs就可以了,由此可见对于不同的linux发行版,bootfs基本是一致的,rootfs会有差别,因此不同的发行版可以公用bootfs。

分层理解

我们可以去下载一个镜像,注意观察下载的日志输出,可以看到时一层一层的在下载!

docker image inspect redis

.......

"Name": "overlay2"

},

"RootFS": {

"Type": "layers",

"Layers": [

//镜像层 (如果之前已有对应的镜像层 可复用) "sha256:f68ef921efae588b3dd5cc466a1ca9c94c24785f1fa9420bea15ecc2dedbe781",

"sha256:b6fc243eaea74d1a41b242da4c3ec5166db80f38c4d57a10ce8860c00d902ace",

"sha256:ec92e47b7c52dacc26df07ee13e8e81c099b5a5661ccc97b06692a9c9d01e772",

"sha256:4be6d4460d3615186717f21ffc0023b168dce48967d01934bbe31127901d3d5c",

"sha256:992463b683270e164936e9c48fa395d05a7b8b5cc0aa208e4fa81aa9158fcae1",

"sha256:0083597d42d190ddb86c35587a7b196fe18d79382520544b5f715c1e4792b19a"

]

},

"Metadata": {

"LastTagTime": "0001-01-01T00:00:00Z"

}

}

特点

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

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

下载的基本层级都是镜像层,是不会变的! docker run的时候就是容器层了!

你的所有操作都是在容器层的!

如何提交提个自己的镜像呢?

commit镜像

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

#命令和git类似

docker commit -m="提交的描述信息" -a="作者" 容器id 目标镜像名:[TAG]

实战测试

#1、启动一个默认的tomcat

#2、发现这个默认的tomcat 是没有webapps应用,镜像的原因,官方的镜像默认 webapps下面是没有文件的!

#3、自己拷贝进去了基本的文件

#4、将我们操作过的容器通过commit提交为一个镜像!我们以后就使用我们修改过的镜像即可,这是我们自己新修改的镜像咯~

容器数据卷

什么是容器数据卷?

docker的理念回顾

将应用和环境打包成一个镜像!

数据?如果数据都在容器中,那么我们容器删除,数据就会丢失!需求:数据可以持久化

MySQL,容器删了,删库跑路!需求:MySQL数据可以存储在本地!

容器之间可以有一个数据共享技术!Docker容器中产生的数据,同步到本地!

这就是卷技术!目录的挂载,将我们容器内的目录,挂载到Linux上面!

总结一句话:容器的持久化和同步操作!容器间也是可以数据共享的!

使用数据卷

方式一:直接使用命令挂载 -v

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

#测试 注:目录不存在没关系 命令操作会创建目录

D:\component\Docker>docker run -it -v D:\ceshi:/ceshi centos /bin/bash

[root@7982747d7f4b /]#

[root@7982747d7f4b /]# ls

bin dev home lib64 media opt root sbin sys usr

ceshi etc lib lost+found mnt proc run srv tmp var

#启动起来使用我们可以通过

docker inspect 容器id

测试文件的同步

再开测试!

1、停止容器

2、宿主机上修改文件

3、启动容器

4、容器内的数据依旧是同步的!

好处:我们以后修改只需要在本地修改即可,容器内会自动同步!

实战:安装MySQL

思考:MySQL的数据持久化的问题 data

#搜镜像

docker search mysql

#下载镜像

docker pull mysql:5.7

#运行容器,需要做数据挂载!

#安装mysql,需要配置密码的,这是需要注意的!

#官方测试 -e代表配置环境

docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag

#启动我们的容器

-d 后台运行

-p 端口映射

-v 卷挂载

-e 环境配置

--name 容器名字

docker run -d -p 3310:3306 -v D:\home\mysql:/etc/mysql/conf.d -v D:\home\mysql\data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql

#本地在navicat测试下可否链接成功 在Navicat创建一个数据库

#测试:我们将mysql01的容器删除,发现,我们挂载到本地的数据卷依旧没有丢失,这就实现了容器数据持久化功能!!

具名挂载和匿名挂载

#匿名挂载

-v 容器内路径

docker run -d -P --name nginx01 -v /etc/nginx nginx

#查看所有的卷的情况

D:\component\Docker>docker volume ls

DRIVER VOLUME NAME

local 6df6459348ba561a16588861b6dc6fa74a62d86454c3f4b43f7a5b12be156580

local b4c9ec1cac19ec6d0606be6813881b5d413a95b5c70de79e5dff49967fcb466d

local b629eff46d633a0adab150bf559691dd38dd5811bd359a5780cf4737beb49ffd

local f30440670a035531f9562135218d2a8e37be31653a72f22be5c5a5ddfe542991

#这里发现,这种就是匿名挂载,我们在-v 只写了容器内的路径,没有写容器外的路径

#具名挂载

#通过 -v 卷名:容器内路径

docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx

D:\component\Docker>docker volume ls

DRIVER VOLUME NAME

local 6df6459348ba561a16588861b6dc6fa74a62d86454c3f4b43f7a5b12be156580

local b4c9ec1cac19ec6d0606be6813881b5d413a95b5c70de79e5dff49967fcb466d

local b629eff46d633a0adab150bf559691dd38dd5811bd359a5780cf4737beb49ffd

local f30440670a035531f9562135218d2a8e37be31653a72f22be5c5a5ddfe542991

local juming-nginx

D:\component\Docker>docker volume inspect juming-nginx

[

{

"CreatedAt": "2021-08-29T06:36:17Z",

"Driver": "local",

"Labels": null,

"Mountpoint": "/var/lib/docker/volumes/juming-nginx/_data",

"Name": "juming-nginx",

"Options": null,

"Scope": "local"

}

]

所有的docker容器内的卷,没有指定目录的情况下都是在/var/lib/docker/volumes/juming-nginx/_data

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

#如何确定是具名挂载还是匿名挂载,还是指定路径挂载

-v 容器内路径 #匿名挂载

-v 卷名:容器内路径 #具名挂载

-v 宿主机路径:容器内路径 #指定路径挂载

拓展:容器内路径:ro rw?

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

ro readly #只读

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就说明这个路径只能通过宿主机来操作,容器内部是无法操作的!

#默认是rw 可读可写

初始Dockerfile

Dockerfile就是用来构建docker镜像的构造文件!---命令脚本!

通过这个脚本可以生成镜像,镜像是一层一层的,脚本是一个个的命令,每个命令都是一层!

#dockerfile

FROM centos

VOLUME ["volume01","volume02"]

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

CMD /bin/bash

docker build -f dockerfile01 -t summer/centos:1.0 .

通过summer/centos:1.0启动一个容器,通过inspet发现没挂载成功....

dockerfile中的VOLUME ["volume01","volume02"] 替换为 VOLUME ["/volume01","/volume02"] 即可

数据卷容器

多个MySQL同步数据!【多个容器之间实现数据共享】

docker run -it --name docker01 summer/centos

ctrl + Q + P退出

#--volumes-from 像 java中的 son extends parents

docker run -it --name docker02 --volumes-from docker01 summer/centos

docker run -it --name docker03 --volumes-from docker01 summer/centos

#测试,可以删除docker01,查看一下docker02和docker03是否还可以访问这个文件

#测试依旧可以访问

#容器之间数据是共享的,文件是拷贝的

多个MySQL实现数据共享

docker run -d -p 3310:3306 -v D:\home\mysql:/etc/mysql/conf.d -v D:\home\mysql\data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql

docker run -d -p 3310:3306 -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 --volumes-from mysql01 mysql

#这个时候,就可以实现两个容器数据同步

结论:

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

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

DockerFile

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

构建步骤:

1、编写一个dockerfile文件

2、docker build 构建成为一个镜像

3、docker run 运行镜像

4、docker push 发布镜像 (DockerHub、阿里云镜像仓库!)

查看一下官方:

很多官方的镜像都是基础包,很多功能没有,我们通常会自己搭建自己的镜像!

官方既然可以制作镜像,那我们也可以!

DockerFile构建过程

基础知识:

1、每个保留关键字(指令)都必须是大写字母

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

3、#表示注释

4、每一个指令都会创建提交一个新的镜像层,并提交!

dockerfile是面向开发的,我们以后要发布项目,做镜像,就需要编写dockerfile文件,这个十分简单!

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

步骤:开发、部署、运维

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

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

Docker容器:容器就是镜像运行起来提供服务的

DockerFile的指令

FROM #基础镜像,一切从这里开始构建

MAINTAINER #镜像是谁写的,姓名+邮箱

RUN #镜像构建的时候需要运行的命令

ADD #步骤:tomcat镜像,这个tomcat压缩包!添加内容 【会自动解压】

WORKDIR #镜像的工作目录 /bin/bash

VOLUME #挂载的目录

EXPOSE #暴露端口配置

CMD #指定这个容器启动的时候要运行的命令【只有最后一个会生效,可被替代】

ENTRYPOINT #指定这个容器启动的时候要运行的命令【可以追加命令】

ONBUILD #当构建一个被继承DockerFile这个时候就会运行ONBUILD的指令。触发指令

COPY #类似ADD,将我们文件拷贝到镜像中

ENV #构建的时候设置环境变量!

实战测试

Docker Hub中百分之99%镜像都是从这个基础镜像过来的FROM scratch,然后配置需要的软件和配置来进行构建的

创建一个自己的centos

#1、编写dokcerfile文件

FROM centos

MAINTAINER summer<12345@163.com>

ENV MYPATH /usr/local

WORKDIR $MYPATH

RUN yum -y install vim

RUN yum -y install net-tools

#暴露的端口

EXPOSE 80

CMD echo $MYPATH

CMD echo "--end--"

CMD /bin/bash

#通过文件构建镜像

docker build -f dockerfile01 -t mycentos .

#测试运行

D:\docker-file>docker run -it mycentos

[root@e0522ad8d55c local]# pwd

/usr/local

[root@e0522ad8d55c local]# ifconfig

...

#这个镜像有了 vim ifconfig命令

docker history 镜像id 命令看镜像构建过程

可以查看官方的mysql镜像

我们平时拿到一个镜像,可以研究一个它是怎么做的了~

CMD与ENTRYPOINT的区别

CMD #指定这个容器启动的时候要运行的命令【只有最后一个会生效,可被替代】

ENTRYPOINT #指定这个容器启动的时候要运行的命令【可以追加命令】

测试cmd

#编写dockerfile文件

FROM centos

CMD ["ls","-a"]

#构建镜像

D:\docker-file>docker build -f dockerfile02 -t cmd-test .

#run运行,发现我们的ls -a生效了

D:\docker-file>docker run cmd-test

.

..

.dockerenv

bin

dev

etc

home

lib

lib64

var

#想追加一个命令 -l 期望:ls -al

D:\docker-file>docker run cmd-test -l

docker: Error response from daemon: OCI runtime create failed: container_linux.go:380: starting container process caused: exec: "-l": executable file not found in $PATH: unknown.

#cmd的情况下 -l 替换了 CMD ["ls","-a"] 命令 -l 不是命令所以报错

#要写成这样==》docker run cmd-test ls -al

D:\docker-file>docker run cmd-test ls -al

total 56

drwxr-xr-x 1 root root 4096 Aug 30 14:37 .

drwxr-xr-x 1 root root 4096 Aug 30 14:37 ..

-rwxr-xr-x 1 root root 0 Aug 30 14:37 .dockerenv

测试ENTRYPOINT

#编写dockerfile文件

FROM centos

ENTRYPOINT ["ls","-a"]

#构建镜像

D:\docker-file>docker build -f dockerfile-entrypoint -t entrypoint-test .

#run运行,发现我们的ls -a生效了

D:\docker-file>docker run entrypoint-test

.

..

.dockerenv

bin

dev

etc

home

lib

lib64

var

#想追加一个命令 -l 期望:ls -al

D:\docker-file>docker run entrypoint-test -l

total 56

drwxr-xr-x 1 root root 4096 Aug 30 14:37 .

drwxr-xr-x 1 root root 4096 Aug 30 14:37 ..

-rwxr-xr-x 1 root root 0 Aug 30 14:37 .dockerenv

#ENTRYPOINT的情况下 -l 追加在 ENTRYPOINT ["ls","-a"] 命令后面

实战:Tomcat

1、准备镜像文件 tomcat 压缩包,jdk的压缩包

2、编写dockerfile文件,官方命名为Dockerfile,build会自动寻找这个文件,就不需要-f指定了

FROM centos

MAINTAINER summer

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

ADD jdk-8u301-linux-x64.tar.gz /usr/local/

ADD apache-tomcat-7.0.76.tar.gz /usr/local/

RUN yum -y install vim

ENV MYPATH /usr/local

WORKDIR $MYPATH

ENV JAVA_HOME /usr/local/jdk1.8.0_301

ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

ENV CATALINA_HONE /usr/local/apache-tomcat-7.0.76

ENV CATALINA_BASH /usr/local/apache-tomcat-7.0.76

ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HONE/bin:$CATALINA_BASH/bin

EXPOSE 8080

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

3、构建镜像

docker build -t diytomcat .

docker run -d -p 9090:8080 --name summertomcat -v D:\docker-file\dockerfile-tomcat\test:/usr/local/apache-tomcat-7.0.76/webapps/test -v D:\docker-file\dockerfile-tomcat\tomcatlogs:/usr/local/apache-tomcat-7.0.76/bin/logs diytomcat

4、启动镜像

5、访问测试 localhost:9090

6、发布项目(由于做了卷挂载,我们直接在本地编写项目就可以发布了~~)

<?xml version="1.0" encoding="UTF-8" ?>

<web-app xmlns:xsi=";

xmlns=";

xmlns:web=";

xsi:schemaLocation="

;

version="2.5">

</web-app>

<%@ page language="java" contentType="text/html;charset=UTF-8"

pageEncoding="UTF-8"%>

<html>

<head>

<meta charset="UTF-8">

<title>Summer</title>

</head>

<body>

Hello world!<br/>

<

System.out.println("-----my test web logs-----")

>

</body>

</html>

开发步骤:

掌握Dockerfile的编写,我们之后的一切都是使用docker镜像来发布运行~

发布自己的镜像

DockerHub

1、地址 注册自己的账号

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

3、在我们服务器上提交自己的镜像

D:\docker-file\dockerfile-tomcat>docker login --help

Log in to a Docker registry or cloud backend.

If no registry server is specified, the default is defined by the daemon.

Usage:

docker login [OPTIONS] [SERVER] [flags]

docker login [command]

Available Commands:

azure Log in to azure

Flags:

-h, --help Help for login

-p, --password string password

--password-stdin Take the password from stdin

-u, --username string username

4、登录完毕后就可以提交镜像了,之后就是push

#login

D:\docker-file\dockerfile-tomcat>docker login -u summergogogo

Password:

Error response from daemon: Get ";: unauthorized: incorrect username or password

D:\docker-file\dockerfile-tomcat>docker login -u summergogogo

Password:

Login Succeeded

#push

D:\docker-file\dockerfile-tomcat>docker push diytomcat

Using default tag: latest

The push refers to repository [docker.io/library/diytomcat]

5f70bf18a086: Preparing

f424aff3a08b: Preparing

e7db93e85970: Preparing

e9466b3b5827: Preparing

c37ad71d3748: Preparing

2653d992f4ef: Waiting

denied: requested access to the resource is denied

#push镜像问题?

D:\docker-file\dockerfile-tomcat>docker tag diytomcat summer/tomcat:1.0

D:\docker-file\dockerfile-tomcat>docker images

D:\docker-file\dockerfile-tomcat>docker push summer/tomcat:1.0

The push refers to repository [docker.io/summer/tomcat]

5f70bf18a086: Preparing

f424aff3a08b: Preparing

e7db93e85970: Preparing

e9466b3b5827: Preparing

c37ad71d3748: Preparing

push提交的时候也是按照镜像的层级来进行提交的!

用本地的提交不上去,因为需要FQ的,所以会被拒绝

Docker网络

理解Docker0

所有的容器不指定网络的情况下,都是docker0路由的

#问题:docker 是如何处理容器网络访问的?

#测试启动一个tomcat容器

docker run -d -P --name tomcat01 tomcat

#查看容器的内部网络地址 ip addr,发现容器启动的时候会得到一个 eth0@if11 ip地址,docker分配的!

D:\docker-file>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

2: tunl0@NONE: <NOARP> mtu 1480 qdisc noop state DOWN group default qlen 1000

link/ipip 0.0.0.0 brd 0.0.0.0

3: sit0@NONE: <NOARP> mtu 1480 qdisc noop state DOWN group default qlen 1000

link/sit 0.0.0.0 brd 0.0.0.0

10: eth0@if11: <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

#思考。windows可以ping通容器吗? 172.17.0.2 windows ping不通 linux环境可以ping通

route -p add 172.17.0.0/16 MASK 255.255.255.0 192.168.65.0

route -p add 172.17.0.0/16 MASK 255.255.240.0 192.168.65.0

route delete 172.17.0.0

原理

1、我们每启动一个docker容器,docker就会给docker容器分配一个ip,我们只要安装了docker,就会有一个网卡docker0

桥接模式

#Linux中!!

#我们在linux下启动的容器带来网卡,都是成对出现的

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

#正因为这个特性 veth pair 充当一个桥梁,连接各种虚拟网络设备的

2、测试tomcat01和tomcat02两个容器是否可以ping通

#tomcat01

D:\docker-file>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

2: tunl0@NONE: <NOARP> mtu 1480 qdisc noop state DOWN group default qlen 1000

link/ipip 0.0.0.0 brd 0.0.0.0

3: sit0@NONE: <NOARP> mtu 1480 qdisc noop state DOWN group default qlen 1000

link/sit 0.0.0.0 brd 0.0.0.0

10: eth0@if11: <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

#tomcat02

D:\docker-file>docker exec -it 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

2: tunl0@NONE: <NOARP> mtu 1480 qdisc noop state DOWN group default qlen 1000

link/ipip 0.0.0.0 brd 0.0.0.0

3: sit0@NONE: <NOARP> mtu 1480 qdisc noop state DOWN group default qlen 1000

link/sit 0.0.0.0 brd 0.0.0.0

10: eth0@if11: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default

link/ether 02:42:ac:11:00:03 brd ff:ff:ff:ff:ff:ff link-netnsid 0

inet 172.17.0.3/16 brd 172.17.255.255 scope global eth0

valid_lft forever preferred_lft forever

#可以ping通

D:\docker-file>docker exec -it tomcat02 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.055 ms

64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.037 ms

64 bytes from 172.17.0.2: icmp_seq=3 ttl=64 time=0.033 ms

64 bytes from 172.17.0.2: icmp_seq=4 ttl=64 time=0.032 ms

结论:tomcat01和tomcat02都是公用的一个路由器,docker0

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

255.255.0.1/16 16代表域 docker可分配65535个ip

00000000.00000000.00000000.00000000 255*255-1

小结

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

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

只要容器删除,对应网桥一对就没了!

思考?

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

引出 --link

就是说tomcat01 和 tomcat02 不用通过ping ip 通过服务名link

#不配置 直接ping容器名 ping不通

D:\docker-file>docker exec -it tomcat02 ping tomcat01

ping: tomcat01: No address associated with hostname

#通过--link ping 容器名字

D:\docker-file>docker run -d -P --name tomcat03 --link tomcat02 tomcat

759cabd25a063111ed669bd11834fcd9875185f1035ad7241179d4afd5e91419

#正向能ping通

D:\docker-file>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.052 ms

64 bytes from tomcat02 (172.17.0.3): icmp_seq=2 ttl=64 time=0.030 ms

64 bytes from tomcat02 (172.17.0.3): icmp_seq=3 ttl=64 time=0.031 ms

#反向不可以ping通

D:\docker-file>docker exec -it tomcat02 ping tomcat03

ping: tomcat03: No address associated with hostname

#显示所有网卡

#docker network ls

D:\docker-file>docker network ls

NETWORK ID NAME DRIVER SCOPE

36c6af259ffd bridge bridge local

71c1a0a9337a host host local

14e8f8ea4bd7 none null local

#docker network inspect 36c6af259ffd

D:\docker-file>docker network inspect 36c6af259ffd

[

{

"Name": "bridge",

"Id": "36c6af259ffdd9693b8288dd80ac65451e827cca84da5626cd10202eed3e20d0",

"Created": "2021-09-01T09:42:16.1069283Z",

"Scope": "local",

"Driver": "bridge",

"EnableIPv6": false,

"IPAM": {

"Driver": "default",

"Options": null,

"Config": [

{

"Subnet": "172.17.0.0/16",

"Gateway": "172.17.0.1" #docker0!!!网关

}

]

},

深究:inspect

#docker inspect 容器名

其实这个tomcat03就是在本地配置了tomcat02的配置!

#查看hosts配置 这里原理发现!

D:\docker-file>#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.3 tomcat02 9227670c1ea0

172.17.0.4 759cabd25a06

本质探究:--link 就是我们在host配置中增加了tomcat02的映射!172.17.0.3 tomcat02 9227670c1ea0

现在完Docker 已经不建议使用--link了!

我们现在用自定义网络!不再用自带的docker0!

docker0问题:它不支持容器名连接访问!

自定义网络

容器互联

查看所有的docker网络

网络模式

bridge:桥接 docker【默认的,自己创建也是使用桥接模式】 上面搭桥 0.2 0.1 0.3

none:不配置网络

host:和宿主机共享网络

container:容器网络连接!(用的少!局限很大)

测试

#我们直接启动一个容器 --net bridge 而是这个就是默认的docker0 这个是默认省略的

#docker run -d -P --name tomcat01 tomcat

#docker run -d -P --name tomcat01 --net bridge tomcat

#docker0特点: 默认,域名不能访问 --link可以打通

#自定义一个网络!

#--driver bridge 桥接模式 (默认也是桥接)

#--subnet 192.168.0.0/16 子网地址 192.168.0.2~192.168.255.255

#--gateway 192.168.0.1 网关

D:\docker-file>docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet

3d0bb320b8186e89b9cf495f022d9c808097063e28b389fa3cf0d71fb6577d59

D:\docker-file>docker network ls

NETWORK ID NAME DRIVER SCOPE

973189954a15 bridge bridge local

71c1a0a9337a host host local

3d0bb320b818 mynet bridge local

14e8f8ea4bd7 none null local

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

这个时候我们用自己的网络启动容器

#用自定义的network启动容器

D:\docker-file>docker run -d -P --name tomcat-net-01 --net mynet tomcat

33a17fe0509186d5c4e95cf9640e06e7760ccb1d33714eaa37f5dff7e0b58ef7

D:\docker-file>docker run -d -P --name tomcat-net-02 --net mynet tomcat

d759d9fc44f2c539c7498e25ef36858d204d9ff2283f5ae52a3047238eca6861

#看一下网络中有这两个容器的ip

D:\docker-file>docker network inspect mynet

【注:】默认的docker0 网络 是不能通过ping容器名的 只能用link关联

#用自定义网络不再用link 直接ping容器名 就可以ping通!!!

D:\docker-file>docker exec -it tomcat-net-01 ping tomcat-net-02

PING tomcat-net-02 (192.168.0.3) 56(84) bytes of data.

64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=1 ttl=64 time=0.049 ms

64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=2 ttl=64 time=0.033 ms

64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=3 ttl=64 time=0.036 ms

我们自定义的网络docker都已经帮我们维护好对应的关系,docker0没有这个功能,推荐我们使用这样自定义的网络!

好处:

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

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

现在假设集群这样---怎么联通呢?

网络连通

#测试打通 tomcat-01 到 mynet

#docker network connect mynet tomcat-01

#连通之后就是将 tomcat-01 打通到mynet了【一个容器两个ip】

#docker network inspect mynet

#在进行测试

#docker exec -it tomcat01 ping tomcat-net-01 ping通了

#docker exec -it tomcat-net-01 ping tomcat-01 ping通了

#tomcat-02打不通 因为tomcat-02没有连到mynet

D:\docker-file>docker exec -it tomcat-02 ping tomcat-net-01

ping: tomcat-net-01: No address associated with hostname

结论:假设要跨网络操作别人,就需要使用docker network connect连通!

实战:部署Redis集群

创建6个文件

D:\docker-file\redis-cluster\node-1\

D:\docker-file\redis-cluster\node-2\

...

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

#先创建一个redis的网络

D:\docker-file>docker network create redis --subnet 172.38.0.0/16

fb40eb077d0716ce295489dbdaca01e8cf883c557f93020511fff95cae17b6fa

D:\docker-file>docker network ls

NETWORK ID NAME DRIVER SCOPE

973189954a15 bridge bridge local

71c1a0a9337a host host local

3d0bb320b818 mynet bridge local

14e8f8ea4bd7 none null local

fb40eb077d07 redis bridge local

#启动容器

D:\docker-file>docker run -p 6371:6379 -p 16371:16379 --name redis-1 -v D:\docker-file\redis-cluster\node-1\conf\redis.conf:/etc/redis/redis.conf -v D:\docker-file\redis-cluster\node-1\data:/data -d --net redis --ip 172.38.0.11 redis redis-server /etc/redis/redis.conf

1b7bb0077c4260d93f68bc79e8a482d3f34f7ed8c77b271f10f7203e1d34881b

D:\docker-file>docker run -p 6372:6379 -p 16372:16379 --name redis-2 -v D:\docker-file\redis-cluster\node-2\conf\redis.conf:/etc/redis/redis.conf -v D:\docker-file\redis-cluster\node-2\data:/data -d --net redis --ip 172.38.0.12 redis redis-server /etc/redis/redis.conf

1b7bb0077c4260d93f68bc79e8a482d3f34f7ed8c77b271f10f7203e1d34881b

docker run -p 6373:6379 -p 16373:16379 --name redis-3 -v D:\docker-file\redis-cluster\node-3\conf\redis.conf:/etc/redis/redis.conf -v D:\docker-file\redis-cluster\node-3\data:/data -d --net redis --ip 172.38.0.13 redis redis-server /etc/redis/redis.conf

docker run -p 6374:6379 -p 16374:16379 --name redis-4 -v D:\docker-file\redis-cluster\node-4\conf\redis.conf:/etc/redis/redis.conf -v D:\docker-file\redis-cluster\node-4\data:/data -d --net redis --ip 172.38.0.14 redis redis-server /etc/redis/redis.conf

docker run -p 6375:6379 -p 16375:16379 --name redis-5 -v D:\docker-file\redis-cluster\node-5\conf\redis.conf:/etc/redis/redis.conf -v D:\docker-file\redis-cluster\node-5\data:/data -d --net redis --ip 172.38.0.15 redis redis-server /etc/redis/redis.conf

docker run -p 6376:6379 -p 16376:16379 --name redis-6 -v D:\docker-file\redis-cluster\node-6\conf\redis.conf:/etc/redis/redis.conf -v D:\docker-file\redis-cluster\node-6\data:/data -d --net redis --ip 172.38.0.16 redis redis-server /etc/redis/redis.conf

#链接集群

D:\docker-file>docker exec -it redis-1 /bin/bash

root@1b7bb0077c42:/data# 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

>>> Performing hash slots allocation on 6 nodes...

Master[0] -> Slots 0 - 5460

Master[1] -> Slots 5461 - 10922

Master[2] -> Slots 10923 - 16383

Adding replica 172.38.0.15:6379 to 172.38.0.11:6379

Adding replica 172.38.0.16:6379 to 172.38.0.12:6379

Adding replica 172.38.0.14:6379 to 172.38.0.13:6379

M: 7195a94d7d3f761936153c8a9249a47ec53a14d4 172.38.0.11:6379

slots:[0-5460] (5461 slots) master

M: 91b1281ca470773564de2a561be14648b95ac195 172.38.0.12:6379

slots:[5461-10922] (5462 slots) master

M: 132295bfd3070eefeb6a124dbb6a9a16dd44009d 172.38.0.13:6379

slots:[10923-16383] (5461 slots) master

S: 253dbeeb78ec2c7507908a28c583c47bd7337548 172.38.0.14:6379

replicates 132295bfd3070eefeb6a124dbb6a9a16dd44009d

S: 337c29dee1ab4637718a5621beb9be287606ce08 172.38.0.15:6379

replicates 7195a94d7d3f761936153c8a9249a47ec53a14d4

S: 7e892eafb89e5a12b3655e16bce2d18048f1e24f 172.38.0.16:6379

replicates 91b1281ca470773564de2a561be14648b95ac195

Can I set the above configuration? (type 'yes' to accept): yes

>>> Nodes configuration updated

>>> Assign a different config epoch to each node

>>> Sending CLUSTER MEET messages to join the cluster

Waiting for the cluster to join

...

>>> Performing Cluster Check (using node 172.38.0.11:6379)

M: 7195a94d7d3f761936153c8a9249a47ec53a14d4 172.38.0.11:6379

slots:[0-5460] (5461 slots) master

1 additional replica(s)

S: 7e892eafb89e5a12b3655e16bce2d18048f1e24f 172.38.0.16:6379

slots: (0 slots) slave

replicates 91b1281ca470773564de2a561be14648b95ac195

S: 253dbeeb78ec2c7507908a28c583c47bd7337548 172.38.0.14:6379

slots: (0 slots) slave

replicates 132295bfd3070eefeb6a124dbb6a9a16dd44009d

S: 337c29dee1ab4637718a5621beb9be287606ce08 172.38.0.15:6379

slots: (0 slots) slave

replicates 7195a94d7d3f761936153c8a9249a47ec53a14d4

M: 132295bfd3070eefeb6a124dbb6a9a16dd44009d 172.38.0.13:6379

slots:[10923-16383] (5461 slots) master

1 additional replica(s)

M: 91b1281ca470773564de2a561be14648b95ac195 172.38.0.12:6379

slots:[5461-10922] (5462 slots) master

1 additional replica(s)

[OK] All nodes agree about slots configuration.

>>> Check for open slots...

>>> Check slots coverage...

[OK] All 16384 slots covered.

#redis-cli -c 带上-c就是集群

root@1b7bb0077c42:/data# redis-cli -c

#看集群信息

127.0.0.1:6379> cluster info

cluster_state:ok

cluster_slots_assigned:16384

cluster_slots_ok:16384

cluster_slots_pfail:0

cluster_slots_fail:0

cluster_known_nodes:6

cluster_size:3

cluster_current_epoch:6

cluster_my_epoch:1

cluster_stats_messages_ping_sent:216

cluster_stats_messages_pong_sent:229

cluster_stats_messages_sent:445

cluster_stats_messages_ping_received:224

cluster_stats_messages_pong_received:216

cluster_stats_messages_meet_received:5

cluster_stats_messages_received:445

#集群节点信息

127.0.0.1:6379> cluster nodes

7e892eafb89e5a12b3655e16bce2d18048f1e24f 172.38.0.16:6379@16379 slave 91b1281ca470773564de2a561be14648b95ac195 0 1630602744774 2 connected

253dbeeb78ec2c7507908a28c583c47bd7337548 172.38.0.14:6379@16379 slave 132295bfd3070eefeb6a124dbb6a9a16dd44009d 0 1630602745000 3 connected

337c29dee1ab4637718a5621beb9be287606ce08 172.38.0.15:6379@16379 slave 7195a94d7d3f761936153c8a9249a47ec53a14d4 0 1630602745588 1 connected

7195a94d7d3f761936153c8a9249a47ec53a14d4 172.38.0.11:6379@16379 myself,master - 0 1630602745000 1 connected 0-5460

132295bfd3070eefeb6a124dbb6a9a16dd44009d 172.38.0.13:6379@16379 master - 0 1630602745788 3 connected 10923-16383

91b1281ca470773564de2a561be14648b95ac195 172.38.0.12:6379@16379 master - 0 1630602745584 2 connected 5461-10922

#set数据到redis集群中

127.0.0.1:6379> set a b

-> Redirected to slot [15495] located at 172.38.0.13:6379

OK

#停掉一个redis-3

#然后get a 看是够能拿到?拿到代表集群还是可用的!

SpringBoot微服务打包Docker镜像

1、创建springboot项目

2、打包应用

3、编写dockerfile

FROM java:8

COPY *.jar /app.jar

CMD ["--server.port=8081"]

EXPOSE 8081

ENTRYPOINT ["java","-jar","/app.jar"]

4、构建镜像

5、发布运行!

6、测试

以后我们使用了Dokcer之后,给别人交付的就是一个镜像即可!

标签: #docker中装docker