docker镜像构建

最新推荐文章于 2024-01-13 12:29:30 发布
最新推荐文章于 2024-01-13 12:29:30 发布
阅读量245 收藏 2
点赞数
分类专栏： docker 文章标签： docker linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42152531/article/details/120152817
版权

docker镜像构建

文件系统

linux操作系统由内核空间和用户空间组成。其中内核空间是kernel，对应的文件系统时bootfs，linux在刚启动的时候会加载bootfs文件系统，在启动完成以后会卸载bootfs。用户空间是rootfs文件系统，包括我们常用/etc、/proc、/bin、/dev等，如下图所示：
在这里插入图片描述
一般镜像结构如下：
在这里插入图片描述
在Image上还会有很多的Image。只有bootfs上面一层那个Image是base Image。（rootfs）

对于任何docker镜像，其文件系统都是与宿主机共用kernel，共用bootfs，但是不共用rootfs。容器的rootfs由容器自己提供。
对于一个镜像，如果其base镜像（bootfs上面一层的那个镜像层）不是操作系统镜像，而是自己写的一个镜像，那么该镜像的文件系统就是自己拷贝过去的文件目录。
比如，自己写了一个helloworld的代码，使用dockerfile构建docker镜像。

FROM scratch		白手起家从0构建一个镜像
COPY hello /		将文件"hello"复制到镜像的根目录，镜像根目录是/
CMD ["hello"]		容器启动时，执行/hello

base镜像一般时底层，同时也能被其他镜像将其作为基础进行扩展。

镜像构建

Docker Daemon在构建dockerfile的过程中，对dockerfile中的每一条命令（FROM命令除外）都会构建一个新的image。
例如用如下命令构建镜像：
在这里插入图片描述
构建过程如下：
在这里插入图片描述
构建出来的镜像层，在容器中都只是可读，不可写，也就是说，在容器运行过程中，对镜像进行修改操作时不会修改镜像的，只会修改镜像层以上的容器层。

当容器启动时，会在镜像层上创建一个新的容器层，该层是可读可写层，容器启动以后的结构如下所示：
在这里插入图片描述
镜像层的数量可能有很多，所有的镜像层联合在一起组成了镜像的文件系统。如果在不同层中，有一个相同路径的文件，那么在容器中，用户只能访问到在上层的文件，不能访问到在下层的该文件。相当于历史层无法访问到。

容器层操作细节

1） 添加文件。在容器中添加文件时，是将该文件添加到容器层中。
2） 读取文件。在容器中读取文件时，docker从文件系统顶端往下依次每层查找此文件，一旦找到该文件，则打开并读取到内存中。因此不会读取到下层的同目录文件。
3） 修改文件。在容器中读取文件时，docker从文件系统顶端往下依次每层查找此文件，一旦找到该文件，则将其复制到容器层中，然后对其进行修改。
4） 删除文件。在容器中删除文件时，docker从文件系统顶端往下依次每层查找此文件，一旦找到该文件，容器则记录下删除操作，并不会真的去删除镜像层的文件。

可以看到，容器在运行过程中，只有当需要修改的时候，才会去复制一份数据，这种特性称为Copy-on-Write。

镜像构建

docker commit

docker commit操作时保存容器层文件系统以及容器层文件系统以下的镜像层文件系统，但是该方式不会保存具体的修改步骤，通过这种方式保存的镜像，无法知道容器层到底进行了哪些修改。

docker export

docker export操作则是只保存最新版的容器层文件系统，并且清除容器层之前的层，也就是清除之前的所有底层镜像，将这个最新的容器层作为新的base镜像。

docker save

docker save方式则是保存容器层以下的镜像层文件系统，相当于修改没有奏效。

docker build

docker build -t ImageName:TagName Dir

-t —— 给镜像加一个tag
ImageName —— 给镜像起的名字
TagName —— 给镜像起的标签名
Dir —— build context目录
Docker默认从build context中查找dockerfile文件。也可以通过-f参数指定dockerfile文件目录。
需要注意的是，dockerfile中的ADD、COPY等命令可以将build context中的文件添加到镜像中。（会将build context目录中的所有文件都发送给docker daemon）。

