Docker

最新推荐文章于 2023-01-14 16:16:51 发布

gdutlog

最新推荐文章于 2023-01-14 16:16:51 发布

阅读量1.2k

点赞数

分类专栏： Docker 文章标签： docker

本文链接：https://blog.csdn.net/yang862819503/article/details/124439346

版权

Docker 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Docker概述

通过Docker可以把一个项目带上环境配置一起打包上线

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

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

DevOps (开发、运维)

应用更快速得交付和部署

传统：一堆帮助文档，安装程序

Docker：打包镜像发布测试，一键运行

更便捷的升级和扩缩容

使用了docker之后，我们部署应用就和搭积木一样

更简单的系统运维

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

更高效的计算资源利用

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

Docker入门

Docker的基本组成

镜像(image)：

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

容器(container)：

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

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

目前就可以把这个容器理解为就是一个简易的linux系统，项目

仓库(repository)：

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

仓库分为公有仓库和私有仓库

Docker Hub

阿里云（配置镜像加速）

Docker的安装

环境准备

一台服务器

环境查看

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

#系统版本
[root@logpumServer /]# 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"

安装

帮助文档：Install Docker Engine | Docker Documentation

#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软件包索引
yum makecache fast

#4.安装docker相关的内容   docker-ce 社区版   ee 企业版
yum install docker-ce docker-ce-cli containerd.io

#5.启动docker
systemctl start docker

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

#7.hello-world程序
docker run hello-world

#8.查看下载的这个hello world镜像
[root@logpumServer /]# docker images
REPOSITORY    TAG          IMAGE ID       CREATED        SIZE
rabbitmq      management   6c3c2a225947   7 weeks ago    253MB
hello-world   latest       feb5d9fea6a5   4 months ago   13.3kB

卸载docker

#1.卸载依赖
yum remove docker-ce docker-ce-cli containerd.io

#2.删除资源
rm -rf /var/lib/docker
rm -rf /var/lib/containerd

阿里云镜像加速

登录阿里云，查找到容器镜像服务
找到镜像加速地址

配置使用

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

回顾helloworld流程

底层原理

Docker是怎么工作的

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

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

Docker为什么比虚拟机快？

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

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

Docker的常用命令

帮助命令

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

帮助文档的地址：Reference documentation | Docker Documentation

镜像命令

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

[root@logpumServer /]# docker images
REPOSITORY    TAG          IMAGE ID       CREATED        SIZE
rabbitmq      management   6c3c2a225947   7 weeks ago    253MB
hello-world   latest       feb5d9fea6a5   4 months ago   13.3kB

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

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

docker search 搜索镜像

[root@logpumServer /]# docker search mysql
NAME                              DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
mysql                             MySQL is a widely used, open-source relation…   12060     [OK]       
mariadb                           MariaDB Server is a high performing open sou…   4622      [OK]       

# 可选项
--filter=STARS=3000    # 搜索出来的镜像就是STARS大于3000的
[root@logpumServer /]# docker search mysql --filter=STARS=3000
NAME      DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
mysql     MySQL is a widely used, open-source relation…   12060     [OK]       
mariadb   MariaDB Server is a high performing open sou…   4622      [OK]

docker pull 下载镜像

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

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

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

[root@logpumServer /]# docker images
REPOSITORY    TAG          IMAGE ID       CREATED        SIZE
mysql         5.7          c20987f18b13   6 weeks ago    448MB
mysql         latest       3218b38490ce   6 weeks ago    516MB
rabbitmq      management   6c3c2a225947   7 weeks ago    253MB
hello-world   latest       feb5d9fea6a5   4 months ago   13.3kB

docker rmi 删除镜像

[root@logpumServer /]# docker rmi -f 镜像id     删除指定镜像
[root@logpumServer /]# docker rmi -f 镜像id 镜像id 镜像id   删除多个镜像
[root@logpumServer /]# docker rmi -f $(docker images -aq)  删除全部镜像

