PengBlog
0%

Docker

发表于 分类于
本文字数： 32k 阅读时长 ≈ 29 分钟

Docker

1.Docker概述

Docker的思想来源于集装箱！

JRE –多个应用 （端口冲突） –原来都是交叉的！

隔离：Docker核心思想！打包装箱！每个箱子是互相隔离的

1.1Docker能做什么

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

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

  • 传统虚拟机，虚拟出一条硬件，运行一个完整的操作系统，然后在系统上安装和运行软件
  • 容器内的应用直接运行在宿主机的内容，容器时是没有自己内核的
  • 每个容器内是互相隔离的，每个容器内都有一个属于自己的文件系统，互不影响

DevOps(开发，运维)

更快速地交付和部署

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

更便捷的升级和扩缩容

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

项目打包为一个镜像，扩展服务器A！服务器B

更简单的系统运维

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

更高效的计算资源利用

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

到极致。

1.2Docker基本组成

镜像（images）：

docker镜像就好比一个模板，可以通过这个模板来创建容器服务，

例如：tomcat镜像===>run ==>tomcat01容器(提供服务器)

通过这个镜像可以创建多个容器（最终服务运行或者项目运行就是在容器中）

容器（container）：

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

容器可以启动，停止，删除等基本命令

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

仓库（repository）：

仓库就是存放镜像的地方

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

1.3回顾Docker helloworld流程

1.run的运行流程图

https://www.freeimg.cn/i/2024/05/08/663b99472e6d7.jpg

1.4底层原理

Docker是怎么工作的？

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

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

https://www.freeimg.cn/i/2024/05/09/663c3667ac2ad.jpg

2.Docker的基本命令

2.1帮助命令

1
2
3
docker version #查看版本信息
docker info    #查看docker的系统信息，包括镜像和容器的数量
docker  命令  --help  #帮助命令

2.2 镜像命令

docker images

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
[root@wpeng /]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
hello-world   latest    d2c94e258dcb   12 months ago   13.3kB

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

#可选项
-a, --all             	#列出所有镜像
      --digests         Show digests
  -f, --filter filter   Filter output based on conditions provided
      --format string   Format output using a custom template:
                        'table':            Print output in table format with column headers (default)
                        'table TEMPLATE':   Print output in table format using the given Go template
                        'json':             Print in JSON format
                        'TEMPLATE':         Print output using the given Go template.
                        Refer to https://docs.docker.com/go/formatting/ for more information about formatting output with templates
      --no-trunc        Don't truncate output
  -q, --quiet           #只显示镜像的id

docker search 搜索镜像

1
2
3
4
5
6
7
8
[root@wpeng ~]# docker search mysql
NAME                            DESCRIPTION                                     STARS     OFFICIAL
mariadb                         MariaDB Server is a high performing open sou…   5722      [OK]
mysql                           MySQL is a widely used, open-source relation…   15008     [OK]
percona                         Percona Server is a fork of the MySQL relati…   627       [OK]

#可选项   
#通过收藏来过滤   --filter=StARS=3000  搜索3000以上收藏的

docker pull 下载镜像

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#下载镜像   docker pull 镜像名[:tag]
[root@wpeng ~]# docker pull mysql
Using default tag: latest   #如果不写tag，默认就是latest
latest: Pulling from library/mysql
0f6737e7f918: Pull complete   #分层下载   docker image的核心  联合文件系统
43ed19546d51: Pull complete 
501aa8e883de: Pull complete 
530c0b888a0f: Pull complete 
4670b7e1bbfd: Pull complete 
33d50b789abe: Pull complete 
7cd9fbae13f7: Pull complete 
34b7592f6de1: Pull complete 
6795b8ab791a: Pull complete 
09cffac37cee: Pull complete 
Digest: sha256:e4054c2973be8766370769312786404fbb4557fb591d9ad37beb2d00a2c574a6  #签名
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest	#真实地址

#以上命令等价于下方命令
docker pull mysql
docker pull docker.io/library/mysql:latest

#指定版本下载
docker pull mysql:8.0.20

docker rmi 删除镜像

1
2
3
[root@wpeng ~]#docker rmi -f 镜像id #删除指定的镜像
[root@wpeng ~]#docker rmi -f 镜像id 镜像id 镜像id 镜像id#删除指定的镜像
[root@wpeng ~]#docker rmi -f $(docker images -aq) #删除全部的镜像

2.3 容器命令

说明：我们有了镜像才可以创建容器 下一个alibaba cloud linux3镜像测试学习

1
docker pull alibaba-cloud-linux-3-registry.cn-hangzhou.cr.aliyuncs.com/alinux3/alinux3:220901.1

上述是下载杭州节点的镜像

新建容器并启动

1
2
3
4
5
6
7
8
9
10
11
12
13
docker run [可选参数] image

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

[root@wpeng ~]# docker run -it 镜像名或者镜像id /bin/bash

bash-4.4# ls  查看容器内的alibabalinux
bin  boot  dev	etc  home  lib	lib64  media  mnt  opt	proc  root  run  sbin  srv  sys  tmp  usr  var

