Docker学习笔记

Docker学习笔记-持续更新

1 Dockerfile详解

1.1 dockerfile镜像构建格式

docker build -t 要打的镜像名:版本号 Dockerfile路径

1.2 dockerfile构建三部曲

（1）构建Dockerfile文件；

（2）采用docker build命令构建镜像；

（3）采用docker run命令依据镜像运行容器实例。

1.3 dockerfile规则

(1) # 代表注释；

(2) 指令必须要大写，后面最少需要带一个参数，最多无限制;

(3) 执行dockerfile的时候，指令是按照从上到下的顺序执行的；

(4) 每一个 Dockerfile 的第一行都是非注释性的，也就是说第一行不能是注释，必须是 FROM 指令，来指定基础镜像，后面的指令都以基础镜像为运行环境；如果构建过程中本地没有指定镜像文件，就会去远端仓库拉。

1.4 dockerfile指令

指令	功能简介
FROM	指定构建新image是使用的基础image，通常必须是Dockerfile的第一个有效指令；定义一个基础镜像。
LABEL	附加到image之上的元数据，键值格式；定义一些元数据。
ENV	以键值格式设定环境变量，可被其后的指令所调用，且基于新生成的image运行的Container中也会存在这些变量。
RUN	以FROM中定义的image为基础环境运行指令命令，生成结果将作为新image的一个镜像层，并可由后续指令所使用。RUN后跟要执行的命令。
CMD	基于dockerfile生成的image运行的container时，CMD能够指定容器中默认运行的程序，因而其只应该定义一次。
ENTRYPOINT	类似于CMD指令的功能，但不能被命令行指定要运行的应用程序覆盖，且与CMD共存时，CMD的内容将作为该指令中定义的程序的参数。
WORKDIR	相当于cd切换目录的命令，如果切换的那个地方没有哪个目录，则会自动创建一个目录。
COPY	相当于cp命令，复制主机上或者前一阶段构建结果中（需要使用--from选项）文件或目录生成新的镜像。
ADD	与COPY指令的功能相似，但ADD传输压缩包的时候，是可以解压的。
VOLUME	指定基于新生成的Image运行Container时期望作为volume使用的目录。
EXPOSE	指定基于新生成的lmage运行Container时期望 暴露的端口，但实际暴露与否取决于"docker run"命令的选项，支持TCP和UDP协议。
USER	为Dockerfile中该指令后面的RUN、CMD和ENTRYPOING指令中要运行的应用程序指定运行者身份UID，以及一个可选的GID。
ONBUILD	触发器，生效于由该Dockerfile 构建出的新l/mage被用于另一个Dockerfile中的FROM指令作为基础镜像时。
STOPSIGNAL	用于通知Container终止的系统调用信号。
HEALTHCHECK	定义检测容器应用的健康状态的具体方法。
SHELL	为容器定义运行时使用的默认shel程序，Linux系统默认使用 [/bin/sh"，"-c"], Windows默认使用 ['cmd', "/S',"/C']。

1.5 用的Dockerfile指令详解、格式与用法

1）FROM标签

这个 FROM 指令是 dockerfile 的第一个指令，然后指定了基础镜像，后面的所有指令都是运行在该基础镜像环境上的。

# tag 是可选的，如果不使用这两个值时，会使用 latest 版本的基础镜像
FROM <image>
FROM <image>:<tag>

# 指定基础镜像为 centos:7
FROM centos:7

2）MAINTAINER

该指令是描述的维护者信息。

MAINTAINER 邮箱/名字

# 指定维护者信息
MAINTAINER maintainer="xiaojie <163.com>"

3）ENV标签

该指令是用于定义环境变量的

# 两种写法都可以满足
ENV <key>=<value>
ENV <key> <value>

# 设置jdk1.8的环境变量
ENV JAVA_HOME=/usr/local/jdk1.8.0_333/
ENV export JRE_HOME=$JAVA_HOME/jre
ENV export CLASSPATH=.:$JAVA_HOME/lib:$JRE_HOME/lib
ENV PATH=$JAVA_HOME/bin:$PATH

4）WORKDIR 标签

该指令是切换到 WORKDIR 目录下工作，这个与 linux 里面的 cd 差不多。如果 WORKDIR 不存在，它将被创建。

