docker基础及进阶

第一章   docker基础

一、   docker介绍

Docker 是一个开源的应用容器引擎，基于 Go 语言 并遵从Apache2.0协议开源。

二、    初识docker

1.       Docker容器 vs 全虚拟化

全虚拟化的系统分配到的是独有的一组资源，只有极少量的资源会共享，是有更强的隔离性，但是更加重了（需要更加多的资源）。用Docker容器有弱些的隔离性，但是它们更加轻量，需要更少的资源，所以你可以毫不费力地启动上千个容器。

基本上，Docker容器和全虚拟化VM有着本质上不同的目标

虚拟机（VM）是对某种计算机操作系统的模拟，虚拟机的实现是基于计算机虚拟化的架构和指令，具体可能需要特定的硬件、软件、或软硬件同时的支持。

Docker是一个创建封装好的隔离计算机环境，每个封装好的环境都被称为容器，并没由传统虚拟化中的Hypervisor层，因为docker是基于容器技术的轻量级虚拟机，相对于传统的虚拟化技术，省去了Hypervisor的开销，而且其虚拟化技术是基于cgroup和Namespace技术，处理逻辑与内核深度融合，

2.       docker 架构

                       

由上图可知，

在功能上，docker通过Libcontainer实现对容器生命周期的管理，信息的设置和查询，以及监控和通信等功能，容器以镜像为基础，同时又为镜像提供了一个标准的和隔离的执行环境。

在概念上，容器很好的诠释了docker集装箱的理念，它可以安装任意的集装和运输方式，做任意的运行环境配置，

在通信上，docker并不会直接与内核交互，它是通过一个更底层的工具Libcontainer与内核交互的，Libcontainer是真正意义上容器引擎，它通过clone系统调用直接创建容器，通过pivot_root系统调用进入容器，且通过直接操作cgroupfs文件实现对资源的监控，而docker本身则侧重于处理更上层的业务。

命名空间

Docker充分使用称为namespace的技术来提供分离的工作空间，我们称为容器。当你运行一个容器，Docker为这个容器创造一些列命名空间。

这个提供了一层分离：容器的每一个方面运行在他自己的明明空间中，并且不能访问其命名空间之外的数据。

Docker引擎在Linux中使用的命名空间有：

• pid命名空间：进程分离
• net命名空间：管理网络接口
• ipc命名空间：管理IPC资源访问
• mnt命名空间：管理挂载点
• uts命名空间：分离内核和版本识别

3.       功能和组件

docker引擎是一个c/s结构的应用，主要组件见下图：

 

• image：Docker 镜像是用于创建 Docker 容器的模板。
• container: 容器是独立运行的一个或一组应用。
• Server是一个常驻进程
• REST API 实现了client和server间的交互协议
• CLI 实现容器和镜像的管理，为用户提供统一的操作界面
• Docker Daemon我们称之为Docker守护进程，也就是Server端，Server端可以部署在远程，也可以部署在本地，因为Server端与客户端(Docker Client)是通过Rest API进行通信。
• docker CLI 实现容器和镜像的管理，为用户提供统一的操作界面,这个 客户端提供一个只读的镜像，然后通过镜像可以创建一个或者多个容器(container)，这些容器可以只是一个RFS(Root File System),也可以是一个包含了用户应用的RFS。容器在docker Client中只是一个进程，两个进程是互不可见的。
• Docker客户端,以docker二进制的形式出现，是Docker最基本的用户接口。他接收来自用户的命令，然后和Docker守护进程来回沟通。

4.       容器的组成

容器的核心技术是cgroup+namespace，对于linux容器的最小组成，可以由以下公式来表示

容器=cgroup+namespace+rootfs+容器引擎（用户态工具）

cgroup：资源控制

namespace：访问隔离

rootfs：文件系统隔离

容器引擎：生命周期控制

5.       镜像、容器、应用的关系是什么？

镜像：Docker镜像是一个特殊的文件系统，除了提供容器运行时所需的程序、库、资源、配置等文件外，还包含了一些为运行时准备的配置参数（如匿名卷、环境变量、用户等）。镜像不包含任何动态数据，其内容在构建之后也不会被改变。

