Author: scott

只要你和程序打交道，了解编译器架构就会令你受益无穷——无论是分析程序效率，还是模拟新的处理器和操作系统。通过本文介绍，即使你对编译器原本一知半解，也能开始用LLVM，来完成有意思的工作。

LLVM是什么？

LLVM是一个好用、好玩，而且超前的系统语言（比如C和C++语言）编译器。

当然，因为LLVM实在太强大，你会听到许多其他特性（它可以是个JIT；支持了一大批非类C语言；还是App Store上的一种新的发布方式等等）。这些都是真的，不过就这篇文章而言，还是上面的定义更重要。

下面是一些让LLVM与众不同的原因：

• LLVM的“中间表示”（IR）是一项大创新。LLVM的程序表示方法真的“可读”（如果你会读汇编）。虽然看上去这没什么要紧，但要知道，其他编译器的中间表示大多是种内存中的复杂数据结构，以至于很难写出来，这让其他编译器既难懂又难以实现。
• 然而LLVM并非如此。其架构远比其他编译器要模块化得多。这种优点可能部分来自于它的最初实现者。
• 尽管LLVM给我们这些狂热的学术黑客提供了一种研究工具的选择，它还是一款有大公司做后台的工业级编译器。这意味着你不需要去在“强大的编译器”和“可玩的编译器”之间做妥协——不像你在Java世界中必须在HotSpot和Jikes之间权衡那样。

为什么人人需要懂点儿LLVM？

是，LLVM是一款酷炫的编译器，但是如果不做编译器研究，还有什么理由要管它？

答：只要你和程序打交道，了解编译器架构就会令你受益，而且从我个人经验来看，非常有用。利用它，可以分析程序要多久一次来完成某项工作；改造程序，使其更适用于你的系统，或者模拟一个新的处理器架构或操作系统——只需稍加改动，而不需要自己烧个芯片，或者写个内核。对于计算机科学研究者来说，编译器远比他们想象中重要。建议你先试试LLVM，而不用hack下面这些工具（除非你真有重要的理由）：

• 架构模拟器；
• 动态二进制分析工具，比如Pin；
• 源代码变换（简单的比如sed，复杂一些的比如抽象语法树的分析和序列化）；
• 修改内核来干预系统调用；
• 任何和虚拟机管理程序相似的东西。

就算一个编译器不能完美地适合你的任务，相比于从源码到源码的翻译工作，它可以节省你九成精力。

下面是一些巧妙利用了LLVM，而又不是在做编译器的研究项目：

• UIUC的Virtual Ghost，展示了你可以用编译器来保护挂掉的系统内核中的进程。
• UW的CoreDet利用LLVM实现了多线程程序的确定性。
• 在我们的近似计算工作中，我们使用LLVM流程来给程序注入错误信息，以模仿一些易出错的硬件。

重要的话说三遍：LLVM不是只用来实现编译优化的！LLVM不是只用来实现编译优化的！LLVM不是只用来实现编译优化的！

组成部分

LLVM架构的主要组成部分如下（事实上也是所有现代编译器架构）：

前端，流程（Pass），后端

下面分别来解释：

• 前端获取你的源代码然后将它转变为某种中间表示。这种翻译简化了编译器其他部分的工作，这样它们就不需要面对比如C++源码的所有复杂性了。作为一个豪迈人，你很可能不想再做这部分工作；可以不加改动地使用Clang来完成。
• “流程”将程序在中间表示之间互相变换。一般情况下，流程也用来优化代码：流程输出的（中间表示）程序和它输入的（中间表示）程序相比在功能上完全相同，只是在性能上得到改进。这部分通常是给你发挥的地方。你的研究工具可以通过观察和修改编译过程流中的IR来完成任务。
• 后端部分可以生成实际运行的机器码。你几乎肯定不想动这部分了。

虽然当今大多数编译器都使用了这种架构，但是LLVM有一点值得注意而与众不同：整个过程中，程序都使用了同一种中间表示。在其他编译器中，可能每一个流程产出的代码都有一种独特的格式。LLVM在这一点上对hackers大为有利。我们不需要担心我们的改动该插在哪个位置，只要放在前后端之间某个地方就足够了。

开始

让我们开干吧。

获取LLVM

首先需要安装LLVM。Linux的诸发行版中一般已经装好了LLVM和Clang的包，你直接用便是。但你还是需要确认一下机子里的版本，是不是有所有你要用到的头文件。在OS X系统中，和XCode一起安装的LLVM就不是那么完整。还好，用CMake从源码构建LLVM也没有多难。通常你只需要构建LLVM本身，因为你的系统提供的Clang已经够用（只要版本是匹配的，如果不是，你也可以自己构建Clang）。

具体在OS X上，Brandon Holt有一个不错的指导文章。用Homebrew也可以安装LLVM。

去读手册

你需要对文档有所了解。我找到了一些值得一看的链接：

• 自动生成的Doxygen文档页非常重要。要想搞定LLVM，你必须要以这些API的文档维生。这些页面可能不太好找，所以我推荐你直接用Google搜索。只要你在搜索的函数或者类名后面加上“LLVM”，你一般就可以用Google找到正确的文档页面了。（如果你够勤奋，你甚至可以“训练”你的Google，使得在不输入LLVM的情况下它也可以把LLVM的相关结果推到最前面）虽然听上去有点逗，不过你真的需要这样找LLVM的API文档——反正我没找到其他的好方法。
• 《语言参考手册》也非常有用，如果你曾被LLVM IR dump里面的语法搞糊涂的话。
• 《开发者手册》描述了一些LLVM特有的数据结构的工具，比如高效字符串，vector和map的替代品等等。它还描述了一些快速类型检查工具 isa、cast和dyn_cast），这些你不管在哪都要跑。 ◾如果你不知道你的流程可以做什么，读《编写LLVM流程》 。不过因为你只是个研究人员而不是浸淫于编译器的大牛，本文的观点可能和这篇教程在一些细节上有所不同。（最紧急的是，别再用基于Makefile的构建系统了。直接开始用CMake构建你的程序吧，读读《“源代码外”指令》）尽管上面这些是解决流程问题的官方材料，
• 不过在在线浏览LLVM代码时，这个GitHub镜像有时会更方便。

写一个流程

使用LLVM来完成高产研究通常意味着你要写一些自定义流程。这一节会指导你构建和运行一个简单的流程来变换你的程序。

框架

我已经准备好了模板仓库，里面有些没用的LLVM流程。我推荐先用这个模板。因为如果完全从头开始，配好构建的配置文件可是相当痛苦的事。

首先从GitHub上下载llvm-pass-skeleton仓库：

$ git clone git@github.com:sampsyo/llvm-pass-skeleton.git

主要的工作都是在skeleton/Skeleton.cpp中完成的。把它打开。这里是我们的业务逻辑：

virtual bool runOnFunction(Function &F) {
  errs() << "I saw a function called " << F.getName() << "!\n";
  return false;
}

LLVM流程有很多种，我们现在用的这一种叫函数流程（function pass）（这是一个不错的入手点）。正如你所期望的，LLVM会在编译每个函数的时候先唤起这个方法。现在它所做的只是打印了一下函数名。

细节：

• errs()是一个LLVM提供的C++输出流，我们可以用它来输出到控制台。
• 函数返回false说明它没有改动函数F。之后，如果我们真的变换了程序，我们需要返回一个true。

