Docker三大编排工具：
Docker Compose：是用来组装多容器应用的工具，可以在 Swarm集群中部署分布式应用。
Docker Machine：是支持多平台安装Docker的工具，使用 Docker Machine，可以很方便地在笔记本、云平台及数据中心里安装Docker。
Docker Swarm：是Docker社区原生提供的容器集群管理工具。
Docker Compose
Github地址： https://github.com/docker/compose
简单来讲，Compose是用来定义和运行一个或多个容器应用的工具。使用compaose可以简化容器镜像的建立及容器的运行。
Compose使用python语言开发，非常适合在单机环境里部署一个或多个容器，并自动把多个容器互相关联起来。
Compose 中有两个重要的概念：
服务 (service)：一个应用的容器，实际上可以包括若干运行相同镜像的容器实例。
项目 (project)：由一组关联的应用容器组成的一个完整业务单元，在 docker-compose.yml 文件中定义。
Compose是使用YML文件来定义多容器应用的，它还会用 docker-compose up 命令把完整的应用运行起来。docker-compose up 命令为应用的运行做了所有的准备工作。从本质上讲，Compose把YML文件解析成docker命令的参数，然后调用相应的docker命令行接口，从而把应用以容器化的方式管理起来。它通过解析容器间的依赖关系来顺序启动容器。而容器间的依赖关系则可以通过在 docker-compose.yml文件中使用 links 标记指定。
安装Docker compose:
官方文档
pip安装：
pip install docker-compose
从github安装：
curl -L --fail https://github.com/docker/compose/releases/download/1.17.0/run.sh -o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose
1
2
3
4
5
6
7
卸载：
rm /usr/local/bin/docker-compose # 使用curl安装的
pip uninstall docker-compose # 使用pip卸载
1
2
3
命令说明
docker-compose --help
1
Docker Machine
Github地址： https://github.com/docker/machine/
Docker Machine 是 Docker 官方编排（Orchestration）项目之一，负责在多种平台上快速安装 Docker 环境。
Docker Machine 项目基于 Go 语言实现，目前在 Github 上进行维护。
安装：
curl -L https://github.com/docker/machine/releases/download/v0.13.0/docker-machine-`uname -s`-`uname -m` > /usr/local/bin/docker-machine
chmod +x /usr/local/bin/docker-machine
1
2
3
完成后，查看版本信息：
# docker-machine -v
docker-machine version 0.13.0, build 9ba6da9
1
2
3
为了得到更好的体验，我们可以安装 bash completion script，这样在 bash 能够通过 tab 键补全 docker-mahine 的子命令和参数。
下载方法：
base=https://raw.githubusercontent.com/docker/machine/v0.13.0
for i in docker-machine-prompt.bash docker-machine-wrapper.bash docker-machine.bash
do
sudo wget "$base/contrib/completion/bash/${i}" -P /etc/bash_completion.d
done
1
2
3
4
5
确认版本将其放置到 /etc/bash_completion.d 目录下。
然后在你的bash终端中运行如下命令，告诉你的设置在哪里可以找到docker-machine-prompt.bash你以前下载的文件 。
source /etc/bash_completion.d/docker-machine-prompt.bash
1
要启用docker-machine shell提示符，请添加 $(__docker_machine_ps1)到您的PS1设置中~/.bashrc。
PS1='[\u@\h \W$(__docker_machine_ps1)]\$ '
1
使用：
Docker Machine 支持多种后端驱动，包括虚拟机、本地主机和云平台等
创建本地主机实例：
使用 virtualbox 类型的驱动，创建一台 Docker主机，命名为test
安装VirtualBox：
配置源：
# cat /etc/yum.repos.d/virtualbox.repo
[virtualbox]
name=Oracle Linux / RHEL / CentOS-$releasever / $basearch - VirtualBox
baseurl=http://download.virtualbox.org/virtualbox/rpm/el/$releasever/$basearch
enabled=1
gpgcheck=0
repo_gpgcheck=0
gpgkey=https://www.virtualbox.org/download/oracle_vbox.asc
#安装VirtualBox：
yum search VirtualBox
yum install -y VirtualBox-5.2
/sbin/vboxconfig # 重新加载VirtualBox服务
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
创建主机：
# docker-machine create -d virtualbox test
Running pre-create checks...
Creating machine...
(test) Copying /root/.docker/machine/cache/boot2docker.iso to /root/.docker/machine/machines/test/boot2docker.iso...
(test) Creating VirtualBox VM...
(test) Creating SSH key...
(test) Starting the VM...
(test) Check network to re-create if needed...
(test) Found a new host-only adapter: "vboxnet0"
(test) Waiting for an IP...
Waiting for machine to be running, this may take a few minutes...
Detecting operating system of created instance...
Waiting for SSH to be available...
Detecting the provisioner...
Provisioning with boot2docker...
Copying certs to the local machine directory...
Copying certs to the remote machine...
Setting Docker configuration on the remote daemon...
Checking connection to Docker...
Docker is up and running!
To see how to connect your Docker Client to the Docker Engine running on this virtual machine, run: docker-machine env test
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
也可以在创建时加上如下参数，来配置主机或者主机上的 Docker。
--engine-opt dns=114.114.114.114 #配置 Docker 的默认 DNS
--engine-registry-mirror https://registry.docker-cn.com #配置 Docker 的仓库镜像
--virtualbox-memory 2048 #配置主机内存
--virtualbox-cpu-count 2 #配置主机 CPU
1
2
3
4
更多参数请使用 docker-machine create --driver virtualbox --help 命令查看。
查看主机：
# docker-machine ls
NAME ACTIVE DRIVER STATE URL SWARM DOCKER ERRORS
test - virtualbox Running tcp://192.168.99.100:2376 v18.05.0-ce
1
2
3
创建主机成功后，可以通过 env 命令来让后续操作目标主机：
docker-machine env test
1
可以通过 SSH 登录到主机：
docker-machine ssh test
1
官方支持驱动：
# 通过 -d 选项可以选择支持的驱动类型。
amazonec2
azure
digitalocean
exoscale
generic
google
hyperv
none
openstack
rackspace
softlayer
virtualbox
vmwarevcloudair
vmwarefusion
vmwarevsphere
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
第三方驱动请到 第三方驱动列表 查看
常用操作命令：
active 查看活跃的 Docker 主机
config 输出连接的配置信息
create 创建一个 Docker 主机
env 显示连接到某个主机需要的环境变量
inspect 输出主机更多信息
ip 获取主机地址
kill 停止某个主机
ls 列出所有管理的主机
provision 重新设置一个已存在的主机
regenerate-certs 为某个主机重新生成 TLS 认证信息
restart 重启主机
rm 删除某台主机
ssh SSH 到主机上执行命令
scp 在主机之间复制文件
mount 挂载主机目录到本地
start 启动一个主机
status 查看主机状态
stop 停止一个主机
upgrade 更新主机 Docker 版本为最新
url 获取主机的 URL
version 输出 docker-machine 版本信息
help 输出帮助信息
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
每个命令，又带有不同的参数，可以通过docker-machine COMMAND --help查看。
Docker Swarm
Docker Swarm 是 Docker 官方三剑客项目之一，提供 Docker 容器集群服务，是 Docker 官方对容器云生态进行支持的核心方案。使用它，用户可以将多个 Docker 主机封装为单个大型的虚拟 Docker 主机，快速打造一套容器云平台。
Docker 1.12 Swarm mode 已经内嵌入 Docker 引擎，成为了 docker 子命令 docker swarm。请注意与旧的 Docker Swarm 区分开来。
Swarm mode内置kv存储功能，提供了众多的新特性，比如：具有容错能力的去中心化设计、内置服务发现、负载均衡、路由网格、动态伸缩、滚动更新、安全传输等。使得 Docker 原生的 Swarm 集群具备与 Mesos、Kubernetes 竞争的实力。
基本概念
Swarm 是使用 SwarmKit 构建的 Docker 引擎内置（原生）的集群管理和编排工具。
节点：
运行 Docker 的主机可以主动初始化一个 Swarm 集群或者加入一个已存在的 Swarm 集群，这样这个运行 Docker 的主机就成为一个 Swarm 集群的节点 (node)
节点分为管理 (manager) 节点和工作 (worker) 节点
管理节点：用于 Swarm 集群的管理，docker swarm 命令基本只能在管理节点执行（节点退出集群命令 docker swarm leave 可以在工作节点执行）。一个 Swarm 集群可以有多个管理节点，但只有一个管理节点可以成为 leader，leader 通过 raft 协议实现。
工作节点：是任务执行节点，管理节点将服务 (service) 下发至工作节点执行。管理节点默认也作为工作节点。也可以通过配置让服务只运行在管理节点。
集群中管理节点与工作节点的关系如下所示：
服务和任务：
任务 （Task）是 Swarm 中的最小的调度单位，目前来说就是一个单一的容器。
服务 （Services） 是指一组任务的集合，服务定义了任务的属性。服务有两种模式：
replicated services 按照一定规则在各个工作节点上运行指定个数的任务。
global services 每个工作节点上运行一个任务。
两种模式通过 docker service create 的 --mode 参数指定。
容器、任务、服务的关系如下所示：
swarm：
从 v1.12 开始，集群管理和编排功能已经集成进 Docker Engine。当 Docker Engine 初始化了一个 swarm 或者加入到一个存在的 swarm 时，它就启动了 swarm mode。没启动 swarm mode 时，Docker 执行的是容器命令；运行 swarm mode 后，Docker 增加了编排 service 的能力。
Docker 允许在同一个 Docker 主机上既运行 swarm service，又运行单独的容器。
node：
swarm 中的每个 Docker Engine 都是一个 node，有两种类型的 node：manager 和 worker。
为了向 swarm 中部署应用，我们需要在 manager node 上执行部署命令，manager node 会将部署任务拆解并分配给一个或多个 worker node 完成部署。manager node 负责执行编排和集群管理工作，保持并维护 swarm 处于期望的状态。swarm 中如果有多个 manager node，它们会自动协商并选举出一个 leader 执行编排任务。woker node 接受并执行由 manager node 派发的任务。默认配置下 manager node 同时也是一个 worker node，不过可以将其配置成 manager-only node，让其专职负责编排和集群管理工作。work node 会定期向 manager node 报告自己的状态和它正在执行的任务的状态，这样 manager 就可以维护整个集群的状态。
service：
service 定义了 worker node 上要执行的任务。swarm 的主要编排任务就是保证 service 处于期望的状态下。
举一个 service 的例子：在 swarm 中启动一个 http 服务，使用的镜像是 httpd:latest，副本数为 3。manager node 负责创建这个 service，经过分析知道需要启动 3 个 httpd 容器，根据当前各 worker node 的状态将运行容器的任务分配下去，比如 worker1 上运行两个容器，worker2 上运行一个容器。运行了一段时间，worker2 突然宕机了，manager 监控到这个故障，于是立即在 worker3 上启动了一个新的 httpd 容器。这样就保证了 service 处于期望的三个副本状态。
默认配置下 manager node 也是 worker node，所以 swarm-manager 上也运行了副本。如果不希望在 manager 上运行 service，可以执行如下命令：
docker node update --availability drain master
1
创建swarm集群
Swarm 集群由管理节点和工作节点组成。现在我们来创建一个包含一个管理节点和两个工作节点的最小 Swarm 集群。
初始化集群：
使用Docker Machine创建三个 Docker 主机，并加入到集群中
首先创建一个 Docker 主机作为管理节点：
docker-machine create -d virtualbox manger
1
使用 docker swarm init 在管理节点初始化一个 Swarm 集群
docker-machine ssh manger
docker@manger:~$ docker swarm init --advertise-addr 192.168.99.101
Swarm initialized: current node (fwh0yy8m8bygdxnsl7x1peioj) is now a manager.
To add a worker to this swarm, run the following command:
docker swarm join --token SWMTKN-1-2acj2brip56iee9p4hc7klx3i6ljnpykh5lx6ea3t9xlhounnv-70knqo263hphhse02gxuvja12 192.168.99.101:2377
To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.
docker@manger:~$
1
2
3
4
5
6
7
8
9
10
11
12
13
注意：如果你的 Docker 主机有多个网卡，拥有多个 IP，必须使用 --advertise-addr 指定 IP。
执行 docker swarm init 命令的节点自动成为管理节点。
增加工作节点：
在docker swarm init 完了之后，会提示如何加入新机器到集群，如果当时没有注意到，也可以通过下面的命令来获知 如何加入新机器到集群。
# docker swarm join-token worker [--quiet]
# docker swarm join-token manager [--quiet]
1
2
根据token的不同，我们来区分加入集群的是manager节点还是普通的节点。通过加入–quiet参数可以只输出token，在需要保存token的时候还是十分有用的。
上一步初始化了一个 Swarm 集群，拥有了一个管理节点，下面继续创建两个 Docker 主机作为工作节点，并加入到集群中。
# docker-machine create -d virtualbox worker1
# docker-machine ssh worker1
docker@worker1:~$ docker swarm join --token SWMTKN-1-2acj2brip56iee9p4hc7klx3i6ljnpykh5lx6ea3t9xlhounnv-70knqo263hphhse02gxuvja12 192.168.99.101:2377
This node joined a swarm as a worker.
docker@worker1:~$
# docker-machine create -d virtualbox worker2
# docker-machine ssh worker2
docker@worker2:~$ docker swarm join --token SWMTKN-1-2acj2brip56iee9p4hc7klx3i6ljnpykh5lx6ea3t9xlhounnv-70knqo263hphhse02gxuvja12 192.168.99.101:2377
This node joined a swarm as a worker.
docker@worker2:~$
1
2
3
4
5
6
7
8
9
10
11
12
13
查看集群：
在manager machine上执行 docker node ls 查看有哪些节点加入到swarm集群。
# docker-machine ssh manger
docker@manger:~$ docker node ls
ID HOSTNAME STATUS AVAILABILITY MANAGER STATUS ENGINE VERSION
fwh0yy8m8bygdxnsl7x1peioj * manger Ready Active Leader 18.05.0-ce
0v6te4mspwu1d1b4250fp5rph worker1 Ready Active 18.05.0-ce
mld8rm9z07tveu1iknvws0lr1 worker2 Ready Active 18.05.0-ce
1
2
3
4
5
6
7
部署服务
使用 docker service 命令来管理 Swarm 集群中的服务，该命令只能在管理节点运行。
新建服务：
在上一节创建的 Swarm 集群中运行一个名为 nginx 服务：
docker@manger:~$ docker service create --replicas 3 -p 80:80 --name nginx nginx
khw3av021hlxs3koanq85301j
overall progress: 3 out of 3 tasks
1/3: running [==================================================>]
2/3: running [==================================================>]
3/3: running [==================================================>]
verify: Service converged
docker@manger:~$
1
2
3
4
5
6
7
8
9
使用浏览器，输入任意节点 IP ,即可看到 nginx 默认页面。
查看服务：
使用 docker service ls 来查看当前 Swarm 集群运行的服务。
docker@manger:~$ docker service ls
ID NAME MODE REPLICAS IMAGE PORTS
khw3av021hlx nginx replicated 3/3 nginx:latest *:80->80/tcp
docker@manger:~$
1
2
3
4
5
使用 docker service ps 来查看某个服务的详情。
docker@manger:~$ docker service ps nginx
ID NAME IMAGE NODE DESIRED STATE CURRENT STATE ERROR PORTS
6b900c649xyp nginx.1 nginx:latest worker1 Running Running 5 minutes
n55uhpjdurxs nginx.2 nginx:latest worker2 Running Running 5 minutes ago
l2uiyggbegsf nginx.3 nginx:latest manger Running Running 5 minutes ago
docker@manger:~$
1
2
3
4
5
6
7
使用 docker service logs 来查看某个服务的日志：
docker@manger:~$ docker service logs nginx
1
服务伸缩：
可以使用 docker service scale 对一个服务运行的容器数量进行伸缩
当业务处于高峰期时，我们需要扩展服务运行的容器数量
$ docker service scale nginx=5
1
当业务平稳时，我们需要减少服务运行的容器数量
$ docker service scale nginx=2
1
删除服务:
使用 docker service rm 来从 Swarm 集群移除某个服务。
$ docker service rm nginx
1
使用 compose 文件
管理敏感数据
管理配置信息
更多swarm的资料可以参考：《每天5分钟玩转 Docker 容器技术》Docker Swarm部分
参考链接：
https://blog.csdn.net/wh211212/article/details/78686241
https://yeasy.gitbooks.io/docker_practice/content/swarm/
docker-compose
安装compose
curl -L https://github.com/docker/compose/releases/download/1.21.2/docker-compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose
测试安装
$ docker-compose --version
docker-compose version 1.21.2, build 1719ceb
常用命令
命令:
build Build or rebuild services
bundle Generate a Docker bundle from the Compose file
config Validate and view the Compose file
create Create services
down Stop and remove containers, networks, images, and volumes
events Receive real time events from containers
exec Execute a command in a running container
help Get help on a command
images List images
kill Kill containers
logs View output from containers
pause Pause services
port Print the public port for a port binding
ps List containers
pull Pull service images
push Push service images
restart Restart services
rm Remove stopped containers
run Run a one-off command
scale Set number of containers for a service
start Start services
stop Stop services
top Display the running processes
unpause Unpause services
up Create and start containers
version Show the Docker-Compose version information
https://docs.docker.com/compose/overview/
https://blog.csdn.net/Dante_003/article/details/70160493
docker-machine
简介
docker-machine是安装docker环境的一个工具，可以在一台机器上通过命令控制几台机器安装docker环境，运行docker命令，创建docker swarm集群的工具。
安装
docker-machine和compose有点类似，都是一个可运行的linux二进制文件(下面都是基于linux版本做的)，下载下来这个文件后放到/usr/local/bin里面设置文件权限就可以直接使用了，docker-machine的github地址
https://github.com/docker/machine
curl -L https://github.com/docker/machine/releases/download/v0.10.0/docker-machine-`uname -s`-`uname -m` >/tmp/docker-machine &&
chmod +x /tmp/docker-machine &&
sudo cp /tmp/docker-machine /usr/local/bin/docker-machine
使用
按照docker-machine github上的介绍，它是一个简化Docker安装的命令行工具，通过一个简单的命令行即可在相应的平台上安装Docker，比如VirtualBox、 Digital Ocean、Microsoft Azure。根据他的描述和github上的例子可以看出他可以直接在指定平台上创建机器。
我们这里只测试已经创建好有ip的实体机或者虚拟机。
docker-machine操作各个机器实际上用ssh无密码访问的，如果是在已经配置好ip的实体机或虚拟机上用就要手动或者使用脚本设置无密码访问了。
无密码访问
ssh-keygen #一直回车
ssh-copy-id root@192.168.1.28 #ip为docker-machine要操作的机器，输入密码
##上面结束之后，每台机器上还得安装net-tools,docker-machine会用到netstat命令来检测端口使用情况，如果机器上没有安装会报错。如果你确定那台机器上的端口没问题，即使报错也没问题，最终那台机器还是会加入到docker-machine的管理中。
yum install net-tools
连接机器
docker-machine create -d generic --generic-ip-address=192.168.1.28 node28
node28为给机器的别名
-d generic驱动类型
–generic-ip-address 要控制机器的ip，必须
–generic-engine-port docker-engine的远程访问端口，默认为2376
–generic-ssh-key 远程访问机器的私钥，默认使用.ssh/下面的私钥
–generic-ssh-user 远程访问机器的用户名，默认为root
–generic-ssh-port 远程ssh访问的端口，默认为22
–engine-insecure-registry docker-engine的insecure-registry
–engine-install-url 安装docker-engine的地址，默认为”https://get.docker.com”
–engine-registry-mirror docker-engine镜像的代理地址
上面的命令根据国内环境可以换为下面
docker-machine create \
-d generic \
--generic-ip-address=192.168.1.28 \
--engine-install-url=https://get.daocloud.io/docker/ \
--engine-registry-mirror=http://91c0cc1e.m.daocloud.io \
node28
通过docker-machine连接了各个机器后，就可以通过docker-machine来操作各个机器了，更多命令查看 docker-machine –help
https://docs.docker.com/machine/install-machine/
https://blog.csdn.net/vchy_zhao/article/details/70238472
swarm
简介
swarm从docker1.9版本开始就有了，但功能不完善、性能不稳定，一直不能登入生产环境，从1.12版本内置到了docker-engine中，可以直接使用docker swarm命令来操作swarm。
swarm是docker集群的资源管理工具。简单点理解，在很多台机器上部署docker，组成一个docker集群，并把整个集群的资源抽象成资源池，使用者部署docker应用的时候，只需要将应用交给swarm，swarm会根据整个集群资源的使用情况来分配资源给部署的docker应用，可以将这个集群的资源利用率达到最大。
类似的服务框架还有mesos+marathon，kubernetes。
编者是从很早接触docker的，swarm还没有出来，kubernetes还不成熟没有人在生产环境使用。
①最早使用的是mesos+marathon那一套，优点是基于成熟的资源调度管理框架mesos，缺点是部署起来还是很麻烦的，像服务发现、负载均衡等概念在里面也都有，但都是碎片化以插件的形式存在，整个体系感觉不是很完善、不像一个整体。
②kubernetes从发布1.0版本以后在生产得到了很多实践，开始步入主流压过swarm和mesos+marathon，kubernetes针对docker应用集群的特点，概括出几个对象，pod、service、replication controller，pod为运行的基本单元，service则是专门来服务发现和服务代理的，replication controller 应用的副本做负载均衡。kubernetes就是一个很专业很全面完善的docker集群管理工具。
③swarm在很多方面很像kubernetes，不知道是不是偷偷抄袭的。swarm通过命令就可以很简单的在docker集群中创建应用设置副本数量，内置服务发现代理。swarm+compose≈kubernetes。swarm由于现在内置于docker中，使用部署更简单，功能上和kubernetes很相似，轻量级。
常用命令
swarm init
swarm join
service create
service inspect
service ls
service rm
service scale
service ps
service update
https://docs.docker.com/engine/swarm/#feature-highlights
https://blog.csdn.net/Dante_003/article/details/70171804
---------------------
前言
你是否曾经和我一样，想了解一个新的中间件，如redis、kafka、zookeeper等，发现无论是单点还是集群搭建过程都异常繁琐，甚至占用了一半以上的学习时间？很多中间件都是基于linux系统的，但是你却要在windows上做文章？作为一个后端程序员，我只想学习一下中间件怎么使用，却被这种繁琐的过程限制住了手脚，抑或是半途而废？
正所谓，工欲善其事，必先利其器。Docker可以完美的解决我们以上的痛点，而且安装过程简单。
本文参照Docker官方文档https://docs.docker.com/，基于windows系统，Linux和Mac系统除了安装过程不同之外其余过程均相同。
一、安装Docker
步骤一
下载安装DockerToolBox： https://docs.docker.com/toolbox/overview/
image.png
步骤二
安装成功之后会有三个图标出现，Docker Quickstart基本上不用，常用的是另两个，打开VM更新到最新版本（因为旧版本打开Kitematic的时候容易卡死）
image.png
步骤三
打开Kitematic软件，点击hello-world-nginx的CREATE按钮，创建一个容器，如果能正常跑起来就证明安装成功了。
image.png
二、Docker Machine
经过上面过程我们已经在Windows里面成功安装了docker环境，但本质上Kitematic软件底层利用的是VirtualBox虚拟机和DockerMachine，那么什么是Docker Machine？
1、Docker Machine概念
Docker Machine就是创建Docker环境的机器，简单说就是有了Docker Machine就可以在任何系统任何平台上快速的搭建Docker环境了。
2、利用Docker Machine快速创建Docker环境
创建Docker虚拟机
打开cmd窗口，执行命令 docker-machine create --driver=virtualbox machine1
该命令以virtualbox为介质快速创建一个包含有docker环境的虚拟机。命令执行完成之后打开virtualbox界面如下：
可以看到machine1正在运行，双击进入该虚拟机可以执行docker的所有命令。
你可以利用上面的命令继续创建多个含有Docker Engine的多个虚拟机
image.png
进入Docker虚拟机
打开cmd窗口，执行命令 docker-machine ssh machine1
该命令可以通过cmd窗口进入到machine1环境，因为virtualbox的复制粘贴操作没有cmd窗口那么便捷，所以我一般复制命令的时候都使用cmd窗口ssh进入
其他Docker machine命令
docker-machine start/stop 可以删除容器关闭和不删除容器关闭虚拟机
更多命令请参考 https://docs.docker.com/machine/reference/
三、Docker Compose
1、Dcoker Compose概念
Docker Compose可以有组织的启动同属于一个服务的多个容器
换句话说 当一个服务包含多个容器的时候，docker compose可以通过yaml文件预先配置，然后统一启动
2、Docker Compose安装
三步走：进入machine1、切换root用户、安装及更改compose权限
1.21.1为版本，可以到https://github.com/docker/compose/releases去查看可更换的compose版本
sudo -i
curl -L https://github.com/docker/compose/releases/download/1.21.1/docker-compose-uname -s-uname -m-o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose
3、Compose的使用
以三节点的zookeeper伪集群为例，最重要的就是yaml文件，这个是构建服务的蓝图
首先：随便在哪个目录下创建一个docker-compose.yml文件（注意名称必须为docker-compose），内容如下
然后：进入docker-compose.yml目录，执行docker-compose up -d （-d表示后台运行）结果如图
version: '3.1'
services:
zoo1:
image: zookeeper
restart: always
hostname: zoo1
ports:
- 2181:2181
environment:
ZOO_MY_ID: 1
ZOO_SERVERS: server.1=0.0.0.0:2888:3888 server.2=zoo2:2888:3888 server.3=zoo3:2888:3888
zoo2:
image: zookeeper
restart: always
hostname: zoo2
ports:
- 2182:2181
environment:
ZOO_MY_ID: 2
ZOO_SERVERS: server.1=zoo1:2888:3888 server.2=0.0.0.0:2888:3888 server.3=zoo3:2888:3888
zoo3:
image: zookeeper
restart: always
hostname: zoo3
ports:
- 2183:2181
environment:
ZOO_MY_ID: 3
ZOO_SERVERS: server.1=zoo1:2888:3888 server.2=zoo2:2888:3888 server.3=0.0.0.0:2888:3888
image.png
再次：检查zookeeper伪集群是否安装成功，使用docker ps 查看正在运行的容器，记下ID
然后：通过docker exec -it id /bin/bash进入zookeeper下，进入bin目录，执行zkCli.sh就可以执行zookeeper命令了！
image.png
就这样伪集群瞬间搭建好，跟谁说理去？
4、yml模板说明：
-
version对应compose和Engine版本
image.png
- services对应多个容器
- zoo1/2/3为容器名称
- image表示基于的镜像为zookeeper
- environment表示环境变量
- ports前面的端口号表示容器宿主机的端口号，后面的端口号表示容器的端口号
- 其他顾名思义
4、Compose yml其他语法
https://docs.docker.com/compose/compose-file/
四、Docker Swarm
上面两位剑客完成了Docker环境搭建和容器的编排工作，swarm则用来完成多台机器（可物理可虚拟）之间容器集群的管理，Swarm是docker自带的一种模式，内嵌到docker里，不用额外安装。
1、Swarm中的重要概念
- 节点：NODE，一个节点本质上是一个包含Docker Engine环境的机器，可以是物理机也可以是虚拟机，我们这里可以是自己构建的docker machine。Node分为两种，一种为leader，一种为worker，前者负责分派工作，后者负责执行工作，同一个NODE可以同时有两种角色。
- 服务：Service，运行在节点上包含一个或者多个task的综合体，每个task都由一个容器和容器内部运行的一些命令共同代表。
- 负载均衡：使用内部负载均衡，访问任何节点端口都会通过负载均衡找到服务，即便当前node没有服务
image.png
2、快速搭建一个Swarm集群
步骤一：
打开cmd窗口，使用docker-machine create xxx 创建一个manager环境和两个worker环境，创建完成可以打开virtualbox查看
image.png
步骤二：
在manager节点即图中的machine1节点内，执行命令
docker swarm init --advertise-addr 192.168.99.101 注意后边的IP为当前机器的IP可以通过cmd窗口的docker-machine ip machine1查看。--advertise-addr表示设置mannager
$ docker swarm init --advertise-addr 192.168.99.101
Swarm initialized: current node (bvz81updecsj6wjz393c09vti) is now a manager.
To add a worker to this swarm, run the following command:
docker swarm join \
--token SWMTKN-1-3pu6hszjas19xyp7ghgosyx9k8atbfcr8p2is99znpy26u2lkl-1awxwuwd3z9j1z3puu7rcgdbx \
172.17.0.2:2377
To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.
步骤三：
上一步中其实已经给出了加入swarm的命令了，如果没记住可以在mananger节点执行docker swarm join-token worker 命令查看
docker swarm join --token SWMTKN-1-3pu6hszjas19xyp7ghgosyx9k8atbfcr8p2is99znpy26u2lkl-7p73s1dx5in4tatdymyhg9hu2 192.168.99.101:2377
执行完上述命令后会有成功的提示
在Manager节点执行docker node ls可以查看当前节点
image.png
步骤四：
至此Docker swarm集群搭建完成，该集群包含三个节点，一个Manager和两个worker，Manager本质上也是一个worker，都可以执行任务。
3、在Swarm上操作服务
- 发布：
随便在哪个节点上执行命令
docker service create
--replicas 3
--name redis
--update-delay 10s
redis:3.0.6
就可以发布一个3.0.6版本的Redis了，replicas表示有三个副本，update-delay表示当升级的时候，一个节点升级成功之后的10秒后才升级另一个节点 - 升级：
docker service update --image redis:3.0.7 redis
这个过程是滚动的，即一个接一个升级 - 查看：
docker service inspect --pretty redis
或者docker service ps redis - 删除：
docker service rm redis - 停止/重启节点：
docker node update --availability drain worker1
该命令停止了节点worker1，停止之后不接受新的请求，不接受manager分派
docker node update --availability active worker1
该命令重启了节点，使其恢复active状态 - 指定端口：
docker service create
--name my-web
--publish published=8080,target=80
--replicas 2
nginx
该命令指定了访问端口为8080，映射docker80端口，可以通过任何节点访问到如192.168.99.101:8080
4、Swarm && Compose
上面Swarm发布的Service都是单个容器的，多个容器如何操作呢？首先我们会联想到Compose，但是Comopse旧版本只支持在单个Host上发布，在集群里就需要Compose新版本了！先保证Compose是v3以上吧！
去这个网址https://github.com/docker/compose/releases/查看compose版本和compose yml版本的对应关系
image.png
Swarm发布Compose编排的Service过程：
步骤一：
编排docker-compose.yml模板文件，此处命名可以随便起，与Compose不同
下面的yml文件来自官方https://github.com/docker/labs/blob/master/beginner/chapters/votingapp.md
- version必须是3及以上
- 该服务包含redis、db、vote服务（投票功能）、result服务（统计结果）等等
version: "3"
services:
redis:
image: redis:alpine
ports:
- "6379"
networks:
- frontend
deploy:
replicas: 2
update_config:
parallelism: 2
delay: 10s
restart_policy:
condition: on-failure
db:
image: postgres:9.4
volumes:
- db-data:/var/lib/postgresql/data
networks:
- backend
deploy:
placement:
constraints: [node.role == manager]
vote:
image: dockersamples/examplevotingapp_vote:before
ports:
- 5000:80
networks:
- frontend
depends_on:
- redis
deploy:
replicas: 2
update_config:
parallelism: 2
restart_policy:
condition: on-failure
result:
image: dockersamples/examplevotingapp_result:before
ports:
- 5001:80
networks:
- backend
depends_on:
- db
deploy:
replicas: 1
update_config:
parallelism: 2
delay: 10s
restart_policy:
condition: on-failure
worker:
image: dockersamples/examplevotingapp_worker
networks:
- frontend
- backend
deploy:
mode: replicated
replicas: 1
labels: [APP=VOTING]
restart_policy:
condition: on-failure
delay: 10s
max_attempts: 3
window: 120s
placement:
constraints: [node.role == manager]
visualizer:
image: dockersamples/visualizer
ports:
- "8080:8080"
stop_grace_period: 1m30s
volumes:
- /var/run/docker.sock:/var/run/docker.sock
deploy:
placement:
constraints: [node.role == manager]
networks:
frontend:
backend:
volumes:
db-data:
步骤二：
执行命令 docker stack deploy --compose-file docker-compose.yml vote 启动基于yml文件的名称为vote的服务
注意docker stack不支持build，需要事先指定镜像
image.png
步骤三：
这样多个容器就以服务的形式发布到集群里面了！通过192.168.99.101:5000访问即可看到页面！
docker stack services vote：可以查看服务状态
docker stack rm vote：可以删除服务
image.png
Docker-Compose所有命令参数可以参考：https://docs.docker.com/compose/compose-file/
五、Docker基础
docker主要由仓库、镜像、容器三个概念组成！下图中显示了三者之间的关系
- 把镜像理解为软件安装包
- 把容器理解为使用的软件
- 把仓库理解为安装包下载网站
image.png
一：对于镜像：
1:增加镜像：
A：从仓库下载：docker pull NAME:TAG
A1:例子：docker pull ubuntu:latest
A2:例子：docker pull ubuntu 同上
A3:例子：docker pull ubuntu:14.04
B：创建镜像：
B1:基于已有镜像的容器创建：docker commit已经修改过的容器，如docker容器里创建了文件的镜像
B11:docker commit -m “消息” -a “作者信息” a925948cb23d（容器ID） test：0.1（标签）
B2:基于本地模板导入
B3:基于Dockerfile创建
C：存出镜像：docker save -o xxx.tar xxx:latest即可保存成tar文件
D：载入镜像：docker load < xxx.tar即可载入tar文件
2:删除镜像：
A：删除镜像：docker rmi image image可以为标签也可以为id
A1:-f强行删除
3:修改镜像：
A：给镜像打标签：docker tag ubuntu:latest myubuntu:latest
4:查看镜像：
A：列出镜像：docker images
A1:-a列出所有的镜像文件
A2:-q仅输出ID信息
B：详细信息：docker inspect ubuntu：latest
C：查看历史：docker history ubuntu：latest
5:搜索镜像：
A：搜索镜像：docker search -s 3 —automated ubuntu 搜索3星以上自动创建的ubutnu镜像
6:上传镜像：
A：先加标签：docker tag xxx：14.04 user／test：latest
再往上推：docker push user／test：latest
B：上传到docker hub里面，跟git很类似
7:Dockerfile详解：
构建：
Kind1：在dockerfile所在目录执行：docker build -t nginx：v3 .
Kind2: 直接用gitRepo构建：docker build git路径：版本
解释：BS架构，dockerfile所在目录应该为空目录，所有需要复制或者添加的文件都应该复制到该目录下，这个路径是一个上下文Context，构建过程中会把上下文发送给Docker引擎
A：FROM命令：以什么为基础，可以是已经存在的镜像，也可以是虚拟镜像scratch
B：RUN命令：与直接在容器内命令行中输入的命令一样的效果，为了减少层数，可以使用\和&&结合的方式，换行并继续的意思
C：COPY命令：COPY package.json ／usr／src／app，前者为上下文中的路径，后者可以为绝对路径，也可以为WORKDIR目录的相对路径
D：ADD命令：与COPY一至，源路径可以为url，可以为tar文件，只在自动解压缩的场合使用ADD，其余一律用RUN
E：CMD命令：制定容器启动时所要执行的命令，只能执行一次，多次会覆盖，CMD 【“可执行程序”，“param1”，“parma2”】
F：ENTRYPOINT命令：格式与RUN相同，给容器配置一个可执行程序格式与CMD相同，docker run指令不会覆盖ENTRYPOINT命令而会覆盖CMD命令，比如-i
G：ENV命令：设dockerfile的环境变量 ENV key value，之后的命令可以使用ENV定义的环境变量，容器内也可以使用
H：VOLUME命令：VOLUME ／data，匿名卷容器内的／data映射入主机了
I：EXPOSE命令：声明端口 EXPOSE 80 8080
J：WORKDIR：指定工作目录，或者成为当前目录，如果目录不存在WORKDIR会帮你创建
K：USER命令：制定当前用户
二：对于容器：
1:创建容器：
A：创建容器：docker create -it ubuntu：latest
保持标准输入打开：-i
后台运行容器：-d
分配一个伪终端：-t
B：创建并启动容器：docker run ubuntu ／bin/bash
2:删除容器：
A：docker rm命令删除：
B：删除所有：sudo docker rm $(docker ps -a -q)
3:停止容器：
A：优雅的停止：docker stop dockerID
B：直接杀死：docker kill id
4:查看容器：docker ps
A：获取容器输出信息：docker logs id
5:进入容器：
A：exec命令：docker exec -it dockerID ／bin／bash
B：nsenter工具：可以去查
6:容器互联：
A：docker run -d -P —name dockerName1 --link dockerName2:dockerName2Alias ubuntu：14.04
B：
7:启动容器：
A：docker start af（容器ID）
B：重启：docker restart id
C：启动容器会自动在镜像层外挂载一层可读写层
D：直接从镜像启动容器：docker run -i -t -d -p 8080:8080 --name myname ubuntu:latest
8:导入导出容器：
A：导出容器：docker export -o xxx.tar dockerID
B：导入容器：docker import xxx.tar - dockerName
三：对于仓库：
1:创建私有仓库：
A：创建本地／tmp／registry 位置的仓库 docker run -d -p 5000:5000 registry
B：创建制定路径仓库 docker run -d -p 5000:5000 -v ／opt／data／registry：／tmp／registry registry
2:从国内镜像下载镜像：
A：从时速云下载镜像：docker pull index.tenxcloud.com/docker_library/镜像：标签
四：对于数据：
1:数据卷：
A：容器内数据直接映射到本地主机环境
B：数据卷可以被多个容器共享和重用
C：对数据卷修改立马生效，并且更新数据卷不影响镜像
D：数据卷会一直存在，直到没有容器使用才可以安全卸载
E：挂载数据卷到容器内目录的两种方法：
E1：docker run -d -P --name web -v /webapp ubuntu:14.04 把容器的webapp目录映射到主机上
E2：挂载指定目录到容器：docker run -d -P --name web -v /src/webapp（主机目录）:/opt/webapp（容器内目录）:ro ubuntu：14.04 加上：ro后容器对锁挂在的数据卷内数据就无法修改了
E3：可以挂载单个文件到容器内目录作为数据卷，不推荐
F：删除数据卷：docker rm -v
2:数据卷容器：
A：使用特定容器维护数据卷
B：操作流程：
B1:创建数据卷容器：docker run -v ／dbdata —name dbdata ubuntu
B2:在其他容器使用—volumes-from dbdata即可挂载改容器，可以寄连挂在，也可以挂载多个数据卷容器
总结：
本篇博客涵盖了Docker自家的所有内容，从Docker基础到Docker三剑客都有解析，可以作为入门指导。
有了docker之后我们就可以随便的安装那些安装过程复杂的软件了，如果你看懂了，请给我一点鼓励哦！
三剑客简介
docker-machine
docker技术是基于Linux内核的cgroup技术实现的，那么问题来了，在非Linux平台上是否就不能使用docker技术了呢？答案是可以的，不过显然需要借助虚拟机去模拟出Linux环境来。
docker-machine就是docker公司官方提出的，用于在各种平台上快速创建具有docker服务的虚拟机的技术，甚至可以通过指定driver来定制虚拟机的实现原理（一般是virtualbox）。
docker-compose
docker镜像在创建之后，往往需要自己手动pull来获取镜像，然后执行run命令来运行。当服务需要用到多种容器，容器之间又产生了各种依赖和连接的时候，部署一个服务的手动操作是令人感到十分厌烦的。
dcoker-compose技术，就是通过一个.yml配置文件，将所有的容器的部署方法、文件映射、容器连接等等一系列的配置写在一个配置文件里，最后只需要执行docker-compose up命令就会像执行脚本一样的去一个个安装容器并自动部署他们，极大的便利了复杂服务的部署。
docker-swarm
swarm是基于docker平台实现的集群技术，他可以通过几条简单的指令快速的创建一个docker集群，接着在集群的共享网络上部署应用，最终实现分布式的服务。
docker-compose 的工作流程
使用Compose仅需要三步：
1、用一个定义你的应用程序的环境，Dockerfile这样它就可以在任何地方再现。
2、定义组成您的应用程序的服务，docker-compose.yml 以便它们可以在隔离的环境中一起运行。
3、运行docker-compose up和撰写启动并运行您的整个应用程序。
参考文章：https://docs.docker.com/compose/overview/
docker-compose安装布署
[root@docker ~]# curl -L https://github.com/docker/compose/releases/download/1.21.2/docker-compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 617 0 617 0 0 396 0 --:--:-- 0:00:01 --:--:-- 397
100 10.3M 100 10.3M 0 0 678k 0 0:00:15 0:00:15 --:--:-- 1876k
[root@docker ~]# chmod +x /usr/local/bin/docker-compose
[root@docker ~]# docker-compose --version
docker-compose version 1.21.2, build a133471docker-compose管理命令介绍
Compose具有管理应用程序整个生命周期的命令：
- 启动，停止和重建服务
- 查看正在运行的服务的状态
- 流式传输运行服务的日志输出
- 在服务上运行一次性命令
[root@docker ~]# docker-compose --help
Define and run multi-container applications with Docker.
Usage:
docker-compose [-f <arg>...] [options] [COMMAND] [ARGS...]
docker-compose -h|--help
Options:
-f, --file FILE Specify an alternate compose file
(default: docker-compose.yml)
-p, --project-name NAME Specify an alternate project name
(default: directory name)
--verbose Show more output
--log-level LEVEL Set log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
--no-ansi Do not print ANSI control characters
-v, --version Print version and exit
-H, --host HOST Daemon socket to connect to
--tls Use TLS; implied by --tlsverify
--tlscacert CA_PATH Trust certs signed only by this CA
--tlscert CLIENT_CERT_PATH Path to TLS certificate file
--tlskey TLS_KEY_PATH Path to TLS key file
--tlsverify Use TLS and verify the remote
--skip-hostname-check Don't check the daemon's hostname against the
name specified in the client certificate
--project-directory PATH Specify an alternate working directory
(default: the path of the Compose file)
--compatibility If set, Compose will attempt to convert deploy
keys in v3 files to their non-Swarm equivalent
Commands:
build Build or rebuild services
bundle Generate a Docker bundle from the Compose file
config Validate and view the Compose file
create Create services
down Stop and remove containers, networks, images, and volumes
events Receive real time events from containers
exec Execute a command in a running container
help Get help on a command
images List images
kill Kill containers
logs View output from containers
pause Pause services
port Print the public port for a port binding
ps List containers
pull Pull service images
push Push service images
restart Restart services
rm Remove stopped containers
run Run a one-off command
scale Set number of containers for a service
start Start services
stop Stop services
top Display the running processes
unpause Unpause services
up Create and start containers
version Show the Docker-Compose version informationdocker-compose 运行时是需要指定service名称，可以同时指定多个，也可以不指定。不指定时默认就是对配置文件中所有的service执行命令。
-f #用于指定配置文件
-p #用于指定项目名称
docker-compose build
用来创建或重新创建服务使用的镜像
docker-compose build service_a
创建一个镜像名叫service_a
docker-compose kill
用于通过容器发送SIGKILL信号强行停止服务
docker-compose logs
显示service的日志信息
docker-compose pause/unpause
docker-compose pause #暂停服务
docker-compose unpause #恢复被暂停的服务
docker-compose port
用于查看服务中的端口与物理机的映射关系
docker-compose port nginx_web 80
查看服务中80端口映射到物理机上的那个端口
dokcer-compose ps
用于显示当前项目下的容器
注意，此命令与docker ps不同作用，此命令会显示停止后的容器（状态为Exited），只征对某个项目。
docker-compose pull
用于拉取服务依赖的镜像
docker-compose restart
用于重启某个服务中的所有容器
docker-compose restart service_name
只有正在运行的服务可以使用重启命令，停止的服务是不可以重启
docker-compose rm
删除停止的服务（服务里的容器）
-f #强制删除
-v #删除与容器相关的卷（volumes）
docker-compose run
用于在服务中运行一个一次性的命令。这个命令会新建一个容器，它的配置和srvice的配置相同。
但两者之间还是有两点不同之处
1、run指定的命令会直接覆盖掉service配置中指定的命令
2、run命令启动的容器不会创建在service配置中指定的端口，如果需要指定使用--service-ports指定
docker-compose start/stop
docker-compose start 启动运行某个服务的所有容器
docker-compose stop 停止运行某个服务的所有容器
docker-compose scale
指定某个服务启动的容器个数
[root@docker ~]# docker-compose scale --help
Numbers are specified in the form `service=num` as arguments.
For example:
$ docker-compose scale web=2 worker=3
This command is deprecated. Use the up command with the `--scale` flag
instead.
Usage: scale [options] [SERVICE=NUM...]
Options:
-t, --timeout TIMEOUT Specify a shutdown timeout in seconds.
(default: 10)docker-compose配置文件实例
一个docker-compose.yml的实例文件如下
version: "3"
services:
nginx:
container_name: web-nginx
image: nginx:latest
restart: always
ports:
- 80:80
volumes:
- ./webserver:/webserver
- ./nginx/nginx.conf:/etc/nginx/nginx.conf下面将配置文件做个简单的解释说明
docker-compose的配置文件是一个.yml格式的文件
第一部分
version: "3" #指定语法的版本
第二部分
services: #定义服务
nginx: #服务的名称，-p参数后接服务名称
container_name: web-nginx #容器的名称
image: nginx:latest #镜像
restart: always
ports: #端口映射
- 80:80
第三部分
volumes: #物理机与容器的磁盘映射关系
- ./webserver:/webserver
- ./nginx/nginx.conf:/etc/nginx/nginx.conf整体的目录结构如下
[root@docker docker]# tree ./
./
├── docker-compose.yml
├── nginx
│?? └── nginx.conf
└── webserver
└── index.html
2 directories, 3 files配置文件如下
[root@docker docker]# cat webserver/index.html
welcome to nginx server!!!!!!!!!
[root@docker docker]# cat nginx/nginx.conf
#user nginx;
worker_processes 1;
error_log /var/log/nginx/error.log warn;
pid /var/run/nginx.pid;
events {
worker_connections 1024;
}
http {
include /etc/nginx/mime.types;
default_type application/octet-stream;
log_format main '$remote_addr - $remote_user [$time_local] "$request" '
'$status $body_bytes_sent "$http_referer" '
'"$http_user_agent" "$http_x_forwarded_for"';
access_log /var/log/nginx/access.log main;
client_max_body_size 10m;
sendfile on;
#tcp_nopush on;
keepalive_timeout 65;
#gzip on;
server {
listen 80;
server_name localhost;
location / {
root /webserver;
index index.html index.htm;
}
}
include /etc/nginx/conf.d/*.conf;
}使用命令启动容器
[root@docker docker]# docker-compose up -d
Pulling nginx (nginx:1.14)...
Trying to pull repository docker.io/library/nginx ...
1.14: Pulling from docker.io/library/nginx
f2aa67a397c4: Already exists
6160d1ac49e9: Pull complete
046b67408776: Pull complete
Digest: sha256:85ab7c44474df01422fe8fdbf9c28e497df427e8a67ce6d47ba027c49be4bdc6
Status: Downloaded newer image for docker.io/nginx:1.14
Creating nginx-server ... done
[root@docker docker]# lsof -i :80
COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME
docker-pr 891 root 4u IPv6 1187080 0t0 TCP *:http (LISTEN)
[root@docker docker]# docker ps |grep nginx
07ca899cc44b nginx:1.14 "nginx -g 'daemon ..." 29 seconds ago Up 28 seconds 0.0.0.0:80->80/tcp nginx-server
#如果启动时不指定里面的服务名称，就是直接启动配置文件里所有的服务浏览器测试是否正常访问
然后我们修改相应的首页文件如下
[root@docker docker]# cat webserver/index.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>welcome to nginx web stie</title>
</head>
<body>
<h2>欢迎来nginx站点</h2>
</body>
</html>再次打开浏览器查看效果
#是不是非常的方便
使用Docker-Compose部署nginx代理Tomcat集群,实现负载均衡
大体步骤分为以下四步
1、下载所需的文件tomcat,jdk
2、编写dockerfile来布署tomcat与java环境，生成镜像文件
3、编写docker-compose.yml配置文件，启动所有容器服务
4、测试负载均衡
具体配置文件如下
#整个目录结构
[root@master java]# tree ./
./
├── docker-compose.yml
├── etc
│ └── localtime
├── nginx
│ └── nginx.conf
├── tomcat
│ ├── apache-tomcat-8.5.31.tar.gz
│ ├── Dockerfile
│ └── jdk-8u144-linux-x64.tar.gz
└── webserver
├── tomcatA
│ └── index.jsp
└── tomcatB
└── index.jsp
6 directories, 8 files两个测试首页文件
[root@master java]# cat webserver/tomcatA/index.jsp
welcome to tomcat-A server
[root@master java]# cat webserver/tomcatB/index.jsp
welcome to tomcat-B server配置文件
[root@master java]# cat docker-compose.yml
version: "3"
services:
nginx:
image: nginx:1.14
restart: always
ports:
- 80:80
links:
- tomcat1:tomcat1
- tomcat2:tomcat2
volumes:
- ./webserver:/webserver
- ./nginx/nginx.conf:/etc/nginx/nginx.conf
- ./etc/localtime:/etc/localtime
depends_on:
- tomcat1
- tomcat2
tomcat1:
hostname: tomcat1
build: ./tomcat
volumes:
- ./webserver/tomcatA:/usr/local/apache-tomcat-8.5.31/webapps/ROOT
- ./etc/localtime:/etc/localtime
tomcat2:
hostname: tomcat2
build: ./tomcat
volumes:
- ./webserver/tomcatB:/usr/local/apache-tomcat-8.5.31/webapps/ROOT
- ./etc/localtime:/etc/localtime安装JAVA环境
[root@master java]# cat tomcat/Dockerfile
FROM centos
ADD jdk-8u144-linux-x64.tar.gz /usr/local
ENV JAVA_HOME /usr/local/jdk1.8.0_144
ADD apache-tomcat-8.5.31.tar.gz /usr/local
EXPOSE 8080
ENTRYPOINT ["/usr/local/apache-tomcat-8.5.31/bin/catalina.sh", "run"]启动所有容器服务
[root@master java]# docker-compose up
Building tomcat1
Step 1/6 : FROM centos
Trying to pull repository docker.io/library/centos ...
latest: Pulling from docker.io/library/centos
7dc0dca2b151: Pull complete
Digest: sha256:b67d21dfe609ddacf404589e04631d90a342921e81c40aeaf3391f6717fa5322
Status: Downloaded newer image for docker.io/centos:latest
---> 49f7960eb7e4
Step 2/6 : ADD jdk-8u144-linux-x64.tar.gz /usr/local
---> 8c9e14062a24
Removing intermediate container a499940235ac
Step 3/6 : ENV JAVA_HOME /usr/local/jdk1.8.0_144
---> Running in cefedfd97f61
---> 12528cd5a517
Removing intermediate container cefedfd97f61
Step 4/6 : ADD apache-tomcat-8.5.31.tar.gz /usr/local
---> 246fa08bea1c
Removing intermediate container a1aaaa2bf0b8
Step 5/6 : EXPOSE 8080
---> Running in 87c4b41f3c1e
---> fd207f27b830
Removing intermediate container 87c4b41f3c1e
Step 6/6 : ENTRYPOINT /usr/local/apache-tomcat-8.5.31/bin/catalina.sh run
---> Running in 9adaed8e3ab9
---> b6fc6d3925f7
Removing intermediate container 9adaed8e3ab9
Successfully built b6fc6d3925f7
WARNING: Image for service tomcat1 was built because it did not already exist. To rebuild this image you must use `docker-compose build` or `docker-compose up --build`.
Building tomcat2
Step 1/6 : FROM centos
---> 49f7960eb7e4
Step 2/6 : ADD jdk-8u144-linux-x64.tar.gz /usr/local
---> Using cache
---> 8c9e14062a24
Step 3/6 : ENV JAVA_HOME /usr/local/jdk1.8.0_144
---> Using cache
---> 12528cd5a517
Step 4/6 : ADD apache-tomcat-8.5.31.tar.gz /usr/local
---> Using cache
---> 246fa08bea1c
Step 5/6 : EXPOSE 8080
---> Using cache
---> fd207f27b830
Step 6/6 : ENTRYPOINT /usr/local/apache-tomcat-8.5.31/bin/catalina.sh run
---> Using cache
---> b6fc6d3925f7
Successfully built b6fc6d3925f7
WARNING: Image for service tomcat2 was built because it did not already exist. To rebuild this image you must use `docker-compose build` or `docker-compose up --build`.
Pulling nginx (nginx:1.14)...
Trying to pull repository docker.io/library/nginx ...
1.14: Pulling from docker.io/library/nginx
f2aa67a397c4: Already exists
6160d1ac49e9: Pull complete
046b67408776: Pull complete
Digest: sha256:85ab7c44474df01422fe8fdbf9c28e497df427e8a67ce6d47ba027c49be4bdc6
Status: Downloaded newer image for docker.io/nginx:1.14
Creating java_tomcat2_1 ... done
Creating java_tomcat1_1 ... done
Creating java_nginx_1 ... done查看启动情况
[root@master java]# docker-compose ps
Name Command State Ports
----------------------------------------------------------------------------
java_nginx_1 nginx -g daemon off; Up 0.0.0.0:80->80/tcp
java_tomcat1_1 /usr/local/apache-tomcat-8 ... Up 8080/tcp
java_tomcat2_1 /usr/local/apache-tomcat-8 ... Up 8080/tcp 检测负载均衡
[root@master java]# curl http://localhost
welcome to tomcat-A server
[root@master java]# curl http://localhost
welcome to tomcat-B server
[root@master java]# curl http://localhost
welcome to tomcat-A server
[root@master java]# curl http://localhost
welcome to tomcat-B server浏览器访问测试负载均衡
查看日志输出信息
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:33 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:34 +0000] "GET / HTTP/1.1" 499 0 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:34 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:36 +0000] "GET / HTTP/1.1" 499 0 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:36 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:36 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:37 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:37 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:37 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:37 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:38 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:38 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:38 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:38 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:38 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:39 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 172.19.0.1 - - [08/Jun/2018:02:18:30 +0000] "GET / HTTP/1.1" 200 27 "-" "curl/7.29.0" "-"
nginx_1 | 172.19.0.1 - - [08/Jun/2018:02:18:31 +0000] "GET / HTTP/1.1" 200 27 "-" "curl/7.29.0" "-"
nginx_1 | 172.19.0.1 - - [08/Jun/2018:02:18:32 +0000] "GET / HTTP/1.1" 200 27 "-" "curl/7.29.0" "-"
nginx_1 | 172.19.0.1 - - [08/Jun/2018:02:18:33 +0000] "GET / HTTP/1.1" 200 27 "-" "curl/7.29.0" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:19:32 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
CentOS7安装最新版Docker、compose、swarm、machine
最新版 Docker 安装
1.卸载 Docker
sudo yum remove docker docker-client docker-client-latest docker-common docker-latest docker-latest-logrotate docker-logrotate docker-selinux docker-engine-selinux docker-engine
2.安装所需的包
sudo yum install -y yum-utils device-mapper-persistent-data lvm2
3.设置稳定的存储库
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
4.可选：启用边缘和测试存储库
sudo yum-config-manager --enable docker-ce-edge
sudo yum-config-manager --enable docker-ce-test
禁用边缘存储库
sudo yum-config-manager --disable docker-ce-edge
5.安装最新版本的 Docker CE
sudo yum install docker-ce
6.启动 Docker
sudo systemctl start docker
7.通过运行 hello-world 映像验证是否已正确安装
sudo docker run hello-world
docker-compose 安装
1.下载最新版本的 Docker Compose (第一次执行提示失败，就多执行几次这个命令试试)
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
2.对二进制文件应用可执行权限
sudo chmod +x /usr/local/bin/docker-compose
3.测试安装
docker-compose --version
docker-machine 安装
1.下载 Docker Machine 二进制文件并将其解压缩到 PATH (第一次执行提示失败，就多执行几次这个命令试试)
base=https://github.com/docker/machine/releases/download/v0.14.0 && curl -L $base/docker-machine-$(uname -s)-$(uname -m) >/tmp/docker-machine && sudo install /tmp/docker-machine /usr/local/bin/docker-machine
2.通过显示机器版本来检查安装
docker-machine version
搭建 swarm 集群
1.新版 docker 已集成 swarm，无需单独安装
2.使用 docker swarm init 在管理节点初始化一个 Swarm 集群
docker swarm init --advertise-addr 192.168.153.150
# 如果你的 Docker 主机有多个网卡，拥有多个 IP，必须使用 --advertise-addr 指定 IP
# 执行 docker swarm init 命令的节点自动成为管理节点
3.将其他主机作为 管理节点 或 工作节点 加入 swarm 集群（以下命令在待加入节点执行）
docker swarm join --token [MANAGER-TOKEN||WORKER-TOKEN] [MANAGER-IP]:2377
# 示例：docker swarm join --token SWMTKN-1-3pu6hszjas19xyp7ghgosyx9k8atbfcr8p2is99znpy26u2lkl-1awxwuwd3z9j1z3puu7rcgdbx 192.168.153.150:2377
--------------
注意：各机器之间要开启以下通信端口 或 关闭防火墙
# TCP端口2377集群管理端口
# TCP与 UDP端口7946节点之间通讯端口
# TCP与 UDP端口4789 overlay 网络通讯端口
firewall-cmd --zone=public --add-port=2377/tcp --permanent
firewall-cmd --zone=public --add-port=7946/tcp --permanent
firewall-cmd --zone=public --add-port=7946/udp --permanent
firewall-cmd --zone=public --add-port=4789/tcp --permanent
firewall-cmd --zone=public --add-port=4789/udp --permanent
firewall-cmd --reload
关闭防火墙：
sudo systemctl stop firewalld.service
sudo systemctl disable firewalld.service
--------------
4.在管理节点使用 docker node ls 查看集群
docker node ls
5.向集群中添加工作节点，通过以下命令获取加入集群的 WORKER-TOKEN
docker swarm join-token worker
向集群中添加管理节点，通过以下命令获取加入集群的 MANAGER-TOKEN
docker swarm join-token manager
6.退出集群
(1)如果是 manager 先降级为 worker
docker node demote [HOSTNAME || ID] # ID前几位即可
(2)退出集群
docker swarm leave
(3)移除节点
docker node rm [HOSTNAME || ID] # ID前几位即可
# leave后该节点仍将出现在节点列表中，并将 STATUS标记为 down，已不影响 swarm操作；
# 要从列表中删除非活动节点，使用 node rm 命令即可。
使用 swarm+compose 部署集群服务
1.使用 swarm+compose 部署服务
docker stack deploy -c docker-compose.yml [JIQUN-NAME]
2.查看服务
docker stack ls
3.移除服务
docker stack down [JIQUN-NAME]
# 该命令不会移除服务所使用的 数据卷，如果你想移除数据卷请使用 docker volume rm
其他 Docker 常用命令
查看 swarm 集群中的服务：docker service ls
查看 swarm 集群中某个服务的运行状态信息：docker service ps mwp_db
查看 swarm 集群中某个服务的基础详细信息：docker service inspect mwp_db
查看 swarm 集群中某个服务的日志：docker service logs mwp_db
从 swarm 集群中移除某个服务：docker service rm mwp_db
搜索仓库镜像：docker search nginx
查找本地镜像：docker images nginx
查看本地镜像列表：docker images 或 docker image ls
删除本地镜像：docker rmi [IMAGE ID]
强制删除本地镜像：docker rmi -f [IMAGE ID] # 一般先停止相关容器，再 docker rmi [IMAGE ID] 正常删除镜像
列出本机容器 container：docker ps -a 或 docker container ls
删除 container：docker rm [CONTAINER ID] 或 docker container rm [CONTAINER ID]
清理所有处于终止状态的容器：docker container prune
进入后台运行的容器 container：docker exec -it [CONTAINER_NAME || CONTAINER_ID] /bin/sh
# docker exec 进入容器后 exit 不会导致容器停止
创建一个新的容器并运行：docker run --name web2 -d -p 81:80 nginx:v2
停止一个运行中的容器：docker stop [CONTAINER ID || NAMES]
查看所有数据卷：docker volume ls
删除指定数据卷：docker volume rm [VOLUME NAME]
清理所有无主数据卷：docker volume prune
查看 Image 或 Container 的信息：docker inspect [IMAGE || IMAGE ID || CONTAINER ID]
查看 CentOS 系统内核版本：uname -r
使用 Dockerfile 定制镜像：docker build -t nginx:v3 [DOCKERFILE PATH || URL]
# 其中 [DOCKERFILE PATH || URL] 为 Dockerfile 文件所在目录，例：docker build -t nginx:v3 .
更多命令可参考：http://www.runoob.com/docker/docker-command-manual.html
配置 Docker 加速器
参考：https://yeasy.gitbooks.io/docker_practice/install/mirror.html
对于使用 systemd 的系统，在 /etc/docker/daemon.json 中写入如下内容（如果文件不存在则新建该文件）
{
"registry-mirrors": [
"https://registry.docker-cn.com"
]
}
之后重新启动服务。
$ sudo systemctl daemon-reload
$ sudo systemctl restart docker
检查加速器是否生效：docker info
Registry Mirrors:
https://registry.docker-cn.com/
Docker hub 地址：https://hub.docker.com/
Docker 官方文档地址：https://docs.docker.com/
ubuntu16.04安装最新版docker、docker-compose、docker-machine
安装前说明:
本文将介绍在ubuntu16.04系统下安装和升级docker、docker-compose、docker-machine。
docker：有两个版本:docker-ce(社区版)和docker-ee(企业版)。
笔者这里介绍安装或升级的是最新版docker-ce(社区版)。
参考官网地址：https://docs.docker.com/engine/installation/linux/docker-ce/ubuntu/#os-requirements
docker-compse：可运行和管理多个docker容器。
docker-machine：docker官方提供的docker管理工具。可管理多个docker主机，可搭建swarm集群。
一、docker安装
1，卸载旧版本docker
全新安装时，无需执行该步骤
$ sudo apt-get remove docker docker-engine docker.io
2，更新系统软件
$ sudo apt-get update
3，安装依赖包
$ sudo apt-get install \
apt-transport-https \
ca-certificates \
curl \
software-properties-common
4，添加官方密钥
执行该命令时，如遇到长时间没有响应说明网络连接不到docker网站，需要使用代-理进行。
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
显示OK,表示添加成功.
5，添加仓库
$ sudo add-apt-repository \ "deb [arch=amd64] https://download.docker.com/linux/ubuntu \ $(lsb_release -cs) \ stable"
6，再次更新软件
经实践，这一步不能够省略，我们需要再次把软件更新到最新，否则下一步有可能会报错。
$ sudo apt-get update
7，安装docker
如果想指定安装某一版本，可使用 sudo apt-get install docker-ce=<VERSION> 命令，把<VERSION>替换为具体版本即可。
以下命令没有指定版本，默认就会安装最新版
$ sudo apt-get install docker-ce
8，查看docker版本
$ docker -v
显示“Docker version 17.09.0-ce, build afdb6d4”字样，表示安装成功。
二、docker-compose安装
1，下载docker-compose
$ sudo curl -L https://github.com/docker/compose/releases/download/1.17.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
2，授权
$ sudo chmod +x /usr/local/bin/docker-compose
3，查看版本信息
$ docker-compose --version
显示出版本信息，即安装成功。
三、docker-machine安装
说明：docker-machine的使用是要基于virtualBox的。如果没有安装安装过，请先安装virtualBox。
1，安装virtualBox
登录virtualBox官网：https://www.virtualbox.org/wiki/Linux_Downloads
找到"Ubuntu 16.04 ("Xenial") i386 | AMD64"字样，点击“AMD64”进行下载。
下载后，执行以下命令进行安装：
$ sudo dpkg -i virtualbox-5.2_5.2.0-118431_Ubuntu_xenial_amd64.deb
2，下载并安装docker-machine
$ curl -L https://github.com/docker/machine/releases/download/v0.13.0/docker-machine-`uname -s`-`uname -m` >/tmp/docker-machine && chmod +x /tmp/docker-machine && sudo cp /tmp/docker-machine /usr/local/bin/docker-machine
3，查看版本信息
$ docker-machine version
在 VirtualBox 中使用 Docker Machine 管理主机
大家好，今天我们学习在 VirtualBox 中使用 Docker Machine 来创建和管理 Docker 主机。Docker Machine 是一个可以帮助我们在电脑上、在云端、在数据中心内创建 Docker 主机的应用。它为根据用户的配置和需求创建服务器并在其上安装 Docker和客户端提供了一个轻松的解决方案。这个 API 可以用于在本地主机、或数据中心的虚拟机、或云端的实例提供 Docker 服务。Docker Machine 支持 Windows、OSX 和 Linux，并且是以一个独立的二进制文件包形式安装的。仍然使用（与现有 Docker 工具）相同的接口，我们就可以充分利用已经提供 Docker 基础框架的生态系统。只要一个命令，用户就能快速部署 Docker 容器。
本文列出一些简单的步骤用 Docker Machine 来部署 docker 容器。
1. 安装 Docker Machine
Docker Machine 完美支持所有 Linux 操作系统。首先我们需要从 github下载最新版本的 Docker Machine，本文使用 curl 作为下载工具，Docker Machine 版本为 0.2.0。
64 位操作系统
# curl -L https://github.com/docker/machine/releases/download/v0.2.0/docker-machine_linux-amd64 > /usr/local/bin/docker-machine32 位操作系统
# curl -L https://github.com/docker/machine/releases/download/v0.2.0/docker-machine_linux-i386 > /usr/local/bin/docker-machine下载完成后，找到 /usr/local/bin目录下的docker-machine文件，让其可以执行：
# chmod +x /usr/local/bin/docker-machine确认是否成功安装了 docker-machine，可以运行下面的命令，它会打印 Docker Machine 的版本信息：
# docker-machine -v运行下面的命令，安装 Docker 客户端，以便于在我们自己的电脑止运行 Docker 命令：
# curl -L https://get.docker.com/builds/linux/x86_64/docker-latest > /usr/local/bin/docker# chmod +x /usr/local/bin/docker
2. 创建 VirtualBox 虚拟机
在 Linux 系统上安装完 Docker Machine 后，接下来我们可以安装 VirtualBox 虚拟机，运行下面的就可以了。--driver virtualbox选项表示我们要在 VirtualBox 的虚拟机里面部署 docker，最后的参数“linux” 是虚拟机的名称。这个命令会下载boot2dockeriso，它是个基于 Tiny Core Linux 的轻量级发行版，自带 Docker 程序，然后docker-machine命令会创建一个 VirtualBox 虚拟机（LCTT译注：当然，我们也可以选择其他的虚拟机软件）来运行这个 boot2docker 系统。
# docker-machine create --driver virtualbox linux测试下有没有成功运行 VirtualBox 和 Docker，运行命令：
# docker-machine ls如果执行成功，我们可以看到在 ACTIVE 那列下面会出现一个星号“*”。
3. 设置环境变量
现在我们需要让 docker 与 docker-machine 通信，运行 docker-machine env <虚拟机名称>来实现这个目的。
# eval "$(docker-machine env linux)"# docker ps这个命令会设置 TLS 认证的环境变量，每次重启机器或者重新打开一个会话都需要执行一下这个命令，我们可以看到它的输出内容：
# docker-machine env linuxexport DOCKER_TLS_VERIFY=1export DOCKER_CERT_PATH=/Users/<your username>/.docker/machine/machines/devexport DOCKER_HOST=tcp://192.168.99.100:2376
4. 运行 Docker 容器
完成配置后我们就可以在 VirtualBox 上运行 docker 容器了。测试一下，我们可以运行虚拟机 docker run busybox，并在里面里执行echo hello world命令，我们可以看到容器的输出信息。
# docker run busybox echo hello world
5. 拿到 Docker 主机的 IP
我们可以执行下面的命令获取运行 Docker 的主机的 IP 地址。我们可以看到在 Docker 主机的 IP 地址上的任何暴露出来的端口。
# docker-machine ip
6. 管理主机
现在我们可以随心所欲地使用上述的 docker-machine 命令来不断创建主机了。
当你使用完 docker 时，可以运行 docker-machine stop来停止所有主机，如果想开启所有主机，运行docker-machine start。
# docker-machine stop# docker-machine start你也可以只停止或开启一台主机：
$ docker-machine stop linux$ docker-machine start linux
总结
最后，我们使用 Docker Machine 成功在 VirtualBox 上创建并管理一台 Docker 主机。Docker Machine 确实能让用户快速地在不同的平台上部署 Docker 主机，就像我们这里部署在 VirtualBox 上一样。这个 virtualbox 驱动可以在本地机器上使用，也可以在数据中心的虚拟机上使用。Docker Machine 驱动除了支持本地的 VirtualBox 之外，还支持远端的 Digital Ocean、AWS、Azure、VMware 以及其它基础设施。
如果你有任何疑问，或者建议，请在评论栏中写出来，我们会不断改进我们的内容。谢谢，祝愉快。
Docker Engine
当人们提到 Docker，一般而言，大家说的是 Docker Engine，如下图：
它是一个 client-server application。
Docker Engine 由三个部分组成：
Docker 进程（Docker Daemon）
REST API：指定了和进程交互的接口
CLI(command line interface)：通过 REST API 和 daemon 通信，诸如：docker run <image>, docker ps...
Docker Machine
Docker Machine 是一种提供管理主机的 工具。常规，你会安装 Docker Machine 在你的本地机器上。
Docker Machine 有自己的命令client：docker-machine
Docker Engine 则有client：docker
我们可以使用 Docker Machine 来安装 Docker Engine 在一个或者多个虚拟系统上，这些虚拟系统可以是本地的（比如Virtualbox里），也可以是远程的（云）。
privileged参数
-
$ docker help run -
... -
--privileged=false Give extended privileges to this container -
...
大约在0.6版，privileged被引入docker。
使用该参数，container内的root拥有真正的root权限。
否则，container内的root只是外部的一个普通用户权限。
privileged启动的容器，可以看到很多host上的设备，并且可以执行mount。
甚至允许你在docker容器中启动docker容器。
介绍：
docker compose 是 docker 官方推出的一款单机容器编排工具,
和 docker swarm, docker machine 并称为 docker 容器编排三剑客, 虽然其被 k8s 吊打,
但是由于其简单易学在中小规模的集群中还是占有相当的一部分地位的
使用Compose的步骤：
1、定义您的应用程序环境，Dockerfile以便可以在任何地方进行复制
2、定义构成应用程序的服务，docker-compose.yml 以便它们可以在隔离环境中一起运行
3、运行 docker-compose up 和 Compose starts 运行整个应用程序
compose 的特性：
1、单个主机上的多个环境隔离
2、创建容器时保留卷数据
3、仅重新创建已更改的容器
4、变量和在环境之间移动合成
安装：
docker compose 依赖所有的工作依赖于 docker, 在安装 compose 前请确保已在本地或远程主机中安装 docker
二进制安装：
curl -L "https://github.com/docker/compose/releases/download/1.22.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose
pip安装：
pip install docker-compose
一个简单的例子：
mkdir composetest && cd composetest ＃创建一个专用目录,用于编写和保存 compose 文件
cat app.py #编写一个 flask web 应用作为测试
import time
import redis
from flask import Flask
app = Flask(__name__)
cache = redis.Redis(host='redis', port=6379) #连接 redis
# 定义函数
def get_hit_count():
retries = 5
while True:
try:
return cache.incr('hits')
except redis.exceptions.ConnectionError as exc:
if retries == 0:
raise exc
retries -= 1
time.sleep(0.5)
@app.route('/')
def hello():
count = get_hit_count()
# 每访问一次返回的 count 加 1
return 'Hello World! I have been seen {} times.\n'.format(count)
if __name__ == "__main__":
#运行 web 应用
app.run(host="0.0.0.0", debug=True)
cat Dockerfile #编写docker file 文件以便 compose 可以根据 docker file 动态构建镜像
FROM python:3.4-alpine
ADD . /code
WORKDIR /code
RUN pip install flask redis
CMD ["python", "app.py"]
cat docker-compose.yml #编写 compose 文件定义容器间的关系
version: '3'
services:
web:
build: .
ports:
- "5000:5000"
volumes:
- .:/code
redis:
image: "redis:alpine"
docker-compose up #启动 docker compose 定义的 docker 集群
curl http://127.0.0.1:5000/ #访问 Web APP
# 示例来源
# https://docs.docker.com/compose/gettingstarted/#step-5-edit-the-compose-file-to-add-a-bind-mount
docker-compose 命令：
介绍：
1、docker-compose 命令的执行都必须指定或者在当前目录下存在 compose 文件, 且输出的内容都是这个 compose.yml 文件定义的集群内的信息
2、每个集群中可以拥有多个 services, services 由 compose.yml 的 services 定义
选项：
-f 指定 compose 文件路径(可以指定多个)
子命令：
create 创建 compose 集群, 但不启动(已废弃, 使用 up --no-start 代替)
down 停止或删除容器, 网络, 镜像和数据卷
exec 运行容器中的命令或者连接容器
help 查看帮助信息
images 列出 compose 集群所用的镜像
kill kill 掉 compose 集群
logs 获取 compose 集群日志
pause 暂停 compose 集群
ps 列出正在运行的容器
pull 拉取 compose.yml 文件中定义的所有 docker 镜像
push 上传 compose.yml 文件中定义的所有 docker 镜像
restart 重启 compose 集群
rm 删除一个停止的容器或者 compose 集群
run 和 exec 相同
scale 更改 compose 集群内指定的 services 的副本数量
start 启动 compose 集群
stop 停止 compose 集群
top 显示 compose 集群中运行的进程及其状态
unpause 恢复被暂停的 compose 集群
up 创建并启动一个 compose 集群
version 输出 compose 版本使用 Docker Machine、Swarm 和 Compose 进行 Docker 规划
机器(Machine)用一个命令就把你从“零带到Docker”。它可以让你轻松地部署Docker引擎到您的计算机上，云提供商上，以及自己的数据中心。Machine’s blog post上有更多的信息并提供软件下载。
集群(Swarm)是Docker容器的本地集群。它将多个Docker引擎汇聚到一起组成一个虚拟主机。将Docker客户端或第三方工具（例如，Compose，Dokku，Shipyard，Jenkins，the Docker client，等）指向Swarm, 并将会透明地扩展到多个主机。一个测试版本的Swarm已经可用，我们正在努力将其与亚马逊Web服务，IBM Bluemix，Joyent，Kubernetes，Mesos和微软的Azure。Machine’s blog post上有更多的信息。
组合(Compose)是一种定义和运行包含Docker的多容器分布式应用程序。早在十二月，我们就向社区公开了它的设计。基于社区反馈，Compose 是基于 Fig。Fig 是一种在开发环境运行Docker的一个工具。 Compose’s blog post 上有更多的信息并提供软件下载。
现在在一起
Docker 引擎对单一容器的应用程序表现良好，使得它们在构建，部署和转移应用程序方面更加的容易。但是我们无时不知道你需要的是能够定义和部署复杂的由多个服务组成的应用程序。如果你现在希望用Docker来完成这件事，Docker引擎还不清楚要做什么。你可能不得不拼凑一些shell脚本的东西使它工作。
这不是理想的方案。我们想与你分享一些我们的一些想法， 这些想法是有关如何在分布式的应用中使用Docker，我们今天发布的工具都要帮助实现这些想法。
我们听说，你想要你的分布式应用程序是：
-
在不同的环境中便携的使用：你可以定义你的应用程序将如何在开发环境运行，那么它们也应该无缝地在测试，准生产环境和生产环境运行。
-
在不同的供应商中便携的使用：你可以在不同的云供应商和自己的服务器之间移动你的应用程序，或跨几个供应商运行它们。
-
可组合的：你可以将你的应用分拆到多个服务。
我们今天发布的工具是一个平台的开始，这个平台将使这一切成为可能。
首先，你使用Machine创建已经安装了Docker引擎的主机。Machine可以在您的计算机上，云服务提供商，和/或在您自己的数据中心上创建这些主机。
接下来，你将这些Docker引擎用Swarm汇集到一起。Swarm将Docker引擎连接成一个单一的，虚拟引擎。这有点像运行了很多Docker容器的一个非常大的计算机。你不再担心管理服务器–它们都汇集在一起并由一个集群系统为你管理这些资源。
Swarm带有一个内置的集群系统，但如果你想和现有的正在运行的系统整合，Swarm将来也会运行在Mesos或Kubernetes之上。
另外，如果你想把Swarm部署到云上，而不是建立自己的Swarm，为此，我们正和亚马逊EC2 Container Service，IBM Bluemix Container Service, Joyent Smart Data Center和微软的Azure合作，将他们的产品与Swarm整合。
一旦你有了一个Swarm，你就可以在它上面运行你的应用程序。你用Compose来定义你的多容器应用程序（例如，一个Web服务器容器连接到一个数据库容器）。Compose可以在任何可以调用Docker API的机器上运行这个应用。在开发阶段，你可以将Compose直接运行在你电脑上的的Docker主机上。当你需要把你的应用程序放到准生产和生产环境，你可以将Compose指向Swarm集群。
所以，如果你用Compose来定义你的应用程序，你可以在任何环境或供应方上运行它：在你的电脑上，在云上的一个Swarm，在你自己的数据中心的一个Swarm，一个运行在Mesos 或Kubernetes之上运行的Swarm上。
参与
这种设计仍在完善当中，我们真的希望听到你们的意见。当我们在Docker上做了很大开发的时候，我们会把这些变化开放出来以供人们使用。这让我们看到用户如何使用它，这样我们可以快速地迭代开发。并且，因为它是开源的，你可以直接参与它的开发。
Machine, Swarm and Compose的安装说明以及下载。它们可以作为独立的工具，但如果你敢于冒险的话，你可以将他们安装到一起（尽管这还是处在一个非常实验状态）。请参考有关Machine+Swarm以及Compose+Swarm的文档。
如果你对软件高层设计有任何的评论，可以发送你的评论到 docker-dev mailing list。项目会把每天完成的开发都更新到 Machine, Swarm 和 Compose 的GitHub仓库里去。
如果你就已经使用了一个Docker1.0之前的版本，那么你非常适合在这个时候参与这个项目。
了解更多关于Machine, Swarm and Compose的信息：
了解更多有关Docker
-
刚接触Docker? 试试我们的10分钟在线入门培训
-
用一个免费的Docker Hub账号，分享images,automate builds和更多
-
阅读Docker Engine 1.5发布说明
-
参加即将开始的Docker会议
-
报名参加DockerCon 2015
本文地址：https://www.oschina.net/translate/orchestrating-docker-with-machine-swarm-and-compose
原文地址：https://blog.docker.com/2015/02/orchestrating-docker-with-machine-swarm-and-compose/
扫一扫
1296
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
