超长docker笔记

docker-ce 和docker-ee

docker操作容器只需要id前4位就可以

docker编译安装

https://blog.csdn.net/lwyeluo/article/details/51765309

 

删除命令

docker rmi $(docker images | grep none | awk '{print $3}')

 

ubuntu安装

Ubuntu 16.04 LTS 64位系统，通过apt的docker官方源安装最新的Docker CE(Community Edition)，即Docker社区版，是开发人员和小型团队的理想选择。

开始安装

·        由于apt官方库里的docker版本可能比较旧，所以先卸载可能存在的旧版本：

$ sudo apt-get remove docker docker-engine docker-ce docker.io1

·        更新apt包索引：

$ sudo apt-get update1

·        安装以下包以使apt可以通过HTTPS使用存储库（repository）：

$ sudo apt-get install -y apt-transport-https ca-certificates curl software-properties-common1

·        添加Docker官方的GPG密钥：

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -1

·        使用下面的命令来设置stable存储库：

$ sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"1

·        再更新一下apt包索引：

$ sudo apt-get update1

·        安装最新版本的Docker CE：

$ sudo apt-get install -y docker-ce1

·        在生产系统上，可能会需要应该安装一个特定版本的Docker CE，而不是总是使用最新版本：

列出可用的版本：

$ apt-cache madison docker-ce1

 

选择要安装的特定版本，第二列是版本字符串，第三列是存储库名称，它指示包来自哪个存储库，以及扩展它的稳定性级别。要安装一个特定的版本，将版本字符串附加到包名中，并通过等号(=)分隔它们：

$ sudo apt-get install docker-ce=<VERSION>1

验证docker

·        查看docker服务是否启动：

$ systemctl status docker

·        若未启动，则启动docker服务：

$ sudo systemctl start docker1

·        经典的hello world：

$ sudo docker run hello-world

有以上输出则证明docker已安装成功！

 

 

本教程$为普通用户#为root用户

前提条件

Docker 要求 Ubuntu 系统的内核版本高于 3.10 ，查看本页面的前提条件来验证你的 Ubuntu 版本是否支持 Docker。

通过 uname -r 命令查看你当前的内核版本

 

runoob@runoob:~$ uname -r

 

使用脚本安装 Docker

1、获取最新版本的 Docker 安装包

 

runoob@runoob:~$ wget -qO- https://get.docker.com/ | sh

 

 

# 添加镜像元

$ sudo apt-get install -y apt-transport-https

添加源的gpg密钥：

$ sudo apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys 58118E89F3A912897C070ADBF76221572C52609D

获取当前操作系统的代号

$ lsb_release -c

Codename: trusty

 

 

2、启动docker 后台服务

runoob@runoob:~$ sudo service docker start

3、测试运行hello-world

runoob@runoob:~$ sudo docker run hello-world

镜像加速

鉴于国内网络问题，后续拉取 Docker 镜像十分缓慢，我们可以需要配置加速器来解决，我使用的是网易的镜像地址：http://hub-mirror.c.163.com。

新版的 Docker 使用 /etc/docker/daemon.json（Linux） 或者 %programdata%\docker\config\daemon.json（Windows） 来配置 Daemon。

请在该配置文件中加入（没有该文件的话，请先建一个）：

{ "registry-mirrors": ["http://hub-mirror.c.163.com"] }

 

配置Docker

为了避免每次使用docker命令都要用特权身份，可以将当前用户加入安装中自动创建的docker用户组:

$ sudo usermod -aG docker 用户名

重新登陆后生效

 

Docker服务支持多种启动参数服务默认配置文件在/etc/default/docker可以通过修改其中DOCKER_OPTS来修改服务启动的参数，下一行代码让Docker服务可以通过本地2375端口接收来自外部的请求:

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

修改之后重启Docker服务

$ sudo service docker restart

查看ocker日志

$ sudo tail /var/log/upstart/docker.log

查看docker版本信息

$ docker version

 

运行交互式的容器

我们通过docker的两个参数 -i -t，让docker运行的容器实现"对话"的能力

 

runoob@runoob:~$ docker run -i -t ubuntu:15.10 /bin/bash root@dc0050c79503:/#

 

各个参数解析：

• -t:在新容器内指定一个伪终端或终端。
• -i:允许你对容器内的标准输入 (STDIN) 进行交互。

 

 

启动容器（后台模式）

使用以下命令创建一个以进程方式运行的容器

 

runoob@runoob:~$ docker run -d ubuntu:15.10 /bin/sh -c "while true; do echo hello world; sleep 1; done" 2b1b7a428627c51ab8810d541d759f072b4fc75487eed05812646b8534a2fe63

 

在容器内使用docker logs命令，查看容器内的标准输出

runoob@runoob:~$ docker logs 2b1b7a428627

 

runoob@runoob:~$ docker logs amazing_cori

 

停止容器

我们使用 docker stop 命令来停止容器:

 

通过docker ps查看，容器已经停止工作:

runoob@runoob:~$ docker ps

 

也可以用下面的命令来停止:

runoob@runoob:~$ docker stop amazing_corisuofang

 

docker pull 系统NAME:版本

如果不制定版本号下载最新版系统==ubuntu:latest

 

docker system df 显示docker磁盘使用情况

docker system events 从服务器获取实时事件

docker system info 显示系统范围的信息

docker system prune 删除未使用的数据

docker container prune 删除所有已停止的容器

 

 

3.1获取镜像

标准格式为

docker pull 系统仓库地址/系统名:版本号(如果不指定仓库地址默认会使用DockerHub)

docker pull registry.hub.docker.com/ubuntu:14.04

-a, --all-tags 下载所有符合给定tag的镜像

# pull命令的子命令-a,--all-tags=true|false是否获取仓库中的所有镜像，默认为否

 

执行docker中的系统终端

docker run -it ubuntu:14.04 bash

 

3.2 查看镜像信息

docker images

# images子命令: 等价于 image ls

# 该命令可以模糊查询docker images ubu*:版本号, 如果只有一个同名镜像可以省略版本号

-a, --all=true|false 列出所有的镜像文件

-q, --quiet 只显示镜像ID

--digests=true|false 列出镜像的数字摘要值,默认为否

-f, --filter=[] 过滤列出的镜像，如dangling=true 只显示没有被使用的镜像；也可以指定带有特定标注的镜像等

--format="TEMPLATE" 控制输出格式，如.ID代表ID信息，.Repository代表仓库信息等

--no-trunc=true|false 对输出结果中太长的部分是否进行截断，如果镜像的ID信息，默认为是；

man docker-images查看

 

2.使用tag命令添加镜像标签

docker tag ubuntu:latest myubuntu:latest

# 再次使用docker images查看,之后可以直接使用myubuntu:latest来表示这个镜像了

 

3.使用inspect命令查看详细信息

使用docker inspect命令可以查看该镜像相信信息，包括制作者、适应架构、各层数字摘要等

$docker inspect ubuntu:14.04

 

4.使用history命令查看镜像历史

$docker history ubuntu:14.04

-H, --human 将创建时间、大小进行优化打印(默认为true)

-q, --quiet 只显示镜像ID

# 注意过长的命令被自动截断了，可以使用--no-trunc选项来输出完整命令

 

3.3搜寻镜像

docker search搜索远端仓库中的共享镜像，用法为docker search TERM

--automated=true|false :仅显示自动创建的镜像，默认为否；

--no-trunc=true|false :输出信息不截断显示，默认为否；

-s, --stars=X :指定仅显示评价为指定星级以上的镜像，默认为0,即输出所有镜像

-f, --filter filter 根据提供的格式筛选结果

--format string 利用Go语言的format格式化输出结果

--limit int 展示最大的结果数，默认25个

# docker search -f is-official=true centos 查找出所有centos的官方镜像,格式固定

 

3.4删除镜像

1.使用标签删除镜像

使用docker rmi myubuntu:latest 等价于 docker image rm 镜像:版本

或者docker rmi 镜像id:版本 # 如果使用这种方法会删除所有相关tag

-f 强制删除

# 当镜像只剩下一个标签时此时在删除标签就会删除镜像文件所有层

 

2.使用镜像ID删除镜像

如果容器中的镜像正在运行，将无法删除

$ docker run ubuntu:14.04 echo 'hello! I am here'

$ docker ps -a

$ docker rmi ubuntu:140.04

# 如果想强行删除可以加参数-f

$ docker rmi -f ubuntu:14.04

 

3.5创建镜像

1.基于已有镜像的容器创建

使用docker commit [options]命令

-a, --author=""：作者信息

-c, --change=[]：提交的时候执行Dockerfile指定，包括CMB|ENTRYPOINT|ENV|EXPOSE|LABEL|ONBUILD|

|VOLUME|WORKDIR等；

-m, --message=""：提交消息；

-p, --pause=true：提交时暂定容器运行

 

2.基于本地模板导入

# 该方法会抹去父级镜像信息

命令格式为docker import [options] file |url|-[repository[:tag]]

-c, --change list 为创建的镜像加入Dockerfile命令

-m, --message string 导入时，添加提交信息

openvz下载地址http://openvz.org/Download/templates/precreated

$ cat ubuntu-14.04-x86_64-minimal.tar.gz | docker import - ubuntu:14.04

 

3.6存出和载入镜像

1.保存镜像docker save

# 可以保存多个镜像docker save 镜像1:版本 镜像id 镜像3:版本 > 文件中.tar

# 如果保存镜像id镜像名和版本号会丢失

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

2.载入镜像docker load

$ docker load --input(或者i) ubuntu_14.04.tar 或 docker load < ubuntu_14.04.tar

3.上传镜像docker push

命令格式：docker push name[:tag] | [registry_host[:registry_port]/name[:tag]]

$ docker tag test:latest user/test:latest

$ docker push user/test:latest

# 用户在Docker Hub网站注册后可以上传自制的镜像，可以先给镜像添加标签，在将标签对应的镜像上传

# 第一个上传时，会提示输入登录信息或进行注册

 

4.1创建容器

1.新建容器docker create

$ docker create -it ubuntu:latest

$ docker ps -a

# 使用create命令新建的容器出去停止状态，可以用docker start命令启动

 

名字，简写	默认	描述
--add-host		添加自定义的主机到IP映射（主机：IP）
--attach , -a		附加到STDIN，STDOUT或STDERR
--blkio-weight		阻止IO（相对权重），介于10和1000之间，或0禁用（默认值为0）
--blkio-weight-device		块IO重量（相对设备重量）
--cap-add		添加Linux功能
--cap-drop		删除Linux功能
--cgroup-parent		容器的可选父cgroup
--cidfile		将容器ID写入文件
--cpu-count		CPU数量（仅限Windows）
--cpu-percent		CPU百分比（仅限Windows）
--cpu-period		限制CPU CFS（完全公平调度程序）期间
--cpu-quota		限制CPU CFS（完全公平调度程序）配额
--cpu-rt-period		API 1.25+ 以微秒为单位限制CPU实时周期
--cpu-rt-runtime		API 1.25+ 以微秒为单位限制CPU实时运行时间
--cpu-shares , -c		CPU份额（相对重量）
--cpus		API 1.25+ CPU数量
--cpuset-cpus		允许执行的CPU（0-3,0,1）
--cpuset-mems		允许执行的MEM（0-3,0,1）
--device		将主机设备添加到容器
--device-cgroup-rule		将规则添加到cgroup允许的设备列表
--device-read-bps		限制设备的读取速率（每秒字节数）
--device-read-iops		限制设备的读取速率（每秒IO）
--device-write-bps		限制写入速率（每秒字节数）到设备
--device-write-iops		限制写入速率（每秒IO）到设备
--disable-content-trust	true	跳过图像验证
--dns		设置自定义DNS服务器
--dns-opt		设置DNS选项
--dns-option		设置DNS选项
--dns-search		设置自定义DNS搜索域
--entrypoint		覆盖图像的默认入口点
--env , -e		设置环境变量
--env-file		读入环境变量文件
--expose		公开一个端口或一系列端口
--group-add		添加其他群组加入
--health-cmd		运行以检查运行状况的命令
--health-interval		运行检查之间的时间（ms | s | m | h）（默认为0）
--health-retries		需要报告不健康的连续失败
--health-start-period		API 1.29+ 在开始健康重试倒数前，容器要初始化的起始时间段（ms | s | m | h）（默认值为0）
--health-timeout		允许一次检查运行的最长时间（ms | s | m | h）（默认值为0）
--help		打印用法
--hostname , -h		容器主机名称
--init		API 1.25+ 在容器中运行一个init，用于转发信号并收集进程
--interactive , -i		即使没有连接，也要保持STDIN打开
--io-maxbandwidth		系统驱动器的最大IO带宽限制（仅限Windows）
--io-maxiops		系统驱动器的最大IOps限制（仅限Windows）
--ip		IPv4地址（例如172.30.100.104）
--ip6		IPv6地址（例如，2001：db8 :: 33）
--ipc		使用IPC模式
--isolation		容器隔离技术
--kernel-memory		内核内存限制
--label , -l		在容器上设置元数据
--label-file		阅读标签的行分隔文件
--link		将链接添加到其他容器
--link-local-ip		Container IPv4 / IPv6链路本地地址
--log-driver		记录容器的驱动程序
--log-opt		日志驱动选项
--mac-address		容器MAC地址（例如，92：d0：c6：0a：29：33）
--memory , -m		内存限制
--memory-reservation		内存软限制
--memory-swap		交换限制等于内存加交换：'-1'以启用无限交换
--memory-swappiness	-1	调整容器内存swappiness（0到100）
--mount		将文件系统挂载附加到容器
--name		为容器分配一个名称
--net		将容器连接到网络
--net-alias		为容器添加网络范围的别名
--network		将容器连接到网络
--network-alias		为容器添加网络范围的别名
--no-healthcheck		禁用任何容器指定的HEALTHCHECK
--oom-kill-disable		禁用OOM杀手
--oom-score-adj		调整主机的OOM首选项（从-1000到1000）
--pid		要使用的PID名称空间
--pids-limit		调整容器匹配限制（无限制地设置-1）
--platform		实验（守护程序）API 1.32+ 如果服务器具有多平台功能，请设置平台
--privileged		给这个容器赋予扩展权限
--publish , -p		将容器的端口发布到主机
--publish-all , -P		将所有暴露的端口发布到随机端口
--read-only		将容器的根文件系统挂载为只读
--restart	no	重新启动策略以在容器退出时应用
--rm		当容器退出时自动移除容器
--runtime		运行时用于此容器
--security-opt		安全选项
--shm-size		/ dev / shm的大小
--stop-signal	SIGTERM	停止容器的信号
--stop-timeout		API 1.25+ 超时（以秒为单位）停止容器
--storage-opt		容器的存储驱动程序选项
--sysctl		Sysctl选项
--tmpfs		挂载一个tmpfs目录
--tty , -t		分配一个伪TTY
--ulimit		Ulimit选项
--user , -u		用户名或UID（格式：<name | uid> [：<group | gid>]）
--userns		要使用的用户名称空间
--uts		UTS命名空间使用
--volume , -v		绑定安装一个卷
--volume-driver		容器的可选卷驱动程序
--volumes-from		从指定容器装载卷
--workdir , -w		容器内的工作目录

 

 