容器：镜像（Image）和容器（Container）的关系，就像是面向对象程序设计中的类和实例一样，镜像是静态的定义，容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等。

6.       Dockerfile、Docker镜像和Docker容器的关系

Dockerfile 是软件的原材料，Docker 镜像是软件的交付品，而 Docker 容器则可以认为是软件的运行态。从应用软件的角度来看，Dockerfile、Docker 镜像与 Docker 容器分别代表软件的三个不同阶段，Dockerfile 面向开发，Docker 镜像成为交付标准，Docker 容器则涉及部署与运维，三者缺一不可，合力充当 Docker 体系的基石。

简单来讲，Dockerfile构建出Docker镜像，通过Docker镜像运行Docker容器。

我们可以从Docker容器的角度，来反推三者的关系。首先可以来看下图：

 

7.       容器如何工作？

一个容器包含一个操作系统，用户文件和元数据。正如我们看到的，每一个容器都是从镜像中被构建的。那个镜像告诉Docker容器保存什么数据，当容器发布的时候运行什么进程，还有其他一些配置数据。Docker镜像是只读的。当Docker从一个镜像中运行一个容器的时候，他在镜像的最顶层添加一个读写层（使用union文件系统），在该层中你的应用程序可以运行。

 

8.       运行容器过程

无论是使用docker二进制还是API，Docker客户端告诉Docker守护程序来运行一个容器。

$ docker run -i -t ubuntu /bin/bash

Docker引擎客户端使用带有run选项的docker二进制运行一个新的容器。Docker客户端需要告诉Docker守护进程运行容器的最低限度是:

• 检查本地是否存在指定的镜像，不存在就从公有仓库下载
• 利用镜像创建并启动一个容器
• 分配一个文件系统，并在只读的镜像层外面挂在一层可读写层
• 从宿主主机配置的网桥接口中桥接一个虚拟接口到容器中去
• 从地址池配置一个ip地址给容器
• 执行用户指定的应用程序
• 执行完毕后容器被终止

现在你就拥有一个运行的容器了。现在你可以管理你的容器，与你的应用交互，当结束的时候，可以停止和移除你的容器。

9.       术语

宿主系统 vs 客户系统

宿主系统：是直接安装在计算机上的原生系统

客户系统：是安装在一个虚拟机上，或者宿主机一个分区上的系统

如果安装在虚拟机上，两者可不同，如果安装在一个分区上，两者必须一致。

Hypervisor：是一种计算机软件，固件或硬件，用于创建并运行虚拟机的，一个系统如果安装此服务，里边运行着一个或多个虚拟机，这个系统可被定义宿主机，各个虚拟机定义客户机。

三、           Dockerfile介绍及使用

1.      什么是Dockerfile？

Dockerfile是自动构建docker镜像的配置文件，Dockerfile中的命令非常类似linux shell下的命令 Dockerfile,可以让用户自定义构建docker镜像，支持以 # 开头的注释行 一般，Dockerfile分为4部分 1.基础镜像（父镜像）信息 2.维护者信息 3.镜像操作命令 4.容器启动命令

#第一行必须指令基于的基础镜像

From ubutu

#维护者信息

MAINTAINER docker_user  [email protected]

#镜像的操作指令

apt/sourcelist.list

RUN apt-get update && apt-get install -y ngnix

RUN echo "\ndaemon off;">>/etc/ngnix/nignix.conf

#容器启动时执行指令

CMD /usr/sbin/ngnix

 

2.      指令指令

1、From指令 From 或者From :

DockerFile第一条必须为From指令。如果同一个DockerFile创建多个镜像时，可使用多个From指令（每个镜像一次）

2、MAINTAINER 格式为maintainer ，指定维护者的信息

