Docker常用命令

docker学习笔记1：docke环境的查看

一、环境检查

当登录一个安装了docker的机器后，首先我们要检查下docker环境如何。

1、命令：docker -v  上述命令返回安装的docker的版本信息，返回的信息可能如下：

Docker version 1.9.1, build a34a1d5

说明：执行这个命令不需要docker守护进程已经启动，但其它docker命令基本上都需要docker守护进程已经启动。

2、命令：docker  version   上述命令返回安装的docker的版本详细信息，分客户端和服务器。如：


Client:
 Version:      1.9.1
 API version:  1.21
 Go version:   go1.4.3
 Git commit:   a34a1d5
 Built:        Fri Nov 20 17:56:04 UTC 2015
 OS/Arch:      linux/amd64

Server:
 Version:      1.9.1
 API version:  1.21
 Go version:   go1.4.3
 Git commit:   a34a1d5
 Built:        Fri Nov 20 17:56:04 UTC 2015
 OS/Arch:      linux/amd64
复制代码
说明：执行这个命令时，如果docker守护进程没有启动，则只会返回client的信息。server信息不会显示，会提示无法连接到docker daemon。

3、查看docker守护进程的状态

命令：sudo status docker  如果docker守护进程已经启动，则可能显示的信息如下：

docker start/running, process 1491

否则，可能显示的信息如  docker stop/waiting


4、启动/停止docker守护进程服务

启动: sudo start docker

停止：sudo stop docker

5、查看docker环境的信息

命令:docker info 执行该命令，前提需要docker守护进程已经启动。如果一切正常，会返回如下的信息（这里只提供前面一部分）

Containers: 1
Images: 4
Server Version: 1.9.1
Storage Driver: aufs
 Root Dir: /var/lib/docker/aufs
 Backing Filesystem: extfs
 Dirs: 6
 Dirperm1 Supported: false
Execution Driver: native-0.2
Logging Driver: json-file
Kernel Version: 3.13.0-32-generic
Operating System: Ubuntu 14.04.1 LTS

二、查看docker主机上已有的docker镜像

命令：docker images 执行该命令，会列出主机上已经下载的docker镜像，信息如

REPOSITORY          TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
ubuntu              latest              ce76de2e871b        7 days ago          188 MB
说明，本地镜像都保存在主机的 /var/lib/docker 目录下。

三、查看dokcer主机上已经创建的容器

命令： docker ps -a -q

说明 

-a表示列出所有容器（包括停止运行的容器），否则只会列出运行中的容器。 

-q表示只返回容器ID信息，其它容器信息（如状态、对应的镜像等）不显示。

CONTAINER ID    IMAGE    COMMAND        CREATED     STATUS                    PORTS     NAMES
3d72d0283dc8    ubuntu   "/bin/bash"    4 days ago  Exited(130) 4 days ago           stupefied_kare

docker学习笔记2：容器操作

一、列出主机上已经创建的容器  docker ps -a

二、创建交互式容器    docker run -i -t ubuntu /bin/bash

其中-i -t 表示创建一个提供交互式shell的容器。

ubuntu是镜像名，如果本地不存在，回到仓库中下载。

/bin/bash 是指定容器创建后立即执行的命令。

注意:每个容器都有一个唯一的ID，作为容器的标识。每个容器也有个唯一的名称，在用docker run命令创建时可以通过 --name 名称 来指定，如果不指定，系统会自动产生一个名称。

如： docker run --name  mycontainer   -i -t ubuntu /bin/bash

对于交互式容器，当退出shell后，容器会关闭。 后面可以通过命令重新启动容器。

三、启动/停止容器

如果一个容器已经停止，可以执行如下docker start命令重新启动容器，参数可以是容器的ID 或容器的名称。

docker start 3d72d0283dc8               执行后返回容器的ID

注意，如果指定的容器已经处于启动状态，上述命令只是返回容器ID，不会重新启动容器。

如果要想重启已经启动的容器，可以用 docker restart命令

如果要停止一个运行的容器，可以用 docker stop命令，kill命令也可停止容器，但这命令时强制立即停止容器。

四、附着到交互式容器上

当重新启动容器时，会沿用创建容器（docker run）命令时指定的参数来运行。如果创建容器时，指定了shell。

重启容器时，可以用 docker attach命令附着到容器上，当执行docker attach命令时（可能需要敲下回车键），就回到了容器的bash提示符，

这时就已经相当于在容器内部了的shell操作了。如果操作过程中，退出了shell。容器也会随之停止。

所以这种容器一般是完成特定任务的，不适合运行服务程序。

五、创建守护式容器

这种容器指容器可以长期一直运行，没有交互式会话，非常适合容器中运行后台应用程序和服务（如数据库服务、web服务器等）。
 
docker run --name mydaemon -d ubuntu /bin/sh -c "while true;do echo hello world;sleep 1;done"

上述语句利用-d标识创建了一个守护式容器，该容器启动了一个shell，循环打印一个信息，保证shell不退出。

可以通过docker logs命令来获取容器的日志 ,还可以通过 docker top 命令来查看容器内当前运行的进程信息。

六、与守护式容器交互

可以通过docker exec命令在容器内部额外启动新进程。

如在主机中，执行语句 docker exec -t -i mydaemon /bin/bash

则会出现一个shell会话（容器内的，不是主机的），这样就可以和容器进行交互了，可以完成自己想要的操作。
 
七、查看容器详细信息

利用docker logs 命令可以获取容器的日志信息。

利用docker inspect 命令可以查看容器更多的信息。 如ip地址等，这对守护容器还是很有意义的。

八、执行容器内命令

可以在docker主机上，执行 docker exec命令， 在容器内部启动新的进程。

docker exec -i -t  容器ID/NAME  /bin/bash

上面命令表示在容器内打开一个shell交互式会话，参数 -i -t 是让这个shell能被主机捕捉到，可以在主机上操作该shell。通过这个命令，就可以对容器进行相关的操作了，如进行容器的配置、应用程序的配置等。

注意：这个方式和attach不同。attach绑定的shell退出后容器会退出。这种方式不会。

九、删除容器  命令：docker rm ID/NAME    注意，运行中的容器是无法被删除的。

注意：在利用docker run创建容器时，可以加上标识 --rm，会在容器运行完毕后，自动删除容器，相当于创建的是一个一次性容器。如：

docker run --rm  .......     这个尤其在练习容器的操作使用时非常使用，省去了留下一堆垃圾容器需要人工清理的工作。

十、查看容器的内容改变信息

