Skip to content Skip to main navigation Skip to footer

Linux

Linux: 如何在Ubuntu下设置APT的网络代理(Proxy)

 在公司的网络中,系统有时候需要设置了网络代理之后,才能正常的访问外网,那么下面将会介绍如何在ubuntu linux系统中设置网络代理。

1# 编辑/etc/apt/apt.conf 配置文件(如果/etc/apt/目录下没有apt.conf文件,那么需要手动创建)

2# 按照下面的格式,将网络代理配置信息加入到apt.conf文件里。
Acquire::http::proxy “http://user:passwd@proxyserver:port”;

例如: Acquire::http::Proxy “http://192.168.0.1:80“;

3# 保存退出当前配置文件

4# 运行 sudo apt-get update 命令,来检测ubuntu系统是否能够正常更新。

ubuntutest@ubuntutest:~$ sudo apt-get update
[sudo] password for ubuntutest:
命中:1 http://archive.ubuntu.com/ubuntu xenial InRelease
获取:2 http://security.ubuntu.com/ubuntu xenial-security InRelease [102 kB]
获取:3 http://archive.ubuntu.com/ubuntu xenial-updates InRelease [102 kB]
获取:4 http://archive.ubuntu.com/ubuntu xenial-backports InRelease [102 kB]
已下载 306 kB,耗时 1秒 (250 kB/s)
正在读取软件包列表... 完成

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单元测试。这是一个开放式问题,没有特定的正确答案,不过对方至少得能讲述进程中的一些事情。

欢迎大家补充。

在 Linux 下使用 RAID(四):创建 RAID 5(条带化与分布式奇偶校验)

在 RAID 5 中,数据条带化后存储在分布式奇偶校验的多个磁盘上。分布式奇偶校验的条带化意味着它将奇偶校验信息和条带化数据分布在多个磁盘上,这样会有很好的数据冗余。

Setup Raid 5 in CentOS

在 Linux 中配置 RAID 5

对于此 RAID 级别它至少应该有三个或更多个磁盘。RAID 5 通常被用于大规模生产环境中,以花费更多的成本来提供更好的数据冗余性能。

什么是奇偶校验?

奇偶校验是在数据存储中检测错误最简单的常见方式。奇偶校验信息存储在每个磁盘中,比如说,我们有4个磁盘,其中相当于一个磁盘大小的空间被分割去存储所有磁盘的奇偶校验信息。如果任何一个磁盘出现故障,我们可以通过更换故障磁盘后,从奇偶校验信息重建得到原来的数据。

RAID 5 的优点和缺点

  • 提供更好的性能。
  • 支持冗余和容错。
  • 支持热备份。
  • 将用掉一个磁盘的容量存储奇偶校验信息。
  • 单个磁盘发生故障后不会丢失数据。我们可以更换故障硬盘后从奇偶校验信息中重建数据。
  • 适合于面向事务处理的环境,读操作会更快。
  • 由于奇偶校验占用资源,写操作会慢一些。
  • 重建需要很长的时间。

要求

创建 RAID 5 最少需要3个磁盘,你也可以添加更多的磁盘,前提是你要有多端口的专用硬件 RAID 控制器。在这里,我们使用“mdadm”包来创建软件 RAID。

mdadm 是一个允许我们在 Linux 下配置和管理 RAID 设备的包。默认情况下没有 RAID 的配置文件,我们在创建和配置 RAID 后必须将配置文件保存在一个单独的文件 mdadm.conf 中。

在进一步学习之前,我建议你通过下面的文章去了解 Linux 中 RAID 的基础知识。

我的服务器设置

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

这是9篇系列教程的第4部分,在这里我们要在 Linux 系统或服务器上使用三个20GB(名为/dev/sdb, /dev/sdc 和 /dev/sdd)的磁盘建立带有分布式奇偶校验的软件 RAID 5。

第1步:安装 mdadm 并检验磁盘

1、 正如我们前面所说,我们使用 CentOS 6.5 Final 版本来创建 RAID 设置,但同样的做法也适用于其他 Linux 发行版。

# lsb_release -a
# ifconfig | grep inet

Setup Raid 5 in CentOS

CentOS 6.5 摘要

2、 如果你按照我们的 RAID 系列去配置的,我们假设你已经安装了“mdadm”包,如果没有,根据你的 Linux 发行版使用下面的命令安装。

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

3、 “mdadm”包安装后,先使用fdisk命令列出我们在系统上增加的三个20GB的硬盘。

# fdisk -l | grep sd

Install mdadm Tool in CentOS

安装 mdadm 工具

4、 现在该检查这三个磁盘是否存在 RAID 块,使用下面的命令来检查。

# mdadm -E /dev/sd[b-d]
# mdadm --examine /dev/sdb /dev/sdc /dev/sdd # 或

Examine Drives For Raid

检查 Raid 磁盘

注意: 上面的图片说明,没有检测到任何超级块。所以,这三个磁盘中没有定义 RAID。让我们现在开始创建一个吧!

第2步:为磁盘创建 RAID 分区

5、 首先,在创建 RAID 前磁盘(/dev/sdb, /dev/sdc 和 /dev/sdd)必须有分区,因此,在进行下一步之前,先使用fdisk命令进行分区。

# fdisk /dev/sdb
# fdisk /dev/sdc
# fdisk /dev/sdd

创建 /dev/sdb 分区

请按照下面的说明在 /dev/sdb 硬盘上创建分区。

  • n 创建新的分区。
  • 然后按 P 选择主分区。选择主分区是因为还没有定义过分区。
  • 接下来选择分区号为1。默认就是1。
  • 这里是选择柱面大小,我们没必要选择指定的大小,因为我们需要为 RAID 使用整个分区,所以只需按两次 Enter 键默认将整个容量分配给它。
  • 然后,按 P 来打印创建好的分区。
  • 改变分区类型,按 L可以列出所有可用的类型。
  • t 修改分区类型。
  • 这里使用fd设置为 RAID 的类型。
  • 然后再次使用p查看我们所做的更改。
  • 使用w保存更改。

Create sdb Partition

创建 sdb 分区

注意: 我们仍要按照上面的步骤来创建 sdc 和 sdd 的分区。

创建 /dev/sdc 分区

现在,通过下面的截图给出创建 sdc 和 sdd 磁盘分区的方法,或者你可以按照上面的步骤。

# fdisk /dev/sdc

Create sdc Partition

创建 sdc 分区

创建 /dev/sdd 分区

# fdisk /dev/sdd

Create sdd Partition

创建 sdd 分区

6、 创建分区后,检查三个磁盘 sdb, sdc, sdd 的变化。

# mdadm --examine /dev/sdb /dev/sdc /dev/sdd
# mdadm -E /dev/sd[b-c]  # 或

Check Partition Changes

检查磁盘变化

注意: 在上面的图片中,磁盘的类型是 fd。

7、 现在在新创建的分区检查 RAID 块。如果没有检测到超级块,我们就能够继续下一步,在这些磁盘中创建一个新的 RAID 5 配置。

Check Raid on Partition

*在分区中检查 RAID *

第3步:创建 md 设备 md0

8、 现在使用所有新创建的分区(sdb1, sdc1 和 sdd1)创建一个 RAID 设备“md0”(即 /dev/md0),使用以下命令。

# mdadm --create /dev/md0 --level=5 --raid-devices=3 /dev/sdb1 /dev/sdc1 /dev/sdd1
# mdadm -C /dev/md0 -l=5 -n=3 /dev/sd[b-d]1   # 或

9、 创建 RAID 设备后,检查并确认 RAID,从 mdstat 中输出中可以看到包括的设备的 RAID 级别。

# cat /proc/mdstat

Verify Raid Device

验证 Raid 设备

如果你想监视当前的创建过程,你可以使用watch命令,将 cat /proc/mdstat 传递给它,它会在屏幕上显示且每隔1秒刷新一次。

# watch -n1 cat /proc/mdstat

Monitor Raid Process

监控 RAID 5 构建过程

Raid 5 Process Summary

Raid 5 过程概要

10、 创建 RAID 后,使用以下命令验证 RAID 设备

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

Verify Raid Level

验证 Raid 级别

注意: 因为它显示三个磁盘的信息,上述命令的输出会有点长。

11、 接下来,验证 RAID 阵列,假定包含 RAID 的设备正在运行并已经开始了重新同步。

# mdadm --detail /dev/md0

Verify Raid Array

验证 RAID 阵列

第4步:为 md0 创建文件系统

12、 在挂载前为“md0”设备创建 ext4 文件系统。

# mkfs.ext4 /dev/md0

Create md0 Filesystem

创建 md0 文件系统

13、 现在,在/mnt下创建目录 raid5,然后挂载文件系统到 /mnt/raid5/ 下,并检查挂载点下的文件,你会看到 lost+found 目录。

# mkdir /mnt/raid5
# mount /dev/md0 /mnt/raid5/
# ls -l /mnt/raid5/

14、 在挂载点 /mnt/raid5 下创建几个文件,并在其中一个文件中添加一些内容然后去验证。

# touch /mnt/raid5/raid5_tecmint_{1..5}
# ls -l /mnt/raid5/
# echo "tecmint raid setups" > /mnt/raid5/raid5_tecmint_1
# cat /mnt/raid5/raid5_tecmint_1
# cat /proc/mdstat

Mount Raid 5 Device

挂载 RAID 设备

15、 我们需要在 fstab 中添加条目,否则系统重启后将不会显示我们的挂载点。编辑 fstab 文件添加条目,在文件尾追加以下行。挂载点会根据你环境的不同而不同。

# vim /etc/fstab
/dev/md0                /mnt/raid5              ext4    defaults        0 0

Raid 5 Automount

自动挂载 RAID 5

16、 接下来,运行mount -av命令检查 fstab 条目中是否有错误。

# mount -av

Check Fstab Errors

检查 Fstab 错误

第5步:保存 Raid 5 的配置

17、 在前面章节已经说过,默认情况下 RAID 没有配置文件。我们必须手动保存。如果此步中没有跟随不属于 md0 的 RAID 设备,它会是一些其他随机数字。

所以,我们必须要在系统重新启动之前保存配置。如果配置保存它在系统重新启动时会被加载到内核中然后 RAID 也将被加载。

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

Save Raid 5 Configuration

保存 RAID 5 配置

注意:保存配置将保持 md0 设备的 RAID 级别稳定不变。

第6步:添加备用磁盘

18、 备用磁盘有什么用?它是非常有用的,如果我们有一个备用磁盘,当我们阵列中的任何一个磁盘发生故障后,这个备用磁盘会进入激活重建过程,并从其他磁盘上同步数据,这样就有了冗余。

更多关于添加备用磁盘和检查 RAID 5 容错的指令,请阅读下面文章中的第6步和第7步。

结论

在这篇文章中,我们已经看到了如何使用三个磁盘配置一个 RAID 5 。在接下来的文章中,我们将看到如何故障排除并且当 RAID 5 中的一个磁盘损坏后如何恢复。


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

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

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

如何在 Docker 容器中运行 Kali Linux 2.0

介绍

Kali Linux 是一个对于安全测试人员和白帽的一个知名操作系统。它带有大量安全相关的程序,这让它很容易用于渗透测试。最近,Kali Linux 2.0 发布了,它被认为是这个操作系统最重要的一次发布。另一方面,Docker 技术由于它的可扩展性和易用性让它变得很流行。Dokcer 让你非常容易地将你的程序带给你的用户。好消息是你可以通过 Docker 运行Kali Linux 了,让我们看看该怎么做 🙂

在 Docker 中运行 Kali Linux 2.0

相关提示

如果你还没有在系统中安装docker,你可以运行下面的命令:

对于 Ubuntu/Linux Mint/Debian:

sudo apt-get install docker

对于 Fedora/RHEL/CentOS:

sudo yum install docker

对于 Fedora 22:

dnf install docker

你可以运行下面的命令来启动docker:

sudo docker start

首先运行下面的命令确保 Docker 服务运行正常:

sudo docker status

Kali Linux 的开发团队已将 Kali Linux 的 docker 镜像上传了,只需要输入下面的命令来下载镜像。

docker pull kalilinux/kali-linux-docker

Pull Kali Linux docker

下载完成后,运行下面的命令来找出你下载的 docker 镜像的 ID。

docker images

Kali Linux Image ID

现在运行下面的命令来从镜像文件启动 kali linux docker 容器(这里需用正确的镜像ID替换)。

docker run -i -t 198cd6df71ab3 /bin/bash

它会立刻启动容器并且让你登录到该操作系统,你现在可以在 Kaili Linux 中工作了。

Kali Linux Login

你可以在容器外面通过下面的命令来验证容器已经启动/运行中了:

docker ps

Docker Kali

总结

Docker 是一种最聪明的用来部署和分发包的方式。Kali Linux docker 镜像非常容易上手,也不会消耗很大的硬盘空间,这样也可以很容易地在任何安装了 docker 的操作系统上测试这个很棒的发行版了。


via: http://linuxpitstop.com/run-kali-linux-2-0-in-docker-container/

作者:Aun 译者:geekpi 校对:wxy

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

Linux有问必答:如何检查MariaDB服务端版本

提问: 我使用的是一台运行MariaDB的VPS。我该如何检查MariaDB服务端的版本?

有时候你需要知道你的数据库版本,比如当你升级你数据库或对已知缺陷打补丁时。这里有几种方法找出MariaDB版本的方法。

方法一

第一种找出版本的方法是登录MariaDB服务器,登录之后,你会看到一些MariaDB的版本信息。

另一种方法是在登录MariaDB后出现的命令行中输入‘status’命令。输出会显示服务器的版本还有协议版本。

方法二

如果你不能访问MariaDB服务器,那么你就不能用第一种方法。这种情况下你可以根据MariaDB的安装包的版本来推测。这种方法只有在MariaDB通过包管理器安装的才有用。

你可以用下面的方法检查MariaDB的安装包。

Debian、Ubuntu或者Linux Mint:

$ dpkg -l | grep mariadb

下面的输出说明MariaDB的版本是10.0.17。

Fedora、CentOS或者 RHEL:

$ rpm -qa | grep mariadb

下面的输出说明安装的版本是5.5.41。


via: http://ask.xmodulo.com/check-mariadb-server-version.html

作者:Dan Nanni 译者:geekpi 校对:wxy

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

如何配置 MongoDB 副本集

MongoDB 已经成为市面上最知名的 NoSQL 数据库。MongoDB 是面向文档的,它的无模式设计使得它在各种各样的WEB 应用当中广受欢迎。最让我喜欢的特性之一是它的副本集(Replica Set),副本集将同一数据的多份拷贝放在一组 mongod 节点上,从而实现数据的冗余以及高可用性。

这篇教程将向你介绍如何配置一个 MongoDB 副本集。

副本集的最常见配置需要一个主节点以及多个副节点。这之后启动的复制行为会从这个主节点到其他副节点。副本集不止可以针对意外的硬件故障和停机事件对数据库提供保护,同时也因为提供了更多的节点从而提高了数据库客户端数据读取的吞吐量。

配置环境

这个教程里,我们会配置一个包括一个主节点以及两个副节点的副本集。

为了达到这个目的,我们使用了3个运行在 VirtualBox 上的虚拟机。我会在这些虚拟机上安装 Ubuntu 14.04,并且安装 MongoDB 官方包。

我会在一个虚拟机实例上配置好所需的环境,然后将它克隆到其他的虚拟机实例上。因此,选择一个名为 master 的虚拟机,执行以下安装过程。

首先,我们需要给 apt 增加一个 MongoDB 密钥:

$ sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 7F0CEB10

然后,将官方的 MongoDB 仓库添加到 source.list 中:

$ sudo su
# echo "deb http://repo.mongodb.org/apt/ubuntu "$(lsb_release -sc)"/mongodb-org/3.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-3.0.list

接下来更新 apt 仓库并且安装 MongoDB。

$ sudo apt-get update
$ sudo apt-get install -y mongodb-org

现在对 /etc/mongodb.conf 做一些更改

auth = true
dbpath=/var/lib/mongodb
logpath=/var/log/mongodb/mongod.log
logappend=true
keyFile=/var/lib/mongodb/keyFile
replSet=myReplica

第一行的作用是表明我们的数据库需要验证才可以使用。keyfile 配置用于 MongoDB 节点间复制行为的密钥文件。replSet 为副本集设置一个名称。

接下来我们创建一个用于所有实例的密钥文件。

$ echo -n "MyRandomStringForReplicaSet" | md5sum > keyFile

这将会创建一个含有 MD5 字符串的密钥文件,但是由于其中包含了一些噪音,我们需要对他们清理后才能正式在 MongoDB 中使用。

$ echo -n "MyReplicaSetKey" | md5sum|grep -o "[0-9a-z]\+" > keyFile

grep 命令的作用的是把将空格等我们不想要的内容过滤掉之后的 MD5 字符串打印出来。

现在我们对密钥文件进行一些操作,让它真正可用。

$ sudo cp keyFile /var/lib/mongodb
$ sudo chown mongodb:nogroup keyFile
$ sudo chmod 400 keyFile

接下来,关闭此虚拟机。将其 Ubuntu 系统克隆到其他虚拟机上。

这是克隆后的副节点1和副节点2。确认你已经将它们的MAC地址重新初始化,并且克隆整个硬盘。

请注意,三个虚拟机示例需要在同一个网络中以便相互通讯。因此,我们需要它们弄到“互联网”上去。

这里推荐给每个虚拟机设置一个静态 IP 地址,而不是使用 DHCP。这样它们就不至于在 DHCP 分配IP地址给他们的时候失去连接。

像下面这样编辑每个虚拟机的 /etc/networks/interfaces 文件。

在主节点上:

auto eth1
    iface eth1 inet static
    address 192.168.50.2
    netmask 255.255.255.0

在副节点1上:

auto eth1
    iface eth1 inet static
    address 192.168.50.3
    netmask 255.255.255.0

在副节点2上:

auto eth1
    iface eth1 inet static
    address 192.168.50.4
    netmask 255.255.255.0

