Docker学习

最新推荐文章于 2022-11-29 18:57:11 发布

A_三金

最新推荐文章于 2022-11-29 18:57:11 发布

阅读量510

点赞数

文章标签： docker 学习 linux

本文链接：https://blog.csdn.net/qq_33956536/article/details/125465719

版权

Docker 安装

Docker 的基本组成

在这里插入图片描述

镜像（image）：

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

容器（container）:

Docker利用容器技术，独立运行一个或者一组应用，通过镜像来创建

启动，停止，删除，基本命令！

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

仓库（repository）：

仓库就是存放镜像的地方！

仓库分为共有仓库和私有仓库！

Docker Hub（默认是国外的）

阿里云…都有容器服务（配置镜像加速）

安装Docker

环境准备

需要linux基础
CentOS8
使用Xshell连接远程服务器操作

环境查看

#系统内核是3以上

[root@iZbp12ewt14n9tfv7u1c1sZ /]# uname -r
4.18.0-193.28.1.el8_2.x86_64

# 系统版本

[root@iZbp12ewt14n9tfv7u1c1sZ /]# uname -r
4.18.0-193.28.1.el8_2.x86_64
[root@iZbp12ewt14n9tfv7u1c1sZ /]# ^C
[root@iZbp12ewt14n9tfv7u1c1sZ /]# cat /etc/os-release 
NAME="CentOS Linux"
VERSION="8 (Core)"
ID="centos"
ID_LIKE="rhel fedora"
VERSION_ID="8"
PLATFORM_ID="platform:el8"
PRETTY_NAME="CentOS Linux 8 (Core)"
ANSI_COLOR="0;31"
CPE_NAME="cpe:/o:centos:centos:8"
HOME_URL="https://www.centos.org/"
BUG_REPORT_URL="https://bugs.centos.org/"

CENTOS_MANTISBT_PROJECT="CentOS-8"
CENTOS_MANTISBT_PROJECT_VERSION="8"
REDHAT_SUPPORT_PRODUCT="centos"
REDHAT_SUPPORT_PRODUCT_VERSION="8"

安装

帮助文档：

# 1. 卸载旧安装
$ sudo 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软件包索引
yum makecache
    
# 4. 安装Docker
yum install docker-ce docker-ce-cli containerd.io
# 5. 启动docker
systemctl start docker

# 6. 使用docker version 查看是否安装成功

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GrKhYckX-1656173154582)(E:/Note/Markdown学习/img/1614240782129.png)]

# 7. 
docker run hello-world

# 8.查看镜像   hello world 镜像
[root@iZbp12ewt14n9tfv7u1c1sZ /]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
hello-world   latest    bf756fb1ae65   13 months ago   13.3kB

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

阿里云镜像加速

登录阿里云找到容器服务
找到镜像加速器

配置使用

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qvLm6zcj-1656173154584)(E:/Note/Markdown学习/img/1614242756938.png)]

底层原理

Docker是怎么工作的？

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

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zqQlwMxz-1656173154585)(E:/Note/Markdown学习/img/1614243224659.png)]

Docker 为什么比VM快

Docker 有着比虚拟机更少的抽象层。
Docker利用的是宿主机的内核，VM需要Guest OS.

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-F1re2RH0-1656173154586)(E:/Note/Markdown学习/img/1614243599537.png)]

Docker常用命令

帮助命令

docker version # 显示docker的版本信息
docker info # 显示docker系统信息，镜像和容器的数量
docker 命令 --help #万能命令

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

镜像命令

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

[root@iZbp12ewt14n9tfv7u1c1sZ /]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
hello-world   latest    bf756fb1ae65   13 months ago   13.3kB

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

# 可选项
  -a, --all             Show all images (default hides intermediate images)
      --digests         Show digests
  -f, --filter filter   Filter output based on conditions provided
      --format string   Pretty-print images using a Go template
      --no-trunc        Don't truncate output
  -q, --quiet           Only show image IDs # 只显示id

docker search