[root@logpumServer /]# docker rmi -f 3218b38490ce
Untagged: mysql:latest
Untagged: mysql@sha256:e9027fe4d91c0153429607251656806cc784e914937271037f7738bd5b8e7709
Deleted: sha256:3218b38490cec8d31976a40b92e09d61377359eab878db49f025e5d464367f3b
Deleted: sha256:aa81ca46575069829fe1b3c654d9e8feb43b4373932159fe2cad1ac13524a2f5
Deleted: sha256:0558823b9fbe967ea6d7174999be3cc9250b3423036370dc1a6888168cbd224d
Deleted: sha256:a46013db1d31231a0e1bac7eeda5ad4786dea0b1773927b45f92ea352a6d7ff9
Deleted: sha256:af161a47bb22852e9e3caf39f1dcd590b64bb8fae54315f9c2e7dc35b025e4e3
Deleted: sha256:feff1495e6982a7e91edc59b96ea74fd80e03674d92c7ec8a502b417268822ff

[root@logpumServer /]# docker rmi -f $(docker images -aq)

容器命令

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

docker pull centos

新建容器并启动

  docker run [可选参数] image

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

# 测试,启动并进入容器
[root@logpumServer /]# docker run -it centos /bin/bash
[root@c6ee96530118 /]# ls
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
# 从容器中退回主机
[root@c6ee96530118 /]# exit
exit

列出所有运行的容器

# 正在运行
[root@logpumServer /]# docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES

# 正在运行和曾经运行过的
[root@logpumServer /]# docker ps -a
CONTAINER ID   IMAGE                 COMMAND                  CREATED             STATUS                          PORTS     NAMES
c6ee96530118   centos                "/bin/bash"              4 minutes ago       Exited (0) About a minute ago             epic_heisenberg
163a5cdb9d84   hello-world           "/hello"                 About an hour ago   Exited (0) About an hour ago              stoic_shirley
f1e80d575274   rabbitmq:management   "docker-entrypoint.s…"   12 days ago         Exited (0) 9 days ago                     myrabbit

# -n  列出最近的n个，这里为1个
[root@logpumServer /]# docker ps -a -n=1
CONTAINER ID   IMAGE     COMMAND       CREATED         STATUS                     PORTS     NAMES
c6ee96530118   centos    "/bin/bash"   7 minutes ago   Exited (0) 4 minutes ago             epic_heisenberg

# -q  只显示容器id
[root@logpumServer /]# docker ps -a -q
c6ee96530118
163a5cdb9d84
f1e80d575274

退出容器

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

**删除容器 **

docker rm 容器id		# 删除指定容器，不能删除正在运行的容器，如果要强制删除，rm -f
docker 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		# 强制停止当前容器

[root@logpumServer /]# docker ps -a
CONTAINER ID   IMAGE                 COMMAND                  CREATED          STATUS                      PORTS     NAMES
c6ee96530118   centos                "/bin/bash"              22 minutes ago   Exited (0) 19 minutes ago             epic_heisenberg
163a5cdb9d84   hello-world           "/hello"                 2 hours ago      Exited (0) 2 hours ago                stoic_shirley
f1e80d575274   rabbitmq:management   "docker-entrypoint.s…"   12 days ago      Exited (0) 9 days ago                 myrabbit
[root@logpumServer /]# docker start c6ee96530118
c6ee96530118
[root@logpumServer /]# docker ps
CONTAINER ID   IMAGE     COMMAND       CREATED          STATUS         PORTS     NAMES
c6ee96530118   centos    "/bin/bash"   22 minutes ago   Up 5 seconds             epic_heisenberg
[root@logpumServer /]# docker stop c6ee96530118
c6ee96530118
[root@logpumServer /]# docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES

常用其他命令

后台启动容器

# 通过镜像启动容器
[root@logpumServer /]# docker run -d centos

# 问题：docker ps 的时候发现centos停止了

# 常见的坑:docker容器使用后台运行，就必须要有一个前台进程，docker发现没有应用，就会自动停止
# 容器启动后，发现自己没有提供服务，就会立刻停止，就是没有程序了

查看日志

docker logs

# 查看最近的10条日志
-tf			   # 显示日志
--tail number  # 要显示的记录条数
docker logs -f -t --tail 10 e5842a6d2ce6

查看容器中的进程信息

top命令
docker top