创建一个容器，会在容器的对应的镜像上增加一个可写层，镜像部分是只读的。通过 diff命令可以看出改变的信息。如：

xxx@ubuntu:~$ docker diff mysqldb
A /hello
C /root
A /root/.bash_history
A /root/.mysql_history
C /run
C /run/mysqld
A /run/mysqld/mysqld.pid
A /run/mysqld/mysqld.sock
A /run/mysqld/mysqld.sock.lock
C /tmp

说明：每行代表一个变动的文件或目录。其中 A 表示新增、C表示被修改、D表示被删除（这个例子没有体现）。

十一、主机和容器之间的文件拷贝

很多场景下，我们需要从主机将文件拷贝到容器中，或从容器拷贝文件都主机。利用 cp命令即可，语法格式如下：

docker cp  主机路径    ID/NAME:容器路径        //这是从主机拷贝文件到容器

docker cp   ID/NAME:容器路径    主机路径        //这是从容器拷贝文件到主机

十二、创建容器

我们上面的介绍都是用 docker run 创建容器，并在创建成功后立即启动该容器。

还有另外一个docker create命令，该命令使用格式同run命令，但它只创建容器，不会立即启动。要想运行容器，需要单独再执行启动命令。

 需要注意的是，使用docker create创建守护容器时，不能带-d标识符。

实际上无论是 run ，还是create命令，都有大量可选的参数，我们这里只是介绍最基本的使用方式（也就是说使用尽量少的参数）。在实际生产环境中，往往会更加复杂。

十三、重命名容器

每个一个容器除了ID外，都有一个name（可以在创建时指定，也可以不指定，由系统自动分配）。

当容器创建后，也可以通过rename命令给容器重命名。重命名时，容器处于运行或停止状态都允许修改。

语法格式： docker rename oldname newname

这个命令还是挺有用的，当一个容器的name不适合时，就需要重新创建，只需修改名称即可。 

docker学习笔记3：镜像操作（查找和下载）

一、查看本地镜像

  只有下载后，镜像才会保存在本地（docker环境所在的主机），通过如下命令可以查看本地已经存在的镜像。

命令：dokcer images  该命令列出本地所有已经存在的镜像，显示的信息如：

REPOSITORY          TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
ubuntu              latest              ce76de2e871b        8 days ago          188 MB
说明：docker images 命令可带参数，是个字符串，可以带通配，只显示过滤的镜像。

二、镜像中心

  本地的镜像是从远程镜像中心（Registry）下载到本地的，默认的镜像中心是docker公司负责运营的docker hub中心。

在远程镜像中心，镜像是保存在仓库（Repository）中，仓库存在镜像中心（Registry）中。

每个镜像都有一个唯一的ID号。 一个仓库（如上面的ubuntu）中有多个镜像，通过tag标识来区分不同镜像，一个仓库中的镜像通常是同一种类型的镜像，只是不同版本的区别。换句话说，镜像时由仓库名和tag标识来共同决定的。

docker hub中有两种类型的镜像：用户仓库（user repository）和顶层仓库（top-level  repository）。

用户仓库的镜像是有docker用户创建的。顶层仓库是有docker公司内部管理的。

用户仓库的命名由用户名和仓库名两部分组成（中间用/分隔）；而顶层仓库只有仓库名，如ubuntu仓库。

总结一下，镜像名称的标准格式是：  用户名/仓库名:Tag名，对于顶层的则没有用户名，如果省略tag名，默认为latest.

说明：也可以搭建私服的镜像中心，供企业内部使用。

三、在docker hub中心查找仓库

通过docker search命令可以查找docker hub上所有公共的可用仓库。

可以带一个字符串参数（支持通配），用于查找满足命名的仓库。

举例：docker search mysql
显示的内容如：

NAME                       DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
mysql                      MySQL is a widely used, open-source relati...   1872      [OK]       
mysql/mysql-server         Optimized MySQL Server Docker images. Crea...   110                  [OK]
centurylink/mysql          Image containing mysql. Optimized to be li...   38                   [OK]
sameersbn/mysql                                                            31                   [OK]
google/mysql               MySQL server for Google Compute Engine          14                   [OK]
appcontainers/mysql        Centos/Debian/Ubuntu Based Customizable My...   7                    [OK]
...................

返回的每条记录代表一个镜像。包含5个字段信息：
1）Name：镜像的仓库名。可以看出顶层仓库只有第一个镜像是。其它的都是用户仓库。

2）Description：仓库的描述信息

3）Stars：用户评价，反映一个仓库受欢迎的程度

4）Offical：是否官方，即是否是顶层仓库。可以看出，只有第一个镜像是顶层仓库。

5）Automated：表示这个镜像是由docker hub自动构建的。

四、下载镜像

通过docker run方法是创建容器，如果指定的镜像在本机不存在，则会先去下载镜像。

可以通过docker pull命令只下载镜像，不创建容器。

命令： docker pull  [用户名/]仓库名[:TAG]

含义： 如果只指定仓库名，会下载该仓库下的所有镜像。如果还指定了TAG值，则会下载指定的镜像。

对于dokcer run命令，只指定仓库名，不指定tag时，默认下载的是 latest标识的镜像。

xxx@ubuntu:~$ docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
ubuntu              latest              ce76de2e871b        8 days ago          188 MB
xxx@ubuntu:~$ docker pull mysql
Using default tag: latest
latest: Pulling from library/mysql
73e8d4f6bf84: Pull complete 
040bf8e08425: Pull complete 
86e6c3163927: Pull complete 
68f4b3625ea4: Pull complete 
04f7e78a2c8a: Pull complete 
1bade56c3b6b: Pull complete 
dd6387e14c18: Pull complete 
ca30c0626c9b: Pull complete 
0dc5e226a795: Pull complete 
6c164b0f04cb: Pull complete 
5c74d058f7b5: Pull complete 
0fd3b6e12567: Pull complete 
e8126a9d061e: Pull complete 
d17cffff8039: Pull complete 
1924f4186d05: Pull complete 
14961e5db73a: Pull complete 
Digest: sha256:16de02081c408c41361126aaa718f91693688d39a216a74ac8dab841db050228
Status: Downloaded newer image for mysql:latest
xxx@ubuntu:~$ docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
mysql               latest              14961e5db73a        4 days ago          361.3 MB
ubuntu              latest              ce76de2e871b        8 days ago          188 MB

镜像下载后，就可以通过docker run命令创建相应的容器了。

五、镜像的复制

一个镜像是属于一个仓库，一个仓库中有多个镜像，大家靠tag来区分。