[root@iZbp12ewt14n9tfv7u1c1sZ /]# docker search mysql
NAME          DESCRIPTION       STARS     OFFICIAL   AUTOMATED
mysql         MySQL is a widely used, open-source relation…   10545     [OK]       

# 可选项  通过收藏过滤
-- filter=stars=3000   搜索出star大于3000

docker pull 下载镜像

#下载镜像  docker pull 镜像名字[:tag]
[root@iZbp12ewt14n9tfv7u1c1sZ /]# docker pull mysql
Using default tag: latest  # 如果不写 tag  默认就是latest
latest: Pulling from library/mysql
a076a628af6f: Pull complete  # 分层下载 docker image 核心，联合文件系统
f6c208f3f991: Pull complete 
88a9455a9165: Pull complete 
406c9b8427c6: Pull complete 
7c88599c0b25: Pull complete 
25b5c6debdaf: Pull complete 
43a5816f1617: Pull complete 
1a8c919e89bf: Pull complete 
9f3cf4bd1a07: Pull complete 
80539cea118d: Pull complete 
201b3cad54ce: Pull complete 
944ba37e1c06: Pull complete 
Digest: sha256:feada149cb8ff54eade1336da7c1d080c4a1c7ed82b5e320efb5beebed85ae8c # 签名
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest # 真实地址

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

# 指定版本下载
[root@iZbp12ewt14n9tfv7u1c1sZ /]# docker pull mysql:5.7

docker rmi 删除镜像

[root@iZbp12ewt14n9tfv7u1c1sZ /]# docker rmi -f c8562eaf9d81
# 删除指定id 镜像
[root@iZbp12ewt14n9tfv7u1c1sZ /]# docker rmi -f id id id 
# 删除多个镜像
[root@iZbp12ewt14n9tfv7u1c1sZ /]# 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 主机端口：容器端口  或者直接容器端口
-P  随机指定端口

# 测试  启动并进入容器   名称发生改变
[root@iZbp12ewt14n9tfv7u1c1sZ /]# docker run -it centos /bin/bash
[root@1d7ced879baf /]# 

[root@1d7ced879baf /]# ls  查看内部文件，基础版本，命令不完善
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var


# 从容器中退出到主机
[root@1d7ced879baf /]# exit
exit
[root@iZbp12ewt14n9tfv7u1c1sZ /]# ls
bin   dev  home  lib64  mnt  patch  root  sbin    srv  tmp  var
boot  etc  lib   media  opt  proc   run   sp.jar  sys  usr  www

列出所有运行中的容器

# docker ps
-a 列出当前正在运行的容器，列出历史运行过的容器
   列出当前正在运行的容器
-n=? 显示最近创建的容器
-q   只显然容器的编号


[root@iZbp12ewt14n9tfv7u1c1sZ /]# docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
[root@iZbp12ewt14n9tfv7u1c1sZ /]# docker ps -a
CONTAINER ID   IMAGE          COMMAND       CREATED         STATUS                          PORTS     NAMES
1d7ced879baf   centos         "/bin/bash"   3 minutes ago   Exited (0) About a minute ago             boring_mclean
2b431892e010   bf756fb1ae65   "/hello"      4 hours ago     Exited (0) 4 hours ago                    sleepy_nobel
6884f8846243   bf756fb1ae65   "/hello"      2 weeks ago     Exited (0) 2 weeks ago                    focused_mccarthy

退出容器

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

删除容器

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

启动和停止容器的操作

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

常用其他命令

后台启动容器

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

查看日志

docker logs -f -t --tail 容器

# 自己编写 shell脚本
[root@iZbp12ewt14n9tfv7u1c1sZ /]# docker run -d centos /bin/sh -c "while true;do echo sanjin;sleep 1;done"

[root@iZbp12ewt14n9tfv7u1c1sZ /]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS     NAMES
aa7b60621fc5   centos    "/bin/sh -c 'while t…

# 显示日志
-tf  # 显示日志
  --tail # 显示条数
[root@iZbp12ewt14n9tfv7u1c1sZ /]# docker logs -tf --tail 10 aa7b60621fc5

查看容器中的进程信息 ps

