Docker

来自B站狂神说java

学前准备

1.Linux基础（必要）2.springboot

Docker学习

• Docker概述
• Docker安装
• Docker命令
• Docker镜像
• 容器数据卷
• DockerFile
• Docker网络原理
• IDEA整合Docker
• Docker Compose集群的管理（企业生产上的应用）
• Docker Swarm 简化版的K8s集群管理
• CI/CDJenkins 持续集成和持续部署

Docker概述

Docker为什么会出现？

一款产品：开发–上线 两套环境! 应用环境，应用的配置
开发 运维 问题：在我的电脑上可以运行 版本更新导致服务不可用对于运维来说考验十分大
环境配置十分的麻烦，每一个机器都要部署环境（集群redis，ES，Hadoop）！费时费力。
发布一个项目（jar+（reids、mysql、jdk，ES））项目能不能都带上环境安装打包！
之前在服务器配置一个应用环境 redis mysql jdk Es Hadoop配置超麻烦不能跨平台
Windows，最后发布到Linux

传统:开发jar ，运维来做
现在：开发打包部署上线，一套流程做完！

java — apk —发布 （应用商店）—张三使用apk ----安装即可用

java --jar（环境） ----打包项目带上环境（镜像）—Docker仓库：商店—下载我们发布的镜像 ----直接运行即可

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

docker思想来源于集装箱
JRE --多个应用（端口冲突）—原来都是交叉的
隔离：Docker核心思想！打包装箱！每个箱子都是互相隔离的
docker 通过隔离机制可以将服务器利用到极致

Docker的历史

2010，几个搞IT的年轻人，就在美国成立一家公司dotCloud
做一些pass的云计算服务！LXC有关的容器技术！
他们将自己的容器化技术命名为Docker
Docker刚刚诞生的时候，没有引起注意

开源：
2013，Docker开源！
Docker越来越多的人发现了docker的优点！火了
Docker每一个月都会更新一个版本
2014 年4月9日Docker 1.0发布
Docker为什么这么火？十分轻巧
在容器技术出来之前我们都是使用虚拟机技术
虚拟机：在Window中安装一个VMware通过这个软件我们可以虚拟出来一台或者多台的电脑！笨重！
虚拟机也是属于虚拟化技术
什么是虚拟化呢？

这里简单归纳一下我的理解：

1.虚拟化是资源的一种逻辑表示，并不会受限于物理资源。

2.运行的环境不在真实的硬件上，而是硬件之上的虚拟内存中的一段，或者说是虚拟的环境中。

3.虚拟化为数据、计算能力、存储资源等提供了一个逻辑视图，而不是物理视图。

4.虚拟化的发展，大幅降低了IT硬件成本，减少了资源的浪费，并且提升了系统的稳定性和安全性。

全虚拟化

全虚拟化(FullVirtualization)也称为原始虚拟化技术，该模型使用虚拟机协调Guest操作系统和原始硬件，VMM在Guest操作系统和裸硬件之间用于工作协调，一些受保护指令必须由Hypervisor（虚拟机管理程序）来捕获处理。全虚拟化的运行速度要快于硬件模拟，但是性能方面不如裸机，因为Hypervisor需要占用一些资源。

半虚拟化

半虚拟化(ParaVirtualization)是另一种类似于全虚拟化的技术，它使用Hypervisor分享存取底层的硬件，但是它的Guest操作系统集成了虚拟化方面的代码。该方法无需重新编译或引起陷阱，因为操作系统自身能够与虚拟进程进行很好的协作。半虚拟化需要Guest操作系统做一些修改，使Guest操作系统意识到自己是处于虚拟化环境的，但是半虚拟化提供了与原操作系统相近的性能。

虚拟化技术的关键特性

同质-Equivalence

即VM的运行环境和物理机的环境在本质上是相同的，表现上允许有一些差异。如CPU的桥片必须一致，CPUcore的个数以及内存可以不同，不必使用同类型的网络适配器驱动等等。

高效-Efficiency

即VM的性能必须接近物理机。因此，常见的虚拟系统模拟器（Boches，simics等）就不能成为VM。为达此目的，软件在虚拟系统上运行时，大多数指令要直接运行在硬件上执行，只有少量指令需要VMM的模拟或翻译处理。

资源受控-Resourcecontrol

即VMM(VirtualMachineMonitor)对物理机的所有资源有绝对的控制力。虚拟机不允许直接执行敏感指令。

二者的区别：

vm:  linux centos原生的镜像（一个电脑）隔离需要开启多个虚拟机！几个G 几分钟
docker：隔离，镜像（最核心的环境 4m+jdk+mysql）十分的小巧 几个M kb 秒级启动

聊聊docker
基于go语言开源的项目!
官网

Docker能干嘛

虚拟机技术缺点：

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

容器化技术

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

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

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

DevOps开发运维

应用更快速的交互和部署
传统：一堆的帮助文档安装程序
Docker打包镜像发布测试，一键运行

更便捷的升级或者扩缩容
（springboot1.5，Redis 5.0,Tomcat 8）
使用了docker我们的部署就像是在搭积木一样
项目打包为一个镜像扩展 服务器A！ 服务器B

更简单的系统运维
在容器化 之后我们的开发测试环境都是高度一致的。

更高效的计算资源利用：
docker是内核级别的虚拟化，可以再一个物理机上可以运行很多的容器实例！ 服务器的性能可以被压榨到极致

Docker的安装

docker的基本组成

docker的架构图

镜像：（image）：