其他比较重要的选项还包括

-l, --label=[]:以键值对方式指定容器的标签信息；

--label-file=[]：从文件中读取标签信息

 

2.启动容器

使用docker start

$ docker start af

-a, --attach 将当前shell的 STDOUT/STDERR 连接到容器上

-i, --interactive 将当前shell的 STDIN连接到容器上

# 如果命令瞬间执行完毕可以添加-a参数查看结果

通过docker ps 命令可以查看一个运行中的容器

 

3.新建并启动容器

使用docker run等价于先执行docker create在执行docker start命令

$ docker run ubuntu /bin/echo 'hello world'

-t, --tty 分配一个伪TTY，也就是分配虚拟终端

-i, --interactive 即使没有连接，也要保持STDIN打开

--name 为容器起名，如果没有指定将会随机产生一个名称

-d, --detach 在后台运行容器并打印出容器ID

--rm 当容器退出运行后，自动删除容器

 

 

4.守护态运行

需要让Docker容器在后台以守护态形式运行。可以加参数-d实现

$ docker run -d ubuntu /bin/sh "while true; do echo hello world;sleep 1;done"

# 要获取容器输出信息，可以使用docker logs命令

$ docker logs ce5

# log只能查看到COMMAND的结果

--details 显示日志的额外信息

-f, --follow 动态跟踪显示日志信息

--since string 只显示某事时间节点之后的

--tail string 显示倒数的行数(默认全部)

-t, --timestamps 显示timestamps时间

--until string 只显示某事时间节点之前的

 

 

4.2终止容器

可以使用docker stop来终止一个运行中的容器。首先向容器发送sigterm信号，等待一段超时时间(默认为10秒)后，在发送sigkill信号来终止容器：