[root@iZbp12ewt14n9tfv7u1c1sZ /]# docker top aa7b60621fc5
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                1443881             1443862             0                   22:23               ?                   00:00:00            /bin/sh -c while true;do echo sanjin;sleep 1;done
root                1444440             1443881             0                   22:27               ?                   00:00:00            /usr/bin/coreutils --coreutils-prog-shebang=sleep /usr/bin/sleep 1

查看镜像源数据

[root@iZbp12ewt14n9tfv7u1c1sZ /]# docker inspect aa7b60621fc5
[
    {
        "Id": "aa7b60621fc5dcfdd641483f08b221e3778506747525c425378d52245dd01c90",
        "Created": "2021-02-25T14:24:00.707109998Z",
        "Path": "/bin/sh",
        "Args": [
            "-c",
            "while true;do echo sanjin;sleep 1;done"
        ],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 1443881,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2021-02-25T14:24:01.120383281Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:300e315adb2f96afe5f0b2780b87f28ae95231fe3bdd1e16b9ba606307728f55",
        "ResolvConfPath": "/var/lib/docker/containers/aa7b60621fc5dcfdd641483f08b221e3778506747525c425378d52245dd01c90/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/aa7b60621fc5dcfdd641483f08b221e3778506747525c425378d52245dd01c90/hostname",
        "HostsPath": "/var/lib/docker/containers/aa7b60621fc5dcfdd641483f08b221e3778506747525c425378d52245dd01c90/hosts",
        "LogPath": "/var/lib/docker/containers/aa7b60621fc5dcfdd641483f08b221e3778506747525c425378d52245dd01c90/aa7b60621fc5dcfdd641483f08b221e3778506747525c425378d52245dd01c90-json.log",
        "Name": "/xenodochial_germain",
        "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/04934126b70da4ba2726d398f0571e2fa41e44cef3b903dc280cc9e80e4ce1b4-init/diff:/var/lib/docker/overlay2/b0406a920ae855d77841f6cb4065c063c6de0884fbe36fc5f209227bf8f4fc60/diff",
                "MergedDir": "/var/lib/docker/overlay2/04934126b70da4ba2726d398f0571e2fa41e44cef3b903dc280cc9e80e4ce1b4/merged",
                "UpperDir": "/var/lib/docker/overlay2/04934126b70da4ba2726d398f0571e2fa41e44cef3b903dc280cc9e80e4ce1b4/diff",
                "WorkDir": "/var/lib/docker/overlay2/04934126b70da4ba2726d398f0571e2fa41e44cef3b903dc280cc9e80e4ce1b4/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [],
        "Config": {
            "Hostname": "aa7b60621fc5",
            "Domainname": "",
            "User": "",
            "AttachStdin": false,
            "AttachStdout": false,
            "AttachStderr": false,
            "Tty": false,
            "OpenStdin": false,
            "StdinOnce": false,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
            ],
            "Cmd": [
                "/bin/sh",
                "-c",
                "while true;do echo sanjin;sleep 1;done"
            ],
            "Image": "centos",
            "Volumes": null,
            "WorkingDir": "",
            "Entrypoint": null,
            "OnBuild": null,
            "Labels": {
                "org.label-schema.build-date": "20201204",
                "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": "e5e34fe0ff9a14f1b0c40b0a21258e0902074b360e81c83cef1a3c2c635611ac",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {},
            "SandboxKey": "/var/run/docker/netns/e5e34fe0ff9a",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "43e0f3efa534d6c877b1eaed9c27e0c492364956e51cd8ceb3266fae83c1efae",
            "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": "d0ea85d298ffeeb38c0a92b9909fdfa3fdcf0cc08906b93a0f3b21eeebfcfda8",
                    "EndpointID": "43e0f3efa534d6c877b1eaed9c27e0c492364956e51cd8ceb3266fae83c1efae",
                    "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 bashShell

# 测试
[root@iZbp12ewt14n9tfv7u1c1sZ /]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED          STATUS          PORTS     NAMES
aa7b60621fc5   centos    "/bin/sh -c 'while t…"   10 minutes ago   Up 10 minutes             xenodochial_germain
[root@iZbp12ewt14n9tfv7u1c1sZ /]# docker exec -it aa7b60621fc5 /bin/bash
[root@aa7b60621fc5 /]# ls
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
[root@aa7b60621fc5 /]# ps -ef
UID          PID    PPID  C STIME TTY          TIME CMD
root           1       0  0 14:23 ?        00:00:00 /bin/sh -c while true;do echo sanjin;sleep 1;done
root         677       0  0 14:35 pts/0    00:00:00 /bin/bash
root         716       1  0 14:35 ?        00:00:00 /usr/bin/coreutils --coreutils-prog-shebang=sleep /usr/bin/sle
root         717     677  0 14:35 pts/0    00:00:00 ps -ef
[root@aa7b60621fc5 /]# 


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

# docker exec  # 进入容器后，开启一个新的终端 可以在里面操作（常用）
# docker attach # 进入正在执行的终端，不会启动新的进程

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

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


# 创建文件
[root@fd099a277949 /]# cd /home
[root@fd099a277949 home]# ls
[root@fd099a277949 home]# touch test.java
[root@fd099a277949 home]# ls
test.java
[root@fd099a277949 home]# exit
exit
[root@iZbp12ewt14n9tfv7u1c1sZ home]# docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
[root@iZbp12ewt14n9tfv7u1c1sZ home]# docker ps -a
CONTAINER ID   IMAGE     COMMAND       CREATED         STATUS                     PORTS     NAMES
fd099a277949   centos    "/bin/bash"   3 minutes ago   Exited (0) 8 seconds ago             musing_taussig
# 复制
[root@iZbp12ewt14n9tfv7u1c1sZ home]# docker cp fd099a277949:/home/test.java /home
[root@iZbp12ewt14n9tfv7u1c1sZ home]# ls
redis  sanjin  sanjin.java  test.java  www

小结

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hAfSqS6a-1656173154586)(E:/Note/Markdown学习/img/1614266659410.png)]

练习

Docker 安装Nginx

# 1. 搜索镜像 search 建议去dockerhub搜索，可以看见帮助文档和信息
# 2. 下载镜像 pull

# -d 后台运行
# --name 给容器命名
# -p 宿主机端口：容器内端口
[root@iZbp12ewt14n9tfv7u1c1sZ conf]# docker run -d --name nginx01 -p:8080:80 nginx
aec813e46061adda9fe4c3a2a09c2c667bbe6ae9d21b5862749942695a5f3733
[root@iZbp12ewt14n9tfv7u1c1sZ conf]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS                  NAMES
aec813e46061   nginx     "/docker-entrypoint.…"   4 seconds ago   Up 3 seconds   0.0.0.0:8080->80/tcp   nginx01
[root@iZbp12ewt14n9tfv7u1c1sZ conf]# curl localhost:8080
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
    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>

Docker 安装Tomcat

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

# 我们之前的启动都是后台，停止容器之后，容器还能查到  docker run -it --rm tomcat:9.0   一般用来测试，用完就删除

# 下载再启动
docker pull tomcat:9.0

# 启动直接运行
[root@iZbp12ewt14n9tfv7u1c1sZ home]# docker images
REPOSITORY   TAG       IMAGE ID       CREATED        SIZE
tomcat       9.0       040bdb29ab37   6 weeks ago    649MB
nginx        latest    f6d0b4767a6c   6 weeks ago    133MB
centos       latest    300e315adb2f   2 months ago   209MB
[root@iZbp12ewt14n9tfv7u1c1sZ home]# docker run -d -p 8081:8080 --name tomcat01 tomcat


# 测试访问没有问题


# 进入容器
[root@iZbp12ewt14n9tfv7u1c1sZ home]# docker exec -it tomcat01 /bin/bash

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

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

可视化

portainer(先用这个)
Rancher (CI/CD 再用)

什么是portainer？

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

docker run -d -p 9000:9000 \
--restart=always \
-v /var/run/docker.sock:/var/run/docker.sock \
--name prtainer \portainer/portainer

访问测试：外网8081

通过它来访问

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QGSml9yP-1656173154588)(E:/Note/Markdown学习/img/1614432787949.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-22OyFjEr-1656173154588)(E:/Note/Markdown学习/img/1614433875241.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Lytvnuvi-1656173154588)(E:/Note/Markdown学习/img/1614433897636.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TPUtA7pr-1656173154589)(E:/Note/Markdown学习/img/1614433953362.png)]