需要注意的是通过 WORKDIR 设置工作目录后，Dockerfile 中其后的命令 RUN、CMD、ENTRYPOINT、ADD、 COPY 等命令都会在该目录下执行。在使用 docker run 运行容器时，可以通过 -w 参数覆盖构建时所设置的工作目录。

WORKDIR /usr/workdir
 
# 这时工作目录为/a
WORKDIR /a 
 
# 这时工作目录为/a/b
WORKDIR b
 
# 这时工作目录为/a/b/c
WORKDIR c

5）RUN标签

该指令用于在容器中执行命令。我们常用来安装基础软件，或者执行一些命令。

需要注意的是 RUN 指令创建的中间镜像会被缓存，并会在下次构建中使用。如果不想使用这些缓存镜像，可以在构建时指定 --no-cache 参数，如：docker build --no-cache

# 第一种 shell 执行，eg： RUN mkdir /usr/local/tomcat/webapps/ROOT
RUN <command>
 
# 第二种 exec 执行，eg：echo 'Hello xhf Docker'>/usr/local/tomcat/webapps/ROOT/index.html
RUN ["executable", "param1", "param2"]

# 安装 yum 工具
RUN yum -y install vim
 
# 安装网络监测工具
RUN yum -y install net-tools

6）ADD 标签

该指令是用来将宿主机某个文件或目录放到（复制）容器某个目录下面。

如果复制的文件是 tar 类型的，那么该文件会自动解压 ( 网络压缩资源不会被解压 ) ，可以访问网络资源，类似 wget。

ADD <src>... <dest>
 
ADD ["<src>",... "<dest>"] 

# 将 index.html 放到指定的目录下
ADD index.html /usr/local/tomcat/webapps/ROOT/index.html

7）EXPOSE 标签

该指令用于暴露容器里的端口，没有什么用，加了和不加没有什么区别，仅仅是为了告诉使用这个镜像的人，我的这个容器用到了 xxxx 端口号。

EXPOSE 端口

# 对外暴露 8080 端口
EXPOSE 8080

8）build 标签

该标签用于构建镜像

docker build -f xhf_dockerfile -t mytomcat:0.1 .
 
# -f xhf_dockerfile 表示构建的文件路径
 
# -t 镜像名称:版本号
 
# . 表示当前路径 
 
 
# 如果你当前的目录下只有一个 dockerfile 文件，那么可以省略 -f 参数，如下所示：
docker build -t mytomcat:0.1 .

9）COPY标签

该标签功能类似于 ADD 标签，但是是不会自动解压文件，也不能访问网络资源。

COPY <源路径> <目标路径>

# 指定基础镜像为 tomcat:8 
FROM tomcat:8
 
# 在容器的指定目录下创建一个 ROOT 文件夹
RUN mkdir -p /usr/local/tomcat/webapps/ROOT/
 
# 将 index.html 复制到指定的目录下
COPY index.html /usr/local/tomcat/webapps/ROOT/index.html

10）VOLUME 标签

该标签用于在 image 中创建一个挂载目录，以挂载宿主机上的目录。

# path 代表容器中的目录，与 docker run 不同，Dockerfile 中不能指定宿主机目录，默认使用 docker 管理的挂载点
VOLUME <path>
VOLUME ["path"]

# 指定基础镜像为 tomcat:8 
FROM tomcat:8
 
# 在容器的指定目录下创建一个 ROOT 文件夹
RUN mkdir -p /usr/local/tomcat/webapps/ROOT/
 
# 将 index.html 复制到指定的目录下
COPY index.html /usr/local/tomcat/webapps/ROOT/index.html
 
# 创建两个挂载点
VOLUME ["/data1","/data2"]

# 指定基础镜像为 tomcat:8 
FROM tomcat:8
 
# 在容器的指定目录下创建一个 ROOT 文件夹
RUN mkdir -p /usr/local/tomcat/webapps/ROOT/
 
# 将 index.html 复制到指定的目录下
COPY index.html /usr/local/tomcat/webapps/ROOT/index.html
 
# 创建两个挂载点
VOLUME ["/data1","/data2"]

11）CMD 标签

该标签是构建容器后调用的，也就是在容器启动时才进行调用。