在某些场景下，可能需要把一个已有的镜像 加入（也就是复制）到别的仓库中。这时可以用tag命令。具体的语法格式是：

docker tag [OPTIONS] orignIMAGE[:TAG] [REGISTRYHOST/][USERNAME/]newNAME[:TAG]

这个还是挺有用的，比如当创建一个镜像，命名不适合（仓库名和TAg标识），这样相当于改个名，但实际是拷贝一份。 

docker学习笔记4：利用docker hub上的mysql镜像创建mysql容器

docker hub上有官方的mysql镜像，我们可以利用它来创建mysql容器，作为一个服务容器使用。

1、下载mysql镜像

docker pull mysql

2、创建镜像

docker run --name mysqldb  -e MYSQL_ROOT_PASSWORD=root -d mysql

3、获取被创建容器的ip

docker inspect mysqldb

4、从主机上利用mysql客户端测试能否连接到容器中的mysql服务

mysql -h 172.17.0.2 -u root -p

上面的ip地址是mysqldb容器的ip地址，通过docker inspect mysqldb获取到的 

docker学习笔记5：利用commit命令创建镜像 和 删除本地镜像

一、概述

创建镜像有两种方法，一是用commit命令，二是用dockerfile方法（这个更常用，在下面文章介绍）。本章介绍commit方法。

在介绍commit命令前，我们先回顾下对代码的版本控制，当修改代码后，我们会commit变更到版本服务器上。

对于容器类似的概念，当创建容器后，如果后面对容器做了修改，就可以利用commit命令将修改提交为一个新的镜像。

二、例子说明

下面我们通过具体的例子来说明：

1、创建新容器

docker run --name newcontent -i -t ubuntu /bin/bash

2、进行操作，修改容器内容

echo hello world >>test.txt   //通过重定向功能创建一个文件

3、退出shell，容器关闭

4、用diff命令查看容器的变化信息

xxx@ubuntu:~$ docker diff newcontent
C /root
A /root/.bash_history
A /test.txt

5、创建新镜像
docker commit newcontent  newnewcontent2

这时就在本地创建了一个仓库名为newnewcontent2，tag值为默认为latest的镜像。

规范的镜像名应该为：[username/]repositoryName[:tagName]

如：docker commit newcontent  jeme/myubuntu:1.0  如果没有tagName，则默认为latest。

注意：如果需要把该镜像提交到dokcer hub中心，则必须规范命名（必须是  用户名/仓库名，tag可以缺省），前面的用户名是在dokcer hub上注册的用户名。

三、删除本地镜像   docker rmi  镜像名/ID

docker学习笔记6：利用dockerfile创建镜像介绍（生成简单web服务器镜像）

本文介绍如何利用dockerfile来创建镜像。下面介绍具体的操作过程：

一、创建构建环境
操作示例如下：

xxx@ubuntu:~$ pwd
/home/xxx
xxx@ubuntu:~$ mkdir myweb
xxx@ubuntu:~$ cd myweb
xxx@ubuntu:~/myweb$ touch Dockerfile
上面命令在当前用户(xxx)的主目录下创建了一个myweb目录，并在该目录下建立了一个空的文件名为Dockerfile文件。
这个目录就是我们的构建环境（或上下文）。

二、编写Dockerfile文件内容

Dockerfile文件中，是一系列的指令组成。每条指令，包括指令名（必须大写）和指令所需的参数。看一个例子：

# version：0.0.1
FROM ubuntu
MAINTAINER XXX "[e-mail]"
RUN  apt-get update
RUN  apt-get install -y nginx
RUN  echo 'hello, i am a web image'  > /usr/share/nginx/html/index.html
EXPOSE 80

文件的第一行是一条注释，在dockfile文件中，以#开头的表示注释。

当执行dockerfile文件时（如何执行，后面会介绍），其流程如下：

1、从基础镜像运行一个容器（第一条FROM指令的参数用于指定一个已经存在的基础镜像，每个dockerfile文件的第一条指令都是FROM）

2、在上面创建的容器中，执行一条指令，对容器做出修改（一般指令总会对容器进行一些改变，否则该指令就不需要了）

3、执行类似docker commit命令，提交一个新的镜像层（该层的内容就是上面指令造成的变化内容）

4、基于刚提交的镜像运行一个新的容器。

5、重复2~4步骤，逐个执行dockerfile中的所有指令。

看到这里大家可以有个疑问，为何每条指令都要创建镜像和容器呢，而不是只在开始创建一次容器，然后基于该容器执行所有指令，完成所有修改后，再提交生成一个镜像呢？

这正是docker镜像分层特点的优势。可以想象一下，采用这种放的好处是，即使因为某种原因导致某条指令失败，但我们还是可以得到一个可用的镜像，然后我们就可以通过该镜像运行一个容器，在该容器中执行失败的指令，从而方便的进行调试，找到失败原因。

下面我们来介绍上面dokcerfile文件中每一行的意义：

1、第一行上面已经介绍，以#开头，是注释。

2、第二行FROM指令，用于指定基础镜像。是所有dockerfile的第一条命令。因为所有新的镜像都会基于该基础镜像基础上变化来的。

3、第三行 MAINTAINER指令，是标识镜像的作者和联系方式（这里是电子邮件），以方便镜像使用者和作者联系。


4、第四~六行RUN指令，用于在容器中执行参数指定的命令。上面的例子第4行是更新已经安装的APT仓库，第5行是下载安装nginx包，第6行是生成一个html文件，文件中只包含简单的一句话。

5、最后一行EXPOSE指令，告诉docker守护进程，容器的应用将使用指定的端口号（EXPOSE指令的参数，这个例子是80）。

三、构建镜像

通过docker build命令运行dockerfile文件，最后生成需要的镜像。命令如：docker build -t="jene/myweb" .

参数-t指定生成镜像的所属用户名和仓库名，也可以有tag标识（这个例子没写，默认为latest）。 

命令的最后点 不是结束符，而是表示Dockerfile文件在当前路径下。也可以指定一个git仓库的地址（只要该地址下有Dockerfile），则会利用git仓库中的dockerfile文件来构建镜像。

执行的过程会详细 输出每条指令执行的详细信息。

构建成功后，我们就可以用 docker images命令查看新构建的镜像，也可以用docker history命令查看新构建镜像的构建历史。

四、创建容器和启动容器中的web服务

docker run -d -p 80 --name myweb 1311399350/myweb nginx -g "daemon off;"

上面命令创建和运行了容器，并将nginx服务启动了。