列出所有运行中的容器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#docker ps  
	#列出当前正在运行的容器
-a	#列出当前正在运行的容器+历史运行过的容器
-n=?	#显示最近创建的容器  ？是数字  n=1就是显示最近一个创建的容器
-q #只显示容器的编号



[root@wpeng /]# docker ps        列出正在运行的容器，这里没有容器在运行，所以没有查处结果
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
[root@wpeng /]# docker ps -a	 加一个-a参数，列出现在以及历史运行的容器
CONTAINER ID   IMAGE          COMMAND       CREATED         STATUS                          PORTS     NAMES
6800a5514ec0   c54f2e68b09f   "/bin/bash"   4 minutes ago   Exited (0) About a minute ago             sharp_lovelace
77307f9c5e0b   hello-world    "/hello"      25 hours ago    Exited (0) 25 hours ago                   adoring_rubin

退出容器

1
2
exit  #直接容器停止并退出
ctrl +P +Q  #容器不停止退出

删除容器

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

启动和停止容器

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

2.4常用其他命令

后台启动容器

1
2
3
4
5
6
7
8
9
docker run -d 镜像名或者镜像id
root@wpeng ~]# docker run -d c54f2e68b09f
f589d68fae5ef55b40a0cb27cafb767069e941bf1b046cda87a8a23f3e41f308
#出现了问题，发现镜像停止了
[root@wpeng ~]# docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES

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

查看日志

1
2
3
4
5
6
7
docker logs  -tf --tail number 容器id #显示number条的日志
docker logs -tf  容器id     #显示所有日志

#显示日志
-tf   #显示日志   
		-t:timestamps 表示在输出的日志中包含时间戳
		-f：意味着持续跟进（follow）日志输出

查看容器中进程信息

1
2
3
4
5
6
7
8
docker top 容器id

[root@wpeng ~]# docker ps
CONTAINER ID   IMAGE          COMMAND       CREATED       STATUS       PORTS     NAMES
b049032b93eb   c54f2e68b09f   "/bin/bash"   4 hours ago   Up 4 hours             vigilant_spence
[root@wpeng ~]# docker top b049032b93eb
UID             PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                60523               60502               0                   12:49               pts/0               00:00:00            /bin/bash

查看镜像的元数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
docker inspect 容器id