(1) 一个 Dockerfile 只有一个 CMD 指令，若有多个，只有最后一个 CMD 指令生效。

(2) CMD 主要目的：为容器提供默认执行的命令，这个默认值可以包含可执行文件，也可以不包含可执行文件，意味着必须指定 ENTRYPOINT 指令（第二种写法）。

(3) 注意和 RUN 指令的区别，RUN 是构建镜像时执行的命令，执行的时期不同。

# shell格式
CMD <命令>
 
# exec格式 
CMD ["可执行文件", "参数1", "参数2", ...]

# 构建镜像
docker build -f xhf_dockerfile -t mycentos:0.1 .
 
# 启动容器
docker run mycentos:0.1

12）ENTRYPOINT 标签

标签是指定容器启动的要运行的命令，可以追加命令。

ENTRYPOINT 与 CMD 非常类似，不同的是通过 docker run 执行的命令不会覆盖ENTRYPOINT，而 docker run 命令中指定的任何参数，都会被当做参数再次传递给 ENTRYPOINT。

Dockerfile 中只允许有一个 ENTRYPOINT 命令，多指定时会覆盖前面的设置，而只执行最后的 ENTRYPOINT 指令。

ENTRYPOINT ["executable", "param1", "param2"]
 
ENTRYPOINT command param1 param2 (shell内部命令)

# 指定基础镜像为 centos:7
FROM centos:7
ENTRYPOINT ["echo", "dockerfile-entrypoint test"]
ENTRYPOINT ["ls", "-a"]

执行下面的命令，并且启动容器，如下所示，我们可以看到可以 ENTRYPOINT 标签的只执行了最后一行。

# 构建镜像
docker build -f xhf_dockerfile -t mycentos:0.2 .
 
# 启动容器
docker run mycentos:0.2

13）CMD 和 ENTRYPOINT 配合使用

一般情况下，ENTRYPOINT 和 CMD 标签都是互相配合使用的，即：ENTRYPOINT 填写固定的命令，CMD 填写该固定命令对应的参数，CMD 将这个参数传递给 ENTRYPOINT命令。可以理解为 CMD 参数为 ENTRYPOINT 的默认值，如果项目中使用的不是 CMD 的默认值，就可以在启动 docker 容器时添加上真实的参数值，用来覆盖 CMD 的默认值。

举个例子，比如要在镜像中通过 java -jar 的方式启动一个 java 工程，就可以采用下面的方式，默认启动的时候 commcon.jar 这个工程。

ENTRYPOINT ["java", "-jar"]
 
CMD ["common.jar"]

如果我们不想启动这个 common.jar 的工程了，我们在启动容器的时候更换下命令就可以了，如下所示：

docker run 容器名称 xxxx.jar

2 Dockerfile制作镜像

2.1 基于 Dockerfile 制作 Alpine 系统镜像

1) 准备基础镜像
# 使用 alpine:3.18.0 作为基础镜像
docker pull alpine:3.18.0

2）创建指定目录
mkdir -p /data/dockerfile/base/alpine/

3）编写Dockerfile文件
# 更新 alpine 的软件源（阿里云）；
# 安装必要的工具；
# 更改时区，以使容器和宿主机的时间同步；
[root@localhost ~]# cd /data/dockerfile/base/alpine/
[root@localhost alpine]# vim Dockerfile 
# Alpine Dockerfile
#
FROM alpine:3.18.0
LABEL maintainer="xiaojie <163.com>"
RUN sed -i 's/dl-cdn.alpinelinux.org/mirrors.ustc.edu.cn/' /etc/apk/repositories && apk update \
    && apk --no-cache add iotop gcc libgcc libc-dev libcurl libc-utils pcre-dev zlib-dev libnfs make pcre pcre2 zip unzip net-tools pstree libevent libevent-dev iproute2 tzdata openssl openssl-dev \
    && ln -s /usr/share/zoneinfo/Asia/Shanghai /etc/localtime \
    && echo "Asia/Shanghai" > /etc/timezone

4）构建镜像
docker build -t alpine-init:3.18.0-v1.0 .

# 可以写为脚本
vim docker-build.sh
#/bin/bash
version=$1
docker build -t alpine-init:3.18.0-$1 .