3、RUN 格式为Run 或者Run [“executable” ,”Param1”, “param2”] 前者在shell终端上运行，即/bin/sh -C，后者使用exec运行。例如：RUN [“/bin/bash”, “-c”,”echo hello”] 每条run指令在当前基础镜像执行，并且提交新镜像。当命令比较长时，可以使用“/”换行。

4、CMD指令 支持三种格式： CMD [“executable” ,”Param1”, “param2”]使用exec执行，推荐 CMD command param1 param2，在/bin/sh上执行 CMD [“Param1”, “param2”] 提供给ENTRYPOINT做默认参数。

每个容器只能执行一条CMD命令，多个CMD命令时，只最后一条被执行。

5、EXPOSE

格式为 EXPOSE […] 。

告诉Docker服务端容器暴露的端口号，供互联系统使用。在启动Docker时，可以通过-P,主机会自动分配一个端口号转发到指定的端口。使用-P，则可以具体指定哪个本地端口映射过来

例如： EXPOSE 22 80 8443

6、ENV

格式为 ENV 。 指定一个环境变量，会被后续 RUN 指令使用，并在容器运行时保持。

例如

ENV PG_MAJOR 9.3

ENV PG_VERSION 9.3.4

RUN curl -SL http://example.com/postgres-$PG_VERSION.tar.xz | tar -xJC /usr/src/postgress && …

ENV PATH /usr/local/postgres-$PG_MAJOR/bin:$PATH

7、ADD 格式为 ADD 。

该命令将复制指定的 到容器中的 。 其中 可以是Dockerfile所在目录的一个相对路径；也可以是一个URL；还可以是一个tar文件（自动解压为目录）。则。

8、COPY

格式为 COPY 。

复制本地主机的 （为Dockerfile所在目录的相对路径）到容器中的 。

当使用本地目录为源目录时，推荐使用 COPY 。

9、ENTRYPOINT

两种格式：

ENTRYPOINT [“executable”, “param1”, “param2”] ENTRYPOINT command param1 param2 （shell中执行）。 配置容器启动后执行的命令，并且不可被 docker run 提供的参数覆盖。

每个Dockerfile中只能有一个 ENTRYPOINT ，当指定多个时，只有最后一个起效。

10、VOLUME

格式为 VOLUME [“/data”] 。

创建一个可以从本地主机或其他容器挂载的挂载点，一般用来存放数据库和需要保持的数据等。

11、USER

格式为 USER daemon 。

指定运行容器时的用户名或UID，后续的 RUN 也会使用指定用户。

当服务不需要管理员权限时，可以通过该命令指定运行用户。并且可以在之前创建所需要的用户，例如： RUN groupadd -r postgres && useradd -r -g postgres postgres 。要临时获取管理员权限可以使用 gosu ，而不推荐 sudo 。

12、WORKDIR

格式为 WORKDIR /path/to/workdir 。

为后续的 RUN 、 CMD 、 ENTRYPOINT 指令配置工作目录。

可以使用多个 WORKDIR 指令，后续命令如果参数是相对路径，则会基于之前命令指定的路径。例如

WORKDIR /a WORKDIR b WORKDIR c RUN pwd 则最终路径为 /a/b/c 。

13、ONBUILD

格式为 ONBUILD [INSTRUCTION] 。

配置当所创建的镜像作为其它新创建镜像的基础镜像时，所执行的操作指令。

例如，Dockerfile使用如下的内容创建了镜像 image-A 。

[…] ONBUILD ADD . /app/src ONBUILD RUN /usr/local/bin/python-build –dir /app/src […] 如果基于A创建新的镜像时，新的Dockerfile中使用 FROM image-A 指定基础镜像时，会自动执行 ONBUILD 指令内容，等价于在后面添加了两条指令。

3.      构建镜像

以上文件就是用来生成第一个docker镜像的Dockerfile，通过docker build指令来生成docker镜像 docker build -t hanxt/centos:7 . 如果Dockerfile在当前目录下，输入点.就可以进行加载当前目录下的Dockerfile 如果不在当前目录下需要运行 docker build -t hanxt/centos:7 <Dockerfile_dir>加载相对路径下的Dockerfile

4.      样例

