Docker基础学习--教你玩转Docker

文章目录

学习资料
学习内容
Docker概述
- Docker出现的原因
- Docker 历史
- Docker能干什么
- - 传统虚拟机技术
  - 容器化技术
  - Docker 的优势
Docker安装
- Docker的基本组成
- Docker安装
- - 系统配置
  - 安装步骤
  - 安装阿里云静像
Docker原理
- Docker Run原理
- Docker 是如何工作的
- Docker 为什么比VM快
Docker常用命令解析
- 帮助命令
- 镜像命令
- 容器命令
- 常用其它命令(常用)
Docker部署
- Docker安装nginx
- Docker安装Tomcat
- Docker安装mysql
- Docker安装ES和kibana（未学）
- 端口映射
- Docker可视化窗口（不需要使用）
Docker镜像
- 镜像是什么
- Docker镜像加载原理
- 分层理解
- **commit镜像**
Docker数据卷
- 问题
- 使用数据卷
- 实战：挂载mysql
- 具名挂载和匿名挂载
- 挂载权限设置
- 数据卷之DockerFile
- 数据卷容器
- 数据库同步
DockerFile
- DockerFile的构建过程
- DockerFile指令
- 创建一个自己的centos
- 查看镜像历史
- CMD和ENTRYPOINT区别
- 实战：Tomcat镜像
- - **操作步骤**
  - 发布镜像到dockerhub
  - 发布镜像到阿里云
- 小结
Docker网络
- Docker0
- 思考：数据库的容器ip切换
- 自定义网络
- 网络联通
- 搭建redis集群（未学）
Docker部署SpringBoot项目
问题汇总
- 1. docker卸载后，镜像还存在
- 2. docker run 和 docker start的区别
- 3. mysql安装后，外部无法访问
- 4. ls ls-a ls -l ls -al区别
- 5. 容器启动闪退问题
- 6. 容器创建后如何进行文件挂载
- 7.文件挂载失败
- 8.为什么mysql挂载后，容器内挂载的资源没有消失，而其他容器挂载后，容器内资源消息
- 8.为什么不能直接访问服务器上面的文件，而必须使用代理。
常用命令

学习资料

docker官网：Empowering App Development for Developers | Docker

docker容器：Docker Hub

docker文档：Docker documentation | Docker documentation

docker教程：docker教程_docker使用快速入门-php中文网