# 命令 docker top 容器id
[root@logpumServer /]# docker ps
CONTAINER ID   IMAGE     COMMAND       CREATED          STATUS          PORTS     NAMES
e5842a6d2ce6   centos    "/bin/bash"   12 minutes ago   Up 12 minutes             nostalgic_bouman
[root@logpumServer /]# docker top e5842a6d2ce6
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                1998                1981                0                   17:17               ?                   00:00:00            /bin/bash

查看镜像的元数据

# 命令
docker inspect 容器id

# 测试
[root@logpumServer /]# docker inspect e5842a6d2ce6
[
    {
        "Id": "e5842a6d2ce6fe2933371780c5774d35dd3928358e52bcad82ac62f69ff9a213",
        "Created": "2022-02-06T09:17:48.627055337Z",
        "Path": "/bin/bash",
        "Args": [],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 1998,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2022-02-06T09:17:48.942830393Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:5d0da3dc976460b72c77d94c8a1ad043720b0416bfc16c52c45d4847e53fadb6",
        "ResolvConfPath": "/var/lib/docker/containers/e5842a6d2ce6fe2933371780c5774d35dd3928358e52bcad82ac62f69ff9a213/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/e5842a6d2ce6fe2933371780c5774d35dd3928358e52bcad82ac62f69ff9a213/hostname",
        "HostsPath": "/var/lib/docker/containers/e5842a6d2ce6fe2933371780c5774d35dd3928358e52bcad82ac62f69ff9a213/hosts",
        "LogPath": "/var/lib/docker/containers/e5842a6d2ce6fe2933371780c5774d35dd3928358e52bcad82ac62f69ff9a213/e5842a6d2ce6fe2933371780c5774d35dd3928358e52bcad82ac62f69ff9a213-json.log",
        "Name": "/nostalgic_bouman",
        "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/5f6730d41dfe3c179e8651bbbb32efd76bff21f5146b7ad24e96c87c3872e646-init/diff:/var/lib/docker/overlay2/1004de173cd542b758c8b0a016a8ac55af6cf0d96d5b337e0236badce48a826f/diff",
                "MergedDir": "/var/lib/docker/overlay2/5f6730d41dfe3c179e8651bbbb32efd76bff21f5146b7ad24e96c87c3872e646/merged",
                "UpperDir": "/var/lib/docker/overlay2/5f6730d41dfe3c179e8651bbbb32efd76bff21f5146b7ad24e96c87c3872e646/diff",
                "WorkDir": "/var/lib/docker/overlay2/5f6730d41dfe3c179e8651bbbb32efd76bff21f5146b7ad24e96c87c3872e646/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [],
        "Config": {
            "Hostname": "e5842a6d2ce6",
            "Domainname": "",
            "User": "",
            "AttachStdin": true,
            "AttachStdout": true,
            "AttachStderr": true,
            "Tty": true,
            "OpenStdin": true,
            "StdinOnce": true,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
            ],
            "Cmd": [
                "/bin/bash"
            ],
            "Image": "centos",
            "Volumes": null,
            "WorkingDir": "",
            "Entrypoint": null,
            "OnBuild": null,
            "Labels": {
                "org.label-schema.build-date": "20210915",
                "org.label-schema.license": "GPLv2",
                "org.label-schema.name": "CentOS Base Image",
                "org.label-schema.schema-version": "1.0",
                "org.label-schema.vendor": "CentOS"
            }
        },
        "NetworkSettings": {
            "Bridge": "",
            "SandboxID": "4d4d550bf1de09f7ff118543ffdabd78639b5ad2ff2ef83ebcf1173fa641d6ea",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {},
            "SandboxKey": "/var/run/docker/netns/4d4d550bf1de",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "b3478faebc4ecf1045004d56b3604b6a4ba43ee7649b4e46a23875f6c16aac09",
            "Gateway": "172.18.0.1",
            "GlobalIPv6Address": "",
            "GlobalIPv6PrefixLen": 0,
            "IPAddress": "172.18.0.2",
            "IPPrefixLen": 16,
            "IPv6Gateway": "",
            "MacAddress": "02:42:ac:12:00:02",
            "Networks": {
                "bridge": {
                    "IPAMConfig": null,
                    "Links": null,
                    "Aliases": null,
                    "NetworkID": "071c273e37fa55ebbb91f6c1cef0bffa85e0358524d10528f1033622d59be653",
                    "EndpointID": "b3478faebc4ecf1045004d56b3604b6a4ba43ee7649b4e46a23875f6c16aac09",
                    "Gateway": "172.18.0.1",
                    "IPAddress": "172.18.0.2",
                    "IPPrefixLen": 16,
                    "IPv6Gateway": "",
                    "GlobalIPv6Address": "",
                    "GlobalIPv6PrefixLen": 0,
                    "MacAddress": "02:42:ac:12:00:02",
                    "DriverOpts": null
                }
            }
        }
    }
]

