docker学习流程
Docker概述
- Docker为什么会出现?
Docker的历史
Docker能做什么?
安装Docker
Docker的常用命令
练习:nginx
练习:tomcat
练习:ES+kibana
- 部署ES
- 可视化
Docker镜像讲解
容器数据卷
DockerFile
本地测试
curl localhost:3360
网页测试
在挂载的test目录下(也就是在的tomcat/usr/local/apache-tomcat-9.0.22/webapps/test/WEB-INF)新建/WEB-INF/web.xml文件
- 发布自己的镜像
  - 发布到docker hub
  - 发布到阿里云镜像
- 小结
理解Docker网络
- 小结:
—link
自定义网络
网络连通
实战:部署Redis集群

:::info 弱小和无知不是生存的阻碍,傲慢才是 :::

docker学习流程

Docker概述
Docker安装
Docker命令

镜像命令
容器命令
操作命令
…

Docker镜像
容器数据库
DockerFile
Docker网络问题
IDEA整合Docker
Docker Compose
Docker Swarm
Docker jenkins :::info 知道的越多,不知道的越多
再小的帆也能远航 :::

Docker概述

Docker为什么会出现?

一款产品: 开发 — 上线两套环境 ! 应用环境以及应用配置
开发就是运维,就会有一个问题出现 : 我在我的电脑上可以运行!版本更新,导致服务不可用!对于运维来说考验十分大?
环境配置是十分的麻烦,每一个机器都要部署环境(集群Redis\ES\Hadoop…)费时费力
那发布一个项目(jar+Redis\ES\Hadoop\Mysql),项目能不能都带上环境安装打包
传统: 开发jar ,运维配置
现在: 开发打包部署上线,一套流做完!
Docker给以上的问提出了解决方案

Docker 的思想就来自于集装箱!
JRE — 多个应用(端口冲突)
隔离:Docker核心思想! 打包装箱! 每个箱子都是互相隔离的
Docker通过隔离机制可以将liunx服务器的性能利用到极致.

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

Docker的历史

2010年几个搞IT的年轻人,在美国成立了 dotCloud
做一些pass的云计算服务! LXC有关的容器技术
他们将自己的技术(容器化技术)命名为Docker
Docker刚刚诞生的时候,没有
引起行业的注意, dotCloud 活不下去
开源!
开放源代码!
2013年,Docker 开源
Docker越来越多的人发现了Docker的优点!火了 ,自起Docker 每个月都会更新一个版本!
2014年4月9日,Docker1.0发布
Docker 火的原因是十分轻巧
在容器技术出来之前,我们都是使用虚拟机技术!
虚拟机: 在windows中装一个vmware,通过这个软件我们可以虚拟出来一台或者多台电脑! 笨重!
虚拟机也是属于虚拟化技术 ,Docker容器技术,也是一种虚拟化技术!

Docker 是基于Go语言开发的开源项目
官网:https://www.docker.com/
文档地址:https://docs.docker.com/desktop/
仓库地址:https://hub.docker.com/

Docker能做什么?

之前的虚拟机技术:
Docker - 图1
虚拟机技术的缺点:

资源占用十分多
冗余步骤多
启动时间长

容器化技术:

容器化技术不是模拟一个完整的操作系统
比较Docker和虚拟机技术的不同:
● 传统虚拟机,虚拟出一条硬件,运行一个完整的操作系统,然后再这个系统上安装和运行软件
● 容器内的直接运行再在主机的内核,容器时没有自己的内核的,也没有虚拟我们的硬件,所以一轻便
● 每个容器间是互相隔离的,每个容器内都有一个属于自己的文件系统,互不影响
DevOps
更快速的交付和部署
传统: 一堆帮助文档,安装程序
Docker: 打包镜像发布测试,一键运行
更便捷的升级和扩缩容
使用了Docker之后我们部署应用就和搭积木一样!
项目打包为一个镜像,扩展服务器A 服务器B
更简单的系统运维
在容器化之后,我们的开发,测试环境都是高度一致的
更高效的计算资源利用
Docker是内核级别的虚拟化,可以再一个物理机上可以运行很多容器实例!服务器的性能可以被压榨到极致.

安装Docker

Docker的基本组成

镜像(image):
docker镜像好比是一个模板,可以通过这个模板来创建容器服务,tomcat镜像===>run==>tomcat01容器(提供服务器),通过这个镜像可以创建多个容器(最终服务运行或者项目就是在容器中的)
容器(container):
docker利用容器技术,独立运行一个或者一组应用,通过镜像来创建
启动,停止,删除,基本命令!
目前就可以把这个容器理解为一个建议的linux系统
仓库(repository):
仓库就是存放镜像的地方
仓库分为共有仓库和私有仓库
docker Hub (默认是国外的)
阿里云…都有容器服务器(配置镜像加速!)

安装Docker

环境准备

需要会LInux基础
Centos 7
使用shell软件

环境查看

[root@VM-24-6-centos ~]# uname -r
3.10.0-1160.66.1.el7.x86_64