$ docker stop [-t|--time=[=10] [container...]

$ docker stop ce5

# docker kill命令会直接发送sigkill信号来强行终止容器

# -s, --signal string 指定发送给容器的关闭信号 (默认“KILL”信号)

 

4.3 进入容器

1.attach命令

# 使用容器中的主进程

docker attach [--detach-keys[=[]]] [--no-stdin] [--sig-proxy[=true]] container

支持三个主要选项：

--detach-keys=[=[]]：指定退出attach模式的快捷键序列，默认是ctrl-p ctrl-q;

--no-stdin=true|false：是否关闭标准输入，默认是保持打开；

--sig-proxy=treu|false：是否代理收到的系统信号给应用进程，默认为true

$ docker run -itd ubuntu

$ docker ps

$ docker attach NAMES

 

2.exec

# 使用该方法进入输出的内容不会被记录到logs,属于在容器中新开进程

dockeer exec [-d|--detach] [--detach-keys[=[]]] [-i|--interactive] [--privileged] [-t|--tty] [-u|--user[=user]] container command [arg...]

比较重要的参数有：

-i，--interactive=true|false：打开标准输入接受用户输入命令，默认为false；

--privileged=true|false：是否给执行命令以高权限，默认为false；

-t，--tty=true|false：分配伪终端，默认为false；

-u，--user=""：执行命令的用户或ID

$ docker exec -it 用户名或ID /bin/bash

 

3.nsenter工具需要单独安装

 

4.4 删除容器

docker rm命令来删除处于终止或退出状态的容器，命令格式为

docker rm [-f|--force] [-l|--link] [-v|--volumes] container [container...]

主要支持的选项包括：

-f，--force=false：是否强行终止并删除一个运行中的容器；

-l，--link=false：删除容器的连接，但保留容器；

-v，--volumes=false：删除容器挂载的数据卷

$ docker rm NAMEID

# 默认情况下docker rm只能删除处于终止或退出状态的容器，如果要删除运行状态的容器添加-f参数

 

4.5导入和导出容器

1.导出容器

导出容器是指导出一个已经创建的容器到一个文件，不管此时这个容器是否处于运行状态，可以使用docker export 命令格式为：

docker export [-o|--output[=""]] container

# -o可以指定导出的tar文件名

docker export NAMEID > 文件名.tar

 

2.导入容器

导出的文件可以使用docker import命令导入变成镜像，该命令格式为：

docker import [-c|--change[=[]]] [-m|--message[=message]] file|url|-[repository[:tag]]

可以使用-c, --change=[]选项在导入的同时执行对容器进行修改的Dockerfile指定

$ docker import 文件 test/ubuntu:v1.0

-c, --change list 为创建的镜像加入Dockerfile命令

-m, --message string 导入时，添加提交信息

 

Docker有五种网络驱动模式

bridge network 模式（网桥）：默认的网络模式。类似虚拟机的nat模式

host network 模式（主机）：容器与宿主机之间的网络无隔离，即容器直接使用宿主机网络

None network 模式：容器禁用所有网络。

Overlay network 模式（覆盖网络）： 利用VXLAN实现的bridge模式

Macvlan network 模式：容器具备Mac地址，使其显示为网络上的物理设备

 

docker network ls [OPTIONS] 查看已经建立的网络对象

命令参数(OPTIONS)：

-f, --filter filter 过滤条件(如 'driver=bridge’)

--format string 格式化打印结果

--no-trunc 不缩略显示

-q, --quiet 只显示网络对象的ID

注意：

默认情况下，docker安装完成后，会自动创建bridge、host、none三种网络驱动

 

docker network create [OPTIONS] NETWORK 创建新的网络对象

命令参数(OPTIONS)：

-d, --driver string 指定网络的驱动(默认 "bridge")

--subnet strings 指定子网网段(如192.168.0.0/16、172.88.0.0/24)

--ip-range strings 执行容器的IP范围，格式同subnet参数

--gateway strings 子网的IPv4 or IPv6网关，如(192.168.0.1)

注意：

host和none模式网络只能存在一个

docker自带的overlay 网络创建依赖于docker swarm(集群负载均衡)服务

192.168.0.0/16 等于 192.168.0.0~192.168.255.255 192.168.8.0/24

172.88.0.0/24 等于 172.88.0.0~172.88.0.255

 

docker network inspect [OPTIONS] NETWORK [NETWORK...]

或者 docker inspect [OPTIONS] NETWORK [NETWORK...]

查看一个或多个网络的详细信息

命令参数(OPTIONS)：

-f, --format string 根据format输出结果

 

为启动的容器指定网络模式

docker run/create --network NETWORK

默认情况下，docker创建或启动容器时，会默认使用名为bridge的网络

 

将指定容器与指定网络进行连接或者断开连接

docker network connect [OPTIONS] NETWORK CONTAINER

docker network disconnect [OPTIONS] NETWORK CONTAINER

命令参数(OPTIONS)：

-f, --force 强制断开连接(用于disconnect)

 

启动的容器时，为容器进行端口映射

docker run/create -P …

或者 docker run/create –p …

命令参数(OPTIONS)：

-P, --publish-all 将容器内部所有暴露端口进行随机映射

-p, --publish list 手动指定端口映射

注意：

-p [HOST_IP]:[HOST_PORT]:CONTAINER_PORT

如：-p ::80 将容器的80端口随机(端口)映射到宿主机任意IP

-p :8000:6379 将容器的6379端口映射到宿主机任意IP的8000端口

-p 192.168.5.1::3306 将容器的3306端口随机(端口)映射到宿主机的192.168.5.1IP上

 

特殊host 网络模式（Container网络模式）

Container网络模式，其实就是容器共享其他容器的网络。

相当于该容器,，在网络层面上，将其他容器作为“主机”。它们之间的网络没有隔离。

这些容器之间的特性同host模式。

使用方法：

Docker run/create --network container:CONTAINER …

 

Overlay 网络，也称为覆盖网络。

Overlay 网络的实现方式和方案有多种。Docker自身集成了一种，基于VXLAN隧道技术实现。

Overlay 网络主要用于实现跨主机容器之间的通信。

应用场景：需要管理成百上千个跨主机的容器集群的网络时。

 

 

macvlan网络模式，最主要的特征就是他们的通信会直接基于mac地址进行转发。

这时宿主机其实充当一个二层交换机。Docker会维护着一个MAC地址表，当宿主机网络收到一个数据包后，直接根据mac地址找到对应的容器，再把数据交给对应的容器。

容器之间可以直接通过IP互通，通过宿主机上内建的虚拟网络设备（创建macvlan网络时自动创建），但与主机无法直接利用IP互通。

应用场景：由于每个外来的数据包的目的mac地址就是容器的mac地址，这时每个容器对于外面网络来说就相当于一个真实的物理网络设备。因此当需要让容器来的网络看起来是一个真实的物理机时，使用macvlan模式

 

Docker Hub公共镜像

1.登录

docker login命令输入用户名、密码、邮箱来完成注册和登录。注册成功后，本地用户目录的.dockercfg中将保存用户的认证信息

登录成功的用户可以上传个人制造的镜像

2.基本操作

用户无需登录即可通过docker search命令查找官方仓库中的镜像，并利用docker pull命令来将它下载到本地

 

使用第三方的镜像仓库

docker pull index.tenxcloud.com/docker_library/node:latest

 

搭建无认证私有仓库

第一步：在需要搭建仓库的服务器上安装docker。

第二步：在服务器上，从docker hub下载registry仓库

docker pull registry

第三步：在服务器上，启动仓库

docker run -d -ti --restart always\

--name my-registry\

-p 8000:5000\

-v /my-registry/registry:/var/lib/registry\

registry

注意：registry内部对外开放端口是5000。默认情况下，会镜像存放于容器内的/var/lib/registry(官网Dockerfile中查看)目录下，这样如果容器被删除，则存放于容器中的镜像也会丢失。

 

本地利用curl 服务器IP:8000/v2/_catalog 查看当前仓库中的存放的镜像列表。（注意打开8000端口访问）

 

私有仓库--上传、下载镜像

第一步：利用docker tag重命名需要上传的镜像

docker tag IMAGE 服务器IP:端口/IMAGE_NAME

第二步：利用docker push上传刚刚重命名的镜像

docker push 服务器IP:端口/centos

 

注意：

必须重命名为服务器IP:端口/IMAGE_NAME

如果push出现了类似https的错误那么需要往配置文件/etc/docker/daemon.json里添加：”insecure-registries”:[“服务器IP:端口”]

然后重启docker。

 

搭建带认证的私有仓库（一）

在服务器上：

第一步：删除先前创建的无认证的仓库容器

docker rm -f my-registry

第二步：创建存放认证用户名和密码的文件：

mkdir /my-registry/auth -p

第三步：创建密码验证文件。注意将将USERNAME和PASSWORD替换为设置的用户名和密码

docker run --entrypoint htpasswd registry -Bbn USERNAME PASSWORD > /my-registry/auth/htpasswd

第四步：重新启动仓库镜像

docker run -d -p 8000:5000 --restart=always --name docker-registry \

-v /my-registry/registry:/var/lib/registry \

-v /my-registry/auth:/auth \

-e "REGISTRY_AUTH=htpasswd" \

-e "REGISTRY_AUTH_HTPASSWD_REALM=Registry Realm" \

-e "REGISTRY_AUTH_HTPASSWD_PATH=/auth/htpasswd" \

registry

 

带认证的私有仓库 -上传、下载镜像

在本地机器上：

第一步：首先登录到服务器

docker login -u username -p password 47.94.153.230:8000

第二步：然后执行pull或者push命令 第三步：操作完毕后，可以退出登录

docker logout 47.94.153.230:8000

这是如果想查看仓库中已有的镜像，那么需要进行http验证才可以。可以直接借助浏览器访问47.94.153.230:8000/v2/_catalog就可以访问了

 

注意这里：47.94.153.230指服务器IP

 

 

5.3搭建本地私有仓库

1.使用registry镜像创建私有仓库

$ docker run -d -p 5000:5000 registry

这会在自动下载并启动一个registry容器，创建本地私有仓库服务

默认情况下，会将仓库创建在容器的/tmp/registry目录下。可以通过-v参数修改镜像文件存放地点

$ docker run -d -p 5000:5000 -v /opt/data/registry:/tmp/registry registry

此时，在本地将启动一个私有仓库服务，监听端口5000

 

2.管理私有仓库

$ docker images

# 选择一个容器

使用docker tag命令将这个镜像标记为10.0.2.2:5000/test

$ docker tag ubuntu:14.04 10.0.2.2:5000/test

使用docker push上传标记的镜像

$ docker push 10.0.2.2:5000/test

用curl查看仓库10.0.2.2:5000 中的镜像

$ curl http://10.0.2.2:5000/v1/search

$ curl -XGEThttp://192.168.1.8:5000/v2/_catalog

# 修改docker daemon的启动参数，添加如下参数，表示信任这个私有仓库，不进行安全证书检查：

DOCKER_OPTS="--insecure-registry 10.0.2.2:5000"

之后重启docker服务，并从私有仓库中下载镜像到本地

$ sudo service docker restart

$ docker pull 10.0.2.2:5000/test

 

docker 数据管理

6.1数据卷

数据卷存在于宿主机的文件系统中，独立于容器，和容器的生命周期是分离的。

数据卷可以目录也可以是文件，容器可以利用数据卷与宿主机进行数据共享，实现了容器间的数据共享和交换。

容器启动初始化时，如果容器使用的镜像包含了数据，这些数据会拷贝到数据卷中。

容器对数据卷的修改是实时进行的。

数据卷的变化不会影响镜像的更新。数据卷是独立于联合文件系统，镜像是基于联合文件系统。镜像与数据卷之间不会有相互影响。

 

数据卷是一个可供容器使用的特殊目录，他将主机操作系统目录直接映射进容器，类似linux中的mount操作

数据卷的特性：

1、数据卷可以在容器之间共享和重用，容器间传递数据将变得高效方便

2、对数据卷内数据的修改会立马生效，无论是容器内操作还是本地操作

3、对数据卷内的更新不会影响镜像，解耦了应用和数据

4、卷会一直存在，直到没有容器使用，可以安全卸载它

 

Docker挂载容器数据卷的三种方式

bind mounts：将宿主机上的一个文件或目录被挂载到容器上。

volumes：由Docker创建和管理。使用docker volume命令管理

tmpfs mounts：tmpfs 是一种基于内存的临时文件系统。tmpfs mounts 数据不会存储在磁盘上。

 

bind mounts方式挂载数据卷

利用docker run/create的参数为容器挂载数据卷

用法：

方式一： -v, --volume参数

-v 宿主机文件或文件夹路径:容器中的文件或者文件夹路径

方式二：--mount参数

--mount type=bind, src=宿主机文件或文件夹路径, dst=容器中的文件或者文件夹路径

注意：src指定的文件和路径必须提前创建或存在

命令演示：

 

 

volumes方式挂载数据卷

利用docker run/create为容器挂载数据卷

用法：

方式一： -v, --volume参数

-v VOLUME-NAME:容器中的文件或者文件夹路径

方式二：--mount 参数

--mount type=volume, src=VOLUME-NAME, dst=容器中的文件或者文件夹路径

volume对象管理：

docker volume 命令管理volume数据卷对象

docker volume create 创建数据卷对象

docker volume inspect 查看数据卷详细信息

docker volume ls 查看已创建的数据卷对象

docker volume prune 删除未被使用的数据卷对象

docker volume rm 删除一个或多个数据卷对象

 

tmpfs mount方式挂载数据卷

利用docker run/create为容器挂载数据卷

用法：

--mount type=tmpfs, dst=PATH

 

共享其他容器的数据卷-数据卷容器

利用docker run/create 的--volumes-from参数指定数据卷容器

用法：

docker run/create --volumes-from CONTAINER

 

Docker的数据卷更多会是使用volumes方式来进行使用。使用时需注意：

如果挂载一个空的数据卷到容器中的一个非空目录中，那么这个目录下的文件会被复制到数据卷中。

如果挂载一个非空的数据卷到容器中的一个目录中，那么容器中的目录中会显示数据卷中的数据。如果原来容器中的目录中有数据，那么这些原始数据会被隐藏掉。

这两个规则都非常重要，灵活利用第一个规则可以帮助我们初始化数据卷中的内容。掌握第二个规则可以保证挂载数据卷后的数据总是你期望的结果。

 

1.在容器内创建一个数据卷

在使用docker run 命令的时候，使用-v标记可以在容器内创建一个数据卷。多次重复使用-v标记可以创建多个数据卷

使用training/webapp镜像创建一个web容器，并创建一个数据卷挂载到容器的/webapp目录

$ docker run -d -P web -v /webapp training/webapp python app.py

# -P是将容器服务暴露的端口，自动映射到本地主机的临时端口

推荐方式

挂载一个主机目录作为数据卷

$ docker run -d -P --name web -v /src/webapp:/opt/webapp training/webapp python app.py

# docker挂载数据卷默认是读取权限（rw）可以指定ro

$ docker run -d -P --name web -v /src/webapp:/opt/webapp:ro training/webapp python app.py

不推荐

挂在一个本地主机文件作为数据卷

$ docker run -rm -it -v ~/bash_history:/.bash_history ubuntu /bin/bash

 

6.2数据卷容器

在多个容器简直共享数据，只用一个容器卷

$ docker run -it -v /dbdata --name dbdata ubuntu

$ docker run -it --volumes-from dbdata --name db1 ubuntu

$ docker run -it --volumes-from dbdata --name db2 ubuntu

此时，容器db1和db2都挂载同意数据卷相同的/dbdata目录三个容器任何乙方在该目录下的写入，其他容器都可以看到

可以多次使用--volumes-from参数从多个容器挂载多个数据卷。还可以从其他已经挂在了容器卷的容器来挂载数据卷

$ docker run -d --name db3 --volumes-from db1 training/postgree

 

6.3利用容器卷来迁移数据

1.备份

$ docker run --volumes-from dbdata -v $(pwd):/backup --name worker ubuntu tar cvf /backup/backup.tar /dbdata

首先利用ubuntu镜像 创建一个容器worker。使用--volumes-from dbdata参数来让worker容器挂载dbdata容器的数据卷，使用-v $(pwd):/backup 参数来挂在本地的当前目录到worker容器的/backup目录

worker容器启动后，使用tar cvf /back/backup.tar /dbdata命令来将/dbdata下内容备份为容器内的/backup/backup.tar ,即宿主主机当前目录下的backup.tar

2.恢复

$ docker run -v /dbdata --name dbdata2 ubuntu /bin/bash

首先创建一个容器dbdata2，然后创建另一个新的容器，挂载dbdata2的容器，并使用untar解压备份文件到所挂载的容器卷中

$ docker run --volumes-from dbdata2 -v $(pwd):/backup busybox tar xvf /backup/backup.tar

 

端口映射与容器互联

7.1端口映射实现访问容器

1.从外部访问容器应用

在启动容器的时候，如果不能指定对应的参数，在容器外部是无法通过网络来访问容器内的网络应用和服务的。

当容器中运行一些网络应用，要让外部访问这些应用时，可以通过-P或-p参数指定端口映射。当使用-P(大写)标记时，docker会随机映射一个49000~49900的端口到容器开放的网络端口

$ docker run -d -P training/webapp python app.py

$ docker ps -l

$ docker logs -f

# 查看应用的信息

 

2.映射所有接口地址

使用hostport:containerport 格式将本地的5000端口映射到容器的5000端口，可以执行：

$ docker run -d -p 5000:5000 training/webapp python app.py

此时默认会绑定本地所有接口上的所有地址。多次使用-p标记可以绑定多个端口

$ docker run -d -p 5000:5000 -p 3000:80 training/webapp python app.py

 

3.映射到指定地址的指定端口

可以使用ip:hostport:containerport 格式指定映射使用一个特定地址，比如localhost地址127.0.0.1：

$ docker run -d -p 127.0.0.1:5000:5000 training/webapp python app.py

 

4.映射到指定地址的任意端口

使用ip::containerport 绑定localhost的任意端口到容器的5000端口，本地主机会自动分配一个端口：

$ docker run -d -p 127.0.0.1::5000 training/webapp python app.py

还可以使用udp标记来指定udp端口

$ docker run -d -p 127.0.0.1:5000:5000/udp training/webapp python app.py

 

5.查看映射端口配置

使用docker port 命令来查看当前映射的端口配置，也可以查看到绑定的地址:

$ docker port NAMES

 

7.2互联机制实现便捷互访

1.自定义容器命名

使用--name标记可以为容器自定义命名：

$ docker run -d -p --name web training/webapp python app.py

使用docker ps来验证设定的命名：

$ docker ps -l

也可以使用docker inspect来查看容器的名字：

$ docker inspect -f "{{json .Name}}" IDNAME/web

# 容器的名称是唯一的。如果已经命名了一个叫web的容器，当你要再次使用web这个名称的时候，需要先用docker rm来删除之前创建的同名容器

 

2.容器互联

使用--link参数可以让容器之间安全地进行交互

下面先创建一个新的数据库容器

$ docker run -d --name db training/postgres

删除之前创建的web容器：

$ docker rm -f web

然后创建一个新的web容器，并将它连接到db容器

$ docker run -d -P --name web --link db:db training/webapp python app.py

--link参数的格式为--link name:alias,其中name时要连接的容器名，alias是这个连接的别名

使用docker ps来查看容器的连接。

# docker相当于在两个互联的容器之间创建了一个虚拟通道，而且不用映射他们的端口到宿主主机上。

docker通过两种方式为容器公开连接信息：

更新环境变量

更新/etc/hosts文件

查看web容器的环境变量

$ docker run --rm --name web2 --link db:db training/webapp env

查看web的hosts文件

$ docker run -t -i --rm --link db:db training/webapp /bin/bash

cat /etc/hosts

apt-get install -yqq inetutils-ping

ping db

 

使用dockerfile创建镜像

查看官方的Dockerfile：https://github.com/docker-library/docs

 

dockerfile时一个文本格式的配置文件，用户可以使用dockerfile来快速创建自定义的镜像

8.1基本结构

dockerfile分为四部分：基础镜像信息、维护者信息、镜像操作指令和容器启动时执行指令

Dockerfile 命令概述

https://docs.docker.com/engine/reference/builder/#usage

FROM: 指定基础镜像

RUN： 构建镜像过程中需要执行的命令。可以有多条。docker build

CMD：添加启动容器时需要执行的命令。多条只有最后一条生效。可以在启动容器时被覆盖和修改。

ENTRYPOINT：同CMD，但这个一定会被执行，不会被覆盖修改。

：为镜像添加对应的数据。

MLABELAINTAINER：表明镜像的作者。将被遗弃，被LABEL代替。

EXPOSE：设置对外暴露的端口。

ENV：设置执行命令时的环境变量，并且在构建完成后，仍然生效

ARG：设置只在构建过程中使用的环境变量，构建完成后，将消失

ADD：将本地文件或目录拷贝到镜像的文件系统中。能解压特定格式文件，能将URL作为要拷贝的文件

COPY：将本地文件或目录拷贝到镜像的文件系统中。

VOLUME：添加数据卷

USER：指定以哪个用户的名义执行RUN, CMD 和ENTRYPOINT等命令

WORKDIR：设置工作目录

ONBUILD：如果制作的镜像被另一个Dockerfile使用，将在那里被执行Docekrfile命令

STOPSIGNAL：设置容器退出时发出的关闭信号。

HEALTHCHECK：设置容器状态检查。

SHELL：更改执行shell命令的程序。Linux的默认shell是[“/bin/sh”, “-c”]，Windows的是[“cmd”, “/S”, “/C”]。

 

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

From ubutu

 

#维护者信息

MAINTAINER wjy wjy@mail.com

 

#镜像的操作指令

#apt/sourcelist.list

RUN echo "deb http://archive.ubuntu.com/ubuntu/ raring main universe" >> /etc/apt/sources.list

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

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

 

#容器启动时执行指令

CMD /usr/sbin/ngnix

 

第一个例子时在debian:jessie基础镜像基础上安装Nginx环境，从而创建一个新的nginx镜像

FROM debian:jessie

 

MAINTAINER NGINX Docker Maintainers "docker-maint@nginx.com"

 

ENV NGINX_VERSION 1.10.1-1~jessie

 

RUN apt-key adv --keyserver hkp://pgp.mit.edu:80 --recv-keys 573BFD6B3D8FBC641079A6ABABF5BD827BD9BF62 \

&& echo "deb http://nginx.org/packages/debain/ jessie nginx" >> /etc/apt/sources.list \

&& apt-get update \

&& apt-get install --no-install-recommends --no-install-suggests -y \

ca-certificates \

nginx=${NGINX_VERSION} \

nginx-module-xslt \

nginx-module-geoip \

nginx-module-image-filter \

nginx-module-perl \

nginx-module-njs \

gettext-base \

&& rm -rf /var/lib/apt/lists/*

 

# forward request and error logs to docker log collector

RUN ln -sf /dev/stdout /var/log/nginx/access.log \

&& ln -sf /dev/stderr /var/log/nginx/error.log

 

EXPOSE 80 443

 

CMD ["nginx", "-g", "daemon off;"]

 

第二个例子是基于buildpack-deps:jessie-scm基础镜像，安装Golong相关环境，制作一个Go语言的运行环境镜像：

FROM buildpack-deps:jessie-scm

 

# gcc for cgo

RUN apt-get update && apt-get install -y --no-install-recommends \

g++ \

gcc \

libc6-dev \

make \

&& rm -rf /var/lib/apt/lists/*

 

ENV GOLANG_VERSION 1.6.3

ENV GOLANG_DOWNLOAD_URL https://golang.org/dl/go$GOLANG_VERSION.linux-amd64.tar.gz

ENV GOLANG_DOWNLOAD_SHA256 cdde5e08530c0579255d6153b08fdb3b8e47caabbe717bc7bcd7561275a87aeb

 

RUN curl -fsSL "$GOLANG_DOWNLOAD_URL" -o golang.tar.gz \

&& echo "$GOLANG_DOWNLOAD_SHA256 golang.tar.gz" | sha256sum -c - \

&& tar -C /usr/local -xzf golang.tar.gz \

 

ENV GOPATH /go

ENV PATH $GOPATH/bin:/usr/local/go/bin:$PATH

 

RUN mkdir -p "GOPATH/scr" "$GOPATH/bin" && chmod -R 777 "$GOPATH"

WORKDIR $GOPATH

 

COPY go-wrapper /usr/local/bin

 

指令详解

 

FROM

 

功能为指定基础镜像，并且必须是第一条指令。

如果不以任何镜像为基础，那么写法为：FROM scratch。

同时意味着接下来所写的指令将作为镜像的第一层开始

 

语法：

FROM <image>

FROM <image>:<tag>

FROM <image>:<digest> 

三种写法，其中<tag>和<digest> 是可选项，如果没有选择，那么默认值为latest

 

 

RUN

 功能为运行指定的命令

RUN命令有两种格式

1. RUN <command>

2. RUN ["executable", "param1", "param2"]

第一种后边直接跟shell命令

• 在linux操作系统上默认 /bin/sh -c
• 在windows操作系统上默认 cmd /S /C

第二种是类似于函数调用。

可将executable理解成为可执行文件，后面就是两个参数。

 

两种写法比对：

• RUN /bin/bash -c 'source $HOME/.bashrc; echo $HOME
• RUN ["/bin/bash", "-c", "echo hello"]

注意：多行命令不要写多个RUN，原因是Dockerfile中每一个指令都会建立一层.

 多少个RUN就构建了多少层镜像，会造成镜像的臃肿、多层，不仅仅增加了构件部署的时间，还容易出错。

RUN书写时的换行符是\

 

 

CMD

 

功能为容器启动时要运行的命令

语法有三种写法

1. CMD ["executable","param1","param2"]

2. CMD ["param1","param2"]

3. CMD command param1 param2

第三种比较好理解了，就时shell这种执行方式和写法

第一种和第二种其实都是可执行文件加上参数的形式

 

举例说明两种写法：

• CMD [ "sh", "-c", "echo $HOME"
• CMD [ "echo", "$HOME" ]

补充细节：这里边包括参数的一定要用双引号，就是",不能是单引号。千万不能写成单引号。

原因是参数传递后，docker解析的是一个JSON array

 

RUN & CMD

不要把RUN和CMD搞混了。

RUN是构件容器时就运行的命令以及提交运行结果

CMD是容器启动时执行的命令，在构件时并不运行，构件时紧紧指定了这个命令到底是个什么样子

 

 

LABEL

功能是为镜像指定标签

 

语法：

LABEL <key>=<value> <key>=<value> <key>=<value> ...

 一个Dockerfile种可以有多个LABEL，如下：

LABEL "com.example.vendor"="ACME Incorporated"

LABEL com.example.label-with-value="foo"

LABEL version="1.0"

LABEL description="This text illustrates \

that label-values can span multiple lines."

 但是并不建议这样写，最好就写成一行，如太长需要换行的话则使用\符号

如下：

LABEL multi.label1="value1" \

multi.label2="value2" \

other="value3"

 

说明：LABEL会继承基础镜像种的LABEL，如遇到key相同，则值覆盖

 

 

MAINTAINER

指定作者

语法：

MAINTAINER <name>

 

 

EXPOSE

功能为暴漏容器运行时的监听端口给外部

但是EXPOSE并不会使容器访问主机的端口

如果想使得容器与主机的端口有映射关系，必须在容器启动的时候加上 -P参数

 

 

ENV

功能为设置环境变量

语法有两种

1. ENV <key> <value>

2. ENV <key>=<value> ...

两者的区别就是第一种是一次设置一个，第二种是一次设置多个

 

 

ADD

 一个复制命令，把文件复制到景象中。

如果把虚拟机与容器想象成两台linux服务器的话，那么这个命令就类似于scp，只是scp需要加用户名和密码的权限验证，而ADD不用。

 

语法如下：

1. ADD <src>... <dest>

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

 

<dest>路径的填写可以是容器内的绝对路径，也可以是相对于工作目录的相对路径

<src>可以是一个本地文件或者是一个本地压缩文件，还可以是一个url

 

如果把<src>写成一个url，那么ADD就类似于wget命令

 

如以下写法都是可以的：

• ADD test relativeDir/ 
• ADD test /relativeDir
• ADD http://example.com/foobar /

尽量不要把<scr>写成一个文件夹，如果<src>是一个文件夹了，复制整个目录的内容,包括文件系统元数据

 

COPY

看这个名字就知道，又是一个复制命令

语法如下：

1. COPY <src>... <dest>

2. COPY ["<src>",... "<dest>"]

与ADD的区别

COPY的<src>只能是本地文件，其他用法一致

 

 

ENTRYPOINT

功能是启动时的默认命令

 

语法如下：

1. ENTRYPOINT ["executable", "param1", "param2"]

2. ENTRYPOINT command param1 param2

 

如果从上到下看到这里的话，那么你应该对这两种语法很熟悉啦。

第二种就是写shell

第一种就是可执行文件加参数

 

与CMD比较说明（这俩命令太像了，而且还可以配合使用）：

1. 相同点：

• 只能写一条，如果写了多条，那么只有最后一条生效
• 容器启动时才运行，运行时机相同

 

2. 不同点：

•  ENTRYPOINT不会被运行的command覆盖，而CMD则会被覆盖
•  如果我们在Dockerfile种同时写了ENTRYPOINT和CMD，并且CMD指令不是一个完整的可执行命令，那么CMD指定的内容将会作为ENTRYPOINT的参数

如下：

FROM ubuntu

ENTRYPOINT ["top", "-b"]

CMD ["-c"]

• 如果我们在Dockerfile种同时写了ENTRYPOINT和CMD，并且CMD是一个完整的指令，那么它们两个会互相覆盖，谁在最后谁生效

如下：

FROM ubuntu

ENTRYPOINT ["top", "-b"]

CMD ls -al

那么将执行ls -al ,top -b不会执行。

 

Docker官方使用一张表格来展示了ENTRYPOINT 和CMD不同组合的执行情况

（下方表格来自docker官网）

 

 

 

VOLUME

 

可实现挂载功能，可以将内地文件夹或者其他容器种得文件夹挂在到这个容器种

 

语法为：

VOLUME ["/data"]

    

说明：

   ["/data"]可以是一个JsonArray ，也可以是多个值。所以如下几种写法都是正确的

VOLUME ["/var/log/"]

VOLUME /var/log

VOLUME /var/log /var/db

一般的使用场景为需要持久化存储数据时

容器使用的是AUFS，这种文件系统不能持久化数据，当容器关闭后，所有的更改都会丢失。

所以当数据需要持久化时用这个命令。

 

 

USER

 

设置启动容器的用户，可以是用户名或UID，所以，只有下面的两种写法是正确的

• USER daemo
• USER UID

注意：如果设置了容器以daemon用户去运行，那么RUN, CMD 和 ENTRYPOINT 都会以这个用户去运行

 

 

WORKDIR

 

语法：

WORKDIR /path/to/workdir

 

设置工作目录，对RUN,CMD,ENTRYPOINT,COPY,ADD生效。如果不存在则会创建，也可以设置多次。

 

如：

WORKDIR /a

WORKDIR b

WORKDIR c

RUN pwd

pwd执行的结果是/a/b/c

 

WORKDIR也可以解析环境变量

如：

ENV DIRPATH /path

WORKDIR $DIRPATH/$DIRNAME

RUN pwd

pwd的执行结果是/path/$DIRNAME

 

ARG

语法：

ARG <name>[=<default value>]

设置变量命令，ARG命令定义了一个变量，在docker build创建镜像的时候，使用 --build-arg <varname>=<value>来指定参数

如果用户在build镜像时指定了一个参数没有定义在Dockerfile种，那么将有一个Warning

提示如下：

[Warning] One or more build-args [foo] were not consumed.

    

我们可以定义一个或多个参数，如下：

FROM busybox

ARG user1

ARG buildno

...

也可以给参数一个默认值：

FROM busybox

ARG user1=someuser

ARG buildno=1

...

如果我们给了ARG定义的参数默认值，那么当build镜像时没有指定参数值，将会使用这个默认值

 

 

ONBUILD

语法：

ONBUILD [INSTRUCTION]

这个命令只对当前镜像的子镜像生效。

比如当前镜像为A，在Dockerfile种添加：

ONBUILD RUN ls -al

这个 ls -al 命令不会在A镜像构建或启动的时候执行

 

此时有一个镜像B是基于A镜像构建的，那么这个ls -al 命令会在B镜像构建的时候被执行。

 

 

STOPSIGNAL

语法：

STOPSIGNAL signal

STOPSIGNAL命令是的作用是当容器推出时给系统发送什么样的指令

 

 

HEALTHCHECK

 容器健康状况检查命令

语法有两种：

1. HEALTHCHECK [OPTIONS] CMD command

2. HEALTHCHECK NONE

第一个的功能是在容器内部运行一个命令来检查容器的健康状况

第二个的功能是在基础镜像中取消健康检查命令

 

[OPTIONS]的选项支持以下三中选项：

    --interval=DURATION 两次检查默认的时间间隔为30秒

    --timeout=DURATION 健康检查命令运行超时时长，默认30秒

    --retries=N 当连续失败指定次数后，则容器被认为是不健康的，状态为unhealthy，默认次数是3

    

注意：

HEALTHCHECK命令只能出现一次，如果出现了多次，只有最后一个生效。

 

CMD后边的命令的返回值决定了本次健康检查是否成功，具体的返回值如下：

0: success - 表示容器是健康的

1: unhealthy - 表示容器已经不能工作了

2: reserved - 保留值

 

例子：

HEALTHCHECK --interval=5m --timeout=3s \

CMD curl -f http://localhost/ || exit 1

  

健康检查命令是：curl -f http://localhost/ || exit 1

两次检查的间隔时间是5秒

命令超时时间为3秒

 

SHELL

SHEELL指令允许默认的shell形式被命令形式覆盖。在Linux系统中默认shell形式为 [“/bin/sh”, “-c”], 在 Windows上是[“cmd”, “/S”, “/C”]。SHELL指令必须用Dockerfile中的JSON格式写入。SHELL指令在Windows上特别有用，其中有两个常用的和完全不同的本机shell：cmd和powershell，以及包括sh的备用shell。 SHELL指令可以出现多次。每个SHELL指令都会覆盖所有以前的SHELL指令，并影响所有后续指令。

 

8.3创建镜像

编写完dockerfile之后可以通过docker build命令来创建镜像

基本格式docker build[选项]内容路径，该命令将读取指定路径下（包括子目录的dockerfile），并将该路径下的所有内容发送到docker服务器，由服务器来创建镜像，因此除非生成需要，否贼一般建议放置dockerfile的目录为空目录。

如果使用非内容路径下的dockerfile，可以通过-f选项来指定其路径

要指定生成镜像的标签信息，可以使用-t选项

 

$ docker build -t 标签名 路径

docker build [OPTIONS] PATH | URL | -

命令参数：

PATH Dockerfile所在路径(文件夹路径)，文件名必须是Dockerfile

URL Dockerfile所在URL地址

OPTIONS:

-t, --tag list 为镜像设置名称和tag

-f, --file string 指定Dockerfile的路径(这是可以使用其他名称命名Dockerfile)

 

8.4使用.dockerignore文件

使用方法类似.gitignore可以忽略匹配目录和文件

 

为镜像添加SSH服务

10.1基于commit命令创建

1.准备工作

$ docker run -it ubuntu:14.04 /bin/bash

2.更新apt缓存，并安装openssh-server

$# apt-get update;apt-get install openssh-server -y

$# mkdir - p /var/runsshd

$# /usr/sbin/sshd -D &

查看容器22端口

$# netstat -tunlp

修改ssh服务的安全登录配置，取消pam登录限制

$# sed -ri 's/session required pam_loginuid.so/#session required pam_loginuid.so/g' /etc/pam.d/sshd

在root用户目录下创建.ssh目录，并复制需要登录的公钥信息(一般为本地主机用户目录下的.ssh/id_rsa.pub文件，可由ssh-keygen -t rsa命令生成)到authorized_keys文件中：

$# mkdir root/.ssh

$# vi /root/.ssh/authorized_keys

创建自动启动ssh服务的可执行文件run.sh,并添加可执行权限

$# vi /run.sh

$# chmod +x run.sh

其中，run.sh脚本内容如下：

#! /bin/bash

/usr/sbin/sshd -D

最后退出容器：

exit

3.保存镜像

将所有退出的容器用docker commit命令保存为一个新的sshd:ubuntu镜像

# 该方法会继承父级镜像信息

$ docker commit fc1 sshd:ubunut

-a, --author string 作者

-c, --change list 为创建的镜像加入Dockerfile命令

-m, --message string 提交信息，类似git commit -m

-p, --pause 提交时暂停容器 (default true)

使用docker images查看本地生成的新镜像sshd:ubuntu

4.使用镜像

启动容器，并添加端口映射10022-->22其中10022是宿主机的端口，22是容器的ssh服务监听端口

$ docker run -p 10022:22 -d sshd:ubuntu /run.sh

在宿主或其他主机上可以通过ssh访问10022端口来登录容器

$ ssh ip -p 10022

 

10.2使用dockerfile创建

1.创建工作目录

创建一个sshd_ubuntu工作目录

在其中创建Dockerfile和run.sh文件

2.编写run.sh脚本和authorized_keys文件

#! bin/bash

/usr/sbin/sshd -D

$ ssh-keygen -t rsa

...

$ cat ~/.ssh/id_rsa.pub > authorized_keys

3.编写dockerfile

# 设置继承镜像

FROM ubuntu:14.04

 

# 提供一些作者的信息

MAINTAINER docker_user (邮箱)

 

# 下面开始运行更新命令

RUN apt-get update

 

# 安装ssh服务

RUN apt-get install -y openssh-server

RUN mkdir -p /var/run/sshd

RUN mkdir -p /root/.ssh

# 取消pam限制

RUN sed -ri 's/session required pam_loginuid.so/# session required pam_loginuid.so/g' /etc/pam.d/sshd

 

# 复制配置文件到相应位置，并赋予脚本可执行权限

ADD authorized_keys /root/.ssh/authorized_keys

ADD run.sh /run.sh

RUN chmod 755 /run

 

# 开放端口

EXPOSE 22

 

# 设置自动启动命令

CMD ["/run.sh"]

 

4.创建镜像

$ cd sshd_ubuntu

#注意：这里有个点

$ docker build -t sshd:dockerfile .

 

5.测试镜像，运行容器

$ docker run -d -p 10122:22 sshd:dockerfile

$ docker ps

$ ssh ip -p 端口

 

 

 

 

 

docker三剑客之docker machine

23.1简介

在指定节点上安装docker引擎，配置其为docker主机

集中管理所有docker主机

23.2安装

推荐从官方release库直接下载编译好的二进制文件即可

23.3 使用Machine

docker machine通过多种后端驱动来管理不同的资源，包括虚拟机、本地主机和云平台等。

通过-d选项可以选择支持的驱动类型

1.虚拟化平台

可以通过virtualbox驱动支持本地(需要已安装virtualbox)启动一个虚拟机并配置为docker主机：

$ docker-machine create --driver=virtualbox vbox-instance

将启动一个全新的虚拟机，并安装docker引擎

2.本地主机

这种驱动适合主机操作系统和ssh服务都已经安装好，需要对其安装docker引擎。

首先确保本地主机可以通过user账号的key直接通过ssh连到目标主机。使用generic类型的驱动，注册一台docker主机，命名为test:

$ docker-machine create -d generic --generic-ip-address=10.0.100.102 --generic-ssh-user=user test

创建成功后可以通过docker-machine ls 命令来查看注册到本地管理列表中的docker主机:

$ docker-machine ls

3.云平台驱动

以Amazon Web Service云平台为例，配置其上的虚拟机为docker主机

需要指定access key id、secret access key、vpc id等信息。例如：

$ docker-machine create --driver amazonec2 --amazonec2-access-key AKI******* --amazonec2-secret-key 8T93C******** --amazonec2-vpc-id vpc-******

 

23.4machine命令

格式

docker-machine <command> -h

docker-machine命令：

help 查看帮助信息

active 查看活动的Docker主机

config 输出连接的配置信息

create 创建一个Docker主机

env 显示连接到某个主机需要的环境变量

inspect 输出主机更新信息

ip 获取Docker主机地址

kill 停止某个Docker主机

ls 列出所有管理的Docker主机

regenerate-certs 为某个主机重新成功TLS认证信息

restart 重启Docker主机

rm 删除Docker主机

scp 在Docker主机之间复制文件

ssh SSH到主机上执行命令

start 启动一个主机

status 查看一个主机状态

stop 停止一个主机

upgrade 更新主机Docker版本为最新

url 获取主机的URL

 

1.active

格式为:docker-machine active [arg...]

查看当前激活状态的docker主机。激活意味着当前DOCKER_HOST环境变量指向该主机。例如：

$ docker-machine ls

$ echo $DOCKER_HOST

$ docker-machine active

 

2.config

格式为：docker-machine config [options] [arg...]

查看到激活docker主机的连接信息。例如：

$ docker-machine config dev

 

3.create

格式为：docker-machine create [options] [arg...]

创建一个docker主机

选项包括：

--driver, -d "none"指定驱动类型；

--engine-install-url "https://get.docker.com" 配置docker主机时候的安装url；

--engine-opt option 以键值对格式指定所创建docker引擎的参数；

--engine-insecure-registry option 以键值对格式指定所创建docker引擎允许访问的不支持认证的注册仓库服务；

--engine-registry-mirror option 指定使用注册仓库镜像；

--engine-label option 为所创建的docker引擎添加标签；

--engine-storage-driver 存储后端驱动类型；

--engine-env option 指定环境变量；

--swarm 指定使用swarm；

--swarm-image "swarm:latest" 使用swarm时候采用的镜像；

--swarm-master 配置机器作为swarm集群的master

--swarm-discovery Swarm集群的服务器发现机制参数；

--swarm-strategy "spread" Swarm默认调度策略；

--swarm-opt option 任意传递给swarm的参数；

--swarm-host "tcp://0.0.0.0:3376" 指定地址将监听swarm master节点请求；

--swarm-addr 从指定地址发送广播加入swarm集群服务。

例如：

$ docker-machine create -d virtualbox \

--engine-storage-driver overlay \

--engine-label name=testmachine \

--engine-label year=2015 \

--engine-opt dns=8.8.8.8 \

--engine-env HTTP_PROXY=http://proxy.com:3128 \

--engine-insecure-registry registry.private.com \

mydockermachine

说明：

使用overlay类型存储驱动；

带有name=testmachine和year=2015两个标签；

引擎采用8.8.8.8作为默认dns；

环境变量中指定http代理服务http://proxy.com:3128；

允许使用不带验证的注册仓库服务 registry.private.com

 

4.env

格式为：docker-machine env [options] [arg...]

例如，显示连接到default主机所需要的环境变量：

$ docker-machine env default

 

5.inspect

格式为：docker-machine inspect [option] [arg...]

以json格式输出指定docker主机的详细信息

例如:

$ docker-machine inspect default

 

6.ip

获取指定docker主机地址

$ docker-machine ip default

 

7.kill

直接杀死指定docker主机

指定docker主机会强行停止

 

8.ls

列出所有管理的主机

格式为：docker-machine ls [option] [arg...]

例如：

$ docker-machine ls

可以通过--filter 来只输出某些docker主机、支持过滤器包括名称正则表达式、驱动类型、swarm管理节点名称、状态等。

例如：

$ docker-machine ls --filter state=stopped

支持选项包括

--quiet, -q 减少无关输出信息；

--filter [--filter option --filter option] 只输出符合过滤条件的主机

 

Docker三剑客之Docker Compose

负责实现对docker容器集群的快速编排。定位是“定义和运行多个docker容器的应用”

compose中有两个重要的概念：

服务（service）：一个应用的容器，实际上可以包括若干运行相同镜像的容器实例。

项目（project）：由一组关联的应用容器组成一个完整业务单元，在docker-compose.yml文件中定义。

 

Docker for Mac与Docker for Windows自带docker-compose

Linux下需要单独安装：

第一步：sudo curl -L https://github.com/docker/compose/releases/download/1.21.2/docker-compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose

第二步：sudo chmod +x /usr/local/bin/docker-compose

终端中使用docker-compose --version查看安装的版本

这里示例安装版本是1.21.2，很可能您看到这里时，已经出现更新的版本，因此建议换成最新版本。

查看最新版本 https://github.com/docker/compose/releases

其他安装方法查看 https://docs.docker.com/compose/install/#install-compose

查看版本说明 https://docs.docker.com/compose/compose-file/

 

compose项目由python编写

24.2安装与卸载

安装compose之前，要先安装docker

compose可以通过python的pip工具进行安装

$ sudo pip install -U docker-compose

安装成功后查看

$ docker-compose -h

 

ELK工作原理介绍

 

 

https://www.elastic.co/guide/index.html

配置单机版的docker-compose.yaml文件（https://www.docker.elastic.co/#）

配置docker-compose https://github.com/deviantony/docker-elk

ELK docker-compose 详解 https://my.oschina.net/xpx/blog/2222072?from=singlemessage&isappinstalled=0

 

https://www.centos.bz/2019/01/docker%E9%83%A8%E7%BD%B2elklogstash%E3%80%81elasticsearch%E3%80%81kibana%EF%BC%8C%E7%9B%91%E6%8E%A7%E6%97%A5%E5%BF%97/

swarm版本

version: '3.6'

services:

elasticsearch:

image: docker.elastic.co/elasticsearch/elasticsearch:6.2.4

environment:

- cluster.name=docker-cluster

- bootstrap.memory_lock=false

- "ES_JAVA_OPTS=-Xms512m -Xmx512m"

volumes:

- esdata1:/usr/share/elasticsearch/data

ports:

- 9200:9200

networks:

- esnet

deploy:

placement:

constraints:

- node.role == manager

elasticsearch2:

image: docker.elastic.co/elasticsearch/elasticsearch:6.2.4

environment:

- cluster.name=docker-cluster

- bootstrap.memory_lock=false

- "ES_JAVA_OPTS=-Xms512m -Xmx512m"

- "discovery.zen.ping.unicast.hosts=elasticsearch"

volumes:

- esdata2:/usr/share/elasticsearch/data

networks:

- esnet

deploy:

placement:

constraints:

- node.role == worker

logstash:

image: docker.elastic.co/logstash/logstash:6.2.4

environment:

- "LS_JAVA_OPTS=-Xms256m -Xmx256m"

networks:

- esnet

deploy:

replicas: 2

logstash2:

image: docker.elastic.co/logstash/logstash:6.2.4

environment:

- "LS_JAVA_OPTS=-Xms256m -Xmx256m"

networks:

- esnet

deploy:

replicas: 2

kibana:

image: docker.elastic.co/kibana/kibana:6.2.4

ports:

- "5601:5601"

networks:

- esnet

deploy:

placement:

constraints:

- node.role == manager

volumes:

esdata1:

driver: local

esdata2:

driver: local

 

networks:

esnet:

driver: "overlay"

 

2.二进制包安装

 

Docker Compose File 顶级配置项：

version：指定Docker Compose File版本号

services：定义多个服务并配置启动参数

volumes：声明或创建在多个服务中共同使用的数据卷对象

networks：定义在多个服务中共同使用的网络对象

configs：声明将在本服务中要使用的一些配置文件

secrets：声明将在本服务中要使用的一些秘钥、密码文件

x-***：自定义配置。主要用于复用相同的配置。

更多详细配置 https://docs.docker.com/compose/compose-file/#service-configuration-reference

 

 

3.容器中执行

$ sudo curl -L https://github.com/docker/compose/releases/download/1.16.1/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose

$ sudo chmod +x /usr/local/bin/docker-compose

 

24.3compose命令说明

格式为：docker-compose [-f=<arg>...] [option] [command] [args...]

命令选项如下：

-f, --file FILE指定使用compose模板文件，默认docker-compose.yml,可以多次指定

-p, --project-name NAME指定项目名称，默认将使用所在目录名称作为项目名

--x-networking 使用docker的可拔插网络后端特性（需要docker1.9及以后版本）

--x-network-driver DRIVER指定网络后端的驱动，默认为brdge（需要docker1.9及以后版本）

--verbose 输出更多调试信息

-v, --version 打印版本并退出

命令目录：

build 构建项目中的服务容器

help 获得一个命令的帮助

kill 通过发送sigkill信号来强制停止服务器

logs 查看服务容器的输出

pause 暂停一个服务容器

port 打印某个容器端口所映射的公共端口

ps 列出项目中目前所有容器

pull 拉取服务器依赖的镜像

restart 重启项目中的服务

rm 删除所有(停止状态的)服务容器

run 在指定服务上执行一个命令

scale 设置指定服务运行的容器个数

start 启动已经存在的服务容器

stop 停止已经处于运行状态的容器，但不删除它

unpause 恢复处于暂停状态中的服务

up 自动完成包括构建镜像、创建服务、启动服务并关联服务相关容器的一系列操作

migrate-to-labels 重新创建容器、并添加label

version 打印版本信息

 

命令使用说明：

docker-compose config查看文件是否语法是否正确

1.build

格式为 docker-compose build [options] [service...]

构建(重新构建)项目中的服务器容器

选项包括：

--force-rm 删除构建过程中的临时容器

--no-cache 构建镜像过程中不使用缓存(这将加长构建过程)

--pull 始终尝试通过拉取操作来获取更新版本的镜像

 

2.help

获得一个命令的帮助

 

3.kill

格式为 docker-compose kill [options] [service...]

支持通过-s参数来制定发送的信号:

$ docker-compose kill -s SIGINT

 

4.logs

格式为 docker-compose logs [options] [service...]

查看服务容器的输出。默认情况下，docker-compose将对不同的服务输出使用不同颜色区分。可以通过--no-color来关闭颜色。

 

5.pause

格式为 docker-compose pause [service...]

暂停一个服务容器

 

6.port

格式为 docker-compose port [options] service private_port

显示某个容器端口所映射的公共端口。

选项：

--protocol=proto 指定端口协议，tcp(默认值)或者udp

--index=index 如果同一服务存在多个容器，指定命令对象容器的序号(默认为1)

 

7.ps

格式为 docker-compose ps [options] [service...]

列出项目中目前的所有容器

选项：

-q 值打印容器的id信息

 

8.pull

格式为 docker-compose pull [options] [service...]

拉取服务依赖的镜像

选项：

--ignore-pull-failures 忽略拉取镜像过程中的错误

 

9.restart

格式为 docker-compose restart [options] [service...]

重启项目中的服务

选项为-t, --timeout TIMEOUT ,指定重启前停止容器的超时(默认为10秒)

 

10.rm

格式为 docker-compose rm [options] [service...]

删除所有(停止状态的)服务容器。推荐先执行docker-compose stop命令来停止容器

选项：

-f, --force 强制直接删除，包括非停止状态的容器。一般尽量不要使用该选项

-v 删除容器所挂载的数据卷

 

11.run

格式为 docker-compose run [options] [-p PORT...] [-e KEY=VAL...] [service [command] [args...]]

指定服务上执行一个命令

例如：

$ docker-compose run ubuntu ping docker.com

将会启动一个ubuntu服务容器，并执行ping docker.com命令。

该命令类似于启动容器后运行指定的命令，相关卷、链接等都将会按照配置自动创建。

注意：

给定命令将会覆盖原有的自动运行命令；

不会自动创建端口，以避免冲突。

如果不希望自动启动关联的容器，可以使用--no-deps选项：

$ docker-compose run --no-deps web python manage.py shell

将不会启动web容器所关联的其他容器。

选项:

-d 在后台运行服务容器

--name NAME 为容器指定一个名字

--entrypoint CMD 覆盖默认的容器启动指令

-e KEY=VAL 设置环境变量值， 可多次使用选项来设置多个环境变量

-u, --user="" 指定运行容器的用户名或者uid

--no-deps 不自动启动关联的服务容器

--rm 运行命令后自动删除容器， d模式下将忽略

-p, --publish=[] 映射容器端口到本地主机

--service-ports 配置服务端口并映射到本地主机

-T 不分配伪 tty，意味着依赖tty的指令将无法运行

 

12.scale

格式为 docker-compose scale [options] [service=num...]

设置指定服务运行的容器个数

通过service=num的参数来设置数量。

例如：

$ docker-compose scale web=3 db=2

将启动3个容器运行web服务，2个容器运行db服务。一般情况下，当指定数目多于该服务当前实际运行容器，将新创建并启动容器；反之，将停止容器。

选项：

-t, --timeout TIMEOUT ，停止容器时候的超时（默认为10秒）

 

13.start

格式为 docker-compose start [service...]

启动已经存在的服务容器

 

14.stop

格式为 docker-compose stop [options] [service...]

停止已经处于运行状态的容器，但不删除它。

选项：

-t, --timeout TIMEOUT ，停止容器时候的超时（默认为10秒）

 

15.unpause

格式为 docker-compose unpause [service...]

恢复处于暂停状态中的服务

 

16.up

格式为 docker-compose up [options] [service...]

该命令十分强大，他将尝试自动完成包括构建镜像，(重新)创建服务，启动服务，并关联服务相关容器的一些列操作。链接的服务都将会被自动启动，除非已经处于运行状态。默认情况，启动的容器都在前台，控制套将会同时打印所有容器的输出信息，可以通过ctrl-c停止命令，所有容器将会停止。如果使用docker-compose up -d 将会在后台启动并运行所有容器。一般推荐生产环境使用该选项。默认情况下如果服务容器已经存在，docker-compose up 将会尝试停止容器，然后重新创建（保持使用volumes-from挂载的卷),以保证新启动的服务匹配docker-compose.yml文件的最新内容。如果不希望容器背挺直重新创建，可以使用docker-compose up --no-recreate,这样将只会启动处于停滞状态的容器。如果只想重新部署某个业务，可以使用docker-compose up --no-deps -d <service_name> 来重新创建服务并后台停止旧服务，启动新服务，并不会影响到其他依赖。

选项:

-d 在后台运行服务容器

--no-color 不适用颜色来区分不同的服务的控制台输出

--no-deps 不启动服务所链接的容器

--force-recreate 强制重新创建容器，不能与--no-recreate同时使用

--no-recreate 如果容器已经存在，则不重新创建，不能与--fore-recreate同时使用

--no-build 不自动构建缺失的服务镜像

-t, --timeout TIMEOUT 停止容器时候的超时(默认为10秒)

 

17.migrate-to-labels

格式为 docker-compose migrate-to-labels

重新创建容器，并添加label

 

18.version

格式为 docker-compose version

打印版本信息

 

24.4 compose 环境变量

环境变量可以用来配置compose的行为，以DOCKER_开头的变量和用来配置docker命令行客户端的使用一样。使用波otdocker,$(boot2dockershellinit)将会设置他们为正确的值

 

COMPOSE_PROJECT_NAME

设置通过 Compose 启动的每一个容器前添加的项目名称，默认是当前工作目录的名字。

COMPOSE_FILE

设置要使用的 docker-compose.yml 的路径。默认路径是当前工作目录。

DOCKER_HOST

设置 Docker daemon 的地址。默认使用 unix:///var/run/docker.sock，与 Docker 客户端采用的默认值一致。

DOCKER_TLS_VERIFY

如果设置不为空，则与 Docker daemon 交互通过 TLS 进行。

DOCKER_CERT_PATH

配置 TLS 通信所需要的验证（ca.pem、cert.pem 和 key.pem）文件的路径，默认是 ~/.docker 。

COMPOSE_HTTP_TIMEOUT

设置超时时间，默认60秒

 

24.5 compose 模板文件

例子：

version: "2"

services:

webapp:

image: examples/web

ports:

- "80:80"

volumes:

- "/data"

注意，每个服务都必须通过image指令指定镜像或build指令(需要dockerfile)等自动构建生成镜像。

如果使用buidl指令，在dockerfile中设置的选项将会被自动获取，无需在docker-compose.yml中再次设置

 

模板文件主要指令：

build 指定服务镜像dockerfile所在路径

cap_add, cap_drop 指定容器的内个能力(capacity)分配

command 覆盖容器启动后默认执行的命令

cgroup_parent 指定父cgroup组，意味着将继承该组的资源限制

container_name 指定容器名称。默认将会使用项目名称_服务名称_序号这样的格式

devices 制定设备映射关系

dns 自定义dns服务器。可以是一个值，也可以是一个列表

dns_search 配置dns搜索域。可以是一个值，也可以是一个列表

dockerfile 指定额外编译镜像的dockerfile文件，可以通过该指令来指定

env_file 从文件中获取环境变量，可以为单独的文件路径或列表

environment 设置环境变量，可以使用数组或字典两种格式

expose 暴露端口

extends 基于其他模板文件进行扩展

external_links 链接到docker-compose.yml 外部的容器，甚至可以是非compose管理的外部容器

extra_hosts 指定额外的host名称映射信息

image 指定为镜像沐橙或者镜像ID。如果镜像在本地不存在，compose将会尝试拉取这个镜像

labels 为容器添加docker元数据(metadata) 信息

links 链接到其他服务中的容器

log_driver 指定日志驱动类型，类似于docker中的--log-driver参数。目前支持三种日志驱动类型：log_driver:"josn-file"、log_driver:"stskig"、log_driver:"none"

log_opt 日志驱动的相关参数

net 设置网络模式。参数类似于docker client的--net参数一样

pid 跟主机系统共享进程命名空间。打开该选项的容器之间，以及容器和宿主机系统之间可以通过进程ID来相互访问和操作

ports 暴露端口信息

security_opt 指定容器模板标签(label)机制的默认属性(如用户、角色、类型、级别等)

ulimits 指定容器的ulimits限制值

volumes 数据卷所挂载路径设置。可以设置宿主机路径(HOST:CONTAINER)或加上访问模式(HOST:CONTAINER:ro)

volumes_driver 较新版本的docker支持数据卷的插件驱动

volumes_from 从另一个服务或容器挂在它的数据卷

 

1.build

指定 Dockerfile 所在文件夹的路径（可以是绝对路径，或者相对 docker-compose.yml 文件的路径）。 Compose 将会利用它自动构建这个镜像，然后使用这个镜像。

build: /path/to/build/dir

 

2.cap_add, cap_drop

指定容器的内核能力分配

例如，让容器拥有所有能力可指定为：

cap_add:

- ALL

去掉NET_ADMIN能力可以指定为:

cap_drop:

- NET_ADMIN

 

3.command

覆盖容器启动后默认执行的命令。

command: echo "hello world"

 

4.cgroup_parent

指定父cgroup组，意味着将继承该组的资源限制

例如：

cgroup_parent: cgroups_1

 

5.container_name

指定容器名称。默认将会使用 项目名称服务名称序号 这样的格式。例如：

container_name: docker-web-container

需要注意，指定容器名称后，该服务将无法进行扩展（scale），因为 Docker 不允许多个容器具有相同的名称。

 

6.devices

指定设备映射关系，例如：

devices:

- "/dev/ttUSB1:/dev/ttyUSB0"

 

7.dns

自定义DNS服务器。可以是一个值，也可以是一个列表，例如：

dns: 8.8.8.8

dns:

- 8.8.8.8

- 9.9.9.9

 

8.dns_search

配置DNS搜索域。可以是一个值，也可以是一个列表，例如：

dns_search: example.com

dns_search:

- domain1.example.com

- domain2.example.com

 

9.dockerfile

如果需要指定额外的编译镜像的 Dockefile 文件，可以通过该指令来指定。例如

dockerfile: Dockerfile-alternate

注意，该指令不能跟 image 同时使用，否则 Compose 将不知道根据哪个指令来生成最终的服务镜像。

 

10.env_file

从文件中获取环境变量，可以为单独的文件路径或列表。

如果通过 docker-compose -f FILE 方式来指定 Compose 模板文件，则 env_file 中变量的路径会基于模板文件路径。

如果有变量名称与 environment 指令冲突，则按照惯例，以后者为准。

env_file: .env env_file: - ./common.env - ./apps/web.env - /opt/secrets.env

环境变量文件中每一行必须符合格式，支持 # 开头的注释行。

# common.env: Set development environment PROG_ENV=development

 

11.environment

设置环境变量。你可以使用数组或字典两种格式。

只给定名称的变量会自动获取运行 Compose 主机上对应变量的值，可以用来防止泄露不必要的数据。例如

environment: RACK_ENV: development SESSION_SECRET:

或者

environment: - RACK_ENV=development - SESSION_SECRET

注意，如果变量名称或者值中用到 true|false，yes|no 等表达布尔含义的词汇，最好放到引号里，避免 YAML 自动解析某些内容为对应的布尔语义。

http://yaml.org/type/bool.html 中给出了这些特定词汇，包括

y|Y|yes|Yes|YES|n|N|no|No|NO |true|True|TRUE|false|False|FALSE |on|On|ON|off|Off|OFF

 

12.expose

暴露端口，但不映射到宿主机，只被连接的服务访问。仅可以指定内部端口为参数

expose: - "3000" - "8000"

 

13.extends

基于其它模板文件进行扩展。例如我们已经有了一个 webapp 服务，定义一个基础模板文件为 common.yml。

# common.yml webapp: build: ./webapp environment: - DEBUG=false - SEND_EMAILS=false

再编写一个新的 development.yml 文件，使用 common.yml 中的 webapp 服务进行扩展。

# development.yml web: extends: file: common.yml service: webapp ports: - "8000:8000" links: - db environment: - DEBUG=true db: image: postgres

后者会自动继承 common.yml 中的 webapp 服务及环境变量定义。

使用 extends 需要注意：

• 要避免出现循环依赖，例如 A 依赖 B，B 依赖 C，C 反过来依赖 A 的情况。
• extends 不会继承 links 和 volumes_from 中定义的容器和数据卷资源。

一般的，推荐在基础模板中只定义一些可以共享的镜像和环境变量，在扩展模板中具体指定应用变量、链接、数据卷等信息。

 

14.external_links

链接到 docker-compose.yml 外部的容器，甚至 并非 Compose 管理的外部容器。参数格式跟 links 类似。

external_links: - redis_1 - project_db_1:mysql - project_db_1:postgresql

 

15.extra_hosts

类似 Docker 中的 –add-host 参数，指定额外的 host 名称映射信息。例如：

extra_hosts: - "googledns:8.8.8.8" - "dockerhub:52.1.157.61"

会在启动后的服务容器中 /etc/hosts 文件中添加如下两条条目。

8.8.8.8 googledns 52.1.157.61 dockerhub

 

16.image

指定为镜像名称或镜像 ID。如果镜像在本地不存在，Compose 将会尝试拉去这个镜像。例如：

image: ubuntu image: orchardup/postgresql image: a4bc65fd

 

17.labels

为容器添加 Docker 元数据（metadata）信息。例如可以为容器添加辅助说明信息。

labels: com.startupteam.description: "webapp for a startup team" com.startupteam.department: "devops department" com.startupteam.release: "rc3 for v1.0"

 

18.links

链接到其它服务中的容器。使用服务名称（同时作为别名）或服务名称：服务别名 （SERVICE:ALIAS） 格式都可以。

links: - db - db:database - redis

使用的别名将会自动在服务容器中的 /etc/hosts 里创建。例如：

172.17.2.186 db 172.17.2.186 database 172.17.2.187 redis

被链接容器中相应的环境变量也将被创建。

 

19.log_driver

类似于docker中的--log-driver参数，指定日志驱动类型。目前支持三种日志驱动类型：

log_driver: "json-file"

log_driver: "syslog"

log_driver: "none"

 

20.log_opt

日志驱动的相关参数。例如：

log_driver: "syslog"

log_opt:

syslog-address: "tcp://192.168.0.42:123"

 

21.net

设置网络模式。参数类似于docker client的--net参数：

net: "bridge"

net: "none"

 

22.pid

跟主机系统共享进程命名空间。打开该选项的容器之间，以及容器和宿主机系统之间可以通过进程 ID 来相互访问和操作。

pid: "host"

 

23.ports

暴露端口信息。使用宿主：容器 （HOST:CONTAINER）格式，或者仅仅指定容器的端口（宿主将会随机选择端口）都可以。

ports: - "3000" - "8000:8000" - "49100:22" - "127.0.0.1:8001:8001"

 

24.security_opt

指定容器模板标签(label)机制的默认属性(用户、角色、类型、级别等)。例如：

security_opt:

- label:user:USER

- label:role:ROLE

 

25.ulimits

指定容器的 ulimits 限制值。

例如，指定最大进程数为 65535，指定文件句柄数为 20000（软限制，应用可以随时修改，不能超过硬限制） 和 40000（系统硬限制，只能 root 用户提高）。

ulimits: nproc: 65535 nofile: soft: 20000 hard: 40000

26.volumes

数据卷所挂载路径设置。可以设置宿主机路径 （HOST:CONTAINER） 或加上访问模式 （HOST:CONTAINER:ro）。

该指令中路径支持相对路径。例如

volumes: - /var/lib/mysql - cache/:/tmp/cache - ~/configs:/etc/configs/:ro

 

27.volumes_driver

新版支持数据卷的插件驱动。可以使用第三方驱动创建一个数据卷，然后使用名称来访问它。例如：

volume_driver: mydriver

 

28.volumes_from

从另一个服务或容器挂载它的数据卷。

volumes_from: - service_name - container_name

 

29.其它指令

此外还有包括 cpu_shares, cpuset, domainname, entrypoint, hostname, ipc, mac_address, mem_limit, memswap_limit, privileged, read_only, restart, stdin_open, tty, user, working_dir 等指令，基本跟 docker-run 中对应参数的功能一致。

例如，指定使用 cpu 核 0 和 核 1，只用 50% 的 CPU 资源：

cpu_shares: 73 cpuset: 0,1

指定服务容器启动后执行的命令: entrypoint: /code/entrypoint.sh；

指定容器中运行应用的用户名： user: nginx；

指定容器中工作目录： working_dir: /code；

指定容器中搜索域名、主机名、mac 地址等：

domainname: your_website.com hostname: test mac_address: 08-00-27-00-0C-0A

指定容器中内存和内存交换区限制都为 1G:

mem_limit: 1g memswap_limit: 1g

允许容器中运行一些特权命令: privileged: true；

指定容器退出后的重启策略为始终重启。该命令对保持服务始终运行十分有效，在生产环境中推荐配置为 always 或者 unless-stopped: restart: always；

以只读模式挂载容器的 root 文件系统，意味着不能对容器内容进行修改:read_only: true；

打开标准输入，可以接受外部输入:stdin_open: true；

模拟一个假的远程控制台：

ttr: true

 

30.读取环境变量

例如：

db:

image: "mongo:$(MONGO_VERSION)"

如果指定MONGO_VERSION=3.0 docker-compose up 则会启动一个mongo:3.2镜像的容器；如果执行MONGO_VERSION=2.2 docker-compose up 则会启动一个mongo:2.8镜像的容器

 

DOCKER三剑客之 DOCKER Swarm

25.1简介

docker官方出的容器集群平台

25.2安装

docker swarm init

 

1.下载镜像

需要在所有被swarm管理的docker主机上下载该镜像

$ docker pull swarm

可以使用命令查看swarm版本。

$ docker run --rm swarm -v

2.配置节点

docker主机在加入swarm集群前，需要进行一些简单的配置，添加docker daemon的网络监听。例如在启动时添加-H参数：

$ docker daemon -H tcp://0.0.0.0:2375 -H unix://var/run/docker.sock

如果通过服务方式启动，则需要修改服务的配置文件/etc/default/docker在文件的最后添加：

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

3.启动集群

docker集群管理需要使用服务发现(service discover)功能，swarm支持以下几种方式：

Docker Hub、本地文件、Etcd、Consul、Zookeeper和手动指定节点IP地址信息等。

本地配置集群推荐使用Consul作为服务发现后端。

(1)启动Consul服务后端

$ docker run -d -p 8500:8500 --name=consul progrium/consul -server -bootstrap

获取到本地主机的地址作为consul的服务地址:<consul_ip>:8500

(2)启动管理阶段

首先启动一个主管理节点，映射到主机的4000端口，并获取所在主机地址为<manager0_ip>.其中4000端口是swarm管理器的默认监听端口，用户也可以指定映射为其他端口：

$ docker run -d -p 4000:4000 swarm manage -H :4000 --replication --advertise <manager0_ip>:4000 consul://<consul_ip>:8500

为提高可用性，也可以启动从管理节点。假定获取所有主机地址为<manager1_ip>:

$ docker run -d swarm manage -H :4000 --replication --advertise <manager1_ip>:4000 consul://

<consul_ip>:8500

由于swarm实际上是通过agent调用了本地的docker daemon来运行容器，当swarm集群服务出现故障时，无法接收新的请求，但已经运行起来的容器将不会受影响。

 

25.3使用swarm

consul也可以替换为Etcd、ZooKeeper等

另外一个更方便的方式是直接使用docker hub提供的免费服务发现后端。以下演示操作包括：

create：创建一个集群；

list：列出集群中的节点；

manage：管理一个集群；

join：让节点加入到某个集群。

注意：docker hub的服务发现后端，需要各个节点能通过公网访问到docker hub的服务接口

 

1.创建集群id

在任意一台安装了swarm的机器上执行swarm create命令来在docker hub服务商进行注册。swarm会通过服务发现后端(此处为docker hub提供)来获取一个唯一的由数字和字母组成的token，用来标识管理的集群：

$ docker run --rm swarm create

注意返回的字符串，这是集群的唯一id，加入集群的各个节点将需要这个信息

 

2.配置集群节点

在所有要加入集群的普通节点上执行swarm join命令，表示把这台机器加入指定集群当中。例如，某台机器的ip地址为192.168.0.2，将其加入我们刚创建的集群，则可以使用如下命令：

$ docker run --rm swarm join --addr=192.168.0.2:2375 token://***************************

其中，addr指定ip地址信息将被发送给服务发现后端，用以区分不同的节点manager服务必须要通过这个地址可以访问到该节点。

通过控制台可以看到，上述命令执行后，默认每隔20秒(可以通过--hearttbeat选项指定)会输出一条心条信息。对于发现服务后端来说，默认如果超过60秒(可以通过--ttl选项指定)没有收到心跳信息，则将节点从列表中删除。

如果不希望看到输出日志信息，则可以用-d选项替换--rm选项，让服务后台执行。

执行swarm join命令实际上是通过agent把自己的信息注册到发现服务上，因此，此时对于后端的发现服务来说，已经可以看到有若干节点注册上来了。那么，如何管理和使用这些节点呢？这就需要swarm的manager服务了。

 

3.配置管理节点

配置管理节点需要用到swarm manage命令，该命令将启动manager服务，默认监听到2375端口，所有对集群的管理都可以通过该服务接口进行。

manager服务默认监听的端口跟docker服务监听端口是一样的，这是为了兼容其他基于docker的服务，可以无缝的切换到swarm平台上。

仍然在节点192.168.0.2进行操作。由于采用docker容器形式启动manager服务，本地的2375被docker daemon占用，我们将manager服务监听端口映射到本地一个空闲的12375端口：

$ docker run -d -p 12375:2375 swarm manage token://******************

可以通过docker ps命令来查看启动的swarm manager服务容器:

$ docker ps

 

4.查看集群节点列表

使用swarm list命令查看

$ docker run --rm swarm list token://******************

我们在另外一个节点192.168.0.3上同样适用swarm join命令新加入一个节点：

$ docker run --rm swarm join --addr=192.168.0.3:2375 token://************

再次使用swarm list命令查看

$ docker run --rm swarm list token://*****************

 

5.使用集群服务

所有docker客户端可以继续使用只要指定使用swarm manager服务的监听地址即可。

例如，manager服务监听的地址为192.168.0.2:12375,则可以通过指定-H 192.168.0.2:12375选项来继续使用docker客户端，执行任意docker命令，例如ps、info、run等

在任意节点上使用docker run来启动若干容器，例如：

$ docker -H 192.168.0.2:12375:12375 run -d ubuntu ping 127.0.0.1

使用ps命令查看急群众正在运行的容器

$ docker -H 192.168.0.2:12375 ps

输出结果显示目前急群众正在运行的容器(注意不包括swarm manager服务容器)，可以在不同节点上使用docker ps查看本地容器，会发现这些容器实际上可能运行在集群中的多个节点上(由swarm调度策略进行分配)。使用info查看所有节点信息

$ docker -H 192.168.0.2:12375 info

 

6.使用网络

为了支持跨主机的网络，swarm默认采用了overlay网络类型，实现上通过vxlan来构建联通整个swarm集群的网络

首先在急群众的所有节点上添加配置docker daemon选项：

--cluster-store=<DISCOVERY_HOST:POST> --cluster-advertise=<DOCKER_DAEMON_HOST:POST>

以consul服务为例，可能类似：

--cluster-store=consul://<consul 服务器地址>:8500 --cluster-advertise=192.168.0.3:2375

之后重启docker服务。首先创建一个网络：

$ docker -H 192.168.0.2:12375 network ls

此时，所有添加到这个网络上的容器将自动被分配到集群中的节点上，并且被联通

 

25.4使用其他服务发现后端

swarm目前可以支持多种服务发现后端，这些后端在功能上都是一致的。

使用中可以通过不同的路径来选择特定的服务发现后端机制：

token://<token>：使用docker hub提供的服务，适用于可以访问公网的情况；

file://path/to/file：使用本地文件，需要手动管理；

consul://<ip>/<path>：使用consul服务，私有环境推荐；

etcd://<ip1>,<ip2>/<path>：使用etcd服务，私有环境推荐；

zk://<ip1>,<ip2>/<path>：使用zookeeper服务，私有环境推荐；

[nodes://]<ip1>,<ip2>：手动指定集群中节点的地址，方便进行服务测试。

1.使用文件

使用文件就是将所有属于某个集群的节点的docker daemon信息写入一个文件中，然后让manager从这个文件中直接读取相关信息。

首先在swarm管理节点(129.168.0.2)上新建一个文件，把要加入集群的机器的docker daemon信息写入文件：

$ tee /tmp/cluster_info <<- 'EOF'

然后，本地执行swarm manage命令，并制定服务发现机制为本地文件。注意，因为是容器方式运行manager，需要将本地文件挂在到容器内：

$ docker run -d -p 12375:2375 -v /tmp/cluster_info:/tmp/cluster_info swarm manage file:///tmp/cluster_info

接下来就可以通过使用swarm服务来进行管理了，例如使用info查看所有节点的信息：

$ docker -H 192.168.0.2:12375 info

2.其他发现后端

其他服务发现后端的使用方法也是大同小异，不同之处在于使用swarm命令时指定的路径格式不同。

例如，consul快速部署的命令为：

$ docker run -d -p 8500:8500 --name=consul progrium/consul -server -bootstrap

之后创建swarm的管理服务，指定使用sonsul服务，管理端口监听在本地的4000端口：

$ docker run -d -p 4000:4000 swarm manage -H :4000 --replication --advertise <manager_ip>:4000 consul://<consul_ip>:8500

swarm节点注册时的命令格式类似于：

$ docker join --advertise=<node_ip:2375> consul://<consul_addr>/<optional path prefix>

对于etcd服务后端来说，节点注册时的命令格式类似于

$ swarm join --addr=<node_addr:2375> etcd://<etcd_addr1>,<etch_addr2>/<optional path prefix>

启动管理服务时，格式类似于：

$ swarm manage -H tcp://<manager_ip>:4000 etcd://<etcd_addr1>,<etcd_addr2>/<optional path prefix>

3.地址和端口的范围匹配

对于基于文件和手动指定节点信息联众服务发现后端机制来说，其中地址和端口域可以支持指定一个范围，以一次性指定多个地址。例如：

192.168.0.[2:10]:2375 代表192.168.0.2:2375 ~ 192.168.0.10:2375 一共9个地址；

192.168.0.2:[2:9]375 代表192.168.0.2:2375 ~ 192.168.0.2:9375 一共8个地址。

 

25.5swarm中的调度器

调度器有三种：spread、binpack和random

在执行swarm manage命令启动管理服务的时候，可以通过--strategy参数指定调度策略，默认是spread

三种调度策略的优化目标如下：

spread：如果节点配置相同，选择一个正在运行的容器数量最少的那个节点，即尽量平摊到容器到各个节点；

binpack：跟spread相反，尽可能地把所有的容器放在一台节点上运行，即尽量少用自节点，避免碎片化

random：直接随机分配，不考虑集群中节点的状态，方便进行测试使用

 

1.spread调度策略

在192.168.0.2节点启动管理服务，管理token://********************的集群

$ docker run -d -p 12375:2375 swarm manage --strategy "spreed" token://********************

列出集群中的节点：

$ docker run --rm swarm list token://*******************

此时，两个节点上除了swarm外都没有运行其他容器。启动一个ubuntu容器：

$ docker -H 192.168.0.2:12375 run -d ubuntu:14.04 ping 127.0.0.1

查看它实际上被调度到了192.168.0.3节点(当前节点配置相同时，初始节点随机选择)

再次启动一个ubuntu容器：

$ docker -H 192.168.0.2:12375 run -d ubuntu:14.04 ping 127.0.0.1

查看他的位置，发现被调度到了另一个节点上：192.168.0.2上：

$ docker -H 192.168.0.2:12375 ps

当节点配置不同的时候，spread会更愿意分配到配置较高的节点上

 

2.binpack调度策略

直接启动若干ubuntu容器，并查看他们的位置：

$ docker -H 192.168.0.2:12375 run -d ubuntu:14.04 ping 127.0.0.1

$ docker -H 192.168.0.2:12375 ps

可以看到所有的容器都是分布在同一个节点上(192.168.0.3)上运行的

 

25.6swarm中的过滤器

目前支持五种过滤器：constraint、affinity、port、dependency、health

1.constraint过滤器是绑定到节点的键值对，相当于给节点添加标签。可在启动docker服务的时候指定，例如指定某个节点颜色为red：

$ sudo docker daemon --label color=red -H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock

同样，可以写在docker服务的配置文件里面(以ubuntu 14.04为例)，是/ect/default/docker

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

使用swarm启动容器的时候，采用-e constarint:key=value的形式，可以过滤选择出匹配条件的节点。

例如，我们将192.168.0.2节点打上红色标签，192.168.0.3节点打上绿色标签，然后，分别启动两个容器，指定使用过滤器分别为红色和绿色：

$ docker -H 192.168.0.2:12375 run -d -e constraint:color==red ubuntu:14.04 ping 127.0.0.1

$ docker -H 192.168.0.2:12375 run -d -e onstraint:color==green ubuntu:14.04 ping 127.0.0.1

查看他们将被分配到的指定节点上：

$ docker -H 192.168.0.2:12375 ps

另外，docker内置了一些常见的过滤器，包括node、storagedriver、executiondriver、kernelversion、operatings等。这些值可以通过docker info命令查看

$ docker -H 192.168.0.2:12375 info

 

2.affinity过滤器

affinity过滤器允许用户再启动一个容器的时候，让它分配到某个已有的容器的节点上。

例如，启动一个nginx容器，让他分配到已经运行的某个bunutu容器的节点上。

在constraint过滤器的实例中，我们分别启动了两个ubunutu容器sick_galileo和compassionate_ritchie，分别在Host-2和Host-3shang .

现在启动nginx容器，让他与容器sick_galileo放在一起，都放到Host-2节点上。可以通过-e affinity:container==<name or id>参数来实现：

$ docker -H 192.168.0.2:12375 run -d -e affinity:container==sick_galileo nginx

然后启动一个redis容器，让他与容器compassionate_ritchie放在一起，都放到Host-3节点上：

$ docker -H 192.168.0.2:12375 run -d -e affinity:container==compassionate_ritchie redis

查看所有容器的运行情况：

$ docker -H 192.168.0.2:12375 ps

 

3.其他过滤器的使用方法也是大同小异，例如通过-e affinity:image==<name or id>来选择拥有指定镜像的节点，通过-e affinity:label_name==value来选择拥有指定标签的容器所允许的节点。

此外，当容器端口需要映射到宿主机指定的端口号的时候，swarm也会自动将容器分配到指定宿主机端口可用的节点。

当不同容器之间存在数据卷或链接依赖的时候，swarm会将这些容器分配到同一个节点上。

 

 

rabbitmq的Dockerfile

 

FROM centos:7

MAINTAINER syq 442365450@qq.com

 

RUN yum clean all && yum clean metadata && yum clean dbcache && yum makecache && yum -y update

 

RUN rpm --rebuilddb && yum install -y wget unzip tar

 

RUN rpm -Uvh https://github.com/rabbitmq/erlang-rpm/releases/download/v20.1.7/erlang-20.1.7-1.el7.centos.x86_64.rpm

 

RUN rpm --rebuilddb && yum install -y erlang

 

RUN rpm --import https://www.rabbitmq.com/rabbitmq-release-signing-key.asc

 

RUN rpm --rebuilddb && yum install -y https://github.com/rabbitmq/rabbitmq-server/releases/download/v3.7.0/rabbitmq-server-3.7.0-1.el7.noarch.rpm

 

RUN /usr/sbin/rabbitmq-plugins list <<<'y'

RUN /usr/sbin/rabbitmq-plugins enable --offline rabbitmq_management

 

#CMD /usr/sbin/rabbitmq-server

 

 

docker service

docker service create

Options:

--config config Specify configurations to

expose to the service

--constraint list Placement constraints

--container-label list Container labels

--credential-spec credential-spec Credential spec for managed

service account (Windows only)

-d, --detach Exit immediately instead of

waiting for the service to converge

--dns list Set custom DNS servers

--dns-option list Set DNS options

--dns-search list Set custom DNS search domains

--endpoint-mode string Endpoint mode (vip or dnsrr)

(default "vip")

--entrypoint command Overwrite the default

ENTRYPOINT of the image

-e, --env list Set environment variables

--env-file list Read in a file of environment

variables

--generic-resource list User defined resources

--group list Set one or more supplementary

user groups for the container

--health-cmd string Command to run to check health

--health-interval duration Time between running the check

(ms|s|m|h)

--health-retries int Consecutive failures needed to

report unhealthy

--health-start-period duration Start period for the container

to initialize before counting

retries towards unstable (ms|s|m|h)

--health-timeout duration Maximum time to allow one

check to run (ms|s|m|h)

--host list Set one or more custom

host-to-IP mappings (host:ip)

--hostname string Container hostname

--init Use an init inside each

service container to forward

signals and reap processes

--isolation string Service container isolation mode

-l, --label list Service labels

--limit-cpu decimal Limit CPUs

--limit-memory bytes Limit Memory

--log-driver string Logging driver for service

--log-opt list Logging driver options

--mode string Service mode (replicated or

global) (default "replicated")

--mount mount Attach a filesystem mount to

the service

--name string Service name

--network network Network attachments

--no-healthcheck Disable any

container-specified HEALTHCHECK

--no-resolve-image Do not query the registry to

resolve image digest and

supported platforms

--placement-pref pref Add a placement preference

-p, --publish port Publish a port as a node port

-q, --quiet Suppress progress output

--read-only Mount the container's root

filesystem as read only

--replicas uint Number of tasks

--reserve-cpu decimal Reserve CPUs

--reserve-memory bytes Reserve Memory

--restart-condition string Restart when condition is met

("none"|"on-failure"|"any")

(default "any")

--restart-delay duration Delay between restart attempts

(ns|us|ms|s|m|h) (default 5s)

--restart-max-attempts uint Maximum number of restarts

before giving up

--restart-window duration Window used to evaluate the

restart policy (ns|us|ms|s|m|h)

--rollback-delay duration Delay between task rollbacks

(ns|us|ms|s|m|h) (default 0s)

--rollback-failure-action string Action on rollback failure

("pause"|"continue") (default

"pause")

--rollback-max-failure-ratio float Failure rate to tolerate

during a rollback (default 0)

--rollback-monitor duration Duration after each task

rollback to monitor for

failure (ns|us|ms|s|m|h)

(default 5s)

--rollback-order string Rollback order

("start-first"|"stop-first")

(default "stop-first")

--rollback-parallelism uint Maximum number of tasks rolled

back simultaneously (0 to roll

back all at once) (default 1)

--secret secret Specify secrets to expose to

the service

--stop-grace-period duration Time to wait before force

killing a container

(ns|us|ms|s|m|h) (default 10s)

--stop-signal string Signal to stop the container

-t, --tty Allocate a pseudo-TTY

--update-delay duration Delay between updates

(ns|us|ms|s|m|h) (default 0s)

--update-failure-action string Action on update failure

("pause"|"continue"|"rollback") (default "pause")

--update-max-failure-ratio float Failure rate to tolerate

during an update (default 0)

--update-monitor duration Duration after each task

update to monitor for failure

(ns|us|ms|s|m|h) (default 5s)

--update-order string Update order

("start-first"|"stop-first")

(default "stop-first")

--update-parallelism uint Maximum number of tasks

updated simultaneously (0 to

update all at once) (default 1)

-u, --user string Username or UID (format:

<name|uid>[:<group|gid>])

--with-registry-auth Send registry authentication

details to swarm agents

-w, --workdir string Working directory inside the

container

 

创建一个服务 

docker service create –replicas 5 –name myhelloworld alpine ping docker.com

replicas 参数是指运行实例个数 

name 参数指定服务名称 

alpine 指的是使用的镜像名称 

ping docker.com 指的是容器运行的bash

 

使用docker service ls命令查看创建出来的服务

Options:

-f, --filter filter Filter output based on conditions provided

--format string Pretty-print services using a Go template

-q, --quiet Only display IDs

 

docker service update命令参数：

Options:

--args command Service command args

--config-add config Add or update a config file on a service

--config-rm list Remove a configuration file

--constraint-add list Add or update a placement constraint

--constraint-rm list Remove a constraint

--container-label-add list Add or update a container label

--container-label-rm list Remove a container label by its key

--credential-spec credential-spec Credential spec for managed service account (Windows only)

-d, --detach Exit immediately instead of waiting for the service to converge

--dns-add list Add or update a custom DNS server

--dns-option-add list Add or update a DNS option

--dns-option-rm list Remove a DNS option

--dns-rm list Remove a custom DNS server

--dns-search-add list Add or update a custom DNS search domain

--dns-search-rm list Remove a DNS search domain

--endpoint-mode string Endpoint mode (vip or dnsrr)

--entrypoint command Overwrite the default ENTRYPOINT of the image

--env-add list Add or update an environment variable

--env-rm list Remove an environment variable

--force Force update even if no changes require it

--generic-resource-add list Add a Generic resource

--generic-resource-rm list Remove a Generic resource

--group-add list Add an additional supplementary user group to the container

--group-rm list Remove a previously added supplementary user group from the container

--health-cmd string Command to run to check health

--health-interval duration Time between running the check (ms|s|m|h)

--health-retries int Consecutive failures needed to report unhealthy

--health-start-period duration Start period for the container to initialize before counting retries towards unstable (ms|s|m|h)

--health-timeout duration Maximum time to allow one check to run (ms|s|m|h)

--host-add list Add a custom host-to-IP mapping (host:ip)

--host-rm list Remove a custom host-to-IP mapping (host:ip)

--hostname string Container hostname

--image string Service image tag

--init Use an init inside each service container to forward signals and reap processes

--isolation string Service container isolation mode

--label-add list Add or update a service label

--label-rm list Remove a label by its key

--limit-cpu decimal Limit CPUs

--limit-memory bytes Limit Memory

--log-driver string Logging driver for service

--log-opt list Logging driver options

--mount-add mount Add or update a mount on a service

--mount-rm list Remove a mount by its target path

--network-add network Add a network

--network-rm list Remove a network

--no-healthcheck Disable any container-specified HEALTHCHECK

--no-resolve-image Do not query the registry to resolve image digest and supported platforms

--placement-pref-add pref Add a placement preference

--placement-pref-rm pref Remove a placement preference

--publish-add port Add or update a published port

--publish-rm port Remove a published port by its target port

-q, --quiet Suppress progress output

--read-only Mount the container's root filesystem as read only

--replicas uint Number of tasks

--reserve-cpu decimal Reserve CPUs

--reserve-memory bytes Reserve Memory

--restart-condition string Restart when condition is met ("none"|"on-failure"|"any")

--restart-delay duration Delay between restart attempts (ns|us|ms|s|m|h)

--restart-max-attempts uint Maximum number of restarts before giving up

--restart-window duration Window used to evaluate the restart policy (ns|us|ms|s|m|h)

--rollback Rollback to previous specification

--rollback-delay duration Delay between task rollbacks (ns|us|ms|s|m|h)

--rollback-failure-action string Action on rollback failure ("pause"|"continue")

--rollback-max-failure-ratio float Failure rate to tolerate during a rollback

--rollback-monitor duration Duration after each task rollback to monitor for failure (ns|us|ms|s|m|h)

--rollback-order string Rollback order ("start-first"|"stop-first")

--rollback-parallelism uint Maximum number of tasks rolled back simultaneously (0 to roll back all at once)

--secret-add secret Add or update a secret on a service

--secret-rm list Remove a secret

--stop-grace-period duration Time to wait before force killing a container (ns|us|ms|s|m|h)

--stop-signal string Signal to stop the container

-t, --tty Allocate a pseudo-TTY

--update-delay duration Delay between updates (ns|us|ms|s|m|h)

--update-failure-action string Action on update failure ("pause"|"continue"|"rollback")

--update-max-failure-ratio float Failure rate to tolerate during an update

--update-monitor duration Duration after each task update to monitor for failure (ns|us|ms|s|m|h)

--update-order string Update order ("start-first"|"stop-first")

--update-parallelism uint Maximum number of tasks updated simultaneously (0 to update all at once)

-u, --user string Username or UID (format: <name|uid>[:<group|gid>])

--with-registry-auth Send registry authentication details to swarm agents

-w, --workdir string Working directory inside the container

 

docker service update更新服务： 

docker service update –publish-add 80 my_web

publish-add参数指添加或者更新一个对外端口 

image参数指更新镜像 

hostname 更新或指定容器名称 

force 指强制更新，即使本次更新没有任何改变

 

docker service inspect命令参数：

Options:

-f, --format string Format the output using the given Go template

--pretty Print the information in a human friendly format

 

docker service inspect查看服务详情： 

docker service inspect my_web

Options:

-f, --format string Format the output using the given Go template

--pretty Print the information in a human friendly format

 

docker service ps命令参数：

Options:

-f, --filter filter Filter output based on conditions provided

--format string Pretty-print tasks using a Go template

--no-resolve Do not map IDs to Names

--no-trunc Do not truncate output

-q, --quiet Only display task IDs

 

docker service ps 搜索服务命令： 

docker service ps my_web

Options:

-f, --filter filter Filter output based on conditions provided

--format string Pretty-print tasks using a Go template

--no-resolve Do not map IDs to Names

--no-trunc Do not truncate output

-q, --quiet Only display task IDs

 

docker service rm 删除服务：

docker service ls 列出所有服务：

 

docker service scale 扩展一个或多个服务 

docker service scale webtier_nginx=5

Options:

-d, --detach Exit immediately instead of waiting for the service to converge

 

docker stack

docker stack deploy [OPTIONS] STACK

--bundle-file 【实验阶段】分布式应用程序包文件的路径

-c --compose-file Stack File 路径

--prune 删除不再被引用的服务

--resolve-image always 查询 Registry 以解决​​镜像摘要和支持的平台(“always”、”changed”、”never”)

--with-registry-auth 向 Swarm 代理发送 Registry 认证详细信息

 

docker stack ls

docker stack services [OPTIONS] STACK

docker stack ps [OPTIONS] STACK

docker stack rm STACK [STACK...]

 

 

本txt就工作中用到的常用命令做一个梳理，仅供参考。

docker的使用可暂时分为2部分的内容：基本使用、集群部署

把镜像仓库类比为git,相关命令很相似。

 

一、基本使用

1. 从仓库拉取基础镜像

镜像仓库分为公有和私有。不论是准一还是生产环境，咱们都有各自的私有仓库，即可以从私有、公有仓库拉取镜像，根据个人需求选择镜像。

1.1 从公有仓库拉镜像：

1.1.1 根据关键字搜索镜像

docker search XXX

1.1.2 从仓库拉取镜像到本机

docker pull image-name:tag

1.2 从私有仓库拉取镜像。以生产环境为例

docker pull 10.251.26.11:5000/image-name:tag

1.3 查看本地镜像

docker images

 

2. 制作镜像image

镜像的制作都是基于Dockerfile文件的，Dockerfile实际上就是一个描述性文件，用来描述目标image的。好的Dockerfile应该记录目标image

所具备的所有内容，原则上应该是尽可能把所有内容都写到Dockerfile里。如果不能做到一次性写到位Dockerfile，也不必担心，后期可以在

容器里修改了再commit到镜像上。

 

2.1 下面简要说一下Dockerfile

＃ 表明目标image所基于的基础镜像，必要

FROM image-name:tag

 

# 创建者的基本信息,非必要

MAINTAINER lichunyan (vamlichunyan@foxmail.com)

＃容器要暴露的端口号，根据需求选择是否暴露

EXPOSE 8001

 

# 设置环境变量，比如 ORACLE_HOME 、 JAVA_HOME 、自定义环境变量都可以在此设置。多个环境变量用空格分隔。

ENV A=a B=b C=c

 

＃设置容器的本地时区为上海时区，必需。

RUN cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime

 

＃ 在容器里建目录，根据需要选择

RUN mkdir -p /app && mkdir -p /opt/logs

 

＃ 把当前./go_apps/dockrMain 拷贝到容器的/目录下。 工作中我主要用来把目标容器要跑的项目代码拷贝到容器指定位置

ADD ./go_apps/dockrMain /

＃指定容器里的工作路径，配合下面的CMD使用，CMD所执行的命令，是在在这个工作路径上执行的，非必需。默认是容器根目录／

WORKDIR /app

 

＃容器入口命令，要求该命令是一个阻塞型命令。必要。 原则上，该入口命令是目标容器要运行的服务的启动命令。 以下命令等价于 python XX.py

CMD ["python"，"XX.py"]

 

上述参数基本够平时工作使用了，更多参数请查阅官方文档。

 

2.2 根据Dockerfile制作目标镜像

# -t 用来指定镜像名称的， 后面的 . 不可遗忘，表示使用当前目录下的Dockerfile build镜像，也就意味着你必须在Dockerfile的目录下执行这个命令

docker build -t image-name:tag .

该命令正确执行后会返回一行类似ID的东东，我没搞明白那是啥，貌似不是镜像ID，貌似这个不重要。

然后可以使用docker images 查看你刚刚build成功的镜像。

 

 

3. 容器container启动

在2中我们已经成功build了镜像，接下来就是要使用这个镜像把目标容器跑起来。

容器的启动有很多种方式，我讲一下我工作中用到的3种方式。

3.1 使用docker命令启动;

这种方式最原始，但是也是最能明白容器的启动参数原理的，我会在一些非正式的场合使用这种方式快速启动类似私人测试的容器。

docker run -d -p 8001:9001 --name container-name image-name:tag ＃-d 表示在后台运行容器，-p 8001:9001 表示把宿主机器的8001端口映射到容器的9001端口

更多docker run 的参数请查看官方文档

 

3.2 使用docker-compose命令启动；

这种方式需要docker-compose.yml文件，该文件可以理解为把docker run命令的一些参数文档化，这样下次启动的时候直接使用这个文件就好，不必每次启动都要手动去硬敲一长串的命令。下面简单讲一下该文件

version: '2' ＃文档版本号，貌似必须是2，不然会出错，具体原因我没深究

services:

service1: # 服务名，多个服务只需要增加相应数量节点即可

image: image-name:tag # 也可类似 image: 10.251.26.11:5000/prod-image-zhifu-asyncquerygo:v3 意味着从10.251.26.11:5000拉取镜像prod-image-zhifu-asyncquerygo:v3

restart: always ＃ 始终自动重启

ports:

- 9005:9006 ＃ 宿主机器的9005端口映射到容器的9006端口，可设置多个端口影射

container_name: rc-lichunyan-go ＃容器名称，自定义

volumes: ＃目录挂载

- /opt/logs/rc-lichunyan/go_apps_logs:/opt/logs ＃将宿主机的/opt/logs/rc-lichunyan/go_apps_logs和容器的/opt/logs做影射，即在宿主机的/opt/logs/rc-lichunyan/go_apps_logs目录下看到的是容器的/opt/logs目录下的内容

environment: ＃环境变量，类似Dockerfile里的ENV

- LOG_PREFIX=/opt/logs

 

service2:

...

有了docker-compose.yml咱们就可以使用docker-compose命令启动容器了：

docker-compose up -d ＃ -d 依然表示在后台运行

可以看到，咱们只用了简单的 docker-compose up -d 这句命令就把容器启动起来了，相比于docker run 方式,不仅不需要手工写冗长的参数，

而且还可以一次性启动多个容器，this is fantastic ！save us a lot !

 

3.3 使用docker stack deploy 启动

这种方式就是第二部分集群部署要讲的内容

 

4. 进入容器

容器启动上来后，你可能想进入到容器里作一些操作，使用下面这条命令就可以进入到容器里

docker exec -it container-name /bin/bash

使用exit即可从容器退出到宿主机。

 

5. 容器container提交

这部分非必需，但多数时候却是必需的。如果你在容器内部做了修改，如果希望下次再启动容器的时候，本次做的修改依然有效的话，就必需commit，否则，万一哪天机器宕机，你的容器被迫停止，刚好你没commit，那估计你就要哭了～

docker commit container-name image-name:tag # 容器、镜像名可以用相应的ID替代，commit 到已有镜像时，已有镜像将会被覆盖。

 

6. 提交镜像到仓库

6.1 先tag

docker tag rc-image-rediscluster:v2 10.251.26.11:5000/rc-image-rediscluster:v2

6.2 再push

docker push 10.251.26.11:5000/rc-image-rediscluster:v2

 

7. 其它相关命令

docker ps # 查看当前正在运行的容器

docker ps -a # 查看所有的容器，包括启动失败、停止的容器

docker rm container-name #删除容器，ontainer-name可以使用ontainer-id代替

docker rmi image-name # 删除镜像，image-name可以用image-id代替。 删镜像成功的前提是，用它启动的所有容器都已删除，否则将会失败。

 

二、集群部署

生产环境，按照领导要求，所有服务都需要docker集群化部署的，方便管理。相比于docker-compose可以管理当前宿主机上所有的服务，docker swarm可以统一管理多台负载机器上的所有服务，比docker-compose更强大。

 

1. docker swarm init

docker swarm init --advertise-addr 10.128.112.132:2377

初始化docker swarm，命令正确执行后的内容类型下面内容：

[was@dqapp112132 docker-compose]$ docker swarm init

Swarm initialized: current node (fbhzdzt24c9uih5fqchvwpv14) is now a manager.

To add a worker to this swarm, run the following command:

docker swarm join --token SWMTKN-1-0fviu393dhjftunv8vz6qsctcn34i2tg3mbii5bg8xms2d9y8u-03k73ziio3l8s913nbv0wt02g 10.128.112.132:2377

To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.

 

请将里面的 docker swarm join --token SWMTKN-1-0fviu393dhjftunv8vz6qsctcn34i2tg3mbii5bg8xms2d9y8u-03k73ziio3l8s913nbv0wt02g 10.128.112.132:2377 备份好。请将示例里的IP替换成你宿主机器的IP，端口号不变。

执行完该命令，当前宿主机扮演docker swarm 的manager角色了，它负责统一管理所有node上的容器。

 

2. docker swarm join

node如果要加入到docker swarm集群里，就需要在node机器上使用join命令，比如你可以10.128.112.133机器上使用示例：

docker swarm join --token SWMTKN-1-0fviu393dhjftunv8vz6qsctcn34i2tg3mbii5bg8xms2d9y8u-03k73ziio3l8s913nbv0wt02g 10.128.112.132:2377

那么此时10.128.112.132和10.128.112.133 ,2台机器就在同一个docker swarm下了，其中10.128.112.132是manager，10.128.112.133是node，这意味着，所有管理只需要在manager机器10.128.112.132上执行即可，而node机器10.128.112.133上不需要作任何操作。

示例命令中的token即为步骤1中嘱咐你备份的内容。

更多node均采用该方法join。

 

3. docker node ls

该命令在manager机器上执行，用来查看这个manager的node信息

 

4.docker stack deploy -c docker-compose.yml zhifu

该命令用来发布、启动所有节点上的容器，需要用到docker-compose.yml文件，在该文件里，你配置你的所有服务，可以参考7中示例理解。最后一个参数zhifu自定义，指定你服务的名称，并且最好记住，因为你需要这个参数去rm、ps操作。

增加／减少 node／实例 ，更改配置等操作后，都只需要重新执行一下该命令即可生效，属于热部署，不会影响到正在运行的容器，除非你减少node、实例。

 

5. docker stack ps

该命令跟docker ps具有相同的功能，只不过docker stack ps是用来查看docker swarm下的容器信息

示例： docker stack ps zhifu # 查看zhifu相关的容器信息

 

6. docker stack rm

该命令用来停止响应的swarm服务，

示例：docker stack rm zhifu ＃ 该命令执行后，zhifu的集群就会停止，你使用docker stack ps zhifu 将不会看到任何容器，并且docker ps也不会看到响应的容器信息

 

7. docker-compose.yml 示例

version: '3' ＃必需是3

services:

prod_zhifu_asyncquerygo: ＃ 服务名

image: 10.251.26.11:5000/prod-image-zhifu-asyncquerygo:v3 ＃镜像名，此处直接从仓库拉镜像

restart: always ＃自动重启

deploy:

replicas: 2 ＃实例数量

resources:

limits: ＃限制配置

cpus: "0.3" ＃cpu使用率不能超过0.3

memory: 5000M ＃内存使用率不能超过5000M

restart_policy: ＃重启规则

condition: on-failure ＃ 重启条件：失败

ports:

- 8001:8001 ＃将宿主机8001 端口映射到容器8001端口

container_name: prod-zhifu-asyncquerygo ＃ 容器名称，swarm里这个参数没啥用，因为swarm根本不用这个，而是采用 docker stack deploy -c docker-compose.yml zhifu 命令里的zhifu按照一定的规则给容器命名的

volumes:

- /app/logs/prod-lichunyan/go_apps_logs:/opt/logs

environment:

- LOG_PREFIX=/opt/logs

 

prod_zhifu_osa:

image: 10.251.26.11:5000/prod-image-zhifu-osa:v1

restart: always

deploy:

replicas: 2

resources:

limits:

cpus: "0.2"

memory: 2000M

restart_policy:

condition: on-failure

ports:

- 6101:6101

container_name: prod-zhifu-osa

volumes:

- /app/logs/prod-lichunyan:/opt/logs

environment:

- LOG_PREFIX=/opt/logs

 

prod_zhifu_osr:

image: 10.251.26.11:5000/prod-image-zhifu-osr:v1

restart: always

deploy:

replicas: 2

resources:

limits:

cpus: "0.2"

memory: 2000M

restart_policy:

condition: on-failure

ports:

- 6201:6201

container_name: prod-zhifu-osr

volumes:

- /app/logs/prod-lichunyan:/opt/logs

environment:

- LOG_PREFIX=/opt/logs