IT数码 购物 网址 头条 软件 日历 阅读 图书馆
TxT小说阅读器
↓语音阅读,小说下载,古典文学↓
图片批量下载器
↓批量下载图片,美女图库↓
图片自动播放器
↓图片自动播放器↓
一键清除垃圾
↓轻轻一点,清除系统垃圾↓
开发: C++知识库 Java知识库 JavaScript Python PHP知识库 人工智能 区块链 大数据 移动开发 嵌入式 开发工具 数据结构与算法 开发测试 游戏开发 网络协议 系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑 笔记本 显卡 显示器 固态硬盘 硬盘 耳机 手机 iphone vivo oppo 小米 华为 单反 装机 图拉丁
 
   -> 系统运维 -> Java面试复习---Docker(狂神版) -> 正文阅读

[系统运维]Java面试复习---Docker(狂神版)


前言

本文是Java面试复习系列中的Docker,后面会陆续有该系列其他篇章,并且会一直维护。本系列都为网上资源整理而来,如有问题,及时联系。


Docker学习路径

Docker学习

  • Docker概述
  • Docker安装
  • Docker命令
    • 镜像命令
    • 容器命令
    • 操作命令
    • 。。。
  • Docker镜像
  • 容器数据卷
  • DockerFile
  • Docker网络原理
  • IDEA整合Docker
  • DockerCompose
  • DockerSwarm
  • CI\CD Jenkins

Docker概述

Docker为什么出现?

一款产品:开发–上线 两套环境! 应用环境,应用配置

开发—运维,问题:在自己的电脑上可以运行,别人电脑不行!版本更新,导致服务不可用!对运维来说,考验十分大

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

发布一个项目(jar+(Redsi Mysql jdk es)),项目能不能带上环境安装打包!

之前在服务器配置一个应用的环境Redis、MySQL、jdk等,配置超级麻烦,不能跨平台

传统:开发jar,运维来做

现在:开发打包部署上线,一套流程

Docker就是解决以上问题

Docker的思想来自于集装箱

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

隔离:Docker核心思想!打包装箱!没有箱子相互隔离

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

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

Docker的历史

2010年,几个年轻人,在美国成立了一家公司dotCloud,做一些pass云计算机服务!LXC有关的容器技术!

他们将自己的技术(容器化技术)命名就是Docker!

Docker刚刚诞生的时候,没有引起行业的注意,!活不下去

2013年!Docker开源!每月更新一个版本!

2014年4月9日,Docker发布,Docker十分轻巧

虚拟机:在window中安装一个Vmware,通过这个软件我们可以虚拟出来一个或者多个电脑!笨重!虚拟机也是属于虚拟化技术,Docker容器技术,也是一种虚拟化技术

vm:linux centos原生镜像(一个电脑)隔离,需要开启多个虚拟机
docker:隔离 镜像(最核心的环境)十分小巧

到现在,所有开发人员都必须要回Docker

聊聊Docker

Docker是基于go语言开发!开源项目

官网 文档(超级详细)

DockerHub

Docker能干嘛

之前的虚拟机技术

在这里插入图片描述

虚拟机技术缺点:

1.资源占用十分多

2.冗余步骤多

3.启动慢

容器化技术

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

在这里插入图片描述

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

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

DevOps(开发、运维)

  • 更快速的交付和部署

    • 传统:一堆帮助文档,安装程序
    • Docker:打包镜像发布测试,一键运行
  • 更便捷的升级和扩缩容

    • 使用了Docker之后,我们部署应用就和搭积木一样
    • 项目打包为一个镜像,扩展
  • 更简单的系统运维

    • 在容器化之后,我们的开发,测试环境是高度一致的
  • 更高效的计算资源利用

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

Docker安装

Docker的基本组成

  • 客户端
  • 服务器
  • 仓库

镜像(image):

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

容器(container):

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

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

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

仓库(repository):

仓库就是存放镜像的地方!仓库分为公有仓库和私有仓库!DockerHub(默认是国外的)!阿里云等都有容器服务器(配置镜像加速)!

安装Docker

环境准备

1.需要会一点Linux

2.Centos7

3.使用Xshell连接远程服务器进行操作

环境查看

[root@iZwz9j3h85ywjfp5klhlrnZ /]# cat /etc/os-release
NAME="CentOS Linux"
VERSION="8"
ID="centos"
ID_LIKE="rhel fedora"
VERSION_ID="8"
PLATFORM_ID="platform:el8"
PRETTY_NAME="CentOS Linux 8"
ANSI_COLOR="0;31"
CPE_NAME="cpe:/o:centos:centos:8"
HOME_URL="https://centos.org/"
BUG_REPORT_URL="https://bugs.centos.org/"
CENTOS_MANTISBT_PROJECT="CentOS-8"
CENTOS_MANTISBT_PROJECT_VERSION="8"

安装

# 1.卸载旧版本
 sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine
                  
# 2.需要的安装包
 sudo yum install -y yum-utils
# 3.设置镜像的仓库
 sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo # 默认是国外的
    
 sudo 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.hello-world

# 8.查看一下下载的hello-world镜像

卸载Docker

# 1.卸载依赖
 sudo yum remove docker-ce docker-ce-cli containerd.io
# 2.删除资源
 sudo rm -rf /var/lib/docker  #docker的默认工作路径
 sudo rm -rf /var/lib/containerd

阿里云镜像加速

1.登录阿里云

2.找到镜像加速地址

3.配置使用

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

回顾HelloWorld

在这里插入图片描述

底层原理

Docker是怎么工作的?

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

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

