[关闭]
@Chiang 2019-09-28T09:19:59.000000Z 字数 4512 阅读 643

Docker 命令集

Docker


查看docker安装版本

  1. docker --version
  2. docker-compose --version
  3. docker-machine --version
  4. docker info
  5. # 运行一个Nginx服务器
  6. docker run -d -p 80:80 --name webserver nginx
  7. # 停止 Nginx服务器 容器
  8. docker stop webserver
  9. # 删除 Nginx服务器 容器
  10. docker rm webserver

一张图总结Docker的命令

docker cmd

镜像

获取镜像

  1. # 命令格式
  2. docker pull [选项] [Docker Registry 地址[:端口号]/]仓库名[:标签]
  3. # 查看具体的选项
  4. docker pull --help
  5. # 获取官方镜像 library/ubuntu 仓库中标签为 18.04 的镜像.
  6. docker pull ubuntu:18.04

列出已下载镜像

  1. # 列出所有顶层镜像
  2. docker image ls
  3. # 查看镜像、容器、数据卷所占用的空间
  4. docker system df
  5. # 显示虚悬镜像(dangling image)
  6. docker image ls -f dangling=true
  7. # 删除虚悬镜像
  8. docker image prune
  9. # 显示所有镜像(包含中间层镜像)
  10. docker image ls -a
  11. # 根据仓库名列出镜像
  12. docker image ls ubuntu
  13. # 列出特定的某个镜像,也就是说指定仓库名和标签
  14. docker image ls ubuntu:18.04
  15. # 过滤器参数 --filter,或者简写 -f
  16. docker image ls --filter before=mongo:3.2
  17. # 查询在 mongo:3.2 之后建立的镜像
  18. docker image ls -f since=mongo:3.2
  19. # 显示ID列表
  20. docker image ls -q
  21. # 以特定格式显示
  22. docker image ls --format "{{.ID}}: {{.Repository}}"
  23. docker image ls --format "table {{.ID}}\t{{.Repository}}\t{{.Tag}}"

删除本地镜像

  1. # 命令格式 其中,<镜像> 可以是 镜像短 ID、镜像长 ID、镜像名 或者 镜像摘要
  2. docker image rm [选项] <镜像1> [<镜像2> ...]
  3. # 镜像短 ID
  4. docker image rm 501
  5. # 镜像名
  6. docker image rm centos
  7. # 镜像摘要digest (sha256:b4f0e0bdeb57804)
  8. docker image ls --digests
  9. docker image rm node@sha256:b4f0e0bdeb57804
  10. # 删除所有仓库名为 redis 的镜像
  11. docker image rm $(docker image ls -q redis)
  12. # 删除所有在 mongo:3.2 之前的镜像
  13. docker image rm $(docker image ls -q -f before=mongo:3.2)

docker commit 将容器的存储层保存下来成为镜像

  • Docker 提供了一个 docker commit 命令,可以将容器的存储层保存下来成为镜像.换句话说,就是在原有镜像的基础上,再叠加上容器的存储层,并构成新的镜像
  • 使用 docker commit 意味着所有对镜像的操作都是黑箱操作,生成的镜像也被称为 黑箱镜像
  1. # 命令格式
  2. docker commit [选项] <容器ID或容器名> [<仓库名>[:<标签>]]
  3. # 保存容器为镜像
  4. docker commit \
  5. --author "fazhan <1550149004@qq.com>" \
  6. --message "保存容器为镜像" \
  7. webserver \
  8. nginx:v2
  • --author 指定修改的作者
  • --message 记录本次修改的内容
  1. # 启动镜像
  2. docker run --name webserver -d -p 80:80 nginx
  3. # 进入容器 执行修改操作 退出
  4. docker exec -it websefrver bash
  5. echo '<h1>hello, docker!</h1>' > /usr/share/nginx/html/index.html
  6. exit
  7. # 查看具体改动
  8. docker diff webserver
  9. # 保存容器为镜像
  10. docker commit \
  11. --author "fazhan <1550149004@qq.com>" \
  12. --message "保存容器为镜像" \
  13. webserver \
  14. nginx:v2
  15. # 用 docker history 具体查看镜像内的历史记录
  16. docker history nginx:v2
  17. # 运行新镜像 docker80端口映射到本地81端口
  18. docker run --name web2 -d -p 81:80 nginx:v2

使用 Dockerfile 定制镜像

Dockerfile 是一个文本文件,其内包含了一条条的 指令(Instruction),每一条指令构建一层,因此每一条指令的内容,就是描述该层应当如何构建。

在一个空白目录中,建立一个文本文件,并命名为 Dockerfile:

  1. mkdir mynginx
  2. cd mynginx
  3. touch Dockerfile
  4. # 文件内容
  5. from nginx
  6. run echo '<h1>Hello,Docker!</h1>' > /usr/share/nginx/html/index.html