[root@VM-24-6-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.卸载旧的版本
yum remove docker    \
                    docker-client \
                    docker-client-latsest \
                    dockercommon \
                    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 \
    https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

#4.安装docker   docker-ce社区版   -ee企业版
yum install docker-ce docker-ce-cli containerd.io

#5.启动docker
systemctl start docker

#6.使用docker version检查安装是否成功
[root@VM-24-6-centos ~]# docker version
Client: Docker Engine - Community
 Version:           20.10.17
 API version:       1.41
 Go version:        go1.17.11
 Git commit:        100c701
 Built:             Mon Jun  6 23:05:12 2022
 OS/Arch:           linux/amd64
 Context:           default
 Experimental:      true

Server: Docker Engine - Community
 Engine:
  Version:          20.10.17
  API version:      1.41 (minimum version 1.12)
  Go version:       go1.17.11
  Git commit:       a89b842
  Built:            Mon Jun  6 23:03:33 2022
  OS/Arch:          linux/amd64
  Experimental:     false
 containerd:
  Version:          1.6.6
  GitCommit:        10c12954828e7c7c9b6e0ea9b0c02b01407d3ae1
 runc:
  Version:          1.1.2
  GitCommit:        v1.1.2-0-ga916309
 docker-init:
  Version:          0.19.0
  GitCommit:        de40ad0

#7.hello-world
docker run hello-world

#8.查看一下下载的 hello-world 镜像
[root@VM-24-6-centos ~]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED        SIZE
hello-world   latest    feb5d9fea6a5   8 months ago   13.3kB

卸载docker
yum remove docker-ce docker-ce-cli containerd.io
rm -f /var/lib/docker

阿里云镜像加速
配置

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

docker流程图
流程图.jpg

底层原理

docker是怎么工作的?
docker是一个Client-Server结构的系统 , docker的守护运行在主机上,通过socket从客户端访问
dockers server 接收到 docker-client 的指令,就会执行这个命令!
docker为什么比VM快?

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

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

Docker的常用命令

帮助命令

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

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

镜像命令

REPOSITORY    TAG       IMAGE ID       CREATED        SIZE
hello-world   latest    feb5d9fea6a5   8 months ago   13.3kB
centos        latest    5d0da3dc9764   8 months ago   231MB

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

#可选项
  -a,    --all            #列出所有镜像
  -q, --quiiet    #只显示镜像的ID

[root@VM-24-6-centos ~]# docker search mysql
NAME                           DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
mysql                          MySQL is a widely used, open-source relation…   12716     [OK]       
mariadb                        MariaDB Server is a high performing open sou…   4882      [OK]       

#可选项,通过搜索来过滤
--filter=STARS=3000    #搜索出来的镜像就是STARS大于3000的

#下载镜像 docker pull 镜像名[:tag]
[root@VM-24-6-centos ~]# docker pull mysql
Using default tag: latest #如果不写 tag 则默是 latest
latest: Pulling from library/mysql
72a69066d2fe: Pull complete         #分层下载,docker iamge的核心 联合文件系统
93619dbc5b36: Pull complete 
99da31dd6142: Pull complete 
626033c43d70: Pull complete 
37d5d7efb64e: Pull complete 
ac563158d721: Pull complete 
d2ba16033dad: Pull complete 
688ba7d5c01a: Pull complete 
00e060b6d11d: Pull complete 
1c04857f594f: Pull complete 
4d7cfa90e6ea: Pull complete 
e0431212d27d: Pull complete 
Digest: sha256:e9027fe4d91c0153429607251656806cc784e914937271037f7738bd5b8e7709 #签名
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest #真实地址

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

#指定版本下载
[root@VM-24-6-centos ~]# clear
[root@VM-24-6-centos ~]# docker pull mysql:5.7
5.7: Pulling from library/mysql
72a69066d2fe: Already exists 
93619dbc5b36: Already exists 
99da31dd6142: Already exists 
626033c43d70: Already exists 
37d5d7efb64e: Already exists 
ac563158d721: Already exists 
d2ba16033dad: Already exists 
0ceb82207cd7: Pull complete 
37f2405cae96: Pull complete 
e2482e017e53: Pull complete 
70deed891d42: Pull complete 
Digest: sha256:f2ad209efe9c67104167fc609cca6973c8422939491c9345270175a300419f94
Status: Downloaded newer image for mysql:5.7
docker.io/library/mysql:5.7

[root@VM-24-6-centos ~]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED        SIZE
mysql         5.7       c20987f18b13   5 months ago   448MB
mysql         latest    3218b38490ce   5 months ago   516MB
hello-world   latest    feb5d9fea6a5   8 months ago   13.3kB
centos        latest    5d0da3dc9764   8 months ago   231MB
[root@VM-24-6-centos ~]# docker rmi -f c20987f18b13
Untagged: mysql:5.7
Untagged: mysql@sha256:f2ad209efe9c67104167fc609cca6973c8422939491c9345270175a300419f94
Deleted: sha256:c20987f18b130f9d144c9828df630417e2a9523148930dc3963e9d0dab302a76
Deleted: sha256:6567396b065ee734fb2dbb80c8923324a778426dfd01969f091f1ab2d52c7989
Deleted: sha256:0910f12649d514b471f1583a16f672ab67e3d29d9833a15dc2df50dd5536e40f
Deleted: sha256:6682af2fb40555c448b84711c7302d0f86fc716bbe9c7dc7dbd739ef9d757150
Deleted: sha256:5c062c3ac20f576d24454e74781511a5f96739f289edaadf2de934d06e910b92

 #删除全部镜像
[root@VM-24-6-centos ~]# docker rmi -f $(docker images -qa)
Untagged: mysql:latest
Untagged: mysql@sha256:e9027fe4d91c0153429607251656806cc784e914937271037f7738bd5b8e7709
Deleted: sha256:3218b38490cec8d31976a40b92e09d61377359eab878db49f025e5d464367f3b
Deleted: sha256:aa81ca46575069829fe1b3c654d9e8feb43b4373932159fe2cad1ac13524a2f5
Deleted: sha256:0558823b9fbe967ea6d7174999be3cc9250b3423036370dc1a6888168cbd224d
Deleted: sha256:a46013db1d31231a0e1bac7eeda5ad4786dea0b1773927b45f92ea352a6d7ff9
Deleted: sha256:af161a47bb22852e9e3caf39f1dcd590b64bb8fae54315f9c2e7dc35b025e4e3
Deleted: sha256:feff1495e6982a7e91edc59b96ea74fd80e03674d92c7ec8a502b417268822ff
Deleted: sha256:8805862fcb6ef9deb32d4218e9e6377f35fb351a8be7abafdf1da358b2b287ba
Deleted: sha256:872d2f24c4c64a6795e86958fde075a273c35c82815f0a5025cce41edfef50c7
Deleted: sha256:6fdb3143b79e1be7181d32748dd9d4a845056dfe16ee4c827410e0edef5ad3da
Deleted: sha256:b0527c827c82a8f8f37f706fcb86c420819bb7d707a8de7b664b9ca491c96838
Deleted: sha256:75147f61f29796d6528486d8b1f9fb5d122709ea35620f8ffcea0e0ad2ab0cd0
Deleted: sha256:2938c71ddf01643685879bf182b626f0a53b1356138ef73c40496182e84548aa
Deleted: sha256:ad6b69b549193f81b039a1d478bc896f6e460c77c1849a4374ab95f9a3d2cea2
Untagged: hello-world:latest
Untagged: hello-world@sha256:2498fce14358aa50ead0cc6c19990fc6ff866ce72aeb5546e1d59caac3d0d60f
Deleted: sha256:feb5d9fea6a5e9606aa995e879d862b825965ba48de054caab5ef356dc6b3412
Untagged: centos:latest
Untagged: centos@sha256:a27fd8080b517143cbbbab9dfb7c8571c40d67d534bbdee55bd6c473f432b177
Deleted: sha256:5d0da3dc976460b72c77d94c8a1ad043720b0416bfc16c52c45d4847e53fadb6
Deleted: sha256:74ddd0ec08fa43d09f32636ba91a0a3053b02cb4627c35051aff89f853606b59


docker rmi -f 容器ID #删除指定容器
docker rmi -f 容器ID 容器ID 容器ID 容器ID #删除多个容器
docker rmi -f $(docker imgaes -aq)    #删除全部的容器

docker load 路径
--input , -i : 指定导入的文件，代替 STDIN。
--quiet , -q : 精简输出信息。

docker save 路径 IMAGE 镜像id
-o :输出到的文件。

容器命令

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

docker run [可选参数]    image

#参数说明
--name="Name"            容器名字 tomcat01        tomcat02 ,用来区分容器
-d                                后台方式运行
-it                                使用交互方式运行,进入容器查看内容
-p                                指定容器的端口 -p 8080:8080
    -p                      IP: 主机端口:容器端口
    -p                        主机端口:容器端口 (常用)
    -p                        容器端口
    容器端口
-p                                随机指定端口

#测试,并进入容器
[root@VM-24-6-centos ~]# docker run -it centos /bin/bash
[root@9e1ec2882736 /]# ls 
bin  etc   lib      lost+found  mnt  proc  run   srv  tmp  var
dev  home  lib64  media       opt  root  sbin  sys  usr
[root@9e1ec2882736 /]# 

#从容器中退回到主机
[root@9e1ec2882736 /]# exit
exit
[root@VM-24-6-centos ~]#

-a #累出当前正在运行的容器+历史运行过的容器
-n=? #显示最近创建的容器
-q   #只显示容器的编号
[root@VM-24-6-centos ~]# docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
[root@VM-24-6-centos ~]# docker ps -a
CONTAINER ID   IMAGE          COMMAND       CREATED              STATUS                          PORTS     NAMES
9e1ec2882736   centos         "/bin/bash"   About a minute ago   Exited (0) About a minute ago             lucid_keller
8c8bfe679499   feb5d9fea6a5   "/hello"      53 minutes ago       Exited (0) 53 minutes ago                 vigilant_jang
[root@VM-24-6-centos ~]# docker ps -q
[root@VM-24-6-centos ~]# docker ps -qa
9e1ec2882736
8c8bfe679499
[root@VM-24-6-centos ~]#

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

docker rm 容器id                                #删除单个容器,不能删除正在运行的容器,除非使用rm -rf
docker rm -f $(docker ps -aq)        #删除所有容器
docker rm -a -q|xargs docker rm #删除所有容器

docker start 容器ID            #启动容器
docker restart 容器ID        #重启容器
docker kill   容器ID        #杀死容器
docker stop   容器ID        #暂停容器

其他常用命令

#命令  docker run -d 镜像名
[root@VM-24-6-centos ~]# docker run -d centos
dd2000d9a934df7d95ba1ebc3afccbf6889e4510494b2bf8ec4c81b81ce40526

#问题:docker ps 发现centos停止了

#坑:docker 容器后台使用的时候,容器内必须有一个前台进程.如果没前台进程docker就会自动停止该容器
#nginx,容器启动后,发现自己没有提供服务,就会立即停止

docker logs -ft --tail [条数]    [容器ID]
-tf                #显示日志
--tail number #要显示的日志条数

top命令
docker top 容器ID

查看镜像元数据
docker inspect
[root@VM-24-6-centos ~]# docker inspect d7ebeb0673fa
[
    {
        "Id": "d7ebeb0673fa21c3b732d9c8ad0d63e46efa6fb042905bf2668b021a671a336c",
        "Created": "2022-06-13T05:44:46.949708415Z",
        "Path": "/bin/bash",
        "Args": [],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 5948,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2022-06-13T05:44:47.224749943Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:5d0da3dc976460b72c77d94c8a1ad043720b0416bfc16c52c45d4847e53fadb6",
        "ResolvConfPath": "/var/lib/docker/containers/d7ebeb0673fa21c3b732d9c8ad0d63e46efa6fb042905bf2668b021a671a336c/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/d7ebeb0673fa21c3b732d9c8ad0d63e46efa6fb042905bf2668b021a671a336c/hostname",
        "HostsPath": "/var/lib/docker/containers/d7ebeb0673fa21c3b732d9c8ad0d63e46efa6fb042905bf2668b021a671a336c/hosts",
        "LogPath": "/var/lib/docker/containers/d7ebeb0673fa21c3b732d9c8ad0d63e46efa6fb042905bf2668b021a671a336c/d7ebeb0673fa21c3b732d9c8ad0d63e46efa6fb042905bf2668b021a671a336c-json.log",
        "Name": "/musing_meitner",
        "RestartCount": 0,
        "Driver": "overlay2",
        "Platform": "linux",
        "MountLabel": "",
        "ProcessLabel": "",
        "AppArmorProfile": "",
        "ExecIDs": null,
        "HostConfig": {
            "Binds": null,
            "ContainerIDFile": "",
            "LogConfig": {
                "Type": "json-file",
                "Config": {}
            },
            "NetworkMode": "default",
            "PortBindings": {},
            "RestartPolicy": {
                "Name": "no",
                "MaximumRetryCount": 0
            },
            "AutoRemove": false,
            "VolumeDriver": "",
            "VolumesFrom": null,
            "CapAdd": null,
            "CapDrop": null,
            "CgroupnsMode": "host",
            "Dns": [],
            "DnsOptions": [],
            "DnsSearch": [],
            "ExtraHosts": null,
            "GroupAdd": null,
            "IpcMode": "private",
            "Cgroup": "",
            "Links": null,
            "OomScoreAdj": 0,
            "PidMode": "",
            "Privileged": false,
            "PublishAllPorts": false,
            "ReadonlyRootfs": false,
            "SecurityOpt": null,
            "UTSMode": "",
            "UsernsMode": "",
            "ShmSize": 67108864,
            "Runtime": "runc",
            "ConsoleSize": [
                0,
                0
            ],
            "Isolation": "",
            "CpuShares": 0,
            "Memory": 0,
            "NanoCpus": 0,
            "CgroupParent": "",
            "BlkioWeight": 0,
            "BlkioWeightDevice": [],
            "BlkioDeviceReadBps": null,
            "BlkioDeviceWriteBps": null,
            "BlkioDeviceReadIOps": null,
            "BlkioDeviceWriteIOps": null,
            "CpuPeriod": 0,
            "CpuQuota": 0,
            "CpuRealtimePeriod": 0,
            "CpuRealtimeRuntime": 0,
            "CpusetCpus": "",
            "CpusetMems": "",
            "Devices": [],
            "DeviceCgroupRules": null,
            "DeviceRequests": null,
            "KernelMemory": 0,
            "KernelMemoryTCP": 0,
            "MemoryReservation": 0,
            "MemorySwap": 0,
            "MemorySwappiness": null,
            "OomKillDisable": false,
            "PidsLimit": null,
            "Ulimits": null,
            "CpuCount": 0,
            "CpuPercent": 0,
            "IOMaximumIOps": 0,
            "IOMaximumBandwidth": 0,
            "MaskedPaths": [
                "/proc/asound",
                "/proc/acpi",
                "/proc/kcore",
                "/proc/keys",
                "/proc/latency_stats",
                "/proc/timer_list",
                "/proc/timer_stats",
                "/proc/sched_debug",
                "/proc/scsi",
                "/sys/firmware"
            ],
            "ReadonlyPaths": [
                "/proc/bus",
                "/proc/fs",
                "/proc/irq",
                "/proc/sys",
                "/proc/sysrq-trigger"
            ]
        },
        "GraphDriver": {
            "Data": {
                "LowerDir": "/var/lib/docker/overlay2/c10d73b4e28a79efd479facf0e40f42915f0ca4d5aefe8d33765205eaefbd367-init/diff:/var/lib/docker/overlay2/65fec22ab97113dcdabce8282dd2ec302867ef45c25adc586deaa731d4ed3087/diff",
                "MergedDir": "/var/lib/docker/overlay2/c10d73b4e28a79efd479facf0e40f42915f0ca4d5aefe8d33765205eaefbd367/merged",
                "UpperDir": "/var/lib/docker/overlay2/c10d73b4e28a79efd479facf0e40f42915f0ca4d5aefe8d33765205eaefbd367/diff",
                "WorkDir": "/var/lib/docker/overlay2/c10d73b4e28a79efd479facf0e40f42915f0ca4d5aefe8d33765205eaefbd367/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [],
        "Config": {
            "Hostname": "d7ebeb0673fa",
            "Domainname": "",
            "User": "",
            "AttachStdin": true,
            "AttachStdout": true,
            "AttachStderr": true,
            "Tty": true,
            "OpenStdin": true,
            "StdinOnce": true,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
            ],
            "Cmd": [
                "/bin/bash"
            ],
            "Image": "centos",
            "Volumes": null,
            "WorkingDir": "",
            "Entrypoint": null,
            "OnBuild": null,
            "Labels": {
                "org.label-schema.build-date": "20210915",
                "org.label-schema.license": "GPLv2",
                "org.label-schema.name": "CentOS Base Image",
                "org.label-schema.schema-version": "1.0",
                "org.label-schema.vendor": "CentOS"
            }
        },
        "NetworkSettings": {
            "Bridge": "",
            "SandboxID": "bad963131fa0cca817beef580c2f67696c1f6cf52b6c2588eec0a68355bc964f",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {},
            "SandboxKey": "/var/run/docker/netns/bad963131fa0",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "8aa1490a07700cbb1f3e687b797a2b2c531f826c7a8e89099bcf0189f5d6324f",
            "Gateway": "172.17.0.1",
            "GlobalIPv6Address": "",
            "GlobalIPv6PrefixLen": 0,
            "IPAddress": "172.17.0.2",
            "IPPrefixLen": 16,
            "IPv6Gateway": "",
            "MacAddress": "02:42:ac:11:00:02",
            "Networks": {
                "bridge": {
                    "IPAMConfig": null,
                    "Links": null,
                    "Aliases": null,
                    "NetworkID": "9df546b56e81d2749891fa37b51db086a1126e3a2744b19e9188abd78f537e0d",
                    "EndpointID": "8aa1490a07700cbb1f3e687b797a2b2c531f826c7a8e89099bcf0189f5d6324f",
                    "Gateway": "172.17.0.1",
                    "IPAddress": "172.17.0.2",
                    "IPPrefixLen": 16,
                    "IPv6Gateway": "",
                    "GlobalIPv6Address": "",
                    "GlobalIPv6PrefixLen": 0,
                    "MacAddress": "02:42:ac:11:00:02",
                    "DriverOpts": null
                }
            }
        }
    }
]

docker inspect 镜像ID
[root@VM-24-6-centos ~]# docker inspect d7ebeb0673fa
[
    {
        "Id": "d7ebeb0673fa21c3b732d9c8ad0d63e46efa6fb042905bf2668b021a671a336c",
        "Created": "2022-06-13T05:44:46.949708415Z",
        "Path": "/bin/bash",
        "Args": [],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 5948,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2022-06-13T05:44:47.224749943Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:5d0da3dc976460b72c77d94c8a1ad043720b0416bfc16c52c45d4847e53fadb6",
        "ResolvConfPath": "/var/lib/docker/containers/d7ebeb0673fa21c3b732d9c8ad0d63e46efa6fb042905bf2668b021a671a336c/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/d7ebeb0673fa21c3b732d9c8ad0d63e46efa6fb042905bf2668b021a671a336c/hostname",
        "HostsPath": "/var/lib/docker/containers/d7ebeb0673fa21c3b732d9c8ad0d63e46efa6fb042905bf2668b021a671a336c/hosts",
        "LogPath": "/var/lib/docker/containers/d7ebeb0673fa21c3b732d9c8ad0d63e46efa6fb042905bf2668b021a671a336c/d7ebeb0673fa21c3b732d9c8ad0d63e46efa6fb042905bf2668b021a671a336c-json.log",
        "Name": "/musing_meitner",
        "RestartCount": 0,
        "Driver": "overlay2",
        "Platform": "linux",
        "MountLabel": "",
        "ProcessLabel": "",
        "AppArmorProfile": "",
        "ExecIDs": null,
        "HostConfig": {
            "Binds": null,
            "ContainerIDFile": "",
            "LogConfig": {
                "Type": "json-file",
                "Config": {}
            },
            "NetworkMode": "default",
            "PortBindings": {},
            "RestartPolicy": {
                "Name": "no",
                "MaximumRetryCount": 0
            },
            "AutoRemove": false,
            "VolumeDriver": "",
            "VolumesFrom": null,
            "CapAdd": null,
            "CapDrop": null,
            "CgroupnsMode": "host",
            "Dns": [],
            "DnsOptions": [],
            "DnsSearch": [],
            "ExtraHosts": null,
            "GroupAdd": null,
            "IpcMode": "private",
            "Cgroup": "",
            "Links": null,
            "OomScoreAdj": 0,
            "PidMode": "",
            "Privileged": false,
            "PublishAllPorts": false,
            "ReadonlyRootfs": false,
            "SecurityOpt": null,
            "UTSMode": "",
            "UsernsMode": "",
            "ShmSize": 67108864,
            "Runtime": "runc",
            "ConsoleSize": [
                0,
                0
            ],
            "Isolation": "",
            "CpuShares": 0,
            "Memory": 0,
            "NanoCpus": 0,
            "CgroupParent": "",
            "BlkioWeight": 0,
            "BlkioWeightDevice": [],
            "BlkioDeviceReadBps": null,
            "BlkioDeviceWriteBps": null,
            "BlkioDeviceReadIOps": null,
            "BlkioDeviceWriteIOps": null,
            "CpuPeriod": 0,
            "CpuQuota": 0,
            "CpuRealtimePeriod": 0,
            "CpuRealtimeRuntime": 0,
            "CpusetCpus": "",
            "CpusetMems": "",
            "Devices": [],
            "DeviceCgroupRules": null,
            "DeviceRequests": null,
            "KernelMemory": 0,
            "KernelMemoryTCP": 0,
            "MemoryReservation": 0,
            "MemorySwap": 0,
            "MemorySwappiness": null,
            "OomKillDisable": false,
            "PidsLimit": null,
            "Ulimits": null,
            "CpuCount": 0,
            "CpuPercent": 0,
            "IOMaximumIOps": 0,
            "IOMaximumBandwidth": 0,
            "MaskedPaths": [
                "/proc/asound",
                "/proc/acpi",
                "/proc/kcore",
                "/proc/keys",
                "/proc/latency_stats",
                "/proc/timer_list",
                "/proc/timer_stats",
                "/proc/sched_debug",
                "/proc/scsi",
                "/sys/firmware"
            ],
            "ReadonlyPaths": [
                "/proc/bus",
                "/proc/fs",
                "/proc/irq",
                "/proc/sys",
                "/proc/sysrq-trigger"
            ]
        },
        "GraphDriver": {
            "Data": {
                "LowerDir": "/var/lib/docker/overlay2/c10d73b4e28a79efd479facf0e40f42915f0ca4d5aefe8d33765205eaefbd367-init/diff:/var/lib/docker/overlay2/65fec22ab97113dcdabce8282dd2ec302867ef45c25adc586deaa731d4ed3087/diff",
                "MergedDir": "/var/lib/docker/overlay2/c10d73b4e28a79efd479facf0e40f42915f0ca4d5aefe8d33765205eaefbd367/merged",
                "UpperDir": "/var/lib/docker/overlay2/c10d73b4e28a79efd479facf0e40f42915f0ca4d5aefe8d33765205eaefbd367/diff",
                "WorkDir": "/var/lib/docker/overlay2/c10d73b4e28a79efd479facf0e40f42915f0ca4d5aefe8d33765205eaefbd367/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [],
        "Config": {
            "Hostname": "d7ebeb0673fa",
            "Domainname": "",
            "User": "",
            "AttachStdin": true,
            "AttachStdout": true,
            "AttachStderr": true,
            "Tty": true,
            "OpenStdin": true,
            "StdinOnce": true,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
            ],
            "Cmd": [
                "/bin/bash"
            ],
            "Image": "centos",
            "Volumes": null,
            "WorkingDir": "",
            "Entrypoint": null,
            "OnBuild": null,
            "Labels": {
                "org.label-schema.build-date": "20210915",
                "org.label-schema.license": "GPLv2",
                "org.label-schema.name": "CentOS Base Image",
                "org.label-schema.schema-version": "1.0",
                "org.label-schema.vendor": "CentOS"
            }
        },
        "NetworkSettings": {
            "Bridge": "",
            "SandboxID": "bad963131fa0cca817beef580c2f67696c1f6cf52b6c2588eec0a68355bc964f",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {},
            "SandboxKey": "/var/run/docker/netns/bad963131fa0",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "8aa1490a07700cbb1f3e687b797a2b2c531f826c7a8e89099bcf0189f5d6324f",
            "Gateway": "172.17.0.1",
            "GlobalIPv6Address": "",
            "GlobalIPv6PrefixLen": 0,
            "IPAddress": "172.17.0.2",
            "IPPrefixLen": 16,
            "IPv6Gateway": "",
            "MacAddress": "02:42:ac:11:00:02",
            "Networks": {
                "bridge": {
                    "IPAMConfig": null,
                    "Links": null,
                    "Aliases": null,
                    "NetworkID": "9df546b56e81d2749891fa37b51db086a1126e3a2744b19e9188abd78f537e0d",
                    "EndpointID": "8aa1490a07700cbb1f3e687b797a2b2c531f826c7a8e89099bcf0189f5d6324f",
                    "Gateway": "172.17.0.1",
                    "IPAddress": "172.17.0.2",
                    "IPPrefixLen": 16,
                    "IPv6Gateway": "",
                    "GlobalIPv6Address": "",
                    "GlobalIPv6PrefixLen": 0,
                    "MacAddress": "02:42:ac:11:00:02",
                    "DriverOpts": null
                }
            }
        }
    }
]

#我通常容器都是使用后台方式运行的,需要进入容器,修改一些配置

#命令
docker exec -it 容器ID bash/shell
#测试
[root@VM-24-6-centos ~]# docker ps
CONTAINER ID   IMAGE     COMMAND       CREATED         STATUS         PORTS     NAMES
d7ebeb0673fa   centos    "/bin/bash"   3 minutes ago   Up 3 minutes             musing_meitner
[root@VM-24-6-centos ~]# docker exec -it d7ebeb0673fa bash
[root@d7ebeb0673fa /]# 

#方式二:
docker attach 容器ID
#测试
[root@VM-24-6-centos ~]# docker ps 
CONTAINER ID   IMAGE     COMMAND       CREATED         STATUS         PORTS     NAMES
d7ebeb0673fa   centos    "/bin/bash"   4 minutes ago   Up 4 minutes             musing_meitner
[root@VM-24-6-centos ~]# docker attach d7ebeb0673fa
[root@d7ebeb0673fa /]# #正在执行的当前代码

#docker exec #进入容器后开启一个新的终端,可以在里面擦欧总
#docker attach #进入容器正在执行的终端,不会启动新的进程

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

#进入docker容器内
[root@VM-24-6-centos ~]# docker attach d7ebeb0673fa
[root@d7ebeb0673fa /]# cd /home 
[root@d7ebeb0673fa home]# ls

#在容器内新建文件
[root@d7ebeb0673fa home]# touch 1.java
[root@d7ebeb0673fa home]# exit
exit
[root@VM-24-6-centos ~]# docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
[root@VM-24-6-centos ~]# docker ps -a
CONTAINER ID   IMAGE          COMMAND       CREATED         STATUS                      PORTS     NAMES
d7ebeb0673fa   centos         "/bin/bash"   8 minutes ago   Exited (0) 11 seconds ago             musing_meitner
dd2000d9a934   centos         "/bin/bash"   14 hours ago    Exited (0) 14 hours ago               practical_ganguly
9e1ec2882736   centos         "/bin/bash"   17 hours ago    Exited (0) 17 hours ago               lucid_keller
8c8bfe679499   feb5d9fea6a5   "/hello"      18 hours ago    Exited (0) 18 hours ago               vigilant_jang

#将文件拷贝出来到主机
[root@VM-24-6-centos ~]# docker cp d7ebeb0673fa:/home/1.java /home
[root@VM-24-6-centos ~]# cd /home
[root@VM-24-6-centos home]# ls
1.java  lighthouse  n9e  shelltest

#拷贝是一个手动过程,未来我们使用 -V 卷技术 ,可以实现自动同步 /home /home

小结

练习:nginx

docker 安装 nginx

#1. 搜索镜像 search 建议去docker 搜索,可以看到帮助文档
#2. 下载  pull
#3. 运行测试

root@VM-24-6-centos home]# docker images
REPOSITORY   TAG       IMAGE ID       CREATED        SIZE
nginx        latest    605c77e624dd   5 months ago   141MB
centos       latest    5d0da3dc9764   9 months ago   231MB

# -d 后台运行
# --name 给容器命名
# -p宿主机端口:容器内部端口

[root@VM-24-6-centos home]# docker run -d --name nginx01 -p 6800:80 nginx
c0fad6cdda5ddf02f7163ca26bb528248cff391ad00c2bcd691945a45e350e58
[root@VM-24-6-centos home]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS                                   NAMES
c0fad6cdda5d   nginx     "/docker-entrypoint.…"   5 seconds ago   Up 4 seconds   0.0.0.0:6800->80/tcp, :::6800->80/tcp   nginx01
[root@VM-24-6-centos home]# curl localhost:6800
<!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>

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

端口暴露的概念:

思考问题:每次改动nginx文件都需要进入容器内部,是否可以在容器外部提供一个映射路径,映射到容器,外面修改容器内部就能自动修改? -V 数据集技术

练习:tomcat

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

#下载启动
docker pull tomcat

#启动
docker run -d -p 3355:8080 --name tomcat01 tomcat:9.0

#网页测试访问无问题

#进入容器
docker exec -it tomcat01 /bin/bash 

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

练习:ES+kibana

部署ES

#ES暴露的端口很多
#ES十分占用内存
#ES的数据一般需要放置到安全目录!挂载
#  -net somenetwork 是网络配置

# 启动 elasticearch
docker run -d --name elasticearch -p 9300:9300 -e "discovery.trpe=single-node" elasticearch:7.6.2
{
  "name" : "a88e7f5f09c2",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "pnp4xCPKRlmfNNCWgrEa3w",
  "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"
}

#es 十分占用内存   一般会占用1.5G左右    docker stas查看占用
#修改环境配置启动
docker run -d --name elasticsearch02 -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.6.2
#将 elasticsearch 的内存占用限制在64m到512m之间

#再次启动
curl: (6) Could not resolve host: lcoalhost; Unknown error
[root@VM-24-6-centos ~]# curl localhost:9200
{
  "name" : "d023a99e9e7f",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "JVQAoBN1TdyIDTZzpw5nOQ",
  "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"
}

可视化

portainer(现在用)

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

Rancher(CI/CD再用)

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

Docker镜像讲解

镜像是什么?

镜像是一种轻量级,可执行的独立软件包,用来打包软件运行环境和基于运行环境开发的软件,它包含运行某个软件所需的所有内容,包括代码.运行时库,环境变量和配置文件.
所有的应用,直接打包docker,都可以直接跑起来
如何得到镜像:

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

docker镜像加载原理

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

:::info docker 镜像加载原理 ::: docker的镜像实习生由一层层的文件系统组成,这种层级的文件系统unionfs

bootfs主要包括bootloader和kernel,bootloader主要是引导加载kernel,linux刚启动时会加载bootfs文件系统,在Docker镜像的最底层是bootfs,这一层与我们典型的linux/unix系统是一样的,包含boot加载器和内核.当boot加载完成之后整个内核都在内存中了,此时内存的使用权已由bootfs转交给内核,此时系统也会卸载bootfs
rootfs在bootfs纸上.包含的是典型linux中的/dev ,/proc /bin /etc等标准目录和文件.rootfs就是各种不同操作系统的发行版.如ubuntu,centos等

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

分层理解

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

[root@VM-24-6-centos ~]# docker pull redis
Using default tag: latest
latest: Pulling from library/redis
a2abf6c4d29d: Pull complete 
c7a4e4382001: Pull complete 
4044b9ba67c9: Pull complete 
c8388a79482f: Pull complete 
413c8bb60be2: Pull complete 
1abfd3011519: Pull complete 
Digest: sha256:db485f2e245b5b3329fdc7eff4eb00f913e09d8feb9ca720788059fdc2ed8339
Status: Downloaded newer image for redis:latest
docker.io/library/redis:latest

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

[root@VM-24-6-centos ~]# docker image inspect redis:latest 
[
    {
        "Id": "sha256:7614ae9453d1d87e740a2056257a6de7135c84037c367e1fffa92ae922784631",
        "RepoTags": [
            "redis:latest"
        ],
        "RepoDigests": [
            "redis@sha256:db485f2e245b5b3329fdc7eff4eb00f913e09d8feb9ca720788059fdc2ed8339"
        ],
        "Parent": "",
        "Comment": "",
        "Created": "2021-12-21T12:42:49.755107412Z",
        "Container": "13d25f53410417c5220c8dfe8bd49f06abdbcd69faa62a9b877de02464bb04a3",
        "ContainerConfig": {
            "Hostname": "13d25f534104",
            "Domainname": "",
            "User": "",
            "AttachStdin": false,
            "AttachStdout": false,
            "AttachStderr": false,
            "ExposedPorts": {
                "6379/tcp": {}
            },
            "Tty": false,
            "OpenStdin": false,
            "StdinOnce": false,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
                "GOSU_VERSION=1.12",
                "REDIS_VERSION=6.2.6",
                "REDIS_DOWNLOAD_URL=http://download.redis.io/releases/redis-6.2.6.tar.gz",
                "REDIS_DOWNLOAD_SHA=5b2b8b7a50111ef395bf1c1d5be11e6e167ac018125055daa8b5c2317ae131ab"
            ],
            "Cmd": [
                "/bin/sh",
                "-c",
                "#(nop) ",
                "CMD [\"redis-server\"]"
            ],
            "Image": "sha256:e093f59d716c95cfce82c676f099b960cc700432ab531388fcedf79932fc81ec",
            "Volumes": {
                "/data": {}
            },
            "WorkingDir": "/data",
            "Entrypoint": [
                "docker-entrypoint.sh"
            ],
            "OnBuild": null,
            "Labels": {}
        },
        "DockerVersion": "20.10.7",
        "Author": "",
        "Config": {
            "Hostname": "",
            "Domainname": "",
            "User": "",
            "AttachStdin": false,
            "AttachStdout": false,
            "AttachStderr": false,
            "ExposedPorts": {
                "6379/tcp": {}
            },
            "Tty": false,
            "OpenStdin": false,
            "StdinOnce": false,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
                "GOSU_VERSION=1.12",
                "REDIS_VERSION=6.2.6",
                "REDIS_DOWNLOAD_URL=http://download.redis.io/releases/redis-6.2.6.tar.gz",
                "REDIS_DOWNLOAD_SHA=5b2b8b7a50111ef395bf1c1d5be11e6e167ac018125055daa8b5c2317ae131ab"
            ],
            "Cmd": [
                "redis-server"
            ],
            "Image": "sha256:e093f59d716c95cfce82c676f099b960cc700432ab531388fcedf79932fc81ec",
            "Volumes": {
                "/data": {}
            },
            "WorkingDir": "/data",
            "Entrypoint": [
                "docker-entrypoint.sh"
            ],
            "OnBuild": null,
            "Labels": null
        },
        "Architecture": "amd64",
        "Os": "linux",
        "Size": 112691373,
        "VirtualSize": 112691373,
        "GraphDriver": {
            "Data": {
                "LowerDir": "/var/lib/docker/overlay2/01f3c24aeb80ce73271553f0bf7bd0b69fff52d069cdf024c31b46924b70615f/diff:/var/lib/docker/overlay2/a2c162fdfd2afff26f5f656b99e623ae0d72072b1750704de37dc4019439c647/diff:/var/lib/docker/overlay2/69ef450d372a6ae02b771d69778f34ece2f0629e7a62fc0ff9efc25590f95ead/diff:/var/lib/docker/overlay2/01643867d2726231ea2f89ce545a5d2445e7936ba7666c0e4c0744f6955aca19/diff:/var/lib/docker/overlay2/b5f21f14640258758b545405487af328740e7844a833b6616d6bbb790367042c/diff",
                "MergedDir": "/var/lib/docker/overlay2/69c9438cdda27434484fdfeee04fcde56ed0323c0ad2eec81df20acb59a9196a/merged",
                "UpperDir": "/var/lib/docker/overlay2/69c9438cdda27434484fdfeee04fcde56ed0323c0ad2eec81df20acb59a9196a/diff",
                "WorkDir": "/var/lib/docker/overlay2/69c9438cdda27434484fdfeee04fcde56ed0323c0ad2eec81df20acb59a9196a/work"
            },
            "Name": "overlay2"
        },
        "RootFS": {
            "Type": "layers",
            "Layers": [
                "sha256:2edcec3590a4ec7f40cf0743c15d78fb39d8326bc029073b41ef9727da6c851f",
                "sha256:9b24afeb7c2f21e50a686ead025823cd2c6e9730c013ca77ad5f115c079b57cb",
                "sha256:4b8e2801e0f956a4220c32e2c8b0a590e6f9bd2420ec65453685246b82766ea1",
                "sha256:529cdb636f61e95ab91a62a51526a84fd7314d6aab0d414040796150b4522372",
                "sha256:9975392591f2777d6bf4d9919ad1b2c9afa12f9a9b4d260f45025ec3cc9b18ed",
                "sha256:8e5669d8329116b8444b9bbb1663dda568ede12d3dbcce950199b582f6e94952"
            ]
        },
        "Metadata": {
            "LastTagTime": "0001-01-01T00:00:00Z"
        }
    }
]