上面命令除 -p参数外，其它参数前面文章都介绍过了。-d表示是 容器。 --name指定容器名，这里是myweb。 后面的是镜像名。以及要执行的命令（这里是启动nginx服务）。 -p参数我们下面详细介绍。

下面我们来通过curl工具测试这个web服务是否可用。

1、先进入容器内访问

docker exec -i -t myweb /bin/bash    //进入容器的交互式shell

curl localhost:80   //可能容器中没有curl工具

输出如下内容 ：hello, i am a web image

2、在主机上访问容器内的服务

首先查看容器内的80端口与主机上的端口的映射关系

运行 docker port myweb 80 显示信息如下

0.0.0.0:32768

这里可以看出，映射的端口是32768.

我们在主机执行： curl localhost:32768

输出：hello, i am a web image

3、在主机以外的局域网内的其它机器访问

先用ifconfig查看dokcer主机的ip地址，如 192.168.142.138

在其它机器上通过   一样可以访问到 index.html网页。

五、容器的端口配置

方法一：自动映射

docker run -d -p 80 --name myweb 1311399350/myweb nginx -g "daemon off;"

上面的 -p 80 ,将在docker主机上随机打开一个端口（可利用docker port命令查看，或者docker ps也能看到，这里是32768）映射到容器中的80端口上。

方法二：指定映射

除了自动映射外，还可以指定映射关系，如：

docker run -d -p 80:80 --name myweb 1311399350/myweb nginx -g "daemon off;"

docker port myweb 80
0.0.0.0:80

可以看出，主机上的80端口映射到容器的80端口。

这样指定的方式有好有怀，坏处是，第一无法运行多个同样的容器，第二容易与主机上的应用冲突。好处是端口是已知的。需要小心使用。

方法三：公开dockerfile中EXPOSE指令指定的端口

docker run -d -P --name myweb 1311399350/myweb nginx -g "daemon off;"

利用大写的-P参数，将dockerfile中EXPOSE指令指定的端口（容器内端口）对本地宿主主机公开，并随机绑定到本地宿主主机的端口上。

docker port myweb 80
0.0.0.0:32771

注意： 在docker run命令中通过 -p标记暴露的容器端口，并不一定需要在dockerfile文件中用EXPOSE指令配置。

在dockerfile文件中用EXPOSE指令配置端口，其好处是在docker run命令中可以用-P标记来全部暴露，省去了在docker run命令中用-p来逐个指定。 

docker学习笔记7：发布镜像到docker hub上

镜像创建好后，很重要的一个操作就是共享和发布。可以将自己创建的镜像发布到docker hub上，也可以发布到自己的私有docker hub上。

要想发布镜像到dokcer hub上，首先要在dokcer hub上注册账户，并且在本机（准备提交镜像到docker hub的机器上）上进行注册。具体过程如下：

1、登录 网站注册一个用户，如 jeme。注册时需要提供邮箱进行验证。
2、在本机用docker login 向docker hub注册（登录），如：
xxx@ubuntu:~$ docker login
Username: jeme
Password:
Email: [e-mail]
WARNING: login credentials saved in /home/xxx/.docker/config.json
Login Succeeded

说明：验证通过后，就可以开始将本地创建的镜像发布到docker hub自己的账户下了。

可以通过 docker logout命令退出docker hub，退出后就没法发布镜像到docker hub，除非再次注册。

3、发布镜像

docker push 用户名/仓库名[:tag名]

这里的 用户名/仓库名[:tag名]  代表的镜像必须是本机存在的，tag名不写的话默认就是latest。 也就是说在创建镜像时的命名必须是规范的格式（加用户名）。

并且用户名就是自己在docker hub上注册的名称。如这里的jeme.

发布成功后，这时我们用docker search 就能搜到自己提的镜像。 

docker学习笔记11：Dockerfile 指令 CMD介绍

我们知道，通过docker run 创建并启动一个容器时，命令的最后可以指定容器启动后在容器内立即要执行的指令，如：

docker run -i -t ubunu /bin/bash   //表示容器启动时立即在容器内打开一个shell终端

docker run ubuntu /bin/ps    //表示容器启动后立即运行 /bin/ps命令，显示容器的当前进程。

除了这种方式外，我们可以在dockerfile文件中通过CMD指令指定容器启动时要执行的命令。如：
#test
FROM ubuntu
MAINTAINER xxx
RUN echo hello1 > test1.txt
RUN echo hello2 > /test2.txt
EXPOSE 80
EXPOSE 81
CMD ["/bin/bash"]

上面dockerfile文件中最后一行CMD指令的参数是指定容器启动时要执行的命令，这里是bin/bash命令。

1、用docker run命令创建并启动容器（myimage  是用前面dockerfile创建的镜像的名称）：
docker run -i -t myimage  
上面命令是创建并启动容器，打开一个交互式shell。 而以前的写法是

docker run -i -t myimage  /bin/bash

这样就省去了在docker run中写命令了。

2、即使dockerfile中有CMD指令，我们仍然可以在docker run命令中带上容器启动时执行的命令，这会覆盖dockerfile中的CMD指令指定的命令。如：

docker run -i -t myimage /bin/ps

上面命令，因为/bin/ps覆盖了CMD指令，启动容器时会打印容器内的当前进程，但容器会立即停止，因为/bin/bash被覆盖了，无法打开交互式shell界面。

3、需要注意的是，dockerfile中可以有多条cmd命令，但只是最后一条有效。

4、CMD命令的参数格式，一般写成 字符串数组的方式，如上面的例子。如：

CMD  ["echo","hello world"]

虽然也可写成CMD echo hello word 方式，但这样docker会在指定的命令前加  /bin/sh -c 执行，有时有可能会出问题。 所以推荐采用数据结构的方式来存放命令。

docker 学习笔记20：docker守护进程的配置与启动

安装好docker后，需要启动docker守护进程。有多种启动方式。

一、服务的方式

因为docker守护进程被安装成服务。所以，可以通过服务的方式启停docker守护进程，包括查看状态。

sudo start docker  //启动

sudo stop docker  //停止

sudo status docker  //查看状态

二、利用docker daemon命令

sudo docker daemon

利用sudo ps -A 可以获取守护进程的进程号
 
三、让远程api可以访问docker守护进程

sudo docker daemon -H tcp://0.0.0.0:2375

这需要每次都带参数，而且无法通过服务的方式启动。

可以通过在配置文件配置，来让服务启动也可以让远程访问生效。

对于ubuntu操作系统，修改/etc/default/docker文件中的DOCKER_OPTS设置，如下：

# Use DOCKER_OPTS to modify the daemon startup options.