#测试
[root@wpeng ~]# docker inspect b049032b93eb
[
    {
        "Id": "b049032b93ebf228dabc3f842ee475b9705fbd9a352a10052353faab52a101a8",
        "Created": "2024-05-10T04:49:41.711491571Z",
        "Path": "/bin/bash",
        "Args": [],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 60523,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2024-05-10T04:49:41.915405566Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:c54f2e68b09f57d742dee837edd20ca37b9fd052f8d1456b2b0777c0046528d0",
        "ResolvConfPath": "/var/lib/docker/containers/b049032b93ebf228dabc3f842ee475b9705fbd9a352a10052353faab52a101a8/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/b049032b93ebf228dabc3f842ee475b9705fbd9a352a10052353faab52a101a8/hostname",
        "HostsPath": "/var/lib/docker/containers/b049032b93ebf228dabc3f842ee475b9705fbd9a352a10052353faab52a101a8/hosts",
        "LogPath": "/var/lib/docker/containers/b049032b93ebf228dabc3f842ee475b9705fbd9a352a10052353faab52a101a8/b049032b93ebf228dabc3f842ee475b9705fbd9a352a10052353faab52a101a8-json.log",
        "Name": "/vigilant_spence",
        "RestartCount": 0,
        "Driver": "overlay2",
        "Platform": "linux",
        "MountLabel": "",
        "ProcessLabel": "",
        "AppArmorProfile": "",
        "ExecIDs": null,
        "HostConfig": {
            "Binds": null,
            "ContainerIDFile": "",
            "LogConfig": {
                "Type": "json-file",
                "Config": {}
            },
            "NetworkMode": "bridge",
            "PortBindings": {},
            "RestartPolicy": {
                "Name": "no",
                "MaximumRetryCount": 0
            },
            "AutoRemove": false,
            "VolumeDriver": "",
            "VolumesFrom": null,
            "ConsoleSize": [
                41,
                187
            ],
            "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",
            "Isolation": "",
            "CpuShares": 0,
            "Memory": 0,
            "NanoCpus": 0,
            "CgroupParent": "",
            "BlkioWeight": 0,
            "BlkioWeightDevice": [],
            "BlkioDeviceReadBps": [],
            "BlkioDeviceWriteBps": [],
            "BlkioDeviceReadIOps": [],
            "BlkioDeviceWriteIOps": [],
            "CpuPeriod": 0,
            "CpuQuota": 0,
            "CpuRealtimePeriod": 0,
            "CpuRealtimeRuntime": 0,
            "CpusetCpus": "",
            "CpusetMems": "",
            "Devices": [],
            "DeviceCgroupRules": null,
            "DeviceRequests": null,
            "MemoryReservation": 0,
            "MemorySwap": 0,
            "MemorySwappiness": null,
            "OomKillDisable": false,
            "PidsLimit": null,
            "Ulimits": [],
            "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",
                "/sys/devices/virtual/powercap"
            ],
            "ReadonlyPaths": [
                "/proc/bus",
                "/proc/fs",
                "/proc/irq",
                "/proc/sys",
                "/proc/sysrq-trigger"
            ]
        },
        "GraphDriver": {
            "Data": {
                "LowerDir": "/var/lib/docker/overlay2/9bb0667c3640a03ae8bbb2d698bc030fd5e9a5027d48c0fa48f42bf607472496-init/diff:/var/lib/docker/overlay2/4fabcb33a99857d5f701a9d733a0407faef4f760993cf19c5cca603c16dc27f5/diff",
                "MergedDir": "/var/lib/docker/overlay2/9bb0667c3640a03ae8bbb2d698bc030fd5e9a5027d48c0fa48f42bf607472496/merged",
                "UpperDir": "/var/lib/docker/overlay2/9bb0667c3640a03ae8bbb2d698bc030fd5e9a5027d48c0fa48f42bf607472496/diff",
                "WorkDir": "/var/lib/docker/overlay2/9bb0667c3640a03ae8bbb2d698bc030fd5e9a5027d48c0fa48f42bf607472496/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [],
        "Config": {
            "Hostname": "b049032b93eb",
            "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": "c54f2e68b09f",
            "Volumes": null,
            "WorkingDir": "/",
            "Entrypoint": null,
            "OnBuild": null,
            "Labels": {
                "org.label-schema.build-date": "20220830",
                "org.label-schema.license": "GPLv2",
                "org.label-schema.name": "Alinux3 Base Image",
                "org.label-schema.schema-version": "1.0",
                "org.label-schema.vendor": "Alibaba Cloud"
            }
        },
        "NetworkSettings": {
            "Bridge": "",
            "SandboxID": "5093b0c24d349da1366a160ccf8a6b34453e48241c3739973897cd53eaffbaf7",
            "SandboxKey": "/var/run/docker/netns/5093b0c24d34",
            "Ports": {},
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "3ba3f966c5fe8dffcc94466187ac59bf8367236a889abc542f412647c4e29b6d",
            "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,
                    "MacAddress": "02:42:ac:11:00:02",
                    "NetworkID": "4888153fb4139c358ffdff11975f7acf918721ae5725a8f06e6687a53668279e",
                    "EndpointID": "3ba3f966c5fe8dffcc94466187ac59bf8367236a889abc542f412647c4e29b6d",
                    "Gateway": "172.17.0.1",
                    "IPAddress": "172.17.0.2",
                    "IPPrefixLen": 16,
                    "IPv6Gateway": "",
                    "GlobalIPv6Address": "",
                    "GlobalIPv6PrefixLen": 0,
                    "DriverOpts": null,
                    "DNSNames": null
                }
            }
        }
    }
]

进入当前正在运行的容器

1
2
3
4
5
6
7
8
9
10
11
12
13
#我们通常容器都是使用后台方式进行的，需要进入容器，需要修改一些配置

#命令 
docker exec -it  容器id  /bin/bash


#方式二
docker attach 容器id
正在执行当前的代码

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
docker cp 容器id:容器内路径  目的主机路径

[root@wpeng home]# docker ps
CONTAINER ID   IMAGE          COMMAND       CREATED          STATUS          PORTS     NAMES
52b9662ad370   c54f2e68b09f   "/bin/bash"   52 minutes ago   Up 52 minutes             elated_khayyam
[root@wpeng home]# docker attach 52b9662ad370
bash-4.4# cd /home
bash-4.4# ls
bash-4.4# touch test.java
bash-4.4# ls
test.java
bash-4.4# read escape sequence
[root@wpeng home]# docker cp 52b9662ad370:/home/test.java /home
Successfully copied 1.54kB to /home
[root@wpeng home]# ls
Mytest  test.java  wpeng

#拷贝是一个手动过程  未来我们使用-v卷的技术，可以实现打通主机与容器  例如主机下的/home目录和容器内的/home目录同步

3.作业练习

Docker安装nginx

1
2
3
4
5
6
7
8
9
10
#1.搜索镜像  docker search 镜像名字
#2.下载镜像  docker pull 镜像名字 

# -d 后台运行 --name nginx01  起别名为nginx01  -p 3344:80  主机端口，容器端口 内部端口是80，但是外网访问的是3344端口
[root@wpeng /]# docker run -d --name nginx01 -p 3344:80 nginx
29d82b8d3586f8e8831756410d90ef5ba31561460790da6b3bc9b80d0ddb706a
[root@wpeng /]# docker ps
CONTAINER ID   IMAGE          COMMAND                  CREATED             STATUS             PORTS                                   NAMES
29d82b8d3586   nginx          "/docker-entrypoint.…"   8 seconds ago       Up 7 seconds       0.0.0.0:3344->80/tcp, :::3344->80/tcp   nginx01