docker镜像就好像是一个模板，可以通过这个模板创建一个tomcat镜像服务----》run ----》tomcat1容器（提供服务器）通过这个镜像创建多个容器（最终服务运行或者说是项目运行就是在容器中的）

容器（container）
Docker利用容器技术独立运行一个或者一个组应用通过镜像来创建的启动，停止，删除，基本命令
目前可以把这个容器理解为就是一个简易的linux系统 ，镜像运行的实例

仓库（repository）
仓库就是存放镜像的地方
仓库分为公有仓库和私有仓库
Docker Hub！
阿里云都有服务器（配置镜像加速）

安装docker

环境准备
1.需要会一点点的Linux的基础
2.CentOS7
3.我们使用Xshell连接远程服务进行操作

环境查看uname -r

系统版本
cat /etc/os -releaese

安装
帮助文档：
文档地址

1 卸载旧的版本

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

2 需要的安装包

yum install -y yum-utils

3 设置镜像的仓库

yum-config-manager \
  --add-repo \
  https://download.docker.com/linux/centos/docker-ce.repo # 默认是国外的

搜索国内的镜像地址阿里云加速的镜像地址

 yum-config-manager \
 --add-repo \
  http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

安装之前更新yum软件包的索引
yum makecache fast

4 安装docker相关的内容 docker -ce社区版 ee 企业版

yum install docker-ce docker-ce-cli containerd.io

5,启动docker

systemctl start docker 

6 是否安装成功

docker version

7.测试是否安装成功
docker run hello-world

8.查看一下下载的这个hello- world 镜像
docker images

1 卸载依赖

yum remove docker-ce docker-ce-cli containerd.io

2 删除资源 docker 默认工作路径

rm -rf /var/lib/docker

阿里云镜像加速

镜像服务
服务
选择centos
配置使用

sudo mkdir -p /etc/docker 

sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://uoxx7ef3.mirror.aliyuncs.com"]
}
EOF

sudo systemctl daemon-reload

sudo systemctl restart docker

回顾helloworld流程

底层原理

Docker是怎么工作的？
Docker是一个Client和server的结构的系统，
Docker的守护进行运行在主机上。通过Socket从客户端访问！
DockerServer接收到Docker-Client的指令就会执行这个命令！

Docker为什么比Vm快？

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

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

Docker的常用命令

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

帮助文档的地址：
地址

镜像命令

images
或者说帮助文档
docker images --help
docker images

[root@kuangshen /]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
hel1o-world
latest
bf756fb1ae65
4 months ago
13.3kB

#解释
REPOSITORY
镜像的仓库源

TAG
镜像的标签

IMAGE ID
镜像的id

CREATED
镜像的创建时间

SIZE
镜像的大小

#可选项
-a，--a11
#列出所有镜像
-q，--quiet
#只显示镜像的jd

搜索镜像
docker search mysql

[root@kuangshen /]# docker search mysq1
NAME DESCRIPTION  STARS  OFFICIAL AUTOMATED
mysq1
MySQL is a widely used, open-source relatin..
9494
[OK]
mariadb 
MariaDB is a communi ty-developed fork of MyS...
3441
[OK]
#可选项，通过搜藏来过滤
--filter=STARS= 3000
#搜索出来的镜像就是STARS大于3000的
[root@kuangshen /]# docker search mysq1 --filter=STARS=3000
NAME
DESCRIPTION
STARS
OFFICIAL
AUTOMATED
mysq1
MySQL is a widely used, open-source relation...
9494
[OK]
mariadb
MariaDB is a community-developed fork of MyS.... 3441
[OK]
[root@kuangshen /]# docker search mysq1 --filter=STARS=5000
NAME DESCRIPTION STARS  OFFICIAL AUTOMATED
mysq1
MySQL is a widely used, open-source relatin.... 9494
[OK]
[root@kuangshen /]#

docker pull 下载镜像

#下载镜像docker pull 镜像名[:tag]
[root@kuangshen /]# docker pull mysql
using default tag: latest #如果不写tag, 默认就是latest
latest: pulling from library/mysql
5b54d594fba7: Pull complete
#分层下载，docker iamge的核心 联合文件系统
07e7d6a8a868: Pull complete
abd946892310: Pull complete
dd8f4d07efa5: Pull complete
076d396a6205: Pull complete
cf6b2b93048f: Pull complete
530904b4a8b7: Pu11 complete
fb1e55059a95: Pu11 complete
4bd29a0dcde8: Pu11 complete
b94a001c6ec7: Pu11 complete
cb77cbeb422b: Pu11 complete
2a35cdbd42cc: Pu11 complete
Digest: sha256:dc255ca50a42b3589197000b1 f9bab2b4e010158d1a9f56c3db6ee145506f625 #签名
Status: Downloaded newer image for mysq1: latest
docker. io/library/mysq1:latest #真 实地址
#等价于它
docker pu11 mysq1
docker pu11 docker. io/library/mysq1: latest
#指定版本下载
[root@kuangshen /]# docker pu11 mysq1:5.7
5.7: Pulling from library/mysq1 
5b54d594fba7: Already exists
07e7d6a8a868: Already exists
abd946892310: Already exists
dd8f4d07efa5: Already exists
076d396a6205: Already exists
cf6b2b93048f: Already exists
530904b4a8b7: Already exists
a37958cbebcf: Pu11 complete
04960017f638: Pu11 complete
e1285def0d2a: Pu11 complete
670cb3a9678e: Pu11 complete
Digest: sha256 :e4d39b85118358ffef6adc5e8c7 d00e49d20b25597e6ffdc994696f10e 3dc8e2
Status: Downloaded newer image for mysq1:5.7
docker. io/library/mysq1:5.7