# canal

FROM tomcat

WORKDIR /home/software

ADD canal.zip /home/software/

RUN unzip -oq /home/software/canal.zip -d /opt/mateinfo/ \

    && rm -f /home/software/* \

    && rm -rf /opt/mateinfo/app \

    && chown -R mateinfo:inoc /opt/mateinfo \

    && chmod -R 700 /opt/mateinfo \

    && chmod -R 750 /opt/mateinfo/logs

EXPOSE 11111 12111

CMD ["/bin/bash"]

四、   Docker的网络连接

• 桥接
• 网桥方式需要安装网桥管理工具
• yum install bridge-utils
• brctl show //可以看到虚拟机的网络关系
• 通过虚拟网桥桥接互通，所有网卡都要在一个网段下，所以要对每个Docker守护进程对ip的分配做出限制
• 下面，我们就来实现这个结构：
• 

我的两台Ubuntu 14.04 的虚拟机ip：

Host1 ： 10.211.55.3  网卡：eth0

Host2 ：10.211.55.5   网卡   eth1

网关：10.211.55.1

对容器ip的划分：

Host1: 10.211.55.64/26

　　地址范围： 10.211.55.65～10.211.55.126

 

Host2: 10.211.55.128/26

　　地址范围： 10.211.55.129～10.211.55.190

需要的操作：

以下，以Host1 为例，Host2 上操作相似，只是网卡名字不一样，我在这里，没有使用默认的docker0 网桥，而是新建了虚拟网桥

1. 分别在Docker主机上建立虚拟网桥：

　　 Host1: $ sudo brctl addbr br0

2. 为网桥分配一个同网段ip

　　Host1: $ sudo ifconfig br0 10.211.55.10 netmask 255.255.255.0

　　Host2: $ sudo ifconfig br0 10.211.55.20 netmask 255.255.255.0

3. 桥接本地网卡

　　Host1: $ sudo brctl addif br0 eth0

这里，我们就准备好了网桥设置

下面我们来修改Docker的配置,使用我们新建的网桥代替docker0:

1. 修改 /etc/default/docker文件

　　$sudo vim /etc/default/docker

2. 添加守护进程的启动选项：

　　Host1: DOCKER_OPTS=" -b=br0 --fixed-cidr=‘10.211.55.64/26‘ "  

　　Host2: DOCKER_OPTS=" -b=br1 --fixed-cidr=‘10.211.55.128/26‘ "

      这里，-b 用来指定容器连接的网桥名字

　　　　　--fixed-cidr用来限定为容器分配的IP地址范围

3. 保存文件并重启Docker服务

　　$ sudo service docker restart

下面，就可以来验证：

1.分别在两个Host上启动一个容器

　　$ docker run -it ubuntu /bin/bash

 2.在容器中运行ping命令查看连接情况

• ovs
• 

ovs: open vswitch是一个高质量的，多层虚拟交换机

操作步骤:

1.在虚拟机中建立ovs网桥

2.添加gre连接

3.配置docker容器虚拟网桥

4.为虚拟网桥添加ovs接口

5.添加不同Docker容器网段路由

GRE：通用路由协议封装

GRE隧道：隧道技术(Tunneling)是一种通过使用互联网络的基础设施在网络之间传递数据的方式。使用隧道传递的数据(或负载)可以是不同协议的数据帧或包。隧道协议将其它协议的数据帧或包重新封装然后通过隧道发送。新的帧头提供路由信息，以便通过互联网传递被封装的负载数据。

$ ovs-vsctl show  

 $ ovs-vsctl add-br obr0  

 $ ovs-vsctl add-port obr0 gre0  

 $ ovs-vsctl set interface gre0 type=gre options:remote_ip=192.168.59.104  

 $ ovs-vsctl show  

 $ brctl addbr br0

 $ ifconfig br0 192.168.1.1 netmask 255.255.255.0  

 $ brctl addif br0 obr0  

 $ brctl show  

 $ ip route add 192.168.2.0/24 via 192.168.59.104 dev eth0

 

weave

 

Docker的原生网络支持非常有限，且没有跨主机的集群网络方案。目前实现Docker网络的开源方案有Weave、Kubernetes、Flannel、Pipework以及SocketPlane等，其中Weave被评价为目前最靠谱的，那么这里就对Weave的基本原理及使用方法做个总结。

Weave: 是由Zett.io公司开发的，它能够创建一个虚拟网络，用于连接部署在多台主机上的Docker容器，这样容器就像被接入了同一个网络交换机，那些使用网络的应用程序不必去配置端口映射和链接等信息。外部设备能够访问Weave网络上的应用程序容器所提供的服务，同时已有的内部系统也能够暴露到应用程序容器上。Weave能够穿透防火墙并运行在部分连接的网络上，另外，Weave的通信支持加密，所以用户可以从一个不受信任的网络连接到主机。

安装与启动

$ wget -O /usr/local/bin/weave https://raw.githubusercontent.com/zettio/weave/master/weave

$ chmod a+x /usr/local/bin/weave

启动weave路由器，这个路由器其实也是以容器的形式运行的。

$ weave launch

此时会发现有两个网桥，一个是Docker默认生成的，另一个是Weave生成的。 

$ brctl show

$ docker ps

简单使用

准备

1. host1: 10.0.2.6

2. host2: 10.0.2.8

3. host1上的应用容器1: 192.168.0.2/24 host1上的应用容器2: 192.168.1.2/24

4. host2上的应用容器1: 192.168.0.3/24

两台机上均安装Docker及Weave，并均启动好Weave路由容器。

在两台机上均启动一个应用容器。可以直接使用weave run命令，也可以先使用docker run启动好容器，然后使用weave attach命令给容器绑定IP地址。

$ weave run 192.168.0.2/24 -itd ubuntu bash

或者

$ docker run -itd ubuntu bash

$ weave attach 192.168.0.2/24 $ID

此时发现两个容器之间是不通的，需要使用weave connect命令在两台weave的路由器之间建立连接。

$ weave connect 10.0.2.8

会发现，此时位于两台不同主机上的容器之间可以相互ping通了。但是处于不同子网的两个容器是不能互联的，这样我们就可以使用不同子网进行容器间的网络隔离了。

我们会发现，如果不使用Docker的原生网络，在容器内部是不能访问宿主机以及外部网络的。此时我们可以使用weave expose 192.168.0.1/24来给weave网桥添加IP，以实现容器与宿主机网络连通。但是，此时在容器内部依然不能访问外部网络。

我们可以同时使用Docker的原生网络和weave网络来实现容器互联及容器访问外网和端口映射。使用外部网络及端口映射的时候就使用docker0网桥，需要容器互联的时候就使用weave网桥。每个容器分配两个网卡。

其他特性

• 应用隔离：不同子网容器之间默认隔离的，即便它们位于同一台物理机上也相互不通（使用-icc=false关闭容器互通）；不同物理机之间的容器默认也是隔离的
• 安全性：可以通过weave launch -password wEaVe设置一个密码用于weave peers之间加密通信
• 查看weave路由状态：weave ps
• 注意(容器重启问题)
• 如果使用weave，则就不能再使用docker自带的auto-restart feature（如docker run –restart=always redis），因为weave是在docker之外为容器配置的网络，容器重启的时候docker本身不会做这些事情。因而，还需额外的工具来管理容器的状态（比如systemd, upstart等），这些工具要调用weave命令（weave run/start/attach）来启动容器。

五、     镜像仓库Registry API

1.常见API

详细可见https://docs.docker.com/registry/spec/api/#detail

方法	路径/v2/<name>	实体	描述	实例
GET	/v2/	Base	检查是否正常	curl –X GET http://localhost:5000/v2/
GET	/tags/list	Tags	镜像清单	http://localhost:5000/v2/foo/bar/tags/list
GET	/manifests/<referevce>	Manifest	清单内容
Put	/manifests/<referevce>	Manifest
Delete	/manifests/<referevce>	Manifest
GET	/v2/_catalog	Catalog	列出存储库

2.部署私有仓库

2.1使用docker-hub自带镜像registry

执行# docker run -d \

         -e SETTINGS_FLAVOR=local \

         -e STORAGE_PATH=/opt/docker-registry \

         -e SEARCH_BACKEND=sqlalchemy \

         -v /opt/docker-registry/:/var/lib/registry/ \

         -p 5000:5000 \

         registry

# curl -XGET http://registry:5000/v2/_catalog

# curl -XGET http://registry:5000/v2/image_name/tags/list

# curl -XGET http://100.90.61.14:5000/v2/_catalog

vim  /usr/lib/systemd/system/docker.service

ExecStart=/usr/bin/dockerd  --insecure-registry 192.168.0.153:5000

2.2使用harbor做私有镜像库

六、    常用命令      

1.列出本机的镜像 docker images

删除<none>悬挂镜像， -q 列出id

# docker image –filter “dangling=true” –q | xargs docker rmi

docker images | awk '/^.*none.*/ { print $3 }'