在这里插入图片描述

Docker为什么比VM快?

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

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

在这里插入图片描述

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

Docker的常用命令

帮助命令

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

帮助文档的地址:https://docs.docker.com/engine/reference/commandline/

镜像命令

docker image查看所有本地主机上的镜像
[root@daigua /]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED        SIZE
hello-world   latest    d1165f221234   5 months ago   13.3kB

# 解释 
REPOSITORY 镜像的仓库源
TAG 镜像的标签
IMAGE 镜像id
CREATED 镜像的创建时间
SIZE 镜像的大小

# 可选项
-a,--all #列出所有镜像
-q,--quiet #只显示镜像的id
docker search搜索镜像
[root@daigua /]# docker search mysql
NAME                              DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
mysql                             MySQL is a widely used, open-source relation…   11205     [OK]       
mariadb                           MariaDB Server is a high performing open sou…   4259      [OK]       
mysql/mysql-server                Optimized MySQL Server Docker images. Create…   833  

# 可选项,通过收藏来过滤
--filter=STARS=3000 # 搜索出来的镜像就是STARS大于3000的
docker pull下载镜像
# 下载镜像 docker pull 镜像名[:tag]
[root@daigua /]# docker pull mysql
Using default tag: latest # 如果不写tag,默认就是latest
latest: Pulling from library/mysql
33847f680f63: Pull complete # 分层下载 docker images的核心
5cb67864e624: Pull complete 
1a2b594783f5: Pull complete 
b30e406dd925: Pull complete 
48901e306e4c: Pull complete 
603d2b7147fd: Pull complete 
802aa684c1c4: Pull complete 
715d3c143a06: Pull complete 
6978e1b7a511: Pull complete 
f0d78b0ac1be: Pull complete 
35a94d251ed1: Pull complete 
36f75719b1a9: Pull complete 
Digest: sha256:8b928a5117cf5c2238c7a09cd28c2e801ac98f91c3f8203a8938ae51f14700fd # 签名
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest # 真实地址

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

# 指定版本下载
[root@daigua /]# docker pull mysql:5.7
5.7: Pulling from library/mysql
33847f680f63: Already exists 
5cb67864e624: Already exists 
1a2b594783f5: Already exists 
b30e406dd925: Already exists 
48901e306e4c: Already exists 
603d2b7147fd: Already exists 
802aa684c1c4: Already exists 
5b5a19178915: Pull complete 
f9ce7411c6e4: Pull complete 
f51f6977d9b2: Pull complete 
aeb6b16ce012: Pull complete 
Digest: sha256:be70d18aedc37927293e7947c8de41ae6490ecd4c79df1db40d1b5b5af7d9596
Status: Downloaded newer image for mysql:5.7
docker.io/library/mysql:5.7
docker rmi 删除镜像
[root@daigua /]# docker rmi -f 容器id # 删除指定的镜像
[root@daigua /]# docker rmi -f 容器id 容器id 容器id # 删除多个镜像
[root@daigua /]# docker rmi -f $(docker images -aq) # 删除全部镜像

容器命令

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

docker pull centos
新建容器并启动
docker run[可选参数] image

# 参数说明
--name="NAME" 容器名字 用来区分容器
-d            后台运行
-it           使用交互方式运行,进入容器查看内容
-p            指定容器端口
  -p ip:主机端口:容器端口
  -p 主机端口:容器端口
  -p 容器端口
  容器端口
-p             随机指定端口

# 测试:启动并进入容器
[root@daigua /]# docker run -it centos /bin/bash
[root@24de185362f3 /]# ls # 查看容器内部centos,基础版本,很多命令都是不完善的
bin  etc   lib	  lost+found  mnt  proc  run   srv  tmp  var
dev  home  lib64  media       opt  root  sbin  sys  usr

# 从容器中退出到主机
[root@24de185362f3 /]# exit
exit
[root@daigua /]# ls
bin   dev  home  lib64       media  opt    proc  run   srv  tmp  var
boot  etc  lib   lost+found  mnt    patch  root  sbin  sys  usr  www
列出所有的运行容器
# docker ps 命令
  #列出当前正在运行的容器
-a #列出当前正在运行的容器+带出历史运行过的容器
-n=? #显示最近创建的容器
-aq # 只显示容器编号

[root@daigua /]# docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
[root@daigua /]# docker ps -a
CONTAINER ID   IMAGE          COMMAND       CREATED         STATUS                     PORTS     NAMES
24de185362f3   centos         "/bin/bash"   6 minutes ago   Exited (0) 4 minutes ago             confident_fermat
d260d8e9d713   d1165f221234   "/hello"      2 hours ago     Exited (0) 2 hours ago               kind_merkle
[root@daigua /]# docker ps -n=1
CONTAINER ID   IMAGE     COMMAND       CREATED         STATUS                     PORTS     NAMES
24de185362f3   centos    "/bin/bash"   6 minutes ago   Exited (0) 5 minutes ago             confident_fermat
[root@daigua /]# docker ps -aq
24de185362f3
d260d8e9d713
退出容器
exit # 退出容器 停止并推出
ctrl + p + q # 容器不停止退出
删除容器
docker rm 容器id                    # 删除指定容器(不能删除正在运行的容器,强制删除 rm -f)
docker rm -f $(docker ps -aq)      # 删除所有容器
docker ps -a -q | xargs docker rm  # 删除所有容器
启动和停止容器
docker start 容器id      # 启动容器
docker restart 容器id    # 重启容器
docker stop 容器id       # 停止当前正在运行的容器
docker kill 容器id       # 强制停止容器