#DOCKER_OPTS="--dns 8.8.8.8 --dns 8.8.4.4"

DOCKER_OPTS="-H=unix:///var/run/docker.sock -H=0.0.0.0:2375"

这样通过 sudo start docker启动docker后，就可以远程访问了，如：

  //相当于在本地 docker info访问

 //返回活动的容器

？all=1 返回所有容器

除了利用web访问外，还可利用docker命令远程访问，如果别的机器上也装了docker，

访问方式如： docker -H  192.168.142.138:2375 info

注意：可以采用 sudo docker daemon 方式启动守护进程，然后进行本地的docker命令操作，可以铜鼓日志查看不同命令对应的url

 在linux下，可以通过curl工具访问url，因为返回的是json串，非格式化的。可以结合python命令，转为格式化的json，让看起来比较清楚。如：

curl http://192.168.142.138:2375/images/json | python -mjson.tool

docker 学习笔记21：docker连接网络的设置


1、如果docker主机不需要通过代理连接外网


    则docker的相关命令（如docker search）或docker容器与网络相关的操作都可以正常进行，不需要特殊设置。
 

2、当docker主机 是通过代理才能连接外网时，采用服务方式启动守护进程


如果docker守护进程是通过服务的方式启动的（sudo start docker）

当我们执行如  docker search ubuntu 命令时，会报错
Error response from daemon: Get dial tcp: lookup index.docker.io on 127.0.1.1:53: read udp 127.0.1.1:53: i/o timeout

而且这时启动的容器，在容器内也无法连接外网。

需要通过设置来完成。

3、当docker主机 是通过代理才能连接外网时，让docker守护进程可连接外网，非服务启动方式

通过如下方式启动docker守护进程

sudo HTTP_PROXY=http://代理地址:端口 docker daemon

这时执行如  docker search ubuntu 命令时，可以成功。 注意，这并不需要docker主机自己设置代理上网（也就是docker进程没有利用主机设置的代理上网）。

但是正常启动的容器，在容器内也无法连接外网。


4、当docker主机 是通过代理才能连接外网时，采用服务方式启动

可以修改 /etc/default/docker 配置文件

# If you need Docker to use an HTTP proxy, it can also be specified here.
#export http_proxy=""
export http_proxy="http://代理地址:端口"

这样采用 sudo start docker方式启动守护进程后

这时执行如  docker search ubuntu 命令时，可以成功。

注意，这并不需要docker主机自己设置代理上网（也就是docker进程没有利用主机设置的代理上网）。

但是正常启动的容器，在容器内也无法连接外网。

5、怎么让容器通过代理上网


容器本身是一个轻量级的linux系统，我们可以通让主机上网一样设置让其上网。容器上网和让docker守护进程联网没有关系。

方法一：临时联网

在shell界面上设置临时环境变量：  export http_proxy="http://代理ip地址:端口"

如：export http_proxy=""

一旦设置正确的环境变量http_proxy，容器就可以正常上网了。

因为是临时的，shell关闭后，环境变量就没了。

方法二：修改主目录下的.bashrc文件，增加两行

http_proxy=
export http_proxy

就是把环境变量http_proxy持久化，但只对该用户登录有效。

注意：容器设置代理 和 docker主机设置代理以及docker守护进程设置代理无关，也就是容器只会使用自己的代理信息上网。

docker学习笔记：容器的网络设置

创建一个docker容器，docker系统会自动为该容器分配一个ip地址，通常是172.17开头。


我们可以在主机上用 docker inspect 命令 或者进入容器用ifconfig命令来查看容器的ip地址。


假设某个容器(假设容器的名称为myweb)被分配的地址是 172.17.0.2，该容器上启动了一个web服务，其端口号是80（注意这是容器中的端口号）。


这时我们用docker port命令可以查看该web服务在容器的端口对应到主机端口的信息，如：


docker port myweb


输出
80/tcp -> 0.0.0.0:32776

一、这时我们在docker主机上可通过如下方式访问容器的服务

1、方式一：

curl  

2、方式二：

假设主机的ip地址为192.168.142.138

curl  

这样docker主机局域网内的机器就可以通过主机的地址和绑定的ip来访问到docker容器上的服务了。不过这存在的问题是，需要将容器端口与主机上端口的映射关系变成固定的。否则一旦容器重启，绑定端口就会变了。


3、方式三：

假设容器的ip地址为 172.17.0.2

curl


二、其它容器访问该容器的web服务


现在启动另外一个容器，在该容器中要访问myweb容器提供的web服务，可以用如下方式：

1、方式一：直接通过容器的ip地址访问

curl  


说明：这么做是可以的，但问题是容器的ip地址是自动分配的，一旦提供该web服务的容器重启后，其ip可能发生变化。这就导致原来指定的ip有问题了。

2、方式二：通过主机地址和映射端口访问


curl

说明：这存在的问题是，端口的映射是自动的，容器一旦重启后会发生变化。


总结下，如果某个容器提供了对外的服务（如web服务），则统一的访问方式可以利用docker主机的ip地址和容器映射到主机上的端口来统一访问。


三、容器之间互联的另外一种方式

docker提供了一种机制，可以让一个容器和另一个容器很方便的连接起来。举例：

docker run --name test1 --link myweb:web -it ubuntu /bin/bash

上面命令创建了一个新的容器test1。 这里引入了一个新的标记 --link，其参数部分的myweb表示要连接的容器，web是要连接的容器的别名。

容器创建后，我们用 ping web命令发现能连接到myweb容器，这样因为用的不是ip地址，而是别名。这样即使myweb1容器重启后，上面创建的test1容器对其连接的代码或脚本也不用修改。

假设myweb容器提供了web服务，容器内的端口是80.

这时在test1容器内可以用如下方式访问：  curl  

显然，这种方式的优点是不再指定ip地址，即使 myweb容器重启后ip地址变了也没关系。

 注意：需要注意的是，如果myweb容器未启动，但有别的容器启动，test1容器利用别名web可能会关联到别的容器上，这是个问题。

1. 查看docker信息（version、info）

1. # 查看docker版本  
2. $docker version  
3.   
4. # 显示docker系统的信息  
5. $docker info  

2. 对image的操作（search、pull、images、rmi、history）

1. # 检索image  
2. $docker search image_name  
3.   
4. # 下载image  
5. $docker pull image_name  
6.   
7. # 列出镜像列表; -a, --all=false Show all images; --no-trunc=false Don't truncate output; -q, --quiet=false Only show numeric IDs  
8. $docker images  
9.   
10. # 删除一个或者多个镜像; -f, --force=false Force; --no-prune=false Do not delete untagged parents  
11. $docker rmi image_name  
12.   
13. # 显示一个镜像的历史; --no-trunc=false Don't truncate output; -q, --quiet=false Only show numeric IDs  
14. $docker history image_name  