构建

通过CMake来构建这个流程：

$ cd llvm-pass-skeleton
$ mkdir build
$ cd build
$ cmake ..  # Generate the Makefile.
$ make  # Actually build the pass.

如果LLVM没有全局安装,你需要告诉CMake LLVM的位置.你可以把环境变量LLVM_DIR的值修改为通往share/llvm/cmake/的路径。比如这是一个使用Homebrew安装LLVM的例子：

$ LLVM_DIR=/usr/local/opt/llvm/share/llvm/cmake cmake ..

构建流程之后会产生一个库文件，你可以在build/skeleton/libSkeletonPass.so或者类似的地方找到它，具体取决于你的平台。下一步我们载入这个库来在真实的代码中运行这个流程。

运行

想要运行你的新流程，用clang编译你的C代码，同时加上一些奇怪的flag来指明你刚刚编译好的库文件：

$ clang -Xclang -load -Xclang build/skeleton/libSkeletonPass.* something.c
I saw a function called main!

-Xclang -load -Xclang path/to/lib.so这是你在Clang中载入并激活你的流程所用的所有代码。所以当你处理较大的项目的时候，你可以直接把这些参数加到Makefile的CFLAGS里或者你构建系统的对应的地方。

（通过单独调用clang，你也可以每次只跑一个流程。这样需要用LLVM的opt命令。这是官方文档里的合法方式，但在这里我就不赘述了。）

恭喜你，你成功hack了一个编译器！接下来，我们要扩展这个hello world水平的流程，来做一些好玩的事情。

理解LLVM的中间表示

想要使用LLVM里的程序，你需要知道一点中间表示的组织方法。

模块（Module），函数（Function），代码块（BasicBlock），指令（Instruction） 模块包含了函数，函数又包含了代码块，后者又是由指令组成。除了模块以外，所有结构都是从值产生而来的。

容器

首先了解一下LLVM程序中最重要的组件： 

• 粗略地说，模块表示了一个源文件，或者学术一点讲叫翻译单元。其他所有东西都被包含在模块之中。 
• 最值得注意的是，模块容纳了函数，顾名思义，后者就是一段段被命名的可执行代码。（在C++中，函数function和方法method都相应于LLVM中的函数。） 
• 除了声明名字和参数之外，函数主要会做为代码块的容器。代码块和它在编译器中的概念差不多，不过目前我们把它看做是一段连续的指令。 
• 而说到指令，就是一条单独的代码命令。这一种抽象基本上和RISC机器码是类似的：比如一个指令可能是一次整数加法，可能是一次浮点数除法，也可能是向内存写入。

大部分LLVM中的内容——包括函数，代码块，指令——都是继承了一个名为值的基类的C++类。值是可以用于计算的任何类型的数据，比如数或者内存地址。全局变量和常数（或者说字面值，立即数，比如5）都是值。

指令

这是一个写成人类可读文本的LLVM中间表示的指令的例子。

%5 = add i32 %4, 2

这个指令将两个32位整数相加（可以通过类型i32推断出来）。它将4号寄存器（写作%4）中的数和字面值2（写作2）求和，然后放到5号寄存器中。这就是为什么我说LLVM IR读起来像是RISC机器码：我们甚至连术语都是一样的，比如寄存器，不过我们在LLVM里有无限多个寄存器。

在编译器内，这条指令被表示为指令C++类的一个实例。这个对象有一个操作码表示这是一次加法，一个类型，以及一个操作数的列表，其中每个元素都指向另外一个值（Value）对象。在我们的例子中，它指向了一个代表整数2的常量对象和一个代表5号寄存器的指令对象。（因为LLVM IR使用了静态单次分配格式，寄存器和指令事实上是一个而且是相同的，寄存器号是人为的字面表示。）

另外，如果你想看你自己程序的LLVM IR，你可以直接使用Clang：

$ clang -emit-llvm -S -o - something.c

查看流程中的IR

让我们回到我们正在做的LLVM流程。我们可以查看所有重要的IR对象，只需要用一个普适而方便的方法：dump()。它会打印出人可读的IR对象的表示。因为我们的流程是处理函数的，所以我们用它来迭代函数里所有的代码块，然后是每个代码块的指令集。

下面是代码。你可以通过在llvm-pass-skeleton代码库中切换到containers分支来获得代码。

errs() << "Function body:\n";
F.dump();
for (auto& B : F) {
  errs() << "Basic block:\n";
  B.dump();
  for (auto& I : B) {
    errs() << "Instruction: ";
    I.dump();
  }
}

使用C++ 11里的auto类型和foreach语法可以方便地在LLVM IR的继承结构里探索。

如果你重新构建流程并通过它再跑程序，你可以看到很多IR被切分开输出，正如我们遍历它那样。

做些更有趣的事

当你在找寻程序中的一些模式，并有选择地修改它们时，LLVM的魔力真正展现了出来。这里是一个简单的例子：把函数里第一个二元操作符（比如+，-）改成乘号。听上去很有用对吧？

下面是代码。这个版本的代码，和一个可以试着跑的示例程序一起，放在了llvm-pass-skeleton仓库的 mutate分支。

for (auto& B : F) {
  for (auto& I : B) {
    if (auto* op = dyn_cast(&I)) {
      // Insert at the point where the instruction `op` appears.
      IRBuilder<> builder(op);
      // Make a multiply with the same operands as `op`.
      Value* lhs = op->getOperand(0);
      Value* rhs = op->getOperand(1);
      Value* mul = builder.CreateMul(lhs, rhs);
      // Everywhere the old instruction was used as an operand, use our
      // new multiply instruction instead.
      for (auto& U : op->uses()) {
        User* user = U.getUser();  // A User is anything with operands.
        user->setOperand(U.getOperandNo(), mul);
      }
      // We modified the code.
      return true;
    }
  }
}

细节如下：

• dyn_cast(p)构造函数是LLVM类型检查工具的应用。使用了LLVM代码的一些惯例,使得动态类型检查更高效，因为编译器总要用它们。具体来说，如果I不是“二元操作符”，这个构造函数返回一个空指针，就可以完美应付很多特殊情况（比如这个）。
• IRBuilder用于构造代码。它有一百万种方法来创建任何你可能想要的指令。
• 为把新指令缝进代码里，我们需要找到所有它被使用的地方，然后当做一个参数换进我们的指令里。回忆一下，每个指令都是一个值：在这里，乘法指令被当做另一条指令里的操作数，意味着乘积会成为被传进来的参数。
• 我们其实应该移除旧的指令，不过简明起见我把它略去了。

现在我们编译一个这样的程序（代码库中的example.c）：

#include 
int main(int argc, const char** argv) {
    int num;
    scanf("%i", &num);
    printf("%i\n", num + 2);
    return 0;
}

如果用普通的编译器，这个程序的行为和代码并没有什么差别；但我们的插件会让它将输入翻倍而不是加2。

$ cc example.c
$ ./a.out
10
12
$ clang -Xclang -load -Xclang build/skeleton/libSkeletonPass.so example.c
$ ./a.out
10
20

很神奇吧！

链接动态库