5）验证镜像
[root@localhost aa]# docker images -f reference=alpine-init
REPOSITORY    TAG           IMAGE ID       CREATED              SIZE
alpine-init   3.18.0-v1.0   1cd97c0619b9   About a minute ago   220MB

6）启动容器，验证
[root@localhost ~]# docker run -it --name myalpine alpine-init:3.18.0-v1.0 sh
/ # cat /etc/timezone 
Asia/Shanghai
/ # ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
6: eth0@if7: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
       valid_lft forever preferred_lft forever
/ # ifconfig 
eth0      Link encap:Ethernet  HWaddr 02:42:AC:11:00:02  
          inet addr:172.17.0.2  Bcast:172.17.255.255  Mask:255.255.0.0
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:11 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0 
          RX bytes:946 (946.0 B)  TX bytes:0 (0.0 B)

lo        Link encap:Local Loopback  
          inet addr:127.0.0.1  Mask:255.0.0.0
          UP LOOPBACK RUNNING  MTU:65536  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000 
          RX bytes:0 (0.0 B)  TX bytes:0 (0.0 B)

/ #

2.2 基于 Dockerfile 制作 Ubuntu 系统镜像

1) 准备基础镜像
# 使用 alpine:3.18.0 作为基础镜像
docker pull ubuntu:22.04
# 查看版本
# docker run --rm ubuntu:22.04 cat /etc/issue      
Ubuntu 22.04.4 LTS \n \l

2）创建指定目录
mkdir -p /data/dockerfile/base/alpine/

3）编写apt源文件
[root@localhost ~]# cd /data/dockerfile/base/alpine/
[root@localhost ubuntu]# vim source.list
deb http://mirrors.163.com/ubuntu/ jammy main restricted universe multiverse
deb http://mirrors.163.com/ubuntu/ jammy-security main restricted universe multiverse
deb http://mirrors.163.com/ubuntu/ jammy-updates main restricted universe multiverse
deb http://mirrors.163.com/ubuntu/ jammy-proposed main restricted universe multiverse
deb http://mirrors.163.com/ubuntu/ jammy-backports main restricted universe multiverse
deb-src http://mirrors.163.com/ubuntu/ jammy main restricted universe multiverse
deb-src http://mirrors.163.com/ubuntu/ jammy-security main restricted universe multiverse
deb-src http://mirrors.163.com/ubuntu/ jammy-updates main restricted universe multiverse
deb-src http://mirrors.163.com/ubuntu/ jammy-proposed main restricted universe multiverse
deb-src http://mirrors.163.com/ubuntu/ jammy-backports main restricted universe multiverse