3. 启动容器（run）

容器可以理解为在沙盒中运行的进程。这个沙盒包含了该进程运行所必须的资源，包括文件系统、系统类库、shell 环境等等。但这个沙盒默认是不会运行任何程序的。你需要在沙盒中运行一个进程来启动某一个容器。这个进程是该容器的唯一进程，所以当该进程结束的时候，容器也会完全的停止。

1. # 在容器中运行"echo"命令，输出"hello word"  
2. $docker run image_name echo "hello word"  
3.   
4. # 交互式进入容器中  
5. $docker run -i -t image_name /bin/bash  
6.   
7.   
8. # 在容器中安装新的程序  
9. $docker run image_name apt-get install -y app_name  

Note：  在执行apt-get 命令的时候，要带上-y参数。如果不指定-y参数的话，apt-get命令会进入交互模式，需要用户输入命令来进行确认，但在docker环境中是无法响应这种交互的。apt-get 命令执行完毕之后，容器就会停止，但对容器的改动不会丢失。

4. 查看容器（ps）

1. # 列出当前所有正在运行的container  
2. $docker ps  
3. # 列出所有的container  
4. $docker ps -a  
5. # 列出最近一次启动的container  
6. $docker ps -l  

5. 保存对容器的修改（commit）

当你对某一个容器做了修改之后（通过在容器中运行某一个命令），可以把对容器的修改保存下来，这样下次可以从保存后的最新状态运行该容器。

1. # 保存对容器的修改; -a, --author="" Author; -m, --message="" Commit message  
2. $docker commit ID new_image_name  

Note：  image相当于类，相当于实例，不过可以动态给实例安装新软件，然后把这个container用commit命令固化成一个image。

6. 对容器的操作（rm、stop、start、kill、logs、diff、top、cp、restart、attach）

1. # 删除所有容器  
2. $docker rm `docker ps -a -q`  
3.   
4. # 删除单个容器; -f, --force=false; -l, --link=false Remove the specified link and not the underlying container; -v, --volumes=false Remove the volumes associated to the container  
5. $docker rm Name/ID  
6.   
7. # 停止、启动、杀死一个容器  
8. $docker stop Name/ID  
9. $docker start Name/ID  
10. $docker kill Name/ID  
11.   
12. # 从一个容器中取日志; -f, --follow=false Follow log output; -t, --timestamps=false Show timestamps  
13. $docker logs Name/ID  
14.   
15. # 列出一个容器里面被改变的文件或者目录，list列表会显示出三种事件，A 增加的，D 删除的，C 被改变的  
16. $docker diff Name/ID  
17.   
18. # 显示一个运行的容器里面的进程信息  
19. $docker top Name/ID  
20.   
21. # 从容器里面拷贝文件/目录到本地一个路径  
22. $docker cp Name:/container_path to_path  
23. $docker cp ID:/container_path to_path  
24.   
25. # 重启一个正在运行的容器; -t, --time=10 Number of seconds to try to stop for before killing the container, Default=10  
26. $docker restart Name/ID  
27.   
28. # 附加到一个运行的容器上面; --no-stdin=false Do not attach stdin; --sig-proxy=true Proxify all received signal to the process  
29. $docker attach ID  

Note： attach命令允许你查看或者影响一个运行的容器。你可以在同一时间attach同一个容器。你也可以从一个容器中脱离出来，是从CTRL-C。

7. 保存和加载镜像（save、load）

当需要把一台机器上的镜像迁移到另一台机器的时候，需要保存镜像与加载镜像。

1. # 保存镜像到一个tar包; -o, --output="" Write to an file  
2. $docker save image_name -o file_path  
3. # 加载一个tar包格式的镜像; -i, --input="" Read from a tar archive file  
4. $docker load -i file_path  
5.   
6. # 机器a  
7. $docker save image_name > /home/save.tar  
8. # 使用scp将save.tar拷到机器b上，然后：  
9. $docker load < /home/save.tar  

8、 登录registry server（login）

1. # 登陆registry server; -e, --email="" Email; -p, --password="" Password; -u, --username="" Username  
2. $docker login  

9. 发布image（push）

1. # 发布docker镜像  
2. $docker push new_image_name  

10.  根据Dockerfile 构建出一个容器

1. #build  
2.       --no-cache=false Do not use cache when building the image  
3.       -q, --quiet=false Suppress the verbose output generated by the containers  
4.       --rm=true Remove intermediate containers after a successful build  
5.       -t, --tag="" Repository name (and optionally a tag) to be applied to the resulting image in case of success  
6. $docker build -t image_name Dockerfile_path  

Dockfile是一种被程序解释的脚本，Dockerfile由一条一条的指令组成，每条指令对应下面的一条命令。Docker程序将这些Dockerfile指令翻译真正的Linux命令。Dockerfile有自己书写格式和支持的命令，Docker程序解决这些命令间的依赖关系，类似于Makefile。Docker程序将读取Dockerfile，根据指令生成定制的image。相比image这种黑盒子，Dockerfile这种显而易见的脚本更容易被使用者接受，它明确的表明image是怎么产生的。有了Dockerfile，当我们需要定制自己额外的需求时，只需在Dockerfile上添加或者修改指令，重新生成image即可，省去了敲命令的麻烦。

1. Dockerfile的书写规则及指令使用方法

Dockerfile的指令是忽略大小写的，建议使用大写，使用 # 作为注释，每一行只支持一条指令，每条指令可以携带多个参数。
Dockerfile的指令根据作用可以分为两种，构建指令和设置指令。构建指令用于构建image，其指定的操作不会在运行image的容器上执行；设置指令用于设置image的属性，其指定的操作将在运行image的容器中执行。

（1）FROM（指定基础image）

构建指令，必须指定且需要在Dockerfile其他指令的前面。后续的指令都依赖于该指令指定的image。FROM指令指定的基础image可以是官方远程仓库中的，也可以位于本地仓库。
该指令有两种格式：

1. FROM   

指定基础image为该image的最后修改的版本。或者：

1. FROM :  

指定基础image为该image的一个tag版本。

（2）MAINTAINER（用来指定镜像创建者信息）

构建指令，用于将image的制作者相关的信息写入到image中。当我们对该image执行docker inspect命令时，输出中有相应的字段记录该信息。
格式：

1. MAINTAINER   