如下命令的执行顺序：
在这里插入图片描述

执行RUN，将Ubuntu作为base镜像
执行RUN，安装vim
启动一个临时容器，在该容器中通过apt-get
vim安装vim
将该容器保存为镜像（docker commit）
删除容器
镜像构建成功

在整个过程中，实际上的保存容器的方法是docker commit。

dockerfile构建过程：

1） 从base镜像运行一个容器
2） 执行一条指令，对容器进行修改
3） 执行docker commit操作，生成一个新的容器镜像层
4） docker再基于刚刚提交的镜像，运行一个新容器
5） 重复2~4步，直到dockerfile中的所有指令全部执行完毕。in

docker history

docker history ImageName

ImageName —— 镜像名
docker history命令可以查看镜像的历史信息，可以看到每一层镜像是通过什么命令来对镜像进行修改的。
输出结果中的missing表示无法获取image id，通常从docker hub下载的镜像会有这个问题。

容器生命周期

docker RUN

docker RUN命令在当前镜像的顶部执行命令，并创建新的层。docker RUN命令常常用于镜像修改。

docker CMD

docker CMD命令是用来设置docker启动时的CMD默认命令。

docker CMD命令会被启动docker时的docker run命令覆盖掉，如果docker run命令后面有执行命令，则不会执行docker CMD命令。

docker ENTRYPOINT

docker ENTRYPOINT命令不会被覆盖掉，不会被docker run命令覆盖，始终都会执行。

容器的生命周期取决于启动时运行的命令，只要该命令不结束，容器就不会退出。
在这里插入图片描述
如上所示的命令中，while死循环，命令不会结束，该容器永不退出。

docker exec

docker exec在容器中打开新的终端，并且可以启动新的进程。

docker exec进入的容器，新建的终端属于daemon的子进程。

例如：
在这里插入图片描述
这里，docker exec进入到的则是bash终端，不是容器启动时创建的/bin/bash终端。

docker attach

docker attach直接进入容器启动命令创建的终端中，不会启动新的进程。
例如：使用docker attach命令则会进入容器创建时的/bin/bash终端。

docker logs

docker logs -f +容器id
可以查看/bin/bash终端的输出。

docker 启停

docker镜像的构建使用CMD命令时，有两种方式，一种时shell方式，一种是exec方式。如下所示：

shell方式

dockerfile构建如下，利用shell方式构建容器。