理解:
所有的docker镜像都起始于以恶基础镜像层,当进行修改或增加新的内容时,就会在当前镜像址上,创建新的镜像层.
举一个简单的例子,假如基于ubuntu linux 16.04 创建的一个新的镜像,这是新镜像的第一层;如果在该镜像中添加python包就会在基础镜像址上创建第二个镜像层;如果继续添加一个安全补丁,就会创建第三个镜像层.
该镜像当前已经包含三个镜像层,如下图所示 1 (2).jpg
在添加额外的镜像层的同时,镜像始终保持时当前所有镜像的组合,理解这一点非常重要.下图中举了一个简单的例子,每个镜像层包括三个文件,而镜像包含了来自两个镜像层的六个文件

下图中展示了一个稍微复杂的三层镜像,在外部看来只有六个文件,这是英文最上层的文件7时文件5的一个更新版本

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

:::info 特点! ::: Docker镜像都是只读的!!
当容器启动时,一个新的可写层(镜像层)被加载到镜像的顶部!
这一层就是镜像层,容器之下的就叫镜像层!!!
Docker - 图15

commit镜像

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

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

实战:

#启动一个默认的tomcat
#启动之后发现tomcat没有 webapps应用 ,官方的镜像默认webapps下面文件
#自己拷贝进去了基本的文件
#将我们操作过的容器通过commit提交为一个镜像 
[root@VM-24-6-centos ~]# docker images
REPOSITORY            TAG       IMAGE ID       CREATED          SIZE
tomcat02.1.0          latest    f9590528b8f3   14 seconds ago   684MB
tomcat                latest    fb5657adc892   5 months ago     680MB
redis                 latest    7614ae9453d1   5 months ago     113MB
portainer/portainer   latest    580c0e4e98b0   15 months ago    79.1MB
elasticsearch         7.6.2     f29a1ee41030   2 years ago      791MB
#tomcat02.1.0就是我们操作并提交的镜像