docker rmi -f $(docker images | awk '/^.*none.*/ { print $3 }')

镜像：Docker 镜像是用于创建 Docker 容器的模板 容器：容器是独立运行的一个或一组应用 仓库：用来保存镜像，可以理解为代码控制中的代码仓库

一个仓库中包含多个镜像，以镜像为模板可创建出多个容器，每个容器是独立运行的一个或者一组应用。 容器是镜像的实例，镜像是容器的模板 。

简略：

容器生命周期：run、start/stop/restart、kill、rm、pause/unpause、create、exec

容器操作：ps、inspect、top、attach、events、logs、wait、export、port

容器rootfs：commit、cp、diff

镜像仓库：login/logout、pull、push、search

本地镜像管理：images、rmi、tag、build、history、save、import

info|version：info、version       【docker info/vaersion分别查看系统信息和版本信息】

容器

增：

docker create [OPTIONS] IMAGE [COMMAND] [ARG...]  #创建一个新的容器但不启动它

docker run [OPTIONS] IMAGE [COMMAND] [ARG...]  #创建一个新的容器并运行一个命令

进：

docker exec -ti <container name/id> #不会像attach方式因为退出，导致整个容器退出。         

docker attach  <container name/id> #进入虚拟机，如果从这个stdin中exit，会导致容器的停止。

