document/TranslateProject
2
0
Fork 0
mirror of https://github.com/LCTT/TranslateProject.git synced 2024-12-23 21:20:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

Translated!

Browse Source 
Signed-off-by: Wenxuan Zhao <viz@linux.com>
This commit is contained in:
Wenxuan Zhao 2017-09-20 00:05:55 -03:00
parent d35c52e220
commit 171115fb95
No known key found for this signature in database
GPG Key ID: 0B45B13F10587A57
3 changed files with 236 additions and 213 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

73
Dict.md
View File

@ -14,55 +14,55 @@
### 2. ### 2.
#### B #### #### B ####
### 1. Backbone：骨干 ### 1. Backbone：骨干
>是一个网络的一部分，其作为所有网络运输的一个基本通道，其需要非常高的带宽。一个骨干网络的服务提供者连接许多企业子网和较小服务提供者的网络。一个企业骨干网络连接许多局域网和数据中心。 > 是一个网络的一部分，其作为所有网络运输的一个基本通道，其需要非常高的带宽。一个骨干网络的服务提供者连接许多企业子网和较小服务提供者的网络。一个企业骨干网络连接许多局域网和数据中心。
### 2. B channel(Bearer channel)：承载信道 ### 2. B channel(Bearer channel)：承载信道
>承载信道（Bearer Channel），也叫做B channel，是一个全双工DS0时间槽（64-kbps），其携带模拟语音或数字资料通过综合服务数字网（ISDN）。 > 承载信道（Bearer Channel），也叫做B channel，是一个全双工DS0时间槽（64-kbps），其携带模拟语音或数字资料通过综合服务数字网（ISDN）。
### 3. Backchannel：反向通道 ### 3. Backchannel：反向通道
>是指当其他实时在线会话在进行中时，习惯使用网络化的计算机来维持一个实时的在线会话。 > 是指当其他实时在线会话在进行中时，习惯使用网络化的计算机来维持一个实时的在线会话。
### 4. Back End：后台 ### 4. Back End：后台
>在一个计算机系统中，是指为一个前台作业提供服务的一个节点或软件程序。前台直接影响用户，后台可能与其他系统相连接，如数据库和其它系统。 > 在一个计算机系统中，是指为一个前台作业提供服务的一个节点或软件程序。前台直接影响用户，后台可能与其他系统相连接，如数据库和其它系统。
### 5. Back-haul：回程线路 ### 5. Back-haul：回程线路
>是一个通信信道，它使携带信息流到远于最终目的地的地方，然后将它送回。这样做是因为传输到更远的远程区域的代价要远比直接发送的代价低地多。 > 是一个通信信道，它使携带信息流到远于最终目的地的地方，然后将它送回。这样做是因为传输到更远的远程区域的代价要远比直接发送的代价低地多。
### 6. Backoff：退避 ### 6. Backoff：退避
>是指当一个主机已经在有MAC 协议的网络中经历了一个冲突之后试图去重发之前的等待时期。这个退避时间通常是任意的来最小化相同节点再次冲突的可能性。在每次冲突后增加退避时期也能帮助预防重复碰撞，特别当这个网络负担很重时。 > 是指当一个主机已经在有MAC 协议的网络中经历了一个冲突之后试图去重发之前的等待时期。这个退避时间通常是任意的来最小化相同节点再次冲突的可能性。在每次冲突后增加退避时期也能帮助预防重复碰撞，特别当这个网络负担很重时。
### 7. Backplane：附加卡 ### 7. Backplane：附加卡
>在许多网络中是一个物理接口模块，例如，连接在一个界面处理器或卡和在一个总线机箱内数据总线和功率分配总线之间的一个路由器或转换器。 > 在许多网络中是一个物理接口模块，例如，连接在一个界面处理器或卡和在一个总线机箱内数据总线和功率分配总线之间的一个路由器或转换器。
### 8. Back Pressure：背压 ### 8. Back Pressure：背压
>在计算机系统中，是指网络拥塞信息逆流通过一个Internet网络。 > 在计算机系统中，是指网络拥塞信息逆流通过一个Internet网络。
### 9. Balun(balanced-unbalanced)：不平衡变压器 ### 9. Balun(balanced-unbalanced)：不平衡变压器
>意味着平衡-非平衡。不平衡变压器是一个设计用来转换平衡和不平衡之间的电信号的设备。 > 意味着平衡-非平衡。不平衡变压器是一个设计用来转换平衡和不平衡之间的电信号的设备。
### 10. Baseband：基带 ### 10. Baseband：基带
>是一种类型的网络技术,在那里仅仅一种载波频率被使用。在一个基带网中，信息在传送介质中以数字的形式被携带在一个单一的多元信号通道中。 > 是一种类型的网络技术,在那里仅仅一种载波频率被使用。在一个基带网中，信息在传送介质中以数字的形式被携带在一个单一的多元信号通道中。
### 11. Bastion Host：防御主机 ### 11. Bastion Host：防御主机
>是在内部网络和外部网络之间的一个网关，它被设计来防御针对内部网络的攻击。这个系统在非武装区(DMZ)的公共一边，不被防火墙或过滤路由器保护，它对攻击是完全暴露的。 > 是在内部网络和外部网络之间的一个网关，它被设计来防御针对内部网络的攻击。这个系统在非武装区(DMZ)的公共一边，不被防火墙或过滤路由器保护，它对攻击是完全暴露的。
### 12: Bc(Committed Burst)：约定资讯讯务 ### 12: Bc(Committed Burst)：约定资讯讯务
>是一个用在帧中继系统的术语，是一个帧中继交互网约定接受和传输和通过一个帧中继网络数据链路控制（DLC）和一个特殊的时帧的最大数据量（用比特表示）。 > 是一个用在帧中继系统的术语，是一个帧中继交互网约定接受和传输和通过一个帧中继网络数据链路控制（DLC）和一个特殊的时帧的最大数据量（用比特表示）。
### 13. BCP(Best Current Practices)：最优现行方法 ### 13. BCP(Best Current Practices)：最优现行方法
>是副系列的IETF RFCs，其被用于描述在Internet上的最优配置技术。 > 是副系列的IETF RFCs，其被用于描述在Internet上的最优配置技术。
### 14. BCU(Balanced Configuration Unit)：平衡配置单元 ### 14. BCU(Balanced Configuration Unit)：平衡配置单元
>是一个综合的IBM解决方法，它由软件和硬件组成。BCUs是综合的和测试作为数据仓库系统的预配置功能块。 > 是一个综合的IBM解决方法，它由软件和硬件组成。BCUs是综合的和测试作为数据仓库系统的预配置功能块。
### 15. BECN(Backward Explicit Congestion Notification)：显式拥塞通知 ### 15. BECN(Backward Explicit Congestion Notification)：显式拥塞通知
>是在帧中继报头的一个1比特域，其发信号到任何接收帧的事物（转换器和数据终端设备），拥塞就发生在帧的反面（后面）。帧中继转换器和数据终端设备可能遵照显式拥塞通知位来减慢那个方向的数据传输率。 > 是在帧中继报头的一个1比特域，其发信号到任何接收帧的事物（转换器和数据终端设备），拥塞就发生在帧的反面（后面）。帧中继转换器和数据终端设备可能遵照显式拥塞通知位来减慢那个方向的数据传输率。
### 16. BER(Bit Error Rate)：误码率 ### 16. BER(Bit Error Rate)：误码率
>是接收到的位包含错误的比率。BER通常被表示成十足的负面力量。 > 是接收到的位包含错误的比率。BER通常被表示成十足的负面力量。
### 17. BIP(Bit Interleaved Parity)：位交叉奇偶校验 ### 17. BIP(Bit Interleaved Parity)：位交叉奇偶校验
>一个用在ATM中的术语，是一个通常用来检测链接错误的一种方法。一个检测位或字被嵌入到以前发生阻塞或帧的链接中。位错误在有效载荷中能够作为维护信息被删除和报告。 > 一个用在ATM中的术语，是一个通常用来检测链接错误的一种方法。一个检测位或字被嵌入到以前发生阻塞或帧的链接中。位错误在有效载荷中能够作为维护信息被删除和报告。
#### C #### #### C ####
@ -90,66 +90,71 @@
> 指 Linux 内核的 live patch 支持。 > 指 Linux 内核的 live patch 支持。
### 2. LTS(Long Term Support)：长期支持 ### 2. LTS(Long Term Support)：长期支持
>该缩写词多见于操作系统发行版或者软件发行版名称中，表明该版本属于长期支持版。 > 该缩写词多见于操作系统发行版或者软件发行版名称中，表明该版本属于长期支持版。
#### M #### #### M ####
#### N #### #### N ####
#### O #### #### O ####
### 1. Orchestration：编排
> 描述复杂计算机系统、中间件（middleware）和业务的自动化的安排、协调和管理（来自维基百科）。
#### P #### #### P ####
### 1.P-code(Pseudo-code)：伪代码语言 ### 1. P-code(Pseudo-code)：伪代码语言
>一种解释型语言，执行方式介于编译型语言和解释型语言之间。和解释型语言一样，伪代码编程语言无需编译，在执行时自动转换成二进制形式。然而，和编译型语言不同的是，这种可执行的二进制文件是以伪代码的形式而不是机器语言的形式存储的。伪代码语言的例子有 Java、Python 和 REXX/Object REXX。 > 一种解释型语言，执行方式介于编译型语言和解释型语言之间。和解释型语言一样，伪代码编程语言无需编译，在执行时自动转换成二进制形式。然而，和编译型语言不同的是，这种可执行的二进制文件是以伪代码的形式而不是机器语言的形式存储的。伪代码语言的例子有 Java、Python 和 REXX/Object REXX。
### 2. PAM(Pluggable Authentication Modules)：可插拔认证模块 ### 2. PAM(Pluggable Authentication Modules)：可插拔认证模块
>用于系统安全性的可替换的用户认证模块，它允许在不知道将使用何种认证方案的情况下进行编程。这允许将来用其它模块来替换某个模块，却无需重写软件。 > 用于系统安全性的可替换的用户认证模块，它允许在不知道将使用何种认证方案的情况下进行编程。这允许将来用其它模块来替换某个模块，却无需重写软件。
### 3. Port/Ported/Porting：移植 ### 3. Port/Ported/Porting：移植
>一个过程，即获取为某个操作系统平台编写的程序，并对其进行修改使之能在另一 OS 上运行，并且具有类似的功能。 > 一个过程，即获取为某个操作系统平台编写的程序，并对其进行修改使之能在另一 OS 上运行，并且具有类似的功能。
### 4. POSIX(Portable Operating System Interface for uniX)：UNIX 可移植操作系统接口 ### 4. POSIX(Portable Operating System Interface for uniX)：UNIX 可移植操作系统接口
>一组编程接口标准，它们规定如何编写应用程序源代码以便应用程序可在操作系统之间移植。POSIX 基于 UNIX，它是 The Open Group 的 X/Open 规范的基础。 > 一组编程接口标准，它们规定如何编写应用程序源代码以便应用程序可在操作系统之间移植。POSIX 基于 UNIX，它是 The Open Group 的 X/Open 规范的基础。
#### Q #### #### Q ####
#### R #### #### R ####
### 1. RCS(Revision Control System)：修订控制系统 ### 1. RCS(Revision Control System)：修订控制系统
>一组程序，它们控制组环境下文件的共享访问并跟踪文本文件的变化。常用于维护源代码模块的编码工作。 > 一组程序，它们控制组环境下文件的共享访问并跟踪文本文件的变化。常用于维护源代码模块的编码工作。
### 2. RFS(Remote File Sharing)：远程文件共享 ### 2. RFS(Remote File Sharing)：远程文件共享
>一个程序，它让用户访问其它计算机上的文件，就好象文件在用户的系统上一样。 > 一个程序，它让用户访问其它计算机上的文件，就好象文件在用户的系统上一样。
#### S #### #### S ####
### 1. shebang [ʃɪ'bæŋ]：释伴 ### 1. shebang [ʃɪ'bæŋ]：释伴
>Shebang（也称为Hashbang）是一个由井号和叹号构成的字符序列（#!），出现在文本文件的第一行的前两个字符，后跟解释器路径，如：#!/bin/sh，这通常是Linux中shell脚本的标准起始行。 > Shebang（也称为Hashbang）是一个由井号和叹号构成的字符序列（#!），出现在文本文件的第一行的前两个字符，后跟解释器路径，如：#!/bin/sh，这通常是Linux中shell脚本的标准起始行。
>长期以来，shebang都没有正式的中文名称。Linux中国翻译组将其翻译为：释伴，即解释伴随行的简称，同时又是shebang的音译。 > 长期以来，shebang都没有正式的中文名称。Linux中国翻译组将其翻译为：释伴，即解释伴随行的简称，同时又是shebang的音译。
### 2. Spool(Simultaneous Peripheral Operation On-Line)：假脱机 ### 2. Spool(Simultaneous Peripheral Operation On-Line)：假脱机
>将数据发送给一个程序，该程序将该数据信息放入队列以备将来使用（例如，打印假脱机程序） > 将数据发送给一个程序，该程序将该数据信息放入队列以备将来使用（例如，打印假脱机程序）
### 2. Steganography：隐写术 ### 2. Steganography：隐写术
>将一段信息隐藏在另一段信息中的做法。一个示例是在数字化照片中放置不可见的数字水印。 > 将一段信息隐藏在另一段信息中的做法。一个示例是在数字化照片中放置不可见的数字水印。
### 3. Swap：交换 ### 3. Swap：交换
>暂时将数据（程序和／或数据文件）从随机存取存储器移到磁盘存储器（换出），或反方向移动（换入），以允许处理比物理内存所能容纳的更多的程序和数据。 > 暂时将数据（程序和／或数据文件）从随机存取存储器移到磁盘存储器（换出），或反方向移动（换入），以允许处理比物理内存所能容纳的更多的程序和数据。
### 4. Scheduling：调度
> 将任务分配至资源的过程，在计算机或生产处理中尤为重要（来自维基百科）。
#### T #### #### T ####
### 1. Time-sharing：分时 ### 1. Time-sharing：分时
>一种允许多个用户分享处理器的方法，它以时间为基础给每个用户分配一部分处理器资源，按照这些时间段轮流运行每个用户的进程。 > 一种允许多个用户分享处理器的方法，它以时间为基础给每个用户分配一部分处理器资源，按照这些时间段轮流运行每个用户的进程。
### 2. TL;DR:长篇摘要 ### 2. TL;DR:长篇摘要
>Too Long；Didn't Read的缩写词，即太长，未阅的意思。该词多见于互联网社区论坛中，用于指出该文太长，没有阅读，或者标示出一篇长文章的摘要。在论坛回复中，该缩写词也多作为灌水用。因此，Linux中国翻译组将其翻译为：长篇摘要。 > Too Long；Didn't Read的缩写词，即太长，未阅的意思。该词多见于互联网社区论坛中，用于指出该文太长，没有阅读，或者标示出一篇长文章的摘要。在论坛回复中，该缩写词也多作为灌水用。因此，Linux中国翻译组将其翻译为：长篇摘要。
#### U #### #### U ####
#### V #### #### V ####
### 1. VRML(Virtual Reality Modeling Language)：虚拟现实建模语言 ### 1. VRML(Virtual Reality Modeling Language)：虚拟现实建模语言
>一种主要基于 Web 的语言，用于 3D 效果（如构建遍历）。 > 一种主要基于 Web 的语言，用于 3D 效果（如构建遍历）。
#### W #### #### W ####
### 1. Wrapper：封装器 ### 1. Wrapper：封装器
>用于启动另一个程序的程序。 > 用于启动另一个程序的程序。
#### X #### #### X ####