docker rmi删除镜像！

[root@kuangshen /]# docker rmi -f容器id #删除指定的容器
[root@kuangshen /]# docker rmi -f容器id容器id容器id容器id #删除多个容器
[root@kuangshen /]# 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
随机指定端口
#测试，启动并进入容器
[root@kuangshen /]# docker run -it centos /bin/bash
[root@e4eccc01b495 /]# 1s # 查看容器内的centos，基础版本，很多命令都是不完善的!这个就是容器的id
bin dev etc home 1ib 1 ib641os t+found media mnt opt proc root run sbin srv sys tmp us r
var
#从容器中退回主机
[root@e4eccc01b495 /]# exit
exit
[root@kuangshen /]# 1s
bin
dev home kuangshen 1ib64
media opt
proc run
share
sys usr www
boot
etf hpt
1ib
lost+found
mnt
patch root sbin
Srv 
tmp
var

列出所有的运行的容器

# docker ps命令
#列出当前正在运行的容器
-a #列出当前正在运行的容器+带出历史运行过的容器
-n=?#显示最近创建的容器
-q #只显示容器的编号
[root@kuangshen /]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
[root@kuangshen /]# docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
e4eccc01b495
centos
"/bin/bash"
2 minutes ago
Exited (0) About a
minute ago
modest_ hel 1man
74bfa7 d94103
bf756fb1ae65
"/he1lo" 
50 minutes ago
Exited (0) 50 minutes
ago
optimistic_ almeida

退出容器

exit
#直接容器停止并退出
Ctr1 + P+ Q
#容不停止退出

删除容器

docker rm容器id #删除指定的容器，不能删除正在运行的容器，如果要强制删除rm -f
docker rm -f s(docker ps -aq)#删除所有的容器
docker ps -a -q |xargs docker rm#删除所有的容器

启动和停止容器

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

常用的其他命令

后台启动容器

#命令docker run -d镜像名!
[root@kuangshen /]# docker run -d centos
#问题docker pS，发现centos停止了
#常见的坑: docker 容器使用后台运行，就必须要有要一个前台进程，docker发现没有应用，就会自动停止
# nginx，容器启动后，发现自己没有提供服务，就会立刻停止，就是没有程序了

查看日志

docker 1ogs -f -t --tail 容器，没有日志
#自己编写一段she11脚本
[root@kuangshen /]# docker run -d centos /bin/sh -c "while true;do echo kuangshen;sleep 1; done'
[root@kuangshen /]# docker ps
CONTAINER ID
IMAGE
dce7b86171bf
centos
#显示日志
-tf
#显示日志
--tail number
#要显示日志条数
[root@kuangshen /]# docker 1ogs -tf --tail 10 dce7b86171bf

查看容器中的进程信息

#命令docker top容器id
[root@kuangshen /]# docker top dce7b86171bf
UID PID PPID C STIME TTY
root 22891 22875 0 21 :21 ?
root 23351 22891 0 21 :25 ?

查看容器的元数据

#命令
docker inspect 容器id
#测试
[root@kuangshen /]# docker inspect dce7b86171bf

进入当前正在运行的容器

#我们通常容器都是使用后台方式运行的，需要进入容器，修改一些配置
#命令
docker exec -it 容器id bashShe11
#测试
[root@kuangshen /]# docker ps
CONTAINER ID
IMAGE
COMMAND
CREATED
STATUS
PORTS
NAMES
dce7b86171bf
centos
"/bin/sh -C 'while t.."
8 minutes ago
Up 8 minutes
determi ned_ proskuri akova
[root@kuangshen /]# docker. exec -it dce7b86171bf /bin/bash
[root@dce7b86171bf /]# 1s
bin dev etc home 1ib 1ib64 1os t+found
media
mnt opt proc root run sbin srv sys tmp usr
var
[root@dce7b86171bf /]# ps -ef
UID
PID PPID C STIME TTY
TIME CMD
root
1
0013:21?
00:00:00 /bin/sh -C while true; do echo kuangshen;sleep 1; done
root
505
0 0 13:30 pts/0
00:00:00 /bin/bash 
root
530
1013:30?
00:00:00 /usr/bin/coreutils --coreutils -prog-shebang=sleep
/usr/bin/s leep 1
root
5050 13:30 pts /0
00:00:00 ps -ef
#方式二
docker attach 容器id
#测试
[root@kuangshen /]# docker attach dce7b86171bf
正在执行当前的代码...

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

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

docker cp 容器id:容器内路径目 的的主机路径
#查看当前主机目录下
[root@kuangshen home]# 1s
idea kuangshen kuangshen. java mysq1
[root@kuangshen home]# docker ps
CONTAINER ID
IMAGE
COMMAND
CREATED
STATUS
PORTS
NAMES
b7845 3025116
centos
"/bin/bash"
33 seconds ago
Up 32 seconds
frosty_ _hertz
#进入docker容器内部
[root@kuangshen home]# docker attach b7845 3025116
[root@b78453025116 /]# cd /home
[root@b78453025116 home]# 1s
#在容器内新建-一个文件
[root@b7 8453025116 home]# touch test. java
[root@b78453025116 home]# exit
exit 
[root@kuangshen home]# docker ps
CONTAINER ID
IMAGE
COMMAND
CREATED
STATUS
PORTS
NAMES
[root@kuangshen home]# docker ps -a
CONTAINER ID
IMAGE
COMMAND
CREATED
STATUS
PORTS
NAMES
b78453025116
centos
"/bin/bash"
About a minute ago
Exited (0) 7 seconds
ago
frosty_ hertz
#将这文件拷贝出来到主机上
[root@kuangshen home]# docker cp b78453025116:/home/test. java /home
[root@kuangshen home]# ls
idea
kuangshen
kuangshen. java mysql
test. java
[root@kuangshen home]#
#拷贝是一个手动过程，未来我们使用-v卷的技术，可以实现，自动同步 /home /homel