常用其他命令

后台启动容器
# 命令 docker run -d 镜像名
[root@daigua ~]# docker run -d centos
#问题 docker ps时,发现centos停止
#常见的坑,docker容器使用后台运行,就必须要有一个后台进程,docker发现没有应用,就会自动停止
# nginx,容器启动,发现自己没有提供服务,就会立刻停止,就是没有程序了
查看日志
docker logs -tf --tail 容器

#自己编写一段Shell脚本
[root@daigua ~]#  docker run -d centos /bin/sh -c "while true;do echo kuangshen;sleep 1;done"

# 显示日志
-tf       #显示日志
--tail number  # 要显示日志的条数
[root@daigua ~]# docker logs -tf --tail 10 容器id
查看容器中进程信息
# 命令 docker top 容器id
[root@daigua ~]# docker top aa7725e69152
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                21055               21037               0                   18:28               pts/0               00:00:00            /bin/bash
查看镜像的元数据
# 命令
docker inspect 容器id
[root@daigua ~]# docker inspect aa7725e69152
进入当前正在运行的容器
# 我们通常容器都是使用后台方式运行的

# 命令
docker exec -it 容器id bashShell

# 测试
[root@daigua ~]# docker exec -it aa7725e69152 /bin/bash
[root@aa7725e69152 /]# ls
bin  etc   lib	  lost+found  mnt  proc  run   srv  tmp  var
dev  home  lib64  media       opt  root  sbin  sys  usr
[root@aa7725e69152 /]# ps -ef
UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 10:28 pts/0    00:00:00 /bin/bash
root        22     0  0 10:58 pts/1    00:00:00 /bin/bash
root        37    22  0 10:58 pts/1    00:00:00 ps -ef

# 方式二
docker attach 容器id
# 测试
[root@daigua ~]# docker attach aa7725e69152
正在执行当前的代码

# docker exec     # 进入容器开启一个新的终端,可以在里面操作
# docker attach   # 进入容器正在执行的终端,不会启动新的进程
从容器内拷贝文件到主机
docker cp 容器id:容器内路径 目的地主机路径

# 查看当前主机目录
[root@daigua ~]# ls
install.sh  nohup.out
[root@daigua ~]# cd /home
[root@daigua home]# ls
springboot  www
[root@daigua home]# touch kuangshen.java
[root@daigua home]# ls
kuangshen.java  springboot  www
[root@daigua home]# docker ps
CONTAINER ID   IMAGE     COMMAND       CREATED              STATUS              PORTS     NAMES
14df9b83a376   centos    "/bin/bash"   About a minute ago   Up About a minute             exciting_fermi
0f6af92534e5   centos    "/bin/bash"   3 minutes ago        Up 3 minutes                  thirsty_kilby

# 进入docker容器内部
[root@daigua home]# docker attacher 14df9b83a376
docker: 'attacher' is not a docker command.
See 'docker --help'
[root@daigua home]# docker attach 14df9b83a376
[root@14df9b83a376 /]# cd /home
[root@14df9b83a376 home]# ls

# 在容器内部创建一个文件夹
[root@14df9b83a376 home]# touch test.java
[root@14df9b83a376 home]# exit
exit

# 将文件拷贝到主机
[root@daigua home]# docker cp 14df9b83a376:/home/test.java /home
[root@daigua home]# ls
kuangshen.java  springboot  test.java  www

# 拷贝是一个手动过程,未来我们使用-V卷的技术

作业练习

Docker 安装 Nginx

# 1.搜索镜像 search 建议去docker搜索,可以看到帮助文档
# 2.下载镜像 pull
# 3.运行测试
[root@daigua ~]# docker images
REPOSITORY   TAG       IMAGE ID       CREATED        SIZE
nginx        latest    08b152afcfae   12 days ago    133MB
centos       latest    300e315adb2f   7 months ago   209MB

# -d 后台运行
# --name 给容器命名
# -p 宿主机端口:容器内部端口
[root@daigua ~]# docker run -d --name nginx01 -p 3344:80 nginx
c4e2eb9435fc33678212bcdd1b1ca29ce68c94fc9fc766c3cc8d99e7c670fbcc
[root@daigua ~]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS                  NAMES
c4e2eb9435fc   nginx     "/docker-entrypoint.…"   8 seconds ago   Up 7 seconds   0.0.0.0:3344->80/tcp   nginx01
[root@daigua ~]# curl localhost:3344

# 进入容器
[root@daigua ~]# docker exec -it nginx01 /bin/bash
root@c4e2eb9435fc:/# whereis nginx
nginx: /usr/sbin/nginx /usr/lib/nginx /etc/nginx /usr/share/nginx
root@c4e2eb9435fc:/# cd etc/nginx
root@c4e2eb9435fc:/etc/nginx# ls
conf.d	fastcgi_params	mime.types  modules  nginx.conf  scgi_params  uwsgi_params
root@c4e2eb9435fc:/etc/nginx#     

端口暴露

在这里插入图片描述

docker 安装 tomcat

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

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

# 下载启动
docker pull tomcat

# 启动运行
[root@daigua ~]# docker run -d -p 3355:8080 --name tomcat01 tomcat

# 测试访问没有问题

# 进入容器
[root@daigua ~]# docker run -d -p 3355:8080 --name tomcat01 tomcat
d9a6fb45f9871f88244f619dcfe8cf08dfbedd682f73fc15140473133f332cfa
[root@daigua ~]# docker exec -it tomcat01 /bin/bash