进入当前正在运行的容器

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

# 命令1
docker exec -it 容器id bashShell

# 测试
[root@logpumServer /]# docker ps
CONTAINER ID   IMAGE     COMMAND       CREATED          STATUS          PORTS     NAMES
e5842a6d2ce6   centos    "/bin/bash"   24 minutes ago   Up 24 minutes             nostalgic_bouman
[root@logpumServer /]# docker exec -it e5842a6d2ce6 /bin/bash
[root@e5842a6d2ce6 /]# ls
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var

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

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

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

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

# 测试
[root@logpumServer /]# docker attach e5842a6d2ce6
[root@e5842a6d2ce6 /]# cd /home
[root@e5842a6d2ce6 home]# ls
[root@e5842a6d2ce6 home]# touch test.java
[root@e5842a6d2ce6 home]# ls
test.java
[root@e5842a6d2ce6 home]# exit
exit
# 拷贝文件
[root@logpumServer /]# docker cp e5842a6d2ce6:/home/test.java /home
[root@logpumServer /]# cd /home
[root@logpumServer home]# ls
test.java  www

作业练习

Docker安装nginx

# 1.搜索镜像  建议去dockerhub
# 2.下载镜像  pull
# 3.运行测试  

# 下载镜像
[root@logpumServer /]# docker pull nginx
Using default tag: latest
latest: Pulling from library/nginx
a2abf6c4d29d: Pull complete 
a9edb18cadd1: Pull complete 
589b7251471a: Pull complete 
186b1aaa4aa6: Pull complete 
b4df32aa5a72: Pull complete 
a0bcbecc962e: Pull complete 
Digest: sha256:0d17b565c37bcbd895e9d92315a05c1c3c9a29f762b011a10c54a66cd53c9b31
Status: Downloaded newer image for nginx:latest
docker.io/library/nginx:latest

# 查看镜像
[root@logpumServer /]# docker images
REPOSITORY    TAG          IMAGE ID       CREATED        SIZE
nginx         latest       605c77e624dd   5 weeks ago    141MB
mysql         5.7          c20987f18b13   6 weeks ago    448MB
rabbitmq      management   6c3c2a225947   7 weeks ago    253MB
hello-world   latest       feb5d9fea6a5   4 months ago   13.3kB
centos        latest       5d0da3dc9764   4 months ago   231MB

# 启动镜像创建容器
# -d 后台运行
# --name 给容器命名
# -p 宿主机端口:容器内部端口
[root@logpumServer /]# docker run -d --name nginx01 -p 3344:80 nginx
5f21a67dc744a0abbf5570019fbb1f6679f53b0607566f9098283c0811b69e18

# 查看容器
[root@logpumServer /]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED              STATUS              PORTS                  NAMES
5f21a67dc744   nginx     "/docker-entrypoint.…"   About a minute ago   Up About a minute   0.0.0.0:3344->80/tcp   nginx01

# 运行测试
[root@logpumServer /]# curl localhost:3344
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
html { color-scheme: light dark; }
body { width: 35em; margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif; }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>

思考问题：我们每次改动nginx配置文件，都需要进入容器内部。十分麻烦，我要是可以在容器外部提供一个映射路径，达到在容器修改文件名，容器内部就可以自动修改

数据卷

作业：使用docker装一个tomcat

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

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

# 下载再启动
docker pull tomcat:9.0

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

# 测试访问没有问题

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

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

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