学习方式:理解概念,一定要实践,最后实践和理论结合

容器数据卷

什么是容器数据卷?

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

总结: 容器的持久化和同步操作容器之间的数据也可以共享

使用数据卷

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

#docker run -it -v 主机目录:容器目录 
[root@VM-24-6-centos ~]# docker run -it -v /home/ceshi:/home centos bash

#退出容器后  docker inspect 容器ID 查看是否挂载成功

测试文件的同步
再次测试

停止容器
宿主机上修改文件
再次启动容器
容器内数据依旧同步

实战:安装Mysql

思考:Mysql的数据持久化的问题

#    获取镜像

docker pull mysql:5.7

#运行容器,需要做数据挂载!  #安装启动mysql .需要配置密码
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-连接到服务器的3310 --- 3310 和容器内的3306映射,这个时候我们就可以链接上了

#在本例测试创建一个数据库,查看一些我们映射的路径是否OK
#假设我们将容器删除
#发现我们挂载到本地的数据卷并没有丢失,这就实现了容器数据持久化的功能!

具名挂载和匿名挂载

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

#查看所偶的volume情况 
docker volue ls

[root@VM-24-6-centos ~]# docker volume ls
DRIVER    VOLUME NAME
local     30c952ecfb4d0e550a1fea42b63ace99c1cafdd03a173ca85024f374a62982f7
local     098f28bed7882100d3ba1ccf3f4f8826b6401fc9febd3f79af1349233c213ca1

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