开启/停止/重启

docker container  start/stop/restart   <hash>

docker container rm <hash> # 从此机器中移除指定的容器【删除容器时，容器必须是停止状态，否则会报如下错误】

删：

docker container rm $(docker container ls -a -q) # 删除所有容器 docker container kill <hash> # 强制关闭指定的容器

查：

docker container ls # 列出所有运行的容器

docker container ls -a # 列出所有的容器
docker ps # 查看我们正在运行的容器

docker ps -l # 查询最后一次创建的容器

docker logs <container id> # 查看容器内的标准输出

docker logs <container name> # 查看容器内的标准输出
docker port <container name/id> <port> # 查看容器端口的映射情况
docker inspect <container id/name> #查看Docker的底层信息,它会返回一个 JSON 文件记录着 Docker 容器的配置和状态信息

镜像

增：docker build -t friendlyname . # 使用此目录的“Dockerfile”创建镜像

docker push 192.168.1.52:5000/zabbix #提交镜像到本地私有 docker pull ubuntu:13.10 # 下载ubuntu:13.10镜像

删：

\docker image rm <image id> # 从机器中移除指定镜像

docker image rm $(docker image ls -a -q) # 从机器上移除所有镜像

查：

docker image ls -a # 列出机器上所有镜像

docker search httpd # 通过 docker search 命令搜索 httpd 来寻找适合我们的镜像

运:

docker run httpd # 使用镜像仓库

docker commit 将容器保存为镜像

常用命令

导出镜像

docker save -o image_name.tar image_name

查看docker网络

[root@docker ~]# docker network ls

NETWORK ID          NAME                DRIVER              SCOPE