部署es + kibana

# es 暴露的端口很多
# es 十分耗内存
# es 数据一般需要放置到安全目录，挂载

# --net somenetwork  网络配置  在这里先不用

# 启动elasticsearch
docker run -d --name elasticsearch --net somenetwork -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2

# 启动了之后，linux服务器就变得很卡
docker stats   #查看cpu的状态

# 测试es是否成功了
curl localhost:9200

# 关闭后增加内存的限制，修改配置文件，-e 环境配置修改
docker run -d --name elasticsearch --net somenetwork -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.6.2

作业：使用kibana连接es

可视化

portainer
Rancher (CI/CD再用)

什么是portainer？

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

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

Docker镜像讲解

镜像是什么

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

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

如何得到镜像：

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

Docker 镜像加载原理

UnionFS（联合文件系统）

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

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

Docker镜像加载原理

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

bootfs(boot file system)主要包含bootload和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等等。

分层理解

分层的镜像

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

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

最大的好处：资源共享，比如有多个镜像都从相同的Base镜像构建而来,那么宿主机

只需在磁盘上保留一份base镜像,同时内存中也只需要加载一份base镜像,这样就可以为所有的容器服务了,而且镜像的每一层都可以被共享

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

[root@logpum ~]# docker images
REPOSITORY            TAG                 IMAGE ID            CREATED             SIZE
nginx                 latest              2622e6cca7eb        32 hours ago        132MB
portainer/portainer   latest              cd645f5a4769        9 days ago          79.1MB
redis                 latest              36304d3b4540        13 days ago         104MB
mysql                 latest              30f937e841c8        2 weeks ago         541MB
tomcat                9.0                 1b6b1fe7261e        3 weeks ago         647MB
elasticsearch         7.6.2               f29a1ee41030        2 months ago        791MB
elasticsearch         latest              5acf0e8da90b        20 months ago       486MB
[root@CZP ~]# docker image inspect redis
[
        "RootFS": {
            "Type": "layers",
            "Layers": [
                "sha256:ffc9b21953f4cd7956cdf532a5db04ff0a2daa7475ad796f1bad58cfbaf77a07",
                "sha256:d4e681f320297add0ede0554524eb9106d8c3eb3a43e6e99d79db6f76f020248",
                "sha256:59bd5a888296b623ae5a9efc8f18285c8ac1a8662e5d3775a0d2d736c66ba825",
                "sha256:c112794a20c5eda6a791cbec8700fb98eab30671a2248ac7e2059b475c46c45f",
                "sha256:bf8b736583f08c02b92f8a75ac5ea181e4d74107876177caa80ddad8b6b57a72",
                "sha256:6ef422d19214800243b28017d346c7ab9bfe63cb198a39312d1714394b232449"
            ]
    }
]

理解:

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

举一个简单的例子,假如基于Ubuntu Linux 16.64创建一个新的镜像,这就是新镜像的第一层,如果在该镜像中添加python包,就会在该镜像之上创建第二个镜像层; 如果继续添加一个安全补丁,就会创建第三个镜像层

该镜像已经包含3个镜像层,如下图所示(这只是一个简单的例子)

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

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

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

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

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

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

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

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

特点

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

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

如何自己提交一个镜像

Commit镜像

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

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

实战测试

# 1.启动一个默认的tomcat

# 2.发现这个默认的tomcat是没有webapps应用的，需要手动拷贝

# 3.自己拷贝了基本的文件

# 4.将操作过的容器通过commit提交为一个新的镜像，我们以后就可以用我们修改过的镜像，这就是我们自己的一个修改过的镜像

