docker基础及进阶

第一章   docker基础

1、   docker介绍

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

2、    初识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：是一种计算机软件，固件或硬件，用于建立并运行虚拟机的，一个系统若是安装此服务，里边运行着一个或多个虚拟机，这个系统可被定义宿主机，各个虚拟机定义客户机。

3、           Dockerfile介绍及使用

1.      什么是Dockerfile？

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

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

From ubutu

#维护者信息

MAINTAINER docker_user  docker_user@mail.com

#镜像的操做指令

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.      指令指令

一、From指令 From 或者From :

DockerFile第一条必须为From指令。若是同一个DockerFile建立多个镜像时，可以使用多个From指令（每一个镜像一次）

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

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

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

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

五、EXPOSE

格式为 EXPOSE […] 。

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

例如： EXPOSE 22 80 8443

六、ENV

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

例如

9.3ENV PG_MAJOR

9.3.4ENV PG_VERSION

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

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

七、ADD 格式为 ADD 。

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

八、COPY

格式为 COPY 。

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

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

九、ENTRYPOINT

两种格式：

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

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

十、VOLUME

格式为 VOLUME [“/data”] 。

建立一个能够从本地主机或其余容器挂载的挂载点，通常用来存放数据库和须要保持的数据等。

十一、USER

格式为 USER daemon 。

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

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

十二、WORKDIR

格式为 WORKDIR /path/to/workdir 。

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

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

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

1三、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"]

 

4、   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）来启动容器。

5、     镜像仓库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作私有镜像库

6、    经常使用命令      

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 构建镜像

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

docker cp 容器与本机文件复制

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

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

docker commit 将容器保存为镜像

format: docker commit containerId repo/image:version

7.hjl.hscf.com5000.0docker commitf7045d72b2c repo:/zabbix-server:v1

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

format: docker exec -it containerId/containerName bash

execdocker-it devdb bash

docker history 查看镜像的建立历史

docker history imageId

docker images 列出镜像

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

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

docker inspect 分析镜像

docker inspect imageid

docker info 查看docker信息

dockerinfo

docker load 将压缩包恢复为镜像

load.04docker< ubuntu_14.tar

docker login 登录镜像库

.hscf.com5000docker login repo:

docker logs 查看容器日志

docker logs containerId

docker kill 杀死容器

sudo#中止全部已退出的容器docker kill $(docker ps -q)

docker ps 列出镜像

# 查看全部镜像docker ps

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

docker push 推送镜像到镜像库

push.hscf.com5000.0dockerrepo:/cmsdev:v1

docker restart 重启容器

docker restart containerId或containerName

docker rm 删除容器

sudo-a# 删除全部容器docker rm $(docker ps-q)

docker rmi 删除镜像

删除全部包含 none的镜像

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

docker run 运行容器

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

---web-nginx-mysql\docker runname zabbix

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

-e="Asia/Shanghai"\PHP_TZ

-vvar\/u01/SCFDOCKER/registry://lib/registry

-p800080\:

-d-web-nginx-mysqlzabbix/zabbix

docker stop 中止容器运行

stopdocker save 将镜像保存为压缩包dockercontainerId

dockersave-oubuntu_14.04.tarubuntu:14.04

docker search 搜索镜像

dockersearchcentos:latest

docker tag 镜像打tag

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

.0.hscf.com5000.0docker tag cmsdev:v1repo:/cmsdev:v1

经常使用组合命令

中止并删除全部容器

-qdocker kill $(sudo docker ps)

-a-qdocker rm $(sudo docker ps)

-a-qdocker ps

打tag并推送镜像

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

.0.hscf.com5000.0docker tag cmsdev:v1repo:/cmsdev:v1

push.hscf.com5000.0dockerrepo:/cmsdev:v1

删除含有 none的镜像

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

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

保存镜像并恢复

.04.tar14.04docker save -o ubuntu_14ubuntu:

.04.tardocker load < ubuntu_14

查看日志

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

-f# 动态查看日志docker logscontainerId

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

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

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

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

1.  配置docker daemon的参数，因为每一个发行版的linux的init系统不用，因此使用通用的命令行方式重启docker daemon

docker daemon --insecure-registry 192.168.6.65:5000 &

4、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