小结：

attach
Attach to a running container
#当前she11下attach 连接指定运行镜像
build
Build an image from a Dockerfile
#通过Dockerfile定制镜像
commit
Create a new image from a container changes
#提交当前容器为新的镜像
cp
Copy files/folders from the containers filesystem to the host path
#从容器中拷贝指定文件或者目
录到宿主机中
I
create
Create a new container
#创建一个新的容器，同run,但不启动容器
diff
Inspect changes on a container's filesystem
#查看docker 容器变化
events
Get real time events from the server
#从docker服务获取容器实时事件
exec
Run a command in an existing container
#在已存在的容器上运行命令
export
Stream the contents of a container as a tar archive
#导出容器的内容流作为一个tar. 归档文件[对应
import 
history
Show the history of an image
#展示一个镜像形成历史
images
List images
#列出系统当前镜像
import
Create a new filesystem image from the contents of a tarba11 #从tar包中的内容创建一个新的文件系
统映像[对应export]
info
Display system-wide information
#显示系统相关信息
inspect
Return 1ow-1eve1 information on a container
#查看容器详细信息
ki1l
Ki1l a running container
# ki1l指定docker容器
load
Load an image from a tar archive
#从一个tar包中加载一个镜像[对应save]
login
Register or Login to the docker registry server
#注册或者登陆一个docker 源服务器
logout
Log out from a Docker registry server
#从当前Docker registry退出
logs
Fetch the 1ogs of a container
#输出当前容器日志信息
port
Lookup the public-facing port which is NAT-ed to PRIVATE_ PORT
#查看映射端口对应的容器内部源端
C
pause
Pause a11 processes within a container
#暂停容器
ps
List containers
#列出容器列表
pull
Pull an image or a repos itory from the docker registry server
#从docker镜像源服务器拉取指定镜
像或者库镜像
push 
Push an image or a repository to the docker registry server
#推送指定镜像或者库镜像至docker源
服务器
restart
Restart a running container
#重启运行的容器
rm
Remove one or more containers
#移除一个或者多个容器
rmi
Remove one or more i mages
#移除一个或多个镜像[无容器使用该镜像才可删除，否则需删除相关容
器才可继续或-f强制删除]
run
Run a commarnjgd in a new container
#创建一个新的容器并运行一个命令
save
Save an image to a tar archive
#保存一个镜像为一个tar包[对应load]
search
Search for an image on the Docker Hub
#在docker hub 中搜索镜像
start
Start a stopped containers
#启动容器
stop
Stop a running containers
#停止容器
tag
Tag an image into a repos i tory
#给源中镜像打标签
top
Lookup the running processes of a container
#查看容器中运行的进程信息
unpause
Unpause a paused container
#取消暂停容器
version
Show the docker vers ion informati on
#查看docker版本号
wait
B1ock until a container stops， then print its exit code
#截取容器停止时的退出状态值

docker的命令是十分多的，上面都是我们学习的那些命令

作业练习
1.docker安装nginx

#1、搜索镜像search 建议大家去docker搜索，可以看到帮助文档
#2、下载镜像 pu11
#3、运行测试
[root@kuangshen home]# docker images 
REPOSITORY TAG IMAGE ID CREATED SIZE
nginx
latest
602e111c06b6
3 weeks ago
127MB
centos
latest
470671670cac
3 months ago
237MB
#-d后台运行
#--name
给容器命名
#-p宿主机端口:容器内部端口
[root@kuangshen home]# docker run -d --name nginx01 -p 3344:80 nginx
495da206521 3b8936b883c4ab4332ea4e97 6a17d5cc 30c8a42d407 6840a9677a
[root@kuangshen home]# docker ps
CONTAINER ID
IMAGE
COMMAND
CREATED
STATUS
PORTS
NAMES
495da2065213
nginx
"nginx -g 'daemon of.."
3 seconds ago
Up 3 seconds
0.0.0.0:3344->80/tcp
nginx01
[root@kuangshen home]# cur1 localhost:3344

端口暴露的概念

装tomcat

#官方的使用
docker run -it --rm tomcat:9.0
#我们之前的启动都是后台，停止了容器之后，容器还是可以查到 docker run -it --rm， 一般用来测试，用完就删除
#下载在启动
docker pu11 tomcat
#启动运行
docker run -d -p 3355 :8080 --name tomcat01 tomcat
#测试访问没有问题
#进入容器
[root@kuangshen home] docker exec -it tomcat01 /bin/bash
#发现问题，1、1inux命令少了，2.没有webapps.阿里云镜像的原因。 默认是最小的镜像，所有不必要的都剔除掉。
#保证最小可运行的环境!
思考问题:我们以后要部署项目,如果每次都要进入容器是不是十分麻烦?我要是可以在容器外部提供一个映射路径 , webapps ,
我们在外部放置项目,就自动同步到内部就好了!

作业三