3f91f2097286        bridge              bridge              local

d7675dbd247c        docker_gwbridge     bridge              local

5b36c7e947fd        host                host                local

ims6qkpikafu        ingress             overlay             swarm

85ba10e7ef79        none                null                local

创建一个docker网络my-docker

docker network create -d bridge \

--subnet=192.168.0.0/24 \

--gateway=192.168.0.100 \

--ip-range=192.168.0.0/24 \

my-docker

利用刚才创建的网络启动一个容器

#docker run --network=my-docker --ip=192.168.0.5 -itd --name=con_name -h lb01 image_name

--network   #指定容器网络

--ip        #设定容器ip地址

-h          #给容器设置主机名

查看容器pid

#方法一：

docker top con_name

 

#方法二：

docker build 构建镜像

docker build -t="cmsdev:v1.0" . #基于当前目录Dockerfile构建镜像

docker cp 容器与本机文件复制

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

docker cp hscf-zabbix-agent-2.0:/etc/zabbix /zabbix

docker commit 将容器保存为镜像

format: docker commit containerId repo/image:version

docker commit 7f7045d72b2c repo.hjl.hscf.com:5000/zabbix-server:v1.0

docker exec -it 到容器内执行命令

format: docker exec -it containerId/containerName bash

docker exec -it devdb bash 

docker history 查看镜像的创建历史

docker history imageId

docker images 列出镜像

docker images | awk '/^.*none.*/ { print $3 }' #查看所有包含none的镜像

docker images --no-trunc  #列出完整镜像ID的镜像

docker inspect 分析镜像

docker inspect imageid

docker info 查看docker信息

docker info

docker load 将压缩包恢复为镜像

docker load < ubuntu_14.04.tar

docker login 登陆镜像库

docker login repo.hscf.com:5000

docker logs 查看容器日志

docker logs containerId

docker kill 杀死容器

docker kill $(sudo docker ps -q) #停止所有已退出的容器

docker ps 列出镜像

docker ps # 查看所有镜像

docker ps --no-trunc # 查看有完整容器ID的镜像

docker push 推送镜像到镜像库

docker push repo.hscf.com:5000/cmsdev:v1.0

docker restart 重启容器

docker restart containerId或containerName

docker rm 删除容器

docker rm $(sudo docker ps -a -q) # 删除所有容器

docker rmi 删除镜像

删除所有包含 none的镜像

docker rmi -f $(docker images | awk '/^.*none.*/ { print $3 }')

docker run 运行容器

包含环境变量、磁盘挂载、端口映射、docker链接的例子

docker run --name zabbix-web-nginx-mysql \

--link zabbix-server-mysql:zabbix-server \

-e PHP_TZ="Asia/Shanghai" \

-v /u01/SCFDOCKER/registry:/var/lib/registry \

-p 8000:80 \

-d zabbix/zabbix-web-nginx-mysql

docker stop 停止容器运行

docker stop containerIddocker save 将镜像保存为压缩包

docker save -o ubuntu_14.04.tar ubuntu:14.04

docker search 搜索镜像

docker search centos:latest

docker tag 镜像打tag

为镜像cmsdev:v1.0打一个tag

docker tag cmsdev:v1.0 repo.hscf.com:5000/cmsdev:v1.0

常用组合命令

停止并删除所有容器

docker kill $(sudo docker ps -q)

docker rm $(sudo docker ps -a -q)

docker ps -a -q

打tag并推送镜像

docker build -t="cmsdev:v1.0"

docker tag cmsdev:v1.0 repo.hscf.com:5000/cmsdev:v1.0

docker push repo.hscf.com:5000/cmsdev:v1.0

删除含有 none的镜像

docker images | awk '/^.*none.*/ { print $3 }'

docker rmi -f $(docker images | awk '/^.*none.*/ { print $3 }')

保存镜像并恢复

docker save -o ubuntu_14.04.tar ubuntu:14.04

docker load < ubuntu_14.04.tar

查看日志

docker logs --tail=200 containerId # 查看容器最后200行日志