Docker安装tomcat

1
2
3
4
5
6
7
8
9
10
11
#官方使用  
docker run -it --rm tomcat:9.0

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

#下载再启动
docker pull tomcat
#启动运行
[root@wpeng ~]# docker run -d --name tomcat01 tomcat
abe42510023f787c38cfe38bc5ed99ae88e78baa479be84223e9aef21e177af8

Docker部署es+kibana

1
2
3
4
5
6
7
#es  暴露的端口很多
#es  十分的耗内存
#es 的数据一般需要放置到安全目录！挂载

#启动 elasticsearch
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:版本号
#--net somenetwork 网络配置

4.可视化

4.1portainer

1
2
3
4
5
6
7
8
9
# 查询当前有哪些Portainer镜像
docker search portainer

# 下载镜像
docker pull portainer/portainer

# 运行portainerUI图形界面
# -d后台运行 --name 命名 -p 端口映射(需要确认端口号是开放的) -v挂载(后面博客详说)
docker run -d --name portainerUI -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock -restart=always --privileged=true portainer/portainer

什么是portainer？

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

Rancher

5.Docker镜像讲解

5.1镜像是什么

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

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

如何得到镜像呢

  • 从远程仓库下载
  • 别人拷贝给你
  • 自己制作一个镜像 docker file

5.2Docker镜像加载原理

UnionFs （联合文件系统）

我们下载的时候看到一层层的下载就是这个。

UnionFs（联合文件系统）：Union文件系统（UnionFs）是一种分层、轻量级并且高性能的文件系统，他支

持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下（

unite several directories into a single virtual filesystem)。Union文件系统是

Docker镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作各种具体的应

用镜像。

特性：一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系

统叠加起来，这样最终的文件系统会包含所有底层的文件和目录。

5.3分层理解

https://blog.csdn.net/weixin_46618592/article/details/126555359

https://www.freeimg.cn/i/2024/05/11/663f920212692.jpg

5.4 commit镜像

1
2
3
4
5
docker commit  提交容器成为一个新的副本

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

实战测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#启动一个默认的tomcat
docker exec -it 5a2a89b5dd88 /bin/bash

#发现这个默认的tomcat是没有webapps应用，  镜像的原因，官方的镜像默认webapps下面是没有文件的
root@5a2a89b5dd88:/usr/local/tomcat# cd webapps
root@5a2a89b5dd88:/usr/local/tomcat/webapps# ls

#我自己拷贝进去了基本的文件
root@5a2a89b5dd88:/usr/local/tomcat# cd webapps.dist/
root@5a2a89b5dd88:/usr/local/tomcat/webapps.dist# ls
docs  examples  host-manager  manager  ROOT

root@5a2a89b5dd88:/usr/local/tomcat# cp -r  webapps.dist/* webapps
root@5a2a89b5dd88:/usr/local/tomcat# cd webapps
root@5a2a89b5dd88:/usr/local/tomcat/webapps# ls
docs  examples  host-manager  manager  ROOT


添加镜像

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
[root@wpeng /]docker ps        
CONTAINER ID   IMAGE                 COMMAND             CREATED          STATUS          PORTS                                                           NAMES
5a2a89b5dd88   tomcat                "catalina.sh run"   12 minutes ago   Up 12 minutes   8080/tcp                                                        unruffled_visvesvaraya
af1186a6d300   portainer/portainer   "/portainer"        40 hours ago     Up 40 hours     8000/tcp, 9443/tcp, 0.0.0.0:9000->9000/tcp, :::9000->9000/tcp   portainerUI

[root@wpeng /]# docker commit  -a="wpeng" -m="add webapps application" 5a2a89b5dd88 tomcat02:1.0
sha256:e337f0c3d17aacf7cc88a4ab64c31f8574703310f73c59f36d441f8bd69fd30d
[root@wpeng /]# docker images
REPOSITORY                                                                   TAG        IMAGE ID       CREATED         SIZE
tomcat02                                                                     1.0        e337f0c3d17a   5 seconds ago   460MB
nginx                                                                        latest     1d668e06f1e5   9 days ago      188MB
tomcat                                                                       latest     fca42eb4b550   10 days ago     455MB
mysql                                                                        latest     f3df03e3cfc9   11 days ago     585MB
hello-world                                                                  latest     d2c94e258dcb   12 months ago   13.3kB
portainer/portainer                                                          latest     5f11582196a4   17 months ago   287MB
alibaba-cloud-linux-3-registry.cn-hangzhou.cr.aliyuncs.com/alinux3/alinux3   220901.1   c54f2e68b09f   20 months ago   162MB
elasticsearch                                                                7.6.2      f29a1ee41030   4 years ago     791MB
  #tomcat02就是我们自己修改过的镜像，以后使用我们自己的镜像

6.容器数据卷

6.1什么是容器数据卷

docker理念回顾、

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

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