可视化面板，平时不会使用

Docker 镜像讲解

镜像是什么

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

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

如何得到镜像！

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

Docker 镜像加载原理

UninoFS （联合文件系统）

外面下载的时候看到一层层的时候就是这个！

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

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

Docker 镜像加载原理

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

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

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pwb0ymGT-1656173154589)(E:/Note/Markdown学习/img/1614434680428.png)]

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

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

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

分层理解

分层的镜像

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X6TRI4z8-1656173154589)(E:/Note/Markdown学习/img/1614434980227.png)]

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

[root@iZbp12ewt14n9tfv7u1c1sZ home]# docker image inspect redis:latest
 "RootFS": {
            "Type": "layers",
            "Layers": [
                "sha256:cb42413394c4059335228c137fe884ff3ab8946a014014309676c25e3ac86864",
                "sha256:8e14cb7841faede6e42ab797f915c329c22f3b39026f8338c4c75de26e5d4e82",
                "sha256:1450b8f0019c829e638ab5c1f3c2674d117517669e41dd2d0409a668e0807e96",
                "sha256:f927192cc30cb53065dc266f78ff12dc06651d6eb84088e82be2d98ac47d42a0",
                "sha256:a24a292d018421783c491bc72f6601908cb844b17427bac92f0a22f5fd809665",
                "sha256:3480f9cdd491225670e9899786128ffe47054b0a5d54c48f6b10623d2f340632"
            ]
        },
        "Metadata": {
            "LastTagTime": "0001-01-01T00:00:00Z"
        }
    }
]