#es暴露的端口很多!
#es十分的耗内存
#es的数据一般需要放置到安全目录!挂载
#--net somenetwork ?网络配置
#启动elasticsearch
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node"
elasticsearch:7.6.2
#启动了linux就卡住了 
docker stats 查看cpu的状态
#es是十分耗内存的，1.xG
1核2G!
#查看docker stats
#测试一下es是够成功了
[root@kuangshen home]# cur1 localhost:9200
#赶紧关闭，增加内存的限制，修改配置文件-e环境配置修改
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery. type=s ingle-node" -e
ES_ JAVA OPTS-"-Xms64m -Xmx512m" elasticsearch:7.6.2

#赶紧关闭，增加内存的限制，修改配置文件-e环境配置修改

如何连接网络ES连接Kibana

可视化

portainer(先用这个)

docker run -d -p 8088 :9000 \
--restart=always -V /var/run/docker.sock: /var/run/ docker.sock --privi leged=true portainer/portainer

Rancher ( CI/CD再用)

什么是portainer？
Docker图形化界面管理工具!提供一个后台面板供我们操作!

docker run -d -p 8088:9000 \
--restart=always -V /var/run/ docker.sock:/var/run/docker.sock --privi leged=true portainer/portainer

访问测试：http://ip8088/

Docker镜像讲解

镜像是什么？

镜像是一种轻量级、可执行的独立软件包,用来打包软件运行环境和基于运行环境开发的软件,它包含运行某个软件所需的所有内
容,包括代码、运行时、库、环境变量和配置文件。
所有的应用,直接打包docker镜像,就可以直接跑起来!
如何得到镜像:
●从远程仓库下载
●朋友拷贝给你
●自己制作-个镜像DockerFile

Docker镜像加载的原理

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

UnionFS (联合文件系统) : Union文件系统( UnionFS)是-种分层、轻量级并且高性能的文件系统,它支持对文件系统的修改
作为- -次提交来- -层层的叠加,同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual
filesystem)。Union 文件系统是Docker镜像的基础。镜像可以通过分层来进行继承,基于基础镜像(没有父镜像) ,可以制作各
种具体的应用镜像。
特性: - -次同时加载多个文件系统,但从外面看起来,只能看到一个文件系统,联合加载会把各层文件系统叠加起来,这样最终的
文件系统会包含所有底层的文件和目录

Dokcer镜像加载原理

docker的镜像实际上由- -层- -层的文件系统组成,这种层级的文件系统UnionFS。
bootfs(boot file system)主要包含bootloader和kernel, bootloader主要是引导加载kernel, Linux刚启动时会加载bootfs文件系
统,在Docker镜像的最底层是bootfs。这一-层 与我们典型的Linux/Unix系统是一样的,包含boot加载器和内核。当boo加载完成
之后整个内核就都在内存中了,此时内存的使用权已由bootfs转交给内核,此时系统也会卸载bootfs。
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镜像要采用这种分层的结构呢?

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

[root@kuangshen home]# docker image inspect redis: latest
[
// ....
I
"RootFS": {
"Type": "Iayers",
"Layers": [
"sha256 :c2adabaecedbda0af72b153C6499a0555f3a7 69d52370469d8f6bd6328af9b13" ,
"sha256:744315296a49be711c312df a1b3a80516116f7 8C437 367f f0bc678da1123e990" ,
"sha256:379ef5d5cb402a5538413d7 285b21aa58a560882d15f1f553f7868dc4b66afa8" ,
"sha256 : d00fd460ef fb7b0667 60f97 447 c071492d471c5176d05b8af1751806a1f905f8",
"sha256 : 4d0c196331523cfed7bf5bafd616ecb3855256838d850b6f3d5fba911 f6c4123" ,
"sha256 :98b4a6242af2536383425ba2d6de033a510e049d9ca07ff501b95052da76e894"
]
}，
"Metadata": {
"LastTagTime": "0001 -01-01T00 :00: 00Z"
}
}

理解

所有的Docker镜像都起始于一个基础镜像层 ,当进行修改或增加新的内容时,就会在当前镜像层之上,创建新的镜像层。
举一个简单的例子,假如基于Ubuntu Linux 16.04创建一个新的镜像,这就是新镜像的第一-层 ;如果在该镜像中添加Python包,
就会在基础镜像层之上创建第二个镜像层;如果继续添加一个安全补丁,就会创建第三个镜像层。
该镜像当前已经包含3个镜像层,如下图所示(这只是-个用于演示的很简单的例子)。

在添加额外的镜像层的同时,镜像始终保持是当前所有镜像的组合,理解这一点非常重要。 下图中举了一个简单的例子,每个镜像
层包含3个文件,而镜像包含了来自两个镜像层的6个文件。

上图中的镜像层跟之前图中的略有区别,主要目的是便于展示文件。
下图中展示了一个稍微复杂的三层镜像,在外部看来整个镜像只有6个文件,这是因为最上层中的文件7是文件5的一一个更新版本。

这种情况下，上层镜像层中的文件覆盖了底层镜像层中的文件。这样就使得文件的更新版本作为一个新镜像层添加到镜像当中。
Docker通过存储引擎(新版本采用快照机制)的方式来实现镜像层堆栈,并保证多镜像层对外展示为统- -的文件系统。
Linux.上可用的存储引擎有AUFS、Overlay2、 Device Mapper、Btrfs 以及ZFS。顾名思义,每种存储引擎都基于Linux中对应的
文件系统或者块设备技术,井且每种存储引擎都有其独有的性能特点。
Docker在Windows上仅支持windowsfilter -种存储引擎,该引擎基于NTFS文件系统之上实现了分层和CoW[1]。
下图展示了与系统显示相同的三层镜像。所有镜像层堆叠并合并,对外提供统- -的视图。

特点

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