docker logs -f containerId # 动态查看日志

docker ps --no-trunc | grep cmsdev # 获取特定镜像的容器ID全程

cd /var/lib/docker/containers/containerFullId #进入容器所在目录

contailerFullId-json.log # 该文件就是容器的日志文件

docker cp 从容器复制一个文件或目录到本地目录或标准输出

1.  配置docker daemon的参数，由于每个发行版的linux的init系统不用，所以使用通用的命令行方式重启docker daemon

docker daemon --insecure-registry 192.168.6.65:5000 &

四、docker 技巧

1..清理无用的docker容器命令

docker ps -aqf  status=exited | xargs docker rm

2.清理无用镜像的命令

docker images -qf dangling=true | xargs docker rmi

3.清理无用的docker挂载

docker volume rm $(docker volume ls -q -f dangling=true)

dockerignore使用

docker rm $(echo $(docker ps -q --no-trunc) $(dockerps -a -q--no-trunc) | sed 's|\s|\n|g' |sort | uniq -u)

删除当前不在运行状态的容器ID，也可以把前面改成docker rm

docker images -a -q --no-trunc        显示当前仓库中的镜像与临时镜像的ID，不截断输出 作者：淹死的鱼_hz 链接：https://www.jianshu.com/p/711bc4ffcecf 來源：简书 简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

1. 在宿主机中查看 docker容器的ip地址

[root@hadoop mydockerbuild]# docker inspect docker_test1 --format '{{.NetworkSettings.IPAddress}}'

172.17.0.2

 

docker build 构建镜像

Usage: docker [OPTIONS] COMMAND [arg...]

       docker [ --help | -v | --version ]

A self-sufficient runtime for containers.

Options:

  --config=~/.docker              Location of client config files

  -D, --debug                     Enable debug mode

  -H, --host=[]                   Daemon socket(s) to connect to

  -h, --help                      Print usage

  -l, --log-level=info            Set the logging level

  --tls                           Use TLS; implied by --tlsverify

  --tlscacert=~/.docker/ca.pem    Trust certs signed only by this CA

  --tlscert=~/.docker/cert.pem    Path to TLS certificate file

  --tlskey=~/.docker/key.pem      Path to TLS key file

  --tlsverify                     Use TLS and verify the remote

  -v, --version                   Print version information and quit

docker --help

Commands:

    attach    Attach to a running container

    build     Build an image from a Dockerfile

    commit    Create a new image from a container's changes

    cp        Copy files/folders between a container and the local filesystem

    create    Create a new container

    diff      Inspect changes on a container's filesystem

    events    Get real time events from the server

    exec      Run a command in a running container

    export    Export a container's filesystem as a tar archive

    history   Show the history of an image

    images    List images

    import    Import the contents from a tarball to create a filesystem image

    info      Display system-wide information

    inspect   Return low-level information on a container, image or task

    kill      Kill one or more running containers

    load      Load an image from a tar archive or STDIN

    login     Log in to a Docker registry.

    logout    Log out from a Docker registry.

    logs      Fetch the logs of a container

    network   Manage Docker networks

    node      Manage Docker Swarm nodes

    pause     Pause all processes within one or more containers

    port      List port mappings or a specific mapping for the container

    ps        List containers

    pull      Pull an image or a repository from a registry

    push      Push an image or a repository to a registry

    rename    Rename a container

    restart   Restart a container

    rm        Remove one or more containers

    rmi       Remove one or more images

    run       Run a command in a new container

    save      Save one or more images to a tar archive (streamed to STDOUT by default)

    search    Search the Docker Hub for images

    service   Manage Docker services

    start     Start one or more stopped containers

    stats     Display a live stream of container(s) resource usage statistics

    stop      Stop one or more running containers

    swarm     Manage Docker Swarm

    tag       Tag an image into a repository

    top       Display the running processes of a container

    unpause   Unpause all processes within one or more containers

    update    Update configuration of one or more containers

    version   Show the Docker version information

    volume    Manage Docker volumes

    wait      Block until a container stops, then print its exit code