理解：

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

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-O2dgEzb3-1656173154590)(E:/Note/Markdown学习/img/1614439282219.png)]

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9TE0aU8K-1656173154590)(E:/Note/Markdown学习/img/1614439530101.png)]

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MxtKCcJ9-1656173154591)(E:/Note/Markdown学习/img/1614439679837.png)]

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-E6qqDs9Q-1656173154591)(E:/Note/Markdown学习/img/1614439816461.png)]

特点

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

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GWFXumFw-1656173154592)(E:/Note/Markdown学习/img/1614442272637.png)]

如何提交一个自己的镜像

commit镜像

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

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

实战测试

# 启动一个默认的tomcat

# 发现tomcat是没有webapps应用，镜像的原因，官方的镜像是默认没有的

# 我自己拷贝进去了基本的文件
root@8d9428ed4f5d:/usr/local/tomcat# cp -r webapps.dist/* webapps
# 将我们操作的容器提交为一个镜像，我们以后就使用我们修改过的镜像就可以，这就是我们自己一个修改过的镜像

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fwFHRQ4p-1656173154592)(E:/Note/Markdown学习/img/1614442953422.png)]

如果想要保存当前容器的状态，可以通过commit来提交，获得一个镜像，
就好比VM的虚拟机

到了这里，算是入门docker

容器数据卷

什么是容器数据卷

docker的理念

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

数据？如果数据都在容器中，那么我们容器一删除，数据就会丢失。

需求 数据可持久化

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

容器直接可以有数据共享的技术！ Docker 容器中产生的数据，同步到本地！

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZqtdkKhE-1656173154592)(E:/Note/Markdown学习/img/1614443720182.png)]

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

使用数据卷

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

docker run -it -v 主机目录:容器内目录

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

# 启动起来后，我们可以通过docker inspect 容器id 查看信息

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-En3lsV4n-1656173154593)(E:/Note/Markdown学习/img/1614444428367.png)]

测试文件的同步

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1JpbxB69-1656173154593)(E:/Note/Markdown学习/img/1614444612233.png)]

再测试

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iyUpqoPg-1656173154593)(E:/Note/Markdown学习/img/1614444954064.png)]