把这个容器发布给其他人，打包容器层和镜像层一起打包过后形成新的层级发送给其他人。
如何提交自己的镜像
Commint镜像

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

实战测试
#1、启动一个默认的tomcat
#2、发现这个默认的tomcat是没有webapps应用，镜像的原因， 官方的镜像默认webapps 下面是没有文件的!
#3、我自己拷贝进去了基本的文件
#4、将我们操作过的容器通过commit提交为一个镜像!我 们以后就使用我们修改过的镜像即可，这就是我们自己的一个修改的镜像

学习方式说明:理解概念,但是-定要实践,最后实践和理论相结合- -次搞定这个知识
如果你想要保存当前容器的状态，就可以通过commit来提交，获得一个镜像，
就好比我们以前学习VM时候，快照!

容器数据卷

什么是容器数据卷？

docker的理念回顾

将应用和环境打包成一个镜像 !
数据?如果数据都在容器中,那么我们容器删除,数据就会丢失!需求:数据可以持久化
MySQL,容器删了,删库跑路!需求: MySQL数据可以存储在本地!
容器之间可以有一个数据共享的技术! Docker 容器中产生的数据,同步到本地!
这就是卷技术!目录的挂载,将我们容器内的目录,挂载到Linux上面!|

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

使用数据卷

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

docker run -it -V主机目录:容器内目录
#测试
[root@kuangshen home]# docker run -it -V /home/ceshi :/home centos /bin/bash
启动起来时候我们可以通过docker inspect 容器id

测试文件的同步

再来测试
1.停止容器
2.宿主机上修改文件
3.启动容器
4.容器内的数据依旧是同步的

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

实战MySql的数据同步

思考：MySQL数据持久化的问题！

[root@kuangshen home]# docker pu11 mysq1:5.7
#运行容器，需要做数据挂载! 安装启动mysq1，需要配置密码的，这是要注意点!
#启动我们的
-d后台运行
-p端口映射
-v卷挂载
-e环境配置
--name容器名字
[root@kuangshen home]# docker run -d -p 3310:3306 -V /home/mysq1/conf :/etc/mysq1/conf.d -v
/home/mysq1/data: /var/1ib/mysq1 -e MYSQL ROOT PASSWORD=123456 --name mysq101 mysq1:5.7

#启动成功之后，我们在本地使用sqlyog 来接测试一下
#sqlyog- 连接到服务器的3310—3310 和容器内的3306映射， 这个时候我们就可以连接上了!
#在本地测试创建一个数据库，查看一下我们映射的路径是否ok!

假设我们把容器删除，发现我们挂载到本地的数据卷依旧没有丢失这就实现了容器数据的持久化功能！

具名挂载和匿名挂载

#匿名挂载
-V容器内路径!
docker run -d -P --name nginx01 -V /ect/nginx nginx
#查看所有的volume 的情况
[root@kuangshen home]# docker volume 1s
local
9f38292179faa178afcce54d80be99d4ddd68c91d2a68870bcece7 2d2b7 ed061
#这里发现，这种就是匿名挂载，我们在-V只写了容器内的路径，没有写容器外的路径!
#具名挂载
[root@kuangshen home]# docker run -d -P --name nginx02 -V juming-nginx :/etc/nginx nginx
95b809564484c8ac87 d65c69643e7 e67447f1c77ff9a91b93edec7003692e3a9
[root@kuangshen home]# docker volume 1s
DRIVER
VOLUME NAME
1oca1 juming-nginx

所有的docker容器内的卷,没有指定目录的情况下都是在/var/lib/docker/volumes/xxxx/data
我们通过具名挂载可以方便的找到我们的-个卷,大多数情况在使用的具名挂载

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

拓展:
#通过-v容器内路径: ro rw改变读写权限
ro
readonly #只读
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文件， 名字可以随机建议Dockerfile
#文件中的内容指令(大写) 参数
FROM centos
VOLUME ["volume01" ，"volume02"]
CMD echo "----end-----"
CMD /bin/bash
#这里的每个命令，就是镜像的一层!

启动我们运行的容器

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


查看卷挂载的路径

测试一下刚才的文件是否同步出去!
这种方式我们未来使用的十分多,因为我们通常会构建自己的镜像!
假设构建镜像时候没有挂载卷,要手动镜像挂载-V卷名:容器内路径!

数据卷容器

多个mysql同步数据！

dcoker01停掉了或者删除掉了怎么办？
继承docker01的docker02和docker03的数据依然在。
测试依旧可以访问
原理：

多个mysql实现数据共享

[root@kuangshen home]# docker run -d -P 3310:3306 -V /etc/mysq1/conf.d -V /var/1ib/mysq1 -e
MYSQL_ ROOT_ PASSWORD=123456 --name mysq101 mysq1 :5.7
[root@kuangshen home]# docker run -d -p 3310:3306 -e MYSQL_ ,ROOT_ PASSWORD=123456 --name mysq102 --
volumes-form mysq101 mysq1:5.7
#这个时候，可以实现两个容器数据同步!

结论：
容器之间配置信息的传递数据卷容器的生命周期一直持续到没有容器使用为止
但是一旦持久到了本地这个时候本地的数据时不会删除的

Dockerfile

dockerfile是用来构建dokcer镜像的文件!命令参数脚本!
构建步骤:
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 #镜像的工作目录
VOLUME #挂载的目录
EXPOSE #保留端口配置
CMD #指定这个容器启动的时候要运行的命令,只有最后一个会生效，可被替代
ENTRYPOINT #指定这个容器启动的时候要运行的命令,可以追加命令
ONBUILD #当构建一个被继承DockerFile 这个时候就会运行ONBUILD 的指令。触发指令。
COPY #类似ADD，将我们文件拷贝到镜像中
ENV #构建的时候设置环境变量!

