Ubuntu 下对切屏幕的方法

Mac 下有很好的窗口管理工具 divvy,在 UBUNTU 下没有特别好用的工具,但是使用 wmctrl 和一段脚本就可以实现基本的屏幕对切的功能:

安装 wmctrl

sudo apt-get install wmctrl

安装 shell 脚本

#!/bin/sh
set -- $(xwininfo -root| awk -F '[ :]+' '/ (Width|Height):/ { print $3 }')
width=$1
height=$2
win1=$(xwininfo| awk '/^xwininfo: W/ { print $4 }')
win2=$(xwininfo| awk '/^xwininfo: W/ { print $4 }')
wmctrl -i -r $win1 -e 0,0,0,$((width/2)),$height
wmctrl -i -r $win2 -e 0,$((width/2)),0,$((width/2)),$height

使用

执行脚本,点击选择 2 个窗口,就可以将 2 个窗口左右平铺整个屏幕。

根据这个脚本,其实你可以设计出更复杂的切分方案。

为什么人人都该懂点LLVM

只要你和程序打交道,了解编译器架构就会令你受益无穷——无论是分析程序效率,还是模拟新的处理器和操作系统。通过本文介绍,即使你对编译器原本一知半解,也能开始用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的替代品等等。它还描述了一些快速类型检查工具 isacastdyn_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::getOrInsertFunctionIRBuilder::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 BradburyLLVM周报是个跟进LLVM生态圈的好资源。

深入分析 Docker 镜像原理

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

1.1 什么是Docker镜像

深入分析 Docker 镜像原理
深入分析 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 文件存储路径展示如下:

深入分析 Docker 镜像原理
深入分析 Docker 镜像原理

除了 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容器的角度,来反推三者的关系。首先可以来看下图:

深入分析 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会永远留在下层,但是没有影响

如何在 Linux 终端中知道你的公有 IP

公有地址由 InterNIC 分配并由基于类的网络 ID 或基于 CIDR 的地址块构成(被称为 CIDR 块),并保证了在全球互联网中的唯一性。当公有地址被分配时,其路由将会被记录到互联网中的路由器中,这样访问公有地址的流量就能顺利到达。访问目标公有地址的流量可经由互联网抵达。比如,当一个 CIDR 块被以网络 ID 和子网掩码的形式分配给一个组织时,对应的 [网络 ID,子网掩码] 也会同时作为路由储存在互联网中的路由器中。目标是 CIDR 块中的地址的 IP 封包会被导向对应的位置。

在本文中我将会介绍在几种在 Linux 终端中查看你的公有 IP 地址的方法。这对普通用户来说并无意义,但 Linux 服务器(无GUI或者作为只能使用基本工具的用户登录时)会很有用。无论如何,从 Linux 终端中获取公有 IP 在各种方面都很意义,说不定某一天就能用得着。

以下是我们主要使用的两个命令,curl 和 wget。你可以换着用。

Curl 纯文本格式输出:

curl icanhazip.com
curl ifconfig.me
curl curlmyip.com
curl ip.appspot.com
curl ipinfo.io/ip
curl ipecho.net/plain
curl www.trackip.net/i

curl JSON格式输出:

curl ipinfo.io/json
curl ifconfig.me/all.json
curl www.trackip.net/ip?json (有点丑陋)

curl XML格式输出:

curl ifconfig.me/all.xml

curl 得到所有IP细节 (挖掘机)

curl ifconfig.me/all

使用 DYDNS (当你使用 DYDNS 服务时有用)

curl -s 'http://checkip.dyndns.org' | sed 's/.*Current IP Address: \([0-9\.]*\).*/\1/g'
curl -s http://checkip.dyndns.org/ | grep -o "[[:digit:].]\+"

使用 Wget 代替 Curl

wget http://ipecho.net/plain -O - -q ; echo
wget http://observebox.com/ip -O - -q ; echo

使用 host 和 dig 命令

如果有的话,你也可以直接使用 host 和 dig 命令。