Dockerfile 指令详解

from
run
copy
add
cmd
entrypoint
env
arg
volume
expose
workdir
user
healthcheck
onbuild

构建镜像

Dockerfile 文件所在目录执行:

  1. # 命令格式
  2. docker build [选项] <上下文路径/URL/->
  3. docker build -t nginx:v3 .
  4. # 直接用 Git repo 进行构建
  5. docker build https://github.com/twang2218/gitlab-ce-zh.git
  6. # 用给定的 tar 压缩包构建
  7. docker build http://server/context.tar.gz
  8. # 从标准输入中读取 Dockerfile 进行构建
  9. docker build - < Dockerfile
  10. cat Dockerfile | docker build -
  11. # 从标准输入中读取上下文压缩包进行构建
  12. docker build - < context.tar.gz

镜像构建上下文(Context)

如果注意,会看到 docker build 命令最后有一个 .。. 表示当前目录,而 Dockerfile 就在当前目录,因此不少初学者以为这个路径是在指定 Dockerfile 所在路径,这么理解其实是不准确的。如果对应上面的命令格式,你可能会发现,这是在指定 上下文路径。那么什么是上下文呢?

首先我们要理解 docker build 的工作原理。Docker 在运行时分为 Docker 引擎(也就是服务端守护进程)和客户端工具。Docker 的引擎提供了一组 REST API,被称为 Docker Remote API,而如 docker 命令这样的客户端工具,则是通过这组 API 与 Docker 引擎交互,从而完成各种功能。因此,虽然表面上我们好像是在本机执行各种 docker 功能,但实际上,一切都是使用的远程调用形式在服务端(Docker 引擎)完成。也因为这种 C/S 设计,让我们操作远程服务器的 Docker 引擎变得轻而易举。

当我们进行镜像构建的时候,并非所有定制都会通过 RUN 指令完成,经常会需要将一些本地文件复制进镜像,比如通过 COPY 指令、ADD 指令等。而 docker build 命令构建镜像,其实并非在本地构建,而是在服务端,也就是 Docker 引擎中构建的。那么在这种客户端/服务端的架构中,如何才能让服务端获得本地文件呢?

这就引入了上下文的概念。当构建的时候,用户会指定构建镜像上下文的路径,docker build 命令得知这个路径后,会将路径下的所有内容打包,然后上传给 Docker 引擎。这样 Docker 引擎收到这个上下文包后,展开就会获得构建镜像所需的一切文件。

多阶段构建

容器

运行容器退出后随之将其删除

  1. docker run -it --rm \
  2. ubuntu:18.04 \
  3. bash
  • -it: 是两个参数, 一个是-i:交互式操作, 一个是-t终端.
  • --rm: 容器退出后随之将其删除.
  • ubuntu:18.04: 这是指用 Ubuntu:18.04 镜像为基础来启动容器.
  • bash: 放在镜像名后的是命令.这里我们希望有个交互式shell,因此用的是bash

新建并启动容器

  1. # 输出一个 “Hello World”
  2. docker run ubuntu:18.04 /bin/echo 'Hello world'
  3. # -t 选项让Docker分配一个伪终端(pseudo-tty)并绑定到容器的标准输入上, -i 则让容器的标准输入保持打开
  4. docker run -t -i ubuntu:18.04 /bin/bash

启动已终止容器

  1. # 启动容器
  2. docker container start
  3. # 用 ps 或 top 来查看进程信息
  4. ps
  5. top
  6. # -d 后台运行
  7. docker run -d ubuntu:18.04 /bin/sh -c "while true; do echo hello world; sleep 1; done"
  8. # 查看容器信息
  9. docker container ls -a
  10. # 获取容器输出信息
  11. docker container logs [container ID or NAMES]
  12. # 终止容器
  13. docker container stop
  14. # 重启容器
  15. docker container restart
  16. # 进入后台运行的容器
  17. # 如果从这个 stdin 中 exit,会导致容器的停止
  18. docker attach [container ID or NAMES]
  19. # 如果从这个 stdin 中 exit,不会导致容器的停止 推荐
  20. docker exec -it [container ID or NAMES] bash

导出和导入容器

  1. # 导出容器
  2. docker export 7691a814370e > ubuntu.tar
  3. # 导入容器
  4. cat ubuntu.tar | docker import - test/ubuntu:v1.0
  5. # 通过指定 URL 或者某个目录来导入
  6. docker import http://example.com/exampleimage.tgz example/imagerepo

删除容器

  1. # 删除容器 删除一个运行中的容器,可以添加 -f 参数
  2. docker container rm -f trusting_newton
  3. # 清理所有处于终止状态的容器
  4. docker container prune

仓库


参考资料:
Docker — 从入门到实践
docker for beginners

添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注