# 发现问题:1.linu命令少量 2.没有webapps
# 原因:阿里云的问题,默认是最小镜像,所有不必要的都剔除,保证最小可用环境

部署es + kibana

# 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是十分耗内存的
# 增加内存限制,修改配置文件,-e 环境配置
$ docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512ms" elasticsearch:7.6.2

在这里插入图片描述

可视化

  • portainer(先用着)
docker run -d -p 8088:9000\
--restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer
  • Rancher(CI/CD用)
什么是portainer?

Dockers图形化界面工具!提供一个后台面板帮助我们操作

docker run -d -p 8088:9000 \
--restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer

访问测试:http://ip:8088

可视化面板一般不会使用

Docker镜像讲解

镜像是什么

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

所有的应用,直接打包成为docker镜像,直接跑起来

如何得到一个镜像

  • 从远程仓库下载
  • 拷贝
  • 自己制作

Docker镜像加载原理

UnionFS(联合文件系统)

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

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

Docker镜像加载原理

docker的镜像实际上由一层一层的文件系统组成,这种层级的文件系统UnionFS。

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

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

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

分层理解

分层的镜像

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

[root@daigua ~]# docker pull redis
Using default tag: latest
latest: Pulling from library/redis
33847f680f63: Already exists 
26a746039521: Pull complete 
18d87da94363: Pull complete 
5e118a708802: Pull complete 
ecf0dbe7c357: Pull complete 
46f280ba52da: Pull complete 
Digest: sha256:cd0c68c5479f2db4b9e2c5fbfdb7a8acb77625322dd5b474578515422d3ddb59
Status: Downloaded newer image for redis:latest
docker.io/library/redis:latest

思考:为什么Docker镜像采用分层下载

最大的好处,莫过于资源的共享!比如有多个镜像都从相同的Base镜像构建而来,那么宿主机只需要在磁盘上保留一份base镜像,同时内存中也只需要加载一份base镜像,这样就可以为所有的容器服务,而且镜像的每一层都可以共享

查看镜像分层的方式可以通过docker image inspect命令

# docker image inspect redis
           "Layers": [
                "sha256:814bff7343242acfd20a2c841e041dd57c50f0cf844d4abd2329f78b992197f4",
                "sha256:dd1ebb1f5319785e34838c7332a71e5255bda9ccf61d2a0bf3bff3d2c3f4cdb4",
                "sha256:11f99184504048b93dc2bdabf1999d6bc7d9d9ded54d15a5f09e36d8c571c32d",
                "sha256:e461360755916af80821289b1cbc503692cf63e4e93f09b35784d9f7a819f7f2",
                "sha256:45f6df6342536d948b07e9df6ad231bf17a73e5861a84fc3c9ee8a59f73d0f9f",
                "sha256:262de04acb7e0165281132c876c0636c358963aa3e0b99e7fbeb8aba08c06935"
            ]

特点

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

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

commit镜像

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

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

实战测试

# 启动一个默认的tomcat

# 发现这个默认的tomcat是没有webapps应用 官方问题

# 自己将文件拷贝进webapps

# 将操作完成的容器提交上去

[root@daigua ~]# docker run -it tomcat /bin/bash
root@86953bfac2bf:/usr/local/tomcat# ls
BUILDING.txt	 LICENSE  README.md	 RUNNING.txt  conf  logs	    temp     webapps.dist
CONTRIBUTING.md  NOTICE   RELEASE-NOTES  bin	      lib   native-jni-lib  webapps  work
root@86953bfac2bf:/usr/local/tomcat# cp -r webapps.dist/* webapps
root@86953bfac2bf:/usr/local/tomcat# cd webapps
root@86953bfac2bf:/usr/local/tomcat/webapps# ls
ROOT  docs  examples  host-manager  manager
root@86953bfac2bf:/usr/local/tomcat/webapps# exit
exit
[root@daigua ~]# docker commit -a="fan" -m="增加首页" 86953bfac2bf tomcat2.0:1.0
sha256:97e185399d0204ff8f2ec09f9240b0dd3692884d19a63c086499da3ee31d7b4b
[root@daigua ~]# docker images
REPOSITORY            TAG       IMAGE ID       CREATED          SIZE
tomcat2.0             1.0       97e185399d02   11 seconds ago   673MB
redis                 latest    aa4d65e670d6   11 days ago      105MB
tomcat                9.0       46cfbf1293b1   11 days ago      668MB

学习方式说明:理解概念,但是一定要实践,最后实践和理论相结合一次性搞定这个知识

如果你想要保存当前容器的状态,就可以通过commit来提交,获得一个镜像
就好比vm的快照

容器数据卷

什么是容器数据卷

docker概念回顾

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

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

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

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

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

在这里插入图片描述

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

使用数据卷

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

docker run -it -v 主机目录,容器目录

# 测试
[root@daigua ~]# docker run -it -v /home/ceshi:/home centos /bin/bash

# 启动起来,我们就可以通过 docker inspect 容器id查看
        "Mounts": [
            {
                "Type": "bind",
                "Source": "/home/ceshi",
                "Destination": "/home",
                "Mode": "",
                "RW": true,
                "Propagation": "rprivate"
            }
        ]

测试文件同步

在这里插入图片描述

再来测试

1.停止容器

2.宿主机上修改文件

3.启动容器

4.容器内的数据依旧同步

在这里插入图片描述

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

实战:安装MySQL

# 获取镜像
[root@daigua ~]# docker pull mysql:5.7

# 运行容器,需要做数据的挂载  # 安装启动mysql,需要配置密码
# 官方测试 docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag

# 启动mysql
-d 后台启动
-p 端口映射
-v 卷挂载
-e 环境配置
--name 容器名
[root@daigua ~]# docker run -d -p 3310:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7

# 启动成功之后,在本地使用sqlyog测试连接
# sqlyog连接到服务器3310,3310和容器的3306映射,这个时候我们就可以连接上

# 本地测试创建一个数据库,查看我们路径

假设我们将容器删除,发现,我们挂载到本机的数据卷依旧没有丢失,这就实现了容器数据的持久化

具名和匿名挂载

# 匿名挂载
-v 容器内路径
docker run -d -p --name nginx01 -v /etc/nginx nginx

# 查看所有的volume的情况
[root@daigua ~]# docker volume
local    9sdsd6786awe786465d4a8w8e76a6da1sda

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

# 具名挂载
[root@daigua ~]# docker rum -d -P --name  nginx02 -v juming-nginx:/etc/nginx nginx
[root@daigua ~]# docker volume ls

# 通过-v 卷名:容器内路径
# 查看一下卷
[root@daigua ~]# docker volume inspect juming-nagix

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

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

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

拓展:

# 通过 -v 容器内路径:ro rw 改变读写权限
ro readonly # 只读
rw readwrite # 读写
# 一旦设置了这个权限,容器对我们挂载出来的内容就限定了
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:ro nginx
# 只要看到ro就说明这个路径只能通过宿主机来操作,容器内部是无法操作的

初始Dockerfile

Docker就是用来构建docker镜像文件的

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

# 创建一个dockerfile文件,名字可以随机,建议Dockerfile
# 文件中的内容 指令(大写) 参数
FROM centos

VOLUME ["volume01","volume02"]

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

# 这里的每个命令,就是镜像的一层
[root@daigua docker-test-volume]# docker build -f /home/docker-test-volume/dockerfile -t kuangshen/centos:1.0 .
Sending build context to Docker daemon  2.048kB
Step 1/4 : FROM centos
 ---> 300e315adb2f
Step 2/4 : VOLUME ["volume01","volume02"]
 ---> Running in 0442f11f0a17
Removing intermediate container 0442f11f0a17
 ---> a7caf8c42f55
Step 3/4 : CMD echo "-----end-------"
 ---> Running in 8e1cd1273217
Removing intermediate container 8e1cd1273217
 ---> 41aa8ceacbd3
Step 4/4 : CMD /bin/bash
 ---> Running in 66deb7ecbbd4
Removing intermediate container 66deb7ecbbd4
 ---> fe6cd521df57
Successfully built fe6cd521df57
Successfully tagged kuangshen/centos:1.0
[root@daigua docker-test-volume]# docker images
REPOSITORY            TAG       IMAGE ID       CREATED          SIZE
kuangshen/centos      1.0       fe6cd521df57   27 seconds ago   209MB

查看挂载路径

 "Mounts": [
            {
                "Type": "volume",
                "Name": "c32726a8e1abe2a0e02313923f5265ce99808ec2e70ce001d6fa51973070d956",
                "Source": "/var/lib/docker/volumes/c32726a8e1abe2a0e02313923f5265ce99808ec2e70ce001d6fa51973070d956/_data",
                "Destination": "volume01",
                "Driver": "local",
                "Mode": "",
                "RW": true,
                "Propagation": ""
            },
            {
                "Type": "volume",
                "Name": "b083793fe22b6f9db920e2235893513b82f6b47eb129614d640c0b980e13eab9",
                "Source": "/var/lib/docker/volumes/b083793fe22b6f9db920e2235893513b82f6b47eb129614d640c0b980e13eab9/_data",
                "Destination": "volume02",
                "Driver": "local",
                "Mode": "",
                "RW": true,
                "Propagation": ""
            }
        ],
        
# 测试同步
[root@daigua /]# cd /var/lib/docker/volumes/c32726a8e1abe2a0e02313923f5265ce99808ec2e70ce001d6fa51973070d956/_data
[root@daigua _data]# ls
container.txt

这种方式未来用的十分多,因为我们通常构建自己的镜像

假设构建镜像时候没有挂载卷,需要手动挂载。 -v 卷名:容器内路径

数据卷容器

在这里插入图片描述

# 启动3个容器,通过自己写的镜像

# 启动docker01
[root@a7a3361451d8 /]# ls -l
total 56
lrwxrwxrwx   1 root root    7 Nov  3  2020 bin -> usr/bin
drwxr-xr-x   5 root root  360 Aug  5 02:58 dev
drwxr-xr-x   1 root root 4096 Aug  5 02:58 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 Dec  4  2020 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 120 root root    0 Aug  5 02:58 proc
dr-xr-x---   2 root root 4096 Dec  4  2020 root
drwxr-xr-x  11 root root 4096 Dec  4  2020 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 Aug  5 02:36 sys
drwxrwxrwt   7 root root 4096 Dec  4  2020 tmp
drwxr-xr-x  12 root root 4096 Dec  4  2020 usr
drwxr-xr-x  20 root root 4096 Dec  4  2020 var
drwxr-xr-x   2 root root 4096 Aug  5 02:58 volume01
drwxr-xr-x   2 root root 4096 Aug  5 02:58 volume02