178
sources/tech/20161005 Docker Engine swarm mode - Intro tutorial.md
View File

@ -1,178 +0,0 @@
# Viz 翻译中……
Docker Engine swarm mode - Intro tutorial
============================
Sounds like a punk rock band. But it is the brand new orchestration mechanism, or rather, an improvement of the orchestration available in [Docker][1]. To keep it short and sweet, if you are using an older version of Docker, you will manually need to setup Swarm to create Docker clusters. Starting with [version 1.12][2], the Docker engine comes with a native implementation allowing a seamless clustering setup. The reason why we are here.
In this tutorial, I will try to give you a taste of what Docker can do when it comes to orchestration. This article is by no means all inclusive (bed & breakfast) or all-knowing, but it has what it takes to embark you on your clustering journey. After me.
![Teaser](http://www.dedoimedo.com/images/computers-years/2016-2/docker-swarm-teaser.jpg)
### Technology overview
It would be a shame for me to rehash the very detailed and highly useful Docker documentation article, so I will just outline a brief overview of the technology. So we have Docker, right. Now, you want to use more than a single server as a Docker host, but you want them to belong to the same logical entity. Hence, clustering.
Let's start by a cluster of one. When you initiate swarm on a host, it becomes a manager of the cluster. Technically speaking, it becomes a consensus group of one node. The mathematical logic behind is based on the [Raft][3] algorithm. The manager is responsible for scheduling tasks. The tasks will be delegated to worker nodes, once and if they join the swarm. This is governed by the Node API. I hate the word API, but I must use it here.
The Service API is the second component of this implementation. It allows manager nodes to create distributed services on all of the nodes in the swarm. The services can be replicated, meaning they are spread across the cluster using balancing mechanisms, or they can be global, meaning an instance of the service will be running on each node.
There's much more at work here, but this is good enough to get you primed and pumped. Now, let's do some actual hands-on stuff. Our target platform is [CentOS 7.2][4], which is quite interesting, because at the time I wrote this tutorial, it only had Docker 1.10 in the repos, and I had to manually upgrade the framework to use swarm. We will discuss this in a separate tutorial. Then, we will also have a follow-up guide, where we will join new nodes into our cluster, and we will try an asymmetric setup with [Fedora][5]. At this point, please assume the correct setup is in place, and let's get a cluster service up and running.
### Setup image & service
I will try to setup a load-balanced [Apache][6] service, with multiple instances serving content via a single IP address. Pretty standard. It also highlights the typical reasons why you would go with a cluster configuration - availability, redundancy, horizontal scaling, and performance. Of course, you also need to take into consideration the [networking][7] piece, as well as [storage][8], but that's something that goes beyond the immediate scope of this guide.
The actual Dockerfile template is available in the official repository under httpd. You will need a minimal setup to get underway. The details on how to download images, how to create your own and such are available in my intro guide, linked at the beginning of this tutorial.
docker build -t my-apache2 .
Sending build context to Docker daemon 2.048 kB
Step 1 : FROM httpd:2.4
Trying to pull repository docker.io/library/httpd ...
2.4: Pulling from docker.io/library/httpd
8ad8b3f87b37: Pull complete
c95e1f92326d: Pull complete
96e8046a7a4e: Pull complete
00a0d292c371: Pull complete
3f7586acab34: Pull complete
Digest: sha256:3ad4d7c4f1815bd1c16788a57f81b413...a915e50a0d3a4
Status: Downloaded newer image for docker.io/httpd:2.4
 ---> fe3336dd034d
Step 2 : COPY ../public-html/ /usr/local/apache2/htdocs/
...
![Image created](http://www.dedoimedo.com/images/computers-years/2016-2/docker-swarm-image-created.png)
Before you go any further, you should start a single instance and see that your container is created without any errors and that you can connect to the Web server. Once we establish that, we will create a distributed service.
docker run -dit --name my-running-app my-apache2
Check the IP address, punch into a browser, see what gives.
### Swarm initiation and setup
The next step is to get swarm going. Here's the most basic of commands that will get you underway, and it is very similar to the example used in the Docker blog:
docker service create --name frontend --replicas 5 -p 80:80/tcp my-apache2:latest
What do we have here? We are creating a service called frontend, with five container instances. We are also binding our hostPort 80 with the containerPort 80. And we are using my freshly created Apache image for this. However, when you do this, you will get the following error:
docker service create --name frontend --replicas 5 -p 80:80/tcp my-apache2:latest
Error response from daemon: This node is not a swarm manager. Use "docker swarm init" or "docker swarm join" to connect this node to swarm and try again.
This means you have not setup the current host (node) to be a swarm manager. You either need to init the swarm or join an existing one. Since we do not have one yet, we will now initialize it:
docker swarm init
Swarm initialized: current node (dm58mmsczqemiikazbfyfwqpd) is now a manager.
To add a worker to this swarm, run the following command:
docker swarm join \
--token SWMTKN-1-4ofd46a2nfyvrqwu8w5oeetukrbylyznxla
9srf9vxkxysj4p8-eu5d68pu5f1ci66s7w4wjps1u \
10.0.2.15:2377
To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.
The output is fairly self explanatory. We have created a swarm. New nodes will need to use the correct token to join the swarm. You also have the IP address and port identified, if you require firewall rules. Moreover, you can add managers to the swarm, too. Now, rerun the service create command:
docker service create --name frontend --replicas 5 -p 80:80/tcp my-apache2:latest
6lrx1vhxsar2i50is8arh4ud1
### Test connectivity
Now, let's check that our service actually works. In a way, this is similar to what we did with [Vagrant][9] and [coreOS][10]. After all, the concepts are almost identical. It's just different implementation of the same idea. First, docker ps should show the right output. You should have multiple replicas for the created service.
docker ps
CONTAINER ID        IMAGE               COMMAND              CREATED             STATUS              PORTS              
NAMES
cda532f67d55        my-apache2:latest   "httpd-foreground"  
2 minutes ago       Up 2 minutes        80/tcp              frontend.1.2sobjfchdyucschtu2xw6ms9a
75fe6e0aa77b        my-apache2:latest   "httpd-foreground"  
2 minutes ago       Up 2 minutes        80/tcp              frontend.4.ag77qtdeby9fyvif5v6c4zcpc
3ce824d3151f        my-apache2:latest   "httpd-foreground"  
2 minutes ago       Up 2 minutes        80/tcp              frontend.2.b6fqg6sf4hkeqs86ps4zjyq65
eda01569181d        my-apache2:latest   "httpd-foreground"  
2 minutes ago       Up 2 minutes        80/tcp              frontend.5.0rmei3zeeh8usagg7fn3olsp4
497ef904e381        my-apache2:latest   "httpd-foreground"  
2 minutes ago       Up 2 minutes        80/tcp              frontend.3.7m83qsilli5dk8rncw3u10g5a
I also tested with different, non-default ports, and it works well. You have a lot of leeway in how you can connect to the server and get the response. You can use localhost or the docker interface IP address with the correct port. The example below shows port 1080:
![Replicated Web service works](http://www.dedoimedo.com/images/computers-years/2016-2/docker-swarm-5-replicas-web-works.jpg)
Now, this a very rough, very simple beginning. The real challenge is in creating optimized, scalable services, but they do require a proper technical use case. Moreover, you should also use the docker info and docker service (inspect|ps) commands to learn more about how your cluster is behaving.
### Possible problems
You may encounter some small (or not so small) issues while playing with Docker and swarm. For example, SELinux may complain that you are trying to do something illegal. However, the errors and warnings should not impede you too much.
![SELinux alert](http://www.dedoimedo.com/images/computers-years/2016-2/docker-swarm-selinux-alert.png)
### Docker service is not a docker command
When you try to run the necessary command to start a replicated service, you get an error that says docker: 'service' is not a docker command. This means that you do not have the right version of Docker (check with -v). We will fix this in a follow-up tutorial.
docker service create --name frontend --replicas 5 -p 80:80/tcp my-apache2:latest
docker: 'service' is not a docker command.
### Docker tag not recognized
You may also see the following error:
docker service create -name frontend -replicas 5 -p 80:80/tcp my-apache2:latest
Error response from daemon: rpc error: code = 3 desc = ContainerSpec: "-name" is not a valid repository/tag
There are several [discussions][11] [threads][12] around this. The error may actually be quite innocent. You may have copied the command from a browser, and the hyphens may not be parsed correctly. As simple as that.
### More reading
There's a lot more to be said on this topic, including the Swarm implementation prior to Docker 1.12, as well as the current version of the Docker engine. To wit, please do not be lazy and spend some time reading:
Docker Swarm [overview][13] (for standalone Swarm installations)
[Build][14] a Swarm cluster for production (standalone setups)
[Install and create][15] a Docker Swarm (standalone setups)
Docker engine swarm [overview][16] (for version 1.12)
Getting started with [swarm][17] mode (for version 1.12)
### Conclusion
There you go. Nothing too grand at this point, but I believe you will find the article useful. It covers several key concepts, there's an overview of how the swarm mode works and what it does, and we successfully managed to download and create our own Web server image and then run several clustered instances of it. We did this on a single node for now, but we will expand in the future. Also, we tackled some common problems.
I hope you find this guide interesting. Combined with my previous work on Docker, this should give you a decent understand of how to work with images, the networking stack, storage, and now clusters. Warming up. Indeed, enjoy and see you soon with fresh new tutorials on Docker. I just can't contain [sic] myself.
Cheers.
--------------------------------------------------------------------------------
via: http://www.dedoimedo.com/computers/docker-swarm-intro.html
作者：[Dedoimedo ][a]
译者：[Viz](https://github.com/vizv)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]:http://www.dedoimedo.com/computers/docker-swarm-intro.html
[1]:http://www.dedoimedo.com/computers/docker-guide.html
[2]:https://blog.docker.com/2016/06/docker-1-12-built-in-orchestration/
[3]:https://en.wikipedia.org/wiki/Raft_%28computer_science%29
[4]:http://www.dedoimedo.com/computers/lenovo-g50-centos-xfce.html
[5]:http://www.dedoimedo.com/computers/fedora-24-gnome.html
[6]:https://hub.docker.com/_/httpd/
[7]:http://www.dedoimedo.com/computers/docker-networking.html
[8]:http://www.dedoimedo.com/computers/docker-data-volumes.html
[9]:http://www.dedoimedo.com/computers/vagrant-intro.html
[10]:http://www.dedoimedo.com/computers/vagrant-coreos.html
[11]:https://github.com/docker/docker/issues/24192
[12]:http://stackoverflow.com/questions/38618609/docker-swarm-1-12-name-option-not-recognized
[13]:https://docs.docker.com/swarm/
[14]:https://docs.docker.com/swarm/install-manual/
[15]:https://docs.docker.com/swarm/install-w-machine/
[16]:https://docs.docker.com/engine/swarm/
[17]:https://docs.docker.com/engine/swarm/swarm-tutorial/

196
translated/tech/20161005 Docker Engine swarm mode - Intro tutorial.md Normal file
View File

@ -0,0 +1,196 @@
Docker 引擎的 Swarm 模式 - 入门教程
============================
听起来像是一个朋克摇滚乐队。但它确实是个新的编排机制，抑或者是，一个 [Docker][1] 现有编排体制的改进。简单来讲，如果你在用一个旧版本的 Docker，你必须手动配置 Swarm 来创建 Docker 集群。从 [1.12 版][2]开始，Docker 引擎集成了一个原生的实现（译者注：见下文）来支持无缝的集群设置。也就是为什么会有这篇文章。
在这篇教程中，我将带你体验一下编排后的 Docker 将能做的事情。这篇文章并不是包含所有细节（如 BnB 一般）或是让你对其全知全能，但它能带你踏上你的集群之路。在我的带领下开始吧。
![Teaser](http://www.dedoimedo.com/images/computers-years/2016-2/docker-swarm-teaser.jpg)
### 技术概要
如果把 Docker 详细而又好用的文档照搬到这里那将太丢人了，所以我将简要概括下这个技术的概要。我们已经有了 Docker，对吧。现在，你想要更多的服务器作为 Docker 主机，但同时你希望他们属于同一个逻辑上的实体。也就是说，你想建立一个集群。
我们先从一个主机组成的集群开始。当你在一个主机上初始化一个 Swarm 集群，这台主机将成为这个集群的管理者（manager）。从技术角度来讲，它成为了共识组（consensus group）中的一个结点。其背后的数学逻辑建立在 [Raft][3] 算法之上。管理者（manager）负责调度任务。而具体的任务则会委任给各个加入了 Swarm 集群的工作者（worker）结点。这些操作将由 Node API 所管理。虽说我讨厌 API 这个词汇，但我必须在这里用到它。
Service API 是这个实现中的第二个组件。它允许管理者（manager）结点在所有的 Swarm 集群结点上创建一个分布式的服务。这个服务可以被复制（replicated），也就是说他们（译者注：指这些服务）会由平衡机制被分配到集群中（译者注：指 replicated 模式，多个容器实例将会自动调度任务到集群中的一些满足条件的结点），或者可以分配给全局（译者注：指 global 模式），也就是说每个结点都会运行一个容器实例。
此外还有更多的功课需要做，但这些信息已经足够你上路了。现在，我们开始整些实际的。我们的目标平台是 [CentOS 7.2][4]，有趣的是在我写这篇教程的时候，它的软件仓库中只有 1.10 版的 Docker，也就是说我必须手动更新以使用 Swarm。我们将在另一片教程中讨论这个问题。接下来我们还有一个跟进的指南，其中涵盖了如何将新的结点加入我们现有的集群（译者注：指刚刚建立的单结点集群），并且我们将使用 [Fedora][5] 进行一个非对称的配置。至此，请确保正确的配置已经就位，并有一个工作的集群启动并正在运行（译者注：指第一个结点的 Docker 已经安装并已进入 Swarm 模式，但到这里笔者并没有介绍如何初始化 Swarm 集群，不过别担心下章会讲）。
### 配置镜像和服务
我将尝试配置一个负载均衡的 [Apache][6] 服务，并使用多个容器实例通过唯一的 IP 地址提供页面内容。挺标准的吧（译者注：指这个负载均衡的网页服务器）。这个例子同时也突出了你想要使用集群的大多数原因：可用性、冗余、横向扩展以及性能。当然，你同时需要考虑[网络][7]和[储存][8]这两块，但它们超出了这篇指南所涉及的范围了。
这个 Dockerfile 模板其实可以在官方镜像仓库下的 httpd 中找到。你只需一个最简单的设置来起步。至于如何下载或创建自己的镜像，请参考我的入门指南，链接可以在这篇教程的顶部可以找到。
```
docker build -t my-apache2 .
Sending build context to Docker daemon 2.048 kB
Step 1 : FROM httpd:2.4
Trying to pull repository docker.io/library/httpd ...
2.4: Pulling from docker.io/library/httpd
8ad8b3f87b37: Pull complete
c95e1f92326d: Pull complete
96e8046a7a4e: Pull complete
00a0d292c371: Pull complete
3f7586acab34: Pull complete
Digest: sha256:3ad4d7c4f1815bd1c16788a57f81b413...a915e50a0d3a4
Status: Downloaded newer image for docker.io/httpd:2.4
 ---> fe3336dd034d
Step 2 : COPY ../public-html/ /usr/local/apache2/htdocs/
...
```
![Image created](http://www.dedoimedo.com/images/computers-years/2016-2/docker-swarm-image-created.png)
在你继续下面的步骤之前，你应该确保你能无错误的启动一个容器实例并能链接到这个网页服务器上（译者注：使用下面的命令）。一旦你确保你能连上，我们就可以开始着手创建一个分布式的服务。
```
docker run -dit --name my-running-app my-apache2
```
将这个 IP 地址输入浏览器，看看会出现什么。
### Swarm 初始化和配置
下一步就是启动 Swarm 集群了。你将需要这些最基础的命令来开始，它们与 Docker 博客中的例子非常相似：
```
docker service create --name frontend --replicas 5 -p 80:80/tcp my-apache2:latest
```
这里我们做了什么？我们创建了一个叫做 `frontent` 的服务，它有五个容器实例。同时我们还将主机的 80 端口和容器们的 80 端口相绑定。我们将使用刚刚新创建的 Apache 镜像来做这个测试。然而，当你在自己的电脑上直接键入上面的指令时，你将看到下面的错误：
```
docker service create --name frontend --replicas 5 -p 80:80/tcp my-apache2:latest
Error response from daemon: This node is not a swarm manager. Use "docker swarm init" or "docker swarm join" to connect this node to swarm and try again.
```
这意味着你没有将你的主机（结点）配置成一个 Swarm 管理者（manager）。你可以在这台主机上初始化 Swarm 集群或是让它加入一个现有的集群。由于我们目前还没有一个现成的集群，我们将初始化它（译者注：指初始化 Swarm 集群并使当前结点成为 manager）：
```
docker swarm init
Swarm initialized: current node (dm58mmsczqemiikazbfyfwqpd) is now a manager.
```
为了向这个 Swarm 集群添加一个工作者（worker），请执行下面的指令：
```
docker swarm join \
--token SWMTKN-1-4ofd46a2nfyvrqwu8w5oeetukrbylyznxla
9srf9vxkxysj4p8-eu5d68pu5f1ci66s7w4wjps1u \
10.0.2.15:2377
```
为了向这个 Swarm 集群添加一个管理者（manager），请执行 'docker swarm join-token manager' 并按照指示操作。
操作后的输出不用解释已经很清楚明了。我们成功的创建了一个 Swarm 集群。新的结点们将需要正确的令牌（token）来加入这个 Swarm 集群。如果你需要配置防火墙，你还需找到它的 IP 地址和端口（译者注：指 Docker 的 Swarm 模式通讯所需的端口，默认 2377）。此外，你还可以向 Swarm 集群中添加管理者结点。现在，重新执行刚刚的服务创建指令：
```
docker service create --name frontend --replicas 5 -p 80:80/tcp my-apache2:latest
6lrx1vhxsar2i50is8arh4ud1
```
### 测试连通性
现在，我们来验证下我们的服务是否真的工作了。从某些方面讲，这很像我们在 [Vagrant][9] 和 [coreOS][10] 中做的事情那样。毕竟它们的原理几乎相同。指示相同思想的不同实现罢了（译者注：笔者观点，无法苟同）。首先需要确保 `docker ps` 能够给出正确的输出。你应该能看到所创建服务的多个容器副本。
```
docker ps
CONTAINER ID        IMAGE               COMMAND              CREATED             STATUS              PORTS              
NAMES
cda532f67d55        my-apache2:latest   "httpd-foreground"  
2 minutes ago       Up 2 minutes        80/tcp              frontend.1.2sobjfchdyucschtu2xw6ms9a
75fe6e0aa77b        my-apache2:latest   "httpd-foreground"  
2 minutes ago       Up 2 minutes        80/tcp              frontend.4.ag77qtdeby9fyvif5v6c4zcpc
3ce824d3151f        my-apache2:latest   "httpd-foreground"  
2 minutes ago       Up 2 minutes        80/tcp              frontend.2.b6fqg6sf4hkeqs86ps4zjyq65
eda01569181d        my-apache2:latest   "httpd-foreground"  
2 minutes ago       Up 2 minutes        80/tcp              frontend.5.0rmei3zeeh8usagg7fn3olsp4
497ef904e381        my-apache2:latest   "httpd-foreground"  
2 minutes ago       Up 2 minutes        80/tcp              frontend.3.7m83qsilli5dk8rncw3u10g5a
```
我也测试了不同的、非常规的端口，它们都能正常工作。对于你如何连接服务器和收取请求你将会有很多可配置的余地。你可以使用 localhost 或者 Docker 网络接口（笔者注：应该是指 Docker 的默认网桥 docker0，其网关为 172.17.0.1） IP 地址的正确端口去访问。下面的例子使用了端口 1080：
![Replicated Web service works](http://www.dedoimedo.com/images/computers-years/2016-2/docker-swarm-5-replicas-web-works.jpg)
至此，这是一个非常粗略、简单的开始。真正的挑战是创建一个优化过的、可扩展的服务，但是它们需要一个准确的技术用例。此外，你还会用到 `docker info` 和 `docker service`（还有 `inspect` 和 `ps`）命令来详细了解你的集群是如何工作的。
### 可能会遇到的问题
你可能会在把玩 Docker 和 Swarm 时遇到一些小的问题（也许没那么小）。比如 SELinux 也许会抱怨你正在执行一些非法的操作（译者注：指在强制访问控制策略中没有权限的操作）。然而，这些错误和警告应该不会对你造成太多阻碍。
![SELinux alert](http://www.dedoimedo.com/images/computers-years/2016-2/docker-swarm-selinux-alert.png)
### `docker service` 不是一条命令（`docker service is not a docker command`）
当你尝试执行必须的命令去创建一个复制模式（replicated）的服务时，你可能会遇到一条错误说 `docker: 'service' is not a docker command`（译者注：见下面的例子）。这表示你的 Docker 版本不对（使用 `-v` 选项来检查）。我们将在将来的教程讨论如何修复这个问题。
```
docker service create --name frontend --replicas 5 -p 80:80/tcp my-apache2:latest
docker: 'service' is not a docker command.
```
### `docker tag` 无法识别（`docker tag not recognized`）
你也许会看到下面的错误：
```
docker service create -name frontend -replicas 5 -p 80:80/tcp my-apache2:latest
Error response from daemon: rpc error: code = 3 desc = ContainerSpec: "-name" is not a valid repository/tag
```
关于这个错误已经有多个相关的[讨论][11]和[帖子][12]了。其实这个错误也许相当无辜。你也许是从浏览器粘贴的命令，在浏览器中的横线也许没被正确解析（笔者注：应该用 `--name` 而不是 `-name`）。就是这么简单的原因所导致的。
### 扩展阅读
关于这个话题还有很多可谈的，包含 1.12 版之前的 Swarm 集群实现（笔者注：旧的 Swarm 集群实现，下文亦作`独立版本`，需要 Consul 等应用提供服务发现），以及当前的 Docker 版本提供的（笔者注：新的 Swarm 集群实现，亦被称为 Docker 引擎的 Swarm 模式）。也就是说，请别偷懒花些时间阅读以下内容：
Docker Swarm [概述][13]（独立版本的 Swarm 集群安装）
[构建][14]一个生产环境的 Swarm 集群（独立版本安装）
[安装并创建][15]一个 Docker Swarm 集群（独立版本安装）
Docker 引擎 Swarm [概述][16]（对于 1.12 版）
[Swarm][17] 模式入门（对于 1.12 版）
### 总结
你总算看到这里了。到这里仍然无法保证你学到了什么，但我相信你还是会觉得这篇文章有些用的。它涵盖了一些基础的概念，以及一个 Swarm 集群模式是如何工作的以及它能做什么的概述，与此同时我们也成功的下载了并创建了我们的网页服务器的镜像并且在之后基于它运行了多个集群式的容器实例。虽然我们目前只在单一结点做了以上实验，但是我们会在将来解释清楚（笔者注：以为解释清楚多结点的 Swarm 集群操作）。并且我们解决了一些常见的问题。
我希望你能认为这篇指南足够有趣。结合着我过去所写的关于 Docker 的文章，这些文章应该能给你一个像样的解释包含：怎么样操作镜像、网络栈、储存、以及现在的集群。就当热身吧。的确，请享受并期待在新的 Docker 教程中与你见面。我控几不住我记几啊。
祝你愉快。
--------------------------------------------------------------------------------
via: http://www.dedoimedo.com/computers/docker-swarm-intro.html
作者：[Dedoimedo ][a]
译者：[Viz](https://github.com/vizv)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]:http://www.dedoimedo.com/computers/docker-swarm-intro.html
[1]:http://www.dedoimedo.com/computers/docker-guide.html
[2]:https://blog.docker.com/2016/06/docker-1-12-built-in-orchestration/
[3]:https://en.wikipedia.org/wiki/Raft_%28computer_science%29
[4]:http://www.dedoimedo.com/computers/lenovo-g50-centos-xfce.html
[5]:http://www.dedoimedo.com/computers/fedora-24-gnome.html
[6]:https://hub.docker.com/_/httpd/
[7]:http://www.dedoimedo.com/computers/docker-networking.html
[8]:http://www.dedoimedo.com/computers/docker-data-volumes.html
[9]:http://www.dedoimedo.com/computers/vagrant-intro.html
[10]:http://www.dedoimedo.com/computers/vagrant-coreos.html
[11]:https://github.com/docker/docker/issues/24192
[12]:http://stackoverflow.com/questions/38618609/docker-swarm-1-12-name-option-not-recognized
[13]:https://docs.docker.com/swarm/
[14]:https://docs.docker.com/swarm/install-manual/
[15]:https://docs.docker.com/swarm/install-w-machine/
[16]:https://docs.docker.com/engine/swarm/
[17]:https://docs.docker.com/engine/swarm/swarm-tutorial/