Docker概述
Docker历史
Docker能干嘛
Docker安装
Docker的常用命令
Docker镜像讲解
容器数据卷
DockerFile
Docker网络

Docker学习

Docker概述
Docker安装
Docker命令
- 镜像命令
- 容器命令
- 操作命令
- 。。。
Docker镜像
容器数据卷
DockerFile
Docker网络原理
IDEA整合Docker
Docker Compose
Docker Swarm
CI\CD jenkins

Docker概述

Docker为什么出现？
一款产品开发—-上线两套环境应用环境应用配置
开发——-运维问题：我在我的电脑可以运行版本更新，导致服务不可用对于运维，考验比较大
环境配置十分麻烦，每一个机器都要部署环境（集群Redis、ES、Hadoop。。。）费时费力
发布一个项目（jar + （Redis MYSQL jdk ES）），项目能不能带上环境打包
之前在服务器配置一个应用的环境 Redis MySQL jdk ES Hadoop ，配置超麻烦，不饿能跨平台
Windows 最后发布到linux
传统：开发jar，运维来做
现在：开发打包部署上线，一套流程

java—— apk——-发布（应用商店）——使用apk——下载安装即可
java——jar(环境)——-打包项目带上环境（镜像）——（Docker仓库：商店）—-下载发布的镜像—-直接运行即可

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

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

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

Docker历史

Docker是基于GO语言开发的！开源项目！
官网：https://www.docker.com/

文档地址：https://docs.docker.com/ Docker的文档是超级详细的！
仓库地址：https://hub.docker.com/

Docker能干嘛

之前的虚拟机技术

虚拟机技术缺点：
1.资源占用十分多
2.冗余步骤很多
3.启动很慢！

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

比较Docker和虚拟机的不同：

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

DevOps（开发、运维）

应用更快速的交付和部署

传统：一堆帮助文档，安装程序
Docker：打爆镜像发布测试，一件运行

更便捷的升级和扩缩容

使用了Docker之后，部署应用和搭积木一样
项目打包为一个镜像，扩展，服务器A，服务器B

更简单的系统运维

在容器化之后，我们的开发、测试环境都是高度一致的

更高效的计算资源利用

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

Docker安装

Docker的基本组成

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

安装Docker

环境准备
1.需要一点Linux基础
2.centos7
3.xshell连接远程服务器进行操作

环境查看

#系统内核是3.10以上的
[root@fxh /]# uname -r
3.10.0-957.21.3.el7.x86_64

#系统版本 
[root@fxh /]# 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-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine 
#2.需要的安装包
yum install -y yum-utils
#3.设置镜像的仓库
yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo    #默认是国外的，很慢
yum-config-manager \
    --add-repo \
        http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo #推荐使用阿里云的，十分快速
#更新yum软件包索引
[root@fxh /]# yum makecache fast
#4.安装docker相关内容   docker-ce 社区版  docker-ee 企业版
yum install docker-ce docker-ce-cli containerd.io
#5.启动docker
systemctl start docker 
#6.使用docker version 判断是否启动成功
[root@fxh /]# docker version
Client: Docker Engine - Community
 Version:           19.03.12
 API version:       1.40
 Go version:        go1.13.10
 Git commit:        48a66213fe
 Built:             Mon Jun 22 15:46:54 2020
 OS/Arch:           linux/amd64
 Experimental:      false
Server: Docker Engine - Community
 Engine:
  Version:          19.03.12
  API version:      1.40 (minimum version 1.12)
  Go version:       go1.13.10
  Git commit:       48a66213fe
  Built:            Mon Jun 22 15:45:28 2020
  OS/Arch:          linux/amd64
  Experimental:     false
 containerd:
  Version:          1.2.13
  GitCommit:        7ad184331fa3e55e52b890ea95e65ba581ae3429
 runc:
  Version:          1.0.0-rc10
  GitCommit:        dc9208a3303feef5b3839f4323d9beb36df0a9dd
 docker-init:
  Version:          0.18.0
  GitCommit:        fec3683
#7.hello-world
docker run hello-world

#8.查看一下下载的这个 hello-world 镜像
[root@fxh /]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
hello-world         latest              bf756fb1ae65        7 months ago        13.3kB