FROM ubuntu:14.04
RUN apt-get update && apt-get -y install redis-server && rm -rf /var/lib/apt/lists/*
EXPOSE 6379
CMD "/usr/bin/redis-server"

exec方式
dockerfile构建如下，利用exec方式构建容器。

FROM ubuntu:14.04
RUN apt-get update && apt-get -y install redis-server && rm -rf /var/lib/apt/lists/*
EXPOSE 6379
CMD ["/usr/bin/redis-server"]

然后基于它们构建两个镜像myredis:shell和myredis:exec

docker build -t myredis:shell -f Dockerfile_shell .
docker build -t myredis:exec -f Dockerfile_exec .

运行myredis:shell镜像，我们可以发现它的启动进程(PID1)是/bin/sh -c "/usr/bin/redis-server"并且它创建了一个子进程/usr/bin/redis-server *:6379

root@ubuntu-desktop:~# docker run -d --name myredis_shell myredis:shell
128fdc38cdccc222234ee2c2bc3a4c84355bc97a33e66ddf53c580b86cfe298e
root@ubuntu-desktop:~# docker exec myredis_shell ps -ef
UID          PID    PPID  C STIME TTY          TIME CMD
root           1       0  0 14:23 ?        00:00:00 /bin/sh -c "/usr/bin/redis-server"
root           7       1  0 14:23 ?        00:00:00 /usr/bin/redis-server *:6379
root          10       0  1 14:23 ?        00:00:00 ps -ef

下面运行myredis:exec镜像，我们可以发现它的启动进程是/usr/bin/redis-server *:6379，并没有其他子进程存在。

root@ubuntu-desktop:~# docker run -d --name myredis_exec myredis:exec
ffd77fef180740ef199281747e372c33d6e2df06d9edbf11a03c0d30caf61fa3
root@ubuntu-desktop:~# docker exec myredis_exec ps -ef
UID          PID    PPID  C STIME TTY          TIME CMD
root           1       0  0 14:27 ?        00:00:00 /usr/bin/redis-server *:6379
root           9       0  0 14:27 ?        00:00:00 ps -ef

docker start

docker stop

docker stop命令是向容器发送一个SIGTERM信号。
docker每个container都是docker daemon的子进程。

当创建一个docker容器的时候，就会新建一个PID命名空间，容器启动进程在该命名空间内PID=1。
当PID1的进程结束以后，容器会销毁对应的的PID命名空间，并向容器内其他子进程发送SIGKILL信号。

使用docker stop myredis_exec命令停止exec模式启动的myredis2容器。

root@ubuntu-desktop:~# docker stop myredis_exec
myredis_exec
root@ubuntu-desktop:~# docker logs myredis_exec 
[1] 09 Sep 14:27:17.175 # Warning: no config file specified, using the default config. In order to specify a config file use /usr/bin/redis-server /path/to/redis.conf
[1] 09 Sep 14:27:17.175 * Max number of open files set to 10032
                _._                                                  
           _.-``__ ''-._                                             
      _.-``    `.  `_.  ''-._           Redis 2.8.4 (00000000/0) 64 bit
  .-`` .-```.  ```\/    _.,_ ''-._                                   
 (    '      ,       .-`  | `,    )     Running in stand alone mode
 |`-._`-...-` __...-.``-._|'` _.-'|     Port: 6379
 |    `-._   `._    /     _.-'    |     PID: 1
  `-._    `-._  `-./  _.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |           http://redis.io        
  `-._    `-._`-.__.-'_.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |                                  
  `-._    `-._`-.__.-'_.-'    _.-'                                   
      `-._    `-.__.-'    _.-'                                       
          `-._        _.-'                                           
              `-.__.-'                                               

[1] 09 Sep 14:27:17.175 # Server started, Redis version 2.8.4
[1] 09 Sep 14:27:17.175 # WARNING overcommit_memory is set to 0! Background save may fail under low memory condition. To fix this issue add 'vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this to take effect.
[1] 09 Sep 14:27:17.175 * The server is now ready to accept connections on port 6379
[1 | signal handler] (1631197679) Received SIGTERM, scheduling shutdown...
[1] 09 Sep 14:27:59.545 # User requested shutdown...
[1] 09 Sep 14:27:59.545 * Saving the final RDB snapshot before exiting.
[1] 09 Sep 14:27:59.547 * DB saved on disk
[1] 09 Sep 14:27:59.547 # Redis is now ready to exit, bye bye...

docker stop命令生效，pid1进程收到了SIGTERM信号，随后退出了。

docker stop命令停止shell命令启动的myredis容器。

root@ubuntu-desktop:~# docker stop myredis_shell 
myredis_shell
root@ubuntu-desktop:~# docker logs myredis_shell 
[7] 09 Sep 14:23:50.211 # Warning: no config file specified, using the default config. In order to specify a config file use /usr/bin/redis-server /path/to/redis.conf
[7] 09 Sep 14:23:50.211 * Max number of open files set to 10032
                _._                                                  
           _.-``__ ''-._                                             
      _.-``    `.  `_.  ''-._           Redis 2.8.4 (00000000/0) 64 bit
  .-`` .-```.  ```\/    _.,_ ''-._                                   
 (    '      ,       .-`  | `,    )     Running in stand alone mode
 |`-._`-...-` __...-.``-._|'` _.-'|     Port: 6379
 |    `-._   `._    /     _.-'    |     PID: 7
  `-._    `-._  `-./  _.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |           http://redis.io        
  `-._    `-._`-.__.-'_.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |                                  
  `-._    `-._`-.__.-'_.-'    _.-'                                   
      `-._    `-.__.-'    _.-'                                       
          `-._        _.-'                                           
              `-.__.-'                                               

[7] 09 Sep 14:23:50.211 # Server started, Redis version 2.8.4
[7] 09 Sep 14:23:50.211 # WARNING overcommit_memory is set to 0! Background save may fail under low memory condition. To fix this issue add 'vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this to take effect.
[7] 09 Sep 14:23:50.211 * The server is now ready to accept connections on port 6379

在myredis容器中，pid1进程没有收到SIGTERM信号。这是因为pid1的进程/bin/sh没有对SIGTERM信号的处理逻辑，所以它忽略了SIGTERM信号。当docker等待stop命令执行超过10s以后，docker daemon发送SIGKILL信号强制杀死sh进程。

孤儿进程和僵尸进程

如果子进程退出了，但是父进程没有进行wait()系统调用来回收子进程，那么子进程就会成为僵尸进程。

在myredis2中。exec方式，没有创建/bin/sh

首先在myredis2容器中启动一个bash进程，并创建子进程sleep 1000

root@ubuntu-desktop:~# docker restart myredis_exec 
myredis_exec
root@ubuntu-desktop:~# docker exec -it myredis_exec bash
root@ffd77fef1807:/# sleep 1000

在另一个终端窗口，查看当前进程，我们可以发现一个sleep进程是bash进程的子进程。

root@ubuntu-desktop:~# docker exec myredis_exec ps -ef
UID          PID    PPID  C STIME TTY          TIME CMD
root           1       0  0 14:30 ?        00:00:00 /usr/bin/redis-server *:6379
root           9       0  0 14:30 pts/0    00:00:00 bash
root          25       9  0 14:30 pts/0    00:00:00 sleep 1000
root          26       0  0 14:31 ?        00:00:00 ps -ef

我们杀死bash进程之后查看进程列表，这时候bash进程已经被杀死。这时候sleep进程(PID为21)，虽然已经结束，而且被PID1进程redis-server接管，但是其没有被父进程回收，成为僵尸状态。

root@ubuntu-desktop:~# docker exec myredis_exec kill -9 9
root@ubuntu-desktop:~# docker exec myredis_exec ps -ef
UID          PID    PPID  C STIME TTY          TIME CMD
root           1       0  0 14:30 ?        00:00:00 /usr/bin/redis-server *:6379
root          25       1  0 14:30 ?        00:00:00 [sleep] <defunct>
root          39       0  0 14:31 ?        00:00:00 ps -ef

这是因为PID1进程redis-server没有考虑过作为init对僵尸子进程的回收的场景。

在myredis中。shell方式，创建了/bin/sh

在用/bin/sh作为PID1进程的myredis容器中，再启动一个bash进程，并创建子进程sleep 1000

root@ubuntu-desktop:~# docker restart myredis_shell
myredis_shell
root@ubuntu-desktop:~# docker exec -ti myredis_shell bash
root@128fdc38cdcc:/# sleep 1000

查看容器中进程情况

root@ubuntu-desktop:~# docker exec myredis_shell ps -ef
UID          PID    PPID  C STIME TTY          TIME CMD
root           1       0  0 14:32 ?        00:00:00 /bin/sh -c "/usr/bin/redis-server"
root           7       1  0 14:32 ?        00:00:00 /usr/bin/redis-server *:6379
root          10       0  0 14:32 pts/0    00:00:00 bash
root          25      10  0 14:32 pts/0    00:00:00 sleep 1000
root          26       0  0 14:32 ?        00:00:00 ps -ef

我们杀死bash进程之后查看进程列表，发现bash和sleep 1000进程都已经被杀死和回收

root@ubuntu-desktop:~# docker exec myredis_shell kill -9 10
root@ubuntu-desktop:~# docker exec myredis_shell ps -ef
UID          PID    PPID  C STIME TTY          TIME CMD
root           1       0  0 14:32 ?        00:00:00 /bin/sh -c "/usr/bin/redis-server"
root           7       1  0 14:32 ?        00:00:00 /usr/bin/redis-server *:6379
root          39       0  0 14:33 ?        00:00:00 ps -ef

这是因为sh/bash等应用可以自动清理僵尸进程。

总结：

在创建容器的时候，PID1进程最好要能支持自动清理僵尸/孤儿进程，要能支持SIGTERM信号。
可以在创建PID1进程的时候，添加一个init系统。
例如：

FROM alpine:3.7
...
RUN apk add --no-cache tini
ENTRYPOINT ["/sbin/tini", "--", "COMMAND"]

添加tini系统，这样，tini就是PID1进程。拥有SIGTERM信号支持和自动清理僵尸/孤儿进程的能力。

docker kill

docker kill命令是向容器发送一个SIGKILL信号。

ImSEten
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
修改已有docker容器中的内容方法
01-08
一、docker ps    列出容器 二、docker cp   拷贝文件至容器 注：docker中宿主机与容器（container）互相拷贝传递文件的方法 1、从容器拷贝文件到宿主机 docker cp mycontainer:/opt/testnew/file.txt /opt/test/ 2、从宿主机拷贝文件到容器 docker cp /opt/test/file.txt mycontainer:/opt/testnew/ 需要注意的是，不管容器有没有启动，拷贝命令都会生效。 当结束后，我们使用 exit 来退出，现在我们的容器已经被我们改变了，使用 docker commi
Docker修改已有镜像
weixin_42258446的博客
10-25 6898
Docker修改已有镜像
docker 服务迁移，容器内文件修改
sirwsl
05-25 2707
docker 容器迁移、备份 jar包内配置文件修改 修改docker 容器内配置文件
Docker修改容器内部文件的三种方法
最新发布
km_bandits的博客
01-13 1906
docker修改容器内文件的三种方法
【Docker】如何修改Docker中的文件
yuchangyuan5237的博客
07-19 4131
如何修改 Docker 中的文件
追求极简：Docker镜像构建演化史
02-25
自从2013年dotCloud公司(现已改名为DockerInc)发布Docker容器技术以来，到目前为止已经有四年多的时间了。这期间Docker技术飞速发展...对于已经接纳和使用Docker技术在日常开发工作中的开发者而言，构建Docker镜像已经
CDH docker镜像构建、管理
11-09
CDH docker镜像构建、管理
Docker镜像构建的两种方法解析
09-30
主要为大家详细介绍了Docker镜像构建的两种方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
docker镜像中配置文件的修改
m0_67401660的博客
04-14 7197
docker镜像中配置文件的修改 需要修改docker里面的配置文件时，因为docker镜像里面没有vim，下载也比较麻烦，可以使用 docker cp docker镜像名:想要修改的文件的路径 想要复制到的路径 将镜像中的文件复制到镜像外部，然后使用系统的vim修改，修改后再把文件复制回去。 例如:docker cp zookeeper-server:/etc ~/tmp 注意：修改完cp回镜像的时候可能会失败，原因可能是该文件正在被使用 可以先把该docker镜像服务停止，再把文件cp回去，重启
Docker修改容器内部文件的方法
WTYX666的博客
06-16 3110
1、进入容器内部修改 进入容器的内部对文件进行修改。 docker exec -it 容器ID /bin/bash docker里面没有vim，需要自行安装，安装代码如下所示。不过不推荐这种形式，因为里边的文件是临时的，容器被删除之后，配置就失效了，需要从新配置。 apt-get update apt-get install vim 2、通过docker cp拷贝进行修改 可以通过下面的代码将需要修改的文件拷贝出来，修改完成之后再拷贝回去。 #将容器中的文件拷贝出来 sudo docker cp 容器I
Docker（容器操作案例（更改镜像的显示内容））
分享java学习路上的一些笔记，不足之处多多见谅。
10-30 528
Docker（容器操作案例（更改镜像的显示内容）） 第一步：进入容器内部 第二步：查看路径 *pwd ：当前所在位置*ls ： 下面目录第三步：查找nginx的静态资源所在目录（因为要去改nginx的首页） 第四步：进入nginx镜像的静态资源所在位置 第五步：查看首页界面 第六步：修改首页页面（vi可不行，因为容器里面是阉割版的没有vi这个函数）Vi无法用 测试： 退出容器（exit） 第七步：停止容器 查看停止前后状态 *docker ps查看所有的容器（但是默认是运行的容器） docker p
docker镜像新增文件修改文件方法
m0_67391377的博客
03-25 3265
docker镜像新增文件/修改文件方法 i. 使用docker images获取当前镜像号信息 (如果没有，使用docker pull harbor.xxxx.com/xxx/xxxx:x.x.x.xxx-xxxxxxxx 进行拉取镜像) ii. 将要添加的文件放在一个临时目录下，touch一个Dockerfile文件 （如若需要修改镜像中的文件，可以使用docker cp xxxxx:/app/xxxx/xxxx.xml ./ 拷贝至当前目录） ( 如若镜像未启动 docker run -itd h ha
docker：修改镜像内容
aidway的专栏
02-27 1004
docker：修改镜像内容
编辑docker容器中的文件
lisheng19870305的专栏
08-03 3600
一般docker中没有VI或者其它相应的文本编辑器，为了写个东西安装个vi就可以解决问题，除此之外还有别的办法
Docker - 编辑容器中的文件 - 学习/实践
william_n的博客
04-30 2756
主要用于如何在docker容器中如何编辑文件， 如开发环境直接修改配置文件，做一些测试开发。
在已发布的docker容器中修改其代码
figosoar的专栏
12-24 8282
应用发布为Docker后，后续往往还会添加或修改功能。 有时候会遇到python或系统源造成docker无法编译成功，影响或耽误事。但只要docker镜像没有被删除，并且能够启动，就可以直接修改docker容器中代码来实施修改。 方法如下： 首先，启动该镜像为docker容器，记录其名称或ID，假设为：4df4d4dff85b。 那么在本地修改完原始的docker应用代码文件（假设为：app.py）后，可以使用如下命令将其拷贝到docker中。 docker cp app.py 4df4d4df
修改docker官方镜像内部内容并重新build镜像
热门推荐
weixin_43923436的博客
01-25 1万+
应用场景 在某些情况下，我们可能需要修改官方的docker镜像，不过，首先需要搞明白，镜像：image 和容器：container 的区别： 镜像image：类似于java中的类 容器container：类似于java中的对象 因此，我们往往从docker hub下载官方镜像，然后，把镜像部署到服务器，然后，我们真正用到该服务的时候，往往是根据该镜像生成一个容器，然后运行容器。和java中类和对象的概念很像，镜像就是类，根据类生成对象后，真正使用的是对象，对应docker就是容器。 修改官方docker镜像
docker 安装使用jenkins
niupit的博客
05-28 454
1.拉取jenkins镜像 这里我基于jenkins官方镜像制作一个镜像，已经下载好git的，并上传到了私服harbor上 2.安装运行jenkins镜像 在运行镜像之前，我们先在本机上创建一个jenkins的挂载目录 /home/jenkins，并修改其权限 mkdir /home/jenkins chown -R 1000:1000 /home/jenkins/ 运行jenkins...
docker镜像内文件和宿主机互相拷贝
wangleigiser的博客
07-04 986
1、将本地文件拷贝到docker 镜像内docker cp 本地路径 容器Id或name:容器目录 2、将docker内文件拷贝到本地文件夹内docker cp 容器Id或name:镜像路径 本地路径
Docker镜像构建时磁盘空间 一般是在什么盘下面
06-12
Docker镜像构建时使用的磁盘空间一般是在Docker守护进程所在的文件系统中。在Linux系统中，Docker默认使用的是/var/lib/docker目录来存储镜像、容器和卷等数据。如果你的系统有多个分区，可以通过配置Docker Daemon来更改默认的存储路径。在Windows和MacOS等系统中，Docker使用的是虚拟磁盘来存储数据，可以通过Docker Desktop的设置界面来管理虚拟磁盘的大小。无论在哪个系统中，当磁盘空间不足时，都会导致Docker镜像构建失败。因此，需要及时清理不需要的数据或者扩展磁盘容量来避免这个问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值