[root@logpumServer ~]# docker ps
CONTAINER ID   IMAGE                 COMMAND                  CREATED       STATUS       PORTS                    NAMES
d57b29e167a4   b8e65a4d736d          "/bin/bash"              2 hours ago   Up 2 hours   8080/tcp                 tomcat01
34ace91a23f4   portainer/portainer   "/portainer"             7 hours ago   Up 7 hours   0.0.0.0:8088->9000/tcp   flamboyant_dijkstra
5f21a67dc744   nginx                 "/docker-entrypoint.…"   2 days ago    Up 2 days    0.0.0.0:3344->80/tcp     nginx01
[root@logpumServer ~]# docker commit -a="logpum" -m="add webapps app" d57b29e167a4 mytomcat:1.0
sha256:960ad88c4938cbc9ef8e5ba8e4e101e878d98c26f626ff48177853b478a761d6
[root@logpumServer ~]# docker images
REPOSITORY            TAG          IMAGE ID       CREATED          SIZE
mytomcat              1.0          960ad88c4938   10 seconds ago   685MB
nginx                 latest       605c77e624dd   5 weeks ago      141MB
tomcat                9.0          b8e65a4d736d   6 weeks ago      680MB
mysql                 5.7          c20987f18b13   7 weeks ago      448MB
rabbitmq              management   6c3c2a225947   7 weeks ago      253MB
centos                latest       5d0da3dc9764   4 months ago     231MB
portainer/portainer   latest       580c0e4e98b0   10 months ago    79.1MB
elasticsearch         7.6.2        f29a1ee41030   22 months ago    791MB

如果想要保存当前容器的状态，就可以通过commit来提交从而获取一个镜像

容器数据卷

什么是容器数据卷

docker的理念：将应用和环境打包成一个镜像

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

例如：将Mysql安装在容器中，将容器删除后，数据库也就丢了，相当于删库跑路

容器之间可以有一个数据共享的技术。Docker容器中产生的数据，同步到本地，这就是卷技术。目录的挂载，将我们容器内的目录，挂载到Linux服务器上，说到底们就是为了容器的持久化和同步操作，容器间也是可以数据共享的

使用数据卷

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

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

# 测试
docker run -it -v /home/test:/home centos /bin/bash

# 启动起来的时候我们可以通过docker inspect 容器id查看挂载关系

测试文件的同步（双向绑定）：

容器停止后的测试：

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

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

实战：安装MySQL

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

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

# 启动数据库
[root@logpumServer test]# 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

# 启动成功之后，我们在本地使用slqyog来测试连接一下
# sqlyog-连接到服务器的3310  --->   3310和容器内的3306映射，这个时候我们就连接上了

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

如果将容器删除，挂载到本地的数据卷依旧没有丢失，这就实现了容器数据持久化功能

具名和匿名挂载

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

# 查看所有卷的情况
docker volume ls

[root@logpumServer /]# docker run -d -P -v /etc/nginx nginx
cdeb7ea30ce7db1a34e12dd9b9cc473c9cab18f699558bafd9221c745817c3df
[root@logpumServer /]# docker volume ls
DRIVER    VOLUME NAME
local     2b601773efbbf7dedda27f44cc28a750f5eaf4cee8163834ea554c6098020870
local     8fcedd3f213ba02a3ac0b30786f73bf0d531908ddb64339909eafbc90ca33511
local     236f5c2d2f32f31d13a2cdc0d1f6311db4303d44382e9b702b56ad8b21557b06
# 这种就是匿名挂载，我们只写了容器内的路径，没有写容器外的路径


# 具名挂载
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx

[root@logpumServer /]# docker run -d -P -v juming-nginx:/etc/nginx nginx
0b9a6e036e7e15b385052aa21c3b3c8bdbfc22f91b32b39ba7d9bb83d16f54a8
[root@logpumServer /]# docker volume ls
DRIVER    VOLUME NAME
local     2b601773efbbf7dedda27f44cc28a750f5eaf4cee8163834ea554c6098020870
local     8fcedd3f213ba02a3ac0b30786f73bf0d531908ddb64339909eafbc90ca33511
local     236f5c2d2f32f31d13a2cdc0d1f6311db4303d44382e9b702b56ad8b21557b06
local     juming-nginx

# -v 卷名：容器内路径
# 查看一下这个卷
[root@logpumServer /]# docker volume inspect juming-nginx
[
    {
        "CreatedAt": "2022-02-09T00:18:24+08:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/juming-nginx/_data",
        "Name": "juming-nginx",
        "Options": null,
        "Scope": "local"
    }
]

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

我们通过具名挂载可以方便地找到我们的卷，大多数情况下都是用具名挂载

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

拓展：

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