如果你想调整代码做一些大动作，用IRBuilder来生成LLVM指令可能就比较痛苦了。你可能需要写一个C语言的运行时行为，然后把它链接到你正在编译的程序上。这一节将会给你展示如何写一个运行时库，它可以将所有二元操作的结果记录下来，而不仅仅是闷声修改值。

这里是LLVM流程的代码，也可以在llvm-pass-skeleton代码库的rtlib分支找到它。

// Get the function to call from our runtime library.
LLVMContext& Ctx = F.getContext();
Constant* logFunc = F.getParent()->getOrInsertFunction(
  "logop", Type::getVoidTy(Ctx), Type::getInt32Ty(Ctx), NULL
);
for (auto& B : F) {
  for (auto& I : B) {
    if (auto* op = dyn_cast(&I)) {
      // Insert *after* `op`.
      IRBuilder<> builder(op);
      builder.SetInsertPoint(&B, ++builder.GetInsertPoint());
      // Insert a call to our function.
      Value* args[] = {op};
      builder.CreateCall(logFunc, args);
      return true;
    }
  }
}

你需要的工具包括Module::getOrInsertFunction和IRBuilder::CreateCall。前者给你的运行时函数logop增加了一个声明（类似于在C程序中声明void logop(int i);而不提供实现）。相应的函数体可以在定义了logop函数的运行时库（代码库中的rtlib.c）找到。

#include 
void logop(int i) {
  printf("computed: %i\n", i);
}

要运行这个程序，你需要链接你的运行时库：

$ cc -c rtlib.c
$ clang -Xclang -load -Xclang build/skeleton/libSkeletonPass.so -c example.c
$ cc example.o rtlib.o
$ ./a.out
12
computed: 14
14

如果你希望的话，你也可以在编译成机器码之前就缝合程序和运行时库。llvm-link工具——你可以把它简单看做IR层面的ld的等价工具，可以帮助你完成这项工作。

注记（Annotation）

大部分工程最终是要和开发者进行交互的。你会希望有一套注记（annotations），来帮助你从程序里传递信息给LLVM流程。这里有一些构造注记系统的方法：

• 一个实用而取巧的方法是使用魔法函数。先在一个头文件里声明一些空函数，用一些奇怪的、基本是独特的名字命名。在源代码中引入这个头文件，然后调用这些什么都没有做的函数。然后，在你的流程里，查找唤起了函数的CallInst指令，然后利用它们去触发你真正要做的“魔法”。比如说，你可能想调用__enable_instrumentation()和__disable_instrumentation()，让程序将代码改写限制在某些具体的区域。
• 如果想让程序员给函数或者变量声明加记号，Clang的__attribute__((annotate("foo")))语法会发射一个元数据和任意字符串，可以在流程中处理它。Brandon Holt（又是他）有篇文章讲解了这个技术的背景。如果你想标记一些表达式，而非声明，一个没有文档，同时很不幸受限了的__builtin_annotation(e, "foo")内建方法可能会有用。
• 可以自由修改Clang使它可以翻译你的新语法。不过我不推荐这个。
• 如果你需要标记类型——我相信大家经常没意识到就这么做了——我开发了一个名为Quala的系统。它给Clang打了补丁，以支持自定义的类型检查和可插拔的类型系统，到Java的JSR-308。如果你对这个项目感兴趣，并且想合作，请联系我。

我希望能在以后的文章里展开讨论这些技术。

其他

LLVM非常庞大。下面是一些我没讲到的话题：