了解：卸载docker

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

阿里云镜像加速

1.登录阿里云找到容器镜像服务
2.找到镜像加速地址

3.配置使用

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

回顾Helloworld流程

底层原理

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

Docker为什么比VM快
1.Docker有着比虚拟机更少的抽象层
2.docker利用的是宿主机的内核，vm需要的guest os

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

Docker的常用命令

帮助命令

docker version     #显示docker的版本信息
docker info        #显示docker的系统信息，包括镜像和容器数量  运行时出现warning   解决办法：https://blog.csdn.net/qq_41866516/article/details/98474027
docker 命令 --help   #帮助命令

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

镜像命令

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

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

docker search 搜索镜像

[root@fxh /]# docker search mysql
NAME                              DESCRIPTION                                     STARS               OFFICIAL            AUTOMATED
mysql                             MySQL is a widely used, open-source relation…   9883                [OK]                
mariadb                           MariaDB is a community-developed fork of MyS…   3615                [OK]                
mysql/mysql-server                Optimized MySQL Server Docker images. Create…   721                                     [OK]
#可选项  通过搜藏来过滤
-filter=STARS=3000   #搜索出来的镜像就是STARS大于3000的

docker pull 下载镜像

#下载镜像  docker pull 镜像名[:tag]
[root@fxh /]# docker pull mysql
Using default tag: latest   #如果不屑tag，默认就是latest
latest: Pulling from library/mysql
bf5952930446: Pull complete         #分层下载  docker images的核心 联合文件系统
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@fxh /]# 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

docker rmi 删除镜像

[root@fxh /]# docker rmi -f 容器id   #删除指定的镜像
[root@fxh /]# docker rmi -f 容器id 容器id 容器id 容器id 容器id #删除多个镜像
 [root@fxh /]# 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@fxh /]# docker run -it centos /bin/bash
[root@14b2d26d66c8 /]# 
[root@14b2d26d66c8 /]# ls   #查看容器内的centos
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
[root@14b2d26d66c8 /]# exit   #从容器中退回主机
exit
[root@fxh /]# ls
bin  boot  data  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var

列出所有运行的程序

#docker ps 命令
     #列出当前正在运行的程序
-a   #列出当前正在运行的程序+带出历史运行过的程序
-n=？#显示最近创建的容器
-q   #只显示容器的编号
[root@fxh /]# docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
[root@fxh /]# docker ps -a
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                     PORTS               NAMES
14b2d26d66c8        centos              "/bin/bash"         5 minutes ago       Exited (0) 2 minutes ago                       tender_raman
25e036739f49        bf756fb1ae65        "/hello"            13 hours ago        Exited (0) 13 hours ago                        quirky_easley
[root@fxh /]#

退出容器

exit          #容器停止并退出
ctrl+P+Q  #容器不停止退出

删除容器

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

启动和停止容器的操作

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

常用其他命令

后台启动容器

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

查看日志

docker logs -f -t --tail  容器   ，  没有日志
#自己编写一段shell脚本
[root@fxh /]# docker dun -d centos /bin/sh -c  "while true;do echo fan;sleep 1;done"
#显示日志
-tf    #显示日志
--tail [number] #要显示的日志条数
[root@fxh /]# docker logs -ft --tail 10 [id]

查看容器中进程信息 ps

#命令docker top 容器id
[root@fxh ~]# docker top 9cb705efcc57
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                8798                8782                0                   13:41               ?                   00:00:00            /bin/bash

产看镜像的源数据