实战测试编写自己的centos

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

创建一个自己的centos
1.编写DockerFlie的文件
vim mydockerfile-centos

FROM centos
MAINTAINER kuangshen<24736743@qq. 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

2.通过这个文件构建镜像

docker build -f mydockerfile-centos -t mycentos:0.1

3.测试运行
docker run -it mycentos:0.1 容器内运行
对比：之前的原生的centos

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

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

CMD和ENTRYPOINT区别

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

#编写dockerfile 文件
[root@kuangshen dockerfile]# vim dockerfile-cmd-test
FROM centos
CMD ["'s","-a"]
#构件镜像
[root@kuangshen dockerfile]# docker build -f dockerfile-cmd-test -t cmdtest.
#run运行，发现我们的ls -a命令生效
[root@kuangshen dockerfile]# docker run dd8e4401d72f
. dockerenv
bin
dev
etc
home
1ib
1ib64
#想追加一个命令-1 1s -a1
[root@kuangshen dockerfile]# docker run dd8e4401d72f - l
docker: Error response from daemon: OCI runtime create failed: container_linux. go:349: starting
container process caused “exec: “-l”: executable file not found in SPATH”: unknown.
#cmd的清理下-l替换了CMD [“ls”,"-a"] 命令，-l不是命令所以报错!

[root@kuangshen dockerfile]# vim dockerfile- cmd-entrypoint
FROM centos
ENTRYPOINT [“ls”,"-a"]

[root@kuangshen dockerfile]# docker build -f dockerfile- cmd-entrypoint -t entoryponit-test.
Sending build context to Docker daemon 4. 096kB
Step 1/2 : FROM centos
—> 470671670cac
Step 2/2 : ENTRYPOINT [“ls”,"-a"]
—> Running in 444b257920ef
Removing intermediate container 444b257920ef
—> 3c4c9621ed91
Successfully built 3c4c9621ed9f
Successfu1ly tagged entoryponit-test: latest
[root@kuangshen dockerfile]# docker run 3c4c9621ed91

#我们的追加命令，是直接拼接在我们的ENTRYPOINT 命令的后面!
[root@kuangshen dockerfile]# docker run 3c4c9621ed91 -l
total 56
drwxr-xr-x
1 root root 4096 May 15 13:15 .
drwxr-xr-x
1 root root 4096 May 15 13:15 . .
-rwxr-xr-x
1 root root
0 May 15 13:15 . dockerenv
1 rwxrwxrwx
1 root root
7 May 11 2019 bin -> usr/bin
drwxr*-xr-x ;
5 root root 340 May 15 13:15 dev
drwxr-xr-x
1 root root 4096 May 15 13:15 etc

dockerflie中很多命令都十分相似我们需要了解它们

实战Tomcat镜像压缩包

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

2、编写dockerfile文件

FROM centos
MAINTAINET kuangshen<24736743@qq. com>
COPY readme. txt /usr/1oca1/readme. txt
ADD jdk-8u11-1inux-x64. tar.gz /usr/1oca1/
ADD apache- tomcat-9.0.22. tar. gz /usr/1oca1/
RUN yum -y instal1 vim
ENV MYPATH /usr/1oca1
WORKDIR SMYPATH
ENV JAVA HOME /usr/1oca1/jdk1.8.0 11
ENV CLASSPATH SJAVA HOME/1ib/dt. jar :SJAVA HOME/1ib/tools. jar
ENV CATALINA HOME /usr/1oca1/apache-tomcat-9. 0.22
ENV CATALINA BASH /usr/loca1/apache-tomcat-9. 0.22 
ENV PATH SPATH:SJAVA HOME/bin: SCATALINA HOME/1ib: SCATALINA_ HOME/bin
EXPOSE 8080
CMD /usr/1oca1/apache- tomcat-9.0.22/bin/startup.sh && tail -f /usr/1oca1/apache-tomcat-
9.0.22/bin/logs/catalina. out

Dockerfile是文件的官方名字所以说不用写-f
3.构建镜像
docker bubuild -t diytomcat .
4.启动镜像

5.访问测试
curl localhost:9090 测试端口地址是否能被访问 把url改成usr

6.发布项目
test文件夹下面创建一个WEB-INF的文件夹创建一个web.xml的文件

  <?xml version="1.0" encoding="UTF-8"?>
  <web-app xmlns="http://java.sun.com/xml/ns/javaee"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
                               http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
           version="2.5">

  </web-app>

在test目录下面创建一个index.jsp

<%@ page 1anguage="java"
contentType="text/htm1; charset=UTF-8"
pageEncoding="UTF-8"%>
<! DOCTYPE htm1>
<htm1>
<head>
<meta charset= "utf-8">
<title>菜鸟教程(runoob. com)</title>
</head>
<body>
He11o world!<br/>
<%
out. print1n("你的IP地址" + request. getRemoteaddr());
%>
</body>
</htm1>

发现：项目部署成功，可以直接访问OK！
以后开发的步骤需要掌握dockerFile的编写！我们之后的镜像一切都是使用dockerFile来发布运行

发布自己的镜像

Git Hub

1.地址
2.确定这个账号可以登录
3.在我们的服务器上提交我们镜像
4.登录我们的镜像
docker login -u 账户
然后输入密码
5.提交镜像
docker push