host -t a dartsclink.com | sed 's/.*has address //'
dig +short myip.opendns.com @resolver1.opendns.com

bash 脚本示例:

#!/bin/bash
PUBLIC_IP=`wget http://ipecho.net/plain -O - -q ; echo`
echo $PUBLIC_IP

简单易用。

我实际上是在写一个用于记录每日我的路由器中所有 IP 变化并保存到一个文件的脚本。我在搜索过程中找到了这些很好用的命令。希望某天它能帮到其他人。


via: http://www.blackmoreops.com/2015/06/14/how-to-get-public-ip-from-linux-terminal/

译者:KevinSJ 校对:wxy

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

每个 Android 开发者应该知道的 6 个 SDK 和 API

说到软件开发,有人或许会感叹了解平台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”

用法示例:

Picasso image loading

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

Gradle的依赖项:

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

用法示例:

Mixpanel analytics

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

Gradle的依赖项:

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

使用示例:

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文档:

tracepot:

AppCompat and Support library

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

Gradle的依赖项:

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

用法示例:

WhereDat API

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

文档:

http://wheredatapp.com/developers

用法示例:

在 Linux 下使用 RAID(一):介绍 RAID 的级别和概念

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

RAID in Linux

在 Linux 中理解 RAID 设置

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

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

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

软件 RAID 和硬件 RAID

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

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

硬件 RAID 卡如下所示:

Hardware 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中国 荣誉推出

在 Linux 下使用 RAID(二):使用 mdadm 工具创建软件 RAID 0 (条带化)

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

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

Setup RAID0 in Linux

在 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 基本的概念。

我的服务器设置

操作系统 :  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

install mdadm in linux

安装 mdadm 工具

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

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

# ls -l /dev | grep sd

Check Hard Drives in Linux

检查硬盘

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

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

Check RAID Devices in Linux

检查 RAID 设备

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

第3步:创建 RAID 分区

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

# fdisk /dev/sdb

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

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

Create Partitions in Linux

创建分区

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

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

Create RAID Partitions

在 Linux 上创建 RAID 分区

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

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

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

Verify RAID Partitions

验证 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

Verify RAID Level

查看 RAID 级别

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

Verify RAID Device

查看 RAID 设备

# mdadm --detail /dev/md0

Verify RAID Array

查看 RAID 阵列

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

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

# mkfs.ext4 /dev/md0

Create ext4 Filesystem in Linux

创建 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/

Verify Mount Device

验证挂载的设备

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

# vim /etc/fstab

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

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

Add Device to Fstab

添加设备到 fstab 文件中

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

# mount -av

Check Errors in Fstab

检查 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

Save RAID Configurations

保存 RAID 配置

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


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

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

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

如何使用 Datadog 监控 NGINX(第三篇)

如何使用 Datadog 监控 NGINX(第三篇)
如何使用 Datadog 监控 NGINX(第三篇)

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

如何使用 Datadog 监控 NGINX(第三篇)
如何使用 Datadog 监控 NGINX(第三篇)

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

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

配置 NGINX

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

整合 Datadog 和 NGINX

安装 Datadog 代理

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

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

如何使用 Datadog 监控 NGINX(第三篇)
如何使用 Datadog 监控 NGINX(第三篇)

配置 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”按钮。

如何使用 Datadog 监控 NGINX(第三篇)
如何使用 Datadog 监控 NGINX(第三篇)

指标!

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

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

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

如何使用 Datadog 监控 NGINX(第三篇)
如何使用 Datadog 监控 NGINX(第三篇)

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

如何使用 Datadog 监控 NGINX(第三篇)
如何使用 Datadog 监控 NGINX(第三篇)

NGINX 指标警告

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

监控 NGINX 吞吐量

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

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

    如何使用 Datadog 监控 NGINX(第三篇)
    如何使用 Datadog 监控 NGINX(第三篇)
  2. 定义你的指标监视器。我们想知道 NGINX 每秒总的请求量下降的数量,所以我们在基础设施中定义我们感兴趣的 nginx.net.requestpers 之和。

    NGINX metric

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

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

    如何使用 Datadog 监控 NGINX(第三篇)
    如何使用 Datadog 监控 NGINX(第三篇)
  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中国 荣誉推出