# 将docker02挂载到docker01
[root@daigua ~]# docker run -it --name docker02 --volumes-from docker01 kuangshen/centos:1.0
[root@b4038952a17b /]# ls -l
total 56
lrwxrwxrwx   1 root root    7 Nov  3  2020 bin -> usr/bin
drwxr-xr-x   5 root root  360 Aug  5 03:01 dev
drwxr-xr-x   1 root root 4096 Aug  5 03:01 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 Dec  4  2020 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 122 root root    0 Aug  5 03:01 proc
dr-xr-x---   2 root root 4096 Dec  4  2020 root
drwxr-xr-x  11 root root 4096 Dec  4  2020 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 Aug  5 02:36 sys
drwxrwxrwt   7 root root 4096 Dec  4  2020 tmp
drwxr-xr-x  12 root root 4096 Dec  4  2020 usr
drwxr-xr-x  20 root root 4096 Dec  4  2020 var
drwxr-xr-x   2 root root 4096 Aug  5 02:58 volume01
drwxr-xr-x   2 root root 4096 Aug  5 02:58 volume02

# 只要通过--volumes-from,容器之间的数据就可以共享
# 测试,可以删除docker01,查看docker02 3 是否还可以访问这个文件
# 结果:可以

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

DockerFile

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      # 镜像的工资目录
VOLUME       # 挂载的目录
EXPOST       # 保留端口配置
CMD          # 指定这个容器启动的时候要运行的命令,只有最后一个会运行,可被替代
ENTRYPOINT   # 指定这个容器启动的时候要运行的命令,可追加命令
ONBUILD      # 当构建一个被继承Dockerfile这个时候就会运行ONBUILD指令,触发指令
COPY         # 类似ADD,将我们文件拷贝到镜像中
ENY          # 构建的时候设置环境变量

实战测试

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

创建一个自己的Centos

# 编写dockerfile的文件
[root@daigua dockerfile]# vim mydockerfile-centos
[root@daigua dockerfile]# cat mydockerfile-centos 
FROM centos
MAINTAINER fan<1434919820@

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 

# 通过这个文件构建镜像
[root@daigua dockerfile]# docekr build -f mydockerfile-centos -t mycentos:0.1 .

# 测试运行

对比:之前原生的

在这里插入图片描述

我们增加之后的镜像

在这里插入图片描述

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

[root@daigua dockerfile]# docker history 5bf9a435a6d9
IMAGE          CREATED         CREATED BY                                      SIZE      COMMENT
5bf9a435a6d9   6 minutes ago   /bin/sh -c #(nop)  CMD ["/bin/sh" "-c" "/bin…   0B        
d12eb478f9ae   6 minutes ago   /bin/sh -c #(nop)  CMD ["/bin/sh" "-c" "echo…   0B        
9832eb8ad76e   6 minutes ago   /bin/sh -c #(nop)  CMD ["/bin/sh" "-c" "echo…   0B        
f00ed1e50f53   6 minutes ago   /bin/sh -c #(nop)  EXPOSE 80                    0B        
9058df08b917   6 minutes ago   /bin/sh -c yum -y install net-tools             27.7MB    
e71b79b5e018   7 minutes ago   /bin/sh -c yum -y install vim                   65.2MB    
afc9a51b375e   7 minutes ago   /bin/sh -c #(nop) WORKDIR /usr/local            0B        
14f82bd8f55d   7 minutes ago   /bin/sh -c #(nop)  ENV MYPATH=/usr/local        0B        
9c5b629f5659   7 minutes ago   /bin/sh -c #(nop)  MAINTAINER fan<1434919820@   0B        
300e315adb2f   8 months ago    /bin/sh -c #(nop)  CMD ["/bin/bash"]            0B        
<missing>      8 months ago    /bin/sh -c #(nop)  LABEL org.label-schema.sc…   0B        
<missing>      8 months ago    /bin/sh -c #(nop) ADD file:bd7a2aed6ede423b7…   209MB     

CMD 和 ENTRYPOINT 区别

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

测试CMD

# 编写dockerfile文件
[root@daigua dockerfile]# vim dockerfile-cmd-test
FROM centos
CMD ["ls","-a"]

# 构建镜像
[root@daigua dockerfile]# docker build -f dockerfile-cmd-test -t cmdtest .
Sending build context to Docker daemon  15.87kB
Step 1/2 : FROM centos
 ---> 300e315adb2f
Step 2/2 : CMD ["ls","-a"]
 ---> Running in 4627540349b1
Removing intermediate container 4627540349b1
 ---> 11496f96a4da
Successfully built 11496f96a4da
Successfully tagged cmdtest:latest

# run运行,发现ls -a生效
[root@daigua dockerfile]# docker run 11496f96a4da.
..
.dockerenv
bin
dev
etc
home
lib
lib64

# 想追加一个命令 -l
[root@daigua dockerfile]# docker run 11496f96a4da -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不是命令,所以报错

测试ENTRYPOINT

[root@daigua dockerfile]# docker build -f dockerfile-cmd-entrypoint -t entrypoint-test .
Sending build context to Docker daemon   16.9kB
Step 1/2 : FROM centos
 ---> 300e315adb2f
Step 2/2 : ENTRYPOINT ["ls","-a"]
 ---> Running in c2811d7533db
Removing intermediate container c2811d7533db
 ---> 77eb5c61be48
Successfully built 77eb5c61be48
Successfully tagged entrypoint-test:latest
[root@daigua dockerfile]# docker run 77eb5c61be48.
..
.dockerenv
bin
dev
etc
home
lib
lib64
lost+found
media
mnt
opt
proc

[root@daigua dockerfile]# docker run 77eb5c61be48 -l
total 56
drwxr-xr-x   1 root root 4096 Aug  5 09:49 .
drwxr-xr-x   1 root root 4096 Aug  5 09:49 ..
-rwxr-xr-x   1 root root    0 Aug  5 09:49 .dockerenv
lrwxrwxrwx   1 root root    7 Nov  3  2020 bin -> usr/bin
drwxr-xr-x   5 root root  340 Aug  5 09:49 dev
drwxr-xr-x   1 root root 4096 Aug  5 09:49 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