#push自己的镜像到服务器上! 
[root@kuangshen tomcat]# docker push diytomcat
The push refers to repository [docker. io/1ibrary/diytomcat]
fcc7fccb8e04: Preparing
b5577f344233: Preparing
bdcb94365850: Preparing
1c5bd81521f5: Preparing
0683de282177: Preparing
denied: requested access to the resource is denied #拒绝
#push镜像的问题?
[root@kuangshen tomcat]# docker push kuangshen/diytomcat:1.0
The push refers to repos itory [docker . io/kuangshen/diytomcat2]
An image does not exist 1ocally with the tag: kuangshen/diytomcat2
#解决，增加一个tag
[root@kuangshen tomcat]# docker tag f8559daf1fc2 kuangshen/tomcat:1.0
#docker psuh上去即可!自己发布的镜像尽量带上版本号
[root@kuangshen tomcat]# docker push kuangshen/tomcat:1.0
The push refers to repos itory [docker . i o/kuangshen/ tomcat]
fcc7fccb8e04: Preparing
b5577f344233: Preparing
bdcb94365850: Preparing
1c5bd81521f5: Preparing
0683de282177: Preparing

提交的时候是分层级提交的

阿里云镜像服务上

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

4.创建容器镜像

5浏览阿里云

登录 阿里云 push镜像

镜像的版本

镜像的层信息在dockerFile里面的

阿里云容器的步骤就参考官方的文档即可

小结：

Docker网络

理解Docker0(没有任何的镜像)

清空所有的环境

测试

ip addr

三个网络
问题：docker是如何处理容器网络访问的？

#[root@kuangshen /]# docker run -d -p --name tomcat01 tomcat
#查看容器的内部网络地址ip addr

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

[root@kuangshen /]# docker exec -it tomcat01 ip addr
1: 1o: <L0OPBACK,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 10
valid_ 1ft forever preferred _1ft forever
261: eth0@if262: <BROADCAST,MUL TICAST,UP ,LOWER UP> mtu 1500 qdisc noqueue state UP group default
link/ether 02:42:ac:12:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0
inet 172.18.0.2/16 brd 172.18.255.255 scope g1oba1 eth0
valid 1ft forever preferred. _1ft forever
#思考。liunx能不能ping 通容器内部!

ping 172.18.0.2
linux可以ping通docker的内部容器

原理
同一网段是可以ping通的

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

2.在启动一个容器测试 又多了一对网卡容器外264:263

进入docker容器里面可以看到 容器内263:264

这种一对一对的技术就是evth-pair 技术
evth-pair 技术就是一对一对的虚拟设备接口他们是成对出现的，一般连着协议一端彼此相连
正因为有这个特性用evth-pair 技术 充当一个桥梁连接各种虚拟网络设备的
OpenStack，Docker容器之间的连接，ovS的连接，都是使用evth-pair 技术

3.我们来测试一下tomca01和tomcat02是否可以ping通！
17.0.2 ping 17.0.3

[root@kuangshen /]# docker exec -it tomcat02 ping 172.18.0.2
#结论:容器和容器之间是可以互相ping通的!

绘制一个网络模型图：
这就是一个桥接的模式的网卡
小结

使用linux的桥接直连，宿主机中是一个Docker容器的网桥docker0，

Docker中的所有的 网络接口都是虚拟的虚拟的转发效率高！
只要容器删除 ，对应的网桥一对就没了

–link

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

[root@kuangshen /]# docker exec -it tomcat02 ping tomcat01
ping: tomcat01: Name or service not known
#如何可以解决呢?
通过–link 既可以解决了网络的连通问题

通过link过后03可以ping得通02
02ping03反向可以ping通吗？
探究inspect



其实这个tomcat03就是在本地配置

所以说ping不通

本质探究: -link就是我们在hosts配置中增加了-个172.18.0.3 tomcat02 312857784cd4
我们现在玩Docker已经不建议使用-link了!
自定义网络！ 不适合docker0！
docker问题：他不支持容器名连接访问

自定义网络

查看所有的docker网络

网络模式
bridge：桥接模式 搭桥 docker
none：不配置网络
host：和宿主机共享网络
container：容器内网络连通！用的少！局限性很大

测试
docker rm -f $(docker ps -aq)

ip addr就回到最开始的样子没有网络的连接

#我们直接启动的命令–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 子网
#–gateway 192.168.0.1 路由
[root@kuangshen /]# docker network create --driver bridge --subnet 192. 168.0.0/16 --gateway 192.168.0.1
mynet
eb21272b3a35ceaba11b4aa5bbff131c3fb09C4790f0852ed4540707 438db052
[root@kuangshen /]# docker network ls
NETWORK ID NAME DRIVER SCOPE
5a008c015cac bridge bridge local db44649a9bff composetest_ default
bridge
loca1
ae2b6209c2ab
host
host
loca1
eb21272b3a35
mynet
bridge
loca1

01 和02可以互相ping通

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

好处:
redis -不同的集群使用不同的网络,保证集群是安全和健康的
mysq| -不同的集群使用不同的网络,保证集群是安全和健康的

网络连通的操作

测试打通
tomcat01 -mynet
连通之后就是将tomcat01放到了mynet网络下

一个容器两个ip地址
阿里云 服务器

连通之后！


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

实战：部署redis集群

SpringBoot微服务打包Docker镜像

1、构架springboot项目
2、打包应用
3、编写dockerfile
4、构建镜像
5、发布运行!

直接创建一个web模块就可以了
编码完成后然后打包
搜索插件Dockerfile
连接docker的远程厂库setting里面

home/idea


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

预告：如果有很多镜像

docker compose
Docker Swarm
K8s
CI/CD