文章目录
博主学自B站狂神说，自己边看边做的笔记，这是一个好习惯，记性不好笔记凑。
Docker为什么出现？
以前的项目，从开发到部署上线其实是有两套环境配置的(参考windows上的项目部署到Linux上。导致版本问题的话，就会出现以下问题：
开发：我电脑上可以运行，各种功能没有问题。
运维：问题有点大，我这边没办法用。
Docker的出现让开发打包部署上线，一套流程走完!
所以Docker岂不是应运而生？
java开发运用Docker流程：
java – jar(环境) —打包项目带上环境（镜像）—（Docker仓库：商店）
运维的流程：
下载我们发布的镜像 ---- 直接运行即可！
Dockert是通过隔离机制，将原本不能同时打包上去的东西，打包。类似于集装箱，互不影响了。
Docker架构图
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ckIAGDUF-1641368957606)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\1637461847639.png)]
镜像(image)
docker镜像好比是一个模板，可以通过这个模板来创建容器的服务，比如Tomcat镜像 -->run -->tomcat1容器，通过这个镜像可以创建多个容器
容器(container)
docker利用容器的技术，独立运行一个或者一个组的应用，通过镜像来创建的。
启动，停止，删除，基本命令。
仓库(repository)
仓库就是存放镜像的地方。
默认放在Docker Hub(国外)上。
国内，阿里云(配置镜像加速)。
Docker下载
首先使用命令查看系统内核版本，最好是3以上的
[root@lccccc /]# uname -r
3.10.0-1160.11.1.el7.x86_64
查看系统的版本
[root@VM-24-16-centos ~]# cat /etc/os-release
NAME="CentOS Linux"
VERSION="7 (Core)"
ID="centos"
ID_LIKE="rhel fedora"
VERSION_ID="7"
PRETTY_NAME="CentOS Linux 7 (Core)"
ANSI_COLOR="0;31"
CPE_NAME="cpe:/o:centos:centos:7"
HOME_URL="https://www.centos.org/"
BUG_REPORT_URL="https://bugs.centos.org/"
CENTOS_MANTISBT_PROJECT="CentOS-7"
CENTOS_MANTISBT_PROJECT_VERSION="7"
REDHAT_SUPPORT_PRODUCT="centos"
REDHAT_SUPPORT_PRODUCT_VERSION="7"
安装：
1.卸载旧的版本
[root@VM-24-16-centos ~]# yum remove docker \
> docker-client \
> docker-client-latest \
> docker-common \
> docker-latest \
> docker-latest-logrotate \
> docker-logrotate \
> docker-engine
2.需要的安装包
[root@VM-24-16-centos ~]# yum install -y yum-utils
3.设置镜像仓库（阿里云）
[root@VM-24-16-centos ~]# yum-config-manager \
> --add-repo \
> https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
4.更新yum软件包索引
[root@VM-24-16-centos ~]# yum makecache fast
5.安装docker相关的配置
[root@VM-24-16-centos ~]# yum install docker-ce docker-ce-cli containerd.io
6.启动docker并检查版本，自动启动
[root@VM-24-16-centos ~]# systemctl start docker
[root@VM-24-16-centos ~]# docker version
[root@VM-24-16-centos ~]# systemctl enable docker
7.下载hello-world镜像并进行测试
[root@VM-24-16-centos ~]# docker run hello-world
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
2db29710123e: Pull complete
Digest: sha256:cc15c5b292d8525effc0f89cb299f1804f3a725c8d05e158653a563f15e4f685
Status: Downloaded newer image for hello-world:latest
Hello from Docker!//代表成功
This message shows that your installation appears to be working correctly.
To generate this message, Docker took the following steps:
1. The Docker client contacted the Docker daemon.
2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
(amd64)
3. The Docker daemon created a new container from that image which runs the
executable that produces the output you are currently reading.
4. The Docker daemon streamed that output to the Docker client, which sent it
to your terminal.
To try something more ambitious, you can run an Ubuntu container with:
$ docker run -it ubuntu bash
Share images, automate workflows, and more with a free Docker ID:
https://hub.docker.com/
For more examples and ideas, visit:
https://docs.docker.com/get-started/
[root@VM-24-16-centos ~]# systemctl enable docker //下面有hello-world镜像了
Created symlink from /etc/systemd/system/multi-user.target.wants/docker.service to /usr/lib/systemd/system/docker.service.
[root@VM-24-16-centos ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
hello-world latest feb5d9fea6a5 8 weeks ago 13.3kB
Docker run的运行原理图
Docker 的底层原理
Docker是一个Client-Server结构的系统，Docker的守护进程运行在主机上，通过Socker从客户端访问！Docker Server接收到Docker-Client(用户)的指令，就会执行这个指令！
Docker跟虚拟机相比为什么快？
1.看图，发现Docker比VM具有更少的抽象层
2.docker利用的宿主机的内核，VM需要 Guset OS。
所以 Docker新建一个容器的时候，不需要像虚拟机一样重新加载一个操作系统内核，直接利用宿主机的操作系统，而虚拟机是需要加载Guest OS。 省略了这个复杂的过程，所以相对来说较快。
Docker的常用命令
帮助命令
docker version #查看docker的版本信息
docker info #查看docker的系统信息,包括镜像和容器的数量
docker 命令 --help #帮助命令(可查看可选的参数)
docker COMMAND --help
docker官网查看命令帮助文档：(https://docs.docker.com/engine/reference/commandline/)
镜像命令
1.docker images查看主机所有的镜像文件
[root@VM-24-16-centos ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
hello-world latest feb5d9fea6a5 8 weeks ago 13.3kB
#解释:
1.REPOSITORY 镜像的仓库源
2.TAG 镜像的标签
3.IMAGE ID 镜像的id
4.CREATED 镜像的创建时间
5.SIZE 镜像的大小
# 可选参数
-a/--all 列出所有镜像
-q/--quiet 只显示镜像的id
2.docker search搜索镜像
[root@VM-24-16-centos ~]# docker search mysql
NAME DESCRIPTION STARS OFFICIAL AUTOMATED
mysql MySQL is a widely used, open-source relation… 11707 [OK]
mariadb MariaDB Server is a high performing open sou… 4458 [OK]
mysql/mysql-server Optimized MySQL Server Docker images. Create… 870 [OK]
#docker搜索大于3000STARS的mysql
[root@VM-24-16-centos ~]# docker search mysql -f=STARS=3000
NAME DESCRIPTION STARS OFFICIAL AUTOMATED
mysql MySQL is a widely used, open-source relation… 11707 [OK]
mariadb MariaDB Server is a high performing open sou… 4458 [OK]
3.docker pull下载镜像
#docker pull 镜像名[:tag]
[root@VM-24-16-centos ~]# docker pull mysql
Using default tag: latest #如果不写tag，自动默认下载最新版本
latest: Pulling from library/mysql
a10c77af2613: Pull complete # docker image的核心： 分层下载。
b76a7eb51ffd: Pull complete
258223f927e4: Pull complete
2d2c75386df9: Pull complete
63e92e4046c9: Pull complete
f5845c731544: Pull complete
bd0401123a9b: Pull complete
3ef07ec35f1a: Pull complete
c93a31315089: Pull complete
3349ed800d44: Pull complete
6d01857ca4c1: Pull complete
4cc13890eda8: Pull complete
Digest: sha256:aeecae58035f3868bf4f00e5fc623630d8b438db9d05f4d8c6538deb14d4c31b
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest # 真实地址
#docker指定版本下载
root@VM-24-16-centos ~]# docker pull mysql:5.7
5.7: Pulling from library/mysql
a10c77af2613: Already exists #已经存在的不下载，只下载需要的，极大节省内存跟时间
b76a7eb51ffd: Already exists
258223f927e4: Already exists
2d2c75386df9: Already exists
63e92e4046c9: Already exists
f5845c731544: Already exists
bd0401123a9b: Already exists
2724b2da64fd: Pull complete
d10a7e9e325c: Pull complete
1c5fd9c3683d: Pull complete
2e35f83a12e9: Pull complete
Digest: sha256:7a3a7b7a29e6fbff433c339fc52245435fa2c308586481f2f92ab1df239d6a29
Status: Downloaded newer image for mysql:5.7
docker.io/library/mysql:5.7
4.删除镜像
#1.删除指定的镜像id
[root@iZwz99sm8v95sckz8bd2c4Z ~]# docker rmi -f 镜像id
#2.删除多个镜像id
[root@iZwz99sm8v95sckz8bd2c4Z ~]# docker rmi -f 镜像id 镜像id 镜像id
#3.删除全部的镜像id
[root@iZwz99sm8v95sckz8bd2c4Z ~]# docker rmi -f $(docker images -aq)
容器命令
我们有镜像才可以创建容器，下载一个centos镜像来测试学习
1.docker下载centos镜像
[root@VM-24-16-centos ~]# docker pull centos
2.新建容器并启动
docker run [可选参数] image
#参数说明
--name="名字" 指定容器名字
-d 后台方式运行
-it 使用交互方式运行,进入容器查看内容
-p 指定容器的端口
(
-p ip:主机端口:容器端口 配置主机端口映射到容器端口
-p 主机端口:容器端口(常用)
-p 容器端口
)
-P 随机指定端口(大写的P)
[root@VM-24-16-centos ~]# docker run -it centos /bin/bash #启动并进入容器
[root@fde2cc4237d1 /]# #前面主机名字已改变成镜像名
[root@fde2cc4237d1 /]# exit
#exit 停止并退出容器（后台方式运行则仅退出）
#Ctrl+P+Q 不停止容器退出
3.列出所有运行中的容器
#docker ps
# 列出当前正在运行的容器
-a # 列出所有容器的运行记录(当前+历史)
-n=? # 显示最近创建的n个容器
-q # 只显示容器的编号
[root@VM-24-16-centos ~]# docker ps #列出运行中的容器
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
[root@VM-24-16-centos ~]# docker ps -a #列出曾经运行过的容器
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
fde2cc4237d1 centos "/bin/bash" 7 minutes ago Exited (0) 54 seconds ago inspiring_shtern
21ae6af3b473 centos "/bin/bash" 12 minutes ago Exited (0) 12 minutes ago mystifying_perlman
77afe5dd9d3c hello-world "/hello" 5 hours ago Exited (0) 5 hours ago lucid_mendeleev
4.删除容器
docker rm 容器id #删除指定的容器,不能删除正在运行的容器,强制删除使用 rm -f
docker rm -f $(docker ps -aq) #删除所有的容器
docker ps -a -q|xargs docker rm #删除所有的容器
5.启动和停止容器
docker start 容器id #启动容器
docker restart 容器id #重启容器
docker stop 容器id #停止当前运行的容器
docker kill 容器id #强制停止当前容器
6.后台启动容器
docker run -d 镜像名
其他命令
1.查看日志
docker logs [options] 容器id
#一般为-tf，打印出来所有的日志以及时间
#--tail number 显示条数
2.查看容器中进程信息
docker top 容器id
3.查看容器的元数据
docker inspect 容器id
4.进入当前正在运行的容器
#方式一：docker exec -it 容器id /bin/bash
#方式二：docker attach 容器id
[root@VM-24-16-centos ~]# docker ps #查看当前正在运行的容器
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
940c1a236aa6 centos "/bin/bash" 2 minutes ago Up 2 minutes wizardly_noyce
[root@VM-24-16-centos ~]# docker exec -it 940c1a236aa6 /bin/bash #进入当前正在运行的容器
5.拷贝容器到目标主机
#docker cp 容器id:容器内路径 目的主机路径
#注意是从容器内部拷贝到主机。
[root@VM-24-16-centos home]# docker ps #首先查看有哪个容器在运行
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
97e2068a8fc4 centos "/bin/bash" About a minute ago Up About a minute interesting_colden
[root@VM-24-16-centos home]# docker attach 97e2068a8fc4 #进入容器
[root@97e2068a8fc4 /]# cd /home
[root@97e2068a8fc4 home]# ls
[root@97e2068a8fc4 home]# touch lcc.java
[root@97e2068a8fc4 home]# exit
exit
[root@VM-24-16-centos home]# docker cp 97e2068a8fc4:/home/lcc.java /home #将容器内的文件拷贝到外部
[root@VM-24-16-centos home]# ls
lcc.java lighthouse www
小结
Command Description
#当前Shell下 attach 连接指定的运行镜像
docker attach Attach local standard input, output, and error streams to a running container
#通过Dockerfile 定制镜像
docker build Build an image from a Dockerfile
#提交当前容器为新的镜像
docker commit Create a new image from a container’s changes
#从容器中拷贝指定文件或者目录到宿主机中
docker cp Copy files/folders between a container and the local filesystem
#创建一个新的容器，同run，但不启动容器
docker create Create a new container
#查看docker容器的变化
docker diff Inspect changes to files or directories on a container’s filesystem
#从docker服务获取容器实时事件
docker events Get real time events from the server
#在已存在的容器中上运行命令
docker exec Run a command in a running container
#导出容器的内容作为一个 tar 归档文件
docker export Export a container’s filesystem as a tar archive
#展示一个镜像历史
docker history Show the history of an image
#列出系统当前镜像
docker images List images
#从tar包中的内容创建一个新的文件系统印象
docker import Import the contents from a tarball to create a filesystem image
#显示系统相关信息
docker info Display system-wide information
#查看容器的详细信息
docker inspect Return low-level information on Docker objects
#kill指定的docker容器
docker kill Kill one or more running containers
#从一个tar包中加载一个镜像
docker load Load an image from a tar archive or STDIN
#注册或者登录一个docker源服务器
docker login Log in to a Docker registry
#从当前的docker registry退出
docker logout Log out from a Docker registry
#输出当前的容器日志
docker logs Fetch the logs of a container
#查看映射端口对应的容器内部源端口
docker port List port mappings or a specific mapping for the container
#暂停容器
docker pause
#列出容器列表
docker ps List containers
#从docker镜像源服务器拉去指定镜像或者库镜像
docker pull Pull an image or a repository from a registry
#推送指定镜像或者库镜像至docker源服务器
docker push Push an image or a repository to a registry
#重启运行容器
docker restart Restart one or more containers
#移除一个或者多个容器
docker rm Remove one or more containers
#移除一个或者多个镜像
docker rmi Remove one or more images
#创建一个新的容器并运行一个命令
docker run Run a command in a new container
#保存一个镜像为一个tar包
docker save Save one or more images to a tar archive (streamed to STDOUT by default)
#从docker Hub中搜索镜像
docker search Search the Docker Hub for images
#启动容器
docker start Start one or more stopped containers
#停止容器
docker stop Stop one or more running containers
#给源中的镜像打标签
docker tag Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE
#查看容器中运行的进程信息
docker top Display the running processes of a container
#取消暂停容器
docker unpause Unpause all processes within one or more containers
#查看docker的版本号
docker version Show the Docker version information
#查看数据卷的信息
docker volume
#截取容器停止时的退出状态值
docker wait Block until one or more containers stop, then print their exit codes
练习中出现的问题
练习一二三共同有个问题：以后要部署项目，如果每次都要进入容器不是十分麻烦嘛?如果可以在容器外部提供一个映射的路径，我们在外部放置项目就可以自动同步到内部！
练习一：部署Nignx
1.搜索nginx
[root@VM-24-16-centos ~]# docker search nginx
NAME DESCRIPTION STARS OFFICIAL AUTOMATED
nginx Official build of Nginx. 15834 [OK]
2.下载镜像
[root@VM-24-16-centos ~]# docker pull nginx
Using default tag: latest
3.运行测试
#-d:后台运行 --name:给容器命名 -p宿主机端口(外部访问端口):容器内部端口
[root@VM-24-16-centos ~]# docker run -d --name nginx01 -p 3344:80 nginx
9e71865cdde680d664fd8a7b163ecb24a98cf7f7ffff02c4de9f0149ed710166
[root@VM-24-16-centos ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
9e71865cdde6 nginx "/docker-entrypoint.…" 5 seconds ago Up 4 seconds 0.0.0.0:3344->80/tcp, :::3344->80/tcp nginx01
dc0b2a12d42d centos "/bin/bash" 19 minutes ago Up 19 minutes lucid_mclaren
#访问本机的地址
[root@VM-24-16-centos ~]# curl localhost:3344
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
html { color-scheme: light dark; }
body { width: 35em; margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif; }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>
<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>
<p><em>Thank you for using nginx.</em></p>
</body>
</html>
练习二：部署tomcat
1.搜索tomcat
[root@VM-24-16-centos ~]# docker search tomcat
NAME DESCRIPTION STARS OFFICIAL AUTOMATED
tomcat Apache Tomcat is an open source implementati… 3181 [OK]
2.下载镜像
[root@VM-24-16-centos ~]# docker pull tomcat
Using default tag: latest
latest: Pulling from library/tomcat
647acf3d48c2: Already exists
3.运行测试
[root@VM-24-16-centos ~]# docker run -d -p 3355:8080 --name tomcat01 tomcat
648956ac98b209b24e8378ee6d4831724fe93e188ce114eece4cb7b95519e93a
4.发现问题
测试没问题，能运行，但是找不到页面？
进入到tomcat容器中，发现其运行文件webapps中没有东西。东西都给放在了webapps.dist中，所以把dist文件复制到webapps中，就解决问题了。
练习三：ES+Kibana
解决问题：ES内存占用大，解决内存问题。
1.下载es
#es 暴露的端口很多！
#es 十分地耗内存
#es 的数据一般需要放置到安全目录下！挂载
#启动es 端口转发9200，9300 名字elasticsearch -e配置环境：集群，单个节点
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2
2.查看内存占用情况
#启动了es，查看cpu状态
[root@VM-24-16-centos ~]# docker stats
CONTAINER ID NAME CPU % MEM USAGE / LIMIT MEM % NET I/O BLOCK I/O PIDS
99c27df6c58b elasticsearch 0.12% 1.059GiB / 1.795GiB 59.02% 656B / 0B 1.01GB / 1.4MB 42
9e71865cdde6 nginx01 0.00% 1.316MiB / 1.795GiB 0.07% 1.33kB / 1.27kB 0B / 4.1kB 2
3.测试是否成功
#测试是否成功
[root@VM-24-16-centos ~]# curl localhost:9200
{
"name" : "99c27df6c58b",
"cluster_name" : "docker-cluster",
"cluster_uuid" : "h7S0eq9WRPW6TMPhbMOfbg",
"version" : {
"number" : "7.6.2",
"build_flavor" : "default",
"build_type" : "docker",
"build_hash" : "ef48eb35cf30adf4db14086e8aabd07ef6fb113f",
"build_date" : "2020-03-26T06:34:37.794943Z",
"build_snapshot" : false,
"lucene_version" : "8.4.0",
"minimum_wire_compatibility_version" : "6.8.0",
"minimum_index_compatibility_version" : "6.0.0-beta1"
},
"tagline" : "You Know, for Search"
}
4.停止ES(因为极耗内存)
[root@VM-24-16-centos ~]# docker stop 99c27df6c58b
99c27df6c58b
5.增加内存限制
#在开启时增加内存限制，修改配置文件 -e 环境配置修改
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.6.2
Portainer可视化面板安装运用
用于管理镜像的工具
1.下载
#将内网9000端口映射到外部8088端口 --restart：一种方式 -v：将里面的一部分数据挂载到我们本机上
#--priviledged：授权操作 portainer：安装控制面板
[root@VM-24-16-centos ~]# docker run -d -p 8088:9000 --restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer
Unable to find image 'portainer/portainer:latest' locally
latest: Pulling from portainer/portainer
94cfa856b2b1: Pull complete
49d59ee0881a: Pull complete
a2300fd28637: Pull complete
Digest: sha256:fb45b43738646048a0a0cc74fcee2865b69efde857e710126084ee5de9be0f3f
Status: Downloaded newer image for portainer/portainer:latest
91e989c0267cf3cf8546f92d66fecf48cfad376340c1076068009007820b0708
2.用外网访问Portainer
设置账号密码
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-miKY4SA9-1641368957613)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\1637584332233.png)]
选择local(本地)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HqKXCc6L-1641368957616)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\1637584412206.png)]
成功进入
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G306oA6l-1641368957618)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\1637584438977.png)]
Docker镜像讲解
镜像是什么？
镜像是一种轻量级的、可执行的独立软件包，用来打包软件和基于运行环境开发的软件，它包含了运行某个软件所需要的所有内容，包括代码、运行时、库、换将变量和配置文件。
所有应用直接用docker打包成镜像，可以直接跑起来！解决了上面的运维跟开发人员的问题！
得到镜像的三种方法：
1、从Docker Hub上下载
2、朋友拷贝给你
3、自己制作一个镜像DockerFile
Docker镜像加载的原理
UnionFS联合文件系统
Docker镜像其实是由一层一层的文件系统组成，这种层级的文件系统是UnionFS联合文件系统。
联合文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下 。联合文件系统是 Docker 镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作各种具体的应用镜像。
另外，不同 Docker 容器就可以共享一些基础的文件系统层，同时再加上自己独有的改动层，大大提高了存储的效率。
特性：一次同时加载多个文件系统，但从外部看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录。
Docker镜像加载原理
Docker镜像其实是由一层一层的文件系统组成，这种层级的文件系统是UnionFS联合文件系统。
bootfs主要包含bootloade(内核)和kernel(加载器)，它主要是引导加载kernel，Linux刚启动时会加载bootfs文件系统，在Docker镜像的最底层是bootfs。这一层与我们典型的Linux/Uninx系统是一样的，包含boot加载器和内核，当boot加载之后整个内核都在内存中，此时内存的使用权已由bootfs转交给内核，此时系统会卸载bootfs。
上述过程就想到于我们电脑的黑屏—>开机的过程。
rootfs，在bfs之上，包含的就是典型的Linux系统中的/dev,/proc,/bin,/etc等标准的目录文件。rootfs就是各种不同的操作系统发行版。
rts就造成了，一个容器启动了就是一个小的linux环境了
为什么平时的容器比如Centos很大，到了这边却很小？
因为这是一个精简的容器，包含基本的指令集、工具和程序库就行了，因为底层的加载器已经给替换成本机的加载器了，自己只需要提供rootfs就行了。所以实现了秒级。
如何提交一个自己的镜像到自己的主机？
docker commit 提交容器成为一个新的副本镜像
#命令跟git类似
docker commit -m="提交的描述信息" -a="作者" 容器id 目标镜像名:[TAG]
1.启动一个默认的Tomcat(容器)
这个默认的tomcat是没有webapps文件的内容。参考上述部署tomcat的时候为什么。
这就是我们改装上传镜像的步骤
[root@VM-24-16-centos ~]# docker run -it -p 8080:8080 tomcat
Using CATALINA_BASE: /usr/local/tomcat
Using CATALINA_HOME: /usr/local/tomcat
2.然后进入容器，将webapps.dist下的文件全部复制到webapps下
#然后按Ctrl+P+Q
[root@VM-24-16-centos ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
015cb1c27b40 tomcat "catalina.sh run" 37 seconds ago Up 36 seconds 0.0.0.0:8080->8080/tcp, :::8080->8080/tcp charm
[root@VM-24-16-centos ~]# docker exec -it 015cb1c27b40 /bin/bash
root@015cb1c27b40:/usr/local/tomcat# ls
BUILDING.txt CONTRIBUTING.md LICENSE NOTICE README.md RELEASE-NOTES RUNNING.txt bin conf lib logs native-jni-lib temp webapps webapps.dist work
root@015cb1c27b40:/usr/local/tomcat# cd webapps
root@015cb1c27b40:/usr/local/tomcat/webapps# ls
root@015cb1c27b40:/usr/local/tomcat/webapps# cd ..
root@015cb1c27b40:/usr/local/tomcat# cp -r webapps.dist/* webapps
root@015cb1c27b40:/usr/local/tomcat# cd webapps
root@015cb1c27b40:/usr/local/tomcat/webapps# ls
ROOT docs examples host-manager manager
3.将该容器打包成新的镜像上传
[root@VM-24-16-centos ~]# docker commit -a="lcc" -m="ceshitijiao" 015cb1c27b40 tomcat02:1.0
sha256:909f7f8ef7f39261296534223871320a43cab839c9226aa2baa0aca05f942c71
[root@VM-24-16-centos ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
tomcat02 1.0 909f7f8ef7f3 6 seconds ago 684MB
这个commit命令相当于一个快照！保存现在的这个版本。
Docker，学到这边才算入门！
容器数据卷
什么是容器数据卷？
docker可以把应用跟环境都打成一个镜像，当运行这个镜像的时候它就会成为一个容器，数据都在这个容器中，当我们删除这容器的时候，我们的数据就可能会丢失。所以就来了这需求：容器里面的数据可以持久化。
比如MYQL容器删了，里面的数据全部都没了。需求：MYSQL数据可以存储到本地！
容器之间有这么一个数据共享的技术。让Docker容器中产生的数据可以同步到本地！这就是卷技术，目录的挂载，将我们容器内的目录挂在到Linux上
最终实现容器的持久化跟同步操作，容器间的数据共享
使用容器数据卷
方式一：doucker run -v 挂载
#docker run -it -v 主机目录：容器内目录
#主机跟容器内的文件中的数据会同步
[root@VM-24-16-centos ~]# docker run -it -v /home/ceshi:/home centos /bin/bash
[root@VM-24-16-centos ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
cc8de9cb9b35 centos "/bin/bash" 4 minutes ago Up 4 minutes clever_wozniak
[root@VM-24-16-centos ~]# docker inspect cc8de9cb9b35
"Mounts": [
{
"Type": "bind",
"Source": "/home/ceshi",#主机内的地址
"Destination": "/home",#docker容器内的地址
"Mode": "",
"RW": true,
"Propagation": "rprivate"
}
],
用处：
解决了上面三个练习中部署容器内的东西，得反复进入容器的问题。可以大大减少工作量。
实战：MYSQL数据同步
1.下载mysql
上面已经下载，这边就不重复了
2.运行容器，将其中的目录挂载出来
#官方测试：-e:配置环境 -v:将配置文件跟数据文件挂载
docker run -d -p 3306:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name ccmysql mysql:5.7
在外部用自己的数据库软件访问，也能链接的上！可以直接看服务器上的MySQL中的数据！
3.就算将mysql卸载了，容器内的数据还是会被保留在本机
具名挂载跟匿名挂载
# -v 容器内路径 #匿名挂载
# -v 卷名:容器内路径 #具名挂载
# -v /宿主机路径:容器内路径 [-ro/-rw]#路径挂载
-ro 跟 -rw 为权限，可以不用
-ro:只读，只能通过宿主机操作，容器内部无法操作。
#匿名挂载
#-d:后台 -P:随机端口 -v:只制定了容器内的文件列表(匿名)
[root@VM-24-16-centos /]# docker run -d -P --name nginx02 -v /etc/nginx nginx
7d864731f08b03629a20a1c817449c291c31cfec28cbe19713e422c1e31459e6
#查看容器内的数据卷 一大串的都是匿名数据卷
[root@VM-24-16-centos /]# docker volume ls
DRIVER VOLUME NAME
local 34b4c3827e0838efc950bc52dc22f62e327f167a9f34a7a1128e8134f8b09005
local ef1259ace4d7fa4afd1511d11aac198e0288a41a4c4610d2c92ead49f7013e95
local f33f609223f3925b840dcc5fda013346255873f110e9762d13b107329dac3c2b
#具名挂载
[root@VM-24-16-centos /]# docker run -d -P --name nginx05 -v juming-guazai:/etc/nginx nginx
4f8b57fbcfcefae17b7d3c3cbfef540af64e1c7ca8def63f8ce74e1223233f3e
[root@VM-24-16-centos /]# docker volume ls
DRIVER VOLUME NAME
local 34b4c3827e0838efc950bc52dc22f62e327f167a9f34a7a1128e8134f8b09005
local ef1259ace4d7fa4afd1511d11aac198e0288a41a4c4610d2c92ead49f7013e95
local f33f609223f3925b840dcc5fda013346255873f110e9762d13b107329dac3c2b
local juming-guazai
#查看某个数据卷具体的信息
[root@VM-24-16-centos /]# docker volume inspect juming-guazai
[
{
"CreatedAt": "2021-11-23T20:52:22+08:00",
"Driver": "local",
"Labels": null,
"Mountpoint": "/var/lib/docker/volumes/juming-guazai/_data",#挂载的具体目录地址
"Name": "juming-guazai",
"Options": null,
"Scope": "local"
}
]
docker中的卷，没指定名字都是在/var/lib/docker/volumes/XXX/_data下
我们通过具名挂载可以很方便的找到一个卷，大多数时候都是使用的具名挂载
方式二：DockerFile挂载
认识DockerFile：它就是用来构建docker镜像的构建文件，一个命令脚本。
通过这个脚本可以生成镜像，镜像是一层一层的，脚本时一个个的命令，每个命令就是一层。
1.随便起一个文件
#随机进到一个文件目录下面起一个名字，作为测试文件
cd /home
mkdir docker-test-volume
cd docker-test-volume
vim dockerlcc1
#然后在dockerlcc1中按i插入内容(每个命令就是镜像的一层)
FROM centos #用centos当作基础
VOLUME ["volume01","volume02"]#挂载卷
CMD echo "-----goujian wanbi----"#构建完毕发送这个消息
CMD /bin/bash #默认走的是bash控制台
#然后保存退出
2.通过命令进行生成镜像
#docker build -f:文件 -t:镜像名:版本号 最后一个.:生成在当前目录下
root@VM-24-16-centos docker-test-volume]# docker build -f /home/docker-test-volume/dockerlcc1 -t lcc/centos:1.0 .
Sending build context to Docker daemon 15.36kB
Step 1/4 : FROM centos
---> 5d0da3dc9764
Step 2/4 : VOLUME ["volume01","volume02"]
---> Running in f7faec6bdc3a
Removing intermediate container f7faec6bdc3a
---> 70d0206ae12f
Step 3/4 : CMD echo "-------end--------"
---> Running in cbc6ca13e6d9
Removing intermediate container cbc6ca13e6d9
---> 94939125c2f7
Step 4/4 : CMD /bin/bash
---> Running in 371c67b67052
Removing intermediate container 371c67b67052
---> e8f5c2b9b26a
Successfully built e8f5c2b9b26a
Successfully tagged lcc/centos:1.0
3.运行查看生成的镜像
#进入到该容器中，随便创建个文件。36eeea3e760c为容器ID
[root@36eeea3e760c /]# cd volume01
[root@36eeea3e760c volume01]# touch container.txt
[root@36eeea3e760c volume01]# ls
container.txt
#Ctrl+P+Q不停止退出
[root@VM-24-16-centos docker-test-volume]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
36eeea3e760c e8f5c2b9b26a "/bin/bash" 42 seconds ago Up 41 seconds naughty_rubin
#查看我们创建的容器信息，可看到我们创建的匿名数据卷Volume01跟02已经挂载上去。
[root@VM-24-16-centos docker-test-volume]# docker inspect 36eeea3e760c
"Mounts": [
{
"Type": "volume",
"Name": "35fa3be3907a7845404e1cd553def340ecd8ef88e1f0f213a64466b79ac4b286",
"Source": "/var/lib/docker/volumes/35fa3be3907a7845404e1cd553def340ecd8ef88e1f0f213a64466b79ac4b286/_data",
"Destination": "volume01",
"Driver": "local",
"Mode": "",
"RW": true,
"Propagation": ""
},
{
"Type": "volume",
"Name": "2cc8bedceff65a1d5588c72d936eb6f4bf71b39f0edf26f8bd002dcdf7f3f5bc",
"Source": "/var/lib/docker/volumes/2cc8bedceff65a1d5588c72d936eb6f4bf71b39f0edf26f8bd002dcdf7f3f5bc/_data", #在Docker这是在主机随机生成的目录地址。
"Destination": "volume02",
"Driver": "local",
"Mode": "",
"RW": true,
"Propagation": ""
}
],
这是最常用的方式！这是让我们自己创建镜像的时候不必须再-v进去弄个数据卷，而是自动加载出来了。
多个容器之间同步数据卷
通过–volumes-from实现容器卷共享
1.创建第一个容器
#创建一个容器，跑的镜像是我们上面自己生成的镜像文件
#通过ls -l 可以看到镜像的两个挂载数据卷也在其中
[root@VM-24-16-centos ~]# docker run -it --name docker01 lcc/centos:1.0
[root@d449093457b7 /]# ls
bin dev etc home lib lib64 lost+found media mnt opt proc root run sbin srv sys tmp usr var volume01 volume02
[root@d449093457b7 /]# ls -l
total 56
lrwxrwxrwx 1 root root 7 Nov 3 2020 bin -> usr/bin
drwxr-xr-x 5 root root 360 Nov 24 12:44 dev
drwxr-xr-x 1 root root 4096 Nov 24 12:44 etc
drwxr-xr-x 2 root root 4096 Nov 3 2020 home
lrwxrwxrwx 1 root root 7 Nov 3 2020 lib -> usr/lib
lrwxrwxrwx 1 root root 9 Nov 3 2020 lib64 -> usr/lib64
drwx------ 2 root root 4096 Sep 15 14:17 lost+found
drwxr-xr-x 2 root root 4096 Nov 3 2020 media
drwxr-xr-x 2 root root 4096 Nov 3 2020 mnt
drwxr-xr-x 2 root root 4096 Nov 3 2020 opt
dr-xr-xr-x 123 root root 0 Nov 24 12:44 proc
dr-xr-x--- 2 root root 4096 Sep 15 14:17 root
drwxr-xr-x 11 root root 4096 Sep 15 14:17 run
lrwxrwxrwx 1 root root 8 Nov 3 2020 sbin -> usr/sbin
drwxr-xr-x 2 root root 4096 Nov 3 2020 srv
dr-xr-xr-x 13 root root 0 Nov 24 12:44 sys
drwxrwxrwt 7 root root 4096 Sep 15 14:17 tmp
drwxr-xr-x 12 root root 4096 Sep 15 14:17 usr
drwxr-xr-x 20 root root 4096 Sep 15 14:17 var
drwxr-xr-x 2 root root 4096 Nov 24 12:44 volume01
drwxr-xr-x 2 root root 4096 Nov 24 12:44 volume02
2.通过继承父容器创造出来一个子容器(拥有相同的数据卷)
#子容器 --volumes-from 父容器--> 子容器继承父容器
[root@VM-24-16-centos ~]# docker run -it --name docker02 --volumes-from docker01 lcc/centos:1.0
DockerFile构建过程
基础知识
1、每个保留关键字(指令)都必须是大写字母
2、执行从上到下的顺序进行
3、#表示注释
4、每个指令都会创建提交一个新的镜像层，并提交
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EASNegF0-1641368957622)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\1637836375575.png)]
DockerFile的指令
FROM #基础镜像，一切由它开始构建
MAINTAINER #镜像是谁写的，一般是姓名+邮箱
RUN #Docker镜像构建的时候需要运行的命令
ADD #添加需要的镜像 比如Tomcat镜像，就添加tomcat的压缩包
WORKDIR #镜像的工作目录，比如说/bin/bash
VOLUME #容器卷挂载的目录
EXPOSE #指定暴露的端口
CMD #指定容器启动的时候要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT #指定容器启动时的命令，可以追加命令。
ONBUILD #当构建一个被继承 DockerFile 这个时候就会运行ONBUILD指令。是一个触发指令
COPY #类似ADD，将文件拷贝到镜像中
ENV #构建的时候设置环境变量！
Docker实战测试
创建一个自己的centos
1.先到一个目录下面创建一个将来要用的文件
[root@VM-24-16-centos ~]# cd /home
[root@VM-24-16-centos home]# ls
ceshi docker-test-volume lcc.java lear lighthouse mysql www
[root@VM-24-16-centos home]# mkdir dockerfile
root@VM-24-16-centos home]# ls
ceshi dockerfile docker-test-volume lcc.java lear lighthouse mysql www
[root@VM-24-16-centos home]# cd dockerfile
[root@VM-24-16-centos dockerfile]# ls
2.在文件中输入dockerfile指令，编写配置文件
[root@VM-24-16-centos dockerfile]# vim mydockerfile-lcc
FROM centos #基于centos基础镜像
MAINTAINER lcc<627058587@qq.com> #作者以及联系方式
ENV MYPATH /usr/local #配置环境变量的目录
WORKDIR $MYPATH #工作目录
RUN yum -y install vim #安装一个vim命令
RUN yum -y install net-tools#安装net的命令
EXPOSE 80#暴露到80端口
CMD echo $MYPATH #输出一下
CMD echo "---end---" #输出一下
CMD /bin/bash #启动进入容器就先到/bin/bash命令行
3.通过这个文件构建镜像
#-f:文件路径 -t:镜像名:版本号
#发现其一层层地去生成镜像
[root@VM-24-16-centos dockerfile]# docker build -f mydockerfile-lcc -t mycentoslcc:0.1 .
Sending build context to Docker daemon 2.048kB
Step 1/10 : FROM centos
---> 5d0da3dc9764
Step 2/10 : MAINTAINER lcc<627058587@qq.com>
---> Running in cc70c0e912d6
Removing intermediate container cc70c0e912d6
---> e8a75826940e
Step 3/10 : ENV MYPATH /usr/local
---> Running in fe3579e0d234
Removing intermediate container fe3579e0d234
---> bcc9ca7d8ecc
Step 4/10 : WORKDIR $MYPATH
---> Running in 9a96e51faaa5
Removing intermediate container 9a96e51faaa5
---> 5f46119022e9
Step 5/10 : RUN yum -y install vim
---> Running in cb13534b4421
4.测试运行
#跟原装的centos比，我们这个直接进入的是我们配置的/usr/local目录而不是根目录
#我们有ifconfig命令、vim等命令，而原来的没有，这就是我们之前配置的
[root@VM-24-16-centos dockerfile]# docker run -it mycentoslcc:0.1
[root@298c883da95c local]# pwd
/usr/local
root@298c883da95c local]# ifconfig
eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST> mtu 1500
inet 172.17.0.4 netmask 255.255.0.0 broadcast 172.17.255.255
ether 02:42:ac:11:00:04 txqueuelen 0 (Ethernet)
RX packets 8 bytes 656 (656.0 B)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 0 bytes 0 (0.0 B)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
lo: flags=73<UP,LOOPBACK,RUNNING> mtu 65536
inet 127.0.0.1 netmask 255.0.0.0
loop txqueuelen 1000 (Local Loopback)
RX packets 0 bytes 0 (0.0 B)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 0 bytes 0 (0.0 B)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
CMD命令跟ENTRYPOINT 的区别
1.测试CMD命令
#进入测试文件，输入指令
[root@VM-24-16-centos dockerfile]# vim dockerfile-cmd
FROM centos #以centos为基础镜像
CMD ["ls","-a"] #运行镜像，容器自动输出所有文件
[root@VM-24-16-centos dockerfile]# docker build -f dockerfile-cmd -t cmdtest . #构建镜像
Sending build context to Docker daemon 3.072kB
Step 1/2 : FROM centos
---> 5d0da3dc9764
Step 2/2 : CMD ["ls","-a"]
---> Running in bee9476bc6e7
Removing intermediate container bee9476bc6e7
---> d4dd23bb34b8
Successfully built d4dd23bb34b8
Successfully tagged cmdtest:latest
#运行执行最后一个CMD命令
[root@VM-24-16-centos dockerfile]# docker run d4dd23bb34b8
.
..
.dockerenv
bin
dev
etc
home
lib
lib64
lost+found
media
mnt
opt
proc
root
run
sbin
srv
sys
tmp
usr
var
2.测试ENTRYPOINT命令
#运行docker run d4dd23bb34b8
#实际上是执行 ls -l
#但是如果打docker run d4dd23bb34b8 -a
#其是无法执行的，因为cmd代表着替换ls -l成-a，从而报出没有-a这个命令的错误
#所以更改成ENTRYPOINT ["ls","-a"]的话，后续加上-a，其会自动默认为ls -al。
#我们追加的命令是直接拼接在ENTRYPOINT命令后面的。
实战：制作Tomcat镜像
1.准备Tomcat镜像文件的压缩包，jdk的压缩包。
将本地的tomcat还有jdk的tar.gz文件都通过Xftp放入到我们的文件目录中
[root@VM-24-16-centos tomcat]# ls
apache-tomcat-9.0.55.tar.gz Dockerfile jdk-8u11-linux-x64.tar.gz readme.txt
2.编写dockerfile文件
官方命名配置文件Dockerfile，执行build命令就会自动寻找这个文件，到时候就不用-f指定执行文件是哪个了。
[root@VM-24-16-centos tomcat]# vim Dockerfile
FROM centos#基于centos镜像
MAINTAINER lcc<627058587@qq.com>#作者以及联系方式
COPY readme.txt /usr/local/readme.txt#复制当前文件下的read.txt到容器内的/usr/local位置的readme.txt
ADD jdk-8u11-linux-x64.tar.gz /usr/local/ #复制当前文件下的jdk到容器内
ADD apache-tomcat-9.0.55.tar.gz /usr/local/ #复制tomcat的压缩包到容器内
RUN yum -y install vim #运行镜像的时候为其安装vim指令
ENV MYPATH /usr/local #配置MYPATH值为/url/local
WORKDIR $MYPATH#进去的时候默认进入到MYPATH中的目录
ENV JAVA_HOME /usr/local/jdk1.8.0_11 #配置JAVA键值对，java安装的目录
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar#java配置
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.55#把tomcat的默认目录给到容器里
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.55#跟上述一样
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin#配置其他的环境变量到PATH中
EXPOSE 8080 #暴露端口
CMD /usr/local/apache-tomcat-9.0.55/bin/startup.sh && tail -F /url/local/apache-tomcat-9.0.55/bin/logs/catalina.out #让这个容器一旦启动就可以执行
3.创建Dockerfile镜像
[root@VM-24-16-centos tomcat]# docker build -t diytomcat .
Sending build context to Docker daemon 170.6MB
Step 1/15 : FROM centos
---> 5d0da3dc9764
Step 2/15 : MAINTAINER lcc<627058587@qq.com>
---> Using cache
---> e8a75826940e
Step 3/15 : COPY readme.txt /usr/local/readme.txt
---> 51559177578d
Step 4/15 : ADD jdk-8u11-linux-x64.tar.gz /usr/local/
---> b7df96576d68
4.运行测试tomcat
[root@VM-24-16-centos tomcat]# docker run -d -p 8080:8080 --name lcctomcat01 -v /home/lcc/build/tomcat/test:/usr/local/apache-tomcat-9.0.55/webapps/test -v /home/lcc/build/tomcat/tomcatlogs/:/usr/local/apache-tomcat-9.0.55/logs lcc/tomcat01:1.0
4dc7e5aed624f6dc378cd1efb77f75058c7e37fe01d7557f6b126f1f1ac574e8
[root@VM-24-16-centos tomcat]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
4dc7e5aed624 diytomcat "/bin/sh -c '/usr/lo…" 5 seconds ago Up 5 seconds 0.0.0.0:8080->8080/tcp, :::8080->8080/tcp lcctomcat01
[root@VM-24-16-centos tomcat]# curl localhost:8080
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<title>Apache Tomcat/9.0.55</title>
<link href="favicon.ico" rel="icon" type="image/x-icon" />
<link href="tomcat.css" rel="stylesheet" type="text/css" />
5.发布项目
由于做了卷挂载直接在本地编写项目就可以发布了
在/home/lcc/build/test目录下(对应tomcat里面的webapps/test)创建一个WEB-INFO文件，用来保存web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
id="WebApp_ID" version="2.5">
</web-app>
然后在test目录下创建一个jsp文件，用于放显示的页面
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>菜鸟教程(runoob.com)</title>
</head>
<body>
Hello World!<br/>
<%
out.println("你的 IP 地址 " + request.getRemoteAddr());
%>
</body>
</html>
发布自己的镜像
1.在服务器上登录自己的docker hub 账号
[root@VM-24-16-centos ~]# docker login -u 627058587
Password:
WARNING! Your password will be stored unencrypted in /root/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store
Login Succeeded
2.通过docker push上传镜像
首先在docker hub账户上得有一个叫lcc/tomcat01的仓库，才能上传成功
[root@VM-24-16-centos ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
lcc/tomcat01 1.0 fe6e797b51eb 17 hours ago 635MB
[root@VM-24-16-centos ~]# docker push lcc/tomcat01:1.0
Docker网络
理解Docker0
#通过 ip addr查看网卡，1.lo:本机回环地址 2.etho:服务器的内网地址 3.docker0：docker为我们生成的网卡
[root@VM-24-16-centos ~]# 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
inet6 ::1/128 scope host
valid_lft forever preferred_lft forever
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
link/ether 52:54:00:9d:d5:e9 brd ff:ff:ff:ff:ff:ff
inet 10.0.24.16/22 brd 10.0.27.255 scope global eth0
valid_lft forever preferred_lft forever
inet6 fe80::5054:ff:fe9d:d5e9/64 scope link
valid_lft forever preferred_lft forever
3: docker0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN group default
link/ether 02:42:86:db:a0:89 brd ff:ff:ff:ff:ff:ff
inet 172.17.0.1/16 brd 172.17.255.255 scope global docker0
valid_lft forever preferred_lft forever
inet6 fe80::42:86ff:fedb:a089/64 scope link
valid_lft forever preferred_lft forever
两个容器之间可以通(像ES跟Kibana)（–link方法，目前不推荐使用了）
在我们安装了docker的前提下，我们每启动一个docker容器，docker就会给容器分配一个ip地址，然后就会有一个网卡的桥接模式，使用的技术是evth-pair技术。
evth-pair技术，就是一对虚拟的设备接口，一般都是成对的出现，一段连着协议，一段彼此相连。evth是充当一个桥梁的，连接着各种虚拟设备。
容器跟容器之间是可以互相ping通。
1.创建容器
#通过--link命令使两个容器可以ping通
[root@VM-24-16-centos ~]# docker run -d -P --name lcc02 --link lcc01 tomcat
[root@VM-24-16-centos ~]# docker run -d -P --name lcc01 tomcat
2.发现问题
#发现一个linux_go:380:ping的问题
#上网查找解决方案，容器内部是没有ping命令的，所以需要进入容器给她安装
[root@VM-24-16-centos ~]# docker run -d -P --name lcc02 --link lcc01 tomcat
749cbb661015efd23edbee10767b73a22f028d2e052404e2bc0cbaa11e35beae
[root@VM-24-16-centos ~]# docker exec -it lcc02 ping lcc01
OCI runtime exec failed: exec failed: container_linux.go:380: starting container process caused: exec: "ping": executable file not found in $PATH: unknown
[root@VM-24-16-centos ~]# docker exec -it 749cbb661015 /bin/bash
root@749cbb661015:/usr/local/tomcat# apt-get update && apt-get install iputils-ping
#解决容器不能使用ip addr的问题
[root@VM-24-16-centos ~]# docker exec -it 749cbb661015 /bin/bash
root@749cbb661015:/usr/local/tomcat# ip addr
bash: ip: command not found
root@749cbb661015:/usr/local/tomcat# apt update && apt install -y iproute2
3.两个容器之间ping
#但是上面知识配置了lcc02 ping通的协议，没有配置lcc01到lcc02的协议，所以这边反向ping是不能通的。
[root@VM-24-16-centos ~]# docker exec -it lcc02 ping lcc01
PING lcc01 (172.17.0.3) 56(84) bytes of data.
64 bytes from lcc01 (172.17.0.3): icmp_seq=1 ttl=64 time=0.085 ms
64 bytes from lcc01 (172.17.0.3): icmp_seq=2 ttl=64 time=0.062 ms
64 bytes from lcc01 (172.17.0.3): icmp_seq=3 ttl=64 time=0.063 ms
64 bytes from lcc01 (172.17.0.3): icmp_seq=4 ttl=64 time=0.059 ms
4.容器可以被本地ping通的原因，以及互相ping通的原因
原理：通过查看本地的网络信息发现，我们本地是个.0的广播地址，而其他的容器都是在这个广播地址的同一网关下的，而docker容器在创建的时候就会使用evth-pair技术，在本地留下一个跟容器网络地址通的一个配对的协议，所以可以ping通。
#通过命令查看本地的网络信息
[root@VM-24-16-centos ~]# docker network ls
NETWORK ID NAME DRIVER SCOPE
adb99bb0f4ff bridge bridge local
0a870da121ce host host local
2d316dc6bd8b none null local
[root@VM-24-16-centos ~]# docker network inspect adb99bb0f4ff
"IPAM": {
"Driver": "default",
"Options": null,
"Config": [
{
"Subnet": "172.17.0.0/16"
}
"Containers": {
"749cbb661015efd23edbee10767b73a22f028d2e052404e2bc0cbaa11e35beae": {
"Name": "lcc02",
"EndpointID": "1d9af08cad048b7a632a77b154530e581d2631874cdc1ea3e9f0e2c3fe1edc22",
"MacAddress": "02:42:ac:11:00:04",
"IPv4Address": "172.17.0.4/16",
"IPv6Address": ""
},
"9fbd8d0146684a182c55ca8e4e1cd924e0faab01f2e1076b57573308538c1a7e": {
"Name": "tomcat01",
"EndpointID": "ef82d8d08b2027e4f1bc40095387b3bfd9cd401f3395c493ad0ecc3200248ec3",
"MacAddress": "02:42:ac:11:00:02",
"IPv4Address": "172.17.0.2/16",
"IPv6Address": ""
},
"e1c41d4b1a772c75285a464dd2989830146ab4f8601b829bdbd502305420fcf0": {
"Name": "lcc01",
"EndpointID": "5c2c408e041d8fa29ebe650f9440f6bbe085a24f6d31276bee65f3e6c4241818",
"MacAddress": "02:42:ac:11:00:03",
"IPv4Address": "172.17.0.3/16",
"IPv6Address": ""
}
},
而容器内部如何给另外个容器ping通的呢？通过查看hosts发现，他将lcc01容器的配置直接写死在里面，你要ping lcc01的时候，他直接给转发到172.17.0.3中，映射于此。
[root@VM-24-16-centos ~]# docker exec -it 749cbb661015 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 lcc01 e1c41d4b1a77
172.17.0.4 749cbb661015
自定义网络（推荐使用）
1.查看所有的docker网络
[root@VM-24-16-centos ~]# docker network ls
NETWORK ID NAME DRIVER SCOPE
adb99bb0f4ff bridge bridge local
0a870da121ce host host local
2d316dc6bd8b none null local
2.网络模式
bridge：桥接(默认，自己创建也是用这个)
none：不配置网络(一般不用)
host：和宿主机共享网络
contanier：容器网络连通（用的少。局限性很大）
3.自定义网路
#我们直接docker run的命令其实是默认进入bridge的
docker run -d -P --name tomcat01 tomcat
#等同于
docker run -d -P --name tomcat01 -net bridge tomcat
#自定义网络
#--drive:连接方式，选择了桥接; --subnet:子网的地址;--gateway:网关; 最后是这个网络的名字
[root@VM-24-16-centos ~]# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
df03af65dc8bc90cc07fcaa07ad7efe9ff4d41c5ceab6570958b4d4babde58dc
[root@VM-24-16-centos ~]# docker network ls
NETWORK ID NAME DRIVER SCOPE
df03af65dc8b mynet bridge local
4.测试
#创建两个通过mynet搭建的容器
[root@VM-24-16-centos ~]# docker run -d -P --name tomcat-mynet01 --net mynet tomcat
21eed844648ded49cdee7a237cf9873d1ce6e716eeedcca2efd8717b1dda7dda
[root@VM-24-16-centos ~]# docker run -d -P --name tomcat-mynet02 --net mynet tomcat
e5fb648d3d87e5412c713d2ec2de5f6288567c06a2369def2aeab79c350adbb3
#查看mynet中的配置，发现两者都在其中了
[root@VM-24-16-centos ~]# docker network inspect mynet
"Containers": {
"21eed844648ded49cdee7a237cf9873d1ce6e716eeedcca2efd8717b1dda7dda": {
"Name": "tomcat-mynet01",
"EndpointID": "8a9f26d78e634de023e3eb919ab2ab34d0eb96197ee65bba2cabee05d075bda8",
"MacAddress": "02:42:c0:a8:00:02",
"IPv4Address": "192.168.0.2/16",
"IPv6Address": ""
},
"e5fb648d3d87e5412c713d2ec2de5f6288567c06a2369def2aeab79c350adbb3": {
"Name": "tomcat-mynet02",
"EndpointID": "5b7179c287cbdcebe3fcf1e3ce723d76eaaf7161b4d0c19bbe69b74bb0cb2827",
"MacAddress": "02:42:c0:a8:00:03",
"IPv4Address": "192.168.0.3/16",
"IPv6Address": ""
}
},
小结
1.在原来的–link方法中，运用的底层是docker0，所以都需要往docker0上–link才行，比较麻烦。
而现在用了自己自定义的网络，可以使得不同种类的容器之间使用不一样的网段，相同种类的容器之间不需要声明–link就可以直接打通。
2.但是我们想要两个在不同网络的容器想要互通怎么办呢？答案是docker network connect
#使用docker connect方法
[root@VM-24-16-centos ~]# docker network connect --help
Usage: docker network connect [OPTIONS] NETWORK CONTAINER
Connect a container to a network
Options:
--alias strings Add network-scoped alias for the container
--driver-opt strings driver options for the network
--ip string IPv4 address (e.g., 172.30.100.104)
--ip6 string IPv6 address (e.g., 2001:db8::33)
--link list Add link to another container
#所以运行以下代码，连通容器放入到mynet中，lcc01中的网络就会放入到mynet网络下。
docker network connect mynet lcc01
构建部署Redis集群
1.构建一个属于redis自身的网卡
[root@VM-24-16-centos ~]# docker network create redis --subnet 172.38.0.0/16
98965fbd10d790c40329a33cd81c28c99b9ab0626830af9a97e0720e8c746866
2.通过指令创建多个redis容器
1.通过for循环，循环6次
2.创建redis的配置文件
3.创建redis的conf配置
4.写上具体配置:容器端口6379;cluster-enabled:开启集群;cluster-announce-ip${port}:连接具体的ip。
[root@VM-24-16-centos ~]# for port in $(seq 1 6);\
> do\
> mkdir -p /mydata/redis/node-${port}/conf
> touch /mydata/redis/node-${port}/conf/redis.conf
> cat << EOF >>/mydata/redis/node-${port}/conf/redis.conf
> port 6379
> bind 0.0.0.0
> cluster-enabled yes
> cluster-config-file nodes.conf
> cluster-node-timeout 5000
> cluster-announce-ip 172.38.0.1${port}
> cluster-announce-port 6379
> cluster-announce-bus-port 16379
> appendonly yes
> EOF
> done
3.启动redis容器
说明：
1.启动redis，6379映射到本地6371，16379映射到本地16371，名字为redis-1
2.数据卷挂载，将内部的data跟redis.conf挂载到外部的文件里
3.使用redis的网卡
4.--ip:绑定ip号
5.redis:5.0.9-alipine3.11:redis版本
6.通过redis.conf启动
1.方法一：启动redis-1。而后的2-6就是修改其中的637X、1637X、172.38.0.1X就行。
[root@VM-24-16-centos redis]# 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.11 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
Unable to find image 'redis:5.0.9-alpine3.11' locally
5.0.9-alpine3.11: Pulling from library/redis
cbdbe7a5bc2a: Pull complete
dc0373118a0d: Pull complete
cfd369fe6256: Pull complete
3e45770272d9: Pull complete
558de8ea3153: Pull complete
a2c652551612: Pull complete
Digest: sha256:83a3af36d5e57f2901b4783c313720e5fa3ecf0424ba86ad9775e06a9a5e35d0
Status: Downloaded newer image for redis:5.0.9-alpine3.11
616cabb51e1fb995db3dc6030d7d6e0bd55dab0182acbf5eee3e2452ca97c76e
2.方法二：上述方法一个个去启动比较麻烦，通过代码去遍历启动。
docker run -p 637#{port}:6379 -p 1637${port}:16379 --name redis-${port} \
-v /mydata/redis/node-${port}/data:/data \
-v /mydata/redis/node-${port}/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.1${port} redis:5.0.9-alpine3.11 redis-server /etc/redis/reids.conf; \
4.创建集群并且查看配置
发现有主从机。整个redis为3个主机，3个从机，一个没用了，从机接上
[root@VM-24-16-centos ~]# docker exec -it redis-1 /bin/sh
/data # /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
/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:901
cluster_stats_messages_pong_sent:883
cluster_stats_messages_sent:1784
cluster_stats_messages_ping_received:878
cluster_stats_messages_pong_received:901
cluster_stats_messages_meet_received:5
cluster_stats_messages_received:1784
127.0.0.1:6379> cluster nodes
c16966b2eaa715293b51bcc698418276edf2b520 172.38.0.13:6379@16379 master - 0 1638351604551 3 connected 10923-16383
1fcfe80567a8ed8fdeeef3f5d933d77e81749df4 172.38.0.15:6379@16379 slave a65d3110218e933ccc0a70faa50cd0af1ea11c8e 0 1638351605000 5 connected
637fccd55dd0291fde8837f5cf462a6f770c81e1 172.38.0.14:6379@16379 slave c16966b2eaa715293b51bcc698418276edf2b520 0 1638351605354 4 connected
632401c1cad070f19828e113f330bcbbf33b2f59 172.38.0.12:6379@16379 master - 0 1638351605855 2 connected 5461-10922
a65d3110218e933ccc0a70faa50cd0af1ea11c8e 172.38.0.11:6379@16379 myself,master - 0 1638351604000 1 connected 0-5460
7db5822acedfc07ee067bbb7c933f10b2ee207c0 172.38.0.16:6379@16379 slave 632401c1cad070f19828e113f330bcbbf33b2f59 0 1638351606355 6 connected
127.0.0.1:6379> read escape sequence
SpringBoot微服务打包成Docker镜像发布
1.随便创建一个springboot的项目
通过生命周期里面的package打包到target下面。
2.在IDEA中编写Dockerfile
#用java8基础镜像
FROM java:8
#将当前目录下的.jar放入到容器目录下的/app.jar下(首先将步骤1中的jar放入到./目录下)
COPY *.jar /app.jar
#容器运行时候映射服务器的地址8080
CMD ["--server.port=8080"]
#暴露端口8080
EXPOSE 8080
#执行java -jar /app.jar 命令
ENTRYPOINT ["java","-jar","/app.jar"]
3.运用Xftp将jar包跟dockerfile放入到xshell指定目录中(这次用的是/home/idea)
4.构建镜像
[root@VM-24-16-centos idea]# docker build -t lcc666 .
Sending build context to Docker daemon 17.49MB
Step 1/5 : FROM java:8
Get "https://registry-1.docker.io/v2/": read tcp 10.0.24.16:59970->54.161.109.204:443: read: connection reset by peer
#发现问题：貌似是带宽不够的问题？？？？？？？？？？？？
#解决问题：提供腾讯云镜像加速(因为用的是腾讯云)
[root@VM-24-16-centos /]# vi /etc/docker/daemon.json
[root@VM-24-16-centos /]# sudo systemctl daemon-reload
[root@VM-24-16-centos /]# sudo systemctl restart docker
[root@VM-24-16-centos /]# docker info
#构建镜像
[root@VM-24-16-centos idea]# docker build -t lcc666 .
Sending build context to Docker daemon 17.49MB
Step 1/5 : FROM java:8
8: Pulling from library/java
5.发布运行！
查看上面的笔记。如果进行发布运行的即可
1.docker login登录自己的docker账号
2.docker push上传镜像到自己的repo上。
有问题，可以私聊学长哦～
11万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