#具名挂载
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx
docker volume ls
DRIVER    VOLUME NAME
local     juming-nginx

#通过 -v 卷名:容器内路径
#查看一些这个卷
[root@VM-24-6-centos ~]# docker volume inspect juming-nginx 
[
    {
        "CreatedAt": "2022-06-15T18:58:59+08:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/juming-nginx/_data",
        "Name": "juming-nginx",
        "Options": null,
        "Scope": "local"
    }
]

所有的docker 容器内的卷 ,没有指定目录的情况下都是在
/var/lib/docker/volumes/xxxxxx/_date
我们通过具名挂载可以方便的找到卷 ,大多数情况都是在使用具名挂载 (不建议使用匿挂载)

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

拓展:ro和rw

#通过 -v 容器内路径:ro或者rw 改变读写权限
ro    readonly    #只读权限
rw    readwrite #可读可写

#一点这个设置了容器权限,容器对我们挂载出来的内容就有限定了
docker run -d -p --name nginx02 -v juming-nginx:/etc/nginx:ro nginx
docker run -d -p --name nginx02 -v juming-nginx:/etc/nginx:rw nginx

ro 只要看到ro就说明这个路径只能通过宿主机来操作,容器内部是无法操作的

DockerFile

初识dockerfile

Docker 就是用来构建docker镜像的构建文件命令脚本
通过这个脚本可以生成镜像,镜像是一层一层的,脚本一个个的命令,每个命令都是一层

#脚本 :dockrefile01
FROM centos                      #以centos为基础
VOLUME ["volume01","volume02"]     #挂载数据卷,此处为匿名挂载
CMD echo "----end----"                     #输出----end----
CMD /bin/bash                                         #进入镜像默认走bash
#这里的每个命令都是镜像的一层

docker build -f dockerfile1 -t houyifan/centos .\
#    建造/创建 -f指file文件地址 -t tag生成    最后的.是指当前目录下

[root@VM-24-6-centos docker-test-volume]# docker images
REPOSITORY            TAG       IMAGE ID       CREATED          SIZE
houyifan/centos       latest    5773d08c0efb   20 minutes ago   231MB

#生成成功
#查看匿名挂载路径
docker run -it houyifan/centos /bin/bash
#进入之后
ls -l
#可以看到自己挂载的数据卷目录
drwxr-xr-x   2 root root 4096 Jun 16 05:24 volume01
drwxr-xr-x   2 root root 4096 Jun 16 05:24 volume02
#出现了这个目录就意味着,宿主机上一定有一个目录是和当前volume同步的
#在volume01下创建一个空文件
touch container.test
#然后去容器外查看
docker ps 
[root@VM-24-6-centos docker-test-volume]# docker ps
CONTAINER ID   IMAGE             COMMAND                  CREATED          STATUS          PORTS                                     NAMES
4ed2eb4122ff   houyifan/centos   "/bin/bash"              23 minutes ago   Up 23 minutes     
docker inspect 4ed2eb4122ff