Mysql，容器删除了数据就会丢失！==需求：Mysql数据可以存储在本地==

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

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

https://www.freeimg.cn/i/2024/05/13/6641b5ba591ae.jpg

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

6.2使用数据卷

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

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

测试

1
[root@wpeng home]# docker run -it -v /home/ceshi:/home tomcat /bin/bash
1
2
3
4
5
6
7
8
9
10
11
12
#启动起来之后，可以通过docker inspect 容器id   查看容器的元数据，可以找到下方的挂载

"Mounts": [
          {
              "Type": "bind",
              "Source": "/home/ceshi",    #主机内的目录
              "Destination": "/home",		#容器内的目录
              "Mode": "",
              "RW": true,
              "Propagation": "rprivate"
          }
      ],

6.3实战：部署Mysql

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

1
2
[root@wpeng /]# docker run -d -p 3307:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=Mypasseord --name mysql01 mysql
#挂机到本地

6.4具名和匿名挂载

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#匿名挂载
-v  容器内路径
docker run -d -P --name nginx01 -v /etc/nginx  nginx

[root@wpeng data]# docker volume --help
Usage:  docker volume COMMAND
Manage volumes

Commands:
  create      Create a volume
  inspect     Display detailed information on one or more volumes
  ls          List volumes
  prune       Remove unused local volumes
  rm          Remove one or more volumes

Run 'docker volume COMMAND --help' for more information on a command.
#查看所有卷的情况
[root@wpeng data]# docker volume ls
DRIVER    VOLUME NAME
local     09ed66408d0ea4f3cede2deb02050a0bada25b157888fcda3f1166fea9270c8b
local     36c362bddff71830d36d3a6c32aee9b7a8c8f486d1bcc33e0281e77c9b22b579
local     125b1bde7fa779c129b710c6b2a3d5295c6e1073bad17a53fe1484355d19022e
local     03027f475b79a21b49b0ca7c6950f333151c6cc1f35f0f1735b4d2572ef9ae08
local     959225beaef8d8194aed30d2c96ecb1199b73f5be6e2cd9547d3696ecf90f13b
local     b7016e08f4d6e6cd186815c6778a7831be7e43ba48ea9f0eb370bb756388ee6c
local     ccf907023afe4669577ce46e75b403bbe30f8ed3fdb53e7be3c22e0de57a8680
local     d7b8b4150ebc6d374d39ac8d35e2f598cafd7b8bdb2c44a3f77e3cef09537df1
local     dbb2225560dd9c26105084169118989d03176d98fcc0490246155d820950c684

具名挂载

1
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx

区别

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

拓展：

1
2
3
4
5
6
7
#通过 -v 容器内路径:ro rw 改变读写权限
ro   readonly    #只读
rw	 readwrite	 #读写
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:ro rw nginx
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:ro rw nginx

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

6.5初始Dockerfile

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

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

1
2
3
4
5
6
7
8
9
FROM centos

VOLUME ["volume01","volume02"]

CMD echo "-----end-----"

CMD /bin/bash
#上述的命令，就是镜像的一层

构建镜像

1
docker build -f /home/docker-test-volume/dockerfile -t wpeng/centos:1.0 .

==复制粘贴时，小心细节，结尾一定要加空格再加点==。

1
2
3
4
5
#启动自己生成的容器
[root@wpeng ~]# docker run -it 9b5949716ba8 /bin/bash
#使用ls命令，查看目录发现两个挂载的目录
drwxr-xr-x   2 root root 4096 May 14 02:38 volume01
drwxr-xr-x   2 root root 4096 May 14 02:38 volume02

==发现了这两个卷，说明外部一定有同步的目录==

1
2
#使用inspect命令查看镜像元数据
docker inspect 容器id

https://www.freeimg.cn/i/2024/05/14/6642d5b191c27.png

在mounts下可以找到容器内挂载目录在宿主机上对应的目录，就是source目录

在宿主机下找到这个目录

1
2
3
[root@wpeng /]# cd /var/lib/docker/volumes/d4a1b49ca6e2b10dde089f27d7ef5459b5b7e03aed4f42fbbea05961131f22e5/_data
[root@wpeng _data]# ls
container.txt

可以看到该目录下有一个container.txt

6.6数据卷容器

多个mysql同步数据

https://www.freeimg.cn/i/2024/05/13/66422773b10ff.jpg

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#先启动一个容器
[root@wpeng /]# docker run -it --name docker01 wpeng/centos:1.0 
#再启动一个容器，父容器是docker01
[root@wpeng /]# docker run -it --name docker02 --volumes-from docker01 wpeng/centos:1.0

#在docker01容器中创建一个container.txt
[root@wpeng ~]# docker exec -it 1440424683e5 /bin/bash
[root@1440424683e5 /]# ls    
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var  volume01	volume02
[root@1440424683e5 /]# cd volume01
[root@1440424683e5 volume01]# ls
[root@1440424683e5 volume01]# touch container.txt
[root@1440424683e5 volume01]# ls
container.txt