#命令
docker inspect 容器id
#测试
[root@fxh ~]# docker inspect 9cb705efcc57
[
    {
        "Id": "9cb705efcc57f3cc3996773438a390e7de6b733a59f17cfe12ac12231f7269e0",
        "Created": "2020-08-26T05:41:50.753888334Z",
        "Path": "/bin/bash",
        "Args": [],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 8798,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2020-08-26T05:41:51.024807922Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:0d120b6ccaa8c5e149176798b3501d4dd1885f961922497cd0abef155c869566",
        "ResolvConfPath": "/var/lib/docker/containers/9cb705efcc57f3cc3996773438a390e7de6b733a59f17cfe12ac12231f7269e0/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/9cb705efcc57f3cc3996773438a390e7de6b733a59f17cfe12ac12231f7269e0/hostname",
        "HostsPath": "/var/lib/docker/containers/9cb705efcc57f3cc3996773438a390e7de6b733a59f17cfe12ac12231f7269e0/hosts",
        "LogPath": "/var/lib/docker/containers/9cb705efcc57f3cc3996773438a390e7de6b733a59f17cfe12ac12231f7269e0/9cb705efcc57f3cc3996773438a390e7de6b733a59f17cfe12ac12231f7269e0-json.log",
        "Name": "/dazzling_agnesi",
        "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/6115af567ada6f9457f0ec52c4f72cf16f7c2f28cfb76624963584472577b2f4-init/diff:/var/lib/docker/overlay2/c6af42b6f5619a1eacbec0178f632dbed1e7354f7b55f4605681f68ad2dcff9f/diff",
                "MergedDir": "/var/lib/docker/overlay2/6115af567ada6f9457f0ec52c4f72cf16f7c2f28cfb76624963584472577b2f4/merged",
                "UpperDir": "/var/lib/docker/overlay2/6115af567ada6f9457f0ec52c4f72cf16f7c2f28cfb76624963584472577b2f4/diff",
                "WorkDir": "/var/lib/docker/overlay2/6115af567ada6f9457f0ec52c4f72cf16f7c2f28cfb76624963584472577b2f4/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [],
        "Config": {
            "Hostname": "9cb705efcc57",
            "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": "35d47b54c0038188fbf48578b0953a7609a587d3c1b0abb5f476fda2a9010605",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {},
            "SandboxKey": "/var/run/docker/netns/35d47b54c003",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "fb71cdefa8800bf82f627c49bf31b05217a8291d34f74e55cfaba86690073792",
            "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": "313ad2b43e1a7c5accb9918c3140aff29dbda5a00432da72fb7db8a3885beff4",
                    "EndpointID": "fb71cdefa8800bf82f627c49bf31b05217a8291d34f74e55cfaba86690073792",
                    "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@fxh ~]#

进入当前正在运行的容器

#我通常容器都是使用后台运行的，需要进入容器，修改配置
#命令
docker exec -it 容器id bashShell
#测试
[root@fxh ~]# docker ps 
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
9cb705efcc57        centos              "/bin/bash"         42 minutes ago      Up 42 minutes                           dazzling_agnesi
[root@fxh ~]# docker exec -it 9cb705efcc57 /bin/bash
[root@9cb705efcc57 /]# ls    
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
[root@9cb705efcc57 /]# ps -ef
UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 05:41 pts/0    00:00:00 /bin/bash
root        14     0  0 06:25 pts/1    00:00:00 /bin/bash
root        28    14  0 06:25 pts/1    00:00:00 ps -ef
#方式二
docker attach 容器id
#测试
[root@fxh ~]# docker attach 9cb705efcc57
正在执行当前的代码...
#docker exec    #进入容器后开启一个新的终端，可以在里面操作(常用)
#docker attach  #进入容器正在执行的终端，不会启动新的 进程！

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

docker cp 容器id: 容器内路径   目的主机路径
[root@fxh ~]# docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
9cb705efcc57        centos              "/bin/bash"         55 minutes ago      Up 55 minutes                           dazzling_agnesi
#进入当前容器内部
[root@fxh ~]# docker attach 9cb705efcc57
[root@9cb705efcc57 /]# ls
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
[root@9cb705efcc57 /]# cd /home/
[root@9cb705efcc57 home]# ls
#在容器内新建一个文件
[root@9cb705efcc57 home]# touch test.java 
[root@9cb705efcc57 home]# ls
test.java
[root@9cb705efcc57 home]# exit
exit
[root@fxh ~]# cd /home/
#查看当前主机目录下文件
[root@fxh home]# ls
#将这个文件拷贝到主机上
[root@fxh home]# docker cp 9cb705efcc57:/home/test.java /home
[root@fxh home]# ls
test.java
[root@fxh home]# 
#拷贝是一个手动过程，未来我们使用 -v 卷的技术，可以实现，自动同步

小结

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

作业练习

作业一：Docker安装Nginx

#1.搜索镜像   建议去https://hub.docker.com上搜索，可以看到详细信息、帮助文档
[root@fxh ~]# docker search nginx
#2.拉取镜像
[root@fxh ~]# docker pull nginx
#3.运行测试
[root@fxh ~]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
nginx               latest              4bb46517cac3        12 days ago         133MB
centos              latest              0d120b6ccaa8        2 weeks ago         215MB
#  -d  后台运行
#  --name 给容器命名
#  -p 宿主机端口:容器内部端口
[root@fxh ~]# docker run -d --name nginx01 -p 3340:80 nginx
54636284d9d67928cc43f70f8f7397bc1407adeff97db230bb0b1a9362e03321
[root@fxh ~]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                  NAMES
54636284d9d6        nginx               "/docker-entrypoint.…"   8 seconds ago       Up 8 seconds        0.0.0.0:3340->80/tcp   nginx01
[root@fxh ~]# curl localhost:3340
#进入容器
[root@fxh ~]# docker exec -it nginx01 /bin/bash
root@54636284d9d6:/# ls
bin  boot  dev    docker-entrypoint.d  docker-entrypoint.sh  etc    home  lib  lib64  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
root@54636284d9d6:/# whereis nginx
nginx: /usr/sbin/nginx /usr/lib/nginx /etc/nginx /usr/share/nginx
root@54636284d9d6:/# cd /etc/nginx/
root@54636284d9d6:/etc/nginx# ls
conf.d    fastcgi_params    koi-utf  koi-win  mime.types  modules  nginx.conf  scgi_params    uwsgi_params  win-utf
root@54636284d9d6:/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
#测试访问没有问题
#进入容器
[root@fxh /]# docker exec -it tomcat01 /bin/bash
#发现问题：1.linux命令少了  2.没有webapps    阿里云镜像的原因。默认是最小的镜像，所有不必要的都剔除掉。
#保证最小可运行的环境

思考问题：我们以后要部署项目，如果每次都要进入容器是不是十分麻烦？若是可以在容器外部提供一个映射路径，webapps。我们在外部防止项目，就自动同步到内部就好了

作业三：部署es+kibana

#es 暴露的接口很多
#es 十分的耗内存
#es 的数据一般需要防止到安全目录！ 挂载
#下载启动 elasticsearch
docker run -d --name elasticsearch  -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.9.0
#启动了 linux就卡住了   docker stats  查看cpu的状态 
#es 是十分耗内存的，1点多g
#查看docker stats 
#测试一下es是否成功
[root@fxh /]# curl localhost:9200
{
    "name" : ...
  ...
  ... 
}
#赶紧关闭，增加内存的限制

#赶紧关闭，增加内存的限制,修改配置文件  -e环境配置修改
docker run -d --name elasticsearch  -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmsx512m" elasticsearch:7.9.0

使用kibana连接es 思考网络如何才能连接过去

可视化

protainer(先用这个)

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

Rancher(CI/CD再用)

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

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

访问测试：外网:8088
通过它来访问

选择本地的

进入之后的面板

可视化面板平时基本不会使用，测试即可

Docker镜像讲解

镜像是什么

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

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

从远程仓库下载
朋友拷贝
自己制作一个镜像DockerFile
Docker镜像加载原理
UnionFS（联合文件系统）
下载时看到的一层一层的就是这个
UnionFS（联合文件系统）：Union文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(ubite serval directories into a single virtual filesystem)。Union文件系统时Docker镜像的基础，镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作各种具体的应用镜像。

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

Docker镜像加载原理
docker镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFS。
bootfs(boot file system) 主要包含bootloader和kernel，bootloader主要是引导加载kernel，Linux刚启动时就会加载bootfs文件系统，在Docker镜像的最底层时bootfs。这一层与我们典型的Linux/Unix系统时一样的，包含boot加载器和内核。当boot加载完成之后整个内核就在内存中了，此时内核的使用权已由bootfs转交给内核，此时系统也会卸载bootfs。
rootfs(root file system)，在bootfs之上，包含的就是典型Linux系统中的/dev,/proc,/bin,/etc等标准目录和文件。rootfs就是各种不同的操作系统发行版，比如Ubuntu，centos等。

平时安装的虚拟机的Centos都是几个g，而docker这边几百M。

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

分层理解

分层的镜像
下载镜像都是一层一层的在下载。

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


{
//...
"RootFS": {
            "Type": "layers",
            "Layers": [
                "sha256:d0f104dc0a1f9c744b65b23b3fd4d4d3236b4656e67f776fe13f8ad8423b955c",
                "sha256:09b6608896c0a00497d9e9c1b045f0c906203555740dee64473db943244059c2",
                "sha256:ab0653e928a7c1d4b2f1c8e527d735aa0ea8dcb8c50e7cefc7680cf09cf6f985",
                "sha256:57094a432b39be6fc8a3f533567e10c354705eec37e4f7a8b5a7041a4ec63fa2",
                "sha256:1b80269d908f58520f9f3f00d75e65907eafa0f5143d5fe2b6cafcc30b32bc83",
                "sha256:1bd654b55bb49880160a60ad3a75c4b14254656229d535e943d8fb88124f6177"
            ]
        },
        "Metadata": {
            "LastTagTime": "0001-01-01T00:00:00Z"
        }
    }
]

理解：
所有的docker镜像都起始于一个基础镜像，当进行修改或增加新的内容时，就会在当前镜像之上，创建新的镜像层。举例，假如基于Ubuntu Linux16.04创建一个新的镜像，这就是新镜像的第一层；如果在该镜像中添加Python包，就会在基础镜像层之上创建第二个镜像层；如果继续添加一个安全补丁，就会创建第三个镜像层。
该镜像当前已经包含3个镜像层，如下图所示：

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

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

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

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

如何提交一个自己的镜像

commit镜像

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

实战测试

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

学习方式说明：理解概念，然后一定要实践，最后实践和理论结合搞定知识点

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

到这里算是入门docker！

容器数据卷

什么是容器数据卷

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

          ![image.png](https://cdn.nlark.com/yuque/0/2020/png/651457/1598683235869-788c012d-251e-480e-99ed-d6a872bc7b3d.png#align=left&display=inline&height=214&margin=%5Bobject%20Object%5D&name=image.png&originHeight=427&originWidth=1016&size=81344&status=done&style=none&width=508)<br />**总结一句话：容器的持久化和同步操作!容器间也是可以数据共享的！**

使用数据卷

方式一：直接用命令挂在： -v

docker run -it -v 主机目录: 容器内目录
#测试
[root@fxh home]# docker run -it -v /home/ceshi:/home centos /bin/bash
#启动起来的时候我们可以通过docker inspect 容器id查看详细信息

               ![image.png](https://cdn.nlark.com/yuque/0/2020/png/651457/1598684829097-47e23b4d-8a50-46ce-b875-ff8f9ca461c8.png#align=left&display=inline&height=205&margin=%5Bobject%20Object%5D&name=image.png&originHeight=410&originWidth=1095&size=175687&status=done&style=none&width=547.5)<br />测试文件的同步

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

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

实战：安装MySQL

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

#获取镜像
[root@fxh home]# docker pull mysql:5.7
#运行容器，需要做数据挂载   安装启动mysql，需要配置密码的，这是注意点
#启动自己的
-d 后台运行
-p 端口映射
-v 数据卷挂载
-e 环境配置
--name 容器名
#官方测试：docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag
[root@fxh home]# 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
#启动成功后，在本地使用数据库软件测试连接
#本地数据库软件--连接到服务器的3310----3310和容器内的3306映射，这个时候就可以连接上
#在本地创建一个数据库，查看映射的路径是否ok

假设：将容器删除

发现，挂载到本地的数据卷依然没有消失，这就实现了容器数据持久化的功能！

具名和匿名挂载

#匿名挂载
-V 容器内路径
docker run -d -p --name nginx01 -V /etc/nginx nginx
# 查看所有的volume（卷）的情况
[root@fxh home]# docker volume ls[root@fxh /]# docker volume ls
DRIVER              VOLUME NAME
local               3890c67d4b2fd29c2273be0c2c2d476839fb5467c6298b8e8eae9a846aeddc61
#这里发现，这种就是匿名函数，我们在 -V只写了容器内的路径，没有写容器外的路径
#具名挂载
[root@fxh home]# docker run -d -p --name nginx02  -v juming-nginx:/etc/nginx nginx
DRIVER              VOLUME NAME
local               3890c67d4b2fd29c2273be0c2c2d476839fb5467c6298b8e8eae9a846aeddc61
local               3890c67d4b2fd29c2273be0c2c2d476839fb5467c6298b8e8eae9a846aeddc61
local               3890c67d4b2fd29c2273be0c2c2d476839fb5467c6298b8e8eae9a846aeddc61
local               3890c67d4b2fd29c2273be0c2c2d476839fb5467c6298b8e8eae9a846aeddc61
local               3890c67d4b2fd29c2273be0c2c2d476839fb5467c6298b8e8eae9a846aeddc61
local               3890c67d4b2fd29c2273be0c2c2d476839fb5467c6298b8e8eae9a846aeddc61
local               3890c67d4b2fd29c2273be0c2c2d476839fb5467c6298b8e8eae9a846aeddc61
local               3890c67d4b2fd29c2273be0c2c2d476839fb5467c6298b8e8eae9a846aeddc61
local               jumping-nginx
#通过-v  卷名:容器内路径
#查看一下这个卷

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

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

拓展：

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

初识DockerFile

DockerFile就是用来构建docker镜像的构建文件！命令脚本先体验
通过这个脚本可以生成镜像，镜像是一层一层的，脚本是一个个的命令，每个命令都是一层。

#创建一个dockerfile文件，名字随意，建议Dockerfile
#文件中的内容 指令（大写）和参数：
FROM centos
VOLUME ["volume01","volume02"]
CMD  echo  "---end---"
CMD /bin/bash
 #这里的每个命令就是镜像的一层

#启动自己写的容器

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

查看一下卷挂载的路径

测试一下航材新建的文件是否同步到宿主机
这种方式以后使用的十分多，因为我们通常会构建自己的镜像
假设构建镜像的时候没有挂载卷，要手动镜像挂载 -v 卷名:容器内路径

数据卷容器

多个mysql同步数据

#启动3个容器

#测试，可以删除docker01，查看docker02和cocker03是否可以访问这些文件
#测试结果，依旧可以访问

多个mysql实现数据共享

[root@fxh home]# docker run -d -p 3310:3306 -v /etc/mysql/conf.d -v /var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7
[root@fxh home]# docker run -d -p 3311:3306  -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 --volumes-from mysql 01 mysql:5.7

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

DockerFile

DockerFile介绍

dockerfile是用来构建docker镜像的文件！命令参数脚本
构建步骤
1.编写一个dockerfile文件
2.docker build 构建成为一个镜像
3.docker run 运行镜像
4.docker push 发布镜像（DockerHub、阿里云镜像仓库）

查看一下官方是怎么做的

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

DockerFile构建过程

基础知识：
1.每个保留关键字（指令）都必须是大写字母
2.指令从上到下执行
3.#表示注释
4.每一个指令都会创建提交一个新的镜像层，并提交

dockerfile是面向开发的，以后要发布项目，做镜像，就需要编写dockerfile文件，文件很简单
Docker镜像逐渐成为了企业交付的标准，必须要掌握
步骤：开发、部署、运维。。。缺一不可
DockerFile：构建文件，定义了一切的步骤，好比源代码
DockerImages：通过dockerfile构建生成的镜像，最终要发布和运行的产品
Docker容器：容器就是镜像运行起来提供服务

DockerFile的指令

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

实战测试

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

创建一个自己的centos

[root@fxh dockerfile]# cat mydockerfile-centos 
FROM centos 
MAINTAINER kinghaoge<24736743@qq.com>
ENV MYPATH /usr/local
WORKDIR $MYPATH
RUN yum -y install vim
RUN yum -y install net-tools
EXPOSE 80
CMD echo $MYPATH
CMD echp "---end---"
CMD /bin/bash
#2.通过这个文件构建镜像🤔
[root@fxh dockerfile]# docker build -f mydockerfile-centos -t mycentos:0.1 .
#docker build -f dockerfile文件路径 -t 镜像名:[tag]
Successfully built 66dc2b9bb3db
Successfully tagged mycentos:0.1
#3.测试运行

对比：之前的原生centos镜像

我们增加功能之后的centos镜像

我们可以列出本地进行的变更历史

我们平时拿到一个镜像可以使用docker history 镜像id 来研究是怎么做的

CMD和ENTRYPOINT的区别

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

测试cmd

#编写dockerfile文件
[root@fxh dockerfile]# vim dockerfile-cmd-test
FROM centos
CMD ["ls","-a"]
#构建镜像
[root@fxh dockerfile]# docker build -f dockerfile-cmd-test -t cmdtest .
#run运行 发现命令生效
[root@fxh dockerfile]# docker run 7de1ec5e3ca0
.
..
.dockerenv
bin
dev
etc
home
lib
lib64
lost+found
media
mnt
opt
proc
root
run
sbin
srv
sys
tmp
usr
var
#想追加命令   -l   
[root@fxh dockerfile]# docker run 7de1ec5e3ca0 -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.
#cmd的情况下  -l替换了cmd["ls","-a"]

测试ENTRYPOINT

[root@fxh dockerfile]# vim dockerfile-cmd-entrypoint
[root@fxh dockerfile]# docker build -f dockerfile-cmd-entrypoint -t entrypoint-test .
Sending build context to Docker daemon  4.096kB
Step 1/2 : FROM centos
 ---> 0d120b6ccaa8
Step 2/2 : ENTRYPOINT ["ls","-a"]
 ---> Running in 00fad61c0f37
Removing intermediate container 00fad61c0f37
 ---> 634a70855199
Successfully built 634a70855199
Successfully tagged entrypoint-test:latest
[root@fxh dockerfile]# docker run 634a70855199
.
..
.dockerenv
bin
dev
etc
home
lib
lib64
lost+found
media
mnt
opt
proc
root
run
sbin
srv
sys
tmp
usr
var
#我们的追加命令，是直接拼接在我们的ENTRYPOINT命令的后面
[root@fxh dockerfile]# docker run 634a70855199 -l
total 56
drwxr-xr-x  1 root root 4096 Sep  4 06:46 .
drwxr-xr-x  1 root root 4096 Sep  4 06:46 ..
-rwxr-xr-x  1 root root    0 Sep  4 06:46 .dockerenv
lrwxrwxrwx  1 root root    7 May 11  2019 bin -> usr/bin
drwxr-xr-x  5 root root  340 Sep  4 06:46 dev
drwxr-xr-x  1 root root 4096 Sep  4 06:46 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
drwx------  2 root root 4096 Aug  9 21:40 lost+found
drwxr-xr-x  2 root root 4096 May 11  2019 media
drwxr-xr-x  2 root root 4096 May 11  2019 mnt
drwxr-xr-x  2 root root 4096 May 11  2019 opt
dr-xr-xr-x 90 root root    0 Sep  4 06:46 proc
dr-xr-x---  2 root root 4096 Aug  9 21:40 root
drwxr-xr-x 11 root root 4096 Aug  9 21:40 run
lrwxrwxrwx  1 root root    8 May 11  2019 sbin -> usr/sbin
drwxr-xr-x  2 root root 4096 May 11  2019 srv
dr-xr-xr-x 13 root root    0 Aug 30 08:40 sys
drwxrwxrwt  7 root root 4096 Aug  9 21:40 tmp
drwxr-xr-x 12 root root 4096 Aug  9 21:40 usr
drwxr-xr-x 20 root root 4096 Aug  9 21:40 var

Dockerfile中很多的命令都十分相似，需要了解它们的区别。最好的学习就是对比

实战：Tomcat镜像

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

2.编写dockerfile文件，官方命名 Dockerfile ，build会自动寻找这个文件，就不需要-f指定了！

Docker网络

企业实战

Docker Compose

Docker Swarm

CI/CD jenkins 流水线！