[root@VM-24-6-centos docker-test-volume]# cd /var/lib/docker/volumes/cee48b41815963e0ba1ff356d74aea828308080fe6cdb5ce61cad7ae04626331/_data
[root@VM-24-6-centos _data]# ls
container.txt

测试成功同步成功
这种方式未来使用的十分多,因为我们通常会构建自己的镜像
**假设构建镜像的时候没有挂在卷,要手动镜像挂载 -v 卷名:容器内路径

数据卷容器

多个centos同步数据
Docker - 图21

#启动三个容器,通过刚才自己写的镜像启动
#推荐开三个窗口,方便快捷
docker run -it --name docker01 houyifan/centos
docker run -it --name docker02 --volumes-from docker01 houyifan/centos
docker run -it --name docker03 --volumes-from docker01 houyifan/centos
#docker01 的/volume01中创建一个名为01.txt的文件
#然后在docker02和docker03中的/volume02中就可以看到同步成功了
#在docker02或者03中的/volume01或者02中创建02.txt文件就可以看到docker01也同步成功了
#此时删除docker01,则docker02和docker03中的文件还是保留在
#docker数据卷说是同步技术,但是在这里使用更像是备份技术

多个mysql数据共享

[root@VM-24-6-centos /]# docker run -d -p 3310:3306 -v /etc/mysql/conf.d -v /var/lib/mysql -e MYSQL_ROOT_PAWSSWODR=123456 --name mysql01 mysql:5.7


[root@VM-24-6-centos /]# docker run -d -p 3311:3306 -e MYSQL_ROOT_PAWSSWODR=123456 --name mysql02 --volumes-from mysql01 mysql:5.7


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

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

Docker介绍

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

编写一个dockerfile文件
docker build 构建成为一个镜像
docker run运行镜像
docker push 发布镜像 (dockerHub\阿里云镜像仓库)

看一下官方是怎么做的

FROM scratch
ADD centos-7-x86_64-docker.tar.xz /

LABEL \
    org.label-schema.schema-version="1.0" \
    org.label-schema.name="CentOS Base Image" \
    org.label-schema.vendor="CentOS" \
    org.label-schema.license="GPLv2" \
    org.label-schema.build-date="20201113" \
    org.opencontainers.image.title="CentOS Base Image" \
    org.opencontainers.image.vendor="CentOS" \
    org.opencontainers.image.licenses="GPL-2.0-only" \
    org.opencontainers.image.created="2020-11-13 00:00:00+00:00"

CMD ["/bin/bash"]

很多官方的镜像都是基础包,很多功能没有,我们通常会自己搭建自己的镜像
官方既然可以制作镜像,那我们也可以

DockerFile的构建过程

基础知识:

每个保留关键字(指令)都必须是大写字母
执行从上到下顺序
#表示注释
每一个指令都会创建提交一个新的镜像层并提交

dockerfile是面向开发的,我们以后要发布项目,做镜像,就需要编写dockerfile文件 ,这个文件十分简单
docker 镜像成为了企业交付的标准,必须要掌握!
步骤循序:开发,部署,运维缺一不可
DockerFile:构建文件,定义了一切的步骤,源代码
DockerImages: 通过DockerFile构建生成的镜像,最终发布和运行的产品
Docker容器:容器就是镜像运行起来提供服务的

DockerFile指令

FROM                #基础镜像,一切从这里开始
MAINTAINER    #镜像是谁写的:姓名+邮箱
RUN                    #镜像构建的时候需要运行的命令
ADD                    #步骤,比如要搭建一个含有tomcat的镜像,这个tomcat的压缩包就是需要ADD进去的                                添加项
WORKDIR            #DIR目录是镜像的工作目录
VOLUME            #容器卷的挂载位置
EXPOSE            #指定暴露端口
CMD                    #指定这个容器运行的时候要运行的命令,只有最后一个会生效,可被替代
ENTRYPOINT    #指定这个容器运行的时候要运行的命令,可以追加命令
ONBUILD            #当构建一个被继承的DockerFile 的时候就会运行ONBUILD的指令  是一个触发指令
COPY                #类似ADD ,将我们的文件拷贝到镜像中
ENV                    #构建的时候设置环境变量

实战测试:centos

Docker Hub中99%的镜像都是从这个基础镜像过来的 FROM scatch .然后配置需要的文件和软件

#创建一个自己的centos
#编写DockerFile 的文件
[root@VM-24-6-centos dockerfile]# vim mydockerfile-centos
FROM centos:7
MAINTAINER houyifan<1614397071@qq.com>

ENV MYPATH /
WORKDIR $MYPATH

RUN yum install -y vim 
RUN yum install -y net-tools
RUN yun install -y ll

EXPOSE 80

CMD echo $MYPATH
CMD echo "---end---"

CMD /bin/bash

#2.通过这个文件构建镜像
# docker build -f dockerfile文件路径 -t[镜像名]
Successfully built 09b8aba0c521
Successfully tagged mycentos0.1:latest

#测试运行

我们自己增加之后的镜像!
进入容器默认进入/目录
ifconfig 和 vim 命令

我可以列出本地镜像的变更历史
docker history 命令


[root@VM-24-6-centos dockerfile]# docker images
REPOSITORY            TAG       IMAGE ID       CREATED         SIZE
mysql                 5.7       c20987f18b13   5 months ago    448MB