# 一旦设置了容器权限，容器对我们挂载出来的内容就有限定了，在容器里面就不能去操作了，只能在宿主机操作
docker run -d -P -v juming-nginx:/etc/nginx:ro nginx
docker run -d -P -v juming-nginx:/etc/nginx:rw nginx

初始DockerFile

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

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

# 创建一个dockerfile文件，名字可以随便，建议使用dockerfile

# 文件中的内容     指令（大写） 参数
FROM centos

# 匿名挂载
VOLUME ["volume01","volume02"]

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

# 这里的每个命令就是镜像的一层

# 启动自己写的容器

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

查看一下卷挂载的路径

这种方式我们未来使用得非常多，因为我们通常会构建自己的镜像

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

数据卷容器

多个mysql同步数据

docker01就叫做数据卷容器

再创建一个容器来继承docker01

docker01中也会同步docker03创建的内容

# 测试，可以删除docker01，如何查看一下docker02和03是否能够访问到文件
# 结果：可以

多个mysql实现数据共享

[root@logpumServer test]# 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@logpumServer test]# docker run -d -p 3310:3306 -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 --volumes-from mysql01 mysql:5.7

结论：

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

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

DockerFile

DockerFile介绍

dockerfile 是用来构建docker镜像的文件，就是一个命令参数脚本

构建步骤：

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

很多官网镜像都是基础包，很多功能没有，我们通常会自己搭建自己的镜像

官方既然可以制作镜像，那我们也可以

DockerFile构建过程

基础知识：

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

dockerfile是面向开发的，我们以后要发布项目，做镜像，就需要编写dockerfile文件

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

步骤：开发、部署、运维

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

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

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

DockerFile的指令

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

实战测试

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

创建一个自己的centos

# 1.编写dockerfile文件
[root@logpumServer dockerfile]# cat mydockerfile-centos 
FROM centos

MAINTAINER logpum<862819503@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 echo "-----end-----"
CMD /bin/bash

# 2.通过这个文件构建镜像
docker build -f mydockerfile-centos -t mycentos:0.1 .

# 我们可以列出本地镜像的变更历史
docker history 镜像id

CMD 和 ENTRYPOINT 的区别

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

测试cmd

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

# 构建镜像
[root@logpumServer dockerfile]# docker build -f dockerfile-cmd-test -t cmdtest .
Sending build context to Docker daemon  3.072kB
Step 1/2 : FROM centos
 ---> 5d0da3dc9764
Step 2/2 : CMD ["ls","-a"]
 ---> Running in 6a7c1b634c93
Removing intermediate container 6a7c1b634c93
 ---> cd67231fe474
Successfully built cd67231fe474
Successfully tagged cmdtest:latest

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

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

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

测试ENTRYPOINT

# 编写dockerfile文件
[root@logpumServer dockerfile]# cat dockerfile-entrypoint-test 
FROM centos
ENTRYPOINT ["ls","-a"]

# 构建镜像
[root@logpumServer dockerfile]# docker build -f dockerfile-entrypoint-test -t entrypoint-test .
Sending build context to Docker daemon  4.096kB
Step 1/2 : FROM centos
 ---> 5d0da3dc9764
Step 2/2 : ENTRYPOINT ["ls","-a"]
 ---> Running in 3b1252292c12
Removing intermediate container 3b1252292c12
 ---> 73754a639e65
Successfully built 73754a639e65
Successfully tagged entrypoint-test:latest

# run测试
[root@logpumServer dockerfile]# docker run 73754a639e65
.
..
.dockerenv
bin
dev
etc
home
lib
lib64
lost+found
media
mnt
opt
proc
root
run
sbin
srv
sys
tmp
usr
var