狂神笔记：(61条消息) 狂神说docker(最全笔记）_烟霞畔的博客-CSDN博客_狂神说docker笔记(61条消息) 狂神说docker(最全笔记）_烟霞畔的博客-CSDN博客_狂神说docker笔记

docker容器常见故障：

学习规划(https://www.processon.com/mindmap/61872e0b0791293fb6c57d95)](https://www.processon.com/mindmap/61872e0b0791293fb6c57d95)

学习内容

Docker概述
Docker安装
Docker命令
1. 操作命令
2. 容器命令
3. 操作命令
4. …
Dcoker镜像！
容器数据卷！
DockerFile
Docker网络原理
Idea整合Docker
Docker Compose
Docker Swarm（简化版k8s）
CICD Jenkins

Docker概述 Docker出现的原因

部署项目
1. 之前部署项目：
  1. 开发人员生成jar包，运维人员部署环境（redis，mysql，tomcat等等），项目不能带上环境打包。
  2. 缺点：
    1. 环境配置复杂，耗时长，稍有不慎，甚至需要重新部署
    2. 在不同的系统上部署相同的项目，每个项目都需要配置一套环境，麻烦
2. 利用docker部署项目：
  1. 开发人员打jar包时带上环境，直接生成jar包和环境的镜像，运维人员直接下载使用即可。
  2. 优点：
    1. 项目的开发和运行使用同一套环境（都是开发人员配置的），不会出现在我电脑上能用，在你电脑上不能使用的情况。
    2. 打包后的镜像就像应用商店一样，运维人员直接下载部署集合，不需要再进行复杂的环境配置。
    3. 在不同的服务器上部署项目，只需要配好一套镜像，在所有服务器上直接下载使用即可，不需要在每个服务器上都重新部署一套
    4. docker隔离机制，发挥服务器的最大性能
      1. 如果直接在linux上部署项目，如果有多个项目，很容易出现部署冲突（如端口占用等等），使用docker，将linux分成一个个小的linux的docker容器，每一个docker都是迷你版的linux，每一个docker里面部署各自的项目，将linux服务器的资源发挥到最大，并且可以减少部署冲突的问题。

Docker 历史

docker基于go语言开发。

虚拟机：在window中安装一个vw，通过这个软件我们可以虚拟出来一台或者多台电脑！笨重！

虚拟机也是徐继华技术，Docker容器技术，也是一种虚拟化技术。

vm： linux+centos原生镜像（相当于一台电脑）使用隔离，需要开启多个虚拟机！一个虚拟机几个G，开启需要几分钟。

docker：使用隔离时，采用镜像（小的linux，只包含最核心功能，只有及M）小巧，运行镜像就可以！

Docker能干什么传统虚拟机技术

模拟了一台电脑，内存非常大。

缺点：

资源占用多
冗余步骤多
开多个服务很多

容器化技术

比较docker与虚拟机

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

Docker 的优势

应用更快速的交付和部署
1. 传统：一堆帮助文档，安装程序
2. docker：打包镜像，发布测试和运行。测试环境和运行环境都是用一套配置
更便捷的升级和扩缩容
1. 假如说要进行mysql，redis，springboot的升级，我们只需要将打包的jar和相应环境下载运行即可，而不需要针对各个环境进行升级。
2. 如果我们一个服务器不够用，要用多台服务器部署我们的项目，我们直接下载使用同一套docker配置即可。
更简单的系统运维
1. 在容器化之后，我们的开发，测试环境都是高度一致
更高效的计算资源利用
1. Dcoker是内核级别的虚拟化，可以在一个物理机上运行很多容器示例，服务器的性能可以压榨到极致。

Docker安装 Docker的基本组成

client去启动容器，容器去远程仓库中下载相关静像，在容器中创建这些镜像的示例（可以理解成配置静像）

静像（Image）：

docker静像就好比一个模板，通过模板来创建容器服务。 tomcat静像—run — tomcat1容器（提供服务器），通过这个静像可以创建多个容器（最终服务运行或者项目运行就在这个容器中）。

容器：

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

包含启动，停止，删除，等基本命令。

这个容器可以理解成一个简易的linux系统

仓库：

仓库就是存放静像的地方！分为公有仓库（DockerHub国外的）和私有仓库（私人仓库）。

阿里云，华为云等都有容器服务器（配置镜像下载加速，因为dockerhub是国外的，下载慢）。

docker主机：

安装了Docker程序的机器（Docker直接安装在了操作系统之上）

docker客户端：

链接docker主机进行操作

Docker安装系统配置

# 系统内核 要求linux系统版本高于3.10
[root@ZHQ ~]# uname -r
3.10.0-1127.19.1.el7.x86_64
# 系统版本
[root@ZHQ ~]# 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"

安装步骤

CentOS Docker 安装 | 菜鸟教程 (runoob.com)

使用docker：

查看已安装的docker镜像

docker images

刚刚安装的hello world 镜像

安装阿里云静像

如果没有阿里云镜像，我们下载相关配置的驱动时会从外网上下载，速度非常的慢。

https://cr.console.aliyun.com/cn-hangzhou/instances/mirrorshttps://cr.console.aliyun.com/cn-hangzhou/instances/mirrors

第一步：登陆阿里云，找到容器镜像服务，进入到控制台

第二步：获取加速器地址

第三步：配置使用

将EOF前的内容（包含EOF）在控制台输入，之后再分别执行下面两句话。

Docker原理 Docker Run原理

使用docker run hello-world指令后所进行的操作。

Docker 是如何工作的

Docker是一个Client-Server架构的系统，Docker的守护进程运行在主机上。通过Scoket从客户端进行访问！

DockerServer接收到Docker client的指令，就会执行这个命令1

Docker 为什么比VM快

Docker有着比虚拟机更少的抽象层。
Docker利用的是宿主机的内核，vm需要时Guest os（比较大，有他才能运行）

新建容器的时候，docker不需要像虚拟机一样新建一个操作系统内核。虚拟机加载Guest os，分钟级别。而docker使用了宿主机的操作系统，秒级！

Docker常用命令解析

帮助命令

docker version  # docker版本信息
docker info     # 系统级别的信息，包括镜像和容器的数量
docker 命令 --help

帮助文档

镜像命令

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

[root@iZ2zeg4ytp0whqtmxbsqiiZ ~]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
hello-world         latest              bf756fb1ae65        7 months ago        13.3kB
 
# 解释
REPOSITORY      # 镜像的仓库
TAG             # 镜像的标签
IMAGE ID        # 镜像的ID
CREATED         # 镜像的创建时间
SIZE            # 镜像的大小
 
# 可选项
--all , -a      # 列出所有镜像
--quiet , -q    # 只显示镜像的id

docker search 查找镜像

NAME                              DEscriptION                                     STARS               OFFICIAL         AUTOMATED
mysql                             MySQL is a widely used, open-source relation…   9822                [OK]                
mariadb                           MariaDB is a community-developed fork of MyS…   3586                [OK]                
mysql/mysql-server                Optimized MySQL Server Docker images. Create…   719                                     [OK]
 
# 可选项
--filter=STARS=3000     # 搜素出来的镜像就是STARS大于3000的
 
[root@iZ2zeg4ytp0whqtmxbsqiiZ ~]# docker search mysql --filter=STARS=3000
NAME                DEscriptION                                     STARS               OFFICIAL            AUTOMATED
mysql               MySQL is a widely used, open-source relation…   9822                [OK]                
mariadb             MariaDB is a community-developed fork of MyS…   3586

docker pull 下拉镜像

# 下载镜像，docker pull 镜像名[:tag]
[root@iZ2zeg4ytp0whqtmxbsqiiZ ~]# docker pull mysql
Using default tag: latest           # 如果不写tag，默认就是latest
latest: Pulling from library/mysql
bf5952930446: Pull complete         # 分层下载，dockerimages的核心，联合文件系统
8254623a9871: Pull complete 
938e3e06dac4: Pull complete 
ea28ebf28884: Pull complete 
f3cef38785c2: Pull complete 
894f9792565a: Pull complete 
1d8a57523420: Pull complete 
6c676912929f: Pull complete 
ff39fdb566b4: Pull complete 
fff872988aba: Pull complete 
4d34e365ae68: Pull complete 
7886ee20621e: Pull complete 
Digest: sha256:c358e72e100ab493a0304bda35e6f239db2ec8c9bb836d8a427ac34307d074ed     # 签名
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest      # 真实地址
 
# 等价于
docker pull mysql
docker pull docker.io/library/mysql:latest
 
# 指定版本下载
[root@iZ2zeg4ytp0whqtmxbsqiiZ ~]# docker pull mysql:5.7
5.7: Pulling from library/mysql
bf5952930446: Already exists 
8254623a9871: Already exists 
938e3e06dac4: Already exists 
ea28ebf28884: Already exists 
f3cef38785c2: Already exists 
894f9792565a: Already exists 
1d8a57523420: Already exists 
5f09bf1d31c1: Pull complete 
1b6ff254abe7: Pull complete 
74310a0bf42d: Pull complete 
d398726627fd: Pull complete 
Digest: sha256:da58f943b94721d46e87d5de208dc07302a8b13e638cd1d24285d222376d6d84
Status: Downloaded newer image for mysql:5.7
docker.io/library/mysql:5.7
 
# 查看本地镜像
[root@iZ2zeg4ytp0whqtmxbsqiiZ ~]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
mysql               5.7                 718a6da099d8        6 days ago          448MB
mysql               latest              0d64f46acfd1        6 days ago          544MB
hello-world         latest              bf756fb1ae65        7 months ago        13.3kB

docker rmi 删除镜像

[root@iZ2zeg4ytp0whqtmxbsqiiZ ~]# docker rmi -f IMAGE ID                        # 删除指定镜像
[root@iZ2zeg4ytp0whqtmxbsqiiZ ~]# docker rmi -f IMAGE ID1 IMAGE ID2 IMAGE ID3   # 删除多个镜像
[root@iZ2zeg4ytp0whqtmxbsqiiZ ~]#  docker rmi -f $(docker images -aq)           # 删除所有镜像

容器命令

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

docker pull centos

新建容器并启动

docker run [可选参数] image
 
# 参数说明
--name=“Name”   容器名字    tomcat01    tomcat02    用来区分容器
-d      后台方式运行
-it     使用交互方式运行，进入容器查看内容
-p      指定容器的端口     -p 8080:8080   
    -p  ip:主机端口：容器端口
    -p  主机端口：容器端口（常用）
    -p  容器端口
    容器端口
-p      随机指定端口
 
 
# 测试，启动并进入容器
[root@iZ2zeg4ytp0whqtmxbsqiiZ ~]# docker run -it centos /bin/bash zhuo
[root@74e82b7980e7 /]# ls   # 查看容器内的centos，基础版本，很多命令是不完善的
bin  etc   lib    lost+found  mnt  proc  run   srv  tmp  var
dev  home  lib64  media       opt  root  sbin  sys  usr
 
# 从容器中退回主机
[root@77969f5dcbf9 /]# exit
exit
[root@iZ2zeg4ytp0whqtmxbsqiiZ /]# ls
bin   dev  fanfan  lib    lost+found  mnt  proc  run   srv  tmp  var
boot  etc  home    lib64  media       opt  root  sbin  sys  usr

列出所有的运行的容器

# docker ps 命令
        # 列出当前正在运行的容器
-a      # 列出正在运行的容器包括历史容器
-n=?    # 显示最近创建的容器
-q      # 只显示当前容器的编号
 
[root@iZ2zeg4ytp0whqtmxbsqiiZ /]# docker ps
ConTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
[root@iZ2zeg4ytp0whqtmxbsqiiZ /]# docker ps -a
ConTAINER ID        IMAGE               COMMAND             CREATED             STATUS                     PORTS               NAMES
77969f5dcbf9        centos              "/bin/bash"         5 minutes ago       Exited (0) 5 minutes ago                       xenodochial_bose
74e82b7980e7        centos              "/bin/bash"         16 minutes ago      Exited (0) 6 minutes ago                       silly_cori
a57250395804        bf756fb1ae65        "/hello"            7 hours ago         Exited (0) 7 hours ago                         elated_nash
392d674f4f18        bf756fb1ae65        "/hello"            8 hours ago         Exited (0) 8 hours ago                         distracted_mcnulty
571d1bc0e8e8        bf756fb1ae65        "/hello"            23 hours ago        Exited (0) 23 hours ago                        magical_burnell
 
[root@iZ2zeg4ytp0whqtmxbsqiiZ /]# docker ps -qa
77969f5dcbf9
74e82b7980e7
a57250395804
392d674f4f18
571d1bc0e8e8

退出容器

exit            # 直接退出容器并关闭
Ctrl + P + Q    # 容器不关闭退出

删除容器

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

启动和停止容器的操作

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

常用其它命令(常用)

后台启动容器

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

查看日志

docker logs -tf --tail number 容器id
 
[root@iZ2zeg4ytp0whqtmxbsqiiZ /]# docker logs -tf --tail 1 8d1621e09bff
2020-08-11T10:53:15.987702897Z [root@8d1621e09bff /]# exit      # 日志输出
 
# 自己编写一段shell脚本
[root@iZ2zeg4ytp0whqtmxbsqiiZ /]# docker run -d centos /bin/sh -c "while true;do echo xiaofan;sleep 1;done"
a0d580a21251da97bc050763cf2d5692a455c228fa2a711c3609872008e654c2
 
[root@iZ2zeg4ytp0whqtmxbsqiiZ /]# docker ps
ConTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS               NAMES
a0d580a21251        centos              "/bin/sh -c 'while t…"   3 seconds ago       Up 1 second                             lucid_black
 
# 显示日志
-tf                 # 显示日志
--tail number       # 显示日志条数
[root@iZ2zeg4ytp0whqtmxbsqiiZ /]# docker logs -tf --tail 10 a0d580a21251

查看容器中进程信息ps

# 命令 docker top 容器id
[root@iZ2zeg4ytp0whqtmxbsqiiZ /]# docker top df358bc06b17
UID                 PID                 PPID                C                   STIME               TTY     
root                28498               28482               0                   19:38               ?

查看容器的元数据

# 命令
docker inspect 容器id
 
[root@iZ2zeg4ytp0whqtmxbsqiiZ /]# docker inspect df358bc06b17
[
    {
        "Id": "df358bc06b17ef44f215d35d9f46336b28981853069a3739edfc6bd400f99bf3",
        "Created": "2020-08-11T11:38:34.935048603Z",
        "Path": "/bin/bash",
        "Args": [],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 28498,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2020-08-11T11:38:35.216616071Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:0d120b6ccaa8c5e149176798b3501d4dd1885f961922497cd0abef155c869566",
        "ResolvConfPath": "/var/lib/docker/containers/df358bc06b17ef44f215d35d9f46336b28981853069a3739edfc6bd400f99bf3/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/df358bc06b17ef44f215d35d9f46336b28981853069a3739edfc6bd400f99bf3/hostname",
        "HostsPath": "/var/lib/docker/containers/df358bc06b17ef44f215d35d9f46336b28981853069a3739edfc6bd400f99bf3/hosts",
        "LogPath": "/var/lib/docker/containers/df358bc06b17ef44f215d35d9f46336b28981853069a3739edfc6bd400f99bf3/df358bc06b17ef44f215d35d9f46336b28981853069a3739edfc6bd400f99bf3-json.log",
        "Name": "/hungry_heisenberg",
        "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,
            "Capabilities": null,
            "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/5af8a2aadbdba9e1e066331ff4bce56398617710a22ef906f9ce4d58bde2d360-init/diff:/var/lib/docker/overlay2/62926d498bd9d1a6684bb2f9920fb77a2f88896098e66ef93c4b74fcb19f29b6/diff",
                "MergedDir": "/var/lib/docker/overlay2/5af8a2aadbdba9e1e066331ff4bce56398617710a22ef906f9ce4d58bde2d360/merged",
                "UpperDir": "/var/lib/docker/overlay2/5af8a2aadbdba9e1e066331ff4bce56398617710a22ef906f9ce4d58bde2d360/diff",
                "WorkDir": "/var/lib/docker/overlay2/5af8a2aadbdba9e1e066331ff4bce56398617710a22ef906f9ce4d58bde2d360/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [],
        "Config": {
            "Hostname": "df358bc06b17",
            "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": "20200809",
                "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": "4822f9ac2058e8415ebefbfa73f05424fe20cc8280a5720ad3708fa6e80cdb08",
            "HairpinMode": false,
            "linkLocalIPv6Address": "",
            "linkLocalIPv6PrefixLen": 0,
            "Ports": {},
            "SandboxKey": "/var/run/docker/netns/4822f9ac2058",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "5fd269c0a28227241e40cd30658e3ffe8ad6cc3e6514917c867d89d36a31d605",
            "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": "30d6017888627cb565618b1639fecf8fc97e1ae4df5a9fd5ddb046d8fb02b565",
                    "EndpointID": "5fd269c0a28227241e40cd30658e3ffe8ad6cc3e6514917c867d89d36a31d605",
                    "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
                }
            }
        }
    }
]
[root@iZ2zeg4ytp0whqtmxbsqiiZ /]#

进入当前正在运行的容器

 
进入当前正在运行的容器

# 我们通常容器使用后台方式运行的， 需要进入容器，修改一些配置
 
# 命令
docker exec -it 容器id /bin/bash
 
# 测试
[root@iZ2zeg4ytp0whqtmxbsqiiZ /]# docker exec -it df358bc06b17 /bin/bash
[root@df358bc06b17 /]# ls       
bin  etc   lib    lost+found  mnt  proc  run   srv  tmp  var
dev  home  lib64  media       opt  root  sbin  sys  usr
[root@df358bc06b17 /]# ps -ef
UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 Aug11 pts/0    00:00:00 /bin/bash
root        29     0  0 01:06 pts/1    00:00:00 /bin/bash
root        43    29  0 01:06 pts/1    00:00:00 ps -ef
 
# 方式二
docker attach 容器id
 
# docker exec       # 进入容器后开启一个新的终端，可以在里面操作
# docker attach     # 进入容器正在执行的终端，不会启动新的进程

从容器中拷贝文件到主机

docker cp 容器id：容器内路径(/home/Test.java)    目的地主机路径(/home)
 
[root@iZ2zeg4ytp0whqtmxbsqiiZ /]# docker cp 7af535f807e0:/home/Test.java /home

Docker部署 Docker安装nginx

安装步骤

搜索镜像：docker search nginx
下载镜像：docker pull nginx
启动镜像：docker run -d --name nginx01 -p 3344:80 nginx （访问本机3344，映射到容器里面的80端口）
1. -d 后台运行
2. –name 命名
3. -p 端口设置
本机自测：curl localhost:3344
外部访问：注意阿里云端口的开放
进入nginx容器:docker exec -it nginx01 /bin/bash
进入容器里面的nginx文件夹：
1. 查看文件路径：whereis nginx
2. 进入文件：cd /etc/nginx
3. 查看里面内容：ls
4. 查看nginx配置文件：cat nginx.conf
退出容器：exit
停止容器：docker stop 容器id

注意：如果3344阿里云未开放此端口，是访问不到的

Docker安装Tomcat

安装步骤

docker pull tomcat:8.5.57
1. 直接运行（本地没有镜像会直接下载）:docker run -it --rm tomcat:8.5.57
  1. 之前启动没有–rm，启动都是容器后台，容器退出后还可以查到。而 docker run -it --rm tomcat:8.5.57推出容器后，即把docker容器删除，用于测试使用。通常不使用。
docker run -d --name tomcat01 -p 8080:8080 tomc
curl localhost:8080
1. 发现404
2. 原因：我们下载的tomcat容器是经过缩减过的，下载的容器只保障最基本的运行。
3. 解决方法：
  1. 进入容器内部：docker exec -it tomcat01 /bin/bash
  2. ls，发现有webapps和webapps.dist目录
    1. cd webapps:发现里面是空的
    2. cd webapps.dist:发现里面有tomcat的相关文件（可以理解为tomcat的启动文件）
    3. 我们需要把webapps.dist中的所有文件放在webapps中，即可成功运行。
  3. 拷贝文件：在docker exec -it tomcat01 /bin/bash进去的文件夹下
    1. 执行命令:cp -r webapps.dist/* webapps
  4. 测试：curl localhost:8080
4. 开放阿里云端口

Docker安装mysql

安装步骤

下载mysql最新版:docker pull mysql
运行mysql容器:docker run -d --name mysql01-p 3366:3366 mysql
1. 出现问题：mysql闪退，docker ps 发现没有正在运行的容器
2. 原因：需要未mysql设置账户
  1. 查看错误原因：docker logs mysql01
  2. 卸载刚刚创建的容器：docker rm -f mysql01
  3. 重新启动容器：docker run -d --name mysql01 -e MYSQL_ROOT_PASSWORD=111111 -p 3366:3366 mysql
进入mysql：mysql -u root -p
查看数据库信息：show databases
外部访问数据库
1. 出现问题，nativecat连接mysql一直报错。
2. 原因：我是用的端口映射是3366:3366，外部端口3366没有问题，但是容器内部端口3366并不是mysql的默认端口，mysql的默认端口是3306，所以就需要修改mysql的默认端口。
3. 修改方式：docker安装mysql后如何修改默认端口_aaa6202341的博客-CSDN博客

[root@ZHQ /]# docker run -p 3366:3366 --name mysql01 -e MYSQL_ROOT_PASSWORD=1111111 -d mysql
c3ac777788557126d16be3c05866aa146a15e0e6e8a9f63ce4dc101218eab376
[root@ZHQ /]# docker ps
ConTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                                         NAMES
c3ac77778855        mysql               "docker-entrypoint..."   6 seconds ago       Up 5 seconds        3306/tcp, 33060/tcp, 0.0.0.0:3366->3366/tcp   mysql01
[root@ZHQ /]# docker exec -it mysql01 /bin/bash
root@c3ac77778855:/# ls
bin  boot  dev  docker-entrypoint-initdb.d  entrypoint.sh  etc  home  lib  lib64  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
root@c3ac77778855:/# whereis mysql
mysql: /usr/bin/mysql /usr/lib/mysql /etc/mysql
root@c3ac77778855:/# cd /etc/mysql
root@c3ac77778855:/etc/mysql# ls
conf.d  my.cnf  my.cnf.fallback
root@c3ac77778855:/etc/mysql# mysql -u root -p
Enter password: 
Welcome to the MySQL monitor.  Commands end with ; or g.
Your MySQL connection id is 8
Server version: 8.0.27 MySQL Community Server - GPL

Copyright (c) 2000, 2021, Oracle and/or its affiliates.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or 'h' for help. Type 'c' to clear the current input statement.

mysql> exit

Docker安装ES和kibana（未学）

【狂神说Java】Docker最新超详细版教程通俗易懂_哔哩哔哩_bilibili

端口映射

Docker可视化窗口（不需要使用）

【狂神说Java】Docker最新超详细版教程通俗易懂_哔哩哔哩_bilibili

Docker镜像镜像是什么

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

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

如何获取镜像：

远程仓库下载
别人拷贝
自己制作一个镜像 DockerFile

Docker镜像加载原理

关于docker下载为什么是分层下载的解答！

安装centos 第一层

安装docker 第二层

安装jdk 第三层。

联合文件系统：

UnionFs （联合文件系统）

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

Docker镜像加载原理

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

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

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

平时我们安装进虚拟机的CentOS都是好几个G，为什么Docker这里才200M？

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

虚拟机是分钟级别，容器是秒级！

分层理解

分层的镜像

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

其中id为54的已经存在，就不需要下载，只需要下载没有的。

思考：为什么Docker镜像要采用这种分层的结构呢？

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

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

➜  / docker image inspect redis          
[
    {
        "Id": "sha256:f9b9909726890b00d2098081642edf32e5211b7ab53563929a47f250bcdc1d7c",
        "RepoTags": [
            "redis:latest"
        ],
        "RepoDigests": [
            "redis@sha256:399a9b17b8522e24fbe2fd3b42474d4bb668d3994153c4b5d38c3dafd5903e32"
        ],
        "Parent": "",
        "Comment": "",
        "Created": "2020-05-02T01:40:19.112130797Z",
        "Container": "d30c0bcea88561bc5139821227d2199bb027eeba9083f90c701891b4affce3bc",
        "ContainerConfig": {
            "Hostname": "d30c0bcea885",
            "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.0.1",
                "REDIS_DOWNLOAD_URL=http://download.redis.io/releases/redis-6.0.1.tar.gz",
                "REDIS_DOWNLOAD_SHA=b8756e430479edc162ba9c44dc89ac394316cd482f2dc6b91bcd5fe12593f273"
            ],
            "Cmd": [
                "/bin/sh",
                "-c",
                "#(nop) ",
                "CMD ["redis-server"]"
            ],
            "ArgsEscaped": true,
            "Image": "sha256:704c602fa36f41a6d2d08e49bd2319ccd6915418f545c838416318b3c29811e0",
            "Volumes": {
                "/data": {}
            },
            "WorkingDir": "/data",
            "Entrypoint": [
                "docker-entrypoint.sh"
            ],
            "OnBuild": null,
            "Labels": {}
        },
        "DockerVersion": "18.09.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.0.1",
                "REDIS_DOWNLOAD_URL=http://download.redis.io/releases/redis-6.0.1.tar.gz",
                "REDIS_DOWNLOAD_SHA=b8756e430479edc162ba9c44dc89ac394316cd482f2dc6b91bcd5fe12593f273"
            ],
            "Cmd": [
                "redis-server"
            ],
            "ArgsEscaped": true,
            "Image": "sha256:704c602fa36f41a6d2d08e49bd2319ccd6915418f545c838416318b3c29811e0",
            "Volumes": {
                "/data": {}
            },
            "WorkingDir": "/data",
            "Entrypoint": [
                "docker-entrypoint.sh"
            ],
            "OnBuild": null,
            "Labels": null
        },
        "Architecture": "amd64",
        "Os": "linux",
        "Size": 104101893,
        "VirtualSize": 104101893,
        "GraphDriver": {
            "Data": {
                "LowerDir": "/var/lib/docker/overlay2/adea96bbe6518657dc2d4c6331a807eea70567144abda686588ef6c3bb0d778a/diff:/var/lib/docker/overlay2/66abd822d34dc6446e6bebe73721dfd1dc497c2c8063c43ffb8cf8140e2caeb6/diff:/var/lib/docker/overlay2/d19d24fb6a24801c5fa639c1d979d19f3f17196b3c6dde96d3b69cd2ad07ba8a/diff:/var/lib/docker/overlay2/a1e95aae5e09ca6df4f71b542c86c677b884f5280c1d3e3a1111b13644b221f9/diff:/var/lib/docker/overlay2/cd90f7a9cd0227c1db29ea992e889e4e6af057d9ab2835dd18a67a019c18bab4/diff",
                "MergedDir": "/var/lib/docker/overlay2/afa1de233453b60686a3847854624ef191d7bc317fb01e015b4f06671139fb11/merged",
                "UpperDir": "/var/lib/docker/overlay2/afa1de233453b60686a3847854624ef191d7bc317fb01e015b4f06671139fb11/diff",
                "WorkDir": "/var/lib/docker/overlay2/afa1de233453b60686a3847854624ef191d7bc317fb01e015b4f06671139fb11/work"
            },
            "Name": "overlay2"
        },
        "RootFS": {
            "Type": "layers",
            "Layers": [
                "sha256:c2adabaecedbda0af72b153c6499a0555f3a769d52370469d8f6bd6328af9b13",
                "sha256:744315296a49be711c312dfa1b3a80516116f78c437367ff0bc678da1123e990",
                "sha256:379ef5d5cb402a5538413d7285b21aa58a560882d15f1f553f7868dc4b66afa8",
                "sha256:d00fd460effb7b066760f97447c071492d471c5176d05b8af1751806a1f905f8",
                "sha256:4d0c196331523cfed7bf5bafd616ecb3855256838d850b6f3d5fba911f6c4123",
                "sha256:98b4a6242af2536383425ba2d6de033a510e049d9ca07ff501b95052da76e894"
            ]
        },
        "metadata": {
            "LastTagTime": "0001-01-01T00:00:00Z"
        }
    }
]

问题：这些已下载的层是如何记录的呢？

理解：

所有的 Docker镜像都起始于一个基础镜像层，当进行修改或培加新的内容时，就会在当前镜像层之上，创建新的镜像层。

举一个简单的例子，假如基于 Ubuntu Linux16.04创建一个新的镜像，这就是新镜像的第一层；如果在该镜像中添加 Python包，
就会在基础镜像层之上创建第二个镜像层；如果继续添加一个安全补丁，就会创健第三个镜像层该像当前已经包含3个镜像层，如下图所示（这只是一个用于演示的很简单的例子）。

我们如果再加一个jdk，那么上面就会为我们再加一个第四层

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

上图中的镜像层跟之前图中的略有区別，主要目的是便于展示文件

下图中展示了一个稍微复杂的三层镜像，在外部看来整个镜像只有6个文件，这是因为最上层中的文件7是文件5的一个更新版

文种情況下，上层镜像层中的文件覆盖了底层镜像层中的文件。这样就使得文件的更新版本作为一个新镜像层添加到镜像当中

Docker通过存储引擎（新版本采用快照机制）的方式来实现镜像层堆栈，并保证多镜像层对外展示为统一的文件系统

Linux上可用的存储引撃有AUFS、 Overlay2、 Device Mapper、Btrfs以及ZFS。顾名思义，每种存储引擎都基于 Linux中对应的
件系统或者块设备技术，井且每种存储引擎都有其独有的性能特点。

Docker在 Windows上仅支持 windowsfilter 一种存储引擎，该引擎基于NTFS文件系统之上实现了分层和CoW [1]。

下图展示了与系统显示相同的三层镜像。所有镜像层堆并合井，对外提供统一的视图

特点

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

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

理解：我们pull下来一个镜像之后，假如这个镜像有6层，这6层都是只可读的，并不能修改。当我们运行这个镜像的容器时，我们就可以对它进行操作了，但是我们的操作，都是在这六层之上的容器层（那六层是不会变得），我们操作之后，如果想把我们操作后的容器发给他人，我们可以直接将这7层打包成一个镜像，然后发给别人。

commit镜像

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

实战检测

我们下载tomcat时，运行成功后会出现404，原因时tomcat里面的webapps下面没有任何内容，需要把web apps.dist下的文件拷贝到webapps中。我们可以生成一个这样的镜像，webapps里面包含了启动tomcat的内容，我们再次使用直接创建这个镜像的容器就行，而不需要再从webapps.dist中复制。

# 1、启动一个默认的tomcat
docker run -d -p 8080:8080 tomcat

# 2、发现这个默认的tomcat 是没有webapps应用，官方的镜像默认webapps下面是没有文件的！
docker exec -it 容器id

# 3、拷贝文件进去
cp -r webapps.dist/* webapps
 
# 4、将操作过的容器通过commit调教为一个镜像！我们以后就使用我们修改过的镜像即可，这就是我们自己的一个修改的镜像。
docker commit -m="描述信息" -a="作者" 容器id 目标镜像名:[TAG]
docker commit -m "tomcat add webapp app" -a "zhq"  8ca6316887f1 tomcat10:1.0

如果你想要保存当前容器的状态，就可以通过commit来提交，获得一个镜像，就好比我们我们使用虚拟机的快照。

Docker数据卷问题

docker的理念回顾

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

数据？如果数据都在容器中，那么我们容器删除，数据就会丢失！需求：数据可以持久化

MySQL，容器删除了，删库跑路！需求：MySQL数据可以存储在本地！

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

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

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

使用数据卷

使用方式：直接使用容器挂在 -v

-v, --volume list                    Bind mount a volume
 
docker run -it -v 主机目录:容器内目录  -p 主机端口:容器内端口
将主机的host下的home下的cesh文件与docker容器中的home目录绑定
docker run -it -v /home/ceshi:/home centos /bin/bash

要求：将本机home文件下的test目录与centosdocker镜像中home目录绑定

下载centos镜像 docker pull centos
运行镜像 docker run -it centos /bin/bash
在home目录下创建文件testdata.java： touch testdata.java
退出容器： exit
进行目录映射：docker run -it -v /home/test:/home centos /bin/bash
1. 查看绑定：docker inspect 容器号
在本机中出现目录test，修改文件:vim testdata.java
进入容器中查看效果，发现容器中testdata.java的内容和主机一致。

我们双向绑定后，其中一方进行修改，另一方也会跟着修改。并且，就算停止容器，本机修改后，容器再次启动时也会是最新的数据。可以理解成本机和docker容器共同指向了一个地址。

实战：挂载mysql

创建容器时，直接进行挂载

docker pull mysql:5.7
docker run -d -p 3307:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -r MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7
1. /etc/mysql/conf.d mysql的相关配置文件
2. /var/lib/mysql mysql存储的表信息
此时我们删除容器，容器中的表以及配置信息都还是有的。

具名挂载和匿名挂载

# 匿名挂载   没有指定挂载卷的名称和宿主机的挂载路径
-v 容器内路径!   
docker run -d -P --name nginx01 -v /etc/nginx nginx
 
# 查看所有的volume（数据卷）的情况
➜  ~ docker volume ls    
DRIVER              VOLUME NAME
local               33ae588fae6d34f511a769948f0d3d123c9d45c442ac7728cb85599c2657e50d
local            
# 这里发现，这种就是匿名挂载，我们在 -v只写了容器内的路径，没有写容器外的路劲！
 
# 具名挂载     指定了挂在卷名称juming-nigix，但是没有主机路径
➜  ~ docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx
➜  ~ docker volume ls                  
DRIVER              VOLUME NAME
local               juming-nginx
 
# 通过 -v 卷名：容器内路径
# 查看一下这个卷

# 三种挂载： 匿名挂载、具名挂载、指定路径挂载
-v 容器内路径			#匿名挂载
-v 卷名：容器内路径		#具名挂载
-v /宿主机路径：容器内路径 #指定路径挂载 docker volume ls 是查看不到的

具名挂载的卷信息

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XipAJGlL-1636441487856)(C:UsersDELLAppDataRoamingTyporatypora-user-imagesimage-20211105205808350.png)]

所有的docker容器内的卷，没有指定目录的情况下都是在/var/lib/docker/volumes/xxxx/_data下
如果指定了目录，docker volume ls 是查看不到的

挂载权限设置

# 通过 -v 容器内路径： ro rw 改变读写权限
ro #readonly 只读
rw #readwrite 可读可写  （默认）
docker run -d -P --name nginx05 -v juming:/etc/nginx:ro nginx
docker run -d -P --name nginx05 -v juming:/etc/nginx:rw nginx
 
# ro 只要看到ro就说明这个路径只能通过宿主机来操作，容器内部是无法操作！

数据卷之DockerFile

DockerFile用于构建docker镜像的够建文件。是命令脚本！

创建步骤：

创建一个dockerfile文件。名字随机，建议dockerfile
文件中的内容指令（大写）
每个命令都是一层

镜像脚本

FROM centos

VOLUME [ "volume01","volume02"]

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

FROM centos 以centos为基础
VOLUME [“volume01”,“volume02”]在生成的时候就挂载卷
CMD echo “----end-----” 够建完给我们发的消息 ----end-----
CMD /bin/bash 构建完默认走/bin/bash 控制台

生成镜像

docker build -f /home/docker-test-volume/dockerfile1 -t kuangshen/centos .

镜像脚本地址镜像名 .表示在当前路径下

[root@ZHQ docker-test-volume]# docker build -f /home/docker-test-volume/dockerfile1 -t kuangshen/centos .
Sending build context to Docker daemon 2.048 kB
Step 1/4 : FROM centos   
 ---> 5d0da3dc9764      #  生成镜像
Step 2/4 : VOLUME volume01 volume02
 ---> Running in 0593446e65a0
 ---> 4fdb7fac091d       # 进行挂载
Removing intermediate container 0593446e65a0
Step 3/4 : CMD echo "----end----"
 ---> Running in d9e9d1d5870f
 ---> ae6f9bdab4ff
Removing intermediate container d9e9d1d5870f
Step 4/4 : CMD /bin/bash   
 ---> Running in 6d2d2330b36e
 ---> 4d563c27c3ed
Removing intermediate container 6d2d2330b36e
Successfully built 4d563c27c3ed

此时已经生成我们自己的镜像

启动我们自己的容器

docker run -it 4d563c27c3ed /bin/bash

volume01和volume02我们创建时只指定了容器内路径，因此是匿名挂载。

查看容器信息：docker inspect optimistic_sammet

我们在volume01这个文件夹创建一个文件

[root@bb20967099d9 /]# cd volume01
[root@bb20967099d9 volume01]# touch test.java
[root@bb20967099d9 volume01]# ls
test.java

查看宿主机的挂载目录

这是我们之后经常使用的方式。

假设构建镜像时我们没有挂载卷，那么我们创建容器的时候需要手动镜像挂载 -v 卷名：容器内路径！

数据卷容器

容器内数据共享，多个容器之间数据同步。如多个mysql同步数据。

利用一个父容器，去给别的容器共享数据。

# 创建docker01为父容器
docker run -it --name docker01 kuangshen/centos
# 创建docker02为子容器，继承docker01
docker run -it --name docker02 --volumes-from docker01 kuangshen/centos
# 创建docker03为子容器，继承docker01
docker run -it --name docker03 --volumes-from docker01 kuangshen/centos
# 在docker01下的volume的文件夹下创建docker01file
 touch docker01file
# 发现docker02和docker03中都包含此文件

**说明：**在宿主机中，docker01-03有一个共同的文件存储空间，他们之间实现了数据共享，即使退出或者删除某个容器，这些共享数据还是存储的。如果删除宿主机下的这个文件，那么这些绑定的数据也将消失。

数据卷操作：

查看所有数据卷
1. 方式一：docker volume ls
2. 方式二：进入指定文件夹查看
查看所有不在使用的数据卷，使用–filter dangling=true 过滤不在使用的数据卷
1. docker volume ls --filter dangling=true
创建一个数据卷，可以设置，–name，–path，–mode。也可以不用
1. 拥有一切自动生成的参数: docker volume create
删除数据卷
1. docker volume rm 数据卷名称
删除所有数据卷
1. docker volume ls --filter dangling=true | grep local |awk ‘{print $2}’|xargs docker volume rm
2. 注意：正在使用的不能删除
  1. Error response from daemon: Unable to remove volume, volume still in use: remove 02fdaf3c2190237871d79e86f30df34a00a8d1bf67322c01313b241cc0ece207: volume is in use - [75ee5c98a2b9e67f25d41d8465474dbd25a0a82ec2a05b3a5b368fa79e533c6d]

数据库同步

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

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

注意：两个数据库的端口号不一样。

DockerFile

dockerfile是用来构建docker镜像！是命令参数脚本！

构建步骤：

编写一个dockerfile文件
docker build 构建成一个镜像
docker run 运行镜像
docker push 发布镜像（DockerHub，阿里云镜像仓库）

官方dockerfile

很多官方镜像都像是基础包，很多功能都不具备，我们通常会自己搭建自己的镜像！

官方既然可以制作镜像，能我们一样可以！

我们可以自己制作一个镜像，centos+mysql+jdk+redis等等

DockerFile的构建过程

基础知识：

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

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

Docker镜像逐渐成为企业的交互标准，必须要掌握！

步骤：开发，部署，运维… 缺一不可！

DockerFile：构建文件，定义了一切的步骤，源代码

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

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

DockerFile指令

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

创建一个自己的centos

在home目录下创建dockerfile1文件

编写脚本内容：安装一个centos，包含一些常用指令。

# 编写dockerfile文件
# 编写dockerfile文件
#基础镜像
FROM centos
# 作者信息
MAINTAINER zhq<1427421650@qq.com>
# 构建时创建的环境变量  MYPATH 启动时默认访问的目录
ENV MYPATH /user/local
# 镜像的工作目录
WORKDIR $MYPATH

# 安装常用指令
RUN yum -y install vim
RUN yum -y install net-tools

# 暴露80端口
EXPOSE 80
CMD echo $MYPATH
CMD echo "----end----"
CMD /bin/bash

运行脚本：docker build -f dockerfile1 -t zhq/centos .
3. 通过安装流程我们发现，我们一共10条指令，就分成了10层进行下载。
镜像下载完成
创建镜像的容器并运行
1. docker run -it zhq/centos
安装完毕

查看镜像历史

可以看到镜像的构建过程。

步骤：

docker images
docker history 镜像id

CMD和ENTRYPOINT区别

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

测试CMD

# 编写dockerfile文件
$ vim dockerfile-test-cmd
FROM centos
CMD ["ls","-a"]
# 构建镜像
$ docker build  -f dockerfile-test-cmd -t cmd-test:0.1 .
# 运行镜像
$ docker run cmd-test:0.1
.
..
.dockerenv
bin
dev

# 想追加一个命令  -l 成为ls -al
$ docker run cmd-test:0.1 -l
docker: Error response from daemon: OCI runtime create failed: container_linux.go:349: starting container process caused "exec: "-l":
 executable file not found in $PATH": unknown.
ERRO[0000] error waiting for container: context canceled 
# cmd的情况下 -l 替换了CMD["ls","-l"]。 -l  不是命令所有报错

测试ENTRYPOINT

# 编写dockerfile文件
$ vim dockerfile-test-entrypoint
FROM centos
ENTRYPOINT ["ls","-a"]
# 构建镜像
$ docker build  -f dockerfile-test-entrypoint -t entrypoint-test:0.1
$ docker run entrypoint-test:0.1
.
..
.dockerenv
bin
dev
etc
home
lib
lib64
lost+found ...
# 我们的命令，是直接拼接在我们得ENTRYPOINT命令后面的
$ docker run entrypoint-test:0.1 -l
total 56
drwxr-xr-x   1 root root 4096 May 16 06:32 .
drwxr-xr-x   1 root root 4096 May 16 06:32 ..
-rwxr-xr-x   1 root root    0 May 16 06:32 .dockerenv
lrwxrwxrwx   1 root root    7 May 11  2019 bin -> usr/bin
drwxr-xr-x   5 root root  340 May 16 06:32 dev
drwxr-xr-x   1 root root 4096 May 16 06:32 etc
drwxr-xr-x   2 root root 4096 May 11  2019 home
lrwxrwxrwx   1 root root    7 May 11  2019 lib -> usr/lib
lrwxrwxrwx   1 root root    9 May 11  2019 lib64 -> usr/lib64 ....

实战：Tomcat镜像操作步骤

准备镜像文件 tomcat压缩包（需要jdk环境），jdk压缩包
进入/home/zhq/tomcat
将上述两个压缩包上传到该目录下
1. 上传文件：
  1. 方式1：lrzsz方式上传文件
    1. 安装lrzsz包：yum install -y lrzsz
    2. 上传文件：rz
创建readme.txt说明文档:rouch readme.txt

创建DockerFile脚本: vim Dockerfile

Dockerfile是官方命名，我们也可以自定义，通常使用官方命名即可

FROM centos
MAINTAINER zhq<1427421650@qq.com>

# 拷贝文件  将当前目录下的readme.txt文件拷贝到容器中/usr/local目录
COPY readme.txt /usr/local/readme.txt

# 将压缩包添加到容器中/usr/local目录 (通过ADD 会自动解压我们的压缩包)
ADD apache-tomcat-8.5.72.tar.gz /usr/local/
ADD jdk-8u181-linux-x64.tar.gz /usr/local/

# 安装vim

RUN yum -y install vim

# 进入容器，默认走到/usr/local目录
ENV MYPATH /usr/local
# 工作目录
WORKDIR  /usr/local

# 配置java环境变量
ENV JAVA_HOME /usr/local/jdk1.8.0_181
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
# tomcat配置
ENV CATALINA_HOME /usr/local/apache-tomcat-8.5.72
ENV CATALINA_BASH /usr/local/apache-tomcat-8.5.72
# path配置
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

# 暴漏tomcat的8080端口
EXPOSE 8080

# 启动容器时，就执行tomcat
CMD /usr/local/apache-tomcat-8.5.72/bin/startup.sh && tail -F /usr/local/apache-tomcat-8.5.72/bin/logs/catalina.out

创建镜像： docker build -t mytomcat .
1. 因为我们dockerfile使用的是官方命名Dockerfile，所以构建镜像时会自动读取dockerfile，不需要指定脚本名称（非官方名称运行：$ docker build -f dockerfile-test-entrypoint -t entrypoint-test:0.1）
创建容器
1. docker run -d -p 8080:8080 --name tomcat01 -v /home/zhq/tomcat/test:/usr/local/apache-tomcat-8.5.72/webapps/test -v /home/zhq/tomcat/tomcatlogs/:/usr/local/apache-tomcat-8.5.72/logs mytomcat
3. curl localhost:8080 成功访问到tomcat页面

发布项目

在test目录下创建一个WEB-INF目录，并写一个web.xml文件放入里面



  Welcome to Tomcat
  
     Welcome to Tomcat
  

 index2.jsp
  index.jsp

在test目录下写一个index.jsp文件进行访问

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


life.jsp



Hello Tomcat

进行访问

查看日志

cat catalina.out

[root@ZHQ tomcat]# cd test
[root@ZHQ test]# ls
index.jsp  WEB-INF
[root@ZHQ test]# cd ../
[root@ZHQ tomcat]# cd tomcatlogs
[root@ZHQ tomcatlogs]# ls
catalina.2021-11-06.log  host-manager.2021-11-06.log  localhost_access_log.2021-11-06.txt
catalina.out             localhost.2021-11-06.log     manager.2021-11-06.log
[root@ZHQ tomcatlogs]# cat catalina.out
06-Nov-2021 04:56:06.194 INFO [main] org.apache.catalina.startup.VersionLoggerListener.log Server version name:   Apache Tomcat/8.5.72

发布镜像到dockerhub 发布镜像到阿里云

https://www.bilibili.com/video/BV1og4y1q7M4?p=31

小结

Docker网络 Docker0

# 删除全部容器
$ docker rm -f $(docker ps -aq)

# 删除全部镜像
$ docker rmi -f $(docker images -aq)

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

运行一个tomcat01
1. docker run -d -P --name tomcat01 mytomcat
2. ip addr
3. docker exec tomcat01 ip addr
运行一个tomcat02
1. ip addr
2. docker exec tomcat02 ip addr
  2. ```
  # 我们发现这个容器带来网卡，都是一对对的
  # veth-pair 就是一对的虚拟设备接口，他们都是成对出现的，一端连着协议，一端彼此相连
  # 正因为有这个特性 veth-pair 充当一个桥梁，连接各种虚拟网络设备的
  # OpenStac,Docker容器之间的连接，OVS的连接，都是使用evth-pair技术
```
3. 使用主机ping docker1
  1. ping 172.18.0.3
4. 使用docker1 ping docker2
  1. docker exec -it tomcat01 ping 172.18.0.3
  3. 容器与容器之间和容器与主机之间是可以相互ping通的
5. 网络模型图：容器与容器之间的通信是通过路由进行的，而非直接通信
6. 结论：tomcat01和tomcat02公用一个路由器，docker0。所有的容器不指定网络的情况下，都是docker0路由的，docker会给我们的容器分配一个默认的可用ip。

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

Docker中所有网络接口都是虚拟的，虚拟的转发效率高（内网传递文件）

只要容器删除，对应的网桥一对就没了！

思考：数据库的容器ip切换

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

可以通过link来实现。

使用名字来连通两个容器

使用ip地址ping通（见上方笔记）
使用名字ping通
1. 进行ping：docker exec -it tomcat02 ping tomcat01
  1. 出错：ping: tomcat01: Name or service not known
2. 进行link连接
  1. docker run -d -P --name tomcat03 --link tomcat01 mytomcat
3. 进行ping：docker tomcat03 ping tomcat01
  1. 成功
4. 反向ping（tomcat01 ping tomcat03）：
  1. 出错：ping: tomcat01: Name or service not known
5. 问题：只可以单向ping
双向ping通
1. 查看我们docker中的网络
  1. docker network ls
  2. 查看docker主机
    1. docker network inspect 5bc
    3. 里面包含他的绑定
2. 查看我们的tomcat03的配置
  1. docker inspect tomcat03
  2. 原理剖析，其实他是在我们docker03的本地的host文件中添加了tomcat01的地址映射
    1. 进入查看： docker exec -it tomcat03 cat /etc/hosts
  3. 我们进入tomcat01进行查看配置
    2. 并没有tomcat03的映射。我们可以在其中添加。（没有必要，因为link的方式已经淘汰）
本质探究：–link 就是我们在hosts配置中增加了一个 172.18.0.2 tomcat01 dca6bd83479e，因此当我们访问tomcat01的时候，就相当于访问ip地址 172.18.0.2
因未–link太过麻烦，已经不使用，现在使用自定义网络。不适用docker0
1. docker0问题：不支持容器名连接访问。

自定义网络

**容器互联：**容器与容器之间进行连接。

查看所有的docker网络：

网络模式

bridge：桥接（默认，自己创建也是用bridge 模式）

none：不配置网络

host：和宿主机共享网络

container：容器网络联通（容器之间可以直接互联，局限很大，很少用）

测试

查看网络的相关命令

docker network ls

[root@ZHQ tomcat]# docker network ls
NETWORK ID          NAME                   DRIVER              SCOPE
5bc56f92ce56        bridge                 bridge              local
5be40764e6dc        docker_smart_network   bridge              local
81f37c0badc9        host                   host                local
cf4142c5dd51        none                   null                local

创建docker容器
1. 使用docker0网络
```
docker run -d -P --name tomcat01 tomcat
等价于 => 
docker run -d -P --name tomcat01 --net bridge tomcat
# 我们直接启动的命令 --net bridge,而这个就是我们得docker0
# bridge就是docker0
# docker0，特点：默认，域名不能访问。 --link可以打通连接，但是很麻烦！
```
2. 使用自定义网络
```
# 我们可以 自定义一个网络
$ docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
--driver 设置连接方式
--subnet 子网
--gateway 网关
mynet 自定义网络名称
```
  2. docker network inspect mynet;
3. 使用自定义网络启动tomcat
  1. docker run -d -P --name tomcat-net-01 --net mynet mytomcat
  2. docker run -d -P --name tomcat-net-02 --net mynet mytomcat
  3. 查看 mynetwork
    1. docker network inspect mynet;
    2. 我们创建的两个容器
4. 在自定义网络下，进行容器ping
  1. docker exec tomcat-net-02 ping tomcat-net-01
  3. docker exec tomcat-net-01 ping tomcat-net-02
    1. [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ob5M9WQE-1636441487917)(C:UsersDELLAppDataRoamingTyporatypora-user-imagesimage-20211106224418925.png)]
  4. 我们发现，容器是可以通过名称互相ping通的。推荐使用。
5. 好处：
  1. redis -不同的集群使用不同的网络，保证集群是安全和健康的
  2. mysql-不同的集群使用不同的网络，保证集群是安全和健康的
6. 问题：假如我们的mysql服务和redis服务在不同的网络区段下，能否进行相互连接呢？
  2. 使用网络联通解决。

网络联通

在docker0上创建tomcat01,tomcat02，在mynet上创建两个tomcat-net-01,tomcat-net-02

docker run -d -P --name tomcat01 tomcat
docker run -d -P --name tomcat02 tomcat
docker run -d -P --name tomcat-net-01 --net mynet mytomcat
docker run -d -P --name tomcat-net-02 --net mynet mytomcat

让 tomcat01 ping tomcat-net-02

[root@ZHQ tomcat]# docker exec  tomcat01 ping tomcat-net-01
rpc error: code = 2 desc = oci runtime error: exec failed: container_linux.go:235: starting container process caused "exec: "ping": executable file not found in $PATH"

失败：两个容器并没有联通。docker0和mynet不在同一个网路区段，不可能联通。

虽然两个网络区段不可能联通，但是却可以让一个容器联通另一个网络区段

让容器tomcat01联通mynet网络

docker network COMMAND

Usage:  docker network COMMAND

Manage networks

Options:
      --help   Print usage

Commands:
  connect     Connect a container to a network
  create      Create a network
  disconnect  Disconnect a container from a network
  inspect     Display detailed information on one or more networks
  ls          List networks
  prune       Remove all unused networks
  rm          Remove one or more networks

Run 'docker network COMMAND --help' for more information on a command.

docker network connect --help

Usage:  docker network connect [OPTIONS] NETWORK ConTAINER

Connect a container to a network

Options:
      --alias stringSlice           Add network-scoped alias for the container
      --help                        Print usage
      --ip string                   IP Address
      --ip6 string                  IPv6 Address
      --link list                   Add link to another container (default [])
      --link-local-ip stringSlice   Add a link-local address for the container

将mynet 与 tomcat01 联通
1. docker network connect mynet tomcat01
2. tomcat-net-01 ping tomcat01
  1. docker exec -it tomcat-net-01 ping tomcat01
3. 反向ping tomcat01 ping tomcat-net-01(不可以)
  1. docker exec -it tomcat01 ping tomcat-net-01
4. tomcat-net-01 ping tomcat02（没有联通，所以不行）
  1. docker exec -it tomcat-net-01 ping tomcat02

结论：假设要跨网络操作别人，就需要使用docker network connect 连通！

搭建redis集群（未学）

原生redis集群：【狂神说Java】Redis最新超详细版教程通俗易懂_哔哩哔哩_bilibili

docker创建集群：【狂神说Java】Docker最新超详细版教程通俗易懂_哔哩哔哩_bilibili

实现（3个主机，3个从机，主机挂掉之后，进行相应的操作可以直接在从机上进行）高可用。

Docker部署SpringBoot项目

部署流程

打包 mvn package
黑窗口运行jar包
1. 进入到jar包所在目录打开黑窗口
2. 执行：java -jar smpe-system-1.0.0-RELEASE.jar
3. 成功
使用docker 部署
1. /home/zhq/spring
2. 上传jar包
3. 运行Dockerfile文件
```
FROM java:8
COPY *.jar /app.jar
CMD ["--server.port=8080"]
EXPOSE 8080
ENTRYPOINT ["java","-jar","app.jar"]
```
4. docker build -t safeedu .
1. 此时我们的镜像已经打包完成，之后直接发给别人即可。别人拿到下载即可运行环境。
2. docker run -d -P --name safeedu safeedu
3. 访问成功

问题汇总 1. docker卸载后，镜像还存在 2. docker run 和 docker start的区别

docker run 只在第一次运行时使用，将镜像放到容器中，以后再次启动这个容器时，只需要使用命令docker start即可。docker run相当于执行了两步操作：将镜像放入容器中（docker create）,然后将容器启动，使之变成运行时容器（docker start）。

而docker start的作用是，重新启动已存在的镜像。也就是说，如果使用这个命令，我们必须事先知道这个容器的ID，或者这个容器的名字，我们可以使用docker ps找到这个容器的信息

3. mysql安装后，外部无法访问

docker run -d --name mysql01 -e MYSQL_ROOT_PASSWORD=111111 -p 3366:3366 mysql

出现问题，nativecat连接mysql一直报错。
1. 原因：我是用的端口映射是3366:3366，外部端口3366没有问题，但是容器内部端口3366并不是mysql的默认端口，mysql的默认端口是3306，所以就需要修改mysql的默认端口。
2. 修改方式：docker安装mysql后如何修改默认端口_aaa6202341的博客-CSDN博客

4. ls ls-a ls -l ls -al区别

ls 查看所有未隐藏命令
ls -a 查看所有命令
ls -l 查看所有未隐藏命令以及他们的信息（创建时间等）
ls -al 查看所有命令以及他们的信息

5. 容器启动闪退问题

有时候，当我们docker run -d 容器时，docker ps -a 显示这个容器闪退。主要原因是：当我们使用docker run -d启动容器时，-d设置的是后台运行，如果后台运行的话，容器中的服务要保证开启，否则的话docker就会认为该容器没有运行，就会关掉该容器。

我们使用mysql进行测试

docker run -d --name mysql01 -e MYSQL_ROOT_PASSWORD=111111 -p 3306:3306 mysql
docker exec -it mysql01 /bash/bin
mysql -u root -p 并输入密码,此时我们就进入了数据库中。说明我们创建docker容器时，mysql服务就已经自动开启了。
此时我们停掉mysql服务（注意，是停掉mysql服务，并不是docker容器）
停止指令：mysqladmin -uroot -p shutdown
Enter password:
此时我们使用docker ps会发现，mysql所在的容器docker01 已经被自动停止掉了（我们并没有手动关闭docker，而是关闭了docker中的mysql服务）。
1. 问题：此时我如果重新启动docker容器，会显示启动失败，原因是需要设置密码。
  1. 针对问题，目前没有找到启动原容器的方案，重新docker run 一下。
2. 如果是自定义的dockerfile出现上述问题，可能是dockerfile中的启动命令有误。

6. 容器创建后如何进行文件挂载

(60条消息) 修改docker容器的挂载目录_jun-CSDN博客

7.文件挂载失败

执行将nginx的default.conf文件挂载到宿主机的default.cnof文件

docker run -d -P --privileged=true --name nginx15 -v /home/zhq/web/nginx15/default.conf:/etc/nginx/conf.d/default.conf nginx

报错
```
"container init exited prematurely".
```
原因：docker 禁止用主机上不存在的文件挂载到container中已经存在的文件

Docker volume 挂载时文件或文件夹不存在_weixin_33953249的博客-CSDN博客

8.为什么mysql挂载后，容器内挂载的资源没有消失，而其他容器挂载后，容器内资源消息

mysql挂载

[root@ZHQ /]# docker run -d -p 3307:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql
22df4a2635ff2859e40199355a4a770824ac1dc33b9a492b554b0968f8f62e58
[root@ZHQ ~]# docker exec -t mysql01 bash
root@22df4a2635ff:/# ls
^H^H^H^C
[root@ZHQ ~]# docker exec -it mysql01 /bin/bash
root@22df4a2635ff:/# ls
bin   dev                         entrypoint.sh  home  lib64  mnt  proc  run   srv  tmp  var
boot  docker-entrypoint-initdb.d  etc            lib   media  opt  root  sbin  sys  usr
root@22df4a2635ff:/# cd var 
root@22df4a2635ff:/var# ls
backups  cache  lib  local  lock  log  mail  opt  run  spool  tmp
root@22df4a2635ff:/var# cd lib
root@22df4a2635ff:/var/lib# ls
apt  dpkg  mecab  misc  mysql  pam  systemd
root@22df4a2635ff:/var/lib# cd mysql
root@22df4a2635ff:/var/lib/mysql# ls     # 默认的配置没有被fu'gai
'#ib_16384_0.dblwr'   binlog.000001   ca.pem            ib_logfile0   mysql                public_key.pem    undo_001
'#ib_16384_1.dblwr'   binlog.000002   client-cert.pem   ib_logfile1   mysql.ibd            server-cert.pem   undo_002
'#innodb_temp'        binlog.index    client-key.pem    ibdata1       performance_schema   server-key.pem
 auto.cnf             ca-key.pem      ib_buffer_pool    ibtmp1        private_key.pem      sys

nginx挂载

[root@ZHQ ~]#  docker run -d -P --privileged=true --name nginx30 -v /home/zhq/web/nginx30/default:/etc/nginx/conf.d nginx
ba374c6c870dd97b8224d78696b9223156e3a4500748a31f859144c31b1f6b75
[root@ZHQ ~]# docker exec -it nginx30 /bin/bash
root@ba374c6c870d:/# ls
bin   dev                  docker-entrypoint.sh  home  lib64  mnt  proc  run   srv  tmp  var
boot  docker-entrypoint.d  etc                   lib   media  opt  root  sbin  sys  usr
root@ba374c6c870d:/# cd /etc/nginx
root@ba374c6c870d:/etc/nginx# ls
conf.d  fastcgi_params  mime.types  modules  nginx.conf  scgi_params  uwsgi_params
root@ba374c6c870d:/etc/nginx# cd conf.d
root@ba374c6c870d:/etc/nginx/conf.d# ls
root@ba374c6c870d:/etc/nginx/conf.d#        # 默认的配置被覆盖

8.为什么不能直接访问服务器上面的文件，而必须使用代理。

服务器的资源是通过是http访问的，而本地的HTML文件在浏览器中是通过file协议打开的，他们之间不能跨域访问。

如果需要访问服务器上面的静态资源，需要使用文件传输协议：

中文释义：本地文件传输协议

注解：File协议主要用于访问本地计算机中的文件，就如同在Windows资源管理器中打开文件一样。

windows主机：

file:///G:/ComputerStudy/%E8%BD%AF%E8%80%83/%E8%BD%AF%E8%80%83%E8%B5%84%E6%BA%90/4-%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84.pdf

服务器:

curl file:home/zhq/web/index.html

常用命令

linux命令
1. 系统内核：uname -r
2. 系统版本：cat /etc/os-release
3. 当前目录：pwd
4. 创建目录：mkdir 文件夹名
5. 删除目录：rmdir 文件夹名
6. 创建文件：touch 文件名
7. 查看文件：cat 文件名称
8. 创建/修改文件：vim 文件名称
9. 将一个名为abc的文件重命名为1234：mv abc 1234
10. 上传文件：
  1. 方式1：lrzsz方式上传文件
    1. 安装lrzsz包：yum install -y lrzsz
    2. 上传文件：rz
  2. 方式2：ftp方式上传文件
    1. https://www.linuxprobe.com/windows-linux-ftp.html
docker命令
1. 安装卸载命令
  1. 卸载docker:
```
sudo yum remove docker 
                  docker-client 
                  docker-client-latest 
                  docker-common 
                  docker-latest 
                  docker-latest-logrotate 
                  docker-logrotate 
                  docker-engine
```
  1. 安装docker：yum install docker
  2. 查看docker版本： docker -v
  3. 删除docker安装包：yum remove docker-ce
  4. 删除静像、容器、配置文件：rm -rf /var/lib/docker
  5. 删除所有容器：docker rm -f $(docker ps -aq)
  6. 卸载docker：(61条消息) docker 彻底卸载_无恋-zx的博客-CSDN博客_docker卸载干净
2. 其他命令
  1. docker系统信息：docker info
  2. 帮助命令：docker --help
3. 操作命令
  1. 开机启动docker：systemctl enable docker
  2. 启动docker：systemctl start docker
  3. 停止docker：systemctl stop docker
  4. 创建容器：
  5. 进入容器：
  6. 启动容器：docker start 容器名称
  7. 关闭容器：docker stop 容器名称
  8. 退出容器（后台运行）：ctrl+p+q
  9. 退出容器（退出并关闭）：exit
4. 查看指令
  1. 查看已下载的docker镜像：docker images
  2. 搜索镜像：docker search mysql/redis
5. 指令后缀
  1. -d 后台运行
  2. -p 端口映射
  3. -P 随机端口映射（大写P）
  4. -v 卷挂载
  5. -e 环境配置
6. 获取容器的ip地址：(60条消息) 如何获取 docker 容器(container)的 ip 地址_sannerlittle的博客-CSDN博客_docker 获取容器ip
docker 安装vim (60条消息) docker容器中安装vim_人在码途-CSDN博客_docker vim

Docker基础学习--教你玩转Docker

Hello Tomcat

Linux相关栏目本月热门文章