[root@VM-24-6-centos dockerfile]# docker history mysql:5.7 
IMAGE          CREATED        CREATED BY                                      SIZE      COMMENT
c20987f18b13   5 months ago   /bin/sh -c #(nop)  CMD ["mysqld"]               0B    
<missing>      5 months ago   /bin/sh -c #(nop)  EXPOSE 3306 33060            0B        
<missing>      5 months ago   /bin/sh -c #(nop)  ENTRYPOINT ["docker-entry…   0B        
<missing>      5 months ago   /bin/sh -c ln -s usr/local/bin/docker-entryp…   34B       
<missing>      5 months ago   /bin/sh -c #(nop) COPY file:345a22fe55d3e678…   14.5kB    
<missing>      5 months ago   /bin/sh -c #(nop)  VOLUME [/var/lib/mysql]      0B        
<missing>      5 months ago   /bin/sh -c {   echo mysql-community-server m…   313MB     
<missing>      5 months ago   /bin/sh -c echo 'deb http://repo.mysql.com/a…   55B       
<missing>      5 months ago   /bin/sh -c #(nop)  ENV MYSQL_VERSION=5.7.36-…   0B        
<missing>      5 months ago   /bin/sh -c #(nop)  ENV MYSQL_MAJOR=5.7          0B        
<missing>      5 months ago   /bin/sh -c set -ex;  key='A4A9406876FCBD3C45…   1.84kB    
<missing>      5 months ago   /bin/sh -c apt-get update && apt-get install…   52.2MB    
<missing>      5 months ago   /bin/sh -c mkdir /docker-entrypoint-initdb.d    0B        
<missing>      5 months ago   /bin/sh -c set -eux;  savedAptMark="$(apt-ma…   4.17MB    
<missing>      5 months ago   /bin/sh -c #(nop)  ENV GOSU_VERSION=1.12        0B        
<missing>      5 months ago   /bin/sh -c apt-get update && apt-get install…   9.34MB    
<missing>      5 months ago   /bin/sh -c groupadd -r mysql && useradd -r -…   329kB     
<missing>      5 months ago   /bin/sh -c #(nop)  CMD ["bash"]                 0B        
<missing>      5 months ago   /bin/sh -c #(nop) ADD file:bd5c9e0e0145fe33b…   69.3MB

可以通过这个命令看到镜像构建时都做了什么,拿到一个镜像的时候可以研究一些他是怎么做的?

CMD 和 ENTRYPOINT的区别

测试CMD

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

#CMD测试
#编写 dockerfile文件
[root@VM-24-6-centos dockerfile]# vim dockerfile-cmd
FROM centos
CMD ["ls","-a"]
#通过docker build 命令构建dockerfile文件
[root@VM-24-6-centos dockerfile]# docker build -f dockerfile-cmd -t cmdtest .
#启动容器,发现启动时按照dockerfile文件中所写 ls -a命令生效
[root@VM-24-6-centos dockerfile]# docker run b1a5331e95fa
.
..
.dockerenv
bin
dev
etc
home
lib
lib64
#想在启动时追加一个命令  -l  ls -al
[root@VM-24-6-centos dockerfile]# docker run b1a5331e95fa -l
docker: Error response from daemon: failed to create shim task: OCI runtime create failed: runc create failed: unable to start container process: exec: "-l": executable file not found in $PATH: unknown.
ERRO[0000] error waiting for container: context canceled 
#报错是因为在CMD的情况下   -l 替换了 ["ls","-a"]命令  -l并不是命令所以报错!
#如果要在这里使用ls -al命令必须要
docker run 容器ID ls -al

测试:ENTRYOOINT

#编写dockerfile文件
[root@VM-24-6-centos dockerfile]# vim dockerfile-entorypoint
#docker build 构建
[root@VM-24-6-centos dockerfile]# docker build -f dockerfile-entorypoint  -t entorypoint_test .
Sending build context to Docker daemon  4.096kB
Step 1/2 : FROM centos
 ---> 5d0da3dc9764
Step 2/2 : ENTRYPOINT ["ls","-a"]
 ---> Running in eda40af64760
Removing intermediate container eda40af64760
 ---> ecbab266023c
Successfully built ecbab266023c
Successfully tagged entorypoint_test:latest
#启动容器
[root@VM-24-6-centos dockerfile]# docker run ecbab266023c
.
..
.dockerenv
bin
dev
etc
home
lib
lib64


#这时候可以发现和CMD不同的是,我们的追加命令是直接拼接在ENTRYPOINT后面的
[root@VM-24-6-centos dockerfile]# docker run ecbab266023c -l
total 56
drwxr-xr-x   1 root root 4096 Jun 17 06:28 .
drwxr-xr-x   1 root root 4096 Jun 17 06:28 ..
-rwxr-xr-x   1 root root    0 Jun 17 06:28 .dockerenv
lrwxrwxrwx   1 root root    7 Nov  3  2020 bin -> usr/bin
drwxr-xr-x   5 root root  340 Jun 17 06:28 dev
drwxr-xr-x   1 root root 4096 Jun 17 06:28 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  2021 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 132 root root    0 Jun 17 06:28 proc
dr-xr-x---   2 root root 4096 Sep 15  2021 root
drwxr-xr-x  11 root root 4096 Sep 15  2021 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 Jun 16 05:21 sys
drwxrwxrwt   7 root root 4096 Sep 15  2021 tmp
drwxr-xr-x  12 root root 4096 Sep 15  2021 usr
drwxr-xr-x  20 root root 4096 Sep 15  2021 var

在Docker中很多命令都十分的相似,我们需要了解他们的区别,我们最好的学习方式就是对比他们然后测试效果

实战测试:Tomcat镜像

准备镜像文件tomcat压缩包,JDK压缩包

编写dockerfile文件官方命名Dockerfile ,bulid会自动寻找这个文件,就不需要-f来寻找了

#FROM以centos7为基础
FROM centos:7
#MAINTAINER 设置编写人和邮箱
MAINTAINER houyifan<16143970701@qq.com>
#复制 test目录下的readme.txt到 容器内/usr/local/中
COPY readme.txt /usr/local/readme.txt
#复制并解压当前目录中的jdk文件和tomcat文件到/usr/local中
ADD jdk-8u331-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-9.0.22.tar.gz /usr/local/
#启动时执行yum -y install vim 安装vim
RUN yum -y install vim 
#设置MYPATH变量
ENV MYPATH /usr/local
#将上面的环境变量引用为进入的工作目录
WORKDIR $MYPATH
#配置JAVA变量和tomcat变量
ENV JAVA_HOME /usr/local/jdk1.8.0_331
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.22
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.22
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
# -p 暴露8080端口
EXPOSE 8080
#通过ENTRYPOINT启动tomcat
ENTRYPOINT /usr/local/apache-tomcat-9.0.22/bin/startup.sh 
#通过ENTRYPOINT 将日志打印在以下目录
ENTRYPOINT tail -F /usr/local/apache-tomcat-9.0.22/bin/logs/catalina.out

构建镜像 :::info docker run -d -p 3360:8080 —name hyftomcat2 -v /home/tomcat/test/:/usr/local/apache-tomcat-9.0.64/webapps/test -v /home/tomcat/tomcatlogs/:/usr/local/apache-tomcat-9.0.64/logs diytomcat :::
启动镜像 :::info docker exec -it 镜像id :::
访问测试 :::info

本地测试
curl localhost:3360
网页测试
:::
发布项目 ```xml

在挂载的test目录下(也就是在的tomcat/usr/local/apache-tomcat-9.0.22/webapps/test/WEB-INF)新建/WEB-INF/web.xml文件

```xml
#在挂载的test目录下也就是(/usr/local/apache-tomcat-9.0.22/webapps/test)新建index.jsp文件

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>猪猪吃草</title>
</head>
<body>
Hello World!<br/>
<%
out.println("你的 IP 地址 " + request.getRemoteAddr());
%>
</body>
</html>

项目部署成功.可以访问

以后的开发步骤:需要掌握Dockerfile的编写,我们之后的一切都是使用docker镜像来发布运行

发布自己的镜像

发布到docker hub

地址https://hub.docker.com/注册自己的账户
确定这个账号可以登录
在我们服务器上提交自己的镜像 ```shell [root@VM-24-6-centos tomcat]# docker login —help

Usage: docker login [OPTIONS] [SERVER]

Options: -p, —password string Password —password-stdin Take the password from stdin -u, —username string Username


4. 登录完毕之后就可以提交镜像了,就是docker push
```shell
#push 自己的镜像到docker hub上面
#格式是docker push (用户名)/(文件名):版本号
#最好是在提交之前给自己的镜像重新起名    docker tag 镜像名/镜像ID:版本号 新的镜像名:版本号   格式必须是userNAME/iageNAME
[root@VM-24-6-centos tomcat]# docker push 1614397071pain/tomcat:1.0 
The push refers to repository [docker.io/1614397071pain/tomcat]
62d35dd0272d: Pushed 
11d1edb723d2: Pushing [=====================================>]  15.41MB/15.41MB
b56685164584: Pushing [====================================> ]  365.7MB/369.1MB
01ec176f1082: Pushed 
174f56854903: Pushed

可以发现提交的时候也是按照层级来提交的

发布到阿里云镜像

阿里云镜像容器参考官方镜像地址即可
https://cr.console.aliyun.com/repository/cn-hangzhou/hyfimage/1614397071pain/details

小结

理解Docker网络

问题:docker是如何访问网络的?
Docker - 图28

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

#查看容器内部网络地址 ip addr 发现容器启动的时候得到一个eth0@if262 ip地址:docker分配
#如果报错:OCI runtime exec failed: exec failed: unable to start container process: exec: "ip": executable file not found in $PATH: unknown
#解决方法:进入容器内部 apt update && apt install -y iproute2  即可
[root@VM-24-6-centos ~]#docker exec -it tomcat01 ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
4: eth0@if5: <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通这个Ip
[root@VM-24-6-centos ~]# 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.045 ms
64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.042 ms
64 bytes from 172.17.0.2: icmp_seq=3 ttl=64 time=0.050 ms
64 bytes from 172.17.0.2: icmp_seq=4 ttl=64 time=0.053 ms
64 bytes from 172.17.0.2: icmp_seq=5 ttl=64 time=0.051 ms

#linux 可以ping通容器内部

:::info 原理 :::

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

再次测试 ip addr

再次启动一个tomcat02并查看 ip addr

#我们发现这个容器带来的网卡,都是一对对的
#evth-pair就是一对的虚拟设备接口,他们都是成对出现的,一段连着协议,一段彼此相连
#正因为有这个特性, evth-pair就可以充当一个桥梁`

测试tomcat01 是否可以ping 通 tomcat02
```
docker exec -it tomcat02 ping 172.18.0.2
#结论:容器和容器之间是可以互相ping的
```
绘制一个网络模型图

结论: Tomcat 01 和tomcat02 是公用的一个路由器 docker0
所有容器不指定网络的情况下.都是docker0路由的.docker 会给我们的容器分配一个默认的可用ip
小结:

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

—link

:::info 思考一个问题,我们编写了一个微服务, database url= ip 项目不重启,数据库ip换掉了,我们希望可以处理这个问题,可以用名字来进行访问容器? ::: 在这之前我们把自己写一个centos7和tomcat的dockerfile,方便后面操作,因为后面docker镜像的缘故会造成不方便

FROM centos:7
MAINTAINER houyifan<1614397071@qq.com>
ENV MYPATH /
WORKDIR $MYPATH
RUN yum install -y tomcat
RUN yum install -y vim
RUN yum install -y net-tools
RUN yum install -y yum
RUN yum install -y iputils
EXPOSE 80
CMD echo $MYPATH
CMD echo "---end---"
CMD /bin/bash

FROM centos7:1
MAINTAINER houyifan<16143970701@qq.com>
COPY readme.txt /usr/local/readme.txt
ADD jdk-8u331-linux-x64.tar.gz /usr/local/ 
ADD apache-tomcat-9.0.22.tar.gz /usr/local/

ENV MYPATH /usr/local
WORKDIR $MYPATH

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

EXPOSE 8080
ENTRYPOINT /usr/local/apache-tomcat-9.0.22/bin/startup.sh

之后便可以开始了

[root@VM-24-6-centos tomcat]# docker exec -it tomcat03 ping tomcat02 
ping: tomcat02: Name or service not known

#如何可以解决呢?
[root@VM-24-6-centos tomcat]# docker exec -it tomcat03 ping tomcat02 
ping: tomcat02: Name or service not known
[root@VM-24-6-centos tomcat]# docker run -d -P --name tomcat03 --link tomcat02 tomcat:1.0 

#通过--link就可以解决了
cae72aa0ca086b97bfeb0e1ed2c532a0a748d72997cbeaa0321af73cf904d48f
[root@VM-24-6-centos tomcat]# 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.107 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=2 ttl=64 time=0.061 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=3 ttl=64 time=0.052 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=4 ttl=64 time=0.060 ms

#反向可以ping通吗?
[root@VM-24-6-centos tomcat]# docker exec -it tomcat02 ping tomcat03
ping: tomcat03: Name or service not known
#并不行

探究:

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

#查看hosts的配置,在这里原理发现
[root@VM-24-6-centos tomcat]# 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 e28643de30e4
172.17.0.4    cae72aa0ca08

本质探究:—link 就是我们在hosts配置中增加了一个 172.18.0.3 tomcat 02 e28643de30e4
现在使用Docker已经不建议使用—link了!

自定义网络

[root@VM-24-6-centos ~]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
7276891c6bf8   bridge    bridge    local
564033f348d0   host      host      local
4d839be2fc1a   none      null      local

网络模式:
bridge:桥接模式桥接到docker (默认网络)
none : 不配置网络
host: 和宿主机共享网络
container : 容器之间网络互联(用的很少,局限很大)
测试:

#我们直接俄启动的命令 会有默认一个--net bridge  这个就是我们的docker0
docker run -d -P --name tomcat01 tomcat:1.1 
docker run -d -P --name tomcat01 --net bridge tomcat:1.1 

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

#我们可以自定义一个网络
#--dirver bridge          默认桥接
#--subnet 192.168.0.0/16    子网地址   区间是192.168.0.2到192.168.255.255
#--subnet 192.168.0.1            网关地址
[root@VM-24-6-centos tomcat]# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
d8496e6216a0a5621e01b1d9715416090fc164cdf1b253219bcc0e67d326a918
[root@VM-24-6-centos tomcat]# docker in
info     inspect  
[root@VM-24-6-centos tomcat]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
7276891c6bf8   bridge    bridge    local
564033f348d0   host      host      local
d8496e6216a0   mynet     bridge    local
4d839be2fc1a   none      null      local


#查看自己创建的网络
[root@VM-24-6-centos tomcat]# docker network inspect mynet 
[
    {
        "Name": "mynet",
        "Id": "d8496e6216a0a5621e01b1d9715416090fc164cdf1b253219bcc0e67d326a918",
        "Created": "2022-07-05T17:00:09.179458974+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": {},
        "Options": {},
        "Labels": {}
    }
]

#查看之后,在自己的 mynet之下创建两个Tomcat 试试
docker run -d -P --name tomcat01-net01 --net mynet tomcat:1.1
docker run -d -P --name tomcat02-net01 --net mynet tomcat:1.1
[root@VM-24-6-centos tomcat]# docker inspect mynet 
[
    {
        "Name": "mynet",
        "Id": "d8496e6216a0a5621e01b1d9715416090fc164cdf1b253219bcc0e67d326a918",
        "Created": "2022-07-05T17:00:09.179458974+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": {
            "472fe351df020183d89faf54829d1b1a0648ce436f66707bebded1cb8ea2e582": {
                "Name": "tomcat02-net01",
                "EndpointID": "685559af0451249e020f9ff8668c3b73cbccf71a01900fbe736ce901504322f4",
                "MacAddress": "02:42:c0:a8:00:03",
                "IPv4Address": "192.168.0.3/16",
                "IPv6Address": ""
            },
            "9bddd08a80d9ad4ca1d272362a2a2b2e0ba79cceeac7a6a4b4db5a18f1a95357": {
                "Name": "tomcat01-net01",
                "EndpointID": "1dfa54cc4d49478fdd4d6b52faf42e1c5ac20dfe05b5c5e633f379b7ce4a6816",
                "MacAddress": "02:42:c0:a8:00:02",
                "IPv4Address": "192.168.0.2/16",
                "IPv6Address": ""
            }
        },
        "Options": {},
        "Labels": {}
    }
]

#现在再次在自己创建的mynet网络下测试ping链接
[root@VM-24-6-centos tomcat]# ^C
[root@VM-24-6-centos tomcat]# docker exec -it tomcat01-net01 ping 192.168.0.3
PING 192.168.0.3 (192.168.0.3) 56(84) bytes of data.
64 bytes from 192.168.0.3: icmp_seq=1 ttl=64 time=0.093 ms
64 bytes from 192.168.0.3: icmp_seq=2 ttl=64 time=0.052 ms
64 bytes from 192.168.0.3: icmp_seq=3 ttl=64 time=0.053 ms

#现在不适用--link也可以ping 名字了
[root@VM-24-6-centos tomcat]# docker exec -it tomcat02-net01 ping 192.168.0.2
PING 192.168.0.2 (192.168.0.2) 56(84) bytes of data.
64 bytes from 192.168.0.2: icmp_seq=1 ttl=64 time=0.063 ms
64 bytes from 192.168.0.2: icmp_seq=2 ttl=64 time=0.056 ms

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

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

网络连通

#测试打通 Tomcat01 到mynet
docker network connect mynet tomcat01

#连通之后就是将tomcat01 放到了mynet网络下
#这个操作在官网叫做,一个容器两个地址
#类似云服务器的两个ip  公网ip 和私网ip

测试:

[root@VM-24-6-centos tomcat]# docker exec -it tomcat01 ping tomcat01-net01 
PING tomcat01-net01 (192.168.0.2) 56(84) bytes of data.
64 bytes from tomcat01-net01.mynet (192.168.0.2): icmp_seq=1 ttl=64 time=0.095 ms
64 bytes from tomcat01-net01.mynet (192.168.0.2): icmp_seq=2 ttl=64 time=0.041 ms
64 bytes from tomcat01-net01.mynet (192.168.0.2): icmp_seq=3 ttl=64 time=0.040 ms
--- tomcat01-net01 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 2000ms
rtt min/avg/max/mdev = 0.040/0.058/0.095/0.027 ms

#发现tomcat01 和tomcat01-net01是可以联通了

[root@VM-24-6-centos tomcat]# docker exec -it tomcat02 ping tomcat01-net01 
ping: tomcat01-net01: Name or service not known

#而tomcat02没有和mynet网络联通则不能ping通

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

实战:部署Redis集群

shell脚本

#创建网卡
docker network create redis --subnet 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.1${port}
cluster-announce-port 6379
cluster-announce-bus-port 16379
appendonly yes
EOF
done

docker run -p 6371${port}:6379 -p 16371${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; \

#启动redis
docker run -p 6371:6379 -p 16371:16379 --name redis-1 \
-v /mydata/redis/node-1/data:/date \
-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:/date \
-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

docker run -p 6373:6379 -p 16373:16379 --name redis-3 \
-v /mydata/redis/node-3/data:/date \
-v /mydata/redis/node-3/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.13 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

docker run -p 6374:6379 -p 16374:16379 --name redis-4 \
-v /mydata/redis/node-4/data:/date \
-v /mydata/redis/node-4/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.14 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

docker run -p 6375:6379 -p 16375:16379 --name redis-5 \
-v /mydata/redis/node-5/data:/date \
-v /mydata/redis/node-5/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.15 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

docker run -p 6376:6379 -p 16376:16379 --name redis-6 \
-v /mydata/redis/node-6/data:/date \
-v /mydata/redis/node-6/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.16 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

#创建一个集群,docker exec -it redis-1 /bin/sh 进入redis-1 注意redis中没有bash,这里要用sh进入

/data # redis-cli --cluster create 172.38.0.11:6379 172.38.0.12:6379 172.38.0.13:6379 172.38.0.14:6379 172.38.0.15:6379 172.38.0.16:6379 --cluster-replicas 1
>>> Performing hash slots allocation on 6 nodes...
Master[0] -> Slots 0 - 5460
Master[1] -> Slots 5461 - 10922
Master[2] -> Slots 10923 - 16383
Adding replica 172.38.0.15:6379 to 172.38.0.11:6379
Adding replica 172.38.0.16:6379 to 172.38.0.12:6379
Adding replica 172.38.0.14:6379 to 172.38.0.13:6379
M: 918d0b2598975a9d5f99b4ba103eb283cc12eb54 172.38.0.11:6379
   slots:[0-5460] (5461 slots) master
M: f9b8cf2bea2a4385dcb1b985c686b3811facef12 172.38.0.12:6379
   slots:[5461-10922] (5462 slots) master
M: 522c023534a66772bd916e79a0b0305e6afa2314 172.38.0.13:6379
   slots:[10923-16383] (5461 slots) master
S: de2bf7d41bfe48ebb5f031e6550f1a1da7d979ac 172.38.0.14:6379
   replicates 522c023534a66772bd916e79a0b0305e6afa2314
S: eb089036ed6f48aa43cfae90b961a455d5595801 172.38.0.15:6379
   replicates 918d0b2598975a9d5f99b4ba103eb283cc12eb54
S: 0fcfdb126e58fe1d6e9efc2303969dfaede6fdff 172.38.0.16:6379
   replicates f9b8cf2bea2a4385dcb1b985c686b3811facef12
Can I set the above configuration? (type 'yes' to accept): yes
>>> Nodes configuration updated
>>> Assign a different config epoch to each node
>>> Sending CLUSTER MEET messages to join the cluster
Waiting for the cluster to join
...
>>> Performing Cluster Check (using node 172.38.0.11:6379)
M: 918d0b2598975a9d5f99b4ba103eb283cc12eb54 172.38.0.11:6379
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
S: 0fcfdb126e58fe1d6e9efc2303969dfaede6fdff 172.38.0.16:6379
   slots: (0 slots) slave
   replicates f9b8cf2bea2a4385dcb1b985c686b3811facef12
S: eb089036ed6f48aa43cfae90b961a455d5595801 172.38.0.15:6379
   slots: (0 slots) slave
   replicates 918d0b2598975a9d5f99b4ba103eb283cc12eb54
M: f9b8cf2bea2a4385dcb1b985c686b3811facef12 172.38.0.12:6379
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
M: 522c023534a66772bd916e79a0b0305e6afa2314 172.38.0.13:6379
   slots:[10923-16383] (5461 slots) master
   1 additional replica(s)
S: de2bf7d41bfe48ebb5f031e6550f1a1da7d979ac 172.38.0.14:6379
   slots: (0 slots) slave
   replicates 522c023534a66772bd916e79a0b0305e6afa2314
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.

docker 搭建redis集群完成

我们使用docker 之后,所有的技术都会慢慢的简单起来

Docker

docker学习流程

Docker概述

Docker为什么会出现?

Docker的历史

Docker能做什么?

安装Docker

Docker的基本组成

安装Docker

底层原理

Docker的常用命令

帮助命令

镜像命令

容器命令

其他常用命令

小结

练习:nginx

练习:tomcat

练习:ES+kibana

部署ES

可视化

Docker镜像讲解

镜像是什么?

docker镜像加载原理

分层理解

commit镜像

容器数据卷

什么是容器数据卷?

使用数据卷

实战:安装Mysql

具名挂载和匿名挂载

拓展:ro和rw

DockerFile

初识dockerfile

数据卷容器

Docker介绍

DockerFile的构建过程

DockerFile指令

实战测试:centos

CMD 和 ENTRYPOINT的区别

测试CMD

测试:ENTRYOOINT

实战测试:Tomcat镜像

本地测试curl localhost:3360网页测试

在挂载的test目录下(也就是在的tomcat/usr/local/apache-tomcat-9.0.22/webapps/test/WEB-INF)新建/WEB-INF/web.xml文件

发布自己的镜像

发布到docker hub

发布到阿里云镜像

小结

理解Docker网络

小结:

—link

自定义网络

网络连通

实战:部署Redis集群

本地测试
curl localhost:3360
网页测试