#发现在docker02容器中也发现了container.txt
[root@wpeng ~]# docker run -it --name docker02 --volumes-from docker01 9b5949716ba8
[root@cc09ccf13df0 /]# ls
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var  volume01	volume02
[root@cc09ccf13df0 /]# cd volume01
[root@cc09ccf13df0 volume01]# ls
container.txt

==上述容器docker02依赖于docker01，执行删除docker01容器之后，docker02里面的数据还是存在的，实现了共享与备份==

多个mysql实现数据共享

1
2
3
[root@wpeng /]# docker run -d -p 3307:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=Mypassword --name mysql01 mysql

[root@wpeng /]# docker run -d -p 3308:3306  -e MYSQL_ROOT_PASSWORD=Mypassword --name mysql02 --volumes -from mysql01 mysql

结论

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

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

7.DockerFile

7.1DockerFile介绍

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

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

构建步骤：

  1. 编写一个dockerfile文件
  2. docker build 一个镜像
  3. docker run 运行镜像
  4. 通过docker push 发布镜像（DockerHub，阿里云镜像仓库）

7.2DockerFile构建过程

基础知识

  1. 每个保留关键字（指令）都必须是大写字母
  2. 执行从上到下顺序执行
  3. #表示注释
  4. 每一个指令都会创建提交一个新的镜像层，并提交https://www.freeimg.cn/i/2024/05/14/66433726dd7a8.jpg

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

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

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

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

7.3DockerFile的指令

https://www.freeimg.cn/i/2024/05/14/664339d6b8a72.png

1
2
3
4
5
6
7
8
9
10
11
12
FROM		#基础镜像，一切从这里构建
MAINTAINER  #镜像的作者，一般姓名+邮箱
RUN			#镜像构建的时候需要运行的命令
ADD			#步骤：如果需要添加tomcat镜像，则需要tomcat压缩包！添加内容
WORKDIR		#镜像的工作目录  
VOLUME		#挂载的目录位置
EXPOSE		#暴露端口配置   和-p是一个作用，如果expose了就不需要-p暴露端口了
CMD			#指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT  #指定这个容器启动的时候要运行的命令，可以直接追加命令
ONBUILD     #当构建一个被继承DockerFile，这个时候就会运行ONBUILD的指令，触发指令
COPY		#类似于ADD命令，将我们的文件拷贝到镜像中
ENV			#构建的时候设置环境变量

==CMD和ENTRYPOINT的区别==

CMD

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#启动的时候会列出列表
[root@wpeng dockerfile]# cat dockerfile-test-cmd 
FROM  centos
CMD ["ls","-a"]

#构建镜像
[root@wpeng dockerfile]# docker build -f dockerfile-test-cmd -t cmdtest .

#运行，可以看到运行结果直接列出目录，run的时候会执行ls -a命令
[root@wpeng dockerfile]# docker run cmdtest
.
..
.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@wpeng dockerfile]# docker run cmdtest -l
docker: Error response from daemon: failed to create task for container: failed to create shim task: OCI runtime create failed: runc create failed: unable to start container process: exec: "-l": executable file not found in $PATH: unknown.

#cmd的情况下  -l替换了CMD["ls","-a"]命令，但是-l不是命令，所以报错
#想解决错误，只能[root@wpeng dockerfile]# docker run cmdtest ls -al

ENTRYPOINT

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#启动的时候会出现列表
[root@wpeng dockerfile]# cat dockerfile-cmd-entrypoint 
FROM centos
ENTRYPOINT ["ls","-a"]

#构建镜像
[root@wpeng dockerfile]# docker build -f dockerfile-cmd-entrypoint -t entrypoint-test .

#附加-l参数启动容器，我们的追加命令直接拼接在ENTRYPOINT命令的后面
[root@wpeng dockerfile]# docker run entrypoint-test -l
total 56
drwxr-xr-x   1 root root 4096 May 15 02:59 .
drwxr-xr-x   1 root root 4096 May 15 02:59 ..
-rwxr-xr-x   1 root root    0 May 15 02:59 .dockerenv
lrwxrwxrwx   1 root root    7 Nov  3  2020 bin -> usr/bin
drwxr-xr-x   5 root root  340 May 15 02:59 dev
drwxr-xr-x   1 root root 4096 May 15 02:59 etc
drwxr-xr-x   2 root root 4096 Nov  3  2020 home
lrwxrwxrwx   1 root root    7 Nov  3  2020 lib -> usr/lib
lrwxrwxrwx   1 root root    9 Nov  3  2020 lib64 -> usr/lib64
drwx------   2 root root 4096 Sep 15  2021 lost+found
drwxr-xr-x   2 root root 4096 Nov  3  2020 media
drwxr-xr-x   2 root root 4096 Nov  3  2020 mnt
drwxr-xr-x   2 root root 4096 Nov  3  2020 opt
dr-xr-xr-x 231 root root    0 May 15 02:59 proc
dr-xr-x---   2 root root 4096 Sep 15  2021 root
drwxr-xr-x  11 root root 4096 Sep 15  2021 run
lrwxrwxrwx   1 root root    8 Nov  3  2020 sbin -> usr/sbin
drwxr-xr-x   2 root root 4096 Nov  3  2020 srv
dr-xr-xr-x  13 root root    0 May 15 02:59 sys
drwxrwxrwt   7 root root 4096 Sep 15  2021 tmp
drwxr-xr-x  12 root root 4096 Sep 15  2021 usr
drwxr-xr-x  20 root root 4096 Sep 15  2021 var