• 使用LLVM中的一大批古典编译器分析；
• 通过hack后端来生成任意的特殊机器指令（架构师们经常想这么干）；
• 利用debug info连接源代码中的行和列到IR中的每一处；
• 开发[Clang前端插件]。(http://clang.llvm.org/docs/ClangPlugins.html)

我希望我给你讲了足够的背景来支持你完成一个好项目了。探索构建去吧！如果这篇文章对你帮助，也请让我知道。

---

感谢UW的架构与系统组，围观了我的这篇文章并且提了很多很赞的问题。

以及感谢以下的读者：

• Emery Berger指出了动态二进制分析工具，比如Pin，仍然是你在观察系统结构中具体内容（比如寄存器，内存继承和指令编码等）的好帮手；
• Brandon Holt发了一篇《LLVM debug 技巧》，包括如何用GraphViz绘制控制流图；
• John Regehr在评论中提到把软件搭在LLVM上的缺点：API不稳定性。LLVM内部几乎每版都要大换，所以你需要不断维护你的项目。Alex Bradbury的LLVM周报是个跟进LLVM生态圈的好资源。

第一部分：Docker镜像的基本知识

1.1 什么是Docker镜像

从整体的角度来讲，一个完整的Docker镜像可以支撑一个Docker容器的运行，在 Docker容器运行过程中主要提供文件系统视角。例如一个ubuntu:14.04的镜像，提供了一个基本的ubuntu:14.04的发行版，当然此 镜像是不包含操作系统Linux内核的。

说到此，可能就需要注意一下，linux内核和ubuntu:14.04Docker镜像的区别了。传统虚拟机安装ubuntu:14.04会包含两部分，第一，某一个Linux内核的发行版本，比如Linux 3.8版本的内核；第二，第一个特定的Ubuntu发行版，这部分内容不包含Linux内核，但是包含Linux之外的软件管理方式，软件驱动，如 apt-get软件管理包等。

理解以上内容之后，就可以理解，为什么在一个Linux内核版本为3.8的ubuntu:14.04基础上，可以把Linux内核版本升级到3.18，而ubuntu的版本依然是14.04。最主要的就是：Linux内核版本与ubuntu操作系统发行版之间的区别。

Linux内核＋ubuntu操作系统发行版，组成一台工作的机器让用户体验。那么灵活替换ubuntu操作系统发行版，那是不是也可以实现呢。那么Docker很方便的利用了这一点，技术手段就是Docker镜像。

Docker的架构中，Docker镜像就是类似于“ubuntu操作系统发行版”，可 以在任何满足要求的Linux内核之上运行。简单一点有“Debian操作系统发行版”Docker镜像、“Ubuntu操作系统发行版”Docker镜 像；如果在Debian镜像中安装MySQL 5.6，那我们可以将其命名为Mysql:5.6镜像；如果在Debian镜像中安装有Golang 1.3,那我们可以将其命名为golang:1.3镜像；以此类推，大家可以根据自己安装的软件，得到任何自己想要的镜像。

那么镜像最后的作用是什么呢？很好理解，回到Linux内核上来运行，通过镜像来运行时我们常常将提供的环境称为容器。

以上内容是从宏观的角度看看Docker镜像是什么，我们再从微观的角度进一步深入 Docker镜像。刚才提到了“Debian镜像中安装MySQL 5.6，就成了mysql:5.6镜像”，其实在此时Docker镜像的层级概念就体现出来了。底层一个Debian操作系统镜像，上面叠加一个 mysql层，就完成了一个mysql镜像的构建。层级概念就不难理解，此时我们一般debian操作系统镜像称为mysql镜像层的父镜像。

层级管理的方式大大便捷了Docker镜像的分发与存储。说到分发，大家自然会联想到 Docker镜像的灵活性，传输的便捷性，以及高超的移植性。Docker Hub，作为全球的镜像仓库，作为Docker生态中的数据仓库，将全世界的Docker数据汇聚在一起，是Docker生态的命脉。 

Docker有两方面的技术非常重要，第一是Linux 容器方面的技术，第二是Docker镜像的技术。从技术本身来讲，两者的可复制性很强，不存在绝对的技术难点，然而Docker Hub由于存在大量的数据的原因，导致Docker Hub的可复制性几乎不存在，这需要一个生态的营造。

1.2 Docker镜像的内容

大致介绍了Docker镜像是什么，我们来看看Docker镜像中有哪些内容？

介绍之前，我先分享一下，我个人在接触Docker的两年时间中，对Docker镜像内容认识的变化。

第一阶段：初步接触Docker。相信很多爱好者都会和我一样，有这样一个认识：Docker 镜像代表一个容器的文件系统内容；

第二阶段：初步接触联合文件系统。联合文件系统的概念，让我意识到镜像层级管理的技术，每一层镜像都是容器文件系统内容的一部分。

第三阶段：研究镜像与容器的关系：容器是一个动态的环境，每一层镜像中的文件属于静态内 容，然而 Dockerfile 中的 ENV、VOLUME、CMD 等内容最终都需要落实到容器的运行环境中，而这些内容均不可能直接坐落到每一层镜像所包含的文件系统内容中，那此时每一个Docker镜像还会包含 json文件记录与容器之间的关系。

因此，Docker镜像的内容主要包含两个部分：第一，镜像层文件内容；第二，镜像json文件。

1.3 Docker镜像存储位置

既然是说镜像存储的位置，那么应该包含：镜像层文件和镜像json文件。如一个ubuntu:14.04镜像，包含4个镜像层，在aufs存储驱动的情况下，在磁盘上的情况可以如以下图所示：

1.3.1 查看镜像层组成：

我们可以通过命令 docker history ubuntu:14.04 查看 ubuntu:14.04，结果如下：

1.3.2 镜像层文件内容存储

Docker 镜像层的内容一般在 Docker 根目录的 aufs 路径下，为 /var/lib/docker/aufs/diff/，具体情况如下： 

图中显示了镜像 ubuntu:14.04 的 4 个镜像层内容，以及每个镜像层内的一级目录情况。需要额外注意的是：镜像层 d2a0ecffe6fa 中没有任何内容，也就是所谓的空镜像。

1.3.3 镜像 json 文件存储

对于每一个镜像层，Docker 都会保存一份相应的 json 文件，json 文件的存储路径为 /var/lib/docker/graph，ubuntu:14.04 所有镜像层的 json 文件存储路径展示如下：

除了 json 文件，大家还看到每一个镜像层还包含一个 layersize 文件，该文件主要记录镜像层内部文件内容的总大小。既然谈到了镜像 json 文件，为了给下文铺垫，以下贴出 ubuntu:14.04 中空镜像层 d2a0ecffe6fa 的 json 文件：

Docker镜像存储，就和大家一起先看到这。同时介绍Docker镜像的基本知识也告一段落。以下我们进入此次分享的第二部分。

第二部分 Dockerfile、Docker镜像和Docker容器的关系

Dockerfile 是软件的原材料，Docker 镜像是软件的交付品，而 Docker 容器则可以认为是软件的运行态。从应用软件的角度来看，Dockerfile、Docker 镜像与 Docker 容器分别代表软件的三个不同阶段，Dockerfile 面向开发，Docker 镜像成为交付标准，Docker 容器则涉及部署与运维，三者缺一不可，合力充当 Docker 体系的基石。

简单来讲，Dockerfile构建出Docker镜像，通过Docker镜像运行Docker容器。

我们可以从Docker容器的角度，来反推三者的关系。首先可以来看下图：

我们假设这个容器的镜像通过以下Dockerfile构建而得：

FROM ubuntu:14.04
ADD run.sh /
VOLUME /data
CMD ["./run.sh"]  

2.1 Dockerfile与Docker镜像

首先，我们结合上图来看看Dockerfile与Docker镜像之间的关系。

FROM ubuntu:14.04：设置基础镜像，此时会使用基础镜像 ubuntu:14.04 的所有镜像层，为简单起见，图中将其作为一个整体展示。

ADD run.sh /：将 Dockerfile 所在目录的文件 run.sh 加至镜像的根目录，此时新一层的镜像只有一项内容，即根目录下的 run.sh。

VOLUME /data：设定镜像的 VOLUME，此 VOLUME 在容器内部的路径为 /data。需要注意的是，此时并未在新一层的镜像中添加任何文件，即构建出的磁层镜像中文件为空，但更新了镜像的 json 文件，以便通过此镜像启动容器时获取这方面的信息。

CMD [“./run.sh”]：设置镜像的默认执行入口，此命令同样不会在新建镜像中添加任何文件，仅仅在上一层镜像 json 文件的基础上更新新建镜像的 json 文件。 

因此，通过以上分析，以上的Dockerfile可以构建出一个新的镜像，包含4个镜像层，每一条命令会和一个镜像层对应，镜像之间会存在父子关系。图中很清楚的表明了这些关系。

2.2 Docker镜像与Docker容器的关系

Docker镜像是Docker容器运行的基础，没有Docker镜像，就不可能有Docker容器，这也是Docker的设计原则之一。

可以理解的是：Docker镜像毕竟是镜像，属于静态的内容；而Docker容器就不一样了，容器属于动态的内容。动态的内容，大家很容易联想到进程，内存，CPU等之类的东西。的确，Docker容器作为动态的内容，都会包含这些。

为了便于理解，大家可以把Docker容器，理解为一个或多个运行进程，而这些运行进程将占有相应的内存，相应的CPU计算资源，相应的虚拟网络设备以及相应的文件系统资源。而Docker容器所占用的文件系统资源，则通过Docker镜像的镜像层文件来提供。

那么作为静态的镜像，如何才有能力转化为一个动态的Docker容器呢？此时，我们可以想象：第一，转化的依据是什么；第二，由谁来执行这个转化操作。

其实，转化的依据是每个镜像的json文件，Docker可以通过解析Docker镜像的json的文件，获知应该在这个镜像之上运行什么样的进程，应该为进程配置怎么样的环境变量，此时也就实现了静态向动态的转变。

谁来执行这个转化工作？答案是Docker守护进程。也许大家早就理解这样一句 话：Docker容器实质上就是一个或者多个进程，而容器的父进程就是Docker守护进程。这样的，转化工作的执行就不难理解了：Docker守护进程 手握Docker镜像的json文件，为容器配置相应的环境，并真正运行Docker镜像所指定的进程，完成Docker容器的真正创建。

Docker容器运行起来之后，Docker镜像json文件就失去作用了。此时Docker镜像的绝大部分作用就是：为Docker容器提供一个文件系统的视角，供容器内部的进程访问文件资源。

再次回到上图，我们再来看看容器和镜像之间的一些特殊关系。首先，之前已经提及Docker镜像是分层管理的，管理Docker容器的时候，Docker镜像仍然是分层管理的。由于此时动态的容器中已经存在进程，进程就会对文件系统视角内的文件进行读写操作，因此，就会涉及一个问题：容器是否会篡改Docker镜像的内容？

答案自然是不会的。统一来讲，正如上图，所有的Docker镜像层对于容器来说，都是只读的，容器对于文件的写操作绝对不会作用在镜像中。

既然如此，实现的原理就很重要，究其根本：Docker守护进程会在Docker镜像的 最上层之上，再添加一个可读写层，容器所有的写操作都会作用到这一层中。而如果Docker容器需要写底层Docker镜像中的文件，那么此时就会涉及一 个叫Copy－on－Write的机制，即aufs等联合文件系统保证：首先将此文件从Docker镜像层中拷贝至最上层的可读写层，然后容器进程再对读 写层中的副本进行写操纵。对于容器进程来讲，它只能看到最上层的文件。

那最后我们再来说说：Docker容器的文件系统视角中，到底是不是存在一些内容，不是存储于Docker镜像中的？

这次的答案依旧是肯定的。

再次重申一点，Docker镜像中存储的都是一些静态文件。这些文件原则上应该和容器具体信息以及主机信息完全解藕。那么Docker容器中不存在Docker镜像中的内容主要有以下几点：

1. /proc以及/sys等虚拟文件系统的内容 

2. 容器的hosts文件，hostname文件以及resolv.conf文件，这些事具体环境的信息，原则上的确不应该被打入镜像。

3. 容器的Volume路径，这部分的视角来源于从宿主机上挂载到容器内部的路径

4. 部分的设备文件

QA选集：

问：为什么一个ubuntu:14.04镜像的镜像层的数量是4个，前三层的内容似乎有相同的，如etc？

孙宏亮：这一点，细心的大家肯定发现了。首先，虽然三层 都有，但是会存在两种情况，etc的子目录下有相同路径的文件，那么上层的会覆盖下层的文件；如果内部的文件路径不相同，那么都会存在，都会呈现给最上 层。［可别较真，说目录也是文件哈，意会］

问：关于docker安全性问题，对于安全是怎样处理的，如果我从hub下载镜像，能判别是否安全么2.层级之间的依赖会导致一个崩了整个docker 都崩了么？

孙宏亮：从流程上来讲，如果一切可控的话，我认为是安全的。但是依然会存在一些隐患，比如Dockerfile中基于的base images是否完全受信；镜像的传输过程是否受信；自己的private docker resgitry的安全级别达到什么样的层次，这些都有影响。

问：如何保证仅有的一个deamon的稳定性健壮性？

孙宏亮：这个问题首先需要知道docker daemon的稳定性在哪些方面，那种场景下比较差？的确，docker daemon存在弊病。比如，daemon和容器的耦合等，目前general来讲，docker daemon保证绝对的稳定应该还做不到。

问：生产环境中怎么用docker备份mysql数据？

孙宏亮：数据存储上docker，我目前的建议是：三思。举个简单的例子，官方的mysql镜像运行出来的 容器，密码是明文的，明文的密码存在于：docker inspect container_name, container.json文件中，容器的环境变量中，甚至在日志文件中都会存在，just think about it。当然也有办法解决，缓解这种情况。

问：如果是多层构建，中间的一个层做了升级或者bugfix，会潜在影响上层吧？

孙宏亮：这个bugfix会在上层有体现，但是使用效果是不会有影响的，还有之前的bug会永远留在下层，但是没有影响

说到软件开发，有人或许会感叹了解平台SDK和API比了解语言本身更重要。

如果你是一个进入Android开发的Java开发人员，或者是一家想要确保团队使用的是正确工具的初创企业CxO，那么本文中列举的这些SDK和API或许会非常有用。

在过去4年时间里，我一直致力于构建Android app，下面这些是我构建新app时的必备品，所以推荐给大家。

Material design support library

在开发一个现代化的Android app时，我们总是希望能够使用最新和最棒的设计组件。这通常会使你的应用程序不需要额外装饰就可以看上去很漂亮。你可以有例如波纹的甜美效果，和如FAB这样的新部件。并且design support library允许你在预装棒棒糖的手机上面使用华丽的设计元素。

Gradle的依赖项：

编译“com.android.support:design:22.2.0”

用法示例：

• http://stackoverflow.com/a/28715666
• http://stackoverflow.com/a/30903356

Picasso image loading

加载图像极其耗费RAM。我试过很多库来简化这个过程。个人认为，Square的Picasso是耐用性和易用性的最佳结合。

Gradle的依赖项：

编译“com.squareup.picasso:picasso:2.5.2”

用法示例：

• http://square.github.io/picasso

Mixpanel analytics

没有漏斗分析的移动app注定是要失败的——《Lean Startup》，一本在此领域类似于圣经的书。谷歌分析过于片断化，并且可能会夸大其词。 Mixpanel既精准又敏感。虽然不便宜，但我必须强调其支持真的很棒。

Gradle的依赖项：

编译“com.mixpanel.android:mixpanel-android:4.5.3”

使用示例：

• https://mixpanel.com/help/reference/android

ACRA + tracepot crash reporting

谷歌play store开发者有一个Crashes & ANRs部分。但是，当发生崩溃时，用户必须手动发送报告。如果你真的想把事情安排妥当，那么你应该使用ACRA库，并将其连接到tracepot的后端，以便于查看仪表板。

每次崩溃发生的时候，ACRA都会发送崩溃报告，哪怕用户不发送。 ACRA支持多个报告后端。我选择tracepot是因为它最容易与ACRA整合，只需要引用tracepot在ACRA初始化调用时给你的URL即可。

Gradle的依赖项：

编译“ch.acra：ACRA：4.6.1”

ACRA文档：

• https://github.com/ACRA/acra/wiki/BasicSetup

tracepot：

• http://www.tracepot.com

AppCompat and Support library

这两个不用我多说，基本上是强制性的，它们能在旧设备上支持新功能，从片段到查看寻呼机，一应俱全。

Gradle的依赖项：

编译“com.android.support:appcompat-v7:22.2.0”编译“com.android.support:support-v4:22.2.0”

用法示例：

• http://stackoverflow.com/a/18941423
• http://stackoverflow.com/a/13042867

WhereDat API

你可以使用Android App Search和Lookup API，来获取有关app的数据。

文档：

http://wheredatapp.com/developers

用法示例：

• http://stackoverflow.com/a/30406757
• http://stackoverflow.com/a/30065668

RAID 的意思是廉价磁盘冗余阵列（Redundant Array of Inexpensive Disks），但现在它被称为独立磁盘冗余阵列（Redundant Array of Independent Drives）。早先一个容量很小的磁盘都是非常昂贵的，但是现在我们可以很便宜的买到一个更大的磁盘。Raid 是一系列放在一起，成为一个逻辑卷的磁盘集合。

在 Linux 中理解 RAID 设置

RAID 包含一组或者一个集合甚至一个阵列。使用一组磁盘结合驱动器组成 RAID 阵列或 RAID 集。将至少两个磁盘连接到一个 RAID 控制器，而成为一个逻辑卷，也可以将多个驱动器放在一个组中。一组磁盘只能使用一个 RAID 级别。使用 RAID 可以提高服务器的性能。不同 RAID 的级别，性能会有所不同。它通过容错和高可用性来保存我们的数据。

这个系列被命名为“在 Linux 下使用 RAID”，分为9个部分，包括以下主题：

• 第1部分：介绍 RAID 的级别和概念
• 第2部分：在Linux中如何设置 RAID0（条带化）
• 第3部分：在Linux中如何设置 RAID1（镜像化）
• 第4部分：在Linux中如何设置 RAID5（条带化与分布式奇偶校验）
• 第5部分：在Linux中如何设置 RAID6（条带双分布式奇偶校验）
• 第6部分：在Linux中设置 RAID 10 或1 + 0（嵌套）
• 第7部分：扩展现有的 RAID 阵列和删除故障的磁盘
• 第8部分：在 RAID 中恢复（重建）损坏的驱动器
• 第9部分：在 Linux 中管理 RAID

这是9篇系列教程的第1部分，在这里我们将介绍 RAID 的概念和 RAID 级别，这是在 Linux 中构建 RAID 需要理解的。

软件 RAID 和硬件 RAID

软件 RAID 的性能较低，因为其使用主机的资源。 需要加载 RAID 软件以从软件 RAID 卷中读取数据。在加载 RAID 软件前，操作系统需要引导起来才能加载 RAID 软件。在软件 RAID 中无需物理硬件。零成本投资。

硬件 RAID 的性能较高。他们采用 PCI Express 卡物理地提供有专用的 RAID 控制器。它不会使用主机资源。他们有 NVRAM 用于缓存的读取和写入。缓存用于 RAID 重建时，即使出现电源故障，它会使用后备的电池电源保持缓存。对于大规模使用是非常昂贵的投资。

硬件 RAID 卡如下所示：

硬件 RAID

重要的 RAID 概念

• 校验方式用在 RAID 重建中从校验所保存的信息中重新生成丢失的内容。 RAID 5，RAID 6 基于校验。
• 条带化是将切片数据随机存储到多个磁盘。它不会在单个磁盘中保存完整的数据。如果我们使用2个磁盘，则每个磁盘存储我们的一半数据。
• 镜像被用于 RAID 1 和 RAID 10。镜像会自动备份数据。在 RAID 1 中，它会保存相同的内容到其他盘上。
• 热备份只是我们的服务器上的一个备用驱动器，它可以自动更换发生故障的驱动器。在我们的阵列中，如果任何一个驱动器损坏，热备份驱动器会自动用于重建 RAID。
• 块是 RAID 控制器每次读写数据时的最小单位，最小 4KB。通过定义块大小，我们可以增加 I/O 性能。

RAID有不同的级别。在这里，我们仅列出在真实环境下的使用最多的 RAID 级别。

• RAID0 = 条带化
• RAID1 = 镜像
• RAID5 = 单磁盘分布式奇偶校验
• RAID6 = 双磁盘分布式奇偶校验
• RAID10 = 镜像 + 条带。（嵌套RAID）

RAID 在大多数 Linux 发行版上使用名为 mdadm 的软件包进行管理。让我们先对每个 RAID 级别认识一下。

RAID 0 / 条带化

条带化有很好的性能。在 RAID 0（条带化）中数据将使用切片的方式被写入到磁盘。一半的内容放在一个磁盘上，另一半内容将被写入到另一个磁盘。

假设我们有2个磁盘驱动器，例如，如果我们将数据“TECMINT”写到逻辑卷中，“T”将被保存在第一盘中，“E”将保存在第二盘，’C’将被保存在第一盘，“M”将保存在第二盘，它会一直继续此循环过程。（LCTT 译注：实际上不可能按字节切片，是按数据块切片的。）

在这种情况下，如果驱动器中的任何一个发生故障，我们就会丢失数据，因为一个盘中只有一半的数据，不能用于重建 RAID。不过，当比较写入速度和性能时，RAID 0 是非常好的。创建 RAID 0（条带化）至少需要2个磁盘。如果你的数据是非常宝贵的，那么不要使用此 RAID 级别。

• 高性能。
• RAID 0 中容量零损失。
• 零容错。
• 写和读有很高的性能。

RAID 1 / 镜像化

镜像也有不错的性能。镜像可以对我们的数据做一份相同的副本。假设我们有两个2TB的硬盘驱动器，我们总共有4TB，但在镜像中，但是放在 RAID 控制器后面的驱动器形成了一个逻辑驱动器，我们只能看到这个逻辑驱动器有2TB。

当我们保存数据时，它将同时写入这两个2TB驱动器中。创建 RAID 1（镜像化）最少需要两个驱动器。如果发生磁盘故障，我们可以通过更换一个新的磁盘恢复 RAID 。如果在 RAID 1 中任何一个磁盘发生故障，我们可以从另一个磁盘中获取相同的数据，因为另外的磁盘中也有相同的数据。所以是零数据丢失。

• 良好的性能。
• 总容量丢失一半可用空间。
• 完全容错。
• 重建会更快。
• 写性能变慢。
• 读性能变好。
• 能用于操作系统和小规模的数据库。

RAID 5 / 分布式奇偶校验

RAID 5 多用于企业级。 RAID 5 的以分布式奇偶校验的方式工作。奇偶校验信息将被用于重建数据。它从剩下的正常驱动器上的信息来重建。在驱动器发生故障时，这可以保护我们的数据。

假设我们有4个驱动器，如果一个驱动器发生故障而后我们更换发生故障的驱动器后，我们可以从奇偶校验中重建数据到更换的驱动器上。奇偶校验信息存储在所有的4个驱动器上，如果我们有4个 1TB 的驱动器。奇偶校验信息将被存储在每个驱动器的256G中，而其它768GB是用户自己使用的。单个驱动器故障后，RAID 5 依旧正常工作，如果驱动器损坏个数超过1个会导致数据的丢失。

• 性能卓越
• 读速度将非常好。
• 写速度处于平均水准，如果我们不使用硬件 RAID 控制器，写速度缓慢。
• 从所有驱动器的奇偶校验信息中重建。
• 完全容错。
• 1个磁盘空间将用于奇偶校验。
• 可以被用在文件服务器，Web服务器，非常重要的备份中。

RAID 6 双分布式奇偶校验磁盘

RAID 6 和 RAID 5 相似但它有两个分布式奇偶校验。大多用在大数量的阵列中。我们最少需要4个驱动器，即使有2个驱动器发生故障，我们依然可以更换新的驱动器后重建数据。

它比 RAID 5 慢，因为它将数据同时写到4个驱动器上。当我们使用硬件 RAID 控制器时速度就处于平均水准。如果我们有6个的1TB驱动器，4个驱动器将用于数据保存，2个驱动器将用于校验。

• 性能不佳。
• 读的性能很好。
• 如果我们不使用硬件 RAID 控制器写的性能会很差。
• 从两个奇偶校验驱动器上重建。
• 完全容错。
• 2个磁盘空间将用于奇偶校验。
• 可用于大型阵列。
• 用于备份和视频流中，用于大规模。

RAID 10 / 镜像+条带

RAID 10 可以被称为1 + 0或0 +1。它将做镜像+条带两个工作。在 RAID 10 中首先做镜像然后做条带。在 RAID 01 上首先做条带，然后做镜像。RAID 10 比 01 好。

假设，我们有4个驱动器。当我逻辑卷上写数据时，它会使用镜像和条带的方式将数据保存到4个驱动器上。

如果我在 RAID 10 上写入数据“TECMINT”，数据将使用如下方式保存。首先将“T”同时写入两个磁盘，“E”也将同时写入另外两个磁盘，所有数据都写入两块磁盘。这样可以将每个数据复制到另外的磁盘。

同时它将使用 RAID 0 方式写入数据，遵循将“T”写入第一组盘，“E”写入第二组盘。再次将“C”写入第一组盘，“M”到第二组盘。

• 良好的读写性能。
• 总容量丢失一半的可用空间。
• 容错。
• 从副本数据中快速重建。
• 由于其高性能和高可用性，常被用于数据库的存储中。

结论

在这篇文章中，我们已经了解了什么是 RAID 和在实际环境大多采用哪个级别的 RAID。希望你已经学会了上面所写的。对于 RAID 的构建必须了解有关 RAID 的基本知识。以上内容可以基本满足你对 RAID 的了解。

在接下来的文章中，我将介绍如何设置和使用各种级别创建 RAID，增加 RAID 组（阵列）和驱动器故障排除等。

---

via: http://www.tecmint.com/understanding-raid-setup-in-linux/

作者：Babin Lonston 译者：strugglingyouth 校对：wxy

本文由 LCTT 原创翻译，Linux中国 荣誉推出

RAID 即廉价磁盘冗余阵列，其高可用性和可靠性适用于大规模环境中，相比正常使用，数据更需要被保护。RAID 是一些磁盘的集合，是包含一个阵列的逻辑卷。驱动器可以组合起来成为一个阵列或称为（组的）集合。

创建 RAID 最少应使用2个连接到 RAID 控制器的磁盘组成，来构成逻辑卷，可以根据定义的 RAID 级别将更多的驱动器添加到一个阵列中。不使用物理硬件创建的 RAID 被称为软件 RAID。软件 RAID 也叫做穷人 RAID。

在 Linux 中创建 RAID0

使用 RAID 的主要目的是为了在发生单点故障时保存数据，如果我们使用单个磁盘来存储数据，如果它损坏了，那么就没有机会取回我们的数据了，为了防止数据丢失我们需要一个容错的方法。所以，我们可以使用多个磁盘组成 RAID 阵列。

在 RAID 0 中条带是什么

条带是通过将数据在同时分割到多个磁盘上。假设我们有两个磁盘，如果我们将数据保存到该逻辑卷上，它会将数据保存在两个磁盘上。使用 RAID 0 是为了获得更好的性能，但是如果驱动器中一个出现故障，我们将不能得到完整的数据。因此，使用 RAID 0 不是一种好的做法。唯一的解决办法就是安装有 RAID 0 逻辑卷的操作系统来提高重要文件的安全性。

• RAID 0 性能较高。
• 在 RAID 0 上，空间零浪费。
• 零容错（如果硬盘中的任何一个发生故障，无法取回数据）。
• 写和读性能都很好。

要求

创建 RAID 0 允许的最小磁盘数目是2个，但你可以添加更多的磁盘，不过数目应该是2，4，6，8等的偶数。如果你有一个物理 RAID 卡并且有足够的端口，你可以添加更多磁盘。

在这里，我们没有使用硬件 RAID，此设置只需要软件 RAID。如果我们有一个物理硬件 RAID 卡，我们可以从它的功能界面访问它。有些主板默认内建 RAID 功能，还可以使用 Ctrl + I 键访问它的界面。

如果你是刚开始设置 RAID，请阅读我们前面的文章，我们已经介绍了一些关于 RAID 基本的概念。

• 介绍 RAID 的级别和概念

我的服务器设置

操作系统 :  CentOS 6.5 Final
IP 地址    :  192.168.0.225
两块盘    :  20 GB each

这是9篇系列教程的第2部分，在这部分，我们将看看如何能够在 Linux 上创建和使用 RAID 0（条带化），以名为 sdb 和 sdc 两个 20GB 的硬盘为例。

第1步：更新系统和安装管理 RAID 的 mdadm 软件

1、 在 Linux 上设置 RAID 0 前，我们先更新一下系统，然后安装mdadm 包。mdadm 是一个小程序，这将使我们能够在Linux下配置和管理 RAID 设备。

# yum clean all && yum update
# yum install mdadm -y

安装 mdadm 工具

第2步：确认连接了两个 20GB 的硬盘

2、 在创建 RAID 0 前，请务必确认两个硬盘能被检测到，使用下面的命令确认。

# ls -l /dev | grep sd

检查硬盘

3、 一旦检测到新的硬盘驱动器，同时检查是否连接的驱动器已经被现有的 RAID 使用，使用下面的mdadm 命令来查看。

# mdadm --examine /dev/sd[b-c]

检查 RAID 设备

从上面的输出我们可以看到，没有任何 RAID 使用 sdb 和 sdc 这两个驱动器。

第3步：创建 RAID 分区

4、 现在用 sdb 和 sdc 创建 RAID 的分区，使用 fdisk 命令来创建。在这里，我将展示如何创建 sdb 驱动器上的分区。

# fdisk /dev/sdb

请按照以下说明创建分区。

• 按n 创建新的分区。
• 然后按P 选择主分区。
• 接下来选择分区号为1。
• 只需按两次回车键选择默认值即可。
• 然后，按P 来显示创建好的分区。

创建分区

请按照以下说明将分区创建为 Linux 的 RAID 类型。

• 按L，列出所有可用的类型。
• 按t 去修改分区。
• 键入fd 设置为 Linux 的 RAID 类型，然后按回车确认。
• 然后再次使用p查看我们所做的更改。
• 使用w保存更改。

在 Linux 上创建 RAID 分区

注: 请使用上述步骤同样在 sdc 驱动器上创建分区。

5、 创建分区后，验证这两个驱动器是否正确定义 RAID，使用下面的命令。

# mdadm --examine /dev/sd[b-c]
# mdadm --examine /dev/sd[b-c]1

验证 RAID 分区

第4步：创建 RAID md 设备

6、 现在使用以下命令创建 md 设备（即 /dev/md0），并选择 RAID 合适的级别。

# mdadm -C /dev/md0 -l raid0 -n 2 /dev/sd[b-c]1
# mdadm --create /dev/md0 --level=stripe --raid-devices=2 /dev/sd[b-c]1

• -C – 创建
• -l – 级别
• -n – RAID 设备数

7、 一旦 md 设备已经建立，使用如下命令可以查看 RAID 级别，设备和阵列的使用状态。

# cat /proc/mdstat

查看 RAID 级别

# mdadm -E /dev/sd[b-c]1

查看 RAID 设备

# mdadm --detail /dev/md0

查看 RAID 阵列

第5步：给 RAID 设备创建文件系统

8、 将 RAID 设备 /dev/md0 创建为 ext4 文件系统，并挂载到 /mnt/raid0 下。

# mkfs.ext4 /dev/md0

创建 ext4 文件系统

9、 在 RAID 设备上创建好 ext4 文件系统后，现在创建一个挂载点（即 /mnt/raid0），并将设备 /dev/md0 挂载在它下。

# mkdir /mnt/raid0
# mount /dev/md0 /mnt/raid0/

10、下一步，使用 df 命令验证设备 /dev/md0 是否被挂载在 /mnt/raid0 下。

# df -h

11、 接下来，在挂载点 /mnt/raid0 下创建一个名为tecmint.txt 的文件，为创建的文件添加一些内容，并查看文件和目录的内容。

# touch /mnt/raid0/tecmint.txt
# echo "Hi everyone how you doing ?" > /mnt/raid0/tecmint.txt
# cat /mnt/raid0/tecmint.txt
# ls -l /mnt/raid0/

验证挂载的设备

12、 当你验证挂载点后，就可以将它添加到 /etc/fstab 文件中。

# vim /etc/fstab

添加以下条目，根据你的安装位置和使用文件系统的不同，自行做修改。

/dev/md0                /mnt/raid0              ext4    deaults         0 0

添加设备到 fstab 文件中

13、 使用 mount 命令的 -a 来检查 fstab 的条目是否有误。

# mount -av

检查 fstab 文件是否有误

第6步：保存 RAID 配置

14、 最后，保存 RAID 配置到一个文件中，以供将来使用。我们再次使用带有-s (scan) 和-v (verbose) 选项的 mdadm 命令，如图所示。

# mdadm -E -s -v >> /etc/mdadm.conf
# mdadm --detail --scan --verbose >> /etc/mdadm.conf
# cat /etc/mdadm.conf

保存 RAID 配置

就这样，我们在这里看到，如何通过使用两个硬盘配置具有条带化的 RAID 0 。在接下来的文章中，我们将看到如何设置 RAID 1。

---

via: http://www.tecmint.com/create-raid0-in-linux/

作者：Babin Lonston 译者：strugglingyouth 校对：wxy

本文由 LCTT 原创翻译，Linux中国 荣誉推出

如果你已经阅读了前面的如何监控 NGINX，你应该知道从你网络环境的几个指标中可以获取多少信息。而且你也看到了从 NGINX 特定的基础中收集指标是多么容易的。但要实现全面，持续的监控 NGINX，你需要一个强大的监控系统来存储并将指标可视化，当异常发生时能提醒你。在这篇文章中，我们将向你展示如何使用 Datadog 安装 NGINX 监控，以便你可以在定制的仪表盘中查看这些指标：

Datadog 允许你以单个主机、服务、流程和度量来构建图形和警告，或者使用它们的几乎任何组合构建。例如，你可以监控你的所有主机，或者某个特定可用区域的所有NGINX主机，或者您可以监视具有特定标签的所有主机的一个关键指标。本文将告诉您如何：

• 在 Datadog 仪表盘上监控 NGINX 指标，就像监控其他系统一样
• 当一个关键指标急剧变化时设置自动警报来通知你

配置 NGINX

为了收集 NGINX 指标，首先需要确保 NGINX 已启用 status 模块和一个 报告 status 指标的 URL。一步步的配置开源 NGINX 和 NGINX Plus 请参见之前的相关文章。

整合 Datadog 和 NGINX

安装 Datadog 代理

Datadog 代理是一个开源软件，它能收集和报告你主机的指标，这样就可以使用 Datadog 查看和监控他们。安装这个代理通常仅需要一个命令

只要你的代理启动并运行着，你会看到你主机的指标报告在你 Datadog 账号下。

配置 Agent

接下来，你需要为代理创建一个简单的 NGINX 配置文件。在你系统中代理的配置目录应该在这儿找到。

在目录里面的 conf.d/nginx.yaml.example 中，你会发现一个简单的配置文件，你可以编辑并提供 status URL 和可选的标签为每个NGINX 实例：

init_config:
instances:
    -   nginx_status_url: http://localhost/nginx_status/
        tags:
            -   instance:foo

当你提供了 status URL 和任意 tag，将配置文件保存为 conf.d/nginx.yaml。

重启代理

你必须重新启动代理程序来加载新的配置文件。重新启动命令在这里，根据平台的不同而不同。

检查配置文件

要检查 Datadog 和 NGINX 是否正确整合，运行 Datadog 的 info 命令。每个平台使用的命令看这儿。

如果配置是正确的，你会看到这样的输出：

Checks
======
  [...]
  nginx
  -----
      - instance #0 [OK]
      - Collected 8 metrics & 0 events

安装整合

最后，在你的 Datadog 帐户打开“Nginx 整合”。这非常简单，你只要在 NGINX 整合设置中点击“Install Integration”按钮。

指标!

一旦代理开始报告 NGINX 指标，你会看到一个 NGINX 仪表盘出现在在你 Datadog 可用仪表盘的列表中。

基本的 NGINX 仪表盘显示有用的图表，囊括了几个我们的 NGINX 监控介绍中的关键指标。 （一些指标，特别是请求处理时间要求进行日志分析，Datadog 不支持。）

你可以通过增加 NGINX 之外的重要指标的图表来轻松创建一个全面的仪表盘，以监控你的整个网站设施。例如，你可能想监视你 NGINX 的主机级的指标，如系统负载。要构建一个自定义的仪表盘，只需点击靠近仪表盘的右上角的选项并选择“Clone Dash”来克隆一个默认的 NGINX 仪表盘。

你也可以使用 Datadog 的主机地图在更高层面监控你的 NGINX 实例，举个例子，用颜色标示你所有的 NGINX 主机的 CPU 使用率来辨别潜在热点。

NGINX 指标警告

一旦 Datadog 捕获并可视化你的指标，你可能会希望建立一些监控自动地密切关注你的指标，并当有问题提醒你。下面将介绍一个典型的例子：一个提醒你 NGINX 吞吐量突然下降时的指标监控器。

监控 NGINX 吞吐量

Datadog 指标警报可以是“基于吞吐量的”（当指标超过设定值会警报）或“基于变化幅度的”（当指标的变化超过一定范围会警报）。在这个例子里，我们会采取后一种方式，当每秒传入的请求急剧下降时会提醒我们。下降往往意味着有问题。

1. 创建一个新的指标监控。从 Datadog 的“Monitors”下拉列表中选择“New Monitor”。选择“Metric”作为监视器类型。

   

2. 定义你的指标监视器。我们想知道 NGINX 每秒总的请求量下降的数量，所以我们在基础设施中定义我们感兴趣的 nginx.net.requestpers 之和。

   

3. 设置指标警报条件。我们想要在变化时警报，而不是一个固定的值，所以我们选择“Change Alert”。我们设置监控为无论何时请求量下降了30％以上时警报。在这里，我们使用一个一分钟的数据窗口来表示 “now” 指标的值，对横跨该间隔内的平均变化和之前 10 分钟的指标值作比较。

   

4. 自定义通知。如果 NGINX 的请求量下降，我们想要通知我们的团队。在这个例子中，我们将给 ops 团队的聊天室发送通知，并给值班工程师发送短信。在“Say what’s happening”中，我们会为监控器命名，并添加一个伴随该通知的短消息，建议首先开始调查的内容。我们会 @ ops 团队使用的 Slack，并 @pagerduty 将警告发给短信。

   

5. 保存集成监控。点击页面底部的“Save”按钮。你现在在监控一个关键的 NGINX 工作指标，而当它快速下跌时会给值班工程师发短信。

结论

在这篇文章中，我们谈到了通过整合 NGINX 与 Datadog 来可视化你的关键指标，并当你的网络基础架构有问题时会通知你的团队。

如果你一直使用你自己的 Datadog 账号，你现在应该可以极大的提升你的 web 环境的可视化，也有能力对你的环境、你所使用的模式、和对你的组织最有价值的指标创建自动监控。

如果你还没有 Datadog 帐户，你可以注册免费试用，并开始监视你的基础架构，应用程序和现在的服务。

---

via: https://www.datadoghq.com/blog/how-to-monitor-nginx-with-datadog/

作者：K Young 译者：strugglingyouth 校对：wxy

本文由 LCTT 原创翻译，Linux中国 荣誉推出