好处：我们以后修改只需要再本地修改，容器会自动同步

实战：安装MySQL

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

# 获取镜像
[root@iZbp12ewt14n9tfv7u1c1sZ home]# docker pull mysql:5.7

# 运行容器：需要数据挂载  # 安装启动mysql 需要配置密码
$ docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag

# 启动我们的
-d 后台运行
-p 端口映射
-v 挂载路径
-e 环境配置
--name 容器名字

[root@iZbp12ewt14n9tfv7u1c1sZ home]# docker run -d -p 8080:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7

# 启动成功后，我们使用本地sqlyog测试连接
# sqlyog -h -u -p   连接到服务器的8080 和容器内的3306映射 这个时候 就可以连接上了

# 在本地测试创建一个数据库，查看一下我们映射的路径是ok的

假设我们将容器删除

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iOtmvoxW-1656173154594)(E:/Note/Markdown学习/img/1614446346455.png)]

发现：我们挂载到本地的数据依旧没有丢失，这就实现了持久化技术。

具名和匿名挂载

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

# 查看所有指定卷的情况
[root@iZbp12ewt14n9tfv7u1c1sZ home]# docker volume ls
local     8b46417a6a446ae714408111219d93babc4ccd66ca8873b1b558fd171f05a3ae

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

# 具名挂载
[root@iZbp12ewt14n9tfv7u1c1sZ home]# docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx
7c5612ca917f82cca3b3d043f401d1d2e70008869800147389729e25e79aa372
[root@iZbp12ewt14n9tfv7u1c1sZ home]# docker volume ls
DRIVER    VOLUME NAME
local     8b46417a6a446ae714408111219d93babc4ccd66ca8873b1b558fd171f05a3ae
local     9b84b8f51662f8a70fbdcb232ce4583808dd89146cfb57d28000b0375b23bdc8
local     juming-nginx

# 通过-v 卷名:容器内路径
# 查看一下这个卷

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LKmBpMDI-1656173154594)(E:/Note/Markdown学习/img/1614515219781.png)]

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

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

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

初始DockerFile

DockerFile 就是用来构建docker镜像的构建文件！命令脚本

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

# 创建一个dockerfile文件，名字可以自定义，建议dockerfile
# 文件中的内容：指令（大写） 参数

FROM centos

VOLUME ["volume01","volume02"]

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

# 这里的每个命令都是一层

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EzjO1EjM-1656173154594)(E:/Note/Markdown学习/img/1614519174541.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zFxAPQOm-1656173154595)(E:/Note/Markdown学习/img/1614519184009.png)]

# 启动自己写的容器

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7ALp4kj3-1656173154595)(E:/Note/Markdown学习/img/1614519312067.png)]

这个一定和外面有一个同步的路径

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3ckYqJNR-1656173154596)(E:/Note/Markdown学习/img/1614519351950.png)]

查看一下挂载的路径

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1FOvaSJ9-1656173154596)(E:/Note/Markdown学习/img/1614519781638.png)]

测试一下是否同步了文件

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

假设构建镜像时没有挂载卷，要手动镜像挂载 -v 卷名：容器内路径！

数据卷容器

多个mysql同步数据

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GTdl40cY-1656173154596)(E:/Note/Markdown学习/img/1614520582670.png)]

# 启动3个容器，通过我们写的镜像启动

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EJ6V2gVb-1656173154597)(E:/Note/Markdown学习/img/1614520777944.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-niDahbVa-1656173154597)(E:/Note/Markdown学习/img/1614521318636.png)]

结论：

容器之间配置信息的传递，数据卷容器的生命周期是一直持续到没有人使用为止

但是一旦持久化到本地，这个时候，本地的数据是不会删除的

DockerFile介绍

dockerfile是用来构建docker镜像的文件

构建步骤：

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

查看一下官方是怎么做的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hYj0sjqO-1656173154597)(E:/Note/Markdown学习/img/1614522229047.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4WjjBhm2-1656173154598)(E:/Note/Markdown学习/img/1614522368846.png)]

很多官方的镜像都是基础包，很多功能没有，我们需要自己来自己的搭建。