4）编写Dockerfile文件
# 更新 alpine 的软件源（阿里云）；
# 安装必要的工具；
# 更改时区，以使容器和宿主机的时间同步；
[root@localhost ~]# cd /data/dockerfile/base/ubuntu/
[root@localhost alpine]# vim Dockerfile 
# Alpine Dockerfile
#
# Ubuntu Dockerfile
# 
FROM ubuntu:22.04
LABEL maintainer="xiaojie <163.com>"
ADD source.list /etc/apt/sources.list
RUN apt update \
    && apt -y install iproute2 ntpdate tcpdump telnet traceroute nfs-kernel-server nfs-common lrzsz tree openssl libssl-dev libpcre3 libpcre3-dev zlib1g-dev ntpdate tcpdump telnet traceroute gcc openssh-server iotop unzip zip make \
    && rm -rf /var/lib/apt/lists/*  \
    && apt clean \ 
    && ln -s /usr/share/zoneinfo/Asia/Shanghai /etc/localtime \
    && echo "Asia/Shanghai" > /etc/timezone

4）构建镜像
docker build -t ubuntu-init:22.04-v1.0 .

5）验证镜像
[root@localhost ubuntu]# docker images -f reference=ubuntu-init
REPOSITORY    TAG          IMAGE ID       CREATED         SIZE
ubuntu-init   22.04-v1.0   38f14a2e476f   2 minutes ago   383MB

6）启动容器，验证
[root@localhost ~]# docker run -it --name myalpine alpine-init:3.18.0-v1.0 sh
/ # cat /etc/timezone 
Asia/Shanghai

2.3 基于 Dockerfile 制作 JDK 镜像

注意：

对于一些强依赖glibc的系统建议不要使用Alpine

Alpine官方给出了Alpine的三大特征 Small、Simple、Secure，但其实我们知道一个jdk就已经不小了，强行安装只会违背Alpine的设计初衷，最后其实与其他操作系统差不多了。所以对于java程序来说使用CentOS等操作系统会更好一下

1）准备基础镜像
# 我这里使用ubuntu:22.04 （也可以使用centos）
docker pull ubuntu:22.04

2）创建目录
mkdir -p /data/dockerfile/base/jdk

3）编写Dockerfile
[root@localhost ~]# cd /data/dockerfile/base/jdk/
[root@localhost jdk]# cat Dockerfile 
FROM ubuntu:22.04
LABEL maintainer="xiaojie <163.com>"
WORKDIR /usr/local/jdk
ADD jdk-8u211-linux-x64.tar.gz /usr/local/jdk

ENV JAVA_HOME /usr/local/jdk/jdk1.8.0_211
ENV JRE_HOME /usr/local/jdk/jdk1.8.0_211/jre
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib:$CLASSPATH
ENV PATH $JAVA_HOME/bin:$PATH

4）将jdk-8u211-linux-x64.tar.gz传至/data/dockerfile/base/jdk目录下
[root@localhost jdk]# ls jdk-8u211-linux-x64.tar.gz 
jdk-8u211-linux-x64.tar.gz

5）构建镜像
[root@localhost jdk]# docker build -t ubuntu-jdk:v1 . 

6）验证
[root@localhost jdk]# docker run -it --rm --name myjdk alpine-jdk:v1 java -version
java version "1.8.0_211"
Java(TM) SE Runtime Environment (build 1.8.0_211-b12)
Java HotSpot(TM) 64-Bit Server VM (build 25.211-b12, mixed mode)

2.4 基于 Dockerfile 制作 Nginx 镜像

1）准备基础镜像
这里使用制作好的基础镜像 2.1目录 --> alpine-init:3.18.0-v1.0

2）创建目录
$ mkdir -p /data/dockerfile/web/nginx/

3）编写Dockerfile
$ cd /data/dockerfile/web/nginx/
$ vim Dockerfile 
FROM myalpine:v1.0
LABEL maintainer="xiaojie <163.com>"
RUN apk --no-cache add openssl
ADD nginx-1.26.0.tar.gz /usr/local/src
RUN cd /usr/local/src/nginx-1.26.0 \
    && ./configure --prefix=/apps/nginx \
        --user=nginx \
        --group=nginx \
        --with-http_ssl_module \
        --with-http_v2_module \
        --with-http_realip_module \
        --with-http_stub_status_module \
        --with-http_gzip_static_module \
        --with-pcre \
        --with-stream \
        --with-stream_ssl_module \
        --with-stream_realip_module \
    && make \
    && make install \
    && ln -s /apps/nginx/sbin/nginx /usr/bin/ \
    && addgroup -g 2000 -S nginx \
    && adduser -s /sbin/nologin -u 2000 -S -D -G nginx nginx \
    && chown -R nginx:nginx /apps/nginx
WORKDIR /apps/nginx
COPY nginx.conf /apps/nginx/conf/nginx.conf 
ADD index.html /data/nginx/html/index.html
RUN chown -R nginx:nginx /data/nginx/ /apps/nginx/
EXPOSE 80 443 8081
CMD [ "nginx","-g","daemon off;"]
# 必须为前台启动，否则容器启动后就退出了

4）相关文件移至 /data/dockerfile/web/nginx/ 目录下
[root@localhost nginx]# ls nginx*
nginx-1.26.0.tar.gz  nginx.conf

5）构建镜像
docker build -t mynginx:v1 .

3 Docker常用命令

3.1 查看容器日志

$ docker logs [OPTIONS] CONTAINER
  Options:
        --details        显示更多的信息
    -f, --follow         跟踪实时日志
        --since string   显示自某个timestamp之后的日志，或相对时间，如42m（即42分钟）
        --tail string    从日志末尾显示多少行日志， 默认是all
    -t, --timestamps     显示时间戳
        --until string   显示自某个timestamp之前的日志，或相对时间，如42m（即42分钟）

查看所有日志
$ docker logs  CONTAINER_ID

查看指定时间后的日志，只显示最后100行：
$ docker logs -f -t --since="2021-02-08" --tail=100 CONTAINER_ID

查看最近30分钟的日志:
$ docker logs --since 30m CONTAINER_ID

查看某时间之后的日志：
$ docker logs -t --since="2021-02-08T13:23:37" CONTAINER_ID

查看某时间段日志：
$ docker logs -t --since="2021-02-08T13:23:37" --until "2021-02-09T12:23:37" CONTAINER_ID

3.2 创建启动容器

$ docker run [OPTIONS] IMAGE [COMMAND] [ARG...]
# 其中，OPTIONS 是一系列用于配置容器运行方式的选项，IMAGE 是要运行的容器镜像，COMMAND 是在容器内部执行的命令，ARG 是传递给命令的参数。

  Options:
-i  交互模式运行容器，通常与 -t 同时使用
-t	启动容器后，为容器分配一个命令行，通常与 -i 同时使用
-v	目录映射，容器目录挂载到宿主机目录，格式： <host目录>:<容器目录>
-d	以后台模式运行容器，将容器放置在后台运行，作为守护进程。
-p	指定端口映射，格式：主机(宿主)端口:容器端口
-P	随机端口映射，容器内部端口随机映射到主机的端口（49153起始 49153到65535）
-u	以什么用户身份创建容器
--name	"nginx-lb" 容器名字
-m,--memory bytes	设置容器使用内存最大值
-h, --hostname string	指定容器的 host name
-e username="ritchie"	设置环境变量
--restart 指定容器在退出时的重启策略
--privileged	容器内是否使用真正的 root 权限

使用tomcat7镜像，创建名为tomcat_hogwarts01的容器，并使用-d参数，让其后台运行
$ docker run -d --name tomcat_hogwarts01 tomcat:7

使用镜像 tomcat:7 以后台模式启动一个容器将容器的 8080 端口映射到主机的随机端
$ docker run -d -P --name tomcat_muller tomcat:7

使用镜像 tomcat:7 以后台模式启动一个容器将容器的 8080 端口映射到主机的 8888 端口
$ docker run -d -p 8888:8080 --name tomcat_salah tomcat:7

使用镜像 tomcat:7 ，以后台模式启动一个容器，将容器的 8080 端口映射到主机127.0.0.1:8888 端口容器名字自定义为 tomcat77主机的目录 /usr/local/tomcat/webapp 映射到容器/usr/local/tomcat/webapps 启动容器后，在容器内执行 bash 命令
$ docker run -d -p 127.0.0.1:8888:8080 -v /usr/local/webapps:/usr/local/webapps -it --name tomcat77 tomcat:7 bash

以 root 权限创建容器，当进入容器之后，拥有 root 权限去执行命令
$ docker run -d --name jenkin_hogwarts --privileged=true jenkins/jenkins
### 注意
-uroot：是给了 root 用户身份，但并没有真正的 root 权限
--privileged：真正让当前用户有了 root 权限

设置容器自动重启
$ docker run -d --name jenkins_salah --restart always jenkins/jenkins

退出容器
exit         #容器直接退出
ctrl +P +Q  #容器不停止退出     ---注意：这个很有用的操作

3.3 查看指定镜像的历史层信息

$ docker history [OPTIONS] IMAGE
OPTIONS 说明：
-H, --human: 以人类可读的格式显示镜像大小（默认启用）。
--no-trunc: 显示完整的输出，不截断信息。
-q, --quiet: 仅显示镜像 ID。

3.4 查看镜像

$ docker images [OPTIONS] [REPOSITORY[:TAG]]
使用docker images命令可以列出本地主机上已有镜像的基本信息

OPTIONS 说明：
-a, --all: 显示所有镜像（包括中间层镜像）。
--digests: 显示镜像的摘要信息。
-f, --filter: 过滤输出，基于提供的条件。
--format: 使用 Go 模板格式化输出。
--no-trunc: 显示完整的镜像 ID。
-q, --quiet: 只显示镜像 ID。

不要截断输出.会发现此时的IMAGE ID很长，如果不带此参数，会默认截取
$ docker images --no-trunc

列出带有摘要信息的镜像:
$ docker images --digests

过滤出空悬镜像（REPOSITORY和TAG都为none的）
$ docker images --filter "dangling=true"

排除空悬镜像
$ docker images --filter "dangling=false"

自定义输出格式-- (images:tag)
$ docker images --format "table {{.Repository}}:{{.Tag}}"

只显示镜像ID
$ docker images -q

过滤ubunt的镜像
$ docker images -f "reference=ubuntu"

3.5 进入容器

docker exec [OPTIONS] CONTAINER COMMAND [ARG...]

OPTIONS:
-d, --detach: 在后台运行命令。
--detach-keys: 覆盖分离容器的键序列。
-e, --env: 设置环境变量。
--env-file: 从文件中读取环境变量。
-i, --interactive: 保持标准输入打开。
--privileged: 给这个命令额外的权限。
--user, -u: 以指定用户的身份运行命令。
--workdir, -w: 指定命令的工作目录。
-t, --tty: 分配一个伪终端。

在运行中的 my_container 容器内执行 ls /app 命令，列出 /app 目录的内容
$ docker exec my_container ls /app

在运行中的 my_container 容器内启动一个交互式的 Bash shell。-i 保持标准输入打开，-t 分配一个伪终端
$ docker exec -it my_container /bin/bash

3.6 获取docker的详细信息

Usage: docker inspect [OPTIONS] NAME|ID [NAME|ID...]

返回Docker对象的底层信息

选项:
-f,   --format string 　　使用给定的Go模板格式化输出
-s,  --size 　　　　　   如果类型是container，则显示总文件大小
　   --type string 　　   返回指定类型的JSON

检查容器
$ docker inspect my_container

检查镜像
$ docker inspect my_image

检查卷
$ docker inspect my_volume

检查网络
$ docker inspect my_network

格式化输出
$ docker inspect --format '{{ .State.Running }}' my_container

3.7 复制

docker cp [OPTIONS] CONTAINER:SRC_PATH DEST_PATH
docker cp [OPTIONS] SRC_PATH|- CONTAINER:DEST_PATH

#CONTAINER，可以是正在运行或已停止的容器，名称或ID均可
#SRC_PATH，源文件或目录在容器内的路径
#DEST_PATH，目标路径在主机上的位置

OPTIONS:
-a：将复制的文件或目录保留其原始属性，包括所有者、权限等。
-L：如果SRC_PATH是一个符号链接，则复制链接指向的文件或目录。
-p：保留源文件或目录的时间戳。
-R或-r：递归复制整个目录。

从容器复制文件到宿主机
$ docker cp my_container:/path/in/container /path/on/host

从宿主机复制文件到容器
$ docker cp /path/on/host my_container:/path/in/container

从容器复制目录到宿主机
$ docker cp my_container:/path/in/container /path/on/host

从宿主机复制目录到容器
$ docker cp /path/on/host my_container:/path/in/container

3.8 删除容器

docker rm [OPTIONS] CONTAINER [CONTAINER...]

OPTIONS说明：
-f, --force: 强制删除正在运行的容器（使用 SIGKILL 信号）。
-l, --link: 删除指定的连接，而不是容器本身。
-v, --volumes: 删除容器挂载的卷。

删除一个已经停止的Nginx容器
docker rm my_nginx_container

强制删除一个运行中的数据库容器
docker rm -f my_database_container

删除所有已经停止的容器：
docker rm $(docker ps -a -q)

3.9 删除镜像

docker rmi [OPTIONS] IMAGE [IMAGE...]

常用选项：
-a, --all-tags: 指定仓库名称时，删除该仓库下的所有镜像。
-f, --force: 强制删除镜像，即使该镜像被容器使用。
--help: 打印帮助信息并退出。
--no-prune: 不删除悬空的父镜像。
-q, --quiet: 安静模式，不显示删除镜像的详细信息

删除一个本地镜像
$ docker rmi my_image

强制删除一个正在被使用的本地镜像
$ docker rmi -f my_image

3.10 镜像保存/加载

保存单个镜像到文件
$ docker save -o myimage.tar myimage:latest

保存多个镜像到同一个文件
$ docker save -o multiple_images.tar myimage:latest anotherimage:latest

加载保存的镜像
$ docker load -i mynginx.tar

3.11 查看容器

docker ps [OPTIONS]

OPTIONS说明：
  -a, --all: 显示所有容器，包括停止的容器。
  -q, --quiet: 只显示容器 ID。
  -l, --latest: 显示最近创建的一个容器，包括所有状态。
  -n: 显示最近创建的 n 个容器，包括所有状态。
  --no-trunc: 不截断输出。
  -s, --size: 显示容器的大小。
  --filter, -f: 根据条件过滤显示的容器。
  --format: 格式化输出。

列出所有在运行的容器信息
$ docker ps

列出所有容器，包括停止的容器
$ docker ps -a

只显示容器 ID
$ docker ps -q

显示最近创建的一个容器
$ docker ps -l

显示最近创建的 n 个容器
$ docker ps -n 3 

显示容器的大小
$ docker ps -s

显示状态为 exited 的容器。
$ docker ps -f "status=exited"

显示名称包含 my_container 的容器。
$ docker ps -f "name=my_container"

以表格形式显示容器的 ID、名称和状态。
$ docker ps --format "table {{.ID}}\t{{.Names}}\t{{.Status}}"

4 Docker配置优化

$ vim /etc/docker/daemon.json
{
  "exec-opts": ["native.cgroupdriver=systemd"],
  "registry-mirrors": [
    "https://q1rw9tzz.mirror.aliyuncs.com",
    "https://docker.mirrors.ustc.edu.cn",
    "https://registry.docker-cn.com"
  ],
  "insecure-registries":["http://xxx.xxx.xxx"],
  "data-root": "/data/docker",
  "storage-driver": "overlay2",
  "storage-opts": [
    "overlay2.size=50GB",
    "overlay2.override_kernel_check=true",
    "overlay2.override_wait_for_deletion=true"
  ],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "50MB",
    "max-file": "3"
  },
  "max-concurrent-downloads": 10,
  "max-concurrent-uploads": 5,
  "live-restore": true
}

字段解释

exec-opts

指定 Docker 使用 systemd 作为 cgroup 驱动程序。这是为了确保 Docker 在容器的资源控制方面与宿主系统的 systemd 一致。

registry-mirrors

配置 Docker 镜像仓库镜像源，可以指定多个镜像源地址（避免单个可能会失效的问题），以加速从这些镜像源下载 Docker 镜像。

insecure-registries

配置 Docker 的私有镜像仓库镜像源，该仓库一般是我们私有化部署或使用的云产品服务。

data-root

指定 Docker 的数据目录，存储驱动、日志驱动等数据都会存储在该目录下。

storage-driver

指定 Docker 的存储驱动为 overlay2，不指定默认也是 overlay2。

storage-opts

设置 Docker 存储驱动的选项，overlay2.override_kernel_check=true 表示允许覆盖内核版本检查，以便在不同内核版本之间切换 overlay2 存储驱动。overlay2.override_wait_for_deletion=true c=表示覆盖等待删除操作，提高容器删除速度。overlay2.size=50GB 表示限制存储驱动的容量大小为 50GB，但是我不建议限制其大小，如果在生产环境中你限制的大小太小可能会导致容器中的应用程序无法正常工作或崩溃，如果存储驱动的大小限制不足以容纳容器中的数据，那么超出限制的数据可能会丢失，这可能会导致重要数据的损失，因此需要根据你的具体需求和应用场景来谨慎考虑。确保你了解应用程序的存储需求，并根据实际情况来设置存储驱动大小限制。同时，要定期监控存储空间的使用情况，以确保不会出现不可预测的问题。

log-driver

指定 Docker 容器的日志驱动程序为 json-file，表示容器日志将以 JSON 格式写入文件。

log-opts

设置 Docker 日志驱动的选项，max-size 表示限制单个容器日志文件的最大大小为 50MB。max-file表示最多保留 3 个容器日志文件，旧的日志文件会被轮换出去。

max-concurrent-downloads

设置同时拉取镜像最大数量

max-concurrent-uploads

设置同时推送镜像最大数量

live-restore

当设置为true时，Docker会在守护进程启动时尝试重启所有之前运行中的容器