7.4实战测试

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

https://www.freeimg.cn/i/2024/05/14/66434f85cbc40.png

创建一个自己的centos

1.编写dockerfile的编写文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
[root@wpeng home]# cd dockerfile 
[root@wpeng dockerfile]# ls
[root@wpeng dockerfile]# vim wpengdockerfile

[root@wpeng dockerfile]# cat wpengdockerfile 
FROM centos
MAINTAINER wpeng<2119026961@qq.com>

ENV MYPATH /usr/local
WORKDIR $MYPATH

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

EXPOSE 8090

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

2.通过这个文件构建镜像

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
[root@wpeng dockerfile]# docker build -f wpengdockerfile -t mycentos:0.1 .
[+] Building 14.9s (9/9) FINISHED                                                                                          docker:default
 => [internal] load build definition from wpengdockerfile                                                                            0.0s
 => => transferring dockerfile: 473B                                                                                                 0.0s
 => [internal] load metadata for docker.io/library/centos:latest                                                                     0.0s
 => [internal] load .dockerignore                                                                                                    0.0s
 => => transferring context: 2B                                                                                                      0.0s
 => [1/5] FROM docker.io/library/centos:latest                                                                                       0.0s
 => CACHED [2/5] WORKDIR /usr/local                                                                                                  0.0s
 => [3/5] RUN sed -i 's|^mirrorlist=|#mirrorlist=|g' /etc/yum.repos.d/CentOS-*.repo     && sed -i 's|^#baseurl=http://mirror.centos  5.5s
 => [4/5] RUN yum -y install vim                                                                                                     6.2s 
 => [5/5] RUN yum -y install net-tools                                                                                               2.1s 
 => exporting to image                                                                                                               1.1s 
 => => exporting layers                                                                                                              1.0s 
 => => writing image sha256:bb179add7bd4004d7112989dba95ddc1a361713854f6839a01d636acc36c060e                                         0.0s 
 => => naming to docker.io/library/mycentos:0.1

