devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

docker三剑客docker-compose、docker-machine、swarm

作者：凡人多烦事01 | 2024-05-26 12:46:19

赞

踩

docker machine docker-compose使用

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

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表示后台运行）结果如图

  1. version: '3.1'
  2.  
  3. services:
  4.   zoo1:
  5.     image: zookeeper
  6.     restart: always
  7.     hostname: zoo1
  8.     ports:
  9.       - 2181:2181
  10.     environment:
  11.       ZOO_MY_ID: 1
  12.       ZOO_SERVERS: server.1=0.0.0.0:2888:3888 server.2=zoo2:2888:3888 server.3=zoo3:2888:3888
  13.  
  14.   zoo2:
  15.     image: zookeeper
  16.     restart: always
  17.     hostname: zoo2
  18.     ports:
  19.       - 2182:2181
  20.     environment:
  21.       ZOO_MY_ID: 2
  22.       ZOO_SERVERS: server.1=zoo1:2888:3888 server.2=0.0.0.0:2888:3888 server.3=zoo3:2888:3888
  23.  
  24.   zoo3:
  25.     image: zookeeper
  26.     restart: always
  27.     hostname: zoo3
  28.     ports:
  29.       - 2183:2181
  30.     environment:
  31.       ZOO_MY_ID: 3
  32.       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

  1. $ docker swarm init --advertise-addr 192.168.99.101
  2. Swarm initialized: current node (bvz81updecsj6wjz393c09vti) is now a manager.
  3.  
  4. To add a worker to this swarm, run the following command:
  5.  
  6.     docker swarm join \
  7.     --token SWMTKN-1-3pu6hszjas19xyp7ghgosyx9k8atbfcr8p2is99znpy26u2lkl-1awxwuwd3z9j1z3puu7rcgdbx \
  8.     172.17.0.2:2377
  9.  
  10. 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服务（统计结果）等等
  1. version: "3"
  2. services:
  3.   redis:
  4.     image: redis:alpine
  5.     ports:
  6.       - "6379"
  7.     networks:
  8.       - frontend
  9.     deploy:
  10.       replicas: 2
  11.       update_config:
  12.         parallelism: 2
  13.         delay: 10s
  14.       restart_policy:
  15.         condition: on-failure
  16.   db:
  17.     image: postgres:9.4
  18.     volumes:
  19.       - db-data:/var/lib/postgresql/data
  20.     networks:
  21.       - backend
  22.     deploy:
  23.       placement:
  24.         constraints: [node.role == manager]
  25.   vote:
  26.     image: dockersamples/examplevotingapp_vote:before
  27.     ports:
  28.       - 5000:80
  29.     networks:
  30.       - frontend
  31.     depends_on:
  32.       - redis
  33.     deploy:
  34.       replicas: 2
  35.       update_config:
  36.         parallelism: 2
  37.       restart_policy:
  38.         condition: on-failure
  39.   result:
  40.     image: dockersamples/examplevotingapp_result:before
  41.     ports:
  42.       - 5001:80
  43.     networks:
  44.       - backend
  45.     depends_on:
  46.       - db
  47.     deploy:
  48.       replicas: 1
  49.       update_config:
  50.         parallelism: 2
  51.         delay: 10s
  52.       restart_policy:
  53.         condition: on-failure
  54.  
  55.   worker:
  56.     image: dockersamples/examplevotingapp_worker
  57.     networks:
  58.       - frontend
  59.       - backend
  60.     deploy:
  61.       mode: replicated
  62.       replicas: 1
  63.       labels: [APP=VOTING]
  64.       restart_policy:
  65.         condition: on-failure
  66.         delay: 10s
  67.         max_attempts: 3
  68.         window: 120s
  69.       placement:
  70.         constraints: [node.role == manager]
  71.  
  72.   visualizer:
  73.     image: dockersamples/visualizer
  74.     ports:
  75.       - "8080:8080"
  76.     stop_grace_period: 1m30s
  77.     volumes:
  78.       - /var/run/docker.sock:/var/run/docker.sock
  79.     deploy:
  80.       placement:
  81.         constraints: [node.role == manager]
  82.  
  83. networks:
  84.   frontend:
  85.   backend:
  86.  
  87. volumes:
  88.   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安装布署

  1. [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
  2.   % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
  3.                                  Dload  Upload   Total   Spent    Left  Speed
  4. 100   617    0   617    0     0    396      0 --:--:--  0:00:01 --:--:--   397
  5. 100 10.3M  100 10.3M    0     0   678k      0  0:00:15  0:00:15 --:--:-- 1876k
  6. [root@docker ~]# chmod +x /usr/local/bin/docker-compose 
  7. [root@docker ~]# docker-compose --version
  8. docker-compose version 1.21.2, build a133471

docker-compose管理命令介绍

Compose具有管理应用程序整个生命周期的命令：
  • 启动，停止和重建服务
  • 查看正在运行的服务的状态
  • 流式传输运行服务的日志输出
  • 在服务上运行一次性命令
  1. [root@docker ~]# docker-compose --help
  2. Define and run multi-container applications with Docker.
  3.  
  4. Usage:
  5.   docker-compose [-f <arg>...] [options] [COMMAND] [ARGS...]
  6.   docker-compose -h|--help
  7.  
  8. Options:
  9.   -f, --file FILE             Specify an alternate compose file
  10.                               (default: docker-compose.yml)
  11.   -p, --project-name NAME     Specify an alternate project name
  12.                               (default: directory name)
  13.   --verbose                   Show more output
  14.   --log-level LEVEL           Set log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
  15.   --no-ansi                   Do not print ANSI control characters
  16.   -v, --version               Print version and exit
  17.   -H, --host HOST             Daemon socket to connect to
  18.  
  19.   --tls                       Use TLS; implied by --tlsverify
  20.   --tlscacert CA_PATH         Trust certs signed only by this CA
  21.   --tlscert CLIENT_CERT_PATH  Path to TLS certificate file
  22.   --tlskey TLS_KEY_PATH       Path to TLS key file
  23.   --tlsverify                 Use TLS and verify the remote
  24.   --skip-hostname-check       Don't check the daemon's hostname against the
  25.                               name specified in the client certificate
  26.   --project-directory PATH    Specify an alternate working directory
  27.                               (default: the path of the Compose file)
  28.   --compatibility             If set, Compose will attempt to convert deploy
  29.                               keys in v3 files to their non-Swarm equivalent
  30.  
  31. Commands:
  32.   build              Build or rebuild services
  33.   bundle             Generate a Docker bundle from the Compose file
  34.   config             Validate and view the Compose file
  35.   create             Create services
  36.   down               Stop and remove containers, networks, images, and volumes
  37.   events             Receive real time events from containers
  38.   exec               Execute a command in a running container
  39.   help               Get help on a command
  40.   images             List images
  41.   kill               Kill containers
  42.   logs               View output from containers
  43.   pause              Pause services
  44.   port               Print the public port for a port binding
  45.   ps                 List containers
  46.   pull               Pull service images
  47.   push               Push service images
  48.   restart            Restart services
  49.   rm                 Remove stopped containers
  50.   run                Run a one-off command
  51.   scale              Set number of containers for a service
  52.   start              Start services
  53.   stop               Stop services
  54.   top                Display the running processes
  55.   unpause            Unpause services
  56.   up                 Create and start containers
  57.   version            Show the Docker-Compose version information

docker-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
指定某个服务启动的容器个数

  1. [root@docker ~]# docker-compose scale --help
  2. Numbers are specified in the form `service=num` as arguments.
  3. For example:
  4.  
  5.     $ docker-compose scale web=2 worker=3
  6.  
  7. This command is deprecated. Use the up command with the `--scale` flag
  8. instead.
  9.  
  10. Usage: scale [options] [SERVICE=NUM...]
  11.  
  12. Options:
  13.   -t, --timeout TIMEOUT      Specify a shutdown timeout in seconds.
  14.                              (default: 10)

docker-compose配置文件实例

一个docker-compose.yml的实例文件如下

  1. version: "3"
  2. services:
  3.   nginx:
  4.     container_name: web-nginx
  5.     image: nginx:latest
  6.     restart: always
  7.     ports:
  8.       - 80:80
  9.     volumes:
  10.     - ./webserver:/webserver
  11.     - ./nginx/nginx.conf:/etc/nginx/nginx.conf

下面将配置文件做个简单的解释说明

  1. docker-compose的配置文件是一个.yml格式的文件
  2. 第一部分
  3. version: "3"  #指定语法的版本
  4. 第二部分
  5. services:     #定义服务
  6.   nginx:      #服务的名称，-p参数后接服务名称
  7.     container_name: web-nginx    #容器的名称
  8.     image: nginx:latest          #镜像
  9.     restart: always
  10.     ports:                       #端口映射
  11.       - 80:80
  12. 第三部分
  13. volumes:       #物理机与容器的磁盘映射关系
  14.     - ./webserver:/webserver
  15.     - ./nginx/nginx.conf:/etc/nginx/nginx.conf

整体的目录结构如下

  1. [root@docker docker]# tree ./
  2. ./
  3. ├── docker-compose.yml
  4. ├── nginx
  5. │?? └── nginx.conf
  6. └── webserver
  7.     └── index.html
  8.  
  9. 2 directories, 3 files

配置文件如下

  1. [root@docker docker]# cat webserver/index.html 
  2. welcome to nginx server!!!!!!!!!
  3. [root@docker docker]# cat nginx/nginx.conf
  4. #user  nginx;
  5. worker_processes  1;
  6. error_log  /var/log/nginx/error.log warn;
  7. pid        /var/run/nginx.pid;
  8.  
  9. events {
  10.     worker_connections  1024;
  11. }
  12.  
  13. http {
  14.     include       /etc/nginx/mime.types;
  15.     default_type  application/octet-stream;
  16.  
  17.     log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
  18.                       '$status $body_bytes_sent "$http_referer" '
  19.                       '"$http_user_agent" "$http_x_forwarded_for"';
  20.  
  21.     access_log  /var/log/nginx/access.log  main;
  22.     client_max_body_size 10m;  
  23.     sendfile        on;
  24.     #tcp_nopush     on;
  25.  
  26.     keepalive_timeout  65;
  27.  
  28.     #gzip  on;
  29.  
  30. server {
  31.     listen       80;
  32.     server_name  localhost;
  33.  
  34.     location / {
  35.         root   /webserver;
  36.         index  index.html index.htm;
  37.     }
  38.  
  39. }
  40.     include /etc/nginx/conf.d/*.conf;
  41. }

使用命令启动容器

  1. [root@docker docker]# docker-compose up -d
  2. Pulling nginx (nginx:1.14)...
  3. Trying to pull repository docker.io/library/nginx ... 
  4. 1.14: Pulling from docker.io/library/nginx
  5. f2aa67a397c4: Already exists
  6. 6160d1ac49e9: Pull complete
  7. 046b67408776: Pull complete
  8. Digest: sha256:85ab7c44474df01422fe8fdbf9c28e497df427e8a67ce6d47ba027c49be4bdc6
  9. Status: Downloaded newer image for docker.io/nginx:1.14
  10. Creating nginx-server ... done
  11. [root@docker docker]# lsof -i :80
  12. COMMAND   PID USER   FD   TYPE  DEVICE SIZE/OFF NODE NAME
  13. docker-pr 891 root    4u  IPv6 1187080      0t0  TCP *:http (LISTEN)
  14. [root@docker docker]# docker ps |grep nginx
  15. 07ca899cc44b   nginx:1.14   "nginx -g 'daemon ..."   29 seconds ago  Up 28 seconds  0.0.0.0:80->80/tcp  nginx-server
  16. #如果启动时不指定里面的服务名称，就是直接启动配置文件里所有的服务

浏览器测试是否正常访问
容器技术｜Docker三剑客之docker-compose
然后我们修改相应的首页文件如下

  1. [root@docker docker]# cat webserver/index.html 
  2. <!DOCTYPE html>
  3. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <title>welcome to nginx web stie</title>
  7. </head>
  8. <body>
  9.    <h2>欢迎来nginx站点</h2>
  10. </body>
  11. </html>

再次打开浏览器查看效果
容器技术｜Docker三剑客之docker-compose
#是不是非常的方便

使用Docker-Compose部署nginx代理Tomcat集群,实现负载均衡

大体步骤分为以下四步

1、下载所需的文件tomcat,jdk
2、编写dockerfile来布署tomcat与java环境，生成镜像文件
3、编写docker-compose.yml配置文件，启动所有容器服务
4、测试负载均衡

具体配置文件如下

  1. #整个目录结构
  2. [root@master java]# tree ./
  3. ./
  4. ├── docker-compose.yml
  5. ├── etc
  6. │   └── localtime
  7. ├── nginx
  8. │   └── nginx.conf
  9. ├── tomcat
  10. │   ├── apache-tomcat-8.5.31.tar.gz
  11. │   ├── Dockerfile
  12. │   └── jdk-8u144-linux-x64.tar.gz
  13. └── webserver
  14.     ├── tomcatA
  15.     │   └── index.jsp
  16.     └── tomcatB
  17.         └── index.jsp
  18.  
  19. 6 directories, 8 files

两个测试首页文件

  1. [root@master java]# cat webserver/tomcatA/index.jsp 
  2. welcome to tomcat-A server
  3. [root@master java]# cat webserver/tomcatB/index.jsp 
  4. welcome to tomcat-B server

配置文件

  1. [root@master java]# cat docker-compose.yml 
  2. version: "3"
  3. services:
  4.   nginx:
  5.     image: nginx:1.14
  6.     restart: always
  7.     ports:
  8.       - 80:80
  9.     links:
  10.       - tomcat1:tomcat1
  11.       - tomcat2:tomcat2
  12.     volumes:
  13.       - ./webserver:/webserver
  14.       - ./nginx/nginx.conf:/etc/nginx/nginx.conf
  15.       - ./etc/localtime:/etc/localtime
  16.     depends_on:
  17.       - tomcat1
  18.       - tomcat2
  19.  
  20.   tomcat1:
  21.     hostname: tomcat1
  22.     build: ./tomcat
  23.     volumes:
  24.       - ./webserver/tomcatA:/usr/local/apache-tomcat-8.5.31/webapps/ROOT
  25.       - ./etc/localtime:/etc/localtime
  26.  
  27.   tomcat2:
  28.     hostname: tomcat2
  29.     build: ./tomcat
  30.     volumes:
  31.       - ./webserver/tomcatB:/usr/local/apache-tomcat-8.5.31/webapps/ROOT
  32.       - ./etc/localtime:/etc/localtime

安装JAVA环境

  1. [root@master java]# cat tomcat/Dockerfile 
  2. FROM centos
  3.  
  4. ADD jdk-8u144-linux-x64.tar.gz /usr/local
  5. ENV JAVA_HOME /usr/local/jdk1.8.0_144
  6. ADD apache-tomcat-8.5.31.tar.gz /usr/local
  7.  
  8. EXPOSE 8080
  9. ENTRYPOINT ["/usr/local/apache-tomcat-8.5.31/bin/catalina.sh", "run"]

启动所有容器服务

  1. [root@master java]# docker-compose up
  2. Building tomcat1
  3. Step 1/6 : FROM centos
  4. Trying to pull repository docker.io/library/centos ... 
  5. latest: Pulling from docker.io/library/centos
  6. 7dc0dca2b151: Pull complete
  7. Digest: sha256:b67d21dfe609ddacf404589e04631d90a342921e81c40aeaf3391f6717fa5322
  8. Status: Downloaded newer image for docker.io/centos:latest
  9.  ---> 49f7960eb7e4
  10. Step 2/6 : ADD jdk-8u144-linux-x64.tar.gz /usr/local
  11.  ---> 8c9e14062a24
  12. Removing intermediate container a499940235ac
  13. Step 3/6 : ENV JAVA_HOME /usr/local/jdk1.8.0_144
  14.  ---> Running in cefedfd97f61
  15.  ---> 12528cd5a517
  16. Removing intermediate container cefedfd97f61
  17. Step 4/6 : ADD apache-tomcat-8.5.31.tar.gz /usr/local
  18.  ---> 246fa08bea1c
  19. Removing intermediate container a1aaaa2bf0b8
  20. Step 5/6 : EXPOSE 8080
  21.  ---> Running in 87c4b41f3c1e
  22.  ---> fd207f27b830
  23. Removing intermediate container 87c4b41f3c1e
  24. Step 6/6 : ENTRYPOINT /usr/local/apache-tomcat-8.5.31/bin/catalina.sh run
  25.  ---> Running in 9adaed8e3ab9
  26.  ---> b6fc6d3925f7
  27. Removing intermediate container 9adaed8e3ab9
  28. Successfully built b6fc6d3925f7
  29. 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`.
  30. Building tomcat2
  31. Step 1/6 : FROM centos
  32.  ---> 49f7960eb7e4
  33. Step 2/6 : ADD jdk-8u144-linux-x64.tar.gz /usr/local
  34.  ---> Using cache
  35.  ---> 8c9e14062a24
  36. Step 3/6 : ENV JAVA_HOME /usr/local/jdk1.8.0_144
  37.  ---> Using cache
  38.  ---> 12528cd5a517
  39. Step 4/6 : ADD apache-tomcat-8.5.31.tar.gz /usr/local
  40.  ---> Using cache
  41.  ---> 246fa08bea1c
  42. Step 5/6 : EXPOSE 8080
  43.  ---> Using cache
  44.  ---> fd207f27b830
  45. Step 6/6 : ENTRYPOINT /usr/local/apache-tomcat-8.5.31/bin/catalina.sh run
  46.  ---> Using cache
  47.  ---> b6fc6d3925f7
  48. Successfully built b6fc6d3925f7
  49. 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`.
  50. Pulling nginx (nginx:1.14)...
  51. Trying to pull repository docker.io/library/nginx ... 
  52. 1.14: Pulling from docker.io/library/nginx
  53. f2aa67a397c4: Already exists
  54. 6160d1ac49e9: Pull complete
  55. 046b67408776: Pull complete
  56. Digest: sha256:85ab7c44474df01422fe8fdbf9c28e497df427e8a67ce6d47ba027c49be4bdc6
  57. Status: Downloaded newer image for docker.io/nginx:1.14
  58. Creating java_tomcat2_1 ... done
  59. Creating java_tomcat1_1 ... done
  60. Creating java_nginx_1   ... done

查看启动情况

  1. [root@master java]# docker-compose ps
  2.      Name                   Command               State         Ports       
  3. ----------------------------------------------------------------------------
  4. java_nginx_1     nginx -g daemon off;             Up      0.0.0.0:80->80/tcp
  5. java_tomcat1_1   /usr/local/apache-tomcat-8 ...   Up      8080/tcp          
  6. java_tomcat2_1   /usr/local/apache-tomcat-8 ...   Up      8080/tcp

检测负载均衡

  1. [root@master java]# curl http://localhost
  2. welcome to tomcat-A server
  3. [root@master java]# curl http://localhost
  4. welcome to tomcat-B server
  5. [root@master java]# curl http://localhost
  6. welcome to tomcat-A server
  7. [root@master java]# curl http://localhost
  8. welcome to tomcat-B server

浏览器访问测试负载均衡

容器技术｜Docker三剑客之docker-compose

查看日志输出信息

  1. 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" "-"
  2. 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" "-"
  3. 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" "-"
  4. 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" "-"
  5. 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" "-"
  6. 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" "-"
  7. 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" "-"
  8. 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" "-"
  9. 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" "-"
  10. 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" "-"
  11. 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" "-"
  12. 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" "-"
  13. 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" "-"
  14. 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" "-"
  15. 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" "-"
  16. 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" "-"
  17. nginx_1    | 172.19.0.1 - - [08/Jun/2018:02:18:30 +0000] "GET / HTTP/1.1" 200 27 "-" "curl/7.29.0" "-"
  18. nginx_1    | 172.19.0.1 - - [08/Jun/2018:02:18:31 +0000] "GET / HTTP/1.1" 200 27 "-" "curl/7.29.0" "-"
  19. nginx_1    | 172.19.0.1 - - [08/Jun/2018:02:18:32 +0000] "GET / HTTP/1.1" 200 27 "-" "curl/7.29.0" "-"
  20. nginx_1    | 172.19.0.1 - - [08/Jun/2018:02:18:33 +0000] "GET / HTTP/1.1" 200 27 "-" "curl/7.29.0" "-"
  21. 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" "-"

容器技术｜Docker三剑客之docker-compose

CentOS7安装最新版Docker、compose、swarm、machine

最新版 Docker 安装

  1. 1.卸载 Docker
  2. 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
  3.  
  4. 2.安装所需的包
  5. sudo yum install -y yum-utils device-mapper-persistent-data lvm2
  6.  
  7. 3.设置稳定的存储库
  8. sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
  9.  
  10. 4.可选：启用边缘和测试存储库
  11. sudo yum-config-manager --enable docker-ce-edge
  12. sudo yum-config-manager --enable docker-ce-test
  13. 禁用边缘存储库
  14. sudo yum-config-manager --disable docker-ce-edge
  15.  
  16. 5.安装最新版本的 Docker CE
  17. sudo yum install docker-ce
  18.  
  19. 6.启动 Docker
  20. sudo systemctl start docker
  21.  
  22. 7.通过运行 hello-world 映像验证是否已正确安装
  23. sudo docker run hello-world

docker-compose 安装

  1. 1.下载最新版本的 Docker Compose (第一次执行提示失败，就多执行几次这个命令试试)
  2. 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
  3.  
  4. 2.对二进制文件应用可执行权限
  5. sudo chmod +x /usr/local/bin/docker-compose
  6.  
  7. 3.测试安装
  8. docker-compose --version

docker-machine 安装

  1. 1.下载 Docker Machine 二进制文件并将其解压缩到 PATH (第一次执行提示失败，就多执行几次这个命令试试)
  2. 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
  3.  
  4. 2.通过显示机器版本来检查安装
  5. docker-machine version

搭建 swarm 集群

  1. 1.新版 docker 已集成 swarm，无需单独安装
  2.  
  3. 2.使用 docker swarm init 在管理节点初始化一个 Swarm 集群
  4. docker swarm init --advertise-addr 192.168.153.150
  5. # 如果你的 Docker 主机有多个网卡，拥有多个 IP，必须使用 --advertise-addr 指定 IP
  6. # 执行 docker swarm init 命令的节点自动成为管理节点
  7.  
  8. 3.将其他主机作为 管理节点 或 工作节点 加入 swarm 集群（以下命令在待加入节点执行）
  9. docker swarm join --token [MANAGER-TOKEN||WORKER-TOKEN] [MANAGER-IP]:2377
  10. # 示例：docker swarm join --token SWMTKN-1-3pu6hszjas19xyp7ghgosyx9k8atbfcr8p2is99znpy26u2lkl-1awxwuwd3z9j1z3puu7rcgdbx 192.168.153.150:2377
  11. --------------
  12. 注意：各机器之间要开启以下通信端口 或 关闭防火墙
  13. # TCP端口2377集群管理端口
  14. # TCP与 UDP端口7946节点之间通讯端口
  15. # TCP与 UDP端口4789 overlay 网络通讯端口
  16. firewall-cmd --zone=public --add-port=2377/tcp --permanent
  17. firewall-cmd --zone=public --add-port=7946/tcp --permanent
  18. firewall-cmd --zone=public --add-port=7946/udp --permanent
  19. firewall-cmd --zone=public --add-port=4789/tcp --permanent
  20. firewall-cmd --zone=public --add-port=4789/udp --permanent
  21. firewall-cmd --reload
  22. 关闭防火墙：
  23. sudo systemctl stop firewalld.service
  24. sudo systemctl disable firewalld.service
  25. --------------
  26.  
  27. 4.在管理节点使用 docker node ls 查看集群
  28. docker node ls
  29.  
  30. 5.向集群中添加工作节点，通过以下命令获取加入集群的 WORKER-TOKEN
  31. docker swarm join-token worker
  32. 向集群中添加管理节点，通过以下命令获取加入集群的 MANAGER-TOKEN
  33. docker swarm join-token manager
  34.  
  35. 6.退出集群
  36. (1)如果是 manager 先降级为 worker 
  37. docker node demote [HOSTNAME || ID] # ID前几位即可
  38. (2)退出集群
  39. docker swarm leave
  40. (3)移除节点
  41. docker node rm [HOSTNAME || ID] # ID前几位即可
  42. # leave后该节点仍将出现在节点列表中，并将 STATUS标记为 down，已不影响 swarm操作；
  43. # 要从列表中删除非活动节点，使用 node rm 命令即可。

使用 swarm+compose 部署集群服务

  1. 1.使用 swarm+compose 部署服务
  2. docker stack deploy -c docker-compose.yml [JIQUN-NAME]
  3.  
  4. 2.查看服务
  5. docker stack ls
  6.  
  7. 3.移除服务
  8. docker stack down [JIQUN-NAME]
  9. # 该命令不会移除服务所使用的 数据卷，如果你想移除数据卷请使用 docker volume rm

其他 Docker 常用命令

  1. 查看 swarm 集群中的服务：docker service ls
  2. 查看 swarm 集群中某个服务的运行状态信息：docker service ps mwp_db
  3. 查看 swarm 集群中某个服务的基础详细信息：docker service inspect mwp_db
  4. 查看 swarm 集群中某个服务的日志：docker service logs mwp_db
  5. 从 swarm 集群中移除某个服务：docker service rm mwp_db
  6.  
  7. 搜索仓库镜像：docker search nginx
  8. 查找本地镜像：docker images nginx
  9. 查看本地镜像列表：docker images 或 docker image ls
  10. 删除本地镜像：docker rmi [IMAGE ID]
  11. 强制删除本地镜像：docker rmi -f [IMAGE ID] # 一般先停止相关容器，再 docker rmi [IMAGE ID] 正常删除镜像
  12.  
  13. 列出本机容器 container：docker ps -a 或 docker container ls
  14. 删除 container：docker rm [CONTAINER ID] 或 docker container rm [CONTAINER ID]
  15. 清理所有处于终止状态的容器：docker container prune
  16. 进入后台运行的容器 container：docker exec -it [CONTAINER_NAME || CONTAINER_ID] /bin/sh
  17. # docker exec 进入容器后 exit 不会导致容器停止
  18. 创建一个新的容器并运行：docker run --name web2 -d -p 81:80 nginx:v2
  19. 停止一个运行中的容器：docker stop [CONTAINER ID || NAMES]
  20.  
  21. 查看所有数据卷：docker volume ls
  22. 删除指定数据卷：docker volume rm [VOLUME NAME]
  23. 清理所有无主数据卷：docker volume prune
  24.  
  25. 查看 Image 或 Container 的信息：docker inspect [IMAGE || IMAGE ID || CONTAINER ID]
  26.  
  27. 查看 CentOS 系统内核版本：uname -r
  28.  
  29. 使用 Dockerfile 定制镜像：docker build -t nginx:v3 [DOCKERFILE PATH || URL]
  30. # 其中 [DOCKERFILE PATH || URL] 为 Dockerfile 文件所在目录，例：docker build -t nginx:v3 .
  31.  
  32. 更多命令可参考：http://www.runoob.com/docker/docker-command-manual.html

配置 Docker 加速器

  1. 参考：https://yeasy.gitbooks.io/docker_practice/install/mirror.html
  2. 对于使用 systemd 的系统，在 /etc/docker/daemon.json 中写入如下内容（如果文件不存在则新建该文件）
  3. {
  4.   "registry-mirrors": [
  5.     "https://registry.docker-cn.com"
  6.   ]
  7. }
  8. 之后重新启动服务。
  9. $ sudo systemctl daemon-reload
  10. $ sudo systemctl restart docker
  11. 检查加速器是否生效：docker info
  12. Registry Mirrors:
  13.  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-machine

32 位操作系统

# 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

在 VirtualBox 中使用 Docker Machine 管理主机

运行下面的命令，安装 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 Machine 管理主机

测试下有没有成功运行 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

在 VirtualBox 中使用 Docker Machine 管理主机

 

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。
567993-20170217190545582-1290314792.jpg

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里），也可以是远程的（云）。

567993-20170217190545941-813421736.png

privileged参数

 
  1.  

  2. $ docker help run

  3. ...

  4. --privileged=false Give extended privileges to this container

  5. ...

大约在0.6版，privileged被引入docker。
使用该参数，container内的root拥有真正的root权限。
否则，container内的root只是外部的一个普通用户权限。
privileged启动的容器，可以看到很多host上的设备，并且可以执行mount。
甚至允许你在docker容器中启动docker容器。

  1. 介绍：
  2.     docker compose 是 docker 官方推出的一款单机容器编排工具,
  3.         和 docker swarm, docker machine 并称为 docker 容器编排三剑客, 虽然其被 k8s 吊打,
  4.         但是由于其简单易学在中小规模的集群中还是占有相当的一部分地位的
  5.  
  6.     使用Compose的步骤：
  7.         1、定义您的应用程序环境，Dockerfile以便可以在任何地方进行复制
  8.         2、定义构成应用程序的服务，docker-compose.yml 以便它们可以在隔离环境中一起运行
  9.         3、运行 docker-compose up 和 Compose starts 运行整个应用程序
  10.  
  11. compose 的特性：
  12.     1、单个主机上的多个环境隔离
  13.     2、创建容器时保留卷数据
  14.     3、仅重新创建已更改的容器
  15.     4、变量和在环境之间移动合成
  16.  
  17. 安装：
  18.     docker compose 依赖所有的工作依赖于 docker, 在安装 compose 前请确保已在本地或远程主机中安装 docker
  19.  
  20.     二进制安装：
  21.         curl -L "https://github.com/docker/compose/releases/download/1.22.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
  22.         chmod +x /usr/local/bin/docker-compose
  23.  
  24.     pip安装：
  25.         pip install docker-compose
  26.  
  27. 一个简单的例子：
  28.     mkdir composetest && cd composetest             ＃创建一个专用目录,用于编写和保存　compose 文件
  29.     cat app.py                                      #编写一个 flask web 应用作为测试
  30.         import time
  31.         import redis
  32.         from flask import Flask
  33.  
  34.         app = Flask(__name__)
  35.         cache = redis.Redis(host='redis', port=6379)        #连接 redis
  36.  
  37.         # 定义函数
  38.         def get_hit_count():
  39.             retries = 5
  40.             while True:
  41.                 try:
  42.                     return cache.incr('hits')
  43.                 except redis.exceptions.ConnectionError as exc:
  44.                     if retries == 0:
  45.                         raise exc
  46.                     retries -= 1
  47.                     time.sleep(0.5)
  48.  
  49.         @app.route('/')
  50.         def hello():
  51.             count = get_hit_count()
  52.             # 每访问一次返回的 count 加 1
  53.             return 'Hello World! I have been seen {} times.\n'.format(count)
  54.  
  55.         if __name__ == "__main__":
  56.             #运行 web 应用
  57.             app.run(host="0.0.0.0", debug=True)
  58.  
  59.     cat Dockerfile                                          #编写docker file 文件以便 compose 可以根据 docker file 动态构建镜像
  60.         FROM python:3.4-alpine
  61.         ADD . /code
  62.         WORKDIR /code
  63.         RUN pip install flask redis
  64.         CMD ["python", "app.py"]
  65.  
  66.     cat docker-compose.yml                                  #编写 compose 文件定义容器间的关系
  67.         version: '3'
  68.         services:
  69.           web:
  70.             build: .
  71.             ports:
  72.              - "5000:5000"
  73.             volumes:
  74.              - .:/code
  75.           redis:
  76.             image: "redis:alpine"
  77.  
  78.     docker-compose up                                       #启动 docker compose 定义的 docker 集群
  79.     curl http://127.0.0.1:5000/                             #访问 Web APP
  80.  
  81.         # 示例来源
  82.     # https://docs.docker.com/compose/gettingstarted/#step-5-edit-the-compose-file-to-add-a-bind-mount    
  83.  
  84. docker-compose 命令：
  85.     介绍：
  86.         1、docker-compose 命令的执行都必须指定或者在当前目录下存在 compose 文件, 且输出的内容都是这个 compose.yml 文件定义的集群内的信息
  87.         2、每个集群中可以拥有多个 services, services 由 compose.yml 的 services 定义
  88.  
  89.     选项：
  90.         -f      指定 compose 文件路径(可以指定多个)
  91.  
  92.     子命令：
  93.         create             创建 compose 集群, 但不启动(已废弃, 使用 up --no-start 代替)
  94.         down               停止或删除容器, 网络, 镜像和数据卷
  95.         exec               运行容器中的命令或者连接容器
  96.         help               查看帮助信息
  97.         images             列出 compose 集群所用的镜像
  98.         kill               kill 掉 compose 集群
  99.         logs               获取 compose 集群日志
  100.         pause              暂停 compose 集群
  101.         ps                 列出正在运行的容器
  102.         pull               拉取 compose.yml 文件中定义的所有 docker 镜像
  103.         push               上传 compose.yml 文件中定义的所有 docker 镜像
  104.         restart            重启 compose 集群
  105.         rm                 删除一个停止的容器或者 compose 集群
  106.         run                和 exec 相同
  107.         scale              更改 compose 集群内指定的 services 的副本数量
  108.         start              启动 compose 集群
  109.         stop               停止 compose 集群
  110.         top                显示 compose 集群中运行的进程及其状态
  111.         unpause            恢复被暂停的 compose 集群
  112.         up                 创建并启动一个 compose 集群
  113.         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

本文地址：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/

 

转载于:https://my.oschina.net/hblt147/blog/3039157

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/626721
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号