官方可以自己做镜像，我们也可以

DockerFile构建过程

基础知识：

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nDzTgEB0-1656173154598)(E:/Note/Markdown学习/img/1614522833003.png)]

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

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

步骤：开发，部署，运维

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

Dockerimages: 通过DockerFile 构建生成的镜像，最终发布和运行的产品，原来是jar war，现在启动镜像就自动运行！

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

DockerFile指令

以前我们使用别人的，现在我们自己写镜像

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nYDax7oO-1656173154598)(E:/Note/Markdown学习/img/1614523356335.png)]

实战测试

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7LgYnGJS-1656173154598)(E:/Note/Markdown学习/img/1614524049688.png)]

创建一个自己的Centos

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-n16nvCf6-1656173154599)(E:/Note/Markdown学习/img/1614524670105.png)]

编写文件
构建镜像

命令 docker build -f dockerfile文件路径 -t 镜像名字:[tag]
```
Successfully built 5d41f8a7932d
Successfully tagged mycentos:0.1
```
测试运行

对比之前

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FbIMDcfJ-1656173154599)(E:/Note/Markdown学习/img/1614525385775.png)]

我们增加之后的镜像

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WgGlHWAT-1656173154599)(E:/Note/Markdown学习/img/1614525418038.png)]

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-74r3WO9G-1656173154600)(E:/Note/Markdown学习/img/1614525484416.png)]

我们平时拿到一个镜像可以研究一下它是怎么做的

CMD 和ENTRYPOINT 区别

测试cmd

# 编写dockerfile文件
[root@iZbp12ewt14n9tfv7u1c1sZ dockerfile]# vim dockerfile-cmd-test 
FROM centos
CMD ["ls","-a"]
# 构建镜像
[root@iZbp12ewt14n9tfv7u1c1sZ dockerfile]# docker build -f dockerfile-cmd-test -t cmdtest .
Sending build context to Docker daemon  3.072kB
Step 1/2 : FROM centos
 ---> 300e315adb2f
Step 2/2 : CMD ["ls","-a"]
 ---> Running in 3cb4eb40ccf8
Removing intermediate container 3cb4eb40ccf8
 ---> b3744e2deab2
Successfully built b3744e2deab2
Successfully tagged cmdtest:latest

# run 运行 发现我们的 ls -a 生效了
[root@iZbp12ewt14n9tfv7u1c1sZ dockerfile]# docker run b3744e2deab2
.
..
.dockerenv
bin
dev
etc
home
lib
lib64
lost+found
media
mnt
opt
proc
root
run
sbin
srv
sys
tmp
usr
var

# 想追加一个命令 ls -al
[root@iZbp12ewt14n9tfv7u1c1sZ dockerfile]# docker run b3744e2deab2 -l
docker: Error response from daemon: OCI runtime create failed: container_linux.go:370: starting container process caused: exec: "-l": executable file not found in $PATH: unknown.

# cmd 情况下，-l 替换了["ls","-a"]命令，而-l不是命令，所以报错

测试ENTRYPOINT

# 编写文件
[root@iZbp12ewt14n9tfv7u1c1sZ dockerfile]# vim docker-cmd-entrypoint

FROM centos
ENTRYPOINT ["ls","-a"]

# 构建镜像
[root@iZbp12ewt14n9tfv7u1c1sZ dockerfile]# docker build -f docker-cmd-entrypoint -t entrypoint .
Sending build context to Docker daemon  4.096kB
Step 1/2 : FROM centos
 ---> 300e315adb2f
Step 2/2 : ENTRYPOINT ["ls","-a"]
 ---> Running in 3de55e2edcbb
Removing intermediate container 3de55e2edcbb
 ---> 31cb1617b81c
Successfully built 31cb1617b81c
Successfully tagged entrypoint:latest