（3）RUN（安装软件用）

构建指令，RUN可以运行任何被基础image支持的命令。如基础image选择了ubuntu，那么软件管理部分只能使用ubuntu的命令。
该指令有两种格式：

1. RUN  (the command is run in a shell - `/bin/sh -c`)  
2. RUN ["executable", "param1", "param2" ... ]  (exec form)  

（4）CMD（设置container启动时执行的操作）

设置指令，用于container启动时指定的操作。该操作可以是执行自定义脚本，也可以是执行系统命令。该指令只能在文件中存在一次，如果有多个，则只执行最后一条。
该指令有三种格式：

1. CMD ["executable","param1","param2"] (like an exec, this is the preferred form)  
2. CMD command param1 param2 (as a shell)  

当Dockerfile指定了ENTRYPOINT，那么使用下面的格式：

1. CMD ["param1","param2"] (as default parameters to ENTRYPOINT)  

ENTRYPOINT指定的是一个可执行的脚本或者程序的路径，该指定的脚本或者程序将会以param1和param2作为参数执行。所以如果CMD指令使用上面的形式，那么Dockerfile中必须要有配套的ENTRYPOINT。

（5）ENTRYPOINT（设置container启动时执行的操作）

设置指令，指定容器启动时执行的命令，可以多次设置，但是只有最后一个有效。
两种格式:

1. ENTRYPOINT ["executable", "param1", "param2"] (like an exec, the preferred form)  
2. ENTRYPOINT command param1 param2 (as a shell)  

该指令的使用分为两种情况，一种是独自使用，另一种和CMD指令配合使用。
当独自使用时，如果你还使用了CMD命令且CMD是一个完整的可执行的命令，那么CMD指令和ENTRYPOINT会互相覆盖只有最后一个CMD或者ENTRYPOINT有效。

1. # CMD指令将不会被执行，只有ENTRYPOINT指令被执行  
2. CMD echo “Hello, World!”  
3. ENTRYPOINT ls -l  

另一种用法和CMD指令配合使用来指定ENTRYPOINT的默认参数，这时CMD指令不是一个完整的可执行命令，仅仅是参数部分；ENTRYPOINT指令只能使用JSON方式指定执行命令，而不能指定参数。

1. FROM ubuntu  
2. CMD ["-l"]  
3. ENTRYPOINT ["/usr/bin/ls"]  

（6）USER（设置container容器的用户）

设置指令，设置启动容器的用户，默认是root用户。

1. # 指定memcached的运行用户  
2. ENTRYPOINT ["memcached"]  
3. USER daemon  
4. 或  
5. ENTRYPOINT ["memcached", "-u", "daemon"]  

（7）EXPOSE（指定容器需要映射到宿主机器的端口）

设置指令，该指令会将容器中的端口映射成宿主机器中的某个端口。当你需要访问容器的时候，可以不是用容器的IP地址而是使用宿主机器的IP地址和映射后的端口。要完成整个操作需要两个步骤，首先在Dockerfile使用EXPOSE设置需要映射的容器端口，然后在运行容器的时候指定-p选项加上EXPOSE设置的端口，这样EXPOSE设置的端口号会被随机映射成宿主机器中的一个端口号。也可以指定需要映射到宿主机器的那个端口，这时要确保宿主机器上的端口号没有被使用。EXPOSE指令可以一次设置多个端口号，相应的运行容器的时候，可以配套的多次使用-p选项。
格式:

1. EXPOSE  [...]  

1. # 映射一个端口  
2. EXPOSE port1  
3. # 相应的运行容器使用的命令  
4. docker run -p port1 image  
5.   
6. # 映射多个端口  
7. EXPOSE port1 port2 port3  
8. # 相应的运行容器使用的命令  
9. docker run -p port1 -p port2 -p port3 image  
10. # 还可以指定需要映射到宿主机器上的某个端口号  
11. docker run -p host_port1:port1 -p host_port2:port2 -p host_port3:port3 image  

端口映射是docker比较重要的一个功能，原因在于我们每次运行容器的时候容器的IP地址不能指定而是在桥接网卡的地址范围内随机生成的。宿主机器的IP地址是固定的，我们可以将容器的端口的映射到宿主机器上的一个端口，免去每次访问容器中的某个服务时都要查看容器的IP的地址。对于一个运行的容器，可以使用docker port加上容器中需要映射的端口和容器的ID来查看该端口号在宿主机器上的映射端口。

（8）ENV（用于设置环境变量）

构建指令，在image中设置一个环境变量。
格式:

1. ENV    

设置了后，后续的RUN命令都可以使用，container启动后，可以通过docker inspect查看这个环境变量，也可以通过在docker run --env key=value时设置或修改环境变量。
假如你安装了JAVA程序，需要设置JAVA_HOME，那么可以在Dockerfile中这样写：
ENV JAVA_HOME /path/to/java/dirent

（9）ADD（从src复制文件到container的dest路径）

构建指令，所有拷贝到container中的文件和文件夹权限为0755，uid和gid为0；如果是一个目录，那么会将该目录下的所有文件添加到container中，不包括目录；如果文件是可识别的压缩格式，则docker会帮忙解压缩（注意压缩格式）；如果是文件且中不使用斜杠结束，则会将视为文件，的内容会写入；如果是文件且中使用斜杠结束，则会文件拷贝到目录下。
格式:

1. ADD    

是相对被构建的源目录的相对路径，可以是文件或目录的路径，也可以是一个远程的文件url;
是container中的绝对路径

（10）VOLUME（指定挂载点)）

设置指令，使容器中的一个目录具有持久化存储数据的功能，该目录可以被容器本身使用，也可以共享给其他容器使用。我们知道容器使用的是AUFS，这种文件系统不能持久化数据，当容器关闭后，所有的更改都会丢失。当容器中的应用有持久化数据的需求时可以在Dockerfile中使用该指令。
格式:

1. VOLUME [""]  

1. FROM base  
2. VOLUME ["/tmp/data"]  

运行通过该Dockerfile生成image的容器，/tmp/data目录中的数据在容器关闭后，里面的数据还存在。例如另一个容器也有持久化数据的需求，且想使用上面容器共享的/tmp/data目录，那么可以运行下面的命令启动一个容器：

1. docker run -t -i -rm -volumes-from container1 image2 bash  

container1为第一个容器的ID，image2为第二个容器运行image的名字。

（11）WORKDIR（切换目录）

设置指令，可以多次切换(相当于cd命令)，对RUN,CMD,ENTRYPOINT生效。
格式:

1. WORKDIR /path/to/workdir  