Docker中许多命令十分相似,需要进行对比学习

实战:Tomcat镜像

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

2.编写docker文件,官方命名Dockerfile

FROM centos
MAINTAINET fan<2143141335@

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

ADD jdk-8u212-linux-x64.tar.gz /usr/local
ADD apache-tomcat-7.0.96.tar.gz /usr/local

RUN yum -y install vim

ENV MYPATH /usr/local
WORKDIR $MYPATH

ENV JAVA_HOME /usr/local/jdk1.8.0_11
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-7.0.96
ENV CATALINA_BASH /usr/local/apache-tomcat-7.0.96
ENV PATH $PATH:JAVA_HOME/bin:$CATALINA_HOME/lib:CATALINA_HOME/bin

EXPOSE 8080

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

3.构建镜像

# docker build -t diytomcat .

4.启动镜像

5.访问测试

6.发布项目

发布自己的镜像

DockerHub

1.地址 注册自己的账号

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

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

[root@daigua tomcat]# docker login

4.登录完毕就可以提交

# push镜像到服务器
[root@daigua tomcat]# docker push 作者名/项目名:版本号

# 增加一个tag
[root@daigua tomcat]# docker tag 容器id 镜像名:版本号

阿里云镜像

1.登录阿里云

2.找到容器镜像服务

3.创建命名空间

4.创建容器镜像

5.浏览阿里云

参考官方

小结

Docker网络

理解Docker网络

测试

在这里插入图片描述

三个网络

# 理解:Docker是如何处理容器网络访问的
#[root@daigua /]# docker run -d -P --name tomcat01 tomcat

# 查看容器的内部网络地址 ip addr 发现容器的时候会得到一个eth0@if27 ip地址 docker分配的
[root@daigua /]# docker exec -it tomcat01 ip addr1: 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
26: eth0@if27: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
       valid_lft forever preferred_lft forever

# 思考:linux能不能ping通容器
[root@daigua ~]# 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.117 ms
# linux可以ping通docker容器内部

原理

1.我们每启动一个docker容器,docker就会给docker分配一个ip,我们只要安装了docker,就会有一个网卡docker01,桥接模式,使用的技术是evth-pair技术

2.在启动一个容器,又多了一个网卡

# 我们发现这个容器带来的网卡,都是一对对的
# evth-pair就是一对虚拟设备接口,他们都是成对出现,一段连着协议,一段彼此相连
# 正因为有了这个特性,evth-pair充当一个桥梁,连接各种虚拟网络设备
# OpenStac,Docker容器之间的连接,OVS的连接,都是使用evth-pair技术

3.我们来测试tomcat01与tomcat02可以ping通

# 结论:容器之间是可以相互ping通的

在这里插入图片描述

结论:tomcat01与tomcat02是公用一个路由器,docker0

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

小结

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

在这里插入图片描述

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

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

–link

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

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

# 如何可以解决

# 通过--link 就可以解决网络连通问题
[root@daigua /]# docker run -d -P --name tomcat03 --link tomcat02 tomcat
cab07f6e304f304903fec612ee9d374e4614106a1f4308705fb68aeaa9ceaabc
[root@daigua /]# 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.131 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=2 ttl=64 time=0.113 ms

# 反向可以连通?
[root@daigua /]# docker exec -it tomcat02 ping tomcat03
ping: tomcat03: Name or service not known

探究inspect

在这里插入图片描述

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

# 查看hosts配置
[root@daigua /]# 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 96c337028f69
172.17.0.4	cab07f6e304f

本质:–link就是在我们的hosts配置中增加了172.17.0.3 tomcat02 96c337028f69

我们现在完Docker已经不建议使用–link

自定义网络!不使用docker01

docker01问题:不支持容器名访问

自定义网络

查看所有的docker网络

[root@daigua /]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
defdae954eb3   bridge    bridge    local
ae688637de80   host      host      local
47713da81ad3   none      null      local