3.测试运行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
[root@wpeng dockerfile]# docker run -it mycentos:0.1
[root@11b0db9ce40c local]# pwd 
/usr/local
[root@11b0db9ce40c local]# ifconfig
eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 172.17.0.10  netmask 255.255.0.0  broadcast 172.17.255.255
        ether 02:42:ac:11:00:0a  txqueuelen 0  (Ethernet)
        RX packets 14  bytes 1181 (1.1 KiB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
        inet 127.0.0.1  netmask 255.0.0.0
        inet6 ::1  prefixlen 128  scopeid 0x10<host>
        loop  txqueuelen 1000  (Local Loopback)
        RX packets 0  bytes 0 (0.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

[root@11b0db9ce40c local]# vim test
[root@11b0db9ce40c local]# ls
bin  etc  games  include  lib  lib64  libexec  sbin  share  src  test

#官方原生的
pwd是根目录，我们这里配置了工作目录 /usr/local
官方没有vim命令，我们配置的镜像会有vim命令

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

docker histtory 镜像名或者id

7.5制作Tomcat镜像

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

1
2
3
4
5
6
7
[root@wpeng ~]# cd /home
[root@wpeng home]# ls
Mytest  ceshi  docker-test-volume  dockerfile  mysql  test.java  wpeng
[root@wpeng home]# cd wpeng/
[root@wpeng wpeng]# ls
apache-tomcat-9.0.87  apache-tomcat-9.0.87.tar.gz  jdk-8u202-linux-x64.tar.gz  jdk1.8.0_202

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
[root@wpeng wpeng]# vim Dockerfile

FROM centos: 7
MAINTAINER wpeng<2119026961@qq.com>

ADD jdk-8u202-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-9.0.87.tar.gz /usr/local/

RUN yum -y install vim

ENV MYPATH /usr/local
WORKDIR $MYPATH

ENV JAVA_HOME /usr/local/jdk1.8.0_11
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.87
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.87
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

EXPOSE 8091

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

3.构建镜像

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
[root@wpeng wpeng]# docker build -t diytomcat .
[+] Building 0.0s (1/1) FINISHED                                                                                           docker:default
 => [internal] load build definition from Dockerfile                                                                                 0.0s
 => => transferring dockerfile: 635B                                                                                                 0.0s
Dockerfile:1
--------------------
   1 | >>> FROM centos: 7
   2 |     MAINTAINER wpeng<2119026961@qq.com>
   3 |     
--------------------
ERROR: failed to solve: dockerfile parse error on line 1: FROM requires either one or three arguments
[root@wpeng wpeng]# vim dockerfile
[root@wpeng wpeng]# vim Dockerfile 
[root@wpeng wpeng]# docker build -t diytomcat .
[+] Building 51.7s (10/10) FINISHED                                                                                        docker:default
 => [internal] load build definition from Dockerfile                                                                                 0.0s
 => => transferring dockerfile: 634B                                                                                                 0.0s
 => [internal] load metadata for docker.io/library/centos:7                                                                          3.7s
 => [internal] load .dockerignore                                                                                                    0.0s
 => => transferring context: 2B                                                                                                      0.0s
 => [1/5] FROM docker.io/library/centos:7@sha256:be65f488b7764ad3638f236b7b515b3678369a5124c47b8d32916d6487418ea4                   22.1s
 => => resolve docker.io/library/centos:7@sha256:be65f488b7764ad3638f236b7b515b3678369a5124c47b8d32916d6487418ea4                    0.0s
 => => sha256:be65f488b7764ad3638f236b7b515b3678369a5124c47b8d32916d6487418ea4 1.20kB / 1.20kB                                       0.0s
 => => sha256:dead07b4d8ed7e29e98de0f4504d87e8880d4347859d839686a31da35a3b532f 529B / 529B                                           0.0s
 => => sha256:eeb6ee3f44bd0b5103bb561b4c16bcb82328cfe5809ab675bb17ab3a16c517c9 2.75kB / 2.75kB                                       0.0s
 => => sha256:2d473b07cdd5f0912cd6f1a703352c82b512407db6b05b43f2553732b55df3bc 76.10MB / 76.10MB                                    18.3s
 => => extracting sha256:2d473b07cdd5f0912cd6f1a703352c82b512407db6b05b43f2553732b55df3bc                                            3.4s
 => [internal] load build context                                                                                                    1.6s
 => => transferring context: 205.84MB                                                                                                1.6s
 => [2/5] ADD jdk-8u202-linux-x64.tar.gz /usr/local/                                                                                 4.4s
 => [3/5] ADD apache-tomcat-9.0.87.tar.gz /usr/local/                                                                                0.4s
 => [4/5] RUN yum -y install vim                                                                                                    17.7s
 => [5/5] WORKDIR /usr/local                                                                                                         0.0s 
 => exporting to image                                                                                                               3.2s 
 => => exporting layers                                                                                                              3.2s 
 => => writing image sha256:70cec7e14015b6051ea93fc15d530151d092682565790deb41fb464e65c044cc                                         0.0s 
 => => naming to docker.io/library/diytomcat

7.6发布自己的镜像

发布镜像到dockerhub上

1.登录到dockerhub上

2.在我们的服务器上提交自己的镜像

1
2
3
4
5
6
7
8
9
10
11
[root@wpeng ~]# docker login --help

Usage:  docker login [OPTIONS] [SERVER]

Log in to a 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

3.登录完毕后就可以提交镜像了，就是一步docker push

1
2
3
4
5
6
7
8
#1.项目创建完成后，返回控制台，列出所有镜像
docker images

#2、将要发布的镜像修改标记，标记为自己账号下。此处我的项目名：yuki03233
docker tag consul yuki03233/consul

#3、发布镜像
docker push yuki03233/consul

发布镜像到阿里云服务器上

1.登录阿里云，找到镜像服务

2.创建命名空键7

3.创建容器镜像

8.Docker网络

8.1 理解docker0

三个网络

1
2
3
4
5
6
7
8
#docker 是如何处理容器网络访问的

#查看容器的内部网络地址  ip addr

docker inspect container-id  #审查容器

#linux可以ping通docker容器内部

原理

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

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

8.2 自定义网络

查看所有的docker网络

1
docker network ls

网络模式

bridge：桥接 docker （默认，使用veth技术）

none：不配置网络

host：主机模式，和宿主机共享网络

container：容器网络联通（用的少，局限性很大

1
2
3
4
5
6
7
8
9
10
#创建网络
[root@wpeng /]# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
b23f86d94b2f50d050aed77f82d62ad94d537f86c4f0399606b66ab8c2807868
[root@wpeng /]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
c539b81d49ac   bridge    bridge    local
06e90eab0aaf   host      host      local
b23f86d94b2f   mynet     bridge    local
6cd224f00fba   none      null      local
05af1142be47   zk        bridge    local

检查自己的网络

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
[root@wpeng /]# docker network inspect mynet
[
    {
        "Name": "mynet",
        "Id": "b23f86d94b2f50d050aed77f82d62ad94d537f86c4f0399606b66ab8c2807868",
        "Created": "2024-06-18T23:26:12.7419496+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": {},
            "Config": [
                {
                    "Subnet": "192.168.0.0/16",
                    "Gateway": "192.168.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Ingress": false,
        "ConfigFrom": {
            "Network": ""
        },
        "ConfigOnly": false,
        "Containers": {},
        "Options": {},
        "Labels": {}
    }
]

8.3 网络联通