1. # 在 /p1/p2 下执行 vim a.txt  
2. WORKDIR /p1 WORKDIR p2 RUN vim a.txt  

（12）ONBUILD（在子镜像中执行）

1. ONBUILD   

ONBUILD 指定的命令在构建镜像时并不执行，而是在它的子镜像中执行。
详细资料可参考

2. 创建Dockerfile，构建jdk+tomcat环境

Dockerfile文件

# Pull base image
FROM ubuntu:13.10

MAINTAINER zing wang "[e-mail]"

# update source
RUN echo "deb "> /etc/apt/sources.list
RUN apt-get update

# Install curl
RUN apt-get -y install curl

# Install JDK 7
RUN cd /tmp &&  curl -L '' -H 'Cookie: oraclelicense=accept-securebackup-cookie; gpw_e24=Dockerfile' | tar -xz
RUN mkdir -p /usr/lib/jvm
RUN mv /tmp/jdk1.7.0_65/ /usr/lib/jvm/java-7-oracle/

# Set Oracle JDK 7 as default Java
RUN update-alternatives --install /usr/bin/java java /usr/lib/jvm/java-7-oracle/bin/java 300
RUN update-alternatives --install /usr/bin/javac javac /usr/lib/jvm/java-7-oracle/bin/javac 300

ENV JAVA_HOME /usr/lib/jvm/java-7-oracle/

# Install tomcat7
RUN cd /tmp && curl -L '' | tar -xz
RUN mv /tmp/apache-tomcat-7.0.8/ /opt/tomcat7/

ENV CATALINA_HOME /opt/tomcat7
ENV PATH $PATH:$CATALINA_HOME/bin

ADD tomcat7.sh /etc/init.d/tomcat7
RUN chmod 755 /etc/init.d/tomcat7

# Expose ports.
EXPOSE 8080

# Define default command.
ENTRYPOINT service tomcat7 start && tail -f /opt/tomcat7/logs/catalina.out

tomcat7.sh

1. export JAVA_HOME=/usr/lib/jvm/java-7-oracle/  
2. export TOMCAT_HOME=/opt/tomcat7  
3.   
4. case $1 in  
5. start)  
6.   sh $TOMCAT_HOME/bin/startup.sh  
7. ;;  
8. stop)  
9.   sh $TOMCAT_HOME/bin/shutdown.sh  
10. ;;  
11. restart)  
12.   sh $TOMCAT_HOME/bin/shutdown.sh  
13.   sh $TOMCAT_HOME/bin/startup.sh  
14. ;;  
15. esac  
16. exit 0  

我已经把这些文件上传到了Github

3. 构建镜像

脚本写好了，需要转换成镜像：

1. docker build -t zingdocker/jdk-tomcat .  
2. docker run -d -p 8090:8080 zingdocker/jdk-tomcat  

默认情况下，tomcat会占用8080端口，刚才在启动container的时候，指定了 -p 8090:8080，映射到宿主机端口就是8090。

host为主机IP

1. 前言

Docker的英文本意是“搬运工”，在程序员的世界里，Docker搬运的是集装箱（Container），集装箱里装的是任意类型的App，开发者通过Docker可以将App变成一种标准化的、可移植的、自管理的组件，可以在任何主流系统中开发、调试和运行。

2. 前提

(1) 由于现在的docker的局限性，现在只能使用在64位的服务器上；
(2) 由于linux容器的bug，docker在linux的kernel3.8上运行最佳，同时需要支持AUFS。

3. 升级内核（kernel3.8省略此步），可通过 uname -a 查看系统内核版本

1. # upgrade kernel  
2. sudo apt-get update  
3. sudo apt-get install linux-image-generic-lts-raring linux-headers-generic-lts-raring  
4.   
5. # reboot  
6. sudo reboot  

4. 激活AUFS文件系统支持

1. # 检查一下AUFS是否已安装  
2. sudo apt-get update  
3. sudo apt-get install linux-image-extra-`uname -r`  

5. 安装Docker

1. # 添加Docker库的密钥  
2. sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 36A1D7869245C8950F966E92D8576A8BA88D21E9  
3.   
4. # 添加Docker的库到apt的源列表，更新并安装lxc-docker包  
5. sudo sh -c "echo deb \  
6. > /etc/apt/sources.list.d/docker.list"  
7. sudo apt-get update  
8. sudo apt-get install lxc-docker  

6. 检查Docker是否已安装成功

1. sudo docker version  

7. 添加用户到docker用户组，使之获得执行权限

在执行Docker时，每次都要输入sudo，这样很费事，可以添加用户到docker用户组，使之获得执行权限

1. # 添加当前用户www到docker用户组里  
2. sudo gpasswd -a www docker  
3. # 重启Docker  
4. sudo service docker restart  
5. # 重启系统，使之生效  
6. sudo reboot  

一、查看docker信息

1、查看docker版本docker version
2、显示docker系统的信息docker info

二、对image的操作

1、检索imagedocker search image_name
2、下载imagedocker pull image_name
3、列出镜像列表docker images
4、删除一个或者多个镜像docker rmi image_name
5、显示一个镜像的历史docker history image_name
三、启动容器

1、在容器中运行”echo”命令，输出”hello word”docker run image_name echo "hello word"
2、交互式进入容器中docker run -i -t image_name /bin/bash
3、在容器中安装新的程序docker run image_name apt-get install -y app_name

四、查看容器

1、列出当前所有正在运行的containerdocker ps
2、列出所有的containerdocker ps -a
3、列出最近一次启动的containerdocker ps -l

五、保存对容器的修改

1、保存对容器的修改docker commit ID new_image_name

六、对容器的操作

1、删除所有容器docker rm `docker ps -a -q`
2、删除单个容器docker rm Name/ID
3、 停止、启动、杀死一个容器$docker stop Name/ID  
$docker start Name/ID  
$docker kill Name/ID
4、从一个容器中取日志docker logs Name/ID
5、列出一个容器里面被改变的文件或者目录docker diff Name/ID
6、显示一个运行的容器里面的进程信息docker top Name/ID

7、从容器里面拷贝文件/目录到本地一个路径
docker cp Name:/container_path to_path  
docker cp ID:/container_path to_path
8、重启一个正在运行的容器docker restart Name/ID
9、附加到一个运行的容器上面docker attach ID

七、 保存和加载镜像

1、保存镜像到一个tar包docker save image_name -o file_path
2、加载一个tar包格式的镜像docker load -i file_path
八、 登录registry server1、登陆registry serverdocker login
九、发布image1、发布docker镜像docker push new_image_name