# 追加命令，直接拼接在ENTRYPOINT 命令后面
[root@iZbp12ewt14n9tfv7u1c1sZ dockerfile]# docker run 31cb1617b81c -l
total 0
drwxr-xr-x   1 root root   6 Mar  1 04:54 .
drwxr-xr-x   1 root root   6 Mar  1 04:54 ..
-rwxr-xr-x   1 root root   0 Mar  1 04:54 .dockerenv
lrwxrwxrwx   1 root root   7 Nov  3 15:22 bin -> usr/bin
drwxr-xr-x   5 root root 340 Mar  1 04:54 dev
drwxr-xr-x   1 root root  66 Mar  1 04:54 etc
drwxr-xr-x   2 root root   6 Nov  3 15:22 home
lrwxrwxrwx   1 root root   7 Nov  3 15:22 lib -> usr/lib
lrwxrwxrwx   1 root root   9 Nov  3 15:22 lib64 -> usr/lib64
drwx------   2 root root   6 Dec  4 17:37 lost+found
drwxr-xr-x   2 root root   6 Nov  3 15:22 media
drwxr-xr-x   2 root root   6 Nov  3 15:22 mnt
drwxr-xr-x   2 root root   6 Nov  3 15:22 opt

实战：Tomcat镜像

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZgoTAt0P-1656173154600)(E:/Note/Markdown学习/img/1614575060756.png)]

编写dockerfile文件，官方命名Dockerfile,build的时候自动寻找，不用-f指定

FROM centos

MAINTAINER sanjin<534240118@qq.com>

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

ADD jdk-8u221-linux-x64.rpm /usr/local/
ADD apache-tomcat-9.0.39-windows-x64.zip /usr/local/

RUN yum -y install vim

ENV MYPATH /usr/local
WORKDIR $MYPATH

ENV JAVA_HOME /usr/local/jdk1.8.0_221-amd64
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.39-windows-x64
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.39-windows-x64
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$$CATALINA_HOME/bin


EXPOSE 8080

CMD /usr/local/apache-tomcat-9.0.39-windows-x64/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.39-windows-x64/bin/logs/catalina.out

构建镜像

[root@iZbp12ewt14n9tfv7u1c1sZ sanjin]# docker build -t diytomcat .

运行与测试

发布自己的镜像

DockerHub

注册自己的账号
确定可以登录
提交自己的镜像

[root@iZbp12ewt14n9tfv7u1c1sZ ~]# docker login --help

Usage:  docker login [OPTIONS] [SERVER]

Log in to a Docker registry.
If no server is specified, the default is defined by the daemon.

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

登录完毕之后就可以提交镜像了

[root@iZbp12ewt14n9tfv7u1c1sZ ~]# docker login -u guoyouxin
Password: 
WARNING! Your password will be stored unencrypted in /root/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store

Login Succeeded

root@iZbp12ewt14n9tfv7u1c1sZ ~]# docker tag 5d41f8a7932d guoyouxin/centos:1.0
[root@iZbp12ewt14n9tfv7u1c1sZ ~]# docker images
REPOSITORY            TAG       IMAGE ID       CREATED        SIZE
<none>                <none>    550567be84c3   3 hours ago    459MB
entrypoint            latest    31cb1617b81c   4 hours ago    209MB
cmdtest               latest    b3744e2deab2   4 hours ago    209MB
<none>                <none>    a1e20074abc3   4 hours ago    209MB
guoyouxin/centos      1.0       5d41f8a7932d   18 hours ago   291MB
mycentos              0.1       5d41f8a7932d   18 hours ago   291MB
sanjin/centos         1.0       8d4d208a1772   19 hours ago   209MB
tomcat02              1.0       cdade1cc9766   40 hours ago   654MB
mysql                 5.7       a70d36bc331a   5 weeks ago    449MB
redis                 latest    621ceef7494a   6 weeks ago    104MB
tomcat                9.0       040bdb29ab37   6 weeks ago    649MB
tomcat                latest    040bdb29ab37   6 weeks ago    649MB
nginx                 latest    f6d0b4767a6c   6 weeks ago    133MB
centos                latest    300e315adb2f   2 months ago   209MB
portainer/portainer   latest    62771b0b9b09   7 months ago   79.1MB
[root@iZbp12ewt14n9tfv7u1c1sZ ~]# docker push guoyouxin/centos:1.0