网络模式

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

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  子网
# --gateway 192.168.0.1    路由
[root@daigua /]# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
141421c08645a8b59f621f8a7dd2b3558b480632dd5e6f33984279eb6c9c19f9
[root@daigua /]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
defdae954eb3   bridge    bridge    local
ae688637de80   host      host      local
141421c08645   mynet     bridge    local
47713da81ad3   none      null      local
[root@daigua /]# docker run -d -P --name tomcat-net-01 --net mynet tomcat
5bc4083636dce12a04a1cf9efc121421fca7180202858ac502e6af2e5375fde7
[root@daigua /]# docker run -d -P --name tomcat-net-02 --net mynet tomcat
8c667ce9ecc41c4b60670b2614782a0ab23e7a850a440a4ad4d3be4fdaa96823
[root@daigua /]# docker inspect mynet
[
    {
        "Name": "mynet",
        "Id": "141421c08645a8b59f621f8a7dd2b3558b480632dd5e6f33984279eb6c9c19f9",
        "Created": "2021-08-05T22:26:10.553426817+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": {},
            "Config": [
                {
                    "Subnet": "192.168.0.0/16",
                    "Gateway": "192.168.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Ingress": false,
        "ConfigFrom": {
            "Network": ""
        },
        "ConfigOnly": false,
        "Containers": {
            "5bc4083636dce12a04a1cf9efc121421fca7180202858ac502e6af2e5375fde7": {
                "Name": "tomcat-net-01",
                "EndpointID": "16216f2f81b9dc0cdef30293d75fc819cd69a2325f9553e5f3234d3bcaff1cc8",
                "MacAddress": "02:42:c0:a8:00:02",
                "IPv4Address": "192.168.0.2/16",
                "IPv6Address": ""
            },
            "8c667ce9ecc41c4b60670b2614782a0ab23e7a850a440a4ad4d3be4fdaa96823": {
                "Name": "tomcat-net-02",
                "EndpointID": "e5c0cb3339b8481b8eea67b7e7aa146ad2339b0509c1a7be7f89820f42016f77",
                "MacAddress": "02:42:c0:a8:00:03",
                "IPv4Address": "192.168.0.3/16",
                "IPv6Address": ""
            }
        },
        "Options": {},
        "Labels": {}
    }
]

# 测试ping连接 不适应--link也可以ping通
[root@daigua /]# 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.114 ms

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

好处:

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

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

网络连通

在这里插入图片描述

在这里插入图片描述

# 测试tomcat01 - mynet
# 连通之后就是将tomcat01放到了mynet下
# 一个容器两个ip
[root@daigua /]# docker network connect mynet tomcat01
[root@daigua /]# docker inspect mynet
[
    {
        "Name": "mynet",
        "Id": "141421c08645a8b59f621f8a7dd2b3558b480632dd5e6f33984279eb6c9c19f9",
        "Created": "2021-08-05T22:26:10.553426817+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": {},
            "Config": [
                {
                    "Subnet": "192.168.0.0/16",
                    "Gateway": "192.168.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Ingress": false,
        "ConfigFrom": {
            "Network": ""
        },
        "ConfigOnly": false,
        "Containers": {
            "5bc4083636dce12a04a1cf9efc121421fca7180202858ac502e6af2e5375fde7": {
                "Name": "tomcat-net-01",
                "EndpointID": "16216f2f81b9dc0cdef30293d75fc819cd69a2325f9553e5f3234d3bcaff1cc8",
                "MacAddress": "02:42:c0:a8:00:02",
                "IPv4Address": "192.168.0.2/16",
                "IPv6Address": ""
            },
            "8327e68a432ac973d26d45d172083da20a56770020a81bd8e19bd18deb985644": {
                "Name": "tomcat01",
                "EndpointID": "3f75cdaa21c13b422b7bd46238d06c889e551d585d05aa9e96b1880508c87c87",
                "MacAddress": "02:42:c0:a8:00:04",
                "IPv4Address": "192.168.0.4/16",
                "IPv6Address": ""
            },
            "8c667ce9ecc41c4b60670b2614782a0ab23e7a850a440a4ad4d3be4fdaa96823": {
                "Name": "tomcat-net-02",
                "EndpointID": "e5c0cb3339b8481b8eea67b7e7aa146ad2339b0509c1a7be7f89820f42016f77",
                "MacAddress": "02:42:c0:a8:00:03",
                "IPv4Address": "192.168.0.3/16",
                "IPv6Address": ""
            }
        },
        "Options": {},
        "Labels": {}
    }
]

# 01 连通
[root@daigua /]# docker exec -it tomcat01 ping tomcat-net-01
PING tomcat-net-01 (192.168.0.2) 56(84) bytes of data.
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=1 ttl=64 time=0.094 ms

结论:要是有网络操作别人,就需要使用connect

实战:部署Redis集群

在这里插入图片描述

# 创建一个网卡
[root@daigua /]# docker network create redis --su
bnet 172.38.0.0/16

# 通过脚本创建六个redis配置
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.15${port}
cluster-announce-port 6379
cluster-announce-bus-port 16379
appendonly yes
EOF
done

docker run -p 6375${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/redis.conf; \

docker run -p 6371:6379 -p 16371:16379 --name redis-1 \
-v /mydata/redis/node-1/data:/data \
-v /mydata/redis/node-1/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.11 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

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

# 创建集群
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

SpringBoot微服务打包Docker镜像

1.构建项目

2.打包应用

3.编写dockerfile

4.构建镜像

5.发布运行

以后交付镜像即可

  系统运维 最新文章
配置小型公司网络WLAN基本业务(AC通过三层
如何在交付运维过程中建立风险底线意识,提
快速传输大文件,怎么通过网络传大文件给对
从游戏服务端角度分析移动同步(状态同步)
MySQL使用MyCat实现分库分表
如何用DWDM射频光纤技术实现200公里外的站点
国内顺畅下载k8s.gcr.io的镜像
自动化测试appium
ctfshow ssrf
Linux操作系统学习之实用指令(Centos7/8均
上一篇文章      下一篇文章      查看所有文章
加:2021-08-06 10:14:35  更:2021-08-06 10:15:26 
 
开发: C++知识库 Java知识库 JavaScript Python PHP知识库 人工智能 区块链 大数据 移动开发 嵌入式 开发工具 数据结构与算法 开发测试 游戏开发 网络协议 系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑 笔记本 显卡 显示器 固态硬盘 硬盘 耳机 手机 iphone vivo oppo 小米 华为 单反 装机 图拉丁

360图书馆 购物 三丰科技 阅读网 日历 万年历 2024年11日历 -2024/11/15 6:06:50-

图片自动播放器
↓图片自动播放器↓
TxT小说阅读器
↓语音阅读,小说下载,古典文学↓
一键清除垃圾
↓轻轻一点,清除系统垃圾↓
图片批量下载器
↓批量下载图片,美女图库↓
  网站联系: qq:121756557 email:121756557@qq.com  IT数码