由于我们没有 DNS 服务,所以需要设置设置一下 /etc/hosts 这个文件,手工将主机名称放到此文件中。

在主节点上:

127.0.0.1 localhost primary
192.168.50.2 primary
192.168.50.3 secondary1
192.168.50.4 secondary2

在副节点1上:

127.0.0.1 localhost secondary1
192.168.50.2 primary
192.168.50.3 secondary1
192.168.50.4 secondary2

在副节点2上:

127.0.0.1 localhost secondary2
192.168.50.2 primary
192.168.50.3 secondary1
192.168.50.4 secondary2

使用 ping 命令检查各个节点之间的连接。

$ ping primary
$ ping secondary1
$ ping secondary2

配置副本集

验证各个节点可以正常连通后,我们就可以新建一个管理员用户,用于之后的副本集操作。

在主节点上,打开 /etc/mongodb.conf 文件,将 auth 和 replSet 两项注释掉。

dbpath=/var/lib/mongodb
logpath=/var/log/mongodb/mongod.log
logappend=true
#auth = true
keyFile=/var/lib/mongodb/keyFile
#replSet=myReplica

在一个新安装的 MongoDB 上配置任何用户或副本集之前,你需要注释掉 auth 行。默认情况下,MongoDB 并没有创建任何用户。而如果在你创建用户前启用了 auth,你就不能够做任何事情。你可以在创建一个用户后再次启用 auth。

修改 /etc/mongodb.conf 之后,重启 mongod 进程。

$ sudo service mongod restart

现在连接到 MongoDB master:

$ mongo :27017

连接 MongoDB 后,新建管理员用户。

> use admin
> db.createUser({
user:"admin",
pwd:"
})

重启 MongoDB:

$ sudo service mongod restart

再次连接到 MongoDB,用以下命令将 副节点1 和副节点2节点添加到我们的副本集中。

> use admin
> db.auth("admin","myreallyhardpassword")
> rs.initiate()
> rs.add ("secondary1:27017")
> rs.add("secondary2:27017")

现在副本集到手了,可以开始我们的项目了。参照 官方驱动文档 来了解如何连接到副本集。如果你想要用 Shell 来请求数据,那么你需要连接到主节点上来插入或者请求数据,副节点不行。如果你执意要尝试用副本集操作,那么以下错误信息就蹦出来招呼你了。

myReplica:SECONDARY>
myReplica:SECONDARY> show databases
2015-05-10T03:09:24.131+0000 E QUERY    Error: listDatabases failed:{ "note" : "from execCommand", "ok" : 0, "errmsg" : "not master" }
    at Error ()
    at Mongo.getDBs (src/mongo/shell/mongo.js:47:15)
    at shellHelper.show (src/mongo/shell/utils.js:630:33)
at shellHelper (src/mongo/shell/utils.js:524:36)
    at (shellhelp2):1:1 at src/mongo/shell/mongo.js:47

如果你要从 shell 连接到整个副本集,你可以安装如下命令。在副本集中的失败切换是自动的。

$ mongo primary,secondary1,secondary2:27017/?replicaSet=myReplica

如果你使用其它驱动语言(例如,JavaScript、Ruby 等等),格式也许不同。

希望这篇教程能对你有所帮助。你可以使用Vagrant来自动完成你的本地环境配置,并且加速你的代码。


via: http://xmodulo.com/setup-replica-set-mongodb.html

作者:Christopher Valerio 译者:mr-ping 校对:wxy

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

Ubuntu 14.04中修复“update information is outdated”错误

Ubuntu 14.04中修复“update information is outdated”错误
Ubuntu 14.04中修复“update information is outdated”错误

看到过Ubuntu 14.04的顶部面板上那个显示下面这个错误的红色三角形了吗?

更新信息过时。该错误可能是由网络问题,或者某个仓库不再可用而造成的。请通过从指示器菜单中选择‘显示更新’来手动更新,然后查看是否存在有失败的仓库。

它看起来像这样:

Ubuntu 14.04中修复“update information is outdated”错误
Ubuntu 14.04中修复“update information is outdated”错误

这里的粉红色感叹号标记就是原来的红色三角形,因为我使用了最佳的Ubuntu图标主题之一,Numix。让我们回到该错误中,这是一个常见的更新问题,你也许时不时地会碰到它。现在,你或许想知道的是,到底是什么导致了这个更新错误的出现。

引起‘update information is outdated’错误的原因

导致该错误的原因在其自身的错误描述中就讲得相当明白,它告诉你“这可能是由网络问题或者某个不再可用的仓库导致的”。所以,要么是你更新了系统和某些仓库,要么是PPA不再受到支持了,或者你正面对的类似问题。

虽然错误本身就讲得很明白,而它给出了的议操作“请通过从指示器菜单选择‘显示更新’来手动更新以查看失败的仓库”却并不能很好地解决问题。如果你点击显示更新,你所能看见的仅仅是系统已经更新。

很奇怪,不是吗?我们怎样才能找出是什么出错了,哪里出错了,以及为什么出错呢?

修复‘update information is outdated’错误

这里讨论的‘解决方案’可能对Ubuntu的这些版本有用:Ubuntu 14.04,12.04。你所要做的仅仅是打开终端(Ctrl+Alt+T),然后使用下面的命令:

sudo apt-get update

等待命令结束,然后查看其结果。这里插个快速提示,你可以在终端中添加通知,这样当一个耗时很长的命令结束执行时就会通知你。在该命令的最后几行中,可以看到你的系统正面临什么样的错误。是的,你肯定会看到一个错误。

在我这里,我看到了有名的GPG error: The following could not be verified错误。很明显,在Ubuntu 15.04中安装声破天有点问题。

Ubuntu 14.04中修复“update information is outdated”错误
Ubuntu 14.04中修复“update information is outdated”错误

很可能你看到的不是像我一样的GPG错误,那样的话,我建议你读一读我写的这篇文章修复Ubuntu中的各种常见更新错误

我知道有不少人,尤其是初学者,很是讨厌命令行,但是如果你正在使用Linux,你就无可避免会使用到终端。此外,那东西并没你想象的那么可怕。试试吧,你会很快上手的。

我希望这个快速提示对于你修复Ubuntu中的“update information is outdated”错误有帮助。如果你有任何问题或建议,请不吝提出,我们将无任欢迎。


via: http://itsfoss.com/fix-update-information-outdated-ubuntu/

作者:Abhishek 译者:GOLinux 校对:wxy

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

在 Linux 中使用日志来排错

人们创建日志的主要原因是排错。通常你会诊断为什么问题发生在你的 Linux 系统或应用程序中。错误信息或一系列的事件可以给你提供找出根本原因的线索,说明问题是如何发生的,并指出如何解决它。这里有几个使用日志来解决的样例。

登录失败原因

如果你想检查你的系统是否安全,你可以在验证日志中检查登录失败的和登录成功但可疑的用户。当有人通过不正当或无效的凭据来登录时会出现认证失败,这通常发生在使用 SSH 进行远程登录或 su 到本地其他用户来进行访问权时。这些是由插入式验证模块(PAM)来记录的。在你的日志中会看到像 Failed password 和 user unknown 这样的字符串。而成功认证记录则会包括像 Accepted password 和 session opened 这样的字符串。

失败的例子:

pam_unix(sshd:auth): authentication failure; logname= uid=0 euid=0 tty=ssh ruser= rhost=10.0.2.2
Failed password for invalid user hoover from 10.0.2.2 port 4791 ssh2
pam_unix(sshd:auth): check pass; user unknown
PAM service(sshd) ignoring max retries; 6 > 3

成功的例子:

Accepted password for hoover from 10.0.2.2 port 4792 ssh2
pam_unix(sshd:session): session opened for user hoover by (uid=0)
pam_unix(sshd:session): session closed for user hoover

你可以使用 grep 来查找哪些用户失败登录的次数最多。这些都是潜在的攻击者正在尝试和访问失败的账户。这是一个在 ubuntu 系统上的例子。

$ grep "invalid user" /var/log/auth.log | cut -d ' ' -f 10 | sort | uniq -c | sort -nr
23 oracle
18 postgres
17 nagios
10 zabbix
6 test

由于没有标准格式,所以你需要为每个应用程序的日志使用不同的命令。日志管理系统,可以自动分析日志,将它们有效的归类,帮助你提取关键字,如用户名。

日志管理系统可以使用自动解析功能从 Linux 日志中提取用户名。这使你可以看到用户的信息,并能通过点击过滤。在下面这个例子中,我们可以看到,root 用户登录了 2700 次之多,因为我们筛选的日志仅显示 root 用户的尝试登录记录。

日志管理系统也可以让你以时间为做坐标轴的图表来查看,使你更容易发现异常。如果有人在几分钟内登录失败一次或两次,它可能是一个真正的用户而忘记了密码。但是,如果有几百个失败的登录并且使用的都是不同的用户名,它更可能是在试图攻击系统。在这里,你可以看到在3月12日,有人试图登录 Nagios 几百次。这显然​​不是一个合法的系统用户。

重启的原因

有时候,一台服务器由于系统崩溃或重启而宕机。你怎么知道它何时发生,是谁做的?

关机命令

如果有人手动运行 shutdown 命令,你可以在验证日志文件中看到它。在这里,你可以看到,有人从 IP 50.0.134.125 上作为 ubuntu 的用户远程登录了,然后关闭了系统。

Mar 19 18:36:41 ip-172-31-11-231 sshd[23437]: Accepted publickey for ubuntu from 50.0.134.125 port 52538 ssh
Mar 19 18:36:41 ip-172-31-11-231 23437]:sshd[ pam_unix(sshd:session): session opened for user ubuntu by (uid=0)
Mar 19 18:37:09 ip-172-31-11-231 sudo:   ubuntu : TTY=pts/1 ; PWD=/home/ubuntu ; USER=root ; COMMAND=/sbin/shutdown -r now

内核初始化

如果你想看看服务器重新启动的所有原因(包括崩溃),你可以从内核初始化日志中寻找。你需要搜索内核类(kernel)和 cpu 初始化(Initializing)的信息。

Mar 19 18:39:30 ip-172-31-11-231 kernel: [    0.000000] Initializing cgroup subsys cpuset
Mar 19 18:39:30 ip-172-31-11-231 kernel: [    0.000000] Initializing cgroup subsys cpu
Mar 19 18:39:30 ip-172-31-11-231 kernel: [    0.000000] Linux version 3.8.0-44-generic (buildd@tipua) (gcc version 4.6.3 (Ubuntu/Linaro 4.6.3-1ubuntu5) ) #66~precise1-Ubuntu SMP Tue Jul 15 04:01:04 UTC 2014 (Ubuntu 3.8.0-44.66~precise1-generic 3.8.13.25)

检测内存问题

有很多原因可能导致服务器崩溃,但一个常见的原因是内存用尽。

当你系统的内存不足时,进程会被杀死,通常会杀死使用最多资源的进程。当系统使用了所有内存,而新的或现有的进程试图使用更多的内存时就会出现错误。在你的日志文件查找像 Out of Memory 这样的字符串或类似 kill 这样的内核警告信息。这些信息表明系统故意杀死进程或应用程序,而不是允许进程崩溃。

例如:

[33238.178288] Out of memory: Kill process 6230 (firefox) score 53 or sacrifice child
[29923450.995084] select 5230 (docker), adj 0, size 708, to kill

你可以使用像 grep 这样的工具找到这些日志。这个例子是在 ubuntu 中:

$ grep “Out of memory” /var/log/syslog
 [33238.178288] Out of memory: Kill process 6230 (firefox) score 53 or sacrifice child

请记住,grep 也要使用内存,所以只是运行 grep 也可能导致内存不足的错误。这是另一个你应该中央化存储日志的原因!

定时任务错误日志

cron 守护程序是一个调度器,可以在指定的日期和时间运行进程。如果进程运行失败或无法完成,那么 cron 的错误出现在你的日志文件中。具体取决于你的发行版,你可以在 /var/log/cron,/var/log/messages,和 /var/log/syslog 几个位置找到这个日志。cron 任务失败原因有很多。通常情况下,问题出在进程中而不是 cron 守护进程本身。

默认情况下,cron 任务的输出会通过 postfix 发送电子邮件。这是一个显示了该邮件已经发送的日志。不幸的是,你不能在这里看到邮件的内容。

Mar 13 16:35:01 PSQ110 postfix/pickup[15158]: C3EDC5800B4: uid=1001 from=
Mar 13 16:35:01 PSQ110 postfix/cleanup[15727]: C3EDC5800B4: message-id=<20150310110501.C3EDC5800B4@PSQ110>
Mar 13 16:35:01 PSQ110 postfix/qmgr[15159]: C3EDC5800B4: from=, size=607, nrcpt=1 (queue active)
Mar 13 16:35:05 PSQ110 postfix/smtp[15729]: C3EDC5800B4: to=, relay=gmail-smtp-in.l.google.com[74.125.130.26]:25, delay=4.1, delays=0.26/0/2.2/1.7, dsn=2.0.0, status=sent (250 2.0.0 OK 1425985505 f16si501651pdj.5 - gsmtp)

你可以考虑将 cron 的标准输出记录到日志中,以帮助你定位问题。这是一个你怎样使用 logger 命令重定向 cron 标准输出到 syslog的例子。用你的脚本来代替 echo 命令,helloCron 可以设置为任何你想要的应用程序的名字。

*/5 * * * * echo ‘Hello World’ 2>&1 | /usr/bin/logger -t helloCron

它创建的日志条目:

Apr 28 22:20:01 ip-172-31-11-231 CRON[15296]: (ubuntu) CMD (echo 'Hello World!' 2>&1 | /usr/bin/logger -t helloCron)
Apr 28 22:20:01 ip-172-31-11-231 helloCron: Hello World!

每个 cron 任务将根据任务的具体类型以及如何输出数据来记录不同的日志。

希望在日志中有问题根源的线索,也可以根据需要添加额外的日志记录。


via: http://www.loggly.com/ultimate-guide/logging/troubleshooting-with-linux-logs/

作者:Jason Skowronski 作者:Amy Echeverri 作者:Sadequl Hussain 译者:strugglingyouth 校对:wxy

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

如何在 Ubuntu 15.04 系统中安装 Logwatch

大家好,今天我们会讲述在 Ubuntu 15.04 操作系统上如何安装 Logwatch 软件,它也可以在各种 Linux 系统和类 Unix 系统上安装。Logwatch 是一款可定制的日志分析和日志监控报告生成系统,它可以根据一段时间的日志文件生成您所希望关注的详细报告。它具有易安装、易配置、可审查等特性,同时对其提供的数据的安全性上也有一些保障措施。Logwatch 会扫描重要的操作系统组件像 SSH、网站服务等的日志文件,然后生成用户所关心的有价值的条目汇总报告。

预安装设置

我们会使用 Ubuntu 15.04 版本的操作系统来部署 Logwatch,所以安装 Logwatch 之前,要确保系统上邮件服务设置是正常可用的。因为它会每天把生成的报告通过日报的形式发送邮件给管理员。您的系统的源库也应该设置可用,以便可以从通用源库来安装 Logwatch。

然后打开您 ubuntu 系统的终端,用 root 账号登陆,在进入 Logwatch 的安装操作前,先更新您的系统软件包。

root@ubuntu-15:~# apt-get update

安装 Logwatch

只要你的系统已经更新和已经满足前面说的先决条件,那么就可以在您的机器上输入如下命令来安装 Logwatch。

root@ubuntu-15:~# apt-get install logwatch

在安装过程中,一旦您按提示按下“Y”键同意对系统修改的话,Logwatch 将会开始安装一些额外的必须软件包。

在安装过程中会根据您机器上的邮件服务器设置情况弹出提示对 Postfix 设置的配置界面。在这篇教程中我们使用最容易的 “仅本地(Local only)” 选项。根据您的基础设施情况也可以选择其它的可选项,然后点击“确定”继续。

Potfix Configurations

随后您得选择邮件服务器名,这邮件服务器名也会被其它程序使用,所以它应该是一个完全合格域名/全称域名(FQDN)。

Postfix Setup

一旦按下在 postfix 配置提示底端的 “OK”,安装进程就会用 Postfix 的默认配置来安装,并且完成 Logwatch 的整个安装。

Logwatch Completion

您可以在终端下发出如下命令来检查 Logwatch 状态,正常情况下它应该是激活状态。

root@ubuntu-15:~# service postfix status

Postfix Status

要确认 Logwatch 在默认配置下的安装信息,可以如下示简单的发出“logwatch” 命令。

root@ubuntu-15:~# logwatch

上面执行命令的输出就是终端下编制出的报表展现格式。

Logwatch Report

配置 Logwatch

在成功安装好 Logwatch 后,我们需要在它的配置文件中做一些修改,配置文件位于如下所示的路径。那么,就让我们用文本编辑器打开它,然后按需要做些变动。

root@ubuntu-15:~# vim /usr/share/logwatch/default.conf/logwatch.conf

输出/格式化选项

默认情况下 Logwatch 会以无编码的文本打印到标准输出方式。要改为以邮件为默认方式,需设置“Output = mail”,要改为保存成文件方式,需设置“Output = file”。所以您可以根据您的要求设置其默认配置。

Output = stdout

如果使用的是因特网电子邮件配置,要用 Html 格式为默认出格式,需要修改成如下行所示的样子。

Format = text

现在增加默认的邮件报告接收人地址,可以是本地账号也可以是完整的邮件地址,需要的都可以在这行上写上

MailTo = root
#MailTo = user@test.com

默认的邮件发送人可以是本地账号,也可以是您需要使用的其它名字。

# complete email address.
MailFrom = Logwatch

对这个配置文件保存修改,至于其它的参数就让它保持默认,无需改动。

调度任务配置

现在编辑在 “daily crons” 目录下的 “00logwatch” 文件来配置从 logwatch 生成的报告需要发送的邮件地址。

root@ubuntu-15:~# vim /etc/cron.daily/00logwatch

在这儿您需要作用“–mailto user@test.com”来替换掉“–output mail”,然后保存文件。

Logwatch Cronjob

生成报告

现在我们在终端中执行“logwatch”命令来生成测试报告,生成的结果在终端中会以文本格式显示出来。

root@ubuntu-15:~#logwatch

生成的报告开始部分显示的是执行的时间和日期。它包含不同的部分,每个部分以开始标识开始而以结束标识结束,中间显示的是该部分的完整信息。

这儿显示的是开始的样子,它以显示系统上所有安装的软件包的部分开始,如下所示:

dpkg status

接下来的部分显示的日志信息是关于当前系统登录会话、rsyslogs 和当前及最近的 SSH 会话信息。

logwatch report

Logwatch 报告最后显示的是安全方面的 sudo 日志及根目录磁盘使用情况,如下示:

Logwatch end report

您也可以打开如下的文件来查看生成的 logwatch 报告电子邮件。

root@ubuntu-15:~# vim /var/mail/root

您会看到发送给你配置的用户的所有已生成的邮件及其邮件递交状态。

更多详情

Logwatch 是一款很不错的工具,可以学习的很多很多,所以如果您对它的日志监控功能很感兴趣的话,也以通过如下所示的简短命令来获得更多帮助。

root@ubuntu-15:~# man logwatch

上面的命令包含所有关于 logwatch 的用户手册,所以仔细阅读,要退出手册的话可以简单的输入“q”。

关于 logwatch 命令的使用,您可以使用如下所示的帮助命令来获得更多的详细信息。

root@ubuntu-15:~# logwatch --help

结论

教程结束,您也学会了如何在 Ubuntu 15.04 上对 Logwatch 的安装、配置等全部设置指导。现在您就可以自定义监控您的系统日志,不管是监控所有服务的运行情况还是对特定的服务在指定的时间发送报告都可以。所以,开始使用这工具吧,无论何时有问题或想知道更多关于 logwatch 的使用的都可以给我们留言。


via: http://linoxide.com/ubuntu-how-to/install-use-logwatch-ubuntu-15-04/

作者:Kashif Siddique 译者:runningwater 校对:wxy

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

Bash 下如何逐行读取一个文件

在 Linux 或类 UNIX 系统下如何使用 KSH 或 BASH shell 逐行读取一个文件?

在 Linux、OSX、 *BSD 或者类 Unix 系统下你可以使用 ​​while..do..done 的 bash 循环来逐行读取一个文件。

在 Bash Unix 或者 Linux shell 中逐行读取一个文件的语法

对于 bash、ksh、 zsh 和其他的 shells 语法如下

while read -r line; do COMMAND; done < input.file

通过 -r 选项传递给 read 命令以防止阻止解释其中的反斜杠转义符。

在 read 命令之前添加 IFS= 选项,来防止首尾的空白字符被去掉。

while IFS= read -r line; do COMMAND_on $line; done < input.file

这是更适合人类阅读的语法:

#!/bin/bash
input="/path/to/txt/file"
while IFS= read -r var
do
  echo "$var"
done < "$input"

示例

下面是一些例子:

#!/bin/ksh
file="/home/vivek/data.txt"
while IFS= read line
do
    # display $line or do somthing with $line
    echo "$line"
done <"$file"

在 bash shell 中相同的例子:

#!/bin/bash
file="/home/vivek/data.txt"
while IFS= read -r line
do
    # display $line or do somthing with $line
    printf '%sn' "$line"
done <"$file"

你还可以看看这个更好的:

#!/bin/bash
file="/etc/passwd"
while IFS=: read -r f1 f2 f3 f4 f5 f6 f7
do
    # display fields using f1, f2,..,f7
    printf 'Username: %s, Shell: %s, Home Dir: %sn' "$f1" "$f7" "$f6"
done <"$file"

示例输出:

Bash 下如何逐行读取一个文件
Bash 下如何逐行读取一个文件

图01:Bash 脚本:读取文件并逐行输出文件

Bash 脚本:逐行读取文本文件并创建为 pdf 文件

我的输入文件如下(faq.txt):

4|http://www.cyberciti.biz/faq/mysql-user-creation/|Mysql User Creation: Setting Up a New MySQL User Account
4096|http://www.cyberciti.biz/faq/ksh-korn-shell/|What is UNIX / Linux Korn Shell?
4101|http://www.cyberciti.biz/faq/what-is-posix-shell/|What Is POSIX Shell?
17267|http://www.cyberciti.biz/faq/linux-check-battery-status/|Linux: Check Battery Status Command
17245|http://www.cyberciti.biz/faq/restarting-ntp-service-on-linux/|Linux Restart NTPD Service Command
17183|http://www.cyberciti.biz/faq/ubuntu-linux-determine-your-ip-address/|Ubuntu Linux: Determine Your IP Address
17172|http://www.cyberciti.biz/faq/determine-ip-address-of-linux-server/|HowTo: Determine an IP Address My Linux Server
16510|http://www.cyberciti.biz/faq/unix-linux-restart-php-service-command/|Linux / Unix: Restart PHP Service Command
8292|http://www.cyberciti.biz/faq/mounting-harddisks-in-freebsd-with-mount-command/|FreeBSD: Mount Hard Drive / Disk Command
8190|http://www.cyberciti.biz/faq/rebooting-solaris-unix-server/|Reboot a Solaris UNIX System

我的 bash 脚本:

#!/bin/bash
# Usage: Create pdf files from input (wrapper script)
# Author: Vivek Gite  under GPL v2.x+
#---------------------------------------------------------
#Input file
_db="/tmp/wordpress/faq.txt"
#Output location
o="/var/www/prviate/pdf/faq"
_writer="~/bin/py/pdfwriter.py"
# If file exists
if [[ -f "$_db" ]]
then
    # read it
    while IFS='|' read -r pdfid pdfurl pdftitle
    do
        local pdf="$o/$pdfid.pdf"
        echo "Creating $pdf file ..."
    #Genrate pdf file
        $_writer --quiet --footer-spacing 2
        --footer-left "nixCraft is GIT UL++++ W+++ C++++ M+ e+++ d-"
        --footer-right "Page [page] of [toPage]" --footer-line
        --footer-font-size 7 --print-media-type "$pdfurl" "$pdf"
    done <"$_db"
fi

技巧:从 bash 变量中读取

让我们看看如何在 Debian 或者 Ubuntu Linux 下列出所有安装过的 php 包,请输入:

# 我将输出内容赋值到一个变量名为 $list中 #
list=$(dpkg --list php* | awk '/ii/{print $2}')
printf '%sn' "$list"

示例输出:

php-pear
php5-cli
php5-common
php5-fpm
php5-gd
php5-json
php5-memcache
php5-mysql
php5-readline
php5-suhosin-extension

你现在可以从 $list 中看到它们,并安装这些包:

#!/bin/bash
# BASH can iterate over $list variable using a "here string" #
while IFS= read -r pkg
do
    printf 'Installing php package %s...n' "$pkg"
    /usr/bin/apt-get -qq install $pkg
done <<< "$list"
printf '*** Do not forget to run php5enmod and restart the server (httpd or php5-fpm) ***n'

示例输出:

Installing php package php-pear...
Installing php package php5-cli...
Installing php package php5-common...
Installing php package php5-fpm...
Installing php package php5-gd...
Installing php package php5-json...
Installing php package php5-memcache...
Installing php package php5-mysql...
Installing php package php5-readline...
Installing php package php5-suhosin-extension...
*** Do not forget to run php5enmod and restart the server (httpd or php5-fpm) ***

via: http://www.cyberciti.biz/faq/unix-howto-read-line-by-line-from-file/

作者: VIVEK GIT 译者:strugglingyouth 校对:wxy

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

Alien 魔法:RPM 和 DEB 互转

正如我确信,你们一定知道Linux下的多种软件安装方式:使用发行版所提供的包管理系统(aptitude,yum,或者zypper,还可以举很多例子),从源码编译(尽管现在很少用了,但在Linux发展早期却是唯一可用的方法),或者使用各自的低级工具dpkg用于.deb,以及rpm用于.rpm,预编译包,如此这般。

Alien 魔法:RPM 和 DEB 互转
Alien 魔法:RPM 和 DEB 互转

使用Alien将RPM转换成DEB以及将DEB转换成RPM

在本文中,我们将为你介绍alien,一个用于在各种不同的Linux包格式相互转换的工具,其最常见的用法是将.rpm转换成.deb(或者反过来)。

如果你需要某个特定类型的包,而你只能找到其它格式的包的时候,该工具迟早能派得上用场——即使是其作者不再维护,并且在其网站声明:alien将可能永远维持在实验状态。

例如,有一次,我正查找一个用于喷墨打印机的.deb驱动,但是却没有找到——生产厂家只提供.rpm包,这时候alien拯救了我。我安装了alien,将包进行转换,不久之后我就可以使用我的打印机了,没有任何问题。

即便如此,我们也必须澄清一下,这个工具不应当用来转换重要的系统文件和库,因为它们在不同的发行版中有不同的配置。只有在前面说的那种情况下所建议的安装方法根本不适合时,alien才能作为最后手段使用。

最后一项要点是,我们必须注意,虽然我们在本文中使用CentOS和Debian,除了前两个发行版及其各自的家族体系外,据我们所知,alien可以工作在Slackware中,甚至Solaris中。

步骤1:安装Alien及其依赖包

要安装alien到CentOS/RHEL 7中,你需要启用EPEL和Nux Dextop(是的,是Dextop——不是Desktop)仓库,顺序如下:

# yum install epel-release

启用Nux Dextop仓库的包的当前最新版本是0.5(2015年8月10日发布),在安装之前你可以查看http://li.nux.ro/download/nux/dextop/el7/x86_64/上是否有更新的版本。

# rpm --import http://li.nux.ro/download/nux/RPM-GPG-KEY-nux.ro
# rpm -Uvh http://li.nux.ro/download/nux/dextop/el7/x86_64/nux-dextop-release-0-5.el7.nux.noarch.rpm

然后再做,

# yum update && yum install alien

在Fedora中,你只需要运行上面的命令即可。

在Debian及其衍生版中,只需要:

# aptitude install alien

步骤2:将.deb转换成.rpm包

对于本次测试,我们选择了date工具,它提供了一系列日期和时间工具用于处理大量金融数据。我们将下载.deb包到我们的CentOS 7机器中,将它转换成.rpm并安装:

Check CentOS Version

检查CentOS版本

# cat /etc/centos-release
# wget http://ftp.us.debian.org/debian/pool/main/d/dateutils/dateutils_0.3.1-1.1_amd64.deb
# alien --to-rpm --scripts dateutils_0.3.1-1.1_amd64.deb

Convert .deb to .rpm package in Linux

在Linux中将.deb转换成.rpm

重要:(请注意alien是怎样来增加目标包的次版本号的。如果你想要无视该行为,请添加-keep-version标识)。

如果我们尝试马上安装该包,我们将碰到些许问题:

# rpm -Uvh dateutils-0.3.1-2.1.x86_64.rpm

Install RPM Package

安装RPM包

要解决该问题,我们需要启用epel-testing仓库,然后安装rpmbuild工具来编辑该包的配置以重建包:

# yum --enablerepo=epel-testing install rpmrebuild

然后运行,

# rpmrebuild -pe dateutils-0.3.1-2.1.x86_64.rpm

它会打开你的默认文本编辑器。请转到%files章节并删除涉及到错误信息中提到的目录的行,然后保存文件并退出:

Convert .deb to Alien Version

转换.deb到Alien版

但你退出该文件后,将提示你继续去重构。如果你选择“Y”,该文件会重构到指定的目录(与当前工作目录不同):

# rpmrebuild –pe dateutils-0.3.1-2.1.x86_64.rpm

Build RPM Package

构建RPM包

现在你可以像以往一样继续来安装包并验证:

# rpm -Uvh /root/rpmbuild/RPMS/x86_64/dateutils-0.3.1-2.1.x86_64.rpm
# rpm -qa | grep dateutils

Install Build RPM Package

安装构建RPM包

最后,你可以列出date工具包含的各个工具,也可以查看各自的手册页:

# ls -l /usr/bin | grep dateutils
Alien 魔法:RPM 和 DEB 互转
Alien 魔法:RPM 和 DEB 互转

验证安装的RPM包

步骤3:将.rpm转换成.deb包

在本节中,我们将演示如何将.rpm转换成.deb。在一台32位的Debian Wheezy机器中,让我们从CentOS 6操作系统仓库中下载用于zsh shell的.rpm包。注意,该shell在Debian及其衍生版的默认安装中是不可用的。

# cat /etc/shells
# lsb_release -a | tail -n 4
Alien 魔法:RPM 和 DEB 互转
Alien 魔法:RPM 和 DEB 互转

检查Shell和Debian操作系统版本

# wget http://mirror.centos.org/centos/6/os/i386/Packages/zsh-4.3.11-4.el6.centos.i686.rpm
# alien --to-deb --scripts zsh-4.3.11-4.el6.centos.i686.rpm

你可以安全地无视关于签名丢失的信息:

Convert .rpm to .deb Package

将.rpm转换成.deb包

过了一会儿后,.deb包应该已经生成,并可以安装了:

# dpkg -i zsh_4.3.11-5_i386.deb

Install RPM Converted Deb Package

安装RPM转换来的Deb包

安装完后,你看看可以zsh是否添加到了合法shell列表中:

# cat /etc/shells
Alien 魔法:RPM 和 DEB 互转
Alien 魔法:RPM 和 DEB 互转

确认安装的Zsh包

小结

在本文中,我们已经解释了如何将.rpm转换成.deb及其反向转换,这可以作为这类程序不能从仓库中或者作为可分发源代码获得的最后安装手段。你一定想要将本文添加到书签中,因为我们都需要alien。

请自由分享你关于本文的想法,写到下面的表单中吧。


via: http://www.tecmint.com/convert-from-rpm-to-deb-and-deb-to-rpm-package-using-alien/

作者:Gabriel Cánepa 译者:GOLinux 校对:wxy

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

SSD 下的 MySQL IO 优化尝试

1、背景

在阅读这篇文章之前,读者需要注意的是,为了维护隐私,用 MySQL 服务器的 D 段代替完整 IP,并且略去一些私密信息。

A 项目,因 I/O 出现规律性地剧烈波动。每 15 分钟落地一次,innodbBuffPoolPagesFlushed 参数监控波峰和波谷交替出现,磁盘 I/O 同样如此,并且 until 达到 100%。经过排查,排除了触发器、事件、存储过程、前端程序定时器、系统 crontab 的可能性。最终定位为 InnoDB 日志切换,但是否完全是日志造成的影响,还有待进一步跟踪和分析。

找到问题的可能所在,试图在 24 主库上做了如下调整:

  • 关闭 Query Cache;
  • 设置 InnoDB Log 大小为 1280M;
  • 设置 innodb_max_dirty_pages_pct 为 30,innodb_io_capacity 保持 200 不变。

做了如上调整以后,I/O 趋于平稳,没有再出现大的波动。

为了保险起见,A 项目方面决定采用配有 SSD 的机型,对主库进行迁移,同时对 24 的从库 27 进行迁移。待迁移完成后,在新的主库 39 上,针对 SSD 以及 MySQL InnoDB 参数进行优化。待程序切换完成后,再次对针对 SSD 以及 MySQL InnoDB 参数进行优化。也就是说在上线前后进行优化,观察 I/O 状态。

2、SSD 特性

众所周知,SSD 的平均性能是优于 SAS 的。SSD 能解决 I/O 瓶颈,但互联网行业总要权衡收益与成本的。目前内存数据库是这个领域的一大趋势,一方面,越来越多的应用会往 NoSQL 迁移。另一方面,重要数据总要落地,传统的机械硬盘已经不能满足目前高并发、大规模数据的要求。总的来说,一方面,为了提高性能,尽可能把数据内存化,这也是 InnoDB 存储引擎不断改进的核心原则。后续的 MySQL 版本已经对 SSD 做了优化。另一方面,尽可能上 SSD。

SSD 这么神秘,接下来我们看看它有哪些特性:

  • 随机读能力非常好,连续读性能一般,但比普通 SAS 磁盘好;
  • 不存在磁盘寻道的延迟时间,随机写和连续写的响应延迟差异不大。
  • erase-before-write 特性,造成写入放大,影响写入的性能;
  • 写磨损特性,采用 Wear Leveling 算法延长寿命,但同时会影响读的性能;
  • 读和写的 I/O 响应延迟不对等(读要大大好于写),而普通磁盘读和写的 I/O 响应延迟差异很小;
  • 连续写比随机写性能好,比如 1M 顺序写比 128 个 8K 的随即写要好很多,因为随即写会带来大量的擦除。

总结起来,也就是随机读性能较连续读性能好,连续写性能较随机写性能好,会有写入放大的问题,同一位置插入次数过多容易导致损坏。

3、基于 SSD 的数据库优化

基于 SSD 的数据库优化,我们可以做如下事情:

  • 减少对同一位置的反复擦写,也就是针对 InnoDB 的 Redo Log。因为 Redo Log 保存在 ib_logfile0/1/2,这几个日志文件是复写,来回切换,必定会带来同一位置的反复擦写;
  • 减少离散写入,转化为 Append 或者批量写入,也就是针对数据文件;
  • 提高顺序写入的量。

具体来说,我们可以做如下调整:

  • 修改系统 I/O 调度算法为 NOOP;
  • 提高每个日志文件大小为 1280M(调整 innodb_log_file_size);
  • 通过不断调整 innodb_io_capacity 和 innodb_max_dirty_pages_pct 让落地以及 I/O 水平达到均衡;
  • 关闭 innodb_adaptive_flushing,查看效果;
  • 修改 innodb_write_io_threads 和 innodb_read_io_threads。

针对系统 I/O 调度算法,做如下解释。系统 I/O 调度算法有四种,CFQ(Complete Fairness Queueing,完全公平排队 I/O 调度程序)、NOOP(No Operation,电梯式调度程序)、Deadline(截止时间调度程序)、AS(Anticipatory,预料 I/O 调度程序)。

下面对上述几种调度算法做简单地介绍。

CFQ 为每个进程/线程,单独创建一个队列来管理该进程所产生的请求,也就是说每个进程一个队列,各队列之间的调度使用时间片来调度,以此来保证每个进程都能被很好的分配到 I/O 带宽,I/O 调度器每次执行一个进程的 4 次请求。

NOOP 实现了一个简单的 FIFO 队列,它像电梯的工作主法一样对 I/O 请求进行组织,当有一个新的请求到来时,它将请求合并到最近的请求之后,以此来保证请求同一介质。

Deadline 确保了在一个截止时间内服务请求,这个截止时间是可调整的,而默认读期限短于写期限,这样就防止了写操作因为不能被读取而饿死的现象。

AS 本质上与 Deadline 一样,但在最后一次读操作后,要等待 6ms,才能继续进行对其它 I/O 请求进行调度。可以从应用程序中预订一个新的读请求,改进读操作的执行,但以一些写操作为代价。它会在每个 6ms 中插入新的 I/O 操作,而会将一些小写入流合并成一个大写入流,用写入延时换取最大的写入吞吐量。

在 SSD 或者 Fusion IO,最简单的 NOOP 反而可能是最好的算法,因为其他三个算法的优化是基于缩短寻道时间的,而固态硬盘没有所谓的寻道时间且 I/O 响应时间非常短。

还是用数据说话吧,以下是 SSD 下针对不同 I/O 调度算法所做的 I/O 性能测试,均为 IOPS。

I/O Type NOOP Anticipatory Deadline CFQ
Sequential Read 22256 7955 22467 8652
Sequential Write 4090 2560 1370 1996
Sequential RW Read 6355 760 567 1149
Sequential RW Write 6360 760 565 1149
Random Read 17905 20847 20930 20671
Random Write 7423 8086 8113 8072
Random RW Read 4994 5221 5316 5275
Random RW Write 4991 5222 5321 5278

可以看到,整体来说,NOOP 算法略胜于其他算法。

接下来讲解需要调整的 InnoDB 参数的含义:

  • innodb_log_file_size:InnoDB 日志文件的大小;
  • innodb_io_capacity:缓冲区刷新到磁盘时,刷新脏页数量;
  • innodb_max_dirty_pages_pct:控制了 Dirty Page 在 Buffer Pool 中所占的比率;
  • innodb_adaptive_flushing:自适应刷新脏页;
  • innodb_write_io_threads:InnoDB 使用后台线程处理数据页上写 I/O(输入)请求的数量;
  • innodb_read_io_threads:InnoDB 使用后台线程处理数据页上读 I/O(输出)请求的数量。

4、A 项目 MySQL 主从关系图

A 项目 MySQL 主从关系如图一:

Yzone图一 A 项目 MySQL 主从关系图

5、程序切换之前调优

程序切换之前,39 只是 24 的从库,所以 IO 压力不高,以下的调整也不能说明根本性的变化。需要说明一点,以下调整的平均间隔在 30 分钟左右。

5.1 修改系统 IO 调度算法

系统默认的 I/O 调度算法 是 CFQ,我们试图先修改之。至于为什么修改,可以查看第3节。

具体的做法如下,需要注意的是,请根据实际情况做调整,比如你的系统中磁盘很可能不是 sda。

echo "noop" > /sys/block/sda/queue/scheduler

如果想永久生效,需要更改 /etc/grub.conf,添加 elevator,示例如下:

kernel /vmlinuz-x.x.xx-xxx.el6.x86_64 ro root=UUID=e01d6bb4-bd74-404f-855a-0f700fad4de0 rd_NO_LUKS rd_NO_LVM LANG=en_US.UTF-8 rd_NO_MD SYSFONT=latarcyrheb-sun1
6 crashkernel=auto KEYBOARDTYPE=pc KEYTABLE=us rd_NO_DM elevator=noop rhgb quiet

此步调整做完以后,查看 39 I/O 状态,并没有显著的变化。

5.2 修改 innodb_io_capacity = 4000

在做这个参数调整之前,我们来看看当前 MySQL 的配置:

innodb_buffer_pool_size 42949672960
innodb_log_file_size 1342177280
innodb_io_capacity 200
innodb_max_dirty_pages_pct 30
innodb_adaptive_flushing ON
innodb_write_io_threads 4
innodb_read_io_threads 4

修改方法如下:

SET GLOBAL innodb_io_capacity = 4000;

网络上的文章,针对 SSD 的优化,MySQL 方面需要把 innodb_io_capacity 设置为 4000,或者更高。然而实际上,此业务 UPDATE 较多,每次的修改量大概有 20K,并且基本上都是离散写。innodb_io_capacity 达到 4000,SSD 并没有给整个系统带来很大的性能提升。相反,反而使 IO 压力过大,until 甚至达到 80% 以上。

5.3 修改 innodb_max_dirty_pages_pct = 25

修改方法如下:

SET GLOBAL innodb_max_dirty_pages_pct = 25;

修改之后的 MySQL 配置:

innodb_buffer_pool_size 42949672960
innodb_log_file_size 1342177280
innodb_io_capacity 4000
innodb_max_dirty_pages_pct 25
innodb_adaptive_flushing ON
innodb_write_io_threads 4
innodb_read_io_threads 4

之前已经将 innodb_max_dirty_pages_pct 设置为 30,此处将 innodb_max_dirty_pages_pct 下调为 25%,目的为了查看脏数据对 I/O 的影响。修改的结果是,I/O 出现波动,innodbBuffPoolPagesFlushed 同样出现波动。然而,由于 39 是 24 的从库,暂时还没有切换,所有压力不够大,脏数据也不够多,所以调整此参数看不出效果。

5.4 修改 innodb_io_capacity = 2000

修改方法不赘述。

修改之后的 MySQL 配置:

innodb_buffer_pool_size 42949672960
innodb_log_file_size 1342177280
innodb_io_capacity 2000
innodb_max_dirty_pages_pct 25
innodb_adaptive_flushing ON
innodb_write_io_threads 4
innodb_read_io_threads 4

因为 innodb_io_capacity 为 4000 的情况下,I/O 压力过高,所以将 innodb_io_capacity 调整为 2000。调整后,w/s 最高不过 2000 左右,并且 I/O until 还是偏高,最高的时候有 70%。我们同时可以看到,I/O 波动幅度减小,innodbBuffPoolPagesFlushed 同样如此。

5.5 修改 innodb_io_capacity = 1500

修改方法不赘述。

修改之后的 MySQL 配置:

innodb_buffer_pool_size 42949672960
innodb_log_file_size 1342177280
innodb_io_capacity 1500
innodb_max_dirty_pages_pct 25
innodb_adaptive_flushing ON
innodb_write_io_threads 4
innodb_read_io_threads 4

I/O 持续出现波动,我们接着继续下调 innodb_io_capacity,调整为 1500。I/O until 降低,I/O 波动幅度继续减小,innodbBuffPoolPagesFlushed 同样如此。

5.6 关闭 innodb_adaptive_flushing

修改方法如下:

SET GLOBAL innodb_adaptive_flushing = OFF;

修改之后的 MySQL 配置:

innodb_buffer_pool_size 42949672960
innodb_log_file_size 1342177280
innodb_io_capacity 1500
innodb_max_dirty_pages_pct 25
innodb_adaptive_flushing OFF
innodb_write_io_threads 4
innodb_read_io_threads 4

既然落地仍然有异常,那我们可以试着关闭 innodb_adaptive_flushing,不让 MySQL 干预落地。调整的结果是,脏数据该落地还是落地,并没有受 I/O 压力的影响,调整此参数无效。

5.7 打开 innodb_adaptive_flushing

修改方法如下:

SET GLOBAL innodb_adaptive_flushing = ON;

修改之后的 MySQL 配置:

innodb_buffer_pool_size 42949672960
innodb_log_file_size 1342177280
innodb_io_capacity 1500
innodb_max_dirty_pages_pct 25
innodb_adaptive_flushing ON
innodb_write_io_threads 4
innodb_read_io_threads 4

经过以上调整,关闭 innodb_adaptive_flushing 没有效果,还是保持默认打开,让这个功能持续起作用吧。

5.8 设置 innodb_max_dirty_pages_pct = 20

修改方法不赘述。

修改之后的 MySQL 配置:

innodb_buffer_pool_size 42949672960
innodb_log_file_size 1342177280
innodb_io_capacity 1500
innodb_max_dirty_pages_pct 20
innodb_adaptive_flushing ON
innodb_write_io_threads 4
innodb_read_io_threads 4

接着我们将 innodb_max_dirty_pages_pct 下调为 20,观察脏数据情况。由于 InnoDB Buffer Pool 设置为 40G,20% 也就是 8G,此时的压力达不到此阀值,所以调整参数是没有效果的。但业务繁忙时,就可以看到效果,落地频率会增高。

5.9 设置 innodb_io_capacity = 1000

修改方法不赘述。

修改之后的 MySQL 配置:

innodb_buffer_pool_size 42949672960
innodb_log_file_size 1342177280
innodb_io_capacity 1000
innodb_max_dirty_pages_pct 20
innodb_adaptive_flushing ON
innodb_write_io_threads 4
innodb_read_io_threads 4

经过以上调整,我们需要的是一个均衡的 IO,给其他进程一些余地。于是把 innodb_io_capacity 设置为 1000,此时可以看到 I/O until 维持在 10% 左右,整个系统的参数趋于稳定。

后续还要做进一步的监控、跟踪、分析和优化。

6、 程序切换之后调优

在业务低峰,凌晨 1 点左右,配合研发做了切换。切换之后的主从关系可以查看第五节。

6.1 设置 innodb_max_dirty_pages_pct = 30,innodb_io_capacity = 1500

修改方法不赘述。

修改之后的 MySQL 配置:

innodb_buffer_pool_size 42949672960
innodb_log_file_size 1342177280
innodb_io_capacity 1500
innodb_max_dirty_pages_pct 30
innodb_adaptive_flushing ON
innodb_write_io_threads 4
innodb_read_io_threads 4

在 innodb_io_capacity 为 1000,innodb_max_dirty_pages_pct 为 20 的环境下,I/O until 有小幅波动,而且波峰和波谷持续交替,这种情况是不希望看到的。innodbBuffPoolPagesFlushed 比较稳定,但 innodbBuffPoolPagesDirty 持续上涨,没有下降的趋势。故做了如下调整:innodb_max_dirty_pages_pct = 30,innodb_io_capacity = 1500。调整完成后,innodbBuffPoolPagesDirty 趋于稳定,I/O until 也比较稳定。

6.2 设置 innodb_max_dirty_pages_pct = 40,innodb_io_capacity = 2000

修改方法不赘述。

修改之后的 MySQL 配置:

innodb_buffer_pool_size 42949672960
innodb_log_file_size 1342177280
innodb_io_capacity 2000
innodb_max_dirty_pages_pct 40
innodb_adaptive_flushing ON
innodb_write_io_threads 4
innodb_read_io_threads 4

针对目前这种 I/O 情况,做了如下调整:innodb_max_dirty_pages_pct = 40,innodb_io_capacity = 2000。

6.3 分析

针对以上两个调整,我们通过结合监控数据来分析 I/O 状态。

以下是高速缓冲区的脏页数据情况,如图二:

InnoDB Dirty pages图二 主库的脏数据情况

以下是脏数据落地的情况,如图三

InnoDB Flushed图三 主库的脏数据落地情况

28 号早 8 点到下午 7 点,当脏数据上升,也就是在内存中的数据更多,那么落地就会很少,呈现一个平稳的趋势;当脏数据维持不变,也就是脏数据达到了 innodb_max_dirty_pages_pct 的限额(innodb_buffer_pool_size 为 40G,innodb_max_dirty_pages_pct 为 40%,也就是在内存中的脏数据最多为 16G,每个 Page 16K,则 innodbBufferPoolDirtyPages 最大为 1000K),落地就会增多,呈现上升的趋势,所以才会出现上述图片中的曲线。

这是最后的配置:

innodb_buffer_pool_size 42949672960
innodb_log_file_size 1342177280
innodb_io_capacity 2000
innodb_max_dirty_pages_pct 40
innodb_adaptive_flushing ON
innodb_write_io_threads 4
innodb_read_io_threads 4

7、小结

此次针对 SSD 以及 MySQL InnoDB 参数优化,总结起来,也就是以下三条:

  • 修改系统 I/O 调度算法;
  • 分析 I/O 情况,动态调整 innodb_io_capacity 和 innodb_max_dirty_pages_pct;
  • 试图调整 innodb_adaptive_flushing,查看效果。

针对 innodb_write_io_threads 和 innodb_read_io_threads 的调优我们目前没有做,我相信调整为 8 或者 16,系统 I/O 性能会更好。

还有,需要注意以下几点:

  • 网络文章介绍的方法有局限性和场景性,不能亲信,不能盲从,做任何调整都要以业务优先。保证业务的平稳运行才是最重要的,性能都是其次;
  • 任何一个调整,都要建立在数据的支撑和严谨的分析基础上,否则都是空谈;
  • 这类调优是非常有意义的,是真正能带来价值的,所以需要多下功夫,并且尽可能地搞明白为什么要这么调整。

文末,说一点比较有意思的。之前有篇文章提到过 SSDB。SSDB 底层采用 Google 的 LevelDB,并支持 Redis 协议。LevelDB 的设计完全是贴合 SSD 的设计思想的。首先,尽可能地转化为连续写;其次,不断新增数据文件,防止同一位置不断擦写。另外,SSDB 的名字取得也很有意思,也很有水平。我猜想作者也是希望用户将 SSDB 应用在 SSD 上吧。

8、参考

MySQL 文档: 8.5 Optimizing for InnoDB Tables 

(题图来自:pachosting.hk)

在 Linux 下使用 RAID(五):安装 RAID 6(条带化双分布式奇偶校验)

RAID 6 是 RAID 5 的升级版,它有两个分布式奇偶校验,即使两个磁盘发生故障后依然有容错能力。在两个磁盘同时发生故障时,系统的关键任务仍然能运行。它与 RAID 5 相似,但性能更健壮,因为它多用了一个磁盘来进行奇偶校验。

在之前的文章中,我们已经在 RAID 5 看了分布式奇偶校验,但在本文中,我们将看到的是 RAID 6 双分布式奇偶校验。不要期望比其他 RAID 有更好的性能,除非你也安装了一个专用的 RAID 控制器。在 RAID 6 中,即使我们失去了2个磁盘,我们仍可以通过更换磁盘,从校验中构建数据,然后取回数据。

Setup RAID 6 in CentOS

在 Linux 中安装 RAID 6

要建立一个 RAID 6,一组最少需要4个磁盘。RAID 6 甚至在有些组中会有更多磁盘,这样将多个硬盘捆在一起,当读取数据时,它会同时从所有磁盘读取,所以读取速度会更快,当写数据时,因为它要将数据写在条带化的多个磁盘上,所以性能会较差。

现在,很多人都在讨论为什么我们需要使用 RAID 6,它的性能和其他 RAID 相比并不太好。提出这个问题首先需要知道的是,如果需要高容错性就选择 RAID 6。在每一个用于数据库的高可用性要求较高的环境中,他们需要 RAID 6 因为数据库是最重要,无论花费多少都需要保护其安全,它在视频流环境中也是非常有用的。

RAID 6 的的优点和缺点

  • 性能不错。
  • RAID 6 比较昂贵,因为它要求两个独立的磁盘用于奇偶校验功能。
  • 将失去两个磁盘的容量来保存奇偶校验信息(双奇偶校验)。
  • 即使两个磁盘损坏,数据也不会丢失。我们可以在更换损坏的磁盘后从校验中重建数据。
  • 读性能比 RAID 5 更好,因为它从多个磁盘读取,但对于没有专用的 RAID 控制器的设备写性能将非常差。

要求

要创建一个 RAID 6 最少需要4个磁盘。你也可以添加更多的磁盘,但你必须有专用的 RAID 控制器。使用软件 RAID 我们在 RAID 6 中不会得到更好的性能,所以我们需要一个物理 RAID 控制器。

如果你新接触 RAID 设置,我们建议先看完以下 RAID 文章。

我的服务器设置

操作系统 :  CentOS 6.5 Final
IP 地址    :  192.168.0.228
主机名    :  rd6.tecmintlocal.com
磁盘 1 [20GB]  :  /dev/sdb
磁盘 2 [20GB]  :  /dev/sdc
磁盘 3 [20GB]  :  /dev/sdd
磁盘 4 [20GB]  :  /dev/sde

这是9篇系列教程的第5部分,在这里我们将看到如何在 Linux 系统或者服务器上使用四个 20GB 的磁盘(名为 /dev/sdb、 /dev/sdc、 /dev/sdd 和 /dev/sde)创建和设置软件 RAID 6 (条带化双分布式奇偶校验)。

第1步:安装 mdadm 工具,并检查磁盘

1、 如果你按照我们最进的两篇 RAID 文章(第2篇和第3篇),我们已经展示了如何安装mdadm工具。如果你直接看的这篇文章,我们先来解释下在 Linux 系统中如何使用mdadm工具来创建和管理 RAID,首先根据你的 Linux 发行版使用以下命令来安装。

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

2、 安装该工具后,然后来验证所需的四个磁盘,我们将会使用下面的fdisk命令来检查用于创建 RAID 的磁盘。

# fdisk -l | grep sd

Check Hard Disk in Linux

在 Linux 中检查磁盘

3、 在创建 RAID 磁盘前,先检查下我们的磁盘是否创建过 RAID 分区。

# mdadm -E /dev/sd[b-e]
# mdadm --examine /dev/sdb /dev/sdc /dev/sdd /dev/sde # 或

Check Raid on Disk

在磁盘上检查 RAID 分区

注意: 在上面的图片中,没有检测到任何 super-block 或者说在四个磁盘上没有 RAID 存在。现在我们开始创建 RAID 6。

第2步:为 RAID 6 创建磁盘分区

4、 现在在 /dev/sdb, /dev/sdc, /dev/sdd/dev/sde上为 RAID 创建分区,使用下面的 fdisk 命令。在这里,我们将展示如何在 sdb 磁盘创建分区,同样的步骤也适用于其他分区。

创建 /dev/sdb 分区

# fdisk /dev/sdb

请按照说明进行操作,如下图所示创建分区。

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

Create sdb Partition

创建 /dev/sdb 分区

创建 /dev/sdc 分区

# fdisk /dev/sdc

Create sdc Partition

创建 /dev/sdc 分区

创建 /dev/sdd 分区

# fdisk /dev/sdd

Create sdd Partition

创建 /dev/sdd 分区

创建 /dev/sde 分区

# fdisk /dev/sde

Create sde Partition

创建 /dev/sde 分区

5、 创建好分区后,检查磁盘的 super-blocks 是个好的习惯。如果 super-blocks 不存在我们可以按前面的创建一个新的 RAID。

# mdadm -E /dev/sd[b-e]1
# mdadm --examine /dev/sdb1 /dev/sdc1 /dev/sdd1 /dev/sde1 # 或

Check Raid on New Partitions

*在新分区中检查 RAID *

第3步:创建 md 设备(RAID)

6、 现在可以使用以下命令创建 RAID 设备md0 (即 /dev/md0),并在所有新创建的分区中应用 RAID 级别,然后确认 RAID 设置。

# mdadm --create /dev/md0 --level=6 --raid-devices=4 /dev/sdb1 /dev/sdc1 /dev/sdd1 /dev/sde1
# cat /proc/mdstat

Create Raid 6 Device

创建 Raid 6 设备

7、 你还可以使用 watch 命令来查看当前创建 RAID 的进程,如下图所示。

# watch -n1 cat /proc/mdstat

Check Raid 6 Process

检查 RAID 6 创建过程

8、 使用以下命令验证 RAID 设备。

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

注意::上述命令将显示四个磁盘的信息,这是相当长的,所以没有截取其完整的输出。

9、 接下来,验证 RAID 阵列,以确认重新同步过程已经开始。

# mdadm --detail /dev/md0

Check Raid 6 Array

检查 Raid 6 阵列

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

10、 使用 ext4 为/dev/md0创建一个文件系统,并将它挂载在 /mnt/raid6 。这里我们使用的是 ext4,但你可以根据你的选择使用任意类型的文件系统。

# mkfs.ext4 /dev/md0

Create File System on Raid

在 RAID 6 上创建文件系统

11、 将创建的文件系统挂载到 /mnt/raid6,并验证挂载点下的文件,我们可以看到 lost+found 目录。

# mkdir /mnt/raid6
# mount /dev/md0 /mnt/raid6/
# ls -l /mnt/raid6/

12、 在挂载点下创建一些文件,在任意文件中添加一些文字并验证其内容。

# touch /mnt/raid6/raid6_test.txt
# ls -l /mnt/raid6/
# echo "tecmint raid setups" > /mnt/raid6/raid6_test.txt
# cat /mnt/raid6/raid6_test.txt

Verify Raid Content

验证 RAID 内容

13、 在 /etc/fstab 中添加以下条目使系统启动时自动挂载设备,操作系统环境不同挂载点可能会有所不同。

# vim /etc/fstab
/dev/md0                /mnt/raid6              ext4    defaults        0 0

Automount Raid 6 Device

自动挂载 RAID 6 设备

14、 接下来,执行mount -a命令来验证 fstab 中的条目是否有错误。

# mount -av

Verify Raid Automount

验证 RAID 是否自动挂载

第5步:保存 RAID 6 的配置

15、 请注意,默认情况下 RAID 没有配置文件。我们需要使用以下命令手动保存它,然后检查设备/dev/md0的状态。

# mdadm --detail --scan --verbose >> /etc/mdadm.conf
# cat /etc/mdadm.conf
# mdadm --detail /dev/md0

Save Raid 6 Configuration

保存 RAID 6 配置

Check Raid 6 Status

检查 RAID 6 状态

第6步:添加备用磁盘

16、 现在,已经使用了4个磁盘,并且其中两个作为奇偶校验信息来使用。在某些情况下,如果任意一个磁盘出现故障,我们仍可以得到数据,因为在 RAID 6 使用双奇偶校验。

如果第二个磁盘也出现故障,在第三块磁盘损坏前我们可以添加一个​​新的。可以在创建 RAID 集时加入一个备用磁盘,但我在创建 RAID 集合前没有定义备用的磁盘。不过,我们可以在磁盘损坏后或者创建 RAID 集合时添加一块备用磁盘。现在,我们已经创建好了 RAID,下面让我演示如何添加备用磁盘。

为了达到演示的目的,我已经热插入了一个新的 HDD 磁盘(即 /dev/sdf),让我们来验证接入的磁盘。

# ls -l /dev/ | grep sd

Check New Disk

检查新磁盘

17、 现在再次确认新连接的磁盘没有配置过 RAID ,使用 mdadm 来检查。

# mdadm --examine /dev/sdf

Check Raid on New Disk

在新磁盘中检查 RAID

注意: 像往常一样,我们早前已经为四个磁盘创建了分区,同样,我们使用 fdisk 命令为新插入的磁盘创建新分区。

# fdisk /dev/sdf

Create sdf Partition

为 /dev/sdf 创建分区

18、 在 /dev/sdf 创建新的分区后,在新分区上确认没有 RAID,然后将备用磁盘添加到 RAID 设备 /dev/md0 中,并验证添加的设备。

# mdadm --examine /dev/sdf
# mdadm --examine /dev/sdf1
# mdadm --add /dev/md0 /dev/sdf1
# mdadm --detail /dev/md0

Verify Raid on sdf Partition

在 sdf 分区上验证 Raid

Add sdf Partition to Raid

*添加 sdf 分区到 RAID *

Verify sdf Partition Details

验证 sdf 分区信息

第7步:检查 RAID 6 容错

19、 现在,让我们检查备用驱动器是否能自动工作,当我们阵列中的任何一个磁盘出现故障时。为了测试,我将一个磁盘手工标记为故障设备。

在这里,我们标记 /dev/sdd1 为故障磁盘。

# mdadm --manage --fail /dev/md0 /dev/sdd1

Check Raid 6 Fault Tolerance

检查 RAID 6 容错

20、 让我们查看 RAID 的详细信息,并检查备用磁盘是否开始同步。

# mdadm --detail /dev/md0

Check Auto Raid Syncing

检查 RAID 自动同步

哇塞! 这里,我们看到备用磁盘激活了,并开始重建进程。在底部,我们可以看到有故障的磁盘 /dev/sdd1 标记为 faulty。可以使用下面的命令查看进程重建。

# cat /proc/mdstat

Raid 6 Auto Syncing

RAID 6 自动同步

结论:

在这里,我们看到了如何使用四个磁盘设置 RAID 6。这种 RAID 级别是具有高冗余的昂贵设置之一。在接下来的文章中,我们将看到如何建立一个嵌套的 RAID 10 甚至更多。请继续关注。


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

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

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

Ubuntu 上使用 LVM 轻松调整分区并制作快照

Ubuntu的安装器提供了一个轻松“使用LVM”的复选框。它的描述中说,启用逻辑卷管理可以让你制作快照,并更容易地调整硬盘分区大小——这里将为大家讲述如何完成这些操作。

LVM是一种技术,某种程度上和RAID阵列Windows上的“存储空间”类似。虽然该技术在服务器上更为有用,但是它也可以在桌面端PC上使用。

你应该在新安装Ubuntu时使用LVM吗?

第一个问题是,你是否想要在安装Ubuntu时使用LVM?如果是,那么Ubuntu让这一切变得很简单,只需要轻点鼠标就可以完成,但是该选项默认是不启用的。正如安装器所说的,它允许你调整分区、创建快照、将多个磁盘合并到一个逻辑卷等等——所有这一切都可以在系统运行时完成。不同于传统分区,你不需要关掉你的系统,从Live CD或USB驱动,然后当这些分区不使用时才能调整

完全坦率地说,普通Ubuntu桌面用户可能不会意识到他们是否正在使用LVM。但是,如果你想要在今后做一些更高深的事情,那么LVM就会有所帮助了。LVM可能更复杂,可能会在你今后恢复数据时会导致问题——尤其是在你经验不足时。这里不会有显著的性能损失——LVM是彻底地在Linux内核中实现的。

逻辑卷管理说明

前面,我们已经说明了何谓LVM。概括来讲,它在你的物理磁盘和呈现在你系统中的分区之间提供了一个抽象层。例如,你的计算机可能装有两个硬盘驱动器,它们的大小都是 1 TB。你必须得在这些磁盘上至少分两个区,每个区大小 1 TB。

LVM就在这些分区上提供了一个抽象层。用于取代磁盘上的传统分区,LVM将在你对这些磁盘初始化后,将它们当作独立的“物理卷”来对待。然后,你就可以基于这些物理卷创建“逻辑卷”。例如,你可以将这两个 1 TB 的磁盘组合成一个 2 TB 的分区,你的系统将只看到一个 2 TB 的卷,而LVM将会在后台处理这一切。一组物理卷以及一组逻辑卷被称之为“卷组”,一个典型的系统只会有一个卷组。

该抽象层使得调整分区、将多个磁盘组合成单个卷、甚至为一个运行着的分区的文件系统创建“快照”变得十分简单,而完成所有这一切都无需先卸载分区。

注意,如果你没有创建备份,那么将多个磁盘合并成一个卷将会是个糟糕的想法。它就像RAID 0——如果你将两个 1 TB 的卷组合成一个 2 TB 的卷,只要其中一个硬盘失败,你将丢失该卷上的重要数据。所以,如果你要走这条路,那么备份就及其重要。

管理LVM卷的图形化工具

通常,LVM通过Linux终端命令来管理。这在Ubuntu上也行得通,但是有个更简单的图形化方法可供大家采用。如果你是一个Linux用户,对GParted或者与其类似的分区管理器熟悉,算了,别瞎掰了——GParted根本不支持LVM磁盘。

然而,你可以使用Ubuntu附带的磁盘工具。该工具也被称之为GNOME磁盘工具,或者叫Palimpsest。点击dash中的图标来开启它吧,搜索“磁盘”然后敲击回车。不像GParted,该磁盘工具将会在“其它设备”下显示LVM分区,因此你可以根据需要格式化这些分区,也可以调整其它选项。该工具在Live CD或USB 驱动下也可以使用。

不幸的是,该磁盘工具不支持LVM的大多数强大的特性,没有管理卷组、扩展分区,或者创建快照等选项。对于这些操作,你可以通过终端来实现,但是没有那个必要。相反,你可以打开Ubuntu软件中心,搜索关键字LVM,然后安装逻辑卷管理工具,你可以在终端窗口中运行sudo apt-get install system-config-lvm命令来安装它。安装完之后,你就可以从dash上打开逻辑卷管理工具了。

这个图形化配置工具是由红帽公司开发的,虽然有点陈旧了,但却是唯一的图形化方式,你可以通过它来完成上述操作,将那些终端命令抛诸脑后了。

比如说,你想要添加一个新的物理卷到卷组中。你可以打开该工具,选择未初始化条目下的新磁盘,然后点击“初始化条目”按钮。然后,你就可以在未分配卷下找到新的物理卷了,你可以使用“添加到现存卷组”按钮来将它添加到“ubuntu-vg”卷组,这是Ubuntu在安装过程中创建的卷组。

卷组视图会列出你所有的物理卷和逻辑卷的总览。这里,我们有两个横跨两个独立硬盘驱动器的物理分区,我们有一个交换分区和一个根分区,这是Ubuntu默认设置的分区图表。由于我们从另一个驱动器添加了第二个物理分区,现在那里有大量未使用空间。

要扩展逻辑分区到物理空间,你可以在逻辑视图下选择它,点击编辑属性,然后修改大小来扩大分区。你也可以在这里缩小分区。

system-config-lvm的其它选项允许你设置快照和镜像。对于传统桌面而言,你或许不需要这些特性,但是在这里也可以通过图形化处理。记住,你也可以使用终端命令完成这一切


via: http://www.howtogeek.com/211937/how-to-use-lvm-on-ubuntu-for-easy-partition-resizing-and-snapshots/

译者:GOLinux 校对:wxy

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

在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)

RAID 10 是组合 RAID 1 和 RAID 0 形成的。要设置 RAID 10,我们至少需要4个磁盘。在之前的文章中,我们已经看到了如何使用最少两个磁盘设置 RAID 1 和 RAID 0。

在这里,我们将使用最少4个磁盘组合 RAID 1 和 RAID 0 来设置 RAID 10。假设我们已经在用 RAID 10 创建的逻辑卷保存了一些数据。比如我们要保存数据 “TECMINT”,它将使用以下方法将其保存在4个磁盘中。

在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)
在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)

在 Linux 中创建 Raid 10(LCTT 译注:原图有误,已修正)

RAID 10 是先做镜像,再做条带。因此,在 RAID 1 中,相同的数据将被写入到两个磁盘中,“T”将同时被写入到第一和第二个磁盘中。接着的数据被条带化到另外两个磁盘,“E”将被同时写入到第三和第四个磁盘中。它将继续循环此过程,“C”将同时被写入到第一和第二个磁盘,以此类推。

(LCTT 译注:原文中此处描述混淆有误,已经根据实际情况进行修改。)

现在你已经了解 RAID 10 怎样组合 RAID 1 和 RAID 0 来工作的了。如果我们有4个20 GB 的磁盘,总共为 80 GB,但我们将只能得到40 GB 的容量,另一半的容量在构建 RAID 10 中丢失。

RAID 10 的优点和缺点

  • 提供更好的性能。
  • 在 RAID 10 中我们将失去一半的磁盘容量。
  • 读与写的性能都很好,因为它会同时进行写入和读取。
  • 它能解决数据库的高 I/O 磁盘写操作。

要求

在 RAID 10 中,我们至少需要4个磁盘,前2个磁盘为 RAID 1,其他2个磁盘为 RAID 0,就像我之前说的,RAID 10 仅仅是组合了 RAID 0和1。如果我们需要扩展 RAID 组,最少需要添加4个磁盘。

我的服务器设置

操作系统 :  CentOS 6.5 Final
IP 地址       :   192.168.0.229
主机名       :   rd10.tecmintlocal.com
磁盘 1 [20GB]     :   /dev/sdd
磁盘 2 [20GB]     :   /dev/sdc
磁盘 3 [20GB]     :   /dev/sdd
磁盘 4 [20GB]     :   /dev/sde

有两种方法来设置 RAID 10,在这里两种方法我都会演示,但我更喜欢第一种方法,使用它来设置 RAID 10 更简单。

方法1:设置 RAID 10

1、 首先,使用以下命令确认所添加的4块磁盘没有被使用。

# ls -l /dev | grep sd

2、 四个磁盘被检测后,然后来检查磁盘是否存在 RAID 分区。

# mdadm -E /dev/sd[b-e]
# mdadm --examine /dev/sdb /dev/sdc /dev/sdd /dev/sde # 或
在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)
在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)

验证添加的4块磁盘

注意: 在上面的输出中,如果没有检测到 super-block 意味着在4块磁盘中没有定义过 RAID。

第1步:为 RAID 分区

3、 现在,使用fdisk,命令为4个磁盘(/dev/sdb, /dev/sdc, /dev/sdd 和 /dev/sde)创建新分区。

# fdisk /dev/sdb
# fdisk /dev/sdc
# fdisk /dev/sdd
# fdisk /dev/sde
为 /dev/sdb 创建分区

我来告诉你如何使用 fdisk 为磁盘(/dev/sdb)进行分区,此步也适用于其他磁盘。

# fdisk /dev/sdb

请使用以下步骤为 /dev/sdb 创建一个新的分区。

  • n 创建新的分区。
  • 然后按 P 选择主分区。
  • 接下来选择分区号为1。
  • 只需按两次回车键选择默认值即可。
  • 然后,按 P 来打印创建好的分区。
  • L,列出所有可用的类型。
  • t 去修改分区。
  • 键入 fd 设置为 Linux 的 RAID 类型,然后按 Enter 确认。
  • 然后再次使用p查看我们所做的更改。
  • 使用w保存更改。
在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)
在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)

为磁盘 sdb 分区

注意: 请使用上面相同的指令对其他磁盘(sdc, sdd sdd sde)进行分区。

4、 创建好4个分区后,需要使用下面的命令来检查磁盘是否存在 raid。

# mdadm -E /dev/sd[b-e]
# mdadm --examine /dev/sdb /dev/sdc /dev/sdd /dev/sde # 或
# mdadm -E /dev/sd[b-e]1
# mdadm --examine /dev/sdb1 /dev/sdc1 /dev/sdd1 /dev/sde1 # 或
在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)
在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)

检查磁盘

注意: 以上输出显示,新创建的四个分区中没有检测到 super-block,这意味着我们可以继续在这些磁盘上创建 RAID 10。

第2步: 创建 RAID 设备 md

5、 现在该创建一个md(即 /dev/md0)设备了,使用“mdadm” raid 管理工具。在创建设备之前,必须确保系统已经安装了mdadm工具,如果没有请使用下面的命令来安装。

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

mdadm工具安装完成后,可以使用下面的命令创建一个md raid 设备。

# mdadm --create /dev/md0 --level=10 --raid-devices=4 /dev/sd[b-e]1

6、 接下来使用cat命令验证新创建的 raid 设备。

# cat /proc/mdstat
在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)
在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)

创建 md RAID 设备

7、 接下来,使用下面的命令来检查4个磁盘。下面命令的输出会很长,因为它会显示4个磁盘的所有信息。

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

8、 接下来,使用以下命令来查看 RAID 阵列的详细信息。

# mdadm --detail /dev/md0
在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)
在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)

查看 RAID 阵列详细信息

注意: 你在上面看到的结果,该 RAID 的状态是 active 和re-syncing。

第3步:创建文件系统

9、 使用 ext4 作为md0′的文件系统,并将它挂载到/mnt/raid10`下。在这里,我用的是 ext4,你可以使用你想要的文件系统类型。

# mkfs.ext4 /dev/md0
在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)
在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)

创建 md 文件系统

10、 在创建文件系统后,挂载文件系统到/mnt/raid10下,并使用ls -l命令列出挂载点下的内容。

# mkdir /mnt/raid10
# mount /dev/md0 /mnt/raid10/
# ls -l /mnt/raid10/

接下来,在挂载点下创建一些文件,并在文件中添加些内容,然后检查内容。

# touch /mnt/raid10/raid10_files.txt
# ls -l /mnt/raid10/
# echo "raid 10 setup with 4 disks" > /mnt/raid10/raid10_files.txt
# cat /mnt/raid10/raid10_files.txt
在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)
在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)

挂载 md 设备

11、 要想自动挂载,打开/etc/fstab文件并添加下面的条目,挂载点根据你环境的不同来添加。使用 wq! 保存并退出。

# vim /etc/fstab
/dev/md0                /mnt/raid10              ext4    defaults        0 0
在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)
在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)

挂载 md 设备

12、 接下来,在重新启动系统前使用mount -a来确认/etc/fstab文件是否有错误。

# mount -av

Check Errors in Fstab

检查 Fstab 中的错误

第四步:保存 RAID 配置

13、 默认情况下 RAID 没有配置文件,所以我们需要在上述步骤完成后手动保存它。

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

Save Raid10 Configuration

保存 RAID10 的配置

就这样,我们使用方法1创建完了 RAID 10,这种方法是比较容易的。现在,让我们使用方法2来设置 RAID 10。

方法2:创建 RAID 10

1、 在方法2中,我们必须定义2组 RAID 1,然后我们需要使用这些创建好的 RAID 1 的集合来定义一个 RAID 0。在这里,我们将要做的是先创建2个镜像(RAID1),然后创建 RAID0 (条带化)。

首先,列出所有的可用于创建 RAID 10 的磁盘。

# ls -l /dev | grep sd
在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)
在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)

列出了 4 个设备

2、 将4个磁盘使用fdisk命令进行分区。对于如何分区,您可以按照上面的第1步。

# fdisk /dev/sdb
# fdisk /dev/sdc
# fdisk /dev/sdd
# fdisk /dev/sde

3、 在完成4个磁盘的分区后,现在检查磁盘是否存在 RAID块。

# mdadm --examine /dev/sd[b-e]
# mdadm --examine /dev/sd[b-e]1
在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)
在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)

检查 4 个磁盘

第1步:创建 RAID 1

4、 首先,使用4块磁盘创建2组 RAID 1,一组为sdb1′和sdc1′,另一组是sdd1′ 和sde1′。

# mdadm --create /dev/md1 --metadata=1.2 --level=1 --raid-devices=2 /dev/sd[b-c]1
# mdadm --create /dev/md2 --metadata=1.2 --level=1 --raid-devices=2 /dev/sd[d-e]1
# cat /proc/mdstat
在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)
在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)

创建 RAID 1

在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)
在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)

查看 RAID 1 的详细信息

第2步:创建 RAID 0

5、 接下来,使用 md1 和 md2 来创建 RAID 0。

# mdadm --create /dev/md0 --level=0 --raid-devices=2 /dev/md1 /dev/md2
# cat /proc/mdstat
在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)
在 Linux 下使用 RAID(六):设置 RAID 10 或 1 + 0(嵌套)

创建 RAID 0

第3步:保存 RAID 配置

6、 我们需要将配置文件保存在/etc/mdadm.conf文件中,使其每次重新启动后都能加载所有的 RAID 设备。

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

在此之后,我们需要按照方法1中的第3步来创建文件系统。

就是这样!我们采用的方法2创建完了 RAID 1+0。我们将会失去一半的磁盘空间,但相比其他 RAID ,它的性能将是非常好的。

结论

在这里,我们采用两种方法创建 RAID 10。RAID 10 具有良好的性能和冗余性。希望这篇文章可以帮助你了解 RAID 10 嵌套 RAID。在后面的文章中我们会看到如何扩展现有的 RAID 阵列以及更多精彩的内容。


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

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

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

在 Linux 下使用 RAID(七):在 RAID 中扩展现有的 RAID 阵列和删除故障的磁盘

每个新手都会对阵列(array)这个词所代表的意思产生疑惑。阵列只是磁盘的一个集合。换句话说,我们可以称阵列为一个集合(set)或一组(group)。就像一组鸡蛋中包含6个一样。同样 RAID 阵列中包含着多个磁盘,可能是2,4,6,8,12,16等,希望你现在知道了什么是阵列。

在这里,我们将看到如何扩展现有的阵列或 RAID 组。例如,如果我们在阵列中使用2个磁盘形成一个 raid 1 集合,在某些情况,如果该组中需要更多的空间,就可以使用 mdadm -grow 命令来扩展阵列大小,只需要将一个磁盘加入到现有的阵列中即可。在说完扩展(添加磁盘到现有的阵列中)后,我们将看看如何从阵列中删除故障的磁盘。

Grow Raid Array in Linux

扩展 RAID 阵列和删除故障的磁盘

假设磁盘中的一个有问题了需要删除该磁盘,但我们需要在删除磁盘前添加一个备用磁盘来扩展该镜像,因为我们需要保存我们的数据。当磁盘发生故障时我们需要从阵列中删除它,这是这个主题中我们将要学习到的。

扩展 RAID 的特性

  • 我们可以增加(扩展)任意 RAID 集合的大小。
  • 我们可以在使用新磁盘扩展 RAID 阵列后删除故障的磁盘。
  • 我们可以扩展 RAID 阵列而无需停机。

要求

  • 为了扩展一个RAID阵列,我们需要一个已有的 RAID 组(阵列)。
  • 我们需要额外的磁盘来扩展阵列。
  • 在这里,我们使用一块磁盘来扩展现有的阵列。

在我们了解扩展和恢复阵列前,我们必须了解有关 RAID 级别和设置的基本知识。点击下面的链接了解这些。

我的服务器设置

操作系统    :   CentOS 6.5 Final
IP地址      :   192.168.0.230
主机名     :   grow.tecmintlocal.com
2 块现有磁盘   :   1 GB
1 块额外磁盘   :   1 GB

在这里,我们已有一个 RAID ,有2块磁盘,每个大小为1GB,我们现在再增加一个磁盘到我们现有的 RAID 阵列中,其大小为1GB。

扩展现有的 RAID 阵列

1、 在扩展阵列前,首先使用下面的命令列出现有的 RAID 阵列。

# mdadm --detail /dev/md0

Check Existing Raid Array

检查现有的 RAID 阵列

注意: 以上输出显示,已经有了两个磁盘在 RAID 阵列中,级别为 RAID 1。现在我们增加一个磁盘到现有的阵列里。

2、 现在让我们添加新的磁盘“sdd”,并使用fdisk命令来创建分区。

# fdisk /dev/sdd

请使用以下步骤为 /dev/sdd 创建一个新的分区。

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

Create New Partition in Linux

为 sdd 创建新的分区

3、 一旦新的 sdd 分区创建完成后,你可以使用下面的命令验证它。

# ls -l /dev/ | grep sd

Confirm sdd Partition

确认 sdd 分区

4、 接下来,在添加到阵列前先检查磁盘是否有 RAID 分区。

# mdadm --examine /dev/sdd1

Check Raid on sdd Partition

在 sdd 分区中检查 RAID

注意:以上输出显示,该盘有没有发现 super-blocks,意味着我们可以将新的磁盘添加到现有阵列。

5、 要添加新的分区 /dev/sdd1 到现有的阵列 md0,请使用以下命令。

# mdadm --manage /dev/md0 --add /dev/sdd1

Add Disk To Raid-Array

添加磁盘到 RAID 阵列

6、 一旦新的磁盘被添加后,在我们的阵列中检查新添加的磁盘。

# mdadm --detail /dev/md0

Confirm Disk Added to Raid

确认将新磁盘添加到 RAID 中

注意: 在上面的输出,你可以看到磁盘已经被添加作为备用的。在这里,我们的阵列中已经有了2个磁盘,但我们期待阵列中有3个磁盘,因此我们需要扩展阵列。

7、 要扩展阵列,我们需要使用下面的命令。

# mdadm --grow --raid-devices=3 /dev/md0

Grow Raid Array

扩展 Raid 阵列

现在我们可以看到第三块磁盘(sdd1)已被添加到阵列中,在第三块磁盘被添加后,它将从另外两块磁盘上同步数据。

# mdadm --detail /dev/md0

Confirm Raid Array

确认 Raid 阵列

注意: 对于大容量磁盘会需要几个小时来同步数据。在这里,我们使用的是1GB的虚拟磁盘,所以它非常快在几秒钟内便会完成。

从阵列中删除磁盘

8、 在数据被从其他两个磁盘同步到新磁盘sdd1后,现在三个磁盘中的数据已经相同了(镜像)。

正如我前面所说的,假定一个磁盘出问题了需要被删除。所以,现在假设磁盘sdc1出问题了,需要从现有阵列中删除。

在删除磁盘前我们要将其标记为失效,然后我们才可以将其删除。

# mdadm --fail /dev/md0 /dev/sdc1
# mdadm --detail /dev/md0

Disk Fail in Raid Array

在 RAID 阵列中模拟磁盘故障

从上面的输出中,我们清楚地看到,磁盘在下面被标记为 faulty。即使它是 faulty 的,我们仍然可以看到 raid 设备有3个,1个损坏了,状态是 degraded。

现在我们要从阵列中删除 faulty 的磁盘,raid 设备将像之前一样继续有2个设备。

# mdadm --remove /dev/md0 /dev/sdc1

Remove Disk in Raid Array

在 Raid 阵列中删除磁盘

9、 一旦故障的磁盘被删除,然后我们只能使用2个磁盘来扩展 raid 阵列了。

# mdadm --grow --raid-devices=2 /dev/md0
# mdadm --detail /dev/md0

Grow Disks in Raid Array

在 RAID 阵列扩展磁盘

从上面的输出中可以看到,我们的阵列中仅有2台设备。如果你需要再次扩展阵列,按照如上所述的同样步骤进行。如果你需要添加一个磁盘作为备用,将其标记为 spare,因此,如果磁盘出现故障时,它会自动顶上去并重建数据。

结论

在这篇文章中,我们已经看到了如何扩展现有的 RAID 集合,以及如何在重新同步已有磁盘的数据后从一个阵列中删除故障磁盘。所有这些步骤都可以不用停机来完成。在数据同步期间,系统用户,文件和应用程序不会受到任何影响。

在接下来的文章我将告诉你如何管理 RAID,敬请关注更新,不要忘了写评论。


via: http://www.tecmint.com/grow-raid-array-in-linux/

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

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

MySQL & NoSQL – Memcached 插件

大多数人都已经听说 NoSQL 数据库,其中使用最广泛的工具是 Memcached,你们通过 Memcached 再应用层和数据库之间添加一个缓存层。从 MySQL 5.6 开始,你可以获得一个全新的插件,这个插件把 MySQL 和 Memcached 集成起来。在此文中,我们将学习怎样在 Linux 中 安装这个插件,怎样做一些基础的配置。

MySQL & NoSQL – Memcached 插件
MySQL & NoSQL – Memcached 插件

先决条件

安装 libevent。

译者注:以下命令由译者提供。

命令如下:

yum install libevent -y
yum install php -y
yum install policycoreutils-python -y

译者注:我的操作系统版本是 RHEL 6.5,而作者的 OS 版本为 CentOS。以下是我的 MySQL 版本。

mysql> SHOW VARIABLES LIKE '%version%';
+-------------------------+------------------------------+
| Variable_name           | Value                        |
+-------------------------+------------------------------+
| innodb_version          | 5.6.21                       |
| protocol_version        | 10                           |
| slave_type_conversions  |                              |
| version                 | 5.6.21                       |
| version_comment         | MySQL Community Server (GPL) |
| version_compile_machine | x86_64                       |
| version_compile_os      | Linux                        |
+-------------------------+------------------------------+
7 rows in set (0.00 sec)

安装

安装 Memcached 支持,我们需要创建一些为 MySQL 和 Memcached 集成服务的表。MySQL 已经包含了创建这些表的文件(innodb_memcached_config.sql),你可以在你的 basedir 子目录中找到这个文件。为了找到你的 basedir 在什么地方,运行如下命令:

mysql> SHOW VARIABLES LIKE 'basedir';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| basedir       | /usr  |
+---------------+-------+
1 row in set (0.00 sec)

如果你通过发行版仓库安装 MySQL,这个文件的路径如下:$basedir/share/mysql/innodb_memcached_config.sql

如果你使用 MySQL 二进制版本,这个文件的路径如下:$basedir/share/innodb_memcached_config.sql

现在,我们将运行这个 SQL 文件。默认情况下,这个脚本在 test 数据库中创建一个 test 表,但是在我们的测试中,我们将使用 memcached 数据库。

译者注:操作日志中的时间可能跟原文不同,以下日志来自自己的实验。

mysql> CREATE DATABASE IF NOT EXISTS test;
Query OK, 1 row affected (0.00 sec)
mysql> source /usr/share/mysql/innodb_memcached_config.sql
Query OK, 1 row affected (0.00 sec)
Database changed
Query OK, 0 rows affected (0.14 sec)
Query OK, 0 rows affected (0.02 sec)
Query OK, 0 rows affected (0.02 sec)
Query OK, 1 row affected (0.01 sec)
Query OK, 1 row affected (0.00 sec)
Query OK, 1 row affected (0.01 sec)
Query OK, 1 row affected (0.01 sec)
Database changed
Query OK, 0 rows affected (0.03 sec)
Query OK, 1 row affected (0.00 sec)
mysql>

现在,让我们创建我们自己的表,用于存放 Memcached 数据:

mysql> CREATE DATABASE IF NOT EXISTS memcached;
Query OK, 1 row affected (0.00 sec)
mysql> CREATE TABLE memcached.dados LIKE test.demo_test;
Query OK, 0 rows affected (0.02 sec)
mysql> UPDATE innodb_memcache.containers SET db_schema = 'memcached',
    -> db_table = 'dados' WHERE name = 'aaa' LIMIT 1;
Query OK, 1 row affected (0.05 sec)
Rows matched: 1  Changed: 1  Warnings: 0
mysql> DROP DATABASE test;
Query OK, 1 row affected (0.09 sec)

下一步是在 MySQL 中安装 Memcached 插件。为了实现这个功能,我们将会使用INSTALL PLUGIN 命令:

mysql> INSTALL PLUGIN daemon_memcached soname "libmemcached.so";
Query OK, 0 rows affected (0.03 sec)

验证此插件是否成功安装,我们可以运行如下命令:

mysql> ! netstat -tunap | grep LIST | grep mysql
tcp        0      0 0.0.0.0:11211               0.0.0.0:*                   LISTEN      1858/mysqld
tcp        0      0 :::11211                    :::*                        LISTEN      1858/mysqld
tcp        0      0 :::3306                     :::*                        LISTEN      1858/mysqld

配置和使用

现在,我们将会通过一种编程语言——PHP,比如使用这种方式:

[root@mysql memcache]# cat test1.php

译者注:原文是 new Memcached(),此处改为 new Memcache(),以下的 PHP 脚本均为 new Memcache()。

addServer('localhost', 11211);
    $m->set('key1', 'Testing memcached');
    echo 'Value of key1 is:' . $m->get('key1') . "n";
?>
[root@mysql memcache]# php test1.php
Value of key1 is:Testing memcached

现在,让我们看看在 MySQL 中存储了些什么?

mysql> SELECT * FROM memcached.dados;
+------+-------------------+------+------+------+
| c1   | c2                | c3   | c4   | c5   |
+------+-------------------+------+------+------+
| key1 | Testing memcached |    0 |    1 |    0 |
+------+-------------------+------+------+------+
1 row in set (0.00 sec)

如果我们在 MySQL 中手动更改一个记录,会发生什么?

mysql> UPDATE memcached.dados
    -> SET c2 = 'Entry modified  directly on MySQL';
Query OK, 1 row affected (0.03 sec)
Rows matched: 1  Changed: 1  Warnings: 0
[root@mysql memcache]# cat test2.php
addServer('localhost', 11211);
    echo 'Value of key1 is:' . $m->get('key1') . "n";
?>
[root@mysql memcache]# php test2.php
Value of key1 is:Entry modified  directly on MySQL
[root@mysql memcache]#

如果我们想存放条目到不同的 MySQL 表,那么又会怎样?

我们仅仅需要创建一个新的表,添加一个新的容器,并且使用在 innodb_memcache 数据库的 config_options 表定义的分隔符。

mysql> SELECT * FROM innodb_memcache.config_options
    -> WHERE name = 'table_map_delimiter';
+---------------------+-------+
| name                | value |
+---------------------+-------+
| table_map_delimiter | .     |
+---------------------+-------+
1 row in set (0.00 sec)
mysql> CREATE TABLE memcached.dados2 LIKE memcached.dados;
Query OK, 0 rows affected (0.08 sec)
mysql> INSERT INTO innodb_memcache.containers(name, db_schema, db_table,
    -> key_columns, value_columns, flags, cas_column, expire_time_column,
    -> unique_idx_name_on_key)
    -> VALUES('bbb', 'memcached', 'dados2', 'c1', 'c2', 'c3','c4','c5','PRIMARY');
Query OK, 1 row affected (0.06 sec)

我们已经创建一个名为 dados2 的新表,并且添加了一个新的名为 bbb 的容器指向那个表,现在我们仅仅需要在 Memcached 中使用它作为前缀即可。

[root@mysql memcache]# cat test3.php
addServer('localhost', 11211);
    $m->set('@@bbb.key1', 'Should be stored on dados2 table');
    echo 'Value of bbb.key1 is:' . $m->get('@@bbb.key1') . "n";
?>
[root@mysql memcache]# php test3.php
Value of bbb.key1 is:Should be stored on dados2 table
mysql> SELECT * FROM memcached.dados2;
+------+----------------------------------+------+------+------+
| c1   | c2                               | c3   | c4   | c5   |
+------+----------------------------------+------+------+------+
| key1 | Should be stored on dados2 table |    0 |    2 |    0 |
+------+----------------------------------+------+------+------+
1 row in set (0.00 sec)

我们也可以映射这个表,将存储的值分为单独的域。

mysql> SELECT * FROM innodb_memcache.config_options
    -> WHERE name = 'separator';
+-----------+-------+
| name      | value |
+-----------+-------+
| separator | |     |
+-----------+-------+
1 row in set (0.00 sec)

我们将会使用这个字符来把值存储到不同的列中。让我们创建一个表,添加到一个新的容器中(我们将会指定新的分隔符——逗号’,’,来存放我们的数据):

mysql> CREATE TABLE products
    -> (id varchar(128),
    -> name varchar(255),
    -> value varchar(15),
    -> c3 int,
    -> c4 bigint,
    -> c5 int,
    -> PRIMARY KEY(id));
Query OK, 0 rows affected (0.05 sec)
mysql> INSERT INTO innodb_memcache.containers
    -> (name, db_schema, db_table, key_columns, value_columns,
    -> flags, cas_column, expire_time_column, unique_idx_name_on_key)
    -> VALUES ('products', 'memcached', 'products', 'id', 'name,value',
    -> 'c3','c4','c5','PRIMARY');
Query OK, 1 row affected (0.06 sec)

现在,让我们创建一个产品数组,然后添加这些数据到 Memcached 中。

[root@mysql memcache]# cat test4.php
addServer('localhost', 11211);
    $products = array(
    array('1', 'TV', '1999,00'),
    array('2', 'Hack', '399,00'),
    array('3', 'Table', '599,00'),
    array('4', 'Chair', '99,00')
    );
    foreach($products as $product)
    {
        $key = '@@products.' . $product[0];
        $value = $product[1] . '|' . $product[2];
        $m->set($key, $value);
    }
?>
[root@mysql memcache]# php test4.php
mysql> SELECT * FROM memcached.products;
+----+-------+---------+------+------+------+
| id | name  | value   | c3   | c4   | c5   |
+----+-------+---------+------+------+------+
| 1  | TV    | 1999,00 |    0 |    3 |    0 |
| 2  | Hack  | 399,00  |    0 |    4 |    0 |
| 3  | Table | 599,00  |    0 |    5 |    0 |
| 4  | Chair | 99,00   |    0 |    6 |    0 |
+----+-------+---------+------+------+------+
4 rows in set (0.00 sec)

服务器/服务 重启

让我们看看如果我们重启 MySQL 服务(重启服务器通用适用)会发生什么?

这些存储在 Memcached 中的数据在 MySQL 服务重启之后仍然会存在吗?

[root@mysql memcache]# service mysql restart
Shutting down MySQL...... SUCCESS!
Starting MySQL. SUCCESS!
[root@mysql memcache]# cat test5.php
addServer('localhost', 11211);
    echo 'Value of key1 is:' . $m->get('key1') . "n";
?>
[root@mysql memcache]# php test5.php
Value of key1 is:Entry modified  directly on MySQL

换句话说!即使服务重启或者服务器重启,这些数据仍然会存在。

SELinux

在 SELinux 启用的环境中,会阻止 Memcached 和 MySQL 集成,因为不允许监听 Memcached 端口,下面是一个怎样允许监听 Memcached 端口的例子(我使用 CentOS Linux 分发版):

在 /var/log/audit/audit.log 中查找包含 mysqld 和 denied 关键字的条目,如果你能找到,输入如下的命令来创建一个新的 SELinux 模块来允许:

type=AVC msg=audit(1423266535.066:5): avc:  denied  { name_bind } for
pid=1123 comm="mysqld" src=11211 scontext=system_u:system_r:mysqld_t:s0
tcontext=system_u:object_r:memcache_port_t:s0 tclass=tcp_socket
type=SYSCALL msg=audit(1423266535.066:5): arch=c000003e syscall=49
success=no exit=-13 a0=2f a1=7f3aec043230 a2=10 a3=7f3af61fa75c
items=0 ppid=999 pid=1123 auid=4294967295 uid=27 gid=27 euid=27 suid=27
fsuid=27 egid=27 sgid=27 fsgid=27 tty=(none) ses=4294967295 comm="mysqld"
exe="/usr/sbin/mysqld" subj=system_u:system_r:mysqld_t:s0 key=(null)
[root@mysql ~]# audit2why < /var/log/audit/audit.log
type=AVC msg=audit(1423266535.066:5): avc:  denied  { name_bind } for
pid=1123 comm="mysqld" src=11211 scontext=system_u:system_r:mysqld_t:s0
tcontext=system_u:object_r:memcache_port_t:s0 tclass=tcp_socket
    Was caused by:
        Missing type enforcement (TE) allow rule.
        You can use audit2allow to generate a loadable module to allow this access.
[root@mysql ~]# cd /root/
[root@mysql ~]# mkdir selinux-custom
[root@mysql ~]# cd selinux-custom
[root@mysql selinux-custom]# audit2allow -a -M mysql-memcache
******************** IMPORTANT ***********************
To make this policy package active, execute:
semodule -i mysql-memcache.pp
[root@mysql selinux-custom]# semodule -i mysql-memcache.pp

译者注:以下为译者添加,用于测试在 SELinux 环境下,MySQL 和 Memcached 的集成。

[root@mysql selinux-custom]# sestatus
SELinux status:                 enabled
SELinuxfs mount:                /selinux
Current mode:                   enforcing
Mode from config file:          enforcing
Policy version:                 24
Policy from config file:        targeted
[root@mysql selinux-custom]# getenforce
Enforcing
[root@mysql selinux-custom]# /etc/init.d/mysql restart
Shutting down MySQL....                                    [  OK  ]
Starting MySQL.                                            [  OK  ]
[root@mysql memcache]# cd ~/memcache
[root@mysql memcache]# cat test6.php
addServer('localhost', 11211);
    echo 'Value of key1 is:' . $m->get('key1') . "n";
?>
[root@mysql selinux-custom]# netstat -tunap | grep LIST | grep mysql
tcp        0      0 0.0.0.0:11211               0.0.0.0:*                   LISTEN      7820/mysqld
tcp        0      0 :::11211                    :::*                        LISTEN      7820/mysqld
tcp        0      0 :::3306                     :::*                        LISTEN      7820/mysqld
[root@mysql memcache]# php test6.php
Value of key1 is:Entry modified  directly on MySQL

Memcached 选项

如果你想更改任何 Memcached 特殊的选项,你可以在 MySQL 的配置文件中添加daemon_memcached_option 参数,比如更改 Memcached 端口:

# In the configuration file, my.cnf generally
daemon_memcached_option=”-p11222”

就是这样,我希望你已经学会了如何安装和配置 MySQL 和 Memcached 插件的集成工作。

Linux 文件系统结构介绍

Linux中的文件是什么?它的文件系统又是什么?那些配置文件又在哪里?我下载好的程序保存在哪里了?在 Linux 中文件系统是标准结构的吗?好了,上图简明地阐释了Linux的文件系统的层次关系。当你苦于寻找配置文件或者二进制文件的时候,这便显得十分有用了。我在下方添加了一些解释以及例子,不过“篇幅较长,可以有空再看”。

另外一种情况便是当你在系统中获取配置以及二进制文件时,出现了不一致性问题,如果你是在一个大型组织中,或者只是一个终端用户,这也有可能会破坏你的系统(比如,二进制文件运行在旧的库文件上了)。若然你在你的Linux系统上做安全审计的话,你将会发现它很容易遭到各种攻击。所以,保持一个清洁的操作系统(无论是Windows还是Linux)都显得十分重要。

Linux的文件是什么?

对于UNIX系统来说(同样适用于Linux),以下便是对文件简单的描述:

在UNIX系统中,一切皆为文件;若非文件,则为进程

这种定义是比较正确的,因为有些特殊的文件不仅仅是普通文件(比如命名管道和套接字),不过为了让事情变的简单,“一切皆为文件”也是一个可以让人接受的说法。Linux系统也像UNIX系统一样,将文件和目录视如同物,因为目录只是一个包含了其他文件名的文件而已。程序、服务、文本、图片等等,都是文件。对于系统来说,输入和输出设备,基本上所有的设备,都被当做是文件。

题图版本历史:

  • Version 2.0 – 17-06-2015
    • – Improved: 添加标题以及版本历史
    • – Improved: 添加/srv,/meida和/proc
    • – Improved: 更新了反映当前的Linux文件系统的描述
    • – Fixed: 多处的打印错误
    • – Fixed: 外观和颜色
  • Version 1.0 – 14-02-2015
    • – Created: 基本的图表
    • – Note: 摒弃更低的版本

下载链接

以下是大图的下载地址。如果你需要其他格式,请跟原作者联系,他会尝试制作并且上传到某个地方以供下载

注意: PDF格式文件是打印的最好选择,因为它画质很高。

Linux 文件系统描述

为了有序地管理那些文件,人们习惯把这些文件当做是硬盘上的有序的树状结构,正如我们熟悉的’MS-DOS'(磁盘操作系统)就是一个例子。大的分枝包括更多的分枝,分枝的末梢是树的叶子或者普通的文件。现在我们将会以这树形图为例,但晚点我们会发现为什么这不是一个完全准确的一幅图。

目录 描述
/ 主层次 的根,也是整个文件系统层次结构的根目录
/bin 存放在单用户模式可用的必要命令二进制文件,所有用户都可用,如 cat、ls、cp等等
/boot 存放引导加载程序文件,例如kernels、initrd等
/dev 存放必要的设备文件,例如/dev/null
/etc 存放主机特定的系统级配置文件。其实这里有个关于它名字本身意义上的的争议。在贝尔实验室的UNIX实施文档的早期版本中,/etc表示是“其他(etcetera)目录”,因为从历史上看,这个目录是存放各种不属于其他目录的文件(然而,文件系统目录标准 FSH 限定 /etc 用于存放静态配置文件,这里不该存有二进制文件)。早期文档出版后,这个目录名又重新定义成不同的形式。近期的解释中包含着诸如“可编辑文本配置”或者“额外的工具箱”这样的重定义
/etc/opt 存储着新增包的配置文件 /opt/.
/etc/sgml 存放配置文件,比如 catalogs,用于那些处理SGML(译者注:标准通用标记语言)的软件的配置文件
/etc/X11 X Window 系统11版本的的配置文件
/etc/xml 配置文件,比如catalogs,用于那些处理XML(译者注:可扩展标记语言)的软件的配置文件
/home 用户的主目录,包括保存的文件,个人配置,等等
/lib /bin//sbin/中的二进制文件的必需的库文件
/lib<架构位数> 备用格式的必要的库文件。 这样的目录是可选的,但如果他们存在的话肯定是有需要用到它们的程序
/media 可移动的多媒体(如CD-ROMs)的挂载点。(出现于 FHS-2.3)
/mnt 临时挂载的文件系统
/opt 可选的应用程序软件包
/proc 以文件形式提供进程以及内核信息的虚拟文件系统,在Linux中,对应进程文件系统(procfs )的挂载点
/root 根用户的主目录
/sbin 必要的系统级二进制文件,比如, init, ip, mount
/srv 系统提供的站点特定数据
/tmp 临时文件 (另见 /var/tmp). 通常在系统重启后删除
/usr 二级层级存储用户的只读数据; 包含(多)用户主要的公共文件以及应用程序
/usr/bin 非必要的命令二进制文件 (在单用户模式中不需要用到的);用于所有用户
/usr/include 标准的包含文件
/usr/lib 库文件,用于/usr/bin//usr/sbin/中的二进制文件
/usr/lib<架构位数> 备用格式库(可选的)
/usr/local 三级层次 用于本地数据,具体到该主机上的。通常会有下一个子目录, 比如, bin/, lib/, share/.
/usr/local/sbin 非必要系统的二进制文件,比如用于不同网络服务的守护进程
/usr/share 架构无关的 (共享) 数据.
/usr/src 源代码,比如内核源文件以及与它相关的头文件
/usr/X11R6 X Window系统,版本号:11,发行版本:6
/var 各式各样的(Variable)文件,一些随着系统常规操作而持续改变的文件就放在这里,比如日志文件,脱机文件,还有临时的电子邮件文件
/var/cache 应用程序缓存数据. 这些数据是由耗时的I/O(输入/输出)的或者是运算本地生成的结果。这些应用程序是可以重新生成或者恢复数据的。当没有数据丢失的时候,可以删除缓存文件
/var/lib 状态信息。这些信息随着程序的运行而不停地改变,比如,数据库,软件包系统的元数据等等
/var/lock 锁文件。这些文件用于跟踪正在使用的资源
/var/log 日志文件。包含各种日志。
/var/mail 内含用户邮箱的相关文件
/var/opt 来自附加包的各种数据都会存储在 /var/opt/.
/var/run 存放当前系统上次启动以来的相关信息,例如当前登入的用户以及当前运行的daemons(守护进程).
/var/spool 该spool主要用于存放将要被处理的任务,比如打印队列以及邮件外发队列
/var/mail 过时的位置,用于放置用户邮箱文件
/var/tmp 存放重启后保留的临时文件

Linux的文件类型

大多数文件仅仅是普通文件,他们被称为regular文件;他们包含普通数据,比如,文本、可执行文件、或者程序、程序的输入或输出等等

虽然你可以认为“在Linux中,一切你看到的皆为文件”这个观点相当保险,但这里仍有着一些例外。

  • 目录:由其他文件组成的文件
  • 特殊文件:用于输入和输出的途径。大多数特殊文件都储存在/dev中,我们将会在后面讨论这个问题。
  • 链接文件:让文件或者目录出现在系统文件树结构上多个地方的机制。我们将详细地讨论这个链接文件。
  • (域)套接字:特殊的文件类型,和TCP/IP协议中的套接字有点像,提供进程间网络通讯,并受文件系统的访问控制机制保护。
  • 命名管道 : 或多或少有点像sockets(套接字),提供一个进程间的通信机制,而不用网络套接字协议。

现实中的文件系统

对于大多数用户和常规系统管理任务而言,“文件和目录是一个有序的类树结构”是可以接受的。然而,对于电脑而言,它是不会理解什么是树,或者什么是树结构。

每个分区都有它自己的文件系统。想象一下,如果把那些文件系统想成一个整体,我们可以构思一个关于整个系统的树结构,不过这并没有这么简单。在文件系统中,一个文件代表着一个inode(索引节点),这是一种包含着构建文件的实际数据信息的序列号:这些数据表示文件是属于谁的,还有它在硬盘中的位置。

每个分区都有一套属于他们自己的inode,在一个系统的不同分区中,可以存在有相同inode的文件。

每个inode都表示着一种在硬盘上的数据结构,保存着文件的属性,包括文件数据的物理地址。当硬盘被格式化并用来存储数据时(通常发生在初始系统安装过程,或者是在一个已经存在的系统中添加额外的硬盘),每个分区都会创建固定数量的inode。这个值表示这个分区能够同时存储各类文件的最大数量。我们通常用一个inode去映射2-8k的数据块。当一个新的文件生成后,它就会获得一个空闲的inode。在这个inode里面存储着以下信息:

  • 文件属主和组属主
  • 文件类型(常规文件,目录文件……)
  • 文件权限
  • 创建、最近一次读文件和修改文件的时间
  • inode里该信息被修改的时间
  • 文件的链接数(详见下一章)
  • 文件大小
  • 文件数据的实际地址

唯一不在inode的信息是文件名和目录。它们存储在特殊的目录文件。通过比较文件名和inode的数目,系统能够构造出一个便于用户理解的树结构。用户可以通过ls -i查看inode的数目。在硬盘上,inodes有他们独立的空间。


via: http://www.blackmoreops.com/2015/06/18/linux-file-system-hierarchy-v2-0/

译者:tnuoccalanosrep 校对:wxy

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

RHCSA 系列(一): 回顾基础命令及系统文档

RHCSA (红帽认证系统工程师) 是由 RedHat 公司举行的认证考试,这家公司给商业公司提供开源操作系统和软件,除此之外,还为这些企业和机构提供支持、训练以及咨询服务等。

RHCSA 系列(一): 回顾基础命令及系统文档
RHCSA 系列(一): 回顾基础命令及系统文档

RHCSA 考试准备指南

RHCSA 考试(考试编号 EX200)通过后可以获取由 RedHat 公司颁发的证书. RHCSA 考试是 RHCT(红帽认证技师)的升级版,而且 RHCSA 必须在新的 Red Hat Enterprise Linux(红帽企业版)下完成。RHCT 和 RHCSA 的主要变化就是 RHCT 基于 RHEL5,而 RHCSA 基于 RHEL6 或者7,这两个认证的等级也有所不同。

红帽认证管理员最起码可以在红帽企业版的环境下执行如下系统管理任务:

  • 理解并会使用命令管理文件、目录、命令行以及系统/软件包的文档
  • 在不同的启动等级操作运行中的系统,识别和控制进程,启动或停止虚拟机
  • 使用分区和逻辑卷管理本地存储
  • 创建并且配置本地文件系统和网络文件系统,设置他们的属性(权限、加密、访问控制表)
  • 部署、配置、并且控制系统,包括安装、升级和卸载软件
  • 管理系统用户和组,以及使用集中制的 LDAP 目录进行用户验证
  • 确保系统安全,包括基础的防火墙规则和 SELinux 配置

关于你所在国家的考试注册和费用请参考 RHCSA 认证页面

在这个有15章的 RHCSA(红帽认证管理员)备考系列中,我们将覆盖以下的关于红帽企业 Linux 第七版的最新的信息:

在第一章,我们讲解如何在终端或者 Shell 窗口输入和运行正确的命令,并且讲解如何找到、查阅,以及使用系统文档。

RHCSA 系列(一): 回顾基础命令及系统文档
RHCSA 系列(一): 回顾基础命令及系统文档

RHCSA:回顾必会的 Linux 命令 – 第一部分

前提:

至少你要熟悉如下命令

  • cd 命令 (改变目录)
  • ls 命令 (列举文件)
  • cp 命令 (复制文件)
  • mv 命令 (移动或重命名文件)
  • touch 命令 (创建一个新的文件或更新已存在文件的时间表)
  • rm 命令 (删除文件)
  • mkdir 命令 (创建目录)

在这篇文章中你将会找到更多的关于如何更好的使用他们的正确用法和特殊用法.

虽然没有严格的要求,但是作为讨论常用的 Linux 命令和在 Linux 中搜索信息方法,你应该安装 RHEL7 来尝试使用文章中提到的命令。这将会使你学习起来更省力。

使用 Shell 进行交互

如果我们使用文本模式登录 Linux,我们就会直接进入到我们的默认 shell 中。另一方面,如果我们使用图形化界面登录,我们必须通过启动一个终端来开启 shell。无论那种方式,我们都会看到用户提示符,并且我们可以在这里输入并且执行命令(当按下回车时,命令就会被执行)。

命令是由两个部分组成的:

  • 命令本身
  • 参数

某些参数,称为选项(通常使用一个连字符开头),会改变命令的行为方式,而另外一些则指定了命令所操作的对象。

type 命令可以帮助我们识别某一个特定的命令是由 shell 内置的还是由一个单独的包提供的。这样的区别在于我们能够在哪里找到更多关于该命令的更多信息。对 shell 内置的命令,我们需要看 shell 的手册页;如果是其他的,我们需要看软件包自己的手册页。

Check Shell built in Commands

检查Shell的内置命令

在上面的例子中, cdtype 是 shell 内置的命令,topless 是由 shell 之外的其他的二进制文件提供的(在这种情况下,type将返回命令的位置)。

其他的内置命令:

More Built in Shell Commands

其它内置命令

exec 命令

它用来运行我们指定的外部程序。请注意在多数情况下,只需要输入我们想要运行的程序的名字就行,不过exec 命令有一个特殊的特性:不是在 shell 之外创建新的进程运行,而是这个新的进程会替代原来的 shell,可以通过下列命令来验证。

# ps -ef | grep 

当新的进程终止时,Shell 也随之终止。运行 exec top ,然后按下 q 键来退出 top,你会注意到 shell 会话也同时终止,如下面的屏幕录像展示的那样:

export 命令

给之后执行的命令的输出环境变量。

history 命令

展示数行之前的历史命令。命令编号前面前缀上感叹号可以再次执行这个命令。如果我们需要编辑历史列表中的命令,我们可以按下 Ctrl + r 并输入与命令相关的第一个字符。我们可以看到的命令会自动补全,可以根据我们目前的需要来编辑它:

命令列表会保存在一个叫 .bash_history 的文件里。history 命令是一个非常有用的用于减少输入次数的工具,特别是进行命令行编辑的时候。默认情况下,bash 保留最后输入的500个命令,不过可以通过修改 HISTSIZE 环境变量来增加:

Linux history Command

Linux history 命令

但上述变化,在我们的下一次启动不会保留。为了保持 HISTSIZE 变量的变化,我们需要通过手工修改文件编辑:

# 要设置 history 长度,请看 bash(1)文档中的 HISTSIZE 和 HISTFILESIZE
HISTSIZE=1000

重要: 我们的更改不会立刻生效,除非我们重启了 shell 。

alias 命令

没有参数或使用 -p 选项时将会以“名称=值”的标准形式输出别名列表。当提供了参数时,就会按照给定的名字和值定义一个别名。

使用 alias ,我们可以创建我们自己的命令,或使用所需的参数修改现有的命令。举个例子,假设我们将 ls 定义别名为 ls –color=auto ,这样就可以使用不同颜色输出文件、目录、链接等等。

# alias ls='ls --color=auto'

Linux alias Command

Linux 别名命令

注意: 你可以给你的“新命令”起任何的名字,并且使用单引号包括很多命令,但是你要用分号区分开它们。如下:

# alias myNewCommand='cd /usr/bin; ls; cd; clear'

exit 命令

exitlogout 命令都可以退出 shell 。exit 命令可以退出所有的 shell,logout 命令只注销登录的 shell(即你用文本模式登录时自动启动的那个)。

man 和 info 命令

如果你对某个程序有疑问,可以参考它的手册页,可以使用 man 命令调出它。此外,还有一些关于重要文件(inittab、fstab、hosts 等等)、库函数、shell、设备及其他功能的手册页。

举例:

  • man uname (输出系统信息,如内核名称、处理器、操作系统类型、架构等)
  • man inittab (初始化守护进程的设置)

另外一个重要的信息的来源是由 info 命令提供的,info 命令常常被用来读取 info 文件。这些文件往往比手册页 提供了更多信息。可以通过 info keyword 调用某个命令的信息:

# info ls
# info cut

另外,在 /usr/share/doc 文件夹包含了大量的子目录,里面可以找到大量的文档。它们是文本文件或其他可读格式。

你要习惯于使用这三种方法去查找命令的信息。重点关注每个命令文档中介绍的详细的语法。

使用 expand 命令把制表符转换为空格

有时候文本文档包含了制表符,但是程序无法很好的处理。或者我们只是简单的希望将制表符转换成空格。这就是用到 expand 地方(由GNU核心组件包提供) 。

举个例子,我们有个文件 NumberList.txt,让我们使用 expand 处理它,将制表符转换为一个空格,并且显示在标准输出上。

# expand --tabs=1 NumbersList.txt

Linux expand Command

Linux expand 命令

unexpand命令可以实现相反的功能(将空格转为制表符)

使用 head 输出文件首行及使用 tail 输出文件尾行

通常情况下,head 命令后跟着文件名时,将会输出该文件的前十行,我们可以通过 -n 参数来自定义具体的行数。

# head -n3 /etc/passwd
# tail -n3 /etc/passwd

Linux head and tail Command

Linux 的 head 和 tail 命令

tail 最有意思的一个特性就是能够显示增长的输入文件(tail -f my.log,my.log 是我们需要监视的文件。)这在我们监控一个持续增加的日志文件时非常有用。

使用 paste 按行合并文本文件

paste 命令一行一行的合并文件,默认会以制表符来区分每个文件的行,或者你可以自定义的其它分隔符。(下面的例子就是输出中的字段使用等号分隔)。

# paste -d= file1 file2
RHCSA 系列(一): 回顾基础命令及系统文档
RHCSA 系列(一): 回顾基础命令及系统文档

Linux 中的 merge 命令

使用 split 命令将文件分块

split 命令常常用于把一个文件切割成两个或多个由我们自定义的前缀命名的文件。可以根据大小、区块、行数等进行切割,生成的文件会有一个数字或字母的后缀。在下面的例子中,我们将切割 bash.pdf ,每个文件 50KB (-b 50KB),使用数字后缀 (-d):

# split -b 50KB -d bash.pdf bash_
RHCSA 系列(一): 回顾基础命令及系统文档
RHCSA 系列(一): 回顾基础命令及系统文档

在 Linux 下切割文件

你可以使用如下命令来合并这些文件,生成原来的文件:

# cat bash_00 bash_01 bash_02 bash_03 bash_04 bash_05 > bash.pdf

使用 tr 命令替换字符

tr 命令多用于一对一的替换(改变)字符,或者使用字符范围。和之前一样,下面的实例我们将使用之前的同样文件file2,我们将做:

  • 小写字母 o 变成大写
  • 所有的小写字母都变成大写字母

cat file2 | tr o O
cat file2 | tr [a-z] [A-Z]
RHCSA 系列(一): 回顾基础命令及系统文档
RHCSA 系列(一): 回顾基础命令及系统文档

在 Linux 中替换字符

使用 uniq 和 sort 检查或删除重复的文字

uniq 命令可以帮我们查出或删除文件中的重复的行,默认会输出到标准输出,我们应当注意,uniq只能查出相邻的相同行,所以,uniq 往往和 sort 一起使用(sort 一般用于对文本文件的内容进行排序)

默认情况下,sort 以第一个字段(使用空格分隔)为关键字段。想要指定不同关键字段,我们需要使用 -k 参数,请注意如何使用 sortuniq 输出我们想要的字段,具体可以看下面的例子:

# cat file3
# sort file3 | uniq
# sort -k2 file3 | uniq
# sort -k3 file3 | uniq
RHCSA 系列(一): 回顾基础命令及系统文档
RHCSA 系列(一): 回顾基础命令及系统文档

删除文件中重复的行

从文件中提取文本的命令

cut 命令基于字节(-b)、字符(-c)、或者字段(-f)的数量,从输入文件(标准输入或文件)中提取到的部分将会以标准输出上。

当我们使用字段 cut 时,默认的分隔符是一个制表符,不过你可以通过 -d 参数来自定义分隔符。

# cut -d: -f1,3 /etc/passwd # 这个例子提取了第一和第三字段的文本
# cut -d: -f2-4 /etc/passwd # 这个例子提取了第二到第四字段的文本

从文件中提取文本

从文件中提取文本

注意,简洁起见,上方的两个输出的结果是截断的。

使用 fmt 命令重新格式化文件

fmt 被用于去“清理”有大量内容或行的文件,或者有多级缩进的文件。新的段落格式每行不会超过75个字符宽,你能通过 -w (width 宽度)参数改变这个设定,它可以设置行宽为一个特定的数值。

举个例子,让我们看看当我们用 fmt 显示定宽为100个字符的时候的文件 /etc/passwd 时会发生什么。再次,输出截断了。

# fmt -w100 /etc/passwd

File Reformatting in Linux

Linux 文件重新格式化

使用 pr 命令格式化打印内容

pr 分页并且在按列或多列的方式显示一个或多个文件。 换句话说,使用 pr 格式化一个文件使它打印出来时看起来更好。举个例子,下面这个命令:

# ls -a /etc | pr -n --columns=3 -h "Files in /etc"

以一个友好的排版方式(3列)输出/etc下的文件,自定义了页眉(通过 -h 选项实现)、行号(-n)。

RHCSA 系列(一): 回顾基础命令及系统文档
RHCSA 系列(一): 回顾基础命令及系统文档

Linux的文件格式化

总结

在这篇文章中,我们已经讨论了如何在 Shell 或终端以正确的语法输入和执行命令,并解释如何找到,查阅和使用系统文档。正如你看到的一样简单,这就是你成为 RHCSA 的第一大步。

如果你希望添加一些其他的你经常使用的能够有效帮你完成你的日常工作的基础命令,并愿意分享它们,请在下方留言。也欢迎提出问题。我们期待您的回复。


via: http://www.tecmint.com/rhcsa-exam-reviewing-essential-commands-system-documentation/

作者:Gabriel Cánepa 译者:xiqingongzi 校对:wxy

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

Linux有问必答:如何启用Open vSwitch的日志功能以便调试和排障

问题 我试着为我的Open vSwitch部署排障,鉴于此,我想要检查它的由内建日志机制生成的调试信息。我怎样才能启用Open vSwitch的日志功能,并且修改它的日志等级(如,修改成INFO/DEBUG级别)以便于检查更多详细的调试信息呢?

Open vSwitch(OVS)是Linux平台上最流行的开源的虚拟交换机。由于当今的数据中心日益依赖于软件定义网络(SDN)架构,OVS被作为数据中心的SDN部署中的事实标准上的网络元素而得到飞速应用。

Open vSwitch具有一个内建的日志机制,它称之为VLOG。VLOG工具允许你在各种网络交换组件中启用并自定义日志,由VLOG生成的日志信息可以被发送到一个控制台、syslog以及一个便于查看的单独日志文件。你可以通过一个名为ovs-appctl的命令行工具在运行时动态配置OVS日志。

这里为你演示如何使用ovs-appctl启用Open vSwitch中的日志功能,并进行自定义。

下面是ovs-appctl自定义VLOG的语法。

$ sudo ovs-appctl vlog/set module[:facility[:level]]
  • Module:OVS中的任何合法组件的名称(如netdev,ofproto,dpif,vswitchd等等)
  • Facility:日志信息的目的地(必须是:console,syslog,或者file)
  • Level:日志的详细程度(必须是:emer,err,warn,info,或者dbg)

在OVS源代码中,模块名称在源文件中是以以下格式定义的:

VLOG_DEFINE_THIS_MODULE();

例如,在lib/netdev.c中,你可以看到:

VLOG_DEFINE_THIS_MODULE(netdev);

这个表明,lib/netdev.c是netdev模块的一部分,任何在lib/netdev.c中生成的日志信息将属于netdev模块。

在OVS源代码中,有多个严重度等级用于定义几个不同类型的日志信息:VLOGINFO()用于报告,VLOGWARN()用于警告,VLOGERR()用于错误提示,VLOGDBG()用于调试信息,VLOG_EMERG用于紧急情况。日志等级和工具确定哪个日志信息发送到哪里。

要查看可用模块、工具和各自日志级别的完整列表,请运行以下命令。该命令必须在你启动OVS后调用。

$ sudo ovs-appctl vlog/list

输出结果显示了用于三个场合(facility:console,syslog,file)的各个模块的调试级别。默认情况下,所有模块的日志等级都被设置为INFO。

指定任何一个OVS模块,你可以选择性地修改任何特定场合的调试级别。例如,如果你想要在控制台屏幕中查看dpif更为详细的调试信息,可以运行以下命令。

$ sudo ovs-appctl vlog/set dpif:console:dbg

你将看到dpif模块的console工具已经将其日志等级修改为DBG,而其它两个场合syslog和file的日志级别仍然没有改变。

如果你想要修改所有模块的日志等级,你可以指定“ANY”作为模块名。例如,下面命令将修改每个模块的console的日志级别为DBG。

$ sudo ovs-appctl vlog/set ANY:console:dbg

同时,如果你想要一次性修改所有三个场合的日志级别,你可以指定“ANY”作为场合名。例如,下面的命令将修改每个模块的所有场合的日志级别为DBG。

$ sudo ovs-appctl vlog/set ANY:ANY:dbg

via: http://ask.xmodulo.com/enable-logging-open-vswitch.html

作者:Dan Nanni 译者:GOLinux 校对:wxy

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

在 Ubuntu 中如何安装或升级 Linux 内核到4.2

在 Ubuntu 中如何安装或升级 Linux 内核到4.2
在 Ubuntu 中如何安装或升级 Linux 内核到4.2

Linux 内核 4.2已经发布了。Linus Torvalds 在 lkml.org 上写到:

通过这周这么小的变动,看来在最后一周 发布 4.2 版本应该不会有问题,当然还有几个修正,但是看起来也并不需要延迟一周。 所以这就到了,而且 4.3 的合并窗口现已打开。我已经有了几个等待处理的合并请求,明天我开始处理它们,然后在适当的时候放出来。 从 rc8 以来的简短日志很小,已经附加。这个补丁也很小…

新内核 4.2 有哪些改进?:

  • 重写英特尔的x86汇编代码
  • 支持新的 ARM 板和 SoC
  • 对 F2FS 的 per-file 加密
  • AMDGPU 的内核 DRM 驱动程序
  • 对 Radeon DRM 驱动的 VCE1 视频编码支持
  • 初步支持英特尔的 Broxton Atom SoC
  • 支持 ARCv2 和 HS38 CPU 内核
  • 增加了队列自旋锁的支持
  • 许多其他的改进和驱动更新。

在 Ubuntu 中如何下载4.2内核 :

此内核版本的二进制包可供下载链接如下:

首先检查你的操作系统类型,32位(i386)的或64位(amd64)的,然后使用下面的方式依次下载并安装软件包:

  1. linux-headers-4.2.0-xxx_all.deb
  2. linux-headers-4.2.0-xxx-generic_xxx_i386/amd64.deb
  3. linux-image-4.2.0-xxx-generic_xxx_i386/amd64.deb

安装内核后,在终端((Ctrl+Alt+T))运行sudo update-grub命令来更新 grub boot-loader。

如果你需要一个低延迟系统(例如用于录制音频),请下载并安装下面的包:

  1. linux-headers-4.2.0_xxx_all.deb
  2. linux-headers-4.2.0-xxx-lowlatency_xxx_i386/amd64.deb
  3. linux-image-4.2.0-xxx-lowlatency_xxx_i386/amd64.deb

对于没有图形用户界面的 Ubuntu 服务器,你可以运行下面的命令通过 wget 来逐一抓下载,并通过 dpkg 来安装:

对于64位的系统请运行:

cd /tmp/
wget http://kernel.ubuntu.com/~kernel-ppa/mainline/v4.2-unstable/linux-headers-4.2.0-040200_4.2.0-040200.201508301530_all.deb
wget http://kernel.ubuntu.com/~kernel-ppa/mainline/v4.2-unstable/linux-headers-4.2.0-040200-generic_4.2.0-040200.201508301530_amd64.deb
wget http://kernel.ubuntu.com/~kernel-ppa/mainline/v4.2-unstable/linux-image-4.2.0-040200-generic_4.2.0-040200.201508301530_amd64.deb
sudo dpkg -i linux-headers-4.2.0-*.deb linux-image-4.2.0-*.deb

对于32位的系统,请运行:

cd /tmp/
wget http://kernel.ubuntu.com/~kernel-ppa/mainline/v4.2-unstable/linux-headers-4.2.0-040200_4.2.0-040200.201508301530_all.deb
wget http://kernel.ubuntu.com/~kernel-ppa/mainline/v4.2-unstable/linux-headers-4.2.0-040200-generic_4.2.0-040200.201508301530_i386.deb
wget http://kernel.ubuntu.com/~kernel-ppa/mainline/v4.2-unstable/linux-image-4.2.0-040200-generic_4.2.0-040200.201508301530_i386.deb
sudo dpkg -i linux-headers-4.2.0-*.deb linux-image-4.2.0-*.deb

最后,重新启动计算机才能生效。

要恢复或删除旧的内核,请参阅通过脚本安装内核


via: http://ubuntuhandbook.org/index.php/2015/08/upgrade-kernel-4-2-ubuntu/

作者:Ji m 译者:strugglingyouth 校对:wxy

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