# 可以发现-l命令追加在原命令之后
[root@logpumServer dockerfile]# docker run 73754a639e65 -l
total 56
drwxr-xr-x   1 root root 4096 Feb  9 07:36 .
drwxr-xr-x   1 root root 4096 Feb  9 07:36 ..
-rwxr-xr-x   1 root root    0 Feb  9 07:36 .dockerenv
lrwxrwxrwx   1 root root    7 Nov  3  2020 bin -> usr/bin
drwxr-xr-x   5 root root  340 Feb  9 07:36 dev
drwxr-xr-x   1 root root 4096 Feb  9 07:36 etc
drwxr-xr-x   2 root root 4096 Nov  3  2020 home
lrwxrwxrwx   1 root root    7 Nov  3  2020 lib -> usr/lib
lrwxrwxrwx   1 root root    9 Nov  3  2020 lib64 -> usr/lib64
drwx------   2 root root 4096 Sep 15 14:17 lost+found
drwxr-xr-x   2 root root 4096 Nov  3  2020 media
drwxr-xr-x   2 root root 4096 Nov  3  2020 mnt
drwxr-xr-x   2 root root 4096 Nov  3  2020 opt
dr-xr-xr-x 137 root root    0 Feb  9 07:36 proc
dr-xr-x---   2 root root 4096 Sep 15 14:17 root
drwxr-xr-x  11 root root 4096 Sep 15 14:17 run
lrwxrwxrwx   1 root root    8 Nov  3  2020 sbin -> usr/sbin
drwxr-xr-x   2 root root 4096 Nov  3  2020 srv
dr-xr-xr-x  13 root root    0 Feb  8 17:00 sys
drwxrwxrwt   7 root root 4096 Sep 15 14:17 tmp
drwxr-xr-x  12 root root 4096 Sep 15 14:17 usr
drwxr-xr-x  20 root root 4096 Sep 15 14:17 var

DockerFile中很多命令都十分相似，我们需要了解他们的区别

实战：Tomcat镜像

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

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

FROM centos
MAINTAINER logpum<862819503@qq.com>

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

ADD jdk-8u321-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-9.0.58.tar.gz /usr/local/

RUN yum -y install vim

ENV MYPATH /usr/local
WORKDIR $MYPATH

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

EXPOSE 8080

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

构建镜像

docker build -t diytomcat .

启动镜像

docker run -d -p 9090:8080 --name logpumtomcat -v /home/logpum/build/tomcat/test:/usr/local/apache-tomcat-9.0.58/webapps/test -v /home/logpum/build/tomcat/tomcatlogs/:/usr/local/apache-tomcat-9.0.58/logs diytomcat

访问测试
发布项目（由于做了卷挂载，我们直接在本地编写项目就可以发布了）

<?xml version="1.0" encoding="UTF-8"?>
  <web-app xmlns="http://java.sun.com/xml/ns/javaee"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
                               http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
           version="2.5">

  </web-app>

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>hello,logpum</title>
</head>
<body>
Hello World!<br/>
<%
System.out.println("------my test web log-----");
%>
</body>
</html>

项目部署成功，可以直接访问

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

发布自己的镜像

DockerHub

在服务器上提交自己的镜像

登录完毕后可以提交镜像 docker push

# 登录
[root@logpumServer test]# docker login -u logpum
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@logpumServer test]# docker tag diytomcat logpum/diytomcat:1.0
[root@logpumServer test]# docker push logpum/diytomcat:1.0
The push refers to repository [docker.io/logpum/diytomcat]
a3da55a1bc67: Pushed 
6acc6d93a25d: Pushing [=====>                                             ]  38.64MB/365.3MB
bacf91608f51: Pushed 
74ddd0ec08fa: Mounted from library/centos

提交的时候也是按照镜像的层级来进行提交的

阿里云镜像服务

1、找到容器镜像服务

2、创建命名空间

3、创建容器镜像仓库

4、浏览阿里云

Docker网络

理解Docker0

三个网络

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

gdutlog

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Docker

Docker概述通过Docker可以把一个项目带上环境配置一起打包上线比较Docker和虚拟机技术的不同：传统虚拟机：虚拟出一条硬件，运行一个完整的操作系统，然后在这个系统上安装和运行软件容器内的应用直接运行在宿主机的内核，容器是没有自己的内核的，也没有虚拟我们的硬件，所以就轻便了每个容器间是互相隔离的，每个容器内都有一个属于自己的文件系统，互不影响DevOps (开发、运维)应用更快速得交付和部署传统：一堆帮助文档，安装程序Docker：打包镜像发布测试，一键运行更便捷
复制链接

扫一扫

专栏目录