在 Linux 下使用 RAID(三):用两块磁盘创建 RAID 1(镜像)

RAID 镜像意味着相同数据的完整克隆(或镜像),分别写入到两个磁盘中。创建 RAID 1 至少需要两个磁盘,而且仅用于读取性能或者可靠性要比数据存储容量更重要的场合。

Create Raid1 in Linux

在 Linux 中设置 RAID 1

创建镜像是为了防止因硬盘故障导致数据丢失。镜像中的每个磁盘包含数据的完整副本。当一个磁盘发生故障时,相同的数据可以从其它正常磁盘中读取。而后,可以从正在运行的计算机中直接更换发生故障的磁盘,无需任何中断。

RAID 1 的特点

  • 镜像具有良好的性能。

  • 磁盘利用率为50%。也就是说,如果我们有两个磁盘每个500GB,总共是1TB,但在镜像中它只会显示500GB。

  • 在镜像如果一个磁盘发生故障不会有数据丢失,因为两个磁盘中的内容相同。

  • 读取性能会比写入性能更好。

要求

创建 RAID 1 至少要有两个磁盘,你也可以添加更多的磁盘,磁盘数需为2,4,6,8等偶数。要添加更多的磁盘,你的系统必须有 RAID 物理适配器(硬件卡)。

这里,我们使用软件 RAID 不是硬件 RAID,如果你的系统有一个内置的物理硬件 RAID 卡,你可以从它的功能界面或使用 Ctrl + I 键来访问它。

需要阅读: 介绍 RAID 的级别和概念

在我的服务器安装

操作系统 :  CentOS 6.5 Final
IP 地址    :  192.168.0.226
主机名    :  rd1.tecmintlocal.com
磁盘 1 [20GB]  :  /dev/sdb
磁盘 2 [20GB]  :  /dev/sdc

本文将指导你在 Linux 平台上使用 mdadm (用于创建和管理 RAID )一步步的建立一个软件 RAID 1 (镜像)。同样的做法也适用于如 RedHat,CentOS,Fedora 等 Linux 发行版。

第1步:安装所需软件并且检查磁盘

1、 正如我前面所说,在 Linux 中我们需要使用 mdadm 软件来创建和管理 RAID。所以,让我们用 yum 或 apt-get 的软件包管理工具在 Linux 上安装 mdadm 软件包。

# yum install mdadm     [在 RedHat 系统]
# apt-get install mdadm     [在 Debain 系统]

2、 一旦安装好mdadm包,我们需要使用下面的命令来检查磁盘是否已经配置好。

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

Check RAID on Disks

检查 RAID 的磁盘

正如你从上面图片看到的,没有检测到任何超级块,这意味着还没有创建RAID。

第2步:为 RAID 创建分区

3、 正如我提到的,我们使用最少的两个分区 /dev/sdb 和 /dev/sdc 来创建 RAID 1。我们首先使用fdisk命令来创建这两个分区并更改其类型为 raid。

# fdisk /dev/sdb

按照下面的说明

  • n 创建新的分区。
  • 然后按 P 选择主分区。
  • 接下来选择分区号为1。
  • 按两次回车键默认将整个容量分配给它。
  • 然后,按 P 来打印创建好的分区。
  • L,列出所有可用的类型。
  • t 修改分区类型。
  • 键入 fd 设置为 Linux 的 RAID 类型,然后按 Enter 确认。
  • 然后再次使用p查看我们所做的更改。
  • 使用w保存更改。

Create Disk Partitions

创建磁盘分区

在创建“/dev/sdb”分区后,接下来按照同样的方法创建分区 /dev/sdc 。

# fdisk /dev/sdc

Create Second Partitions

创建第二个分区

4、 一旦这两个分区创建成功后,使用相同的命令来检查 sdb 和 sdc 分区并确认 RAID 分区的类型如上图所示。

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

Verify Partitions Changes

验证分区变化

Check RAID Type

检查 RAID 类型

注意: 正如你在上图所看到的,在 sdb1 和 sdc1 中没有任何对 RAID 的定义,这就是我们没有检测到超级块的原因。

第3步:创建 RAID 1 设备

5、 接下来使用以下命令来创建一个名为 /dev/md0 的“RAID 1”设备并验证它

# mdadm --create /dev/md0 --level=mirror --raid-devices=2 /dev/sd[b-c]1
# cat /proc/mdstat

Create RAID Device

创建RAID设备

6、 接下来使用如下命令来检查 RAID 设备类型和 RAID 阵列

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

Check RAID Device type

检查 RAID 设备类型

Check RAID Device Array

检查 RAID 设备阵列

从上图中,人们很容易理解,RAID 1 已经创建好了,使用了 /dev/sdb1 和 /dev/sdc1 分区,你也可以看到状态为 resyncing(重新同步中)。

第4步:在 RAID 设备上创建文件系统

7、 给 md0 上创建 ext4 文件系统

# mkfs.ext4 /dev/md0

Create RAID Device Filesystem

创建 RAID 设备文件系统

8、 接下来,挂载新创建的文件系统到“/mnt/raid1”,并创建一些文件,验证在挂载点的数据

# mkdir /mnt/raid1
# mount /dev/md0 /mnt/raid1/
# touch /mnt/raid1/tecmint.txt
# echo "tecmint raid setups" > /mnt/raid1/tecmint.txt

Mount Raid Device

挂载 RAID 设备

9、为了在系统重新启动自动挂载 RAID 1,需要在 fstab 文件中添加条目。打开/etc/fstab文件并添加以下行:

/dev/md0                /mnt/raid1              ext4    defaults        0 0

Raid Automount Device

自动挂载 Raid 设备

10、 运行mount -av,检查 fstab 中的条目是否有错误

# mount -av

Check Errors in fstab

检查 fstab 中的错误

11、 接下来,使用下面的命令保存 RAID 的配置到文件“mdadm.conf”中。

# mdadm --detail --scan --verbose >> /etc/mdadm.conf

Save Raid Configuration

保存 Raid 的配置

上述配置文件在系统重启时会读取并加载 RAID 设备。

第5步:在磁盘故障后检查数据

12、我们的主要目的是,即使在任何磁盘故障或死机时必须保证数据是可用的。让我们来看看,当任何一个磁盘不可用时会发生什么。

# mdadm --detail /dev/md0

Raid Device Verify

验证 RAID 设备

在上面的图片中,我们可以看到在 RAID 中有2个设备是可用的,并且 Active Devices 是2。现在让我们看看,当一个磁盘拔出(移除 sdc 磁盘)或损坏后会发生什么。

# ls -l /dev | grep sd
# mdadm --detail /dev/md0

Test RAID Devices

测试 RAID 设备

现在,在上面的图片中你可以看到,一个磁盘不见了。我从虚拟机上删除了一个磁盘。此时让我们来检查我们宝贵的数据。

# cd /mnt/raid1/
# cat tecmint.txt

Verify RAID Data

验证 RAID 数据

你可以看到我们的数据仍然可用。由此,我们可以了解 RAID 1(镜像)的优势。在接下来的文章中,我们将看到如何设置一个 RAID 5 条带化分布式奇偶校验。希望这可以帮助你了解 RAID 1(镜像)是如何工作的。


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

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

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

7 个去伪存真的 JavaScript 面试题

这次我要说的是如何淘汰那些滥竽充数的JavaScript程序员。

你会惊讶于居然有这么多人来面试工作,并且他们的简历描述得都貌似很牛逼的样子。但是如果你问他们相关问题的话,你就会发现他们对此一无所知。我不知道他们这些简历是真的还是只是一个噱头。所以和其他面试官一样,我也有我的一套方法首先确保面试的人是值得我去面试的——我可以在半小时内通过电话搞定。

因此,如果有些你认为应该有的问题却不在我的7个问题中,那可能是因为我将它放到了后面的面试环节里。

此外,我想对那些可能会认为技术面试并不能真正说明程序员是否真的优秀的人说……

你是对的。当我还是一个年轻的程序员时,如果面试技术问题,我也有同样的感觉。但现在,我成了面试官,我觉得这种方式,至少能证明那些通过技术面试的人比那些不能通过的人,是优秀程序员的可能性要大得多。

最后,我想说的是,我不会因为应聘者答错三两个问题或不按我预想地回答就将他们pass掉。但是,如果大多数问题对方都回答不出来的话,那我就会在心里给他亮起红灯!

下面这7个JavaScript面试问题是你应该在面试前先问的。否则,很有可能会浪费你的时间。

1.创建JavaScript对象的两种方法是什么?

这是一个非常简单的问题,如果你用过JavaScript的话。你至少得知道一种方法。但是,尽管如此,根据我的经验,也有很多自称是JavaScript程序员的人说不知道如何回答这个问题。

  • 使用“new”关键字来调用函数。
  • open/close花括号。
var o = {};

你也可以继续提问,“什么情况下使用new关键字创建对象?”但是,由于我只是想淘汰一些人,所以这些问题我会等到真正面试的时候去问。

2.如何创建数组?

这和“如何创建对象”是相同级别的问题。然而,也有一些人回答得了第一个问题,却不能回答这个问题。

用下面的代码,简简单单就能创建一个数组:

var myArray = new Array();

创建数组是一个很复杂的过程。但是我希望能从应聘者口中听到使用方括号的答案。

var myArray = [];

当然,我们还可以继续问其他问题,比如如何高效地删除JavaScript数组中的重复元素等,但是由于我们只需要知道应聘人员是否值得进一步的观察,关于数组的问题我会到此结束。

3.什么是变量提升(Variable Hoisting)?

这个问题稍微难一点,我也并不要求对方一定得回答出来。但是,通过这个问题能够快速确定应聘者的技术水平:他们是否真的像他们声明得那样理解这门编程语言?

变量提升指的是,无论变量是在范围内的哪个地方声明的,JavaScript引擎都会将这个声明移到该范围的顶部。如果在函数中间声明一个变量,例如在某一行中赋值一个变量:

function foo()
{
    // 此处省略若干代码
    var a = "abc";
}

实际上会这样运行代码:

function foo()
{
    var a;
    // 此处省略若干代码
    a = "abc";
}

4.全局变量有什么风险,以及如何保护代码不受干扰?

全局变量的危险之处在于其他人可以创建相同名称的变量,然后覆盖你正在使用的变量。这在任何语言中都是一个令人头疼的问题。

预防的方法也有很多。其中最常用的方法是创建一个包含其他所有变量的全局变量:

var applicationName = {};

然后,每当你需要创建一个全局变量的时候,将其附加到对象上即可。

applicationName.myVariable = "abc";

还有一种方法是将所有的代码封装到一个自动执行的函数中,这样一来,所有声明的变量都声明在该函数的范围内。

(function(){
   var a = "abc";
})();

在现实中,这两种方法你可能都会用到。

5.如何迭代JavaScript对象的成员变量?

for(var prop in obj){
    // bonus points for hasOwnProperty
    if(obj.hasOwnProperty(prop)){
        // do something here
    }
}

6.什么是闭包(Closure)?

闭包允许一个函数定义在另一个外部函数的作用域内,即便作用域内的其他东西都消失了,它仍可以访问该外部函数内的变量。如果应聘者能够说明,在for/next循环中使用闭包却不声明变量来保存迭代变量当前值的一些风险,那就应该给对方加分。

7.请描述你经历过的JavaScript单元测试。

关于这个问题,其实我们只是想看看应聘人员是否真的做过JavaScript单元测试。这是一个开放式问题,没有特定的正确答案,不过对方至少得能讲述进程中的一些事情。

欢迎大家补充。