Merge pull request #126 from LCTT/master

更新至2016年6月13日
This commit is contained in:
tianfeiyu 2016-06-13 22:42:51 +08:00 committed by GitHub
commit 6517b183a0
66 changed files with 3833 additions and 1892 deletions

View File

@ -0,0 +1,464 @@
通过 Docker 化一个博客网站来开启我们的 Docker 之旅
===
![](http://bencane.com/static/img/post-bg.jpg)
> 这篇文章包含 Docker 的基本概念,以及如何通过创建一个定制的 Dockerfile 来 Docker 化Dockerize一个应用。
Docker 是一个过去两年来从某个 idea 中孕育而生的有趣技术公司组织们用它在世界上每个角落来部署应用。在今天的文章中我将讲述如何通过“Docker 化Dockerize”一个现有的应用来开始我们的 Docker 之旅。这里提到的应用指的就是这个博客!
## 什么是 Docker
当我们开始学习 Docker 基本概念时,让我们先去搞清楚什么是 Docker 以及它为什么这么流行。Docker 是一个操作系统容器管理工具,它通过将应用打包在操作系统容器中,来方便我们管理和部署应用。
### 容器 vs. 虚拟机
容器和虚拟机并不完全相似,它是另外一种提供**操作系统虚拟化**的方式。它和标准的虚拟机还是有所不同。
标准的虚拟机一般会包括一个完整的操作系统、操作系统软件包、最后还有一至两个应用。这都得益于为虚拟机提供硬件虚拟化的管理程序。这样一来,一个单一的服务器就可以将许多独立的操作系统作为虚拟客户机运行了。
容器和虚拟机很相似,它们都支持在单一的服务器上运行多个操作环境,只是,在容器中,这些环境并不是一个个完整的操作系统。容器一般只包含必要的操作系统软件包和一些应用。它们通常不会包含一个完整的操作系统或者硬件的虚拟化。这也意味着容器比传统的虚拟机开销更少。
容器和虚拟机常被误认为是两种对立的技术。虚拟机采用一个物理服务器来提供全功能的操作环境,该环境会和其余虚拟机一起共享这些物理资源。容器一般用来隔离一个单一主机上运行的应用进程,以保证隔离后的进程之间不能相互影响。事实上,容器和 **BSD Jails** 以及 `chroot` 进程的相似度,超过了和完整虚拟机的相似度。
### Docker 在容器之上提供了什么
Docker 本身不是一个容器运行环境事实上只是一个与具体实现无关的容器技术Docker 正在努力支持 [Solaris Zones](https://blog.docker.com/2015/08/docker-oracle-solaris-zones/) 和 [BSD Jails](https://wiki.freebsd.org/Docker)。Docker 提供了一种管理、打包和部署容器的方式。虽然一定程度上,虚拟机多多少少拥有这些类似的功能,但虚拟机并没有完整拥有绝大多数的容器功能,即使拥有,这些功能用起来都并没有 Docker 来的方便或那么完整。
现在,我们应该知道 Docker 是什么了,然后,我们将从安装 Docker并部署一个公开的预构建好的容器开始学习 Docker 是如何工作的。
## 从安装开始
默认情况下Docker 并不会自动被安装在您的计算机中,所以,第一步就是安装 Docker 软件包;我们的教学机器系统是 Ubuntu 14.0.4,所以,我们将使用 Apt 软件包管理器,来执行安装操作。
```
# apt-get install docker.io
Reading package lists... Done
Building dependency tree
Reading state information... Done
The following extra packages will be installed:
aufs-tools cgroup-lite git git-man liberror-perl
Suggested packages:
btrfs-tools debootstrap lxc rinse git-daemon-run git-daemon-sysvinit git-doc
git-el git-email git-gui gitk gitweb git-arch git-bzr git-cvs git-mediawiki
git-svn
The following NEW packages will be installed:
aufs-tools cgroup-lite docker.io git git-man liberror-perl
0 upgraded, 6 newly installed, 0 to remove and 0 not upgraded.
Need to get 7,553 kB of archives.
After this operation, 46.6 MB of additional disk space will be used.
Do you want to continue? [Y/n] y
```
为了检查当前是否有容器运行,我们可以执行`docker`命令,加上`ps`选项
```
# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
```
`docker`命令中的`ps`功能类似于 Linux 的`ps`命令。它将显示可找到的 Docker 容器及其状态。由于我们并没有启动任何 Docker 容器,所以命令没有显示任何正在运行的容器。
## 部署一个预构建好的 nginx Docker 容器
我比较喜欢的 Docker 特性之一就是 Docker 部署预先构建好的容器的方式,就像`yum`和`apt-get`部署包一样。为了更好地解释,我们来部署一个运行着 nginx web 服务器的预构建容器。我们可以继续使用`docker`命令,这次选择`run`选项。
```
# docker run -d nginx
Unable to find image 'nginx' locally
Pulling repository nginx
5c82215b03d1: Download complete
e2a4fb18da48: Download complete
58016a5acc80: Download complete
657abfa43d82: Download complete
dcb2fe003d16: Download complete
c79a417d7c6f: Download complete
abb90243122c: Download complete
d6137c9e2964: Download complete
85e566ddc7ef: Download complete
69f100eb42b5: Download complete
cd720b803060: Download complete
7cc81e9a118a: Download complete
```
`docker`命令的`run`选项,用来通知 Docker 去寻找一个指定的 Docker 镜像然后启动运行着该镜像的容器。默认情况下Docker 容器运行在前台,这意味着当你运行`docker run`命令的时候,你的 shell 会被绑定到容器的控制台以及运行在容器中的进程。为了能在后台运行该 Docker 容器,我们使用了`-d` (**detach**)标志。
再次运行`docker ps`命令,可以看到 nginx 容器正在运行。
```
# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
f6d31ab01fc9 nginx:latest nginx -g 'daemon off 4 seconds ago Up 3 seconds 443/tcp, 80/tcp desperate_lalande
```
从上面的输出信息中,我们可以看到正在运行的名为`desperate_lalande`的容器,它是由`nginx:latest image`LCTT 译注: nginx 最新版本的镜像)构建而来得。
### Docker 镜像
镜像是 Docker 的核心特征之一类似于虚拟机镜像。和虚拟机镜像一样Docker 镜像是一个被保存并打包的容器。当然Docker 不只是创建镜像,它还可以通过 Docker 仓库发布这些镜像Docker 仓库和软件包仓库的概念差不多,它让 Docker 能够模仿`yum`部署软件包的方式来部署镜像。为了更好地理解这是怎么工作的,我们来回顾`docker run`执行后的输出。
```
# docker run -d nginx
Unable to find image 'nginx' locally
```
我们可以看到第一条信息是Docker 不能在本地找到名叫 nginx 的镜像。这是因为当我们执行`docker run`命令时,告诉 Docker 运行一个基于 nginx 镜像的容器。既然 Docker 要启动一个基于特定镜像的容器,那么 Docker 首先需要找到那个指定镜像。在检查远程仓库之前Docker 首先检查本地是否存在指定名称的本地镜像。
因为系统是崭新的,不存在 nginx 镜像Docker 将选择从 Docker 仓库下载之。
```
Pulling repository nginx
5c82215b03d1: Download complete
e2a4fb18da48: Download complete
58016a5acc80: Download complete
657abfa43d82: Download complete
dcb2fe003d16: Download complete
c79a417d7c6f: Download complete
abb90243122c: Download complete
d6137c9e2964: Download complete
85e566ddc7ef: Download complete
69f100eb42b5: Download complete
cd720b803060: Download complete
7cc81e9a118a: Download complete
```
这就是第二部分输出信息显示给我们的内容。默认情况下Docker 会使用 [Docker Hub](https://hub.docker.com/) 仓库,该仓库由 Docker 公司维护。
和 Github 一样,在 Docker Hub 创建公共仓库是免费的,私人仓库就需要缴纳费用了。当然,部署你自己的 Docker 仓库也是可以的,事实上只需要简单地运行`docker run registry`命令就行了。但在这篇文章中,我们的重点将不是讲解如何部署一个定制的注册服务。
### 关闭并移除容器
在我们继续构建定制容器之前,我们先清理一下 Docker 环境,我们将关闭先前的容器,并移除它。
我们利用`docker`命令和`run`选项运行一个容器,所以,为了停止同一个容器,我们简单地在执行`docker`命令时,使用`kill`选项,并指定容器名。
```
# docker kill desperate_lalande
desperate_lalande
```
当我们再次执行`docker ps`,就不再有容器运行了
```
# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
```
但是,此时,我们这是停止了容器;虽然它不再运行,但仍然存在。默认情况下,`docker ps`只会显示正在运行的容器,如果我们附加`-a` (all) 标识,它会显示所有运行和未运行的容器。
```
# docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
f6d31ab01fc9 5c82215b03d1 nginx -g 'daemon off 4 weeks ago Exited (-1) About a minute ago desperate_lalande
```
为了能完整地移除容器,我们在用`docker`命令时,附加`rm`选项。
```
# docker rm desperate_lalande
desperate_lalande
```
虽然容器被移除了;但是我们仍拥有可用的**nginx**镜像LCTT 译注:镜像缓存)。如果我们重新运行`docker run -d nginx`Docker 就无需再次拉取 nginx 镜像即可启动容器。这是因为我们本地系统中已经保存了一个副本。
为了列出系统中所有的本地镜像,我们运行`docker`命令,附加`images`选项。
```
# docker images
REPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZE
nginx latest 9fab4090484a 5 days ago 132.8 MB
```
## 构建我们自己的镜像
截至目前,我们已经使用了一些基础的 Docker 命令来启动、停止和移除一个预构建好的普通镜像。为了“Docker 化Dockerize”这篇博客我们需要构建我们自己的镜像也就是创建一个 **Dockerfile**
在大多数虚拟机环境中,如果你想创建一个机器镜像,首先,你需要建立一个新的虚拟机、安装操作系统、安装应用,最后将其转换为一个模板或者镜像。但在 Docker 中,所有这些步骤都可以通过 Dockerfile 实现全自动。Dockerfile 是向 Docker 提供构建指令去构建定制镜像的方式。在这一章节,我们将编写能用来部署这个博客的定制 Dockerfile。
### 理解应用
我们开始构建 Dockerfile 之前,第一步要搞明白,我们需要哪些东西来部署这个博客。
这个博客本质上是由一个静态站点生成器生成的静态 HTML 页面,这个生成器是我编写的,名为 **hamerkop**。这个生成器很简单,它所做的就是生成该博客站点。所有的代码和源文件都被我放在了一个公共的 [Github 仓库](https://github.com/madflojo/blog)。为了部署这篇博客,我们要先从 Github 仓库把这些内容拉取下来,然后安装 **Python** 和一些 **Python** 模块,最后执行`hamerkop`应用。我们还需要安装 **nginx**,来运行生成后的内容。
截止目前,这些还是一个简单的 Dockerfile但它却给我们展示了相当多的 [Dockerfile 语法]((https://docs.docker.com/v1.8/reference/builder/))。我们需要克隆 Github 仓库,然后使用你最喜欢的编辑器编写 Dockerfile我选择`vi`
```
# git clone https://github.com/madflojo/blog.git
Cloning into 'blog'...
remote: Counting objects: 622, done.
remote: Total 622 (delta 0), reused 0 (delta 0), pack-reused 622
Receiving objects: 100% (622/622), 14.80 MiB | 1.06 MiB/s, done.
Resolving deltas: 100% (242/242), done.
Checking connectivity... done.
# cd blog/
# vi Dockerfile
```
### FROM - 继承一个 Docker 镜像
第一条 Dockerfile 指令是`FROM`指令。这将指定一个现存的镜像作为我们的基础镜像。这也从根本上给我们提供了继承其他 Docker 镜像的途径。在本例中,我们还是从刚刚我们使用的 **nginx** 开始,如果我们想从头开始,我们可以通过指定`ubuntu:latest`来使用 **Ubuntu** Docker 镜像。
```
## Dockerfile that generates an instance of http://bencane.com
FROM nginx:latest
MAINTAINER Benjamin Cane <ben@bencane.com>
```
除了`FROM`指令,我还使用了`MAINTAINER`,它用来显示 Dockerfile 的作者。
Docker 支持使用`#`作为注释,我将经常使用该语法,来解释 Dockerfile 的部分内容。
### 运行一次测试构建
因为我们继承了 **nginx** Docker镜像我们现在的 Dockerfile 也就包括了用来构建 **nginx** 镜像的 [Dockerfile](https://github.com/nginxinc/docker-nginx/blob/08eeb0e3f0a5ee40cbc2bc01f0004c2aa5b78c15/Dockerfile) 中所有指令。这意味着,此时我们可以从该 Dockerfile 中构建出一个 Docker 镜像,然后以该镜像运行一个容器。虽然,最终的镜像和 **nginx** 镜像本质上是一样的,但是我们这次是通过构建 Dockerfile 的形式,然后我们将讲解 Docker 构建镜像的过程。
想要从 Dockerfile 构建镜像,我们只需要在运行 `docker` 命令的时候,加上 `build` 选项。
```
# docker build -t blog /root/blog
Sending build context to Docker daemon 23.6 MB
Sending build context to Docker daemon
Step 0 : FROM nginx:latest
---> 9fab4090484a
Step 1 : MAINTAINER Benjamin Cane <ben@bencane.com>
---> Running in c97f36450343
---> 60a44f78d194
Removing intermediate container c97f36450343
Successfully built 60a44f78d194
```
上面的例子,我们使用了`-t` (**tag**)标识给镜像添加“blog”的标签。实质上我们就是在给镜像命名如果我们不指定标签就只能通过 Docker 分配的 **Image ID** 来访问镜像了。本例中,从 Docker 构建成功的信息可以看出,**Image ID**值为 `60a44f78d194`
除了`-t`标识外,我还指定了目录`/root/blog`。该目录被称作“构建目录”,它将包含 Dockerfile以及其它需要构建该容器的文件。
现在我们构建成功了,下面我们开始定制该镜像。
### 使用 RUN 来执行 apt-get
用来生成 HTML 页面的静态站点生成器是用 **Python** 语言编写的,所以,在 Dockerfile 中需要做的第一件定制任务是安装 Python。我们将使用 Apt 软件包管理器来安装 Python 软件包,这意味着在 Dockerfile 中我们要指定运行`apt-get update`和`apt-get install python-dev`;为了完成这一点,我们可以使用`RUN`指令。
```
## Dockerfile that generates an instance of http://bencane.com
FROM nginx:latest
MAINTAINER Benjamin Cane <ben@bencane.com>
## Install python and pip
RUN apt-get update
RUN apt-get install -y python-dev python-pip
```
如上所示,我们只是简单地告知 Docker 构建镜像的时候,要去执行指定的`apt-get`命令。比较有趣的是,这些命令只会在该容器的上下文中执行。这意味着,即使在容器中安装了`python-dev`和`python-pip`,但主机本身并没有安装这些。说的更简单点,`pip`命令将只在容器中执行,出了容器,`pip`命令不存在。
还有一点比较重要的是Docker 构建过程中不接受用户输入。这说明任何被`RUN`指令执行的命令必须在没有用户输入的时候完成。由于很多应用在安装的过程中需要用户的输入信息,所以这增加了一点难度。不过我们例子中,`RUN`命令执行的命令都不需要用户输入。
### 安装 Python 模块
**Python** 安装完毕后,我们现在需要安装 Python 模块。如果在 Docker 外做这些事,我们通常使用`pip`命令,然后参考我的博客 Git 仓库中名叫`requirements.txt`的文件。在之前的步骤中,我们已经使用`git`命令成功地将 Github 仓库“克隆”到了`/root/blog`目录;这个目录碰巧也是我们创建`Dockerfile`的目录。这很重要,因为这意味着 Docker 在构建过程中可以访问这个 Git 仓库中的内容。
当我们执行构建后Docker 将构建的上下文环境设置为指定的“构建目录”。这意味着目录中的所有文件都可以在构建过程中被使用,目录之外的文件(构建环境之外)是不能访问的。
为了能安装所需的 Python 模块,我们需要将`requirements.txt`从构建目录拷贝到容器中。我们可以在`Dockerfile`中使用`COPY`指令完成这一需求。
```
## Dockerfile that generates an instance of http://bencane.com
FROM nginx:latest
MAINTAINER Benjamin Cane <ben@bencane.com>
## Install python and pip
RUN apt-get update
RUN apt-get install -y python-dev python-pip
## Create a directory for required files
RUN mkdir -p /build/
## Add requirements file and run pip
COPY requirements.txt /build/
RUN pip install -r /build/requirements.txt
```
在`Dockerfile`中我们增加了3条指令。第一条指令使用`RUN`在容器中创建了`/build/`目录。该目录用来拷贝生成静态 HTML 页面所需的一切应用文件。第二条指令是`COPY`指令,它将`requirements.txt`从“构建目录”(`/root/blog`)拷贝到容器中的`/build/`目录。第三条使用`RUN`指令来执行`pip`命令;安装`requirements.txt`文件中指定的所有模块。
当构建定制镜像时,`COPY`是条重要的指令。如果在 Dockerfile 中不指定拷贝文件Docker 镜像将不会包含requirements.txt 这个文件。在 Docker 容器中,所有东西都是隔离的,除非在 Dockerfile 中指定执行,否则容器中不会包括所需的依赖。
### 重新运行构建
现在,我们让 Docker 执行了一些定制任务,现在我们尝试另一次 blog 镜像的构建。
```
# docker build -t blog /root/blog
Sending build context to Docker daemon 19.52 MB
Sending build context to Docker daemon
Step 0 : FROM nginx:latest
---> 9fab4090484a
Step 1 : MAINTAINER Benjamin Cane <ben@bencane.com>
---> Using cache
---> 8e0f1899d1eb
Step 2 : RUN apt-get update
---> Using cache
---> 78b36ef1a1a2
Step 3 : RUN apt-get install -y python-dev python-pip
---> Using cache
---> ef4f9382658a
Step 4 : RUN mkdir -p /build/
---> Running in bde05cf1e8fe
---> f4b66e09fa61
Removing intermediate container bde05cf1e8fe
Step 5 : COPY requirements.txt /build/
---> cef11c3fb97c
Removing intermediate container 9aa8ff43f4b0
Step 6 : RUN pip install -r /build/requirements.txt
---> Running in c50b15ddd8b1
Downloading/unpacking jinja2 (from -r /build/requirements.txt (line 1))
Downloading/unpacking PyYaml (from -r /build/requirements.txt (line 2))
<truncated to reduce noise>
Successfully installed jinja2 PyYaml mistune markdown MarkupSafe
Cleaning up...
---> abab55c20962
Removing intermediate container c50b15ddd8b1
Successfully built abab55c20962
```
上述输出所示,我们可以看到构建成功了,我们还可以看到另外一个有趣的信息` ---> Using cache`。这条信息告诉我们Docker 在构建该镜像时使用了它的构建缓存。
### Docker 构建缓存
当 Docker 构建镜像时它不仅仅构建一个单独的镜像事实上在构建过程中它会构建许多镜像。从上面的输出信息可以看出在每一“步”执行后Docker 都在创建新的镜像。
```
Step 5 : COPY requirements.txt /build/
---> cef11c3fb97c
```
上面片段的最后一行可以看出Docker 在告诉我们它在创建一个新镜像,因为它打印了**Image ID** : `cef11c3fb97c`。这种方式有用之处在于Docker能在随后构建这个 **blog** 镜像时将这些镜像作为缓存使用。这很有用处,因为这样, Docker 就能加速同一个容器中新构建任务的构建流程。从上面的例子中我们可以看出Docker 没有重新安装`python-dev`和`python-pip`包Docker 则使用了缓存镜像。但是由于 Docker 并没有找到执行`mkdir`命令的构建缓存,随后的步骤就被一一执行了。
Docker 构建缓存一定程度上是福音,但有时也是噩梦。这是因为决定使用缓存或者重新运行指令的因素很少。比如,如果`requirements.txt`文件发生了修改Docker 会在构建时检测到该变化,然后 Docker 会重新执行该执行那个点往后的所有指令。这得益于 Docker 能查看`requirements.txt`的文件内容。但是,`apt-get`命令的执行就是另一回事了。如果提供 Python 软件包的 **Apt** 仓库包含了一个更新的 python-pip 包Docker 不会检测到这个变化,转而去使用构建缓存。这会导致之前旧版本的包将被安装。虽然对`python-pip`来说,这不是主要的问题,但对使用了存在某个致命攻击缺陷的软件包缓存来说,这是个大问题。
出于这个原因,抛弃 Docker 缓存,定期地重新构建镜像是有好处的。这时,当我们执行 Docker 构建时,我简单地指定`--no-cache=True`即可。
## 部署博客的剩余部分
Python 软件包和模块安装后,接下来我们将拷贝需要用到的应用文件,然后运行`hamerkop`应用。我们只需要使用更多的`COPY` 和 `RUN`指令就可完成。
```
## Dockerfile that generates an instance of http://bencane.com
FROM nginx:latest
MAINTAINER Benjamin Cane <ben@bencane.com>
## Install python and pip
RUN apt-get update
RUN apt-get install -y python-dev python-pip
## Create a directory for required files
RUN mkdir -p /build/
## Add requirements file and run pip
COPY requirements.txt /build/
RUN pip install -r /build/requirements.txt
## Add blog code nd required files
COPY static /build/static
COPY templates /build/templates
COPY hamerkop /build/
COPY config.yml /build/
COPY articles /build/articles
## Run Generator
RUN /build/hamerkop -c /build/config.yml
```
现在我们已经写出了剩余的构建指令,我们再次运行另一次构建,并确保镜像构建成功。
```
# docker build -t blog /root/blog/
Sending build context to Docker daemon 19.52 MB
Sending build context to Docker daemon
Step 0 : FROM nginx:latest
---> 9fab4090484a
Step 1 : MAINTAINER Benjamin Cane <ben@bencane.com>
---> Using cache
---> 8e0f1899d1eb
Step 2 : RUN apt-get update
---> Using cache
---> 78b36ef1a1a2
Step 3 : RUN apt-get install -y python-dev python-pip
---> Using cache
---> ef4f9382658a
Step 4 : RUN mkdir -p /build/
---> Using cache
---> f4b66e09fa61
Step 5 : COPY requirements.txt /build/
---> Using cache
---> cef11c3fb97c
Step 6 : RUN pip install -r /build/requirements.txt
---> Using cache
---> abab55c20962
Step 7 : COPY static /build/static
---> 15cb91531038
Removing intermediate container d478b42b7906
Step 8 : COPY templates /build/templates
---> ecded5d1a52e
Removing intermediate container ac2390607e9f
Step 9 : COPY hamerkop /build/
---> 59efd1ca1771
Removing intermediate container b5fbf7e817b7
Step 10 : COPY config.yml /build/
---> bfa3db6c05b7
Removing intermediate container 1aebef300933
Step 11 : COPY articles /build/articles
---> 6b61cc9dde27
Removing intermediate container be78d0eb1213
Step 12 : RUN /build/hamerkop -c /build/config.yml
---> Running in fbc0b5e574c5
Successfully created file /usr/share/nginx/html//2011/06/25/checking-the-number-of-lwp-threads-in-linux
Successfully created file /usr/share/nginx/html//2011/06/checking-the-number-of-lwp-threads-in-linux
<truncated to reduce noise>
Successfully created file /usr/share/nginx/html//archive.html
Successfully created file /usr/share/nginx/html//sitemap.xml
---> 3b25263113e1
Removing intermediate container fbc0b5e574c5
Successfully built 3b25263113e1
```
### 运行定制的容器
成功的一次构建后,我们现在就可以通过运行`docker`命令和`run`选项来运行我们定制的容器,和之前我们启动 nginx 容器一样。
```
# docker run -d -p 80:80 --name=blog blog
5f6c7a2217dcdc0da8af05225c4d1294e3e6bb28a41ea898a1c63fb821989ba1
```
我们这次又使用了`-d` (**detach**)标识来让Docker在后台运行。但是我们也可以看到两个新标识。第一个新标识是`--name`,这用来给容器指定一个用户名称。之前的例子,我们没有指定名称,因为 Docker 随机帮我们生成了一个。第二个新标识是`-p`,这个标识允许用户从主机映射一个端口到容器中的一个端口。
之前我们使用的基础 **nginx** 镜像分配了80端口给 HTTP 服务。默认情况下,容器内的端口通道并没有绑定到主机系统。为了让外部系统能访问容器内部端口,我们必须使用`-p`标识将主机端口映射到容器内部端口。上面的命令,我们通过`-p 8080:80`语法将主机80端口映射到容器内部的80端口。
经过上面的命令,我们的容器看起来成功启动了,我们可以通过执行`docker ps`核实。
```
# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
d264c7ef92bd blog:latest nginx -g 'daemon off 3 seconds ago Up 3 seconds 443/tcp, 0.0.0.0:80->80/tcp blog
```
## 总结
截止目前,我们拥有了一个运行中的定制 Docker 容器。虽然在这篇文章中,我们只接触了一些 Dockerfile 指令用法,但是我们还是要学习所有的指令。我们可以检查 [Docker's reference page](https://docs.docker.com/v1.8/reference/builder/) 来获取所有的 Dockerfile 指令用法,那里对指令的用法说明得很详细。
另一个比较好的资源是 [Dockerfile Best Practices page](https://docs.docker.com/engine/articles/dockerfile_best-practices/),它有许多构建定制 Dockerfile 的最佳练习。有些技巧非常有用,比如战略性地组织好 Dockerfile 中的命令。上面的例子中,我们将`articles`目录的`COPY`指令作为 Dockerfile 中最后的`COPY`指令。这是因为`articles`目录会经常变动。所以,将那些经常变化的指令尽可能地放在最后面的位置,来最优化那些可以被缓存的步骤。
通过这篇文章,我们涉及了如何运行一个预构建的容器,以及如何构建,然后部署定制容器。虽然关于 Docker 你还有许多需要继续学习的地方,但我想这篇文章给了你如何继续开始的好建议。当然,如果你认为还有一些需要继续补充的内容,在下面评论即可。
--------------------------------------
via: http://bencane.com/2015/12/01/getting-started-with-docker-by-dockerizing-this-blog/
作者Benjamin Cane
译者:[su-kaiyao](https://github.com/su-kaiyao)
校对:[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创翻译,[Linux中国](http://linux.cn/) 荣誉推出

View File

@ -0,0 +1,121 @@
如何启用 Nginx/Apache 的 PHP-FPM 多实例
================================================================================
PHP-FPM 作为 FastCGI 进程管理器而广为熟知,它是 PHP FastCGI 实现的改进,带有更为有用的功能,用于处理高负载的服务器和网站。下面列出其中一些功能:
### 新功能 ###
- 拥有具有优雅graceful启动/停止选项的高级进程管理能力。
- 可以通过不同的用户身份/组身份来以监听多个端口以及使用多个PHP配置。
- 错误日志记录。
- 支持上传加速。
- 特别用于在处理一些耗时任务时结束请求和清空所有数据的功能。
- 同时支持动态和静态的子进程重生。
- 支持IP地址限制。
在本文中,我将要讨论的是,在运行 CPanel 11.52 及 EA3 EasyApache的 CentOS 7 服务器上,于 Nginx 和 Apache 之上安装 PHP-FPM以及如何来通过 CPanel 管理这些安装好的多个 PHP-FPM 实例。
在我们开始安装前, 先看看安装的先决条件。
### 先决条件 ###
1. 启用 Mod_proxy_fcgi 模块
2. 启用 MPM_Event
由于我们要将 PHP-FPM 安装到一台 EA3 服务器,我们需要运行 EasyApache 来编译 Apache 以启用这些模块。
你们可以参考我以前写的,关于如何在 Apache 服务器上安装 Nginx 作为反向代理的文档来了解 Nginx 的安装。
这里,我将再次简述那些安装步骤。具体细节,你可以参考我之前写的**(如何在 CentOS 7/CPanel 服务器上配置 Nginx 反向代理)**一文。
- 步骤 1安装 Epel 仓库
- 步骤 2安装 nDeploy RPM 仓库,这是此次安装中最为**重要**的步骤。
- 步骤 3使用 yum 从 nDeploy 仓库安装 nDeploy 和 Nginx 插件。
- 步骤 4启用/配置 Nginx 为反向代理。
完成这些步骤后,下面为服务器中所有可用 PHP 版本安装 PHP-FPM 包EA3 使用 remi 仓库来安装这些包。你可以运行这个 nDeploy 脚本来下载所有的包。
root@server1 [~]# /opt/nDeploy/scripts/easy_php_setup.sh
Loaded plugins: fastestmirror, tsflags, universal-hooks
EA4 | 2.9 kB 00:00:00
base | 3.6 kB 00:00:00
epel/x86_64/metalink | 9.7 kB 00:00:00
epel | 4.3 kB 00:00:00
extras | 3.4 kB 00:00:00
updates | 3.4 kB 00:00:00
(1/2): epel/x86_64/updateinfo | 460 kB 00:00:00
(2/2): epel/x86_64/primary_db
运行该脚本将为 PHP 54PHP 55PHP 56 和 PHP 70 安装所有这些 FPM 包。
Installed Packages
php54-php-fpm.x86_64 5.4.45-3.el7.remi @remi
php55-php-fpm.x86_64 5.5.31-1.el7.remi @remi
php56-php-fpm.x86_64 5.6.17-1.el7.remi @remi
php70-php-fpm.x86_64 7.0.2-1.el7.remi @remi
在以上安装完成后,你需要为 Apache 启用 PHP-FPM SAPI。你可以运行下面这个脚本来启用 PHP-FPM 实例。
root@server1 [~]# /opt/nDeploy/scripts/apache_php-fpm_setup.sh enable
mod_proxy_fcgi.c
Please choose one default PHP version from the list below
PHP70
PHP56
PHP54
PHP55
Provide the exact desired version string here and press ENTER: PHP54
ConfGen:: lxblogger
ConfGen:: blogr
ConfGen:: saheetha
ConfGen:: satest
which: no cagefsctl in (/usr/local/jdk/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/usr/local/bin:/usr/X11R6/bin:/root/bin)
info [rebuildhttpdconf] Missing owner for domain server1.centos7-test.com, force lookup to root
Built /usr/local/apache/conf/httpd.conf OK
Waiting for “httpd” to restart gracefully …waiting for “httpd” to initialize ……
…finished.
它会问你需要运行哪个 PHP 版本作为服务器默认版本,你可以输入那些细节内容,然后继续配置并为现存的域名生成虚拟主机文件。
我选择了 PHP 54 作为我服务器上的默认 PHP-FPM 版本。
![confirm-php-fpm](http://blog.linoxide.com/wp-content/uploads/2016/01/confirm-php-fpm-1024x525.png)
虽然服务器配置了 PHP-FPM 54但是我们可以通过 CPanel 为各个独立的域名修改 PHP-FPM 实例。
下面我将通过一些截图来为你们说明一下,怎样通过 CPanel 为各个独立域修改 PHP-FPM 实例。
安装了 Nginx 插件后,你的域名的 CPanel 就会有一个 Nginx Webstack 图标,你可以点击该图标来配置你的 Web 服务器。我已经登录进了我其中的一个 CPanel 来配置相应的 Web 服务器。
请看这些截图。
![nginx webstack](http://blog.linoxide.com/wp-content/uploads/2016/01/nginx-webstack.png)
![nginxicon1](http://blog.linoxide.com/wp-content/uploads/2016/01/nginxicon1-1024x253.png)
现在,你可以根据需要为选中的主域配置 web 服务器(这里,我已经选择了主域 saheetha.com。我已经继续通过自动化配置选项来进行了因为我不需要添加任何手动设置。
![nginx_auto_proxy](http://blog.linoxide.com/wp-content/uploads/2016/01/nginx_auto_proxy-1024x408.png)
当 Nginx 配置完后,你可以在这里为你的域名选择 PHP-FPM 实例。
![php-fpm1](http://blog.linoxide.com/wp-content/uploads/2016/01/php-fpm1-1024x408.png)
![php54](http://blog.linoxide.com/wp-content/uploads/2016/01/php54-1024x169.png)
![php55](http://blog.linoxide.com/wp-content/uploads/2016/01/php55.png)
就像你在截图中所看到的,我服务器上的默认 PHP-FPM 是**PHP 54**,而我正要将我的域名的 PHP-FPM 实例单独修改成 **PHP 55**。当你为你的域修改 PHP-FPM 后,你可以通过访问 **phpinfo** 页面来确认。
谢谢你们参考本文,我相信这篇文章会给你提供不少信息和帮助。我会为你们推荐关于这个内容的有价值的评论 :)。
--------------------------------------------------------------------------------
via: http://linoxide.com/linux-how-to/enable-multiple-php-fpm-instances-nginx-apache/
作者:[Saheetha Shameer][a]
译者:[GOLinux](https://github.com/GOLinux)
校对:[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译,[Linux中国](https://linux.cn/) 荣誉推出
[a]:http://linoxide.com/author/saheethas/

View File

@ -0,0 +1,59 @@
七步开始你的 Linux 系统管理员生涯
===============================================
Linux 现在是个大热门。每个人都在寻求 Linux 才能。招聘人员对有 Linux 经验的人求贤若渴,还有无数的职位虚位以待。但是如果你是 Linux 新手,又想要赶上这波热潮,该从何开始下手呢?
###1、安装 Linux###
这应该是不言而喻的,但学习 Linux 的第一关键就是安装 Linux。LFS101x 和 LFS201 课程都包含第一次安装和配置 Linux 的详细内容。
###2、 完成 LFS101x 课程###
如果你是完完全全的 Linux 新手,最佳的起点是我们的免费 Linux 课程 [LFS101x Introduction to Linux](https://www.edx.org/course/introduction-linux-linuxfoundationx-lfs101x-2)。这个在线课程放在 edX.org探索 Linux 系统管理员和终端用户常用的各种工具和技能以及日常的 Linux 工作环境。该课程是为有一定经验,但较少或没有接触过 Linux 的电脑用户设计的,不论他们是在个人还是企业环境中工作。这个课程会从图形界面和命令行两个方面教会你有用的 Linux 知识,让你能够了解主流的 Linux 发行版。
###3、 看看 LFS201 课程###
在你完成 LFS101x 之后,你就可以开始挑战 Linux 中更加复杂的任务了,这是成为一名专业的系统管理员所必须的。为了掌握这些技能,你应该看看 [LFS201 Essentials of Linux System Administration](http://training.linuxfoundation.org/linux-courses/system-administration-training/essentials-of-system-administration) 这个课程。该课程对每个话题进行了深度的解释和介绍,还有大量的练习和实验,帮助你获得相关主题实际的上手经验。
如果你更愿意有个教练,或者你的雇主想将你培养成 Linux 系统管理员的话,你可能会对 LFS220 Linux System Administration 感兴趣。这个课程有 LFS201 中所有的主题,但是它是由专家专人教授的,帮助你进行实验以及解答你在课程主题中的问题。
###4、 练习!###
熟能生巧,和对任何乐器或运动适用一样,这对 Linux 来说也一样适用。在你安装 Linux 之后,经常使用它。一遍遍地练习关键任务,直到你不需要参考材料也能轻而易举地完成。练习命令行的输入输出以及图形界面。这些练习能够保证你掌握成为成功的 Linux 系统管理员所必需的知识和技能。
###5、 获得认证###
在你完成 LFS201 或 LFS220 并且充分练习之后,你现在已经准备好获得系统管理员的认证了。你需要这个证书,因为你需要向雇主证明你拥有一名专业 Linux 系统管理员必需的技能。
现在有一些不同的 Linux 证书,它们每个都有其独到之处。但是,它们里大部分不是在特定发行版(如红帽)上认证,就是纯粹的知识测试,没有演示 Linux 的实际技能。Linux 基金会认证系统管理员Linux Foundation Certified System Administrator证书对想要一个灵活的有意义的初级证书的人来说是个不错的选择。
###6、 参与进来###
如果你所在的地方有本地 Linux 用户组Linux Users GroupLUG的话这时候你可以考虑加入他们。这些组织通常由各种年龄和经验水平的人组成所以不管你的 Linux 经验水平如何,你都能找到和你类似技能水平的人互助,或是更高水平的 Linux 用户来解答你的问题以及介绍有用的资源。要想知道你附近有没有 LUG上 meet.com 看看,或是附近的大学,又或是上网搜索一下。
还有不少在线社区可以在你学习 Linux 的时候帮助你。这些站点和社区向 Linux 新手和有经验的管理员都能够提供帮助和支持:
- [Linux Admin subreddit](https://www.reddit.com/r/linuxadmin)
- [Linux.com](http://www.linux.com/)
- [training.linuxfoundation.org](http://training.linuxfoundation.org/)
- [http://community.ubuntu.com/help-information/](http://community.ubuntu.com/help-information/)
- [https://forums.opensuse.org/forum.php](https://forums.opensuse.org/forum.php)
- [http://wiki.centos.org/Documentation](http://wiki.centos.org/Documentation)
###7、 学会热爱文档###
最后但同样重要的是,如果你困在 Linux 的某些地方,别忘了 Linux 包含的文档。使用命令 manmanual手册info 和 help你从系统内就可以找到 Linux 几乎所有方面的信息。这些内置资源的用处再夸大也不为过,你会发现你在生涯中始终会用到,所以你可能最好早点掌握使用它们。
想要了解更多开始你 Linux IT 生涯的信息?查看我们免费的电子书“[开始你 Linux IT 生涯的简短指南](http://training.linuxfoundation.org/sysadmin-it-career-guide)”。
------------------------------------------------------------------------------
via: http://www.linux.com/news/featured-blogs/191-linux-training/834644-7-steps-to-start-your-linux-sysadmin-career
作者:[linux.com][a]
译者:[alim0x](https://github.com/alim0x)
校对:[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创翻译,[Linux中国](https://linux.cn/) 荣誉推出
[a]:linux.com

View File

@ -0,0 +1,74 @@
混合云计算的 9 大关键趋势
========================================
自从几年前云计算的概念受到IT界的关注以来公有云、私有云和混合云这三种云计算方式都有了可观的演进。其中混合云计算方式是最热门的云计算方式在接受调查的公司中有[88%的公司](https://www.greenhousedata.com/blog/hybrid-continues-to-be-most-popular-cloud-option-adoption-accelerating)将混合云计算摆在至关重要的地位。
混合云计算的疾速演进意味着一两年前的传统观念已经过时了。为此我们询问了几个行业分析师混合云在2016年的走势将会如何我们得到了几个比较有意思的答案。
1. **2016年可能是我们将混合云投入使用的一年。**
混合云从本质上来说依赖于私有云,这对企业来说是比较难实现的。事实上,亚马逊,谷歌和微软的公有云已经进行了大量的投资,并且起步也比较早。私有云拖了混合云发展和使用的后腿。
私有云没有得到这么多的投资,这是有私有云的性质决定的。私有云意味着维护和投资你自己的数据中心。而许多公有云提供商正在推动企业减少或者消除他们的数据中心。
然而,得益于 OpenStack 的发展和微软的 Azure Stack ,这两者基本上就是封装在一个盒子里的私有云,我们将会看到私有云慢慢追上公有云的发展步伐。支持混合云的工具、基础设施和架构也变得更加健壮。
2. **容器,微服务和 unikernels 将会促进混合云的发展。**
分析师预言到2016年底这些原生云技术会或多或少成为主流的。这些云技术正在快速成熟将会成为虚拟机的一个替代品而虚拟机需要更多的资源。
更重要的是,他们既能工作在在线场景,也能工作在离线场景。容器化和编排允许快速的扩大规模,进行公有云和私有云之间的服务迁移,使你能够更容易移动你的服务。
3. **数据和相关性占据核心舞台。**
所有的云计算方式都处在发展模式。这使得云计算变成了一个技术类的故事。咨询公司 [Avoa](http://avoa.com/2016/01/01/2016-is-the-year-of-data-and-relevance/)称,随着云趋于成熟,数据和相关性变得越来越重要。起初,云计算和大数据都是关于怎么得到尽可能多的数据,然后他们担心如何处理这海量的数据。
2016年相关组织将会继续锤炼如何进行数据收集和使用的相关技术。在必须处理的技术和文化方面仍然有待提高。但是2016年应该重新将关注点放在从各个方面考虑的数据重要性上发现最相关的信息而不只是数据的数量。
4. **云服务将超越按需工作负载。**
AWS(Amazon Web Services) 起初是提供给程序员或者是开发人员能够快速启动虚拟机、做一些工作然后离线的一个地方。本质上是按需使用,要花费更多的钱才能让这些服务持续运行、全天候工作。
然而IT 公司正开始作为服务代理,为内部用户提供各种 IT 服务。可以是内部 IT 服务,公有云基础架构提供商,平台服务和软件服务。
他们将越来越多的认识到像云管理平台这样的工具的价值。云管理平台可以提供针对不同服务的基于策略的一致性管理。他们也将看到像提高可移植性的容器等技术的价值。然而,云服务代理,在不同云之间快速移动工作负载从而进行价格套利或者类似的原因,仍然是行不通的。
5. **服务提供商转变成了云服务提供商。**
到目前为止购买云服务成了直销模式。AWS EC2 服务的使用者通常变成了购买者,要么通过官方认证渠道,要么通过影子 IT。但是随着云服务越来越全面提供的服务菜单越来越复杂越来越多的人转向了经销商服务提供商转变成了他们 IT 服务的购买者。
2nd Watch (2nd Watch 是为企业提供云管理的 AWS 的首选合作伙伴)最近的一项调查发现在美国将近85%的 IT 高管愿意支付一个小的溢价从渠道商那里购买公有云服务如果购买过程变得不再那么复杂。根据调查这85%的高管有五分之四的愿意支付额外的15%或者更多。三分之一的受访高管表示,这些有助于他们购买、使用和管理公有云服务。
6. **物联网和云对于2016年的意义好比移动和云对2012年的意义。**
物联网获得了广泛的关注,更重要的是,物联网已经从测试场景进行了实际应用。云的分布式特性使得云成为了物联网非常重要的一部分,对于工业物联网,与后端系统交互的机械和重型设备,混合云将会成为最自然的驱动者,连接,数据采集和处理将会发生在混合云环境中,这得益于私有云在安全和隐私方面的好处。
7. **NIST 对云的定义开始瓦解。**
2011年美国国家标准与技术研究院发布了“[ NIST 对于云计算的定义](http://csrc.nist.gov/publications/nistpubs/800-145/SP800-145.pdf)”PDF这个定义成为了私有云、公有云、混合云和 aaS 模板的标准定义。
然而随着时间的推移定义开始改变。IaaS 变得更加复杂,开始支持 OpenStack[Swift](https://wiki.openstack.org/wiki/Swift) 对象存储和神经网络这样的项目。PaaS 似乎正在消退,因为 PaaS 和传统的中间件开发几乎无异。SaaS只是通过浏览器进行访问的应用也正在失去发展动力因为许多 app 和服务提供了许多云接口,你可以通过各种手段调用接口,不仅仅通过浏览器。
8. **分析变得更加重要**
对于混合云计算来说,分析将会成为一个巨大的增长机遇,云计算具有规模大、灵活性高的优势,使得云计算非常适合需要海量数据的分析工作。对于某些分析方式,比如高度敏感的数据,私有云仍然是主导地位,但是私有云也是混合云的一部分。因此,无论如何,混合云计算胜出。
9. **安全仍然是一个非常紧迫的问题。**
随着混合云计算在2016年的发展以及对物联网和容器等新技术的引进这同时也增加了更多的脆弱可攻破的地方从而导致数据泄露。先增加使用新技术的趋势然后再去考虑安全性这种问题经常发生同时还有缺少经验的工程师不去考虑系统的安全问题总有一天你会尝到灾难的后果的。
当一项新技术出来,管理规范总是落后于安全问题产生后,然后我们才考虑去保护技术。容器就是一个很鲜明的例子。你可以从 Docker 下载各种示例容器但是你知道你下载的东西来自哪里么在人们在对容器内容不知情的情况下下载并运行了容器之后Docker 不得不重新加上安全验证。
像 Path 和 Snapchat 这样的移动技术在智能手机市场火起来之后也出现了重大的安全问题。一项新技术被恶意利用无可避免。所以安全研究人员需要通过各种手段来保证新技术的安全性,很有可能在部署之后才会发现安全问题。
------------------------------------------------------------------------------
via: http://www.datamation.com/cloud-computing/9-key-trends-in-hybrid-cloud-computing.html
作者:[Andy Patrizio][a]
译者:[棣琦](https://github.com/sonofelice)
校对:[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创翻译,[Linux中国](https://linux.cn/) 荣誉推出
[a]:http://www.datamation.com/author/Andy-Patrizio-90720.html

View File

@ -1,9 +1,9 @@
一个Linux驱动的微波炉
一个 Linux 驱动的微波炉
================================================================================
[linux.conf.au](http://linux.conf.au/)里的人们都有一种想到什么就动手去实现的想法。随着硬件开源运动不断地发展壮大这种想法越来越多与现实世界联系的越来越紧密而不仅仅存在于数字世界中。David Tulloh用他制作的[Linux驱动的微波炉 [WebM]](http://mirror.linux.org.au/linux.conf.au/2016/04_Thursday/D4.303_Costa_Theatre/Linux_driven_microwave.webm)来展示一个差劲的微波炉会多么难用以及说明他的项目可以改造这些微波炉使得它们不那么讨人厌。
[linux.conf.au](http://linux.conf.au/)里的人们都有一种想到什么就动手去实现的想法。随着硬件开源运动不断地发展壮大,这种想法越来越多,与现实世界联系的越来越紧密而不仅仅存在于数字世界中。David Tulloh用他制作的[Linux驱动的微波炉 [WebM]](http://mirror.linux.org.au/linux.conf.au/2016/04_Thursday/D4.303_Costa_Theatre/Linux_driven_microwave.webm)来展示一个差劲的微波炉会多么难用以及说明他的项目可以改造这些微波炉使得它们不那么讨人厌。
Tulloh的故事要从他买到了一个公认很便宜的微波炉开始说起它的用户界面比其它微波炉默认的还要糟糕。设定时间时必须使劲按按钮以至于把微波炉都向后推了一段距离——而事实上必须要用力拉仓门把手才能把微波炉拖回原来的位置这形成了一个“优雅”的平衡。当然这只是极端情况。Tulloh郁闷因为这个微波炉近十年来都没有一丁点明显的改善。他可能买到了一个又小又便宜的微波炉,而且特点是大部分人不研究使用手册就不会使用它——和智能手机的对比更加明显:智能手机只需知道一点点的操作指南并且被广泛使用。
Tulloh的故事要从他买到了一个公认很便宜的微波炉开始说起它的用户界面比其它微波炉默认的还要糟糕。设定时间时必须使劲按按钮以至于把微波炉都向后推了一段距离——而事实上必须要用力拉仓门把手才能把微波炉拖回原来的位置这形成了一个“优雅”的平衡。当然这只是极端情况。Tulloh郁闷的是因为这个微波炉近十年来都没有一丁点明显的改善。他可能买到了一个又小又便宜的微波炉,而且特点是大部分人不研究使用手册就不会使用它——和智能手机的对比更加明显:智能手机只需知道一点点的操作指南并且被广泛使用。
改造这个微波炉不一定没有前途“让微波炉重获新生”——这个想法成为了一个原型如果Tulloh可以再平衡一下想做的功能和需求之间的关系的话他希望这变成一个众筹项目一个Linux驱动的微波炉。
@ -11,35 +11,29 @@ Tulloh的故事要从他买到了一个公认很便宜的微波炉开始说起
## 加一点新奇的小玩意
如果把“Linux”和“微波炉”联系在一起的话你可能会想到给微波炉加上一个智能手机式的触摸屏和网络链接然后再通过社区做一款微波炉的“革命性”的手机应用想到这些就像做菜想到分享食谱一样显而易见。但Tulloh的目标和他的原型远远超过这些他做了两个新奇的功能——热感相机和称量物体质量的称重装置。
这个热感相机提供一个可以精确到两度的八乘八像素的图像这足够发现一杯牛奶是否加热到沸腾或者牛排是否解冻到快不能用来烹饪。不论发生哪种情况都可以减小功率或者关掉它。而且在必要的时候会发出警报。这可能不是第一个可以检测温度的微波炉——GE在十年前就开始卖带温度探针的微波炉了——但是一个一直工作的内置传感器比一个手工探针有用多了尤其是有一个可用的API支持的时候。
如果你把“Linux”和“微波炉”联系在一起的话就可能想到给微波炉加上一个智能手机式的触摸屏和网络链接然后再通过社区做一款微波炉的“革命性”的手机应用想到这些就像做菜想到分享食谱一样显而易见。但Tulloh的目标和他的原型远远超过这些他做了两个新奇的功能——热感相机和称量物体质量的称重装置
第二个新发明是一个嵌入的称重装置,它可以在加热之前称量食物(和容器)。很多食谱根据质量大小给出指导的烹饪时间很多微波炉支持你手动输入质量以便它帮你计算。利用内置的称重装置这一过程可以变成自动化的。在许多微波炉的转盘下面稳固地放置一个称重装置是一个机械方面的挑战不过Tulloh觉得这个问题不难处理。相反他对微波炉的设计是基于“平板”或者“平板挂车”的风格——在四角各放置一个传感器这不仅在机械实现上很简单而且很好的达到了要求
这个热感相机提供一个精确度两自由度的八乘八像素的图片这足够发现一杯牛奶是否加热到沸腾或者牛排是否解冻到快不能用来烹饪。不论发生哪种情况功率都可以减小或者关掉。而且在必要的时候会发出警报。这可能不是第一个可以检测温度的微波炉——GE在十年前就开始卖带温度探针的微波炉了——但是一个一直工作的内置传感器比一个手工探针有用多了尤其是有一个可用的API支持的时候。
第二个新发明是一个嵌入的称重装置,它可以在加热之前称量食物(和容器)。很多食谱根据质量给出指导的烹饪时间很多微波炉支持你手动输入质量以便它帮你计算。利用内置的称重装置这一过程可以变成自动化的。在许多微波炉的转盘下面稳固地放置一个称重装置是一个机械方面的挑战不过Tulloh觉得这个问题不难处理。反而他对微波炉的设计是基于“平板”或者“平板挂车”的风格——在四角各放置一个传感器这不仅在机械实现上很简单而且很好的达到了要求。
[用户界面]
一旦你有了这些额外添加的并与逻辑引擎相连的质量温度传感器你可以去尝试更多好玩的可能。一杯刚从冰箱里拿出来的冰牛奶的质量温度分布可能会有适度误差。Tulloh发现这种情况可以被检测到而且提供一些有关的像“煮沸”或者“加热”的选项也是容易做到的下面有一个模拟的界面可点击操作的版本请点击右边链接 [here](http://mwgui.tulloh.id.au/)
一旦你有了这些额外添加的并与逻辑引擎相连的质量温度传感器你可以去尝试更多好玩的可能。一杯刚从冰箱里拿出来的冰牛奶的质量温度分布可能会有适度误差。Tulloh发现可以监检测到这种情况而且提供一些有关的像“煮沸”或者“加热”的选项也是容易做到的下面有一个模拟的界面可点击操作的版本请点击右边链接 [here](http://mwgui.tulloh.id.au/)
![](https://static.lwn.net/images/2016/lca-ovengui-sm.png)
## 改造陈旧的东西
除了才开发出来的新功能Tulloh还想要提升那些原本就提供的功能。可能不是所有微波炉的门把手都像Tulloh那个廉价的一样僵硬但是很少有微波炉将把手设计的让残疾人也能轻松使用。这些缺陷都是可调整的尤其是在美国微波炉应该在仓门关闭的时候给出一个确定关闭的提示。这种确认必须是可靠的以预防那些伪劣产品所以在仓门闭合时固定的槽位里添加一个短杆以确认仓门开闭状态不误使微波炉在仓门开着的时候工作。事实上必须要两个相互联系的机关如果他们提供的结果不一致
保险丝必须断开以便启动一个呼叫服务。Tulloh认为提供一个磁力门闩有更大的灵活性包含简单的软件控制并且像磁控也同样用于[磁性钥匙锁](https://en.wikipedia.org/wiki/Magnetic_keyed_lock),它可以让磁力门闩确认微波炉门是否关闭。
除了才开发出来的新功能Tulloh还想要提升那些原本就提供的功能。可能不是所有微波炉的门把手都像Tulloh那个廉价的一样僵硬但是很少有微波炉将把手设计的让残疾人也能轻松使用。这些缺陷都是可调整的尤其是在美国微波炉应该在仓门关闭的时候给出一个确定关闭的提示。这种确认必须是可靠的以预防那些伪劣产品所以在仓门闭合时固定的槽位里添加一个短杆以确认仓门开闭状态不至于误使微波炉在仓门开着的时候工作。事实上必须要有两个相互联系的机关如果他们提供的结果不一致保险丝必须断开以便启动一个呼叫服务。Tulloh认为提供一个磁力门闩有更大的灵活性包含简单的软件控制并且像磁控也同样用于[磁性钥匙锁](https://en.wikipedia.org/wiki/Magnetic_keyed_lock),它可以让磁力门闩确认微波炉门是否关闭。
微波炉的另一个痛点是它会发出令人厌烦的声音。Tulloh去掉了蜂鸣器并且使用香蕉派类似于树莓派的单片机开发板控制他的微波炉。这可以通过一个把文本转换成语音的系统来用令人愉悦而且可配置的警报来提示和引导使用者。显然下一步就是装上一个用来控制声音的扩音器。
许多微波炉除了定时和设置功率档位之外还可以做更多的事情——它们为烹饪加热化冻等提供一系列的功率谱。加上一个精确的温度测量装置感觉会为这个图表大大扩展它们的序列。Andrew Tridgell对一个问题很好奇加热巧克力——一个需要非常精确的温度控制的过程——是否是可能的。Tulloh没有过这方面的经验他不敢保证这个一定可以但是这个实验结果的确值得期待。即使没做成这件事它也显出了潜在价值——社区接下来可以更进一步去做这件事。
许多微波炉除了定时和设置功率档位之外还可以做更多的事情——它们为烹饪加热化冻等提供一系列的功率档位。加上一个精确的温度测量装置感觉会为这个图表大大扩展这个列表。Andrew Tridgell对一个问题很好奇加热巧克力——一个需要非常精确的温度控制的过程——是否是可能的。Tulloh没有过这方面的经验他不敢保证这个一定可以但是这个实验结果的确值得期待。即使没做成这件事它也显出了潜在价值——社区接下来可以更进一步去做这件事。
## 实用性怎么样?
Tulloh十分乐意向全世界分享这个linux驱动的微波炉他希望看到因为这件事形成一个社区并且想看到它接下来的走势。买一个现成的微波炉并且替换掉里面的电子元件看起来不是一个可行的点子。最后的结果可能会很糟而买一个小巧智能的微波炉必然要花掉比自己改造更多的钱但是潜在的顾客不想在他们的厨房里看到乱七八糟又不协调的东西。
许多零件都是现成的可以买到的磁电管处理器板热传感器等等像USB接口的热传感器而且都很容易安装。软件原型当然也开源在[GitHub](https://github.com/lod?tab=repositories)。这个样例和微波炉门有不小的挑战性并且很可能要定制。Tulloh想要通过提供左侧开仓门的微波炉和颜色多样化的选项来转逆境为机遇。
许多零件都是现成的可以买到的磁电管处理器板热传感器等等像USB接口的热传感器而且都很容易安装。软件原型当然也开源在[GitHub](https://github.com/lod?tab=repositories)。微波炉的舱室和门有不小的挑战性并且很可能要定制。Tulloh想要通过提供左侧开仓门的微波炉和颜色多样化的选项来转逆境为机遇。
一个对读者的快速调查很少有人会贸然承诺他会为了一个全新的升级过的烤箱付出1000澳大利亚元。当然很难知道是否会有充足的时间和足够多的读者来完成这个调查。这整个项目看起来很有趣。所以Tulloh的[博客](http://david.tulloh.id.au/category/microwave/) (点击这里)也很值得一看。
@ -48,8 +42,6 @@ Tulloh十分乐意向全世界分享这个linux驱动的微波炉他希望看
via: https://lwn.net/Articles/674877/
作者Neil Brown
译者yuba0604(https://github.com/yuba0604)
译者水平有限,敬请指正。(lizhengyu@gmail.com)
译者:[yuba0604](https://github.com/yuba0604)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创翻译,[Linux中国](https://linux.cn/) 荣誉推出

View File

@ -1,13 +1,13 @@
开源问题跟踪管理工具Top4
4 个顶级的开源问题跟踪管理工具
========================================
生活充满了bug。
无论怎样小心计划,无论花多少时间去设计,在执行阶段当轮胎压在路上,任何工程都会有未知的问题。也无妨。也许对于任何一个组织的最佳弹性衡量不是他们如何一切都按计划运行地处理事情,而是,当出现磕磕碰碰时他们如何驾驭。
无论怎样小心计划,无论花多少时间去设计,在执行阶段实际执行时,任何工程都会有未知的问题。也无妨。也许对于任何一个组织的最佳弹性衡量不是他们如何一切都按计划运行地处理事情,而是,当出现磕磕碰碰时他们如何驾驭。
对任何一个项目管理流程来说特别是在软件开发领域都需要一个关键工具——问题跟踪管理系统。其基本功能很简单可以对bug进行查看、追踪并以协作的方式解决bug有了它我们更容易跟随整个过程的进展。除了基本功能还有很多专注于满足特定需求的选项及功能使用场景不仅限于软件开发。你可能已经熟悉某些托管版本的工具像 [GitHub Issues](https://guides.github.com/features/issues/)或者[Launchpad](https://launchpad.net/),其中一些工具已经有了自己的开源社区。
接下来这四个bug问题跟踪管理软件的极佳备选全部开源、易于下载自己就可以部署。先说好我们可能没有办法在这里列出每一个问题跟踪工具相反我们列出这四个基于是其丰富的功能和项目背后的社区规模。当然,肯定还有其他类似软件,如果你喜欢的没有列在这里,如果你有一个好的理由,一定要让我们知道,在下面的评论中使它脱颖而出吧。
接下来这四个bug问题跟踪管理软件的极佳备选全部开源、易于下载自己就可以部署。先说好我们可能没有办法在这里列出每一个问题跟踪工具相反我们列出这四个原因基于是其丰富的功能和项目背后的社区规模。当然,肯定还有其他类似软件,如果你喜欢的没有列在这里,如果你有一个好的理由,一定要让我们知道,在下面的评论中使它脱颖而出吧。
## Redmine
@ -15,7 +15,7 @@
Redmine的设置相当灵活支持多种数据库后端和几十种语言还是可定制的可以向问题issue、用户、工程等添加自定义字段。通过社区创建的插件和主题它可以进一步定制。
如果你想试一试,一个[在线演示](http://demo.redmine.org/)可提供使用。Redmine在开源[GPL版本2](http://www.gnu.org/licenses/old-licenses/gpl-2.0.en.html)许可;开源代码可以在工程的[svn仓库](https://svn.redmine.org/redmine)或在[GitHub](https://github.com/redmine/redmine)镜像上找到。
如果你想试一试,一个[在线演示](http://demo.redmine.org/)可提供使用。Redmine采用[GPL版本2](http://www.gnu.org/licenses/old-licenses/gpl-2.0.en.html)许可;开源代码可以在工程的[svn仓库](https://svn.redmine.org/redmine)或在[GitHub](https://github.com/redmine/redmine)镜像上找到。
![](https://opensource.com/sites/default/files/images/business-uploads/issues-redmine.png)
@ -25,7 +25,7 @@ Redmine的设置相当灵活支持多种数据库后端和几十种语言
从通知到重复bug检测再到搜索共享Bugzilla拥有许多高级工具是一个功能更丰富的选项。Bugzilla拥有一套高级搜索系统以及全面的报表工具具有生成图表和自动化按计划生成报告的能力。像Redmine一样Bugzilla是可扩展和可定制的除了字段本身还能针对bug创建自定义工作流。它也支持多种后端数据库和自带的多语言支持。
Bugzilla[Mozilla公共许可证](https://en.wikipedia.org/wiki/Mozilla_Public_License)下许可,你可以读取他们的[未来路线图](https://www.bugzilla.org/status/roadmap.html)还有在官网尝试一个[示例服务](https://landfill.bugzilla.org/)
Bugzilla采用[Mozilla公共许可证](https://en.wikipedia.org/wiki/Mozilla_Public_License),你可以读取他们的[未来路线图](https://www.bugzilla.org/status/roadmap.html)还有在官网尝试一个[示例服务](https://landfill.bugzilla.org/)
![](https://opensource.com/sites/default/files/images/business-uploads/issues-bugzilla.png)
@ -35,7 +35,7 @@ Bugzilla在[Mozilla公共许可证](https://en.wikipedia.org/wiki/Mozilla_Public
由python编写的Trac将其漏洞跟踪能力与它的wiki系统和版本控制系统轻度整合。项目管理能力突出如生成里程碑和路线图一个可定制的报表系统大事记支持多资源库内置的垃圾邮件过滤还可以使用很多通用语言。如其他我们已经看到的漏洞追踪软件有很多插件可进一步扩展其基本特性。
Trac是在改进的[BSD许可](http://trac.edgewall.org/wiki/TracLicense)下获得开放源码许可虽然更老的版本发布在GPL下。你可以在一个[自托管仓库](http://trac.edgewall.org/browser)预览Trac的源码或者查看他们的[路线图](http://trac.edgewall.org/wiki/TracRoadmap)对未来的规划。
Trac以[改进的BSD许可协议](http://trac.edgewall.org/wiki/TracLicense)开源虽然更老的版本发布在GPL下。你可以在一个[自托管仓库](http://trac.edgewall.org/browser)预览Trac的源码或者查看他们的[路线图](http://trac.edgewall.org/wiki/TracRoadmap)对未来的规划。
![](https://opensource.com/sites/default/files/images/business-uploads/issues-trac.png)
@ -43,11 +43,11 @@ Trac是在改进的[BSD许可](http://trac.edgewall.org/wiki/TracLicense)下获
[Mantis](https://www.mantisbt.org/)是这次合集中我们将看到的最后一个工具基于PHP且有16年历史。作为另一个支持多种不同版本控制系统和事件驱动通知系统的bug跟踪管理软件Mantis有一个与其他工具类似的功能设置。虽然它不本身包含wiki但它整合了很多流行的wiki平台且本地化到多种语言。
Mantis[GPL版本2](http://www.gnu.org/licenses/old-licenses/gpl-2.0.en.html)下获得开源许可证书;你可以在[GitHub](https://github.com/mantisbt/mantisbt)浏览他的源代码或查看自托管[路线图](https://www.mantisbt.org/bugs/roadmap_page.php?project=mantisbt&version=1.3.x)对未来的规划。一个示例,你可以查看他们的内部[漏洞跟踪](https://www.mantisbt.org/bugs/my_view_page.php)。
Mantis使用[GPL版本2](http://www.gnu.org/licenses/old-licenses/gpl-2.0.en.html)开源许可证书;你可以在[GitHub](https://github.com/mantisbt/mantisbt)浏览他的源代码或查看自托管[路线图](https://www.mantisbt.org/bugs/roadmap_page.php?project=mantisbt&version=1.3.x)对未来的规划。一个示例,你可以查看他们的内部[漏洞跟踪](https://www.mantisbt.org/bugs/my_view_page.php)。
![](https://opensource.com/sites/default/files/images/business-uploads/issues-mantis.png)
正如我们指出的,这四个不是唯一的选项。想要探索更多?[Apache Bloodhound](https://issues.apache.org/bloodhound/)[Fossil](http://fossil-scm.org/index.html/doc/trunk/www/index.wiki)[The Bug Genie](http://www.thebuggenie.com/),还有很多可替换品都有专注的追随者,每个都有不同的优点和缺点。另外,一些工具在我们[项目管理](https://opensource.com/business/15/1/top-project-management-tools-2015)摘要有问题跟踪功能。所以哪个是你首选的跟踪和碾压bug的工具
正如我们指出的,这四个不是唯一的选项。想要探索更多?[Apache Bloodhound](https://issues.apache.org/bloodhound/)[Fossil](http://fossil-scm.org/index.html/doc/trunk/www/index.wiki)[The Bug Genie](http://www.thebuggenie.com/),还有很多可替换品都有自己的忠实追随者,每个都有不同的优点和缺点。另外,一些工具在我们[项目管理](https://opensource.com/business/15/1/top-project-management-tools-2015)摘要有问题跟踪功能。所以哪个是你首选的跟踪和碾压bug的工具
------------------------------------------------------------------------------

View File

@ -1,21 +1,20 @@
NXP 揭幕了一块超小型物联网64位ARM处理器
NXP 发布了一块超小型物联网64位 ARM 处理器
=========================================================================
**标签**:[ARM][1], [物联网][2], [NXP][3], [NXP 半导体][4]
![](http://1u88jj3r4db2x4txp44yqfj1.wpengine.netdna-cdn.com/wp-content/uploads/2016/02/nxp-930x556.jpg)
[NXP 半导体][5]揭幕了一块声称世界上最小的用于物联网(IoT)的低功耗64位ARM处理器。
[NXP 半导体][5]发布了一块声称世界上最小的用于物联网(IoT)的低功耗64位ARM处理器。
这片小型的QorIQ LS1012A为电池供电大小受限的应用提供了网络级的安全和性能加速。这包括了运行物联网应用或者任何智能及可连接的设备。如果物联网能在2020达到1.7万亿美金的潜力由IDC研究员估算市场得出那么它将需要像NXP这样的处理器该处理器在德国纽伦堡的Embedded World 2016 上揭开了什么的面纱。
这片小型的QorIQ LS1012A为电池供电大小受限的应用提供了网络级的安全和性能加速。这包括了运行物联网应用或者任何智能及可连接的设备。如果物联网能在2020达到1.7万亿美金的潜力由IDC研究员估算市场得出那么它将需要像NXP这样的处理器该处理器在德国纽伦堡的Embedded World 2016 上揭开了什么的面纱。
该芯片带有64位ARMv8芯片拥有网络包加速及内置的安全。它占用9.6平方毫米的空间并且大约消耗1瓦特的电力。潜在的应用包括下一代的物联网网关、可携带娱乐平台、高性能可携带存储应用、移动硬盘、相机的移动存储、平板及其他可充电的设备。
除此之外LS1012A是第一款为新起的基于对象的存储方案设计的处理器基于对象存储基于智能硬盘,它直接连接到以太网数据中心。处理器必须足够小才能直接集成在硬盘的集成电路上。
除此之外LS1012A是第一款为起的基于对象的存储方案设计的处理器,基于对象存储通过智能硬盘直接连接到以太网数据中心。处理器必须足够小才能直接集成在硬盘的集成电路上。
NXP的高级副总裁及数字网络部的经理Tareq Bustami说“低功耗、占用空间小及网络级性能这些突破性组合的NXP LS1012处理器是消费者、物联网相关应用的理想选择。独有的混合能力解放了物联网设计者及开发者使得他们可以在这个高增长的市场中想象并创造更多创新产品。”
NXP的高级副总裁及数字网络部的经理Tareq Bustami说突破性组合了低功耗、占用空间小及网络级性能的NXP LS1012处理器是消费者、物联网相关应用的理想选择。独有地将这些能力结合到一起解放了物联网设计者及开发者,使得他们可以在这个高增长的市场中设计并创造更多创新产品。”
NXP说这是唯一一个能够结合全面的高速外围在一个芯片中的1瓦特、64位处理器这意味着低系统功耗。归功于创新的封装该处理器可以在低成本的电路板中布线
NXP说这是唯一一个1瓦特功耗、64位的、并将这些高速外设综合到一个芯片中的处理器这意味着更低的系统级功耗。归功于创新性的封装该处理器可以运用在低成本的电路板中
NXP的LS1012A可以在2016年4月开始发货并且现在可以订货。NXP在全球35个国家拥有超过4,5000名员工。
@ -25,7 +24,7 @@ via: http://venturebeat.com/2016/02/21/nxp-unveils-a-small-and-tiny-64-bit-arm-p
作者:[DEAN TAKAHASHI][a]
译者:[geekpi](https://github.com/geekpi)
校对:[校对者ID](https://github.com/校对者ID)
校对:[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译,[Linux中国](https://linux.cn/) 荣誉推出

View File

@ -0,0 +1,48 @@
新的 Docker 数据中心管理套件使容器化变得更加井然有序
===============================================================================
![](https://tctechcrunch2011.files.wordpress.com/2016/02/shutterstock_119411227.jpg?w=738)
[Docker][1]之前发布了一个新的容器控制中心称为Docker数据中心DDC其设计目的是用于大型和小型企业创建、管理和分发容器的一个集成管理控制台。
DDC是由包括Docker Universal Control Plane也是同时发布的和Docker Trusted Registry等不同的商业组件组成。它也包括了开源组件比如Docker Engine。这个产品让企业在一个中心管理界面中就可以管理整个Docker化程序的生命周期。
负责产品管理的SVP Scott Johnston告诉TechCrunch“客户催使了这个新工具的产生。公司不仅喜欢Docker给他们带来的敏捷性它们也希望在创建和分发容器的过程中可以进行对安全和管理进行控制。”
Johnston说“公司称这个为容器即服务Caas主要是因为当客户来询问这种类型的管理面板时他们是这样描述的。”
![](https://tctechcrunch2011.files.wordpress.com/2016/02/screen-shot-2016-02-23-at-7-56-54-am.png?w=680&h=401)
像许多开源项目那样Docker首先获得了许多开发者的追随但是随着它的流行那些开发者们所在的公司也希望积极推进它的使用。
这就是DDC设计的目的。它给开发者创建容器化应用的敏捷性也让运维变得井井有条。
实际上这意味着开发者可以创建一系列容器化的组件,将其部署后就可以访问一个完全认证的镜像库。这可以让开发人员用碎片组成应用而不必每次重新发明轮子。这可以加速应用的开发和部署(理论上提升了容器提供的灵活性)。
这方面吸引了Beta客户ADP。这个服务特别喜欢将这个提供给开发人员的中心镜像仓库。
ADP的CTO Keith Fulton在声明中称“作为我们将关键业务微服务化倡议的一部分ADP正在研究能够让开发人员可以利用IT审核过的中央库和安全的核心服务进行快速迭代的方案。”
Docker在2010年由dotcloud的Solomon Hykes发布。他在2013年将公司的重心移到Docker上并在[8月出售了dotCloud][2]2014年完全聚焦在Docker上。
根据CrunchBase的消息公司几年来在5轮融资后势如破竹般获得了1亿8000万美元融资自从成为Docker后获得了1亿6千8百万美元。吸引投资者关注的是Docker提供了一种称为容器的现在分发应用的方式可以构建、管理何分发分布式应用。
容器化可以让开发者创建由多个分布在不同服务器上的碎片组成的分布式应用,而不是一个运行在一个单独服务器上的独立应用。
DDC服务每月每节点150美金起。
--------------------------------------------------------------------------------
via: http://techcrunch.com/2016/02/23/new-docker-data-center-admin-suite-should-bring-order-to-containerization/
作者:[Ron Miller][a]
译者:[geekpi](https://github.com/geekpi)
校对:[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译,[Linux中国](https://linux.cn/) 荣誉推出
[a]:http://techcrunch.com/author/ron-miller/
[1]: https://www.docker.com/
[2]: http://techcrunch.com/2014/08/04/docker-sells-dotcloud-to-cloudcontrol-to-focus-on-core-container-business/

View File

@ -68,7 +68,7 @@
via: https://opensource.com/business/16/2/add-open-source-to-your-resume
作者:[edunham][a]
译者:[pengkai](https://github.com/pengkai)
译者:[kylepeng93](https://github.com/kylepeng93)
校对:[mudongliang](https://github.com/mudongliang)[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译,[Linux中国](https://linux.cn/) 荣誉推出

View File

@ -0,0 +1,53 @@
NodeOSNode 爱好者的 Linux 发行版
================================================
![](http://itsfoss.com/wp-content/uploads/2016/05/node-os-linux.jpg)
[NodeOS][1] 是一款基于 [Node.js][2] 的操作系统,自去年其首个[发布候选版][3]之后正朝着它的1.0版本进发。
如果你之前不知道的话NodeOS 是首个架构在 [Linux][5] 内核之上的由 Node.js 和 [npm][4] 驱动的操作系统。[Jacob Groundwater][6] 在2013年中期介绍了这个项目。该操作系统中用到的主要技术是
- **Linux 内核**: 这个系统建造在 Linux 内核上
- **Node.js 运行时**: Node 作为主要的运行时环境
- **npm 包管理**: npm 作为包管理
NodeOS 源码托管在 [Github][7] 上,因此,任何感兴趣的人都可以轻松贡献或者报告 bug。用户可以从源码构建或者使用[预编译镜像][8]。构建过程及快速起步指南可以在项目仓库中找到。
NodeOS 背后的思想是提供足够 npm 运行的环境,剩余的功能就可以让 npm 包管理来完成。因此,用户可以使用多达大约 250,000 个软件包,并且这个数目每天都还在增长。所有的都是开源的,你可以根据你的需要很容易地打补丁或者增加更多的包。
NodeOS 核心开发被分离成了不同的层面,基本的结构包含:
- **barebones** 带有可以启动到 Node.js REPL 的 initramfs 的自定义内核
- **initramfs** 用于挂载用户分区以及启动系统的 initram 文件系统
- **rootfs** 存放 linux 内核及 initramfs 文件的只读分区
- **usersfs** 多用户文件系统(如传统系统一样)
NodeOS 的目标是可以在任何平台上运行,包括: **实际的硬件(用户计算机或者 SoC**、**云平台、虚拟机、PaaS 提供商,容器**Docker 和 Vagga等等。如今看来它做得似乎不错。在3.3号NodeOS 的成员 [Jesús Leganés Combarro][9] 在 Github上[宣布][10]
>**NodeOS 不再是一个玩具系统了**,它现在开始可以用在有实际需求的生产环境中了。
因此,如果你是 Node.js 的死忠或者乐于尝试新鲜事物,这或许值得你一试。在相关的文章中,你应该了解这些[Linux 发行版的具体用法][11]
--------------------------------------------------------------------------------
via: http://itsfoss.com/nodeos-operating-system/
作者:[Munif Tanjim][a]
译者:[geekpi](https://github.com/geekpi)
校对:[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译,[Linux中国](https://linux.cn/) 荣誉推出
[a]: http://itsfoss.com/author/munif/
[1]: http://node-os.com/
[2]: https://nodejs.org/en/
[3]: https://github.com/NodeOS/NodeOS/releases/tag/v1.0-RC1
[4]: https://www.npmjs.com/
[5]: http://itsfoss.com/tag/linux/
[6]: https://github.com/groundwater
[7]: https://github.com/nodeos/nodeos
[8]: https://github.com/NodeOS/NodeOS/releases
[9]: https://github.com/piranna
[10]: https://github.com/NodeOS/NodeOS/issues/216
[11]: http://itsfoss.com/weird-ubuntu-based-linux-distributions/

View File

@ -0,0 +1,61 @@
将 Linux 软件打包成 Snap 软件包
================
![](https://insights.ubuntu.com/wp-content/uploads/27eb/app-snap.png)
在 Linux 分发应用不总是那么容易。有各种不同的包格式、基础系统、可用库随着发行版的一次次发布所有的这些都让人头疼。然而现在我们有了更简单的东西Snap。
Snap 是开发者打包他们应用的新途径,它相对于传统包格式,如 .deb.rpm 等带来了许多优点。Snap 安全,彼此隔离,宿主系统使用了类似 AppArmor 的技术,它们跨平台且自足的,让开发者可以准确地将应用所需要的依赖打包到一起。沙盒隔离也加强了安全,并允许应用和整个基于 snap 的系统在出现问题的时候可以回滚。Snap 确实是 Linux 应用打包的未来。
创建一个 snap 包并不困难。首先,你需要一个 snap 基础运行环境,能够让你的桌面环境认识并运行 snap 软件包,这个工具叫做 snapd ,默认内置于所有 Ubuntu 16.04 系统中。接着你需要创建 snap 的工具 Snapcraft它可以通过一个简单的命令安装
```
$ sudo apt-get install snapcraft
```
这个环境安装好了之后就可以 snap 起来了。
Snap 使用一个特定的 YAML 格式的文件 snapcraft.yaml它定义了应用是如何打包的以及它需要的依赖。用一个简单的应用来演示一下下面的 YAML 文件是个如何 snap 一个 moon-buggy 游戏的实际例子,该游戏在 Ubuntu 源中提供。
```
name: moon-buggy
version: 1.0.51.11
summary: Drive a car across the moon
description: |
A simple command-line game where you drive a buggy on the moon
apps:
play:
command: usr/games/moon-buggy
parts:
moon-buggy:
plugin: nil
stage-packages: [moon-buggy]
snap:
usr/games/moon-buggy
```
上面的代码出现了几个新概念。第一部分是关于如何让你的应用可以在商店找到的信息设置软件包的元数据名称、版本号、摘要、以及描述。apps 部分实现了 play 命令,指向了 moon-buggy 可执行文件位置。parts 部分告诉 snapcraft 用来构建应用所需要的插件以及依赖的包。在这个简单的例子中我们需要的所有东西就是来自 Ubuntu 源中的 moon-buggy 应用本身snapcraft 负责剩下的工作。
在你的 snapcraft.yaml 所在目录下运行 snapcraft ,它会创建 moon-buggy_1.0.51.11_amd64.snap 包,可以通过以下命令来安装它:
```
$ snap install moon-buggy_1.0.51.11_amd64.snap
```
想了解更复杂一点的 snap 打包操作,比如基于 Electron 的 Simplenote 可以[看这里][1],在线教程在[这里][2],相应的代码在 [Github][3]。更多的例子可以在 Ubuntu 开发者[站点][4]找到。
--------------------------------------------------------------------------------
via: https://insights.ubuntu.com/2016/06/01/apps-to-snaps/
作者:[Jamie][a]
译者:[alim0x](https://github.com/alim0x)
校对:[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译,[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://insights.ubuntu.com/author/jamiebennett/
[1]: http://www.simplenote.com/
[2]: http://www.linuxuk.org/post/20160518_snapping_electron_based_applications_simplenote/
[3]: https://github.com/jamiedbennett/snaps/tree/master/simplenote
[4]: https://developer.ubuntu.com/en/desktop/get-started/

View File

@ -0,0 +1,160 @@
在 Linux 下使用 scp 命令
=======================
![](https://www.unixmen.com/wp-content/uploads/2016/05/SCP-LOGO-1.jpg)
scp 是安全拷贝协议 Secure Copy Protocol的缩写和众多 Linux/Unix 使用者所熟知的拷贝cp命令一样。scp 的使用方式类似于 cp 命令cp 命令将一个文件或文件夹从本地操作系统的一个位置(源)拷贝到目标位置(目的),而 scp 用来将文件或文件夹从网络上的一个主机拷贝到另一个主机当中去。
scp 命令的使用方法如下所示,在这个例子中,我将一个叫 “importantfile” 的文件从本机10.10.16.147拷贝到远程主机10.0.0.6中。在这个命令里你也可以使用主机名字来替代IP地址。
```
[root@localhost ~]# scp importantfile admin@10.0.0.6:/home/admin/
The authenticity of host '10.0.0.6 (10.0.0.6)' can't be established.
RSA key fingerprint is SHA256:LqBzkeGa6K9BfWWKgcKlQoE0u+gjorX0lPLx5YftX1Y.
RSA key fingerprint is MD5:ed:44:42:59:3e:dd:4c:12:43:4a:89:b1:5d:bd:9e:20.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '10.0.0.6' (RSA) to the list of known hosts.
admin@10.0.0.6's password:
importantfile 100% 0 0.0KB/s 00:00
[root@localhost ~]#
```
类似的,如果你想从一个远程主机中取得文件,你可以利用如下的 scp 命令。
```
[root@localhost ~]# scp root@10.10.16.137:/root/importantfile /home/admin/
The authenticity of host '10.10.16.137 (10.10.16.137)' can't be established.
RSA key fingerprint is b0:b0:a3:c3:2e:94:13:0c:29:2e:ba:0b:d3:d6:12:8f.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '10.10.16.137' (RSA) to the list of known hosts.
root@10.10.16.137's password:
importantfile 100% 0 0.0KB/s 00:00
[root@localhost ~]#
```
你也可以像 cp 命令一样,在 scp 命令中使用不同的选项scp 的 man 帮助详细地阐述了不同选项的用法和用处。
**示例输出**
![](https://www.unixmen.com/wp-content/uploads/2016/05/scp.jpg)
scp 可选参数如下所示:
-B 采取批量模式(避免询问密码或口令)
-C 启用压缩。通过指明 -C 参数来开启压缩模式。
-c 加密方式
选择在传输过程中用来加密的加密方式 这个选项会被直接传递到 ssh(1)。
-F ssh 配置
给 ssh 指定一个用来替代默认配置的配置文件。这个选项会被直接传递到 ssh(1)。
-l 限速
限制命令使用的带宽,默认单位是 Kbit/s。
-P 端口
指定需要的连接的远程主机的端口。
注意这个选项使用的是一个大写的“P”因为小写的“-p”已经用来保留目标文件的时间和模式相关信息。LCTT 译注ssh 命令中使用小写的“-p”来指定目标端口。
-p 保留文件原来的修改时间,访问时间以及权限模式。
-q 静默模式:不显示来自 ssh(1) 命令的进度信息,警告和诊断信息。
-r 递归拷贝整个目录。
注意scp 命令在树形遍历的时候同样会跟随符号连接,复制所连接的文件。
-v 详细模式。scp 和 ssh(1) 将会打印出处理过程中的调试信息。这可以帮助你调试连接、认证和配置方面的问题。
**详细模式**
利用 scp 命令的 -v 选项,你可以得到认证、调试等的相关细节信息。
![](http://www.unixmen.com/wp-content/uploads/2016/05/scp-v.jpg)
当我们使用 -v 选项的时候,一个简单的输出如下所示:
```
[root@localhost ~]# scp -v abc.txt admin@10.0.0.6:/home/admin
Executing: program /usr/bin/ssh host 10.0.0.6, user admin,
command scp -v -t/home/admin
OpenSSH_7.1p1, OpenSSL 1.0.2d-fips 9 Jul 2015
debug1: Reading configuration data /etc/ssh/ssh_config
debug1: /etc/ssh/ssh_config line 56: Applying options for *
debug1: Connecting to 10.0.0.6 [10.0.0.6] port 22.
debug1: Connection established.
debug1: Server host key: ssh-rsa SHA256:LqBzkeGa6K9BfWWKgcKlQoE0u+gjorX0lPLx5YftX1Y
debug1: Next authentication method: publickey
debug1: Trying private key: /root/.ssh/id_rsa
debug1: Trying private key: /root/.ssh/id_dsa
debug1: Trying private key: /root/.ssh/id_ecdsa
debug1: Trying private key: /root/.ssh/id_ed25519
debug1: Next authentication method: password
admin@10.0.0.6's password:
debug1: Authentication succeeded (password).
Authenticated to 10.0.0.6 ([10.0.0.6]:22).
debug1: channel 0: new [client-session]
debug1: Requesting no-more-sessions@openssh.com
debug1: Entering interactive session.
debug1: Sending environment.
debug1: Sending command: scp -v -t /home/admin
Sending file modes: C0644 174 abc.txt
Sink: C0644 174 abc.txt
abc.txt 100% 174 0.2KB/s 00:00
Transferred: sent 3024, received 2584 bytes, in 0.3 seconds
Bytes per second: sent 9863.3, received 8428.1
debug1: Exit status 0
[root@localhost ~]#
```
当我们需要拷贝一个目录或者文件夹的时候,我们可以使用 -r 选项,它会递归拷贝整个目录。
![](http://www.unixmen.com/wp-content/uploads/2016/05/scp-with-r.jpg)
**静默模式**
如果你想要关闭进度信息以及警告和诊断信息你可以通过使用scp命令中的-q选项.
![](http://www.unixmen.com/wp-content/uploads/2016/05/scp-with-q.jpg)
上一次我们仅仅使用 -r 参数,它显示了逐个文件的信息,但这一次当我们使用了 -q 参数,它就不显示进度信息。
利用 scp 的 -p 选项来保留目标文件的更新时间,访问时间和权限模式。
![](http://www.unixmen.com/wp-content/uploads/2016/05/scp-with-p.jpg)
**通过 -P 选项来指定远程主机的连接端口**
scp 使用 ssh 命令来在两个主机之间传输文件,因为 ssh 默认使用的是22端口号所以 scp 也使用相同的22端口号。
如果我们希望改变这个端口号,我们可以使用 -P大写的 P因为小写的 p 用来保持文件的访问时间等)选项来指定所需的端口号。
举个例子如果我们想要使用2222端口号我们可以使用如下的命令
```
[root@localhost ~]# scp -P 2222 abcd1 root@10.10.16.137:/root/
```
**限制命令使用的带宽,指定的单位是 Kbit/s**
如下所示,我们可以使用 -l 参数来指定 scp 命令所使用的带宽在此我们将速度限制为512kbit/s。
![](http://www.unixmen.com/wp-content/uploads/2016/05/scp-with-l.jpg)
**开启压缩**
如下所示,我们可以通过开启 scp 命令的压缩模式来节省传输过程中的带宽和时间。
![](https://www.unixmen.com/wp-content/uploads/2016/05/scp-with-C.jpg)
**选择加密数据的加密方式**
scp 默认使用 AES-128 的加密方式,如果我们想要改变这个加密方式,可以通过 -c(小写的 c) 参数来指定其他的加密方式。
![](http://www.unixmen.com/wp-content/uploads/2016/05/scp-with-cipher.jpg)
现在你可以利用 scpSecure copy命令在你所属网络中的两个节点之间安全地拷贝文件了。
--------------------------------------------------------------------------------
via: https://www.unixmen.com/scp-command-linuxunix/
作者:[Naga Ramesh][a]
译者:[lujianbo](https://github.com/lujianbo)
校对:[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译,[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://www.unixmen.com/author/naga/

View File

@ -1,27 +1,26 @@
GHLandy Translated
LFCS 系列第八讲:管理用户和用户组、文件权限和属性以及启用账户 sudo 访问权限
================================================================================
去年八月份Linux 基金会发起了全新的 LFCSLinux Foundation Certified SysadminLinux 基金会认证系统管理员)认证,旨在让世界各地的人能够参与到关于 Linux 系统中间层的基本管理操作的认证考试中去,这项认证包括:维护正在运行的系统和服务的能力、全面监控和分析的能力以及何时向上游团队请求支持的决策能力。
去年八月份Linux 基金会发起了全新的 LFCSLinux Foundation Certified SysadminLinux 基金会认证系统管理员)认证,旨在让世界各地的人能够参与到中等水平的 Linux 系统的基本管理操作的认证考试中去,这项认证包括:维护正在运行的系统和服务的能力、全面监控和分析的能力以及何时向上游团队请求支持的决策能力。
![Linux Users and Groups Management](http://www.tecmint.com/wp-content/uploads/2014/10/lfcs-Part-8.png)
LFCS 系列第八讲
*第八讲: Linux 基金会认证系统管理员*
请看以下视频,里边将描述 LFCS 认证程序。
youtube视频
<iframe width="720" height="405" frameborder="0" allowfullscreen="allowfullscreen" src="//www.youtube.com/embed/Y29qZ71Kicg"></iframe>
本讲是《十套教程》系列的第八讲,在这一讲中,我们将引导你学习如何在 Linux 管理用户和用户组权限的设置,这些内容是 LFCS 认证开始中的必备知识。
本讲是系列教程的第八讲,在这一讲中,我们将引导你学习如何在 Linux 管理用户和用户组权限的设置,这些内容是 LFCS 认证的必备知识。
由于 Linux 是一个多用户的操作系统(允许多个用户通过不同主机或者终端访问一个独立系统),因此你需要知道如何才能有效地管理用户:如何添加、编辑、禁用和删除用户账户,并赋予他们足以完成自身任务的必要权限。
LCTT 译注:本篇原文章节顺序有误,根据理解做了调整。)
### 添加用户账户 ###
添加新用户账户,你需要以 root 运行下两条命令中的任意一条:
添加新用户账户,你需要以 root 运行下两条命令中的任意一条:
# adduser [new_account]
# useradd [new_account]
@ -29,43 +28,43 @@ LFCS 系列第八讲
当新用户账户添加到系统时,会自动执行以下操作:
1. 自动创建用户家目录(默认是 /home/username
2. 自动拷贝下列隐藏文件到新建用户的家目录,用来设置新用户会话的环境变量。
.bash_logout
.bash_profile
.bashrc
.bash_logout
.bash_profile
.bashrc
3. 自动创建邮件缓存目录 /var/spool/mail/username。
4. 自动创建于用户名相同的用户组。
**理解 /etc/passwd 中的内容**
####理解 /etc/passwd 中的内容####
/etc/passwd 文件中存储了所有用户账户的信息,每个用户在里边都有一条对应的记录,其格式(每个字段用冒号隔开)如下:
[username]:[x]:[UID]:[GID]:[Comment]:[Home directory]:[Default shell]
- 字段 [username] 和 [Comment] 是自解释的关系
- 字段 [username] 和 [Comment] 是不言自明的
- 第二个字段中 x 表明通过用户名 username 登录系统是有密码保护的, 密码保存在 /etc/shadow 文件中。
- [UID] 和 [GID] 字段用整数表示,代表该用户的用户标识符和对应所在组的组标志符。
- 字段 [Home directory] 为 username 用户家目录的绝对路径。
- 字段 [Default shell] 指定用户登录系统时默认使用的 shell。
**理解 /etc/group 中的内容**
####理解 /etc/group 中的内容####
/etc/group 文件存储所有用户组的信息。每行记录的格式如下:
[Group name]:[Group password]:[GID]:[Group members]
- [Group name] 为用户组名称。
- 字段 [Group password] 为 x 的话,则说明不用用户组密码。
- 字段 [Group password] 为 x 的话,则说明不使用用户组密码。
- [GID] 与 /etc/passwd 中保存的 GID 相同。
- [Group members] 用户组中的用户使用逗号隔开。
![Add User Accounts in Linux](http://www.tecmint.com/wp-content/uploads/2014/10/add-user-accounts.png)
添加用户账户
*添加用户账户*
#### 修改用户信息 ####
添加用户账户之后,你可以使用 usermod 命令来修改用户信息中的部分字段,该命令基本语法如下:
@ -95,24 +94,21 @@ LFCS 系列第八讲
# usermod --shell /bin/sh tecmint
**显示用户所属的用户组**
# groups tecmint
# id tecmint
下面,我们一次运行上述命令:
# usermod --expiredate 2014-10-30 --append --groups root,users --home /tmp --shell /bin/sh tecmint
![usermod Command Examples](http://www.tecmint.com/wp-content/uploads/2014/10/usermod-command-examples.png)
usermod 命令例示
*usermod 命令例示*
扩展阅读
- [15 useradd Command Examples in Linux][1]
- [15 usermod Command Examples in Linux][2]
####锁定和解锁账户####
对于已有用户账户,我们还可以:
**通过锁定密码来禁用账户**
@ -129,33 +125,9 @@ usermod 命令例示
![Lock User in Linux](http://www.tecmint.com/wp-content/uploads/2014/10/lock-user-in-linux.png)
锁定用户账户
*锁定用户账户*
**为需要对指定文件进行读写的多个用户建立用户组**
运行下列几条命令来完成:
# groupadd common_group # 添加新用户组
# chown :common_group common.txt # 将 common.txt 的用户组修改为 common_group
# usermod -aG common_group user1 # 添加用户 user1 到 common_group 用户组
# usermod -aG common_group user2 # 添加用户 user2 到 common_group 用户组
# usermod -aG common_group user3 # 添加用户 user3 到 common_group 用户组
**删除用户组**
通过以下命令删除用户组:
# groupdel [group_name]
属于这个 group_name 用户组的文件是不会被删除的,而仅仅是删除了用户组。
### Linux 文件权限 ###
除了我们在 [Setting File Attributes Part 3][3] 中说到的基本的读取、写入和执行权限外,文件还有一些不常用却很重要的的权限设置,有时候把它当做“特殊权限”。
就像之前我们讨论的基本权限,这里同样使用八进制数字或者一个字母(象征性符号)好表示该权限类型。
**删除用户账户**
####删除用户账户####
你可以通过 userdel --remove 命令来删除用户账户。这样会删除用户拥有的家目录和家目录下的所有文件,以及邮件缓存目录。
@ -167,9 +139,9 @@ usermod 命令例示
比如,你有下列用户:
- user1 (primary group: user1)
- user2 (primary group: user2)
- user3 (primary group: user3)
- user1 (主组 user1)
- user2 (主组 user2)
- user3 (主组 user3)
他们都需要对你系统里边某个位置的 common.txt 文件,或者 user1 用户刚刚创建的共享进行读写。你可能会运行下列命令:
@ -181,53 +153,88 @@ usermod 命令例示
这时候,用户组就派上用场了,下面将演示怎么做。
**显示用户所属的用户组**
# groups tecmint
# id tecmint
**为需要对指定文件进行读写的多个用户建立用户组**
运行下列几条命令来完成:
# groupadd common_group # 添加新用户组
# chown :common_group common.txt # 将 common.txt 的用户组修改为 common_group
# usermod -aG common_group user1 # 添加用户 user1 到 common_group 用户组
# usermod -aG common_group user2 # 添加用户 user2 到 common_group 用户组
# usermod -aG common_group user3 # 添加用户 user3 到 common_group 用户组
####删除用户组####
通过以下命令删除用户组:
# groupdel [group_name]
属于这个 group_name 用户组的文件是不会被删除的,而仅仅是删除了用户组。
### Linux 文件权限 ###
除了我们在 [LFCS 系列第三讲:归档/压缩文件及目录、设置文件属性和搜索文件][3] 中说到的基本的读取、写入和执行权限外,文件还有一些不常用却很重要的的权限设置,有时候把它当做“特殊权限”。
就像之前我们讨论的基本权限,这里同样使用八进制数字或者一个字母(象征性符号)表示该权限类型。
**理解 Setuid 位**
当为可执行文件设置 setuid 位之后,用户运行程序是会继承该程序属主的有效特权。由于这样做会引起安全风险,因此设置 setuid 权限的文件及程序必须尽量少。你会发现,当系统中有用户需要执行 root 用户所管辖的程序时就是设置了 setuid 权限。
当为可执行文件设置 setuid 位之后,用户运行程序会继承该程序属主的有效特权。由于这样做会引起安全风险,因此设置 setuid 权限的文件及程序必须尽量少。你会发现,当系统中有用户需要访问属于 root 用户的文件是所运行的程序就带有了 setuid 权限。
也就是说,用户不仅仅可以运行这个可执行文件,而且能以 root 权限来运行。比如,先检查 /bin/passwd 的权限,这个可执行文件用于改变账户的密码,并修改 /etc/shadow 文件。超级用户可以改变任意账户的密码,但是其他用户只能改变自己账户的密码。
也就是说,用户不仅仅可以运行这个可执行文件,而且能以 root 权限来运行。比如,让我们来看看 /bin/passwd 的权限,这个可执行文件用于改变账户的密码,修改 /etc/shadow 文件。超级用户可以改变任意账户的密码,但是其他用户只能改变自己账户的密码。
![passwd Command Examples](http://www.tecmint.com/wp-content/uploads/2014/10/passwd-command.png)
passwd 命令例示
*passwd 命令例示*
因此,所有用户都有权限运行 /bin/passwd但只有 root 用户可以指定改变指定用户账户的密码。其他用户只能改变其自身的密码。
![Change User Password in Linux](http://www.tecmint.com/wp-content/uploads/2014/10/change-user-password.png)
修改用户密码
*修改用户密码*
# chmod o+u [filename]
以八进制形式来设置 setuid 位,在当前基本权限(或者想要设置的权限)前加上数字 4 就行了。
# chmod 4755 [filename]
**理解 Setgid 位**
设置 setgid 位之后,真实用户的有效 GID 变为属组的 GID。因此任何用户都能以赋予属组用户的权限来访问文件。另外当目录置了 setgid 位之后,新建的文件将继承其所属目录的 GID并且新建的子目录会继承父目录的 setgid 位。通过这个方法,你能够以一个指定用户组的身份来访问该目录里边的文件,而不必管文件属主的主属组。
设置 setgid 位之后,真实用户的有效 GID 变为属组的 GID。因此任何用户都能以属组用户的权限来访问文件。另外当目录置了 setgid 位之后,新建的文件将继承其所属目录的 GID并且新建的子目录会继承父目录的 setgid 位。通过这个方法,你能够以一个指定用户组身份来访问该目录里边的文件,而不必管文件属主的主属组。
# chmod g+s [filename]
以八进制形式来设置 setgid 位,在当前基本权限(或者想要设置的权限)前加上数字 2 就行了。
# chmod 2755 [directory]
# chmod 2755 [filename]
**给目录设置 SETGID 位**
**给目录设置 Setgid 位**
![Add Setgid in Linux](http://www.tecmint.com/wp-content/uploads/2014/10/add-setgid-to-directory.png)
给命令设置 setgid 位
*给命令设置 setgid 位*
**理解 Sticky 位**
**理解黏连Sticky位**
文件设置了 Sticky 为之后Linux 会将文件忽略,对于该文件影响到的目录,除了属主或者 root 用户外,其他用户无法删除,甚至重命名目录中其他文件也不行
文件设置了黏连Sticky位是没有意义Linux 会忽略该位。如果设置到目录上,会防止其内的文件被删除或改名,除非你是该目录或文件的属主、或者是 root 用户
# chmod o+t [directory]
# chmod o+t [directory]
以八进制形式来设置 sticky 位,在当前基本权限(或者想要设置的权限)前加上数字 1 就行了。
# chmod 1755 [directory]
# chmod 1755 [directory]
若没有 sticky 位任何有权限读写目录的用户都可删除和重命名文件。因此sticky 为通常出现在像 /tmp 之类的目录,这些目录是所有人都具有写权限的。
若没有黏连位,任何有权限读写目录的用户都可删除和重命名其中的文件。因此,黏连位通常出现在像 /tmp 之类的目录,这些目录是所有人都具有写权限的。
![Add Stickybit in Linux](http://www.tecmint.com/wp-content/uploads/2014/10/add-sticky-bit-to-directory.png)
给目录设置 sticky 位
*给目录设置黏连位*
### Linux 特殊文件属性 ###
@ -240,7 +247,7 @@ passwd 命令例示
![Protect File from Deletion](http://www.tecmint.com/wp-content/uploads/2014/10/chattr-command.png)
通过 Chattr 命令来包含文件
*通过 Chattr 命令来包含文件*
### 访问 root 账户并启用 sudo ###
@ -251,15 +258,16 @@ passwd 命令例示
然后输入 root 账户密码。
倘若授权成功,你将以 root 身份登录,工作目录则是登录前所在的位置。如果是想要一登录就自动进入 root 用户的家目录,请运行:
$ su -
然后输入 root 账户密码。
![Enable sudo Access on Linux](http://www.tecmint.com/wp-content/uploads/2014/10/Enable-Sudo-Access.png)
![switch user by su ](http://www.tecmint.com/wp-content/uploads/2014/10/Enable-Sudo-Access.png)
为用户启用 sudo 访问权限
*用户通过 su 切换*
执行上个步骤需要普通用户知道 root 账户的密码,这样会引起非常严重的安全问题。于是,系统管理员通常会配置 sudo 命令来让普通用户在严格控制的环境中以其他用户身份(通常是 root来执行命令。所,可以在严格控制用户的情况下,又允许他运行一条或多条特权命令。
执行上个步骤需要普通用户知道 root 账户的密码,这样会引起非常严重的安全问题。于是,系统管理员通常会配置 sudo 命令来让普通用户在严格控制的环境中以其他用户身份(通常是 root来执行命令。所,可以在严格控制用户的情况下,又允许他运行一条或多条特权命令。
- 扩展阅读:[Difference Between su and sudo User][5]
@ -269,7 +277,7 @@ passwd 命令例示
# visudo
这样会使用 vim如果你按照 [Install and Use vim as Editor Part 2][6] 里边说的来编辑文件)来打开 /etc/sudoers 文件。
这样会使用 vim你可以按照 [LFCS 系列第二讲:如何安装和使用纯文本编辑器 vi/vim][6] 里边说的来编辑文件)来打开 /etc/sudoers 文件。
以下是需要设置的相关的行:
@ -283,19 +291,19 @@ passwd 命令例示
Defaults secure_path="/usr/sbin:/usr/bin:/sbin:/usr/local/bin"
这一行指定 sudo 将要使用的目录,这样可以阻止使用用户指定的目录,那样的话可能会危及系统。
这一行指定 sudo 将要使用的目录,这样可以阻止使用某些用户指定的目录,那样的话可能会危及系统。
下一行是用来指定权限的:
root ALL=(ALL) ALL
- 第一个 ALL 关键词表明这条规则适用于所有主机。
- 第二个 ALL 关键词表明第一个字段中指定的用户能以任何用户身份所具有的权限来运行相应命令。
- 第二个 ALL 关键词表明第一个字段中指定的用户能以任何用户身份的权限来运行相应命令。
- 第三个 ALL 关键词表明可以运行任何命令。
tecmint ALL=/bin/yum update
如果 = 号后边没有指定用户sudo 则默认为 root 用户。本例中tecmint 用户能以 root身份运行 yum update 命令。
如果 = 号后边没有指定用户sudo 则默认为 root 用户。本例中tecmint 用户能以 root 身份运行 yum update 命令。
gacanepa ALL=NOPASSWD:/bin/updatedb
@ -303,16 +311,17 @@ NOPASSWD 关键词表明 gacanepa 用户不需要密码,可以直接运行 /bi
%admin ALL=(ALL) ALL
% 符号表示该行应用 admin 用户组。其他部分的含义与对于用户的含义是一样的。本例表示 admin 用户组的成员可以通过任何主机的链接来运行任何命令。
% 符号表示该行应用 admin 用户组。其他部分的含义与对于用户的含义是一样的。本例表示 admin 用户组的成员可以通过任何主机接来运行任何命令。
通过 sudo -l 命令可以查看,你的账户拥有什么样的权限。
![Sudo Access Rules](http://www.tecmint.com/wp-content/uploads/2014/10/sudo-access-rules.png)
Sudo 访问规则
*Sudo 访问规则*
### 总结 ###
对于系统管理员来说,高效能的用户和文件管理技能是非常必要的。本文已经涵盖了这些内容,我们希望你将这些作为一个开始,,然后慢慢进步。随时在下边发表评论或提问,我们会尽快回应的。
对于系统管理员来说,高效能的用户和文件管理技能是非常必要的。本文已经涵盖了这些内容,我们希望你将这些作为一个开始,然后慢慢进步。随时在下边发表评论或提问,我们会尽快回应的。
--------------------------------------------------------------------------------
@ -320,14 +329,14 @@ via: http://www.tecmint.com/manage-users-and-groups-in-linux/
作者:[Gabriel Cánepa][a]
译者:[GHLandy](https://github.com/GHLandy)
校对:[校对者ID](https://github.com/校对者ID)
校对:[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创翻译,[Linux中国](https://linux.cn/) 荣誉推出
[a]:http://www.tecmint.com/author/gacanepa/
[1]:http://www.tecmint.com/add-users-in-linux/
[2]:http://www.tecmint.com/usermod-command-examples/
[3]:http://www.tecmint.com/compress-files-and-finding-files-in-linux/
[3]:https://linux.cn/article-7171-1.html
[4]:http://www.tecmint.com/chattr-command-examples/
[5]:http://www.tecmint.com/su-vs-sudo-and-how-to-configure-sudo-in-linux/
[6]:http://www.tecmint.com/vi-editor-usage/
[6]:https://linux.cn/article-7165-1.html

View File

@ -0,0 +1,205 @@
LFCS 系列第九讲: 使用 Yum、RPM、Apt、Dpkg、Aptitude 进行 Linux 软件包管理
================================================================================
去年八月, Linux基金会宣布了一个全新的LFCSLinux Foundation Certified SysadminLinux基金会认证系统管理员认证计划这对广大系统管理员来说是一个很好的机会管理员们可以通过认证考试来表明自己可以成功支持Linux系统的整体运营。 一个Linux基金会认证的系统管理员能有足够的专业知识来确保系统高效运行提供第一手的故障诊断和监视并且在需要的情况下将问题提交给工程师支持团队。
![Linux Package Management](http://www.tecmint.com/wp-content/uploads/2014/11/lfcs-Part-9.png)
*Linux基金会认证系统管理员 第九讲*
请观看下面关于Linux基金会认证计划的演示。
youtube 视频
<iframe width="720" height="405" frameborder="0" allowfullscreen="allowfullscreen" src="http://www.youtube.com/embed/Y29qZ71Kicg"></iframe>
本文是本系列教程中的第九讲今天在这篇文章中我们会引导你学习Linux软件包管理这也是LFCS认证考试所需要的。
### 软件包管理 ###
简单的说,软件包管理是系统中安装和维护软件的一种方法,这里说的维护包含更新和卸载。
在Linux早期程序只以源代码的方式发行还带有所需的用户使用手册和必备的配置文件甚至更多。现如今大多数发行商一般使用预装程序或者被称为软件包的程序集合。用户可以使用这些预装程序或者软件包安装到该发行版中。然而Linux最伟大的一点是我们仍然能够获得程序的源代码用来学习、改进和编译。
####软件包管理系统是如何工作的####
如果某一个软件包需要一定的资源,如共享库,或者需要另一个软件包,这就称之为依赖性。所有现在的包管理系统提供了一些解决依赖性的方法,以确保当安装一个软件包时,相关的依赖包也安装好了。
####打包系统####
几乎所有安装在现代Linux系统上的软件都会能互联网上找到。它要么由发行商通过中央仓库中央仓库能包含几千个软件包每个软件包都已经为发行版构建、测试并且维护好了提供要么能够直接得到可以下载和手动安装的源代码。
由于不同的发行版使用不同的打包系统Debian的\*.deb文件/CentOS的\*.rpm文件/openSUSE的专门为openSUSE构建的*.rpm文件因此为一个发行版开发的软件包会与其他发行版不兼容。然而大多数发行版都属于LFCS认证所涉及的三个发行版家族之一。
####高级和低级打包工具####
为了有效地进行软件包管理的任务,你需要知道,有两种类型的实用工具:低级工具(能在后端实际安装、升级、卸载软件包文件),以及高级工具(负责确保能很好的执行依赖性解决和元数据检索的任务——元数据也称为数据的数据)。
|发行版|低级工具|高级工具|
|-----|-------|------|
|Debian版及其衍生版|dpkg|apt-get / aptitude|
|CentOS版|rpm|yum|
|openSUSE版|rpm|zypper|
让我们来看下低级工具和高级工具的描述。
dpkg的是基于Debian的系统的一个低级包管理器。它可以安装删除提供有关资料以及建立*.deb包但它不能自动下载并安装它们相应的依赖包。
- 阅读更多: [15个dpkg命令实例][1]
apt-get是Debian及其衍生版的高级包管理器并提供命令行方式来从多个来源检索和安装软件包其中包括解决依赖性。和dpkg不同的是apt-get不是直接基于.deb文件工作而是基于软件包的正确名称。
- 阅读更多: [25个apt-get命令实力][2]
Aptitude是基于Debian的系统的另一个高级包管理器它可用于快速简便的执行管理任务安装升级和删除软件包还可以自动处理解决依赖性。它在atp-get的基础上提供了更多功能例如提供对软件包的几个版本的访问。
rpm是Linux标准基础LSB兼容发行版所使用的一种软件包管理器用来对软件包进行低级处理。就像dpkg一样rpm可以查询、安装、检验、升级和卸载软件包它多数用于基于Fedora的系统比如RHEL和CentOS。
- 阅读更多: [20个rpm命令实例][3]
相对于基于RPM的系统yum增加了系统自动更新的功能和带依赖性管理的软件包管理功能。作为一个高级工具和apt-get或者aptitude相似yum需要配合仓库工作。
- 阅读更多: [20个yum命令实例][4]
### 低级工具的常见用法 ###
使用低级工具处理最常见的任务如下。
####1. 从已编译(*.deb或*.rpm的文件安装一个软件包####
这种安装方法的缺点是没有提供解决依赖性的方案。当你在发行版本库中无法获得某个软件包并且又不能通过高级工具下载安装时,你很可能会从一个已编译文件安装该软件包。因为低级工具不会解决依赖性问题,所以当安装一个没有解决依赖性的软件包时会出现出错并且退出。
# dpkg -i file.deb [Debian版和衍生版]
# rpm -i file.rpm [CentOS版 / openSUSE版]
**注意**不要试图在CentOS中安装一个为openSUSE构建的.rpm文件反之亦然
####2. 从已编译文件中更新一个软件包####
同样,当某个安装的软件包不在中央仓库中时,你只能手动升级该软件包。
# dpkg -i file.deb [Debian版和衍生版]
# rpm -U file.rpm [CentOS版 / openSUSE版]
####3. 列举安装的软件包####
当你第一次接触一个已经在工作中的系统时,很可能你会想知道安装了哪些软件包。
# dpkg -l [Debian版和衍生版]
# rpm -qa [CentOS版 / openSUSE版]
如果你想知道一个特定的软件包安装在哪儿,你可以使用管道命令从以上命令的输出中去搜索,这在这个系列的[第一讲 操作Linux文件][5] 中有介绍。例如我们需要验证mysql-common这个软件包是否安装在Ubuntu系统中
# dpkg -l | grep mysql-common
![Check Installed Packages in Linux](http://www.tecmint.com/wp-content/uploads/2014/11/Check-Installed-Package.png)
*检查安装的软件包*
另外一种方式来判断一个软件包是否已安装。
# dpkg --status package_name [Debian版和衍生版]
# rpm -q package_name [CentOS版 / openSUSE版]
例如让我们找出sysdig软件包是否安装在我们的系统。
# rpm -qa | grep sysdig
![Check sysdig Package](http://www.tecmint.com/wp-content/uploads/2014/11/Check-sysdig-Package.png)
*检查sysdig软件包*
####4. 查询一个文件是由哪个软件包安装的####
# dpkg --search file_name
# rpm -qf file_name
例如pw_dict.hwm文件是由那个软件包安装的
# rpm -qf /usr/share/cracklib/pw_dict.hwm
![Query File in Linux](http://www.tecmint.com/wp-content/uploads/2014/11/Query-File-in-Linux.png)
*Linux中查询文件*
### 高级工具的常见用法 ###
使用高级工具处理最常见的任务如下。
####1. 搜索软件包####
aptitude的更新操作将会更新可用的软件包列表而aptitude的搜索操作会根据软件包名进行实际搜索。
# aptitude update && aptitude search package_name
在search all选项中yum不仅可以通过软件包名还可以通过软件包的描述搜索。
# yum search package_name
# yum search all package_name
# yum whatprovides “*/package_name”
假定我们需要一个名为sysdig文件想知道我们需要安装哪个软件包才行那么运行。
# yum whatprovides “*/sysdig”
![Check Package Description in Linux](http://www.tecmint.com/wp-content/uploads/2014/11/Check-Package-Description.png)
*检查软件包描述*
whatprovides告诉yum搜索一个含有能够匹配上述正则表达式的文件的软件包。
# zypper refresh && zypper search package_name [在openSUSE上]
####2. 从仓库安装一个软件包####
当安装一个软件包时,在软件包管理器解决了所有依赖性问题后,可能会提醒你确认安装。需要注意的是运行更新( update或刷新refresh根据所使用的软件包管理器不是绝对必要但是考虑到安全性和依赖性的原因保持安装的软件包是最新的是系统管理员的一个好经验。
# aptitude update && aptitude install package_name [Debian版和衍生版]
# yum update && yum install package_name [CentOS版]
# zypper refresh && zypper install package_name [openSUSE版]
####3. 卸载软件包####
remove选项将会卸载软件包但把配置文件保留完好然而purge选项将从系统中完全删去该程序以及相关内容。
# aptitude remove / purge package_name
# yum erase package_name
---注意要卸载的openSUSE包前面的减号 ---
# zypper remove -package_name
在默认情况下,大部分(如果不是全部的话)的软件包管理器会提示你,在你实际卸载之前你是否确定要继续卸载。所以,请仔细阅读屏幕上的信息,以避免陷入不必要的麻烦!
####4. 显示软件包的信息####
下面的命令将会显示birthday这个软件包的信息。
# aptitude show birthday
# yum info birthday
# zypper info birthday
![Check Package Information in Linux](http://www.tecmint.com/wp-content/uploads/2014/11/Check-Package-Information.png)
*检查包信息*
### 总结 ###
作为一个系统管理员软件包管理器是你不能回避的东西。你应该立即去使用本文中介绍的这些工具。希望你在准备LFCS考试和日常工作中会觉得这些工具好用。欢迎在下面留下您的意见或问题我们将尽可能快的回复你。
--------------------------------------------------------------------------------
via http://www.tecmint.com/linux-package-management/
作者:[Gabriel Cánepa][a]
译者:[Flowsnow](https://github.com/Flowsnow)
校对:[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创翻译,[Linux中国](https://linux.cn/) 荣誉推出
[a]:http://www.tecmint.com/author/gacanepa/
[1]:http://www.tecmint.com/dpkg-command-examples/
[2]:http://www.tecmint.com/useful-basic-commands-of-apt-get-and-apt-cache-for-package-management/
[3]:http://www.tecmint.com/20-practical-examples-of-rpm-commands-in-linux/
[4]:http://www.tecmint.com/20-linux-yum-yellowdog-updater-modified-commands-for-package-mangement/
[5]:https://linux.cn/article-7161-1.html

View File

@ -1,76 +0,0 @@
vim-kakali translating
Confessions of a cross-platform developer
=============================================
![](https://opensource.com/sites/default/files/styles/image-full-size/public/images/business/business_clouds.png?itok=cucHuJnU)
[Andreia Gaita][1] is giving a talk at this year's OSCON, titled [Confessions of a cross-platform developer][2]. She's a long-time open source and [Mono][3] contributor, and develops primarily in C#/C++. Andreia works at GitHub, where she's focused on building the GitHub Extension manager for Visual Studio.
I caught up with Andreia ahead of her talk to ask about cross-platform development and what she's learned in her 16 years as a cross-platform developer.
![](https://opensource.com/sites/default/files/images/life/Interview%20banner%20Q%26A.png)
**What languages have you found easiest and hardest to develop cross-platform code for?**
It's less about which languages are good and more about the libraries and tooling available for those languages. The compilers/interpreters/build systems available for languages determine how easy it is to do cross-platform work with them (or whether it's even possible), and the libraries available for UI and native system access determine how deep you can integrate with the OS. With that in mind, I found C# to be the best for cross-platform work. The language itself includes features that allow fast native calls and accurate memory mapping, which you really need if you want your code to talk to the OS and native libraries. When I need very specific OS integration, I switch to C or C++.
**What cross-platform toolkits/abstractions have you used?**
Most of my cross-platform work has been developing tools, libraries and bindings for other people to develop cross-platform applications with, mostly in Mono/C# and C/C++. I don't get to use a lot of abstractions at that level, beyond glib and friends. I mostly rely on Mono for any cross-platform app that includes a UI, and Unity3D for the occasional game development. I play with Electron every now and then.
**What has been your approach to build systems, and how does this vary by language or platform?**
I try to pick the build system that is most suited for the language(s) I'm using. That way, it'll (hopefully) give me less headaches. It needs to allow for platform and architecture selection, be smart about build artifact locations (for multiple parallel builds), and be decently configurable. Most of the time I have projects combining C/C++ and C# and I want to build all the different configurations at the same time from the same source tree (Debug, Release, Windows, OSX, Linux, Android, iOS, etc, etc.), and that usually requires selecting and invoking different compilers with different flags per output build artifact. So the build system has to let me do all of this without getting (too much) in my way. I try out different build systems every now and then, just to see what's new, but in the end, I end up going back to makefiles and a combination of either shell and batch scripts or Perl scripts for driving them (because if I want users to build my things, I'd better pick a command line script language that is available everywhere).
**How do you balance the desire for native look and feel with the need for uniform user interfaces?**
Cross-platform UI is hard! I've implemented several cross-platform GUIs over the years, and it's the one thing for which I don't think there's an optimal solution. There's basically two options. You can pick a cross-platform GUI toolkit and do a UI that doesn't feel quite right in all the platforms you support, with a small codebase and low maintenance cost. Or you can choose to develop platform-specific UIs that will look and feel native and well integrated with a larger codebase and higher maintenance cost. The decision really depends on the type of app, how many features it has, how many resources you have, and how many platforms you're shipping to.
In the end, I think there's an increase in users' tolerance for "One UI To Rule Them All" with frameworks like Electron. I have a Chromium+C+C# framework side project that will one day hopefully allow me build Electron-style apps in C#, giving me the best of both worlds.
**Has building/packaging dependencies been an issue for you?**
I'm very conservative about my use of dependencies, having been bitten so many times by breaking ABIs, clashing symbols, and missing packages. I decide which OS version(s) I'm targeting and pick the lowest common denominator release available of a dependency to minimize issues. That usually means having five different copies of Xcode and OSX Framework libraries, five different versions of Visual Studio installed side-to-side on the same machine, multiple clang and gcc versions, and a bunch of VMs running various other distros. If I'm unsure of the state of packages in the OS I'm targeting, I will sometimes link statically and sometimes submodule dependencies to make sure they're always available. And most of all, I avoid the bleeding edge unless I really, really need something there.
**Do you use continuous integration, code review, and related tools?**
All the time! It's the only way to keep sane. The first thing I do on a project is set up cross-platform build scripts to ensure everything is automateable as early as possible. When you're targeting multiple platforms, CI is essential. It's impossible for everyone to build all the different combinations of platforms in one machine, and as soon as you're not building all of them you're going to break something without being aware of it. In a shared multi-platform codebase, different people own different platforms and features, so the only way to guarantee quality is to have cross-team code reviews combined with CI and other analysis tools. It's no different than other software projects, there's just more points of failure.
**Do you rely on automated build testing, or do you tend to build on each platform and test locally?**
For tools and libraries that don't include UIs, I can usually get away with automated build testing. If there's a UI, then I need to do both—reliable, scriptable UI automation for existing GUI toolkits is rare to non-existent, so I would have to either invest in creating UI automation tools that work across all the platforms I want to support, or I do it manually. If a project uses a custom UI toolkit (like, say, an OpenGL UI like Unity3D does), then it's fairly easy to develop scriptable automation tools and automate most of that stuff. Still, there's nothing like the human ability to break things with a couple of clicks!
**If you are developing cross-platform, do you support cross-editor build systems so that you can use Visual Studio on Windows, Qt Creator on Linux, and XCode on Mac? Or do you tend toward supporting one platform such as Eclipse on all platforms?**
I favor cross-editor build systems. I prefer generating project files for different IDEs (preferably in a way that makes it easier to add more IDEs), with build scripts that can drive builds from the IDEs for the platform they're on. Editors are the most important tool for a developer. It takes time and effort to learn them, and they're not interchangeable. I have my favorite editors and tools, and everyone else should be able to use their favorite tool, too.
**What is your preferred editor/development environment/IDE for cross-platform development?**
The cross-platform developer is cursed with having to pick the lowest common denominator editor that works across the most platforms. I love Visual Studio, but I can't rely on it for anything except Windows work (and you really don't want to make Windows your primary cross-compiling platform), so I can't make it my primary IDE. Even if I could, an essential skill of cross-platform development is to know and use as many platforms as possible. That means really knowing them—using the platform's editors and libraries, getting to know the OS and its assumptions, behaviors, and limitations, etc. To do that and keep my sanity (and my shortcut muscle memory), I have to rely on cross-platform editors. So, I use Emacs and Sublime.
**What are some of your favorite past and current cross-platform projects?**
Mono is my all-time favorite, hands down, and most of the others revolve around it in some way. Gluezilla was a Mozilla binding I did years ago to allow C# apps to embed web browser views, and that one was a doozy. At one point I had a Winforms app, built on Linux, running on Windows with an embedded GTK view in it that was running a Mozilla browser view. The CppSharp project (formerly Cxxi, formerly CppInterop) is a project I started to generate C# bindings for C++ libraries so that you could call, create instances of, and subclass C++ classes from C#. It was done in such a way that it would detect at runtime what platform you'd be running on and what compiler was used to create the native library and generate the correct C# bindings for it. That was fun!
**Where do you see cross-platform development heading in the future?**
The way we build native applications is already changing, and I feel like the visual differences between the various desktop operating systems are going to become even more blurred so that it will become easier to build cross-platform apps that integrate reasonably well without being fully native. Unfortunately, that might mean applications will be worse in terms of accessibility and less innovative when it comes to using the OS to its full potential. Cross-platform development of tools, libraries, and runtimes is something that we know how to do well, but there's still a lot of work to do with cross-platform application development.
--------------------------------------------------------------------------------
via: https://opensource.com/business/16/5/oscon-interview-andreia-gaita
作者:[Marcus D. Hanwell ][a]
译者:[译者ID](https://github.com/译者ID)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创翻译,[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/mhanwell
[1]: https://twitter.com/sh4na
[2]: http://conferences.oreilly.com/oscon/open-source-us/public/schedule/detail/48702
[3]: http://www.mono-project.com/

View File

@ -0,0 +1,60 @@
Should distributors disable IPv4-mapped IPv6?
=============================================
By all accounts, the Internet's transition to IPv6 has been a slow affair. In recent years, though, perhaps inspired by the exhaustion of the IPv4 address space, IPv6 usage has been [on the rise][1]. There is a corresponding interest in ensuring that applications work with both IPv4 and IPv6. But, as a recent discussion on the OpenBSD mailing list has highlighted, a mechanism designed to ease the transition to an IPv6 network may also make the net less secure — and Linux distributions may be configured insecurely by default.
### Address mapping
IPv6 may look like IPv4 in many ways, but it is a different protocol with a different address space. Server programs wanting to receive connections using either protocol must thus open separate sockets for the two different address families — AF_INET for IPv4, and AF_INET6 for IPv6. In particular, a program wishing to accept connections to any of a host's interfaces using either protocol will need to create an AF_INET socket bound to the all-zeroes wild-card address (0.0.0.0) and an AF_INET6 socket bound to the IPv6 equivalent (written as "::"). It must then listen for connections on both sockets — or so one would think.
Many years ago, in [RFC 3493][2], the IETF specified a mechanism by which a program could work with either protocol using a single IPv6 socket. With a socket enabled for this behavior, the program need only bind to :: to receive connections to all interfaces with both protocols. When an IPv4 connection is made to the bound port, the source address will be mapped into IPv6 as described in [RFC 2373][3]. So, for example, a program using this mode would see an incoming connection from 192.168.1.1 as originating from ::ffff:192.168.1.1 (the mixed notation is how such addresses are ordinarily written). The program can also open connections to IPv4 addresses by mapping them in the same manner.
The RFC calls for this behavior to be implemented by default, so most systems do so. There are exceptions, though, one of which is OpenBSD; there, programs wishing to work with both protocols can only do so by creating two independent sockets. A program that opens two sockets on Linux, though, will run into trouble: both the IPv4 and the IPv6 socket will try to bind to the IPv4 address(es), so whichever attempt comes second will fail. In other words, a program that binds a socket to a given port on :: will be bound to that port on both the IPv6 :: and the IPv4 0.0.0.0. If it then tries to bind an IPv4 socket to the same port on 0.0.0.0, the operation will fail as the port is already bound.
There is a way around that problem, of course; the program can call setsockopt() to turn on the IPV6_V6ONLY option. A program that opens two sockets and sets IPV6_V6ONLY should be portable across all systems.
Readers may be less than thoroughly shocked to learn that not every program out there gets all of this right. One of those, it turns out, is the [OpenNTPD][4] implementation of the Network Time Protocol. Brent Cook recently [proposed a small patch][5] adding the requisite setsockopt() call to the upstream OpenNTPD source, which lives within OpenBSD itself. That patch does not look likely to be accepted, though, for the most OpenBSD-like of reasons.
### Security concerns
As mentioned above, OpenBSD does not support IPv4-mapped IPv6 sockets at all. Even if a program tries to explicitly enable address mapping by setting the IPV6_V6ONLY option to zero, its author will be disappointed; that setting has no effect on OpenBSD systems. The reasoning behind this decision is that this mapping brings some security concerns with it. There are various types of attack surface that it opens up, but it all comes down to the provision of two different ways to reach the same port, each with its own access-control rules.
Any given server system may have set up firewall rules describing the allowed access to the port in question. There may also be mechanisms like TCP wrappers or a BPF-based filter in place, or a router on the net could be doing its own stateful connection filtering. The result is likely to be gaps in firewall protection and the potential for all kinds of confusion resulting from the same IPv4 address being reachable via two different protocols. If the address mapping is done at the edge of the network, the situation gets even more complex; see [this draft RFC from 2003][6] for a description of some other attack scenarios that come about if mapped addresses are transmitted between hosts.
Adapting systems and software to properly handle IPv4-mapped IPv6 addresses can certainly be done. But that adds to the overall complexity of the system, and it's a sure bet that this adaptation has not actually been done anywhere near as widely as it should be. As Theo de Raadt [put it][7]:
**Sometimes people put a bad idea into an RFC. Later they discover it is impossible to walk the idea back to the garbagebin. The result is concepts so complicated that everyone has to be a fulltime expert, on admin side and coder side**.
It is not at all clear how many of these full-time experts are actually out there configuring systems and networks where IPv4-mapped IPv6 addresses are in use.
One might well argue that, while IPv4-mapped IPv6 addresses create security hazards, there should be no harm in changing a program so that it turns off address mapping on systems that implement it. But Theo argues that this should not be done, for a couple of reasons. The first is that there are many broken programs out there, and it will never be possible to fix them all. But the real reason is to put pressure on distributors to turn off address mapping by default. As he put it: "**Eventually someone will understand the damage is systematic, and change the system defaults to 'secure by default'**."
### Address mapping on Linux
On Linux systems, address mapping is controlled by a sysctl knob called net.ipv6.bindv6only; it is set to zero (enabling address mapping) by default. Administrators (or distributors) can turn off mapping by setting this knob to one, but they would be well advised to be sure that their applications all work properly before deploying such a system in production. A quick survey suggests that none of the primary distributors change the default for this knob; Debian [changed the default][9] for the "squeeze" release in 2009, but the change broke enough packages ([anything involving Java][10], for example) that it was, [after a certain amount of Debian-style discussion][11], reverted. It would appear that quite a few programs rely on address mapping being enabled by default.
OpenBSD has the freedom to break things outside of its core system in the name of "secure by default"; Linux distributors tend to have a harder time getting away with such changes. So those distributors, being generally averse to receiving abuse from their users, are unlikely to change the default of the bindv6only knob anytime soon. The good news is that this functionality has been the default for years and stories of exploits are hard to find. But, as we all know, that provides no guarantees that exploits are not possible.
--------------------------------------------------------------------------------
via: https://lwn.net/Articles/688462/
作者:[Jonathan Corbet][a]
译者:[译者ID](https://github.com/译者ID)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译,[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://lwn.net/
[1]: https://www.google.com/intl/en/ipv6/statistics.html
[2]: https://tools.ietf.org/html/rfc3493#section-3.7
[3]: https://tools.ietf.org/html/rfc2373#page-10
[4]: https://github.com/openntpd-portable/
[5]: https://lwn.net/Articles/688464/
[6]: https://tools.ietf.org/html/draft-itojun-v6ops-v4mapped-harmful-02
[7]: https://lwn.net/Articles/688465/
[8]: https://lwn.net/Articles/688466/
[9]: https://lists.debian.org/debian-devel/2009/10/msg00541.html
[10]: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=560056
[11]: https://lists.debian.org/debian-devel/2010/04/msg00099.html

View File

@ -0,0 +1,192 @@
GHLandy Translating
Linux vs. Windows device driver model : architecture, APIs and build environment comparison
============================================================================================
Device drivers are parts of the operating system that facilitate usage of hardware devices via certain programming interface so that software applications can control and operate the devices. As each driver is specific to a particular operating system, you need separate Linux, Windows, or Unix device drivers to enable the use of your device on different computers. This is why when hiring a driver developer or choosing an R&D service provider, it is important to look at their experience of developing drivers for various operating system platforms.
![](https://c2.staticflickr.com/8/7289/26775594584_d2fe7483f9_c.jpg)
The first step in driver development is to understand the differences in the way each operating system handles its drivers, underlying driver model and architecture it uses, as well as available development tools. For example, Linux driver model is very different from the Windows one. While Windows facilitates separation of the driver development and OS development and combines drivers and OS via a set of ABI calls, Linux device driver development does not rely on any stable ABI or API, with the driver code instead being incorporated into the kernel. Each of these models has its own set of advantages and drawbacks, but it is important to know them all if you want to provide a comprehensive support for your device.
In this article we will compare Windows and Linux device drivers and explore the differences in terms of their architecture, APIs, build development, and distribution, in hopes of providing you with an insight on how to start writing device drivers for each of these operating systems.
### 1. Device Driver Architecture
Windows device driver architecture is different from the one used in Linux drivers, with either of them having their own pros and cons. Differences are mainly influenced by the fact that Windows is a closed-source OS while Linux is open-source. Comparison of the Linux and Windows device driver architectures will help us understand the core differences behind Windows and Linux drivers.
#### 1.1. Windows driver architecture
While Linux kernel is distributed with drivers themselves, Windows kernel does not include device drivers. Instead, modern Windows device drivers are written using the Windows Driver Model (WDM) which fully supports plug-and-play and power management so that the drivers can be loaded and unloaded as necessary.
Requests from applications are handled by a part of Windows kernel called IO manager which transforms them into IO Request Packets (IRPs) which are used to identify the request and convey data between driver layers.
WDM provides three kinds of drivers, which form three layers:
- Filter drivers provide optional additional processing of IRPs.
- Function drivers are the main drivers that implement interfaces to individual devices.
- Bus drivers service various adapters and bus controllers that host devices.
An IRP passes these layers as it travels from the IO manager down to the hardware. Each layer can handle an IRP by itself and send it back to the IO manager. At the bottom there is Hardware Abstraction Layer (HAL) which provides a common interface to physical devices.
#### 1.2. Linux driver architecture
The core difference in Linux device driver architecture as compared to the Windows one is that Linux does not have a standard driver model or a clean separation into layers. Each device driver is usually implemented as a module that can be loaded and unloaded into the kernel dynamically. Linux provides means for plug-and-play support and power management so that drivers can use them to manage devices correctly, but this is not a requirement.
Modules export functions they provide and communicate by calling these functions and passing around arbitrary data structures. Requests from user applications come from the filesystem or networking level, and are converted into data structures as necessary. Modules can be stacked into layers, processing requests one after another, with some modules providing a common interface to a device family such as USB devices.
Linux device drivers support three kinds of devices:
- Character devices which implement a byte stream interface.
- Block devices which host filesystems and perform IO with multibyte blocks of data.
- Network interfaces which are used for transferring data packets through the network.
Linux also has a Hardware Abstraction Layer that acts as an interface to the actual hardware for the device drivers.
### 2. Device Driver APIs
Both Linux and Windows driver APIs are event-driven: the driver code executes only when some event happens: either when user applications want something from the device, or when the device has something to tell to the OS.
#### 2.1. Initialization
On Windows, drivers are represented by a DriverObject structure which is initialized during the execution of the DriverEntry function. This entry point also registers a number of callbacks to react to device addition and removal, driver unloading, and handling the incoming IRPs. Windows creates a device object when a device is connected, and this device object handles all application requests on behalf of the device driver.
As compared to Windows, Linux device driver lifetime is managed by kernel module's module_init and module_exit functions, which are called when the module is loaded or unloaded. They are responsible for registering the module to handle device requests using the internal kernel interfaces. The module has to create a device file (or a network interface), specify a numerical identifier of the device it wishes to manage, and register a number of callbacks to be called when the user interacts with the device file.
#### 2.2. Naming and claiming devices
##### **Registering devices on Windows**
Windows device driver is notified about newly connected devices in its AddDevice callback. It then proceeds to create a device object used to identify this particular driver instance for the device. Depending on the driver kind, device object can be a Physical Device Object (PDO), Function Device Object (FDO), or a Filter Device Object (FIDO). Device objects can be stacked, with a PDO in the bottom.
Device objects exist for the whole time the device is connected to the computer. DeviceExtension structure can be used to associate global data with a device object.
Device objects can have names of the form **\Device\DeviceName**, which are used by the system to identify and locate them. An application opens a file with such name using CreateFile API function, obtaining a handle, which then can be used to interact with the device.
However, usually only PDOs have distinct names. Unnamed devices can be accessed via device class interfaces. The device driver registers one or more interfaces identified by 128-bit globally unique identifiers (GUIDs). User applications can then obtain a handle to such device using known GUIDs.
##### **Registering devices on Linux**
On Linux user applications access the devices via file system entries, usually located in the /dev directory. The module creates all necessary entries during module initialization by calling kernel functions like register_chrdev. An application issues an open system call to obtain a file descriptor, which is then used to interact with the device. This call (and further system calls with the returned descriptor like read, write, or close) are then dispatched to callback functions installed by the module into structures like file_operations or block_device_operations.
The device driver module is responsible for allocating and maintaining any data structures necessary for its operation. A file structure passed into the file system callbacks has a private_data field, which can be used to store a pointer to driver-specific data. The block device and network interface APIs also provide similar fields.
While applications use file system nodes to locate devices, Linux uses a concept of major and minor numbers to identify devices and their drivers internally. A major number is used to identify device drivers, while a minor number is used by the driver to identify devices managed by it. The driver has to register itself in order to manage one or more fixed major numbers, or ask the system to allocate some unused number for it.
Currently, Linux uses 32-bit values for major-minor pairs, with 12 bits allocated for the major number allowing up to 4096 distinct drivers. The major-minor pairs are distinct for character and block devices, so a character device and a block device can use the same pair without conflicts. Network interfaces are identified by symbolic names like eth0, which are again distinct from major-minor numbers of both character and block devices.
#### 2.3. Exchanging data
Both Linux and Windows support three ways of transferring data between user-level applications and kernel-level drivers:
- **Buffered Input-Output** which uses buffers managed by the kernel. For write operations the kernel copies data from a user-space buffer into a kernel-allocated buffer, and passes it to the device driver. Reads are the same, with kernel copying data from a kernel buffer into the buffer provided by the application.
- **Direct Input-Output** which does not involve copying. Instead, the kernel pins a user-allocated buffer in physical memory so that it remains there without being swapped out while data transfer is in progress.
- **Memory mapping** can also be arranged by the kernel so that the kernel and user space applications can access the same pages of memory using distinct addresses.
##### **Driver IO modes on Windows**
Support for Buffered IO is a built-in feature of WDM. The buffer is accessible to the device driver via the AssociatedIrp.SystemBuffer field of the IRP structure. The driver simply reads from or writes to this buffer when it needs to communicate with the userspace.
Direct IO on Windows is mediated by memory descriptor lists (MDLs). These are semi-opaque structures accessible via MdlAddress field of the IRP. They are used to locate the physical address of the buffer allocated by the user application and pinned for the duration of the IO request.
The third option for data transfer on Windows is called METHOD_NEITHER. In this case the kernel simply passes the virtual addresses of user-space input and output buffers to the driver, without validating them or ensuring that they are mapped into physical memory accessible by the device driver. The device driver is responsible for handling the details of the data transfer.
##### **Driver IO modes on Linux**
Linux provides a number of functions like clear_user, copy_to_user, strncpy_from_user, and some others to perform buffered data transfers between the kernel and user memory. These functions validate pointers to data buffers and handle all details of the data transfer by safely copying the data buffer between memory regions.
However, drivers for block devices operate on entire data blocks of known size, which can be simply moved between the kernel and user address spaces without copying them. This case is automatically handled by Linux kernel for all block device drivers. The block request queue takes care of transferring data blocks without excess copying, and Linux system call interface takes care of converting file system requests into block requests.
Finally, the device driver can allocate some memory pages from kernel address space (which is non-swappable) and then use the remap_pfn_range function to map the pages directly into the address space of the user process. The application can then obtain the virtual address of this buffer and use it to communicate with the device driver.
### 3. Device Driver Development Environment
#### 3.1. Device driver frameworks
##### **Windows Driver Kit**
Windows is a closed-source operating system. Microsoft provides a Windows Driver Kit to facilitate Windows device driver development by non-Microsoft vendors. The kit contains all that is necessary to build, debug, verify, and package device drivers for Windows.
Windows Driver Model defines a clean interface framework for device drivers. Windows maintains source and binary compatibility of these interfaces. Compiled WDM drivers are generally forward-compatible: that is, an older driver can run on a newer system as is, without being recompiled, but of course it will not have access to the new features provided by the OS. However, drivers are not guaranteed to be backward-compatible.
##### **Linux source code**
In comparison to Windows, Linux is an open-source operating system, thus the entire source code of Linux is the SDK for driver development. There is no formal framework for device drivers, but Linux kernel includes numerous subsystems that provide common services like driver registration. The interfaces to these subsystems are described in kernel header files.
While Linux does have defined interfaces, these interfaces are not stable by design. Linux does not provide any guarantees about forward or backward compatibility. Device drivers are required to be recompiled to work with different kernel versions. No stability guarantees allow rapid development of Linux kernel as developers do not have to support older interfaces and can use the best approach to solve the problems at hand.
Such ever-changing environment does not pose any problems when writing in-tree drivers for Linux, as they are a part of the kernel source, because they are updated along with the kernel itself. However, closed-source drivers must be developed separately, out-of-tree, and they must be maintained to support different kernel versions. Thus Linux encourages device driver developers to maintain their drivers in-tree.
#### 3.2. Build system for device drivers
Windows Driver Kit adds driver development support for Microsoft Visual Studio, and includes a compiler used to build the driver code. Developing Windows device drivers is not much different from developing a user-space application in an IDE. Microsoft also provides an Enterprise Windows Driver Kit, which enables command-line build environment similar to the one of Linux.
Linux uses Makefiles as a build system for both in-tree and out-of-tree device drivers. Linux build system is quite developed and usually a device driver needs no more than a handful of lines to produce a working binary. Developers can use any [IDE][5] as long as it can handle Linux source code base and run make, or they can easily compile drivers manually from terminal.
#### 3.3. Documentation support
Windows has excellent documentation support for driver development. Windows Driver Kit includes documentation and sample driver code, abundant information about kernel interfaces is available via MSDN, and there exist numerous reference and guide books on driver development and Windows internals.
Linux documentation is not as descriptive, but this is alleviated with the whole source code of Linux being available to driver developers. The Documentation directory in the source tree documents some of the Linux subsystems, but there are [multiple books][4] concerning Linux device driver development and Linux kernel overviews, which are much more elaborate.
Linux does not provide designated samples of device drivers, but the source code of existing production drivers is available and can be used as a reference for developing new device drivers.
#### 3.4. Debugging support
Both Linux and Windows have logging facilities that can be used to trace-debug driver code. On Windows one would use DbgPrint function for this, while on Linux the function is called printk. However, not every problem can be resolved by using only logging and source code. Sometimes breakpoints are more useful as they allow to examine the dynamic behavior of the driver code. Interactive debugging is also essential for studying the reasons of crashes.
Windows supports interactive debugging via its kernel-level debugger WinDbg. This requires two machines connected via a serial port: a computer to run the debugged kernel, and another one to run the debugger and control the operating system being debugged. Windows Driver Kit includes debugging symbols for Windows kernel so Windows data structures will be partially visible in the debugger.
Linux also supports interactive debugging by means of KDB and KGDB. Debugging support can be built into the kernel and enabled at boot time. After that one can either debug the system directly via a physical keyboard, or connect to it from another machine via a serial port. KDB offers a simple command-line interface and it is the only way to debug the kernel on the same machine. However, KDB lacks source-level debugging support. KGDB provides a more complex interface via a serial port. It enables usage of standard application debuggers like GDB for debugging Linux kernel just like any other userspace application.
### 4. Distributing Device Drivers
##### 4.1. Installing device drivers
On Windows installed drivers are described by text files called INF files, which are typically stored in C:\Windows\INF directory. These files are provided by the driver vendor and define which devices are serviced by the driver, where to find the driver binaries, the version of the driver, etc.
When a new device is plugged into the computer, Windows looks though
installed drivers and loads an appropriate one. The driver will be automatically unloaded as soon as the device is removed.
On Linux some drivers are built into the kernel and stay permanently loaded. Non-essential ones are built as kernel modules, which are usually stored in the /lib/modules/kernel-version directory. This directory also contains various configuration files, like modules.dep describing dependencies between kernel modules.
While Linux kernel can load some of the modules at boot time itself, generally module loading is supervised by user-space applications. For example, init process may load some modules during system initialization, and the udev daemon is responsible for tracking the newly plugged devices and loading appropriate modules for them.
#### 4.2. Updating device drivers
Windows provides a stable binary interface for device drivers so in some cases it is not necessary to update driver binaries together with the system. Any necessary updates are handled by the Windows Update service, which is responsible for locating, downloading, and installing up-to-date versions of drivers appropriate for the system.
However, Linux does not provide a stable binary interface so it is necessary to recompile and update all necessary device drivers with each kernel update. Obviously, device drivers, which are built into the kernel are updated automatically, but out-of-tree modules pose a slight problem. The task of maintaining up-to-date module binaries is usually solved with [DKMS][3]: a service that automatically rebuilds all registered kernel modules when a new kernel version is installed.
#### 4.3. Security considerations
All Windows device drivers must be digitally signed before Windows loads them. It is okay to use self-signed certificates during development, but driver packages distributed to end users must be signed with valid certificates trusted by Microsoft. Vendors can obtain a Software Publisher Certificate from any trusted certificate authority authorized by Microsoft. This certificate is then cross-signed by Microsoft and the resulting cross-certificate is used to sign driver packages before the release.
Linux kernel can also be configured to verify signatures of kernel modules being loaded and disallow untrusted ones. The set of public keys trusted by the kernel is fixed at the build time and is fully configurable. The strictness of checks performed by the kernel is also configurable at build time and ranges from simply issuing warnings for untrusted modules to refusing to load anything with doubtful validity.
### 5. Conclusion
As shown above, Windows and Linux device driver infrastructure have some things in common, such as approaches to API, but many more details are rather different. The most prominent differences stem from the fact that Windows is a closed-source operating system developed by a commercial corporation. This is what makes good, documented, stable driver ABI and formal frameworks a requirement for Windows while on Linux it would be more of a nice addition to the source code. Documentation support is also much more developed in Windows environment as Microsoft has resources necessary to maintain it.
On the other hand, Linux does not constrain device driver developers with frameworks and the source code of the kernel and production device drivers can be just as helpful in the right hands. The lack of interface stability also has an implications as it means that up-to-date device drivers are always using the latest interfaces and the kernel itself carries lesser burden of backwards compatibility, which results in even cleaner code.
Knowing these differences as well as specifics for each system is a crucial first step in providing effective driver development and support for your devices. We hope that this Windows and Linux device driver development comparison was helpful in understanding them, and will serve as a great starting point in your study of device driver development process.
Download this article as ad-free PDF (made possible by [your kind donation][2]): [Download PDF][1]
--------------------------------------------------------------------------------
via: http://xmodulo.com/linux-vs-windows-device-driver-model.html
作者:[Dennis Turpitka][a]
译者:[GHLandy](https://github.com/GHLandy)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译,[Linux中国](https://linux.cn/) 荣誉推出
[a]: http://xmodulo.com/author/dennis
[1]: http://xmodulo.com/linux-vs-windows-device-driver-model.html?format=pdf
[2]: https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=PBHS9R4MB9RX4
[3]: http://xmodulo.com/build-kernel-module-dkms-linux.html
[4]: http://xmodulo.com/go/linux_device_driver_books
[5]: http://xmodulo.com/good-ide-for-c-cpp-linux.html

View File

@ -0,0 +1,55 @@
The Anatomy of a Linux User
================================
**Some new GNU/Linux users understand right away that Linux isnt Windows. Others never quite get it. The best distro designers strive to keep both in mind.**
### The Heart of Linux
Nicky isnt outwardly remarkable in any way. Shes a thirtysomething who decided to go back to school later in life than most. She spent six years in the Navy until she decided a job offer from an old friend would be a better bet than a career in the armed forces. That happens a lot in any of the post-war military service branches. It was at that job where I met her. She was the regional manager for an eight state trucking broker and I was driving for a meat packing outfit in Dallas.
![](http://i2.wp.com/fossforce.com/wp-content/uploads/2016/05/anatomy.jpg?w=525)
We became good friends in 2006, Nicky and me. Shes an outgoing spirit, curious about almost anyone whose path she crosses. We had an ongoing Friday night date to go fight in an indoor laser combat arena. It wasnt rare for us to burn through three 30 minute sessions in a row. Maybe it wasnt as cheap as a paint ball arena, but it was climate controlled and had a horror game feel to it. It was during one of those outings that she asked me if I could fix her computer.
She knew about my efforts to get computers into the homes of disadvantaged kids and I kidded her about paying into Bill Gates 401K plan when she complained about her computer becoming too slow. Nicky figured this was as good a time as any to see what Linux was all about.
Her computer was a decent machine, a mid 2005 Asus desktop with a Dell 19″ monitor. Unfortunately, it had all the obligatory toolbars and popups that a Windows computer can collect when not properly tended. After getting all of the files from the computer, we began the process of installing Linux. We sat together during the install process and I made sure she understood the partitioning process. Inside of an hour, she had a bright new and shiny PCLinuxOS desktop.
She remarked often, as she navigated her way through her new system, at how beautiful the system looked. She wasnt mentioning this as an aside; she was almost hypnotized by the sleek beauty in front of her. She remarked that her screen “shimmered” with beauty. Thats something I took away from our install session and have made sure to deploy on every Linux computer Ive installed since. I want the screen to shimmer for everyone.
The first week or so, she called or emailed me with the usual questions, but the one that was probably the most important was wanting to know how to save her OpenOffice documents so colleagues could read them. This is key when teaching anyone Linux or Open/LibreOffice. Most people just obey the first popup, allow the document to be saved in Open Document Format and get their fingers bit in the process.
There was a story going around a year or so ago about a high school kid who claimed he flunked an exam when his professor couldnt open the file containing his paper. It made for some blustery comments from readers who couldnt decide who was more of a moron, the kid for not having a clue or his professor for not having a ummm… clue of his own.
I know some college professors and each and every one of them could figure out how to open an ODF file. Heck, even as much as Microsoft can be grade A, blue-ribbon proprietary jerks, I think Microsoft Office has been able to open an ODT or ODF file for a while now. I cant say for sure since I havent used Microsoft Office much since 2005.
Even in the bad ol days, when Microsoft was openly and flagrantly shoving their way onto enterprise desktops via their vendor lock-in, I never had a problem when conducting business or collaborating with users of Microsoft Office, because I became pro-active and never assumed. I would email the person or people I was to work with and ask what version of Office they were using. From that information, I could make sure to save my documents in a format they could readily open and read.
But back to Nicky, who put a lot of time into learning about her Linux computer. I was surprised by her enthusiasm.
Learning how to use Linux on the desktop is made much simpler when the person doing the learning realizes that all habits and tools for using Windows are to be left at the door. Even after telling our Reglue kids this, more often than not when I come back to do a check-up with them there is some_dodgy_file.exe on the desktop or in the download folder.
While we are in the general vicinity of discussing files, lets talk about doing updates. For a long time I was dead set against having multiple program installers or updaters on the same computer. In the case of Mint, it was decided to disable the update ability completely within Synaptic and that frosted my flakes. But while for us older folks dpkg and apt are our friends, wise heads have prevailed and have come to understand that the command line doesnt often seem warm and welcoming to new users.
I frothed at the mouth and raged against the machine over the crippling of Synaptic until it was splained to me. Do you remember when you were just starting out and had full admin rights to your brand new Linux install? Remember when you combed through the massive amounts of software listed in Synaptic? Remember how you began check marking every cool program you found? Do you remember how many of those cool programs started with the letters “lib”?
Yeah, me too. I installed and broke a few brand new installations until I found out that those LIB files were the nuts and bolts of the application and not the application itself. Thats why the genius behind Linux Mint and Ubuntu have created smart, pretty-to-look-at and easy-to-use application installers. Synaptic is still there for us old heads, but for the people coming up behind us, there are just too many ways to leave a system open to major borks by installing lib files and the like. In the new installers, those files are tucked away and not even shown to the user. And really, thats the way it should be.
Unless you are charging for support calls that is.
There are a lot of smarts built into todays Linux distros and I applaud those folks because they make my job easier. Not every new user is a Nicky. She was pretty much an install and forget project for me, and she is in the minority. The majority of new Linux users can be needy at times.
Thats okay. They are the ones who will be teaching their kids how to use Linux.
--------------------------------------------------------------------------------
via: http://fossforce.com/2016/05/anatomy-linux-user/
作者:[Ken Starks][a]
译者:[译者ID](https://github.com/译者ID)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译,[Linux中国](https://linux.cn/) 荣誉推出
[a]: http://linuxlock.blogspot.com/

View File

@ -0,0 +1,65 @@
vim-kakali translating
Why Ubuntu-based Distros Are Leaders
=========================================
Over the years, I've tried a number of great Linux distributions. The distros that had the greatest impact with me personally were those that maintained a strong community. But there's more to a popular distribution than a strong community. Popular Linux distributions tend to appeal to newcomers, often due to features that make using the distro easier. There are obviously exceptions to this, but generally speaking it is true.
One distribution that comes to mind is [Ubuntu][1]. Built from a solid [Debian][2] base, Ubuntu has not only become an incredibly popular Linux distro, it's also made countless other distributions such as Linux Mint a reality. In this article, I'll explore why I believe Ubuntu wins the Linux distribution wars and how it's influenced Linux on the desktop as a whole.
### Ubuntu is easy to use
Before I first tried Ubuntu years ago, I preferred using the KDE desktop. At that time, it was simply the environment I had the most experience with. The main reason is that KDE was the most popular option among various newbie-friendly Linux distributions. Newbie-friendly distros like Knoppix, Simply Mepis, Xandros, Linspire, amongst others and all of them pointed their users towards the welcoming arms of KDE.
At this time, KDE did what I needed it to do and I felt little reason to explore other desktop environments. Then one day after my Debian installation failed on me (due to my own user error), I decided to try out this "Ubuntu Dapper Drake" everyone was raving about. At that time, I was less than impressed with the screenshots I had seen, but figured it would be fun to try regardless.
The biggest impression Ubuntu Dapper Drake made on me was how cleanly everything was laid out. Bear in mind, I came from the KDE world where there were fifteen ways to make one menu change. Ubuntu's implementation of GNOME was very minimalist.
Flash forward to 2016 with the current 16.04 release: we have multiple Ubuntu flavors available, along with tons of distributions based on the Ubuntu base. The core thing all of these Ubuntu flavors and derivative distributions share in common is they're all designed to be easy to use. And when you're trying to grow your user base, stuff like this matters.
### Ubuntu LTS
In the past, I've almost always stuck with LTS releases for my main desktop. The x.10 releases were best left to my testing hard drive or perhaps even an old laptop. My reasons for this were simple I had no interest in playing with short term releases on a production PC. I'm a busy guy and simply don't feel this is the best use of my time.
Speaking for myself, I think Ubuntu offering LTS releases is one of the big reasons why the distribution has experienced such success. Think about it offering folks a desktop Linux distro that will be fully supported for a long period of time has its advantages. To be fair, Ubuntu's not alone here, as there are other distros that do this as well. But I think this LTS strategy bundled with a newbie friendly environment has done Ubuntu a world of good.
### Ubuntu Snap packages
In the past, users once raved about the ability to get newer software titles onto their systems using PPAs (personal package archives). Unfortunately, this technology has its shortcomings. Issues like PPA abandonment to discovery are both common issues when working with random software titles.
Then came the concept of [Snap packages][3]. Certainly not a completely new concept, as similar attempts have been made in the past. But what I think Snap will offer Ubuntu users in the long term is the ability to run the latest software without having to run the very latest Ubuntu release. While I still think we're seeing the early days of where Snap packages could end up, I'm excited at the prospect of bleeding edge software on a stable distribution release.
The obvious downside is how much disk space Snap packages might potentially use if you're running a lot of software. Not only that, but most software for Ubuntu has yet to officially make the switch over from deb packages. The first issue is solved with ample hard drive space while the latter will simply be a waiting game.
### Ubuntu Community
I'm among the first to admit that all of the major Linux distributions have great communities. However, I firmly believe that Ubuntu's community might be the most diverse in terms of folks from different walks of life. For example, we have forums ranging from Apple hardware support to gaming. That's a particularly wide variety of specialized discussions.
Going beyond the forums, Ubuntu also offers a highly defined community structure. This structure includes a council, technical board, [LoCo teams][4], and Developer Membership board. There are others, but these are the areas of the community structure that really stand out to me.
Then we have [Ask Ubuntu][5]. In my view, this feature should replace seeking help from the forums as I find it to be far more likely you'll get useful information from this area. Not only that, solutions provided that are voted highly accurate might even make it into the official documentation.
### Ubuntu's future
I think Ubuntu's Unity interface has done little to increase desktop adoption. I understand why it was implemented, how it's making things easier for Ubuntu developers and whatnot. But in the end, I also believe it's paved the way for Ubuntu MATE and Linux Mint to increase in popularity as well.
Another area that I wonder about is the future of Ubuntu's IRC and mailing lists. The fact is, neither lend themselves to bettering documentation like Ask Ubuntu can. As for mailing lists, I've always felt this was a painfully dated way to collaborate, but that's just me others feel different and that's fine.
What say you? Do you think Ubuntu will remain a major player going into the future? Perhaps you believe Arch, Linux Mint or others will dethrone Ubuntu in terms of popularity. Hit the Comments and give your favorite distribution a shout-out. If your favorite is based on Ubuntu, explain why you prefer it over Ubuntu proper. I think many of us can mutually agree that, if nothing else, Ubuntu makes a pretty popular base from which to build other distributions.
--------------------------------------------------------------------------------
via: http://www.datamation.com/open-source/why-ubuntu-based-distros-are-leaders.html
作者:[Matt Hartley][a]
译者:[译者ID](https://github.com/译者ID)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译,[Linux中国](https://linux.cn/) 荣誉推出
[a]: http://www.datamation.com/author/Matt-Hartley-3080.html
[1]: http://www.ubuntu.com/
[2]: https://www.debian.org/
[3]: http://www.datamation.com/open-source/ubuntu-snap-packages-the-good-the-bad-the-ugly.html
[4]: http://loco.ubuntu.com/
[5]: http://askubuntu.com/

View File

@ -1,65 +0,0 @@
The future of sharing: integrating Pydio and ownCloud
=========================================================
![](https://opensource.com/sites/default/files/styles/image-full-size/public/images/business/BIZ_darwincloud_520x292_0311LL.png?itok=5yWIaEDe)
>Image by :
opensource.com
The open source file sharing ecosystem accommodates a large variety of projects, each supplying their own solution, and each with a different approach. There are a lot of reasons to choose an open source solution rather than commercial solutions like Dropbox, Google Drive, iCloud, or OneDrive. These solutions offer to take away worries about managing your data but come with certain limitations, including a lack of control and integration into existing infrastructure.
There are quite a few file sharing and sync alternatives available to users, including ownCloud and Pydio.
### Pydio
The Pydio (Put your data in orbit) project was founded by musician Charles du Jeu, who needed a way to share large audio files with his bandmates. [Pydio][1] is a file sharing and sync solution, with multiple storage backends, designed with developers and system administrators in mind. It has over one million downloads worldwide and has been translated into 27 languages.
Open source from the very start, the project grew organically on [SourceForge][2] and now finds its home on [GitHub][3].
The user interface is based on Google's [Material Design][4]. Users can use an existing legacy file infrastructure or set up Pydio with an on-premise approach, and use web, desktop, and mobile applications to manage their assets everywhere. For administrators, the fine-grained access rights are a powerful tool for configuring access to assets.
On the [Pydio community page][5], you will find several resources to get you up to speed quickly. The Pydio website gives some clear guidelines on [how to contribute][6] to the Pydio repositories on GitHub. The [forum][7] includes sections for developers and community.
### ownCloud
[ownCloud][8] has over 8 million users worldwide and is an open source, self-hosted file sync and sharing technology. There are sync clients for all major platforms as well as WebDAV through a web interface. ownCloud has an easy to use interface, powerful administrator tools, and extensive sharing and collaboration features—designed to give users control over their data.
ownCloud's open architecture is extensible via an API and offers a platform for apps. Over 300 applications have been written, featuring capabilities like handling calendar, contacts, mail, music, passwords, notes, and many other types of data. ownCloud provides security, scales from a Raspberry Pi to a cluster with petabytes of storage and millions of users, and is developed by an international community of hundreds of contributors.
### Federated sharing
File sharing is starting to shift toward teamwork, and standardization provides a solid basis for such collaboration.
Federated sharing, a new open standard supported by the [OpenCloudMesh][9] project, is a step in that direction. Among other things, it allows for the sharing of files and folders between servers that support this, like Pydio and ownCloud instances.
First introduced in ownCloud 7, this server-to-server sharing allows you to mount file shares from remote servers, in effect creating your own cloud of clouds. You can create direct share links with users on other servers that support federated cloud sharing.
Implementing this new API allows for deeper integration between storage solutions while maintaining the security, control, and attributes of the original platforms.
"Exchanging and sharing files is something that is essential today and tomorrow," ownCloud founder Frank Karlitschek said. "Because of that, it is important to do this in a federated and distributed way without centralized data silos. The number one design goal [of federated sharing] is to enable sharing in the most seamless and easiest way while protecting the security and privacy of the users."
### What's next?
An initiative like OpenCloudMesh will extend this new open standard of file sharing through cooperation of institutions and companies like Pydio and ownCloud. ownCloud 9 has already introduced the ability for federated servers to exchange user lists, enabling the same seamless auto-complete experience you have with users on your own server. In the future, the idea of having a (federated!) set of central address book servers that can be used to search for others' federated cloud IDs might bring inter-cloud collaboration to an even higher level.
The initiative will undoubtedly contribute to already growing open technical community within which members can easily discuss, develop, and contribute to the "OCM sharing API" as a vendor-neutral protocol. All leading partners of the OCM project are fully committed to the open API design principle and welcome other open source file share and sync communities to participate and join the connected cloud.
--------------------------------------------------------------------------------
via: https://opensource.com/business/16/5/sharing-files-pydio-owncloud
作者:[ben van 't ende][a]
译者:[译者ID](https://github.com/译者ID)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译,[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/benvantende
[1]: https://pydio.com/
[2]: https://sourceforge.net/projects/ajaxplorer/
[3]: https://github.com/pydio/
[4]: https://www.google.com/design/spec/material-design/introduction.html
[5]: https://pydio.com/en/community
[6]: https://pydio.com/en/community/contribute
[7]: https://pydio.com/forum/f
[8]: https://owncloud.org/
[9]: https://wiki.geant.org/display/OCM/Open+Cloud+Mesh

View File

@ -1,77 +0,0 @@
Test Fedora 24 Beta in an OpenStack cloud
===========================================
![](https://major.io/wp-content/uploads/2012/01/fedorainfinity.png)
Although there are a few weeks remaining before [Fedora 24][1] is released, you can test out the Fedora 24 Beta release today! This is a great way to get [a sneak peek at new features][2] and help find bugs that still need a fix.
The [Fedora Cloud][3] image is available for download from your favorite [local mirror][4] or directly from [Fedoras servers][5]. In this post, Ill show you how to import this image into an OpenStack environment and begin testing Fedora 24 Beta.
One last thing: this is beta software. It has been reliable for me so far, but your experience may vary. I would recommend waiting for the final release before deploying any mission critical applications on it.
### Importing the image
The older glance client (version 1) allows you to import an image from a URL that is reachable from your OpenStack environment. This is helpful since my OpenStack cloud has a much faster connection to the internet (1 Gbps) than my home does (~ 20 mbps upload speed). However, the functionality to import from a URL was [removed in version 2 of the glance client][6]. The [OpenStackClient][7] doesnt offer the feature either.
There are two options here:
- Install an older version of the glance client
- Use Horizon (the web dashboard)
Getting an older version of glance client installed is challenging. The OpenStack requirements file for the liberty release [leaves the version of glance client without a maximum version cap][8] and its difficult to get all of the dependencies in order to make the older glance client work.
Lets use Horizon instead so we can get back to the reason for the post.
### Adding an image in Horizon
Log into the Horizon panel and click Compute > Images. Click + Create Image at the top right of the page and a new window should appear. Add this information in the window:
- **Name**: Fedora 24 Cloud Beta
- **Image Source**: Image Location
- **Image Location**: http://mirrors.kernel.org/fedora/releases/test/24_Beta/CloudImages/x86_64/images/Fedora-Cloud-Base-24_Beta-1.6.x86_64.qcow2
- **Format**: QCOW2 QEMU Emulator
- **Copy Data**: ensure the box is checked
When youre finished, the window should look like this:
![](https://major.io/wp-content/uploads/2016/05/horizon_image.png)
Click Create Image and the images listing should show Saving for a short period of time. Once it switches to Active, youre ready to build an instance.
### Building the instance
Since were already in Horizon, we can finish out the build process there.
On the image listing page, find the row with the image we just uploaded and click Launch Instance on the right side. A new window will appear. The Image Name drop down should already have the Fedora 24 Beta image selected. From here, just choose an instance name, select a security group and keypair (on the Access & Security tab), and a network (on the Networking tab). Be sure to choose a flavor that has some available storage as well (m1.tiny is not enough).
Click Launch and wait for the instance to boot.
Once the instance build has finished, you can connect to the instance over ssh as the fedora user. If your [security group allows the connection][9] and your keypair was configured correctly, you should be inside your new Fedora 24 Beta instance!
Not sure what to do next? Here are some suggestions:
- Update all packages and reboot (to ensure that you are testing the latest updates)
- Install some familiar applications and verify that they work properly
- Test out your existing automation or configuration management tools
- Open bug tickets!
--------------------------------------------------------------------------------
via: https://major.io/2016/05/24/test-fedora-24-beta-openstack-cloud/
作者:[major.io][a]
译者:[译者ID](https://github.com/译者ID)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译,[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://major.io/about-the-racker-hacker/
[1]: https://fedoraproject.org/wiki/Releases/24/Schedule
[2]: https://fedoraproject.org/wiki/Releases/24/ChangeSet
[3]: https://getfedora.org/en/cloud/
[4]: https://admin.fedoraproject.org/mirrormanager/mirrors/Fedora/24/x86_64
[5]: https://getfedora.org/en/cloud/download/
[6]: https://wiki.openstack.org/wiki/Glance-v2-v1-client-compatability
[7]: http://docs.openstack.org/developer/python-openstackclient/
[8]: https://github.com/openstack/requirements/blob/stable/liberty/global-requirements.txt#L159
[9]: https://major.io/2016/05/16/troubleshooting-openstack-network-connectivity/

View File

@ -1,180 +0,0 @@
HOW TO USE WEBP IMAGES IN UBUNTU LINUX
=========================================
![](http://itsfoss.com/wp-content/uploads/2016/05/support-webp-ubuntu-linux.jpg)
>Brief: This guide shows you how to view WebP images in Linux and how to convert WebP images to JPEG or PNG format.
###WHAT IS WEBP?
Its been over five years since Google introduced [WebP file format][0] for images. WebP provides lossy and lossless compression and WebP compressed files are around 25% smaller in size when compared to JPEG compression, Google claims.
Google aimed WebP to become the new standard for images on the web but I dont see it happening. Its over five years and its still not adopted as a standard except in Googles ecosystem. But as we know, Google is pushy about its technologies. Few months back Google changed all the images on Google Plus to WebP.
If you download those images from Google Plus using Google Chrome, youll have WebP images, no matter if you had uploaded PNG or JPEG. And thats not the problem. The actual problem is when you try to open that files in Ubuntu using the default GNOME Image Viewer and you see this error:
>**Could not find XYZ.webp**
>**Unrecognized image file format**
![](http://itsfoss.com/wp-content/uploads/2016/05/WebP-images-Ubuntu-Linux-1.png)
>GNOME Image Viewer doesnt support WebP images
In this tutorial, we shall see
- how to add WebP support in Linux
- list of programs that support WebP images
- how to convert WebP images to PNG or JPEG
- how to download WebP images directly as PNG images
### HOW TO VIEW WEBP IMAGES IN UBUNTU AND OTHER LINUX
[GNOME Image Viewer][3], the default image viewer in many Linux distributions including Ubuntu, doesnt support WebP images. There are no plugins available at present that could enable GNOME Image Viewer to add WebP support.
This means that we simply cannot use GNOME Image Viewer to open WebP files in Linux. A better alternative is [gThumb][4] that supports WebP images by default.
To install gThumb in Ubuntu and other Ubuntu based Linux distributions, use the command below:
```
sudo apt-get install gthumb
```
Once installed, you can simply rightly click on the WebP image and select gThumb to open it. You should be able to see it now:
![](http://itsfoss.com/wp-content/uploads/2016/05/WebP-images-Ubuntu-Linux-2.jpeg)
>WebP image in gThumb
### MAKE GTHUMB THE DEFAULT APPLICATION FOR WEBP IMAGES IN UBUNTU
For Ubuntu beginners, if you like to make gThumb the default application for opening WebP files, just follow the steps below:
#### Step 1: Right click on the WebP image and select Properties.
![](http://itsfoss.com/wp-content/uploads/2016/05/WebP-images-Ubuntu-Linux-3.png)
>Select Properties from Right Click menu
#### Step 2: Go to Open With tab, select gThumb and click on Set as default.
![](http://itsfoss.com/wp-content/uploads/2016/05/WebP-images-Ubuntu-Linux-4.png)
>Make gThumb the default application for WebP images in Ubuntu
### MAKE GTHUMB THE DEFAULT APPLICATIONS FOR ALL IMAGES
gThumb has a lot more to offer than Image Viewer. For example, you can do simple editing, add color filters to the images etc. Adding the filter is not as effective as XnRetro, the dedicated tool for [adding Instagram like effects on Linux][5], but the basic filters are available.
I liked gThumb a lot and decided to make it the default image viewer. If you also want to make gThumb the default application for all kind of images in Ubuntu, follow the steps below:
####Step 1: Open System Settings
![](http://itsfoss.com/wp-content/uploads/2014/04/System_Settings_ubuntu_1404.jpeg)
#### Step 2: Go to Details.
![](http://itsfoss.com/wp-content/uploads/2013/11/System_settings_Ubuntu_1.jpeg)
#### Step 3: Select gThumb as the default applications for images here.
![](http://itsfoss.com/wp-content/uploads/2016/05/WebP-images-Ubuntu-Linux-5.png)
### ALTERNATIVE PROGRAMS TO OPEN WEBP FILES IN LINUX
It is possible that you might not like gThumb. If thats the case, you can choose one of the following applications to view WebP images in Linux:
- [XnView][6] (Not open source)
- GIMP with unofficial WebP plugin that can be installed via this [PPA][7] that is available until Ubuntu 15.10. Ill cover this part in another article.
- [Gwenview][8]
### CONVERT WEBP IMAGES TO PNG AND JPEG IN LINUX
There are two ways to convert WebP images in Linux:
- Command line
- GUI
#### 1. USING COMMAND LINE TO CONVERT WEBP IMAGES IN LINUX
You need to install WebP tools first. Open a terminal and use the following command:
```
sudo apt-get install webp
```
##### CONVERT JPEG/PNG TO WEBP
Well use cwebp command (does it mean compress to WebP?) to convert JPEG or PNG files to WebP. The command format is like:
```
cwebp -q [image_quality] [JPEG/PNG_filename] -o [WebP_filename]
```
For example, you can use the following command:
```
cwebp -q 90 example.jpeg -o example.webp
```
##### CONVERT WEBP TO JPEG/PNG
To convert WebP images to JPEG or PNG, well use dwebp command. The command format is:
```
dwebp [WebP_filename] -o [PNG_filename]
```
An example of this command could be:
```
dwebp example.webp -o example.png
```
#### 2. USING GUI TOOL TO CONVERT WEBP TO JPEG/PNG
For this purpose, we will use XnConvert which is a free but not open source application. You can download the installer files from their website:
[Download XnConvert][1]
Note that XnConvert is a powerful tool that you can use for batch resizing images. However, in this tutorial, we shall only see how to convert a single WebP image to PNG/JPEG.
Open XnConvert and select the input file:
![](http://itsfoss.com/wp-content/uploads/2016/05/WebP-images-Ubuntu-Linux-6.jpeg)
In the Output tab, select the output format you want it to be converted. Once you have selected the output format, click on Convert.
![](http://itsfoss.com/wp-content/uploads/2016/05/WebP-images-Ubuntu-Linux-7.jpeg)
Thats all you need to do to convert WebP images to PNG, JPEg or any other image format of your choice.
### DOWNLOAD WEBP IMAGES AS PNG DIRECTLY IN CHROME WEB BROWSER
Probably you dont like WebP image format at all and you dont want to install a new software just to view WebP images in Linux. It will be a bigger pain if you have to convert the WebP file for future use.
An easier and less painful way to deal with is to install a Chrome extension Save Image as PNG. With this extension, you can simply right click on a WebP image and save it as PNG directly.
![](http://itsfoss.com/wp-content/uploads/2016/05/WebP-images-Ubuntu-Linux-8.png)
>Saving WebP image as PNG in Google Chrome
[Get Save Image as PNG extension][2]
### WHATS YOUR PICK?
I hope this detailed tutorial helped you to get WebP support on Linux and helped you to convert WebP images. How do you handle WebP images in Linux? Which tool do you use? From the above described methods, which one did you like the most?
----------------------
via: http://itsfoss.com/webp-ubuntu-linux/?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%3A+ItsFoss+%28Its+FOSS%21+An+Open+Source+Blog%29
作者:[Abhishek Prakash][a]
译者:[译者ID](https://github.com/译者ID)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创翻译,[Linux中国](https://linux.cn/) 荣誉推出
[a]: http://itsfoss.com/author/abhishek/
[0]: https://developers.google.com/speed/webp/
[1]: http://www.xnview.com/en/xnconvert/#downloads
[2]: https://chrome.google.com/webstore/detail/save-image-as-png/nkokmeaibnajheohncaamjggkanfbphi?utm_source=chrome-ntp-icon
[3]: https://wiki.gnome.org/Apps/EyeOfGnome
[4]: https://wiki.gnome.org/Apps/gthumb
[5]: http://itsfoss.com/add-instagram-effects-xnretro-ubuntu-linux/
[6]: http://www.xnview.com/en/xnviewmp/#downloads
[7]: https://launchpad.net/~george-edison55/+archive/ubuntu/webp
[8]: https://userbase.kde.org/Gwenview

View File

@ -0,0 +1,68 @@
Translating by GitFuture
How to mount your Google Drive on Linux with google-drive-ocamlfuse
========================================================================
>If you're looking for an easy way to mount your Google Drive folders to a Linux box, Jack Wallen shows you how with the help of google-drive-ocamlfuse.
![](http://tr4.cbsistatic.com/hub/i/2016/05/18/ee5d7b81-e5be-4b24-843d-d3ca99230a63/651be96ac8714698f8100afa6883e64d/linuxcloudhero.jpg)
>Image: Jack Wallen
Google has yet to release a Linux version of its Google Drive app, though there are plenty of ways to gain access to your Drive files from Linux.
If you prefer a GUI tool, you've got Insync. If you prefer the command line, there are tools such as Grive2 and the incredibly easy to use FUSE-based system written in Ocaml. I'll show how to use the latter to mount your Google Drive account on your Linux desktop. Although it's done via the command line, you'll be surprised at how easy it is to pull off. It's so easy, anyone can do it.
This system features:
- Full read/write access to ordinary files/folders
- Read-only access to Google Docs, sheets, and slides
- Access to your Drive's Trash (.trash) Directory
- Duplicate file handling
- Support for multiple accounts
Let's walk through the installation and setup of google-drive-ocamlfuse on a Ubuntu 16.04 desktop so you can gain access to your Drive files.
### Installation
1. Open a terminal window.
2. Add the necessary PPA with the command sudo add-apt-repository ppa:alessandro-strada/ppa.
3. When prompted, type your sudo password and hit Enter.
4. Update app with the command sudo apt-get update.
5. Install the software by issuing the command sudo apt-get install google-drive-ocamlfuse.
### Authorization
The next step is to authorize google-drive-ocamlfuse so it will have access to your Google account. To do this, go back to the terminal window and issue the command google-drive-ocamlfuse. This command will open a browser window that will either prompt you to log into your Google account or, if you're already logged in, ask you to allow google-drive-ocamlfuse access to your Google account. If you've not logged in, do so and then click Allow. The next window (which appeared on a Ubuntu 16.04 desktop, but not an Elementary OS Freya desktop) will ask you to grant permission for both gdfuse and OAuth2 Endpoint to access your Google account. Click Allow again. The next browser screen will inform you to wait until the authorization tokens have downloaded; you can minimize the browser at this point. When your terminal prompt returns (Figure A), you know the tokens have been downloaded, and you're ready to mount.
**Figure A**
![](http://tr4.cbsistatic.com/hub/i/r/2016/05/18/a493122b-445f-4aca-8974-5ec41192eede/resize/620x/6ae5907ad2c08dc7620b7afaaa9e389c/googledriveocamlfuse3.png)
>Image: Jack Wallen
**The app has been authorized, and you're ready to go.**
### Mounting your Google Drive
Before you mount your Google Drive, you must create a folder to serve as the mount point. From the terminal, issue the command mkdir ~/google-drive to create a new folder in your home directory. Finally, issue the command google-drive-ocamlfuse ~/google-drive to mount your Google Drive to the google-drive folder.
At this point, you should see your Google Drive files/folders populate in the google-drive folder. You can work with Google Drive as if it were a local folder system.
When you want to unmount the google-drive folder, issue the command fusermount -u ~/google-drive.
### It's no GUI, but it works like a champ
I find this particular system really handy to use. It's incredibly fast at syncing with Google Drive, and it can make for an elegant means of backing up your Google Drive account locally.
Give google-drive-ocamlfuse a go, and see what kind of magic you can make with it.
--------------------------------------------------------------------------------
via: http://www.techrepublic.com/article/how-to-mount-your-google-drive-on-linux-with-google-drive-ocamlfuse/
作者:[Jack Wallen ][a]
译者:[译者ID](https://github.com/译者ID)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译,[Linux中国](https://linux.cn/) 荣誉推出
[a]: http://www.techrepublic.com/search/?a=jack+wallen

View File

@ -0,0 +1,180 @@
Vic020
How to Add Cron Jobs in Linux and Unix
======================================
![](https://www.unixmen.com/wp-content/uploads/2016/05/HOW-TO-ADD-CRON-JOBS-IN-LINUX-AND-UNIX-696x334.png)
### Introduction
![](http://www.unixmen.com/wp-content/uploads/2016/05/cronjob.gif)
Cron job are used to schedule commands to be executed periodically. You can setup commands or scripts, which will repeatedly run at a set time. Cron is one of the most useful tool in Linux or UNIX like operating systems. The cron service (daemon) runs in the background and constantly checks the /etc/crontab file, and /etc/cron.*/ directories. It also checks the /var/spool/cron/ directory.
### Command of crontab
crontab is the command used to install, deinstall or list the tables (cron configuration file) used to drive the [cron(8)][1] daemon in Vixie Cron. Each user can have their own crontab file, and though these are files in /var/spool/cron/crontabs, they are not intended to be edited directly. You need to use crontab command for editing or setting up your own cron jobs.
### Types of cron configuration files
There are different types of configuration files:
- **The UNIX / Linux system crontab** : Usually, used by system services and critical jobs that requires root like privileges. The sixth field (see below for field description) is the name of a user for the command to run as. This gives the system crontab the ability to run commands as any user.
- **The user crontabs**: User can install their own cron jobs using the crontab command. The sixth field is the command to run, and all commands run as the user who created the crontab
**Note**: This faq features cron implementations written by Paul Vixie and included in many [Linux][2] distributions and Unix like systems such as in the popular 4th BSD edition. The syntax is [compatible][3] with various implementations of crond.
How Do I install or create or edit my own cron jobs?
To edit your crontab file, type the following command at the UNIX / Linux shell prompt:
```
$ crontab -e
```
Syntax of crontab (field description)
The syntax is:
```
1 2 3 4 5 /path/to/command arg1 arg2
```
OR
```
1 2 3 4 5 /root/ntp_sync.sh
```
Where,
- 1: Minute (0-59)
- 2: Hours (0-23)
- 3: Day (0-31)
- 4: Month (0-12 [12 == December])
- 5: Day of the week(0-7 [7 or 0 == sunday])
- /path/to/command Script or command name to schedule
Easy to remember format:
```
* * * * * command to be executed
| | | | |
| | | | —– Day of week (0 7) (Sunday=0 or 7)
| | | ——- Month (1 12)
| | ——— Day of month (1 31)
| ———– Hour (0 23)
————- Minute (0 59)
```
Example simple crontab.
````
## run backupscript 5 minutes 1 time ##
*/5 * * * * /root/backupscript.sh
## Run backupscript daily on 1:00 am ##
0 1 * * * /root/backupscript.sh
## Run backup script monthly on the 1st of month 3:15 am ##
15 3 1 * * /root/backupscript.sh
```
### How do I use operators?
An operator allows you to specifying multiple values in a field. There are three operators:
- **The asterisk (*)** : This operator specifies all possible values for a field. For example, an asterisk in the hour time field would be equivalent to every hour or an asterisk in the month field would be equivalent to every month
- **The comma (,)** : This operator specifies a list of values, for example: “1,5,10,15,20, 25”.
- **The dash ()** : This operator specifies a range of values, for example: “5-15” days , which is equivalent to typing “5,6,7,8,9,….,13,14,15” using the comma operator.
- **The separator (/)** : This operator specifies a step value, for example: “0-23/” can be used in the hours field to specify command execution every other hour. Steps are also permitted after an asterisk, so if you want to say every two hours, just use */2.
### Use special string to save time
Instead of the first five fields, you can use any one of eight special strings. It will not just save your time but it will improve readability.
Special string | Meaning
|:-- |:--
@reboot | Run once, at startup.
@yearly | Run once a year, “0 0 1 1 *”.
@annually | (same as @yearly)
@monthly | Run once a month, “0 0 1 * *”.
@weekly | Run once a week, “0 0 * * 0”.
@daily | Run once a day, “0 0 * * *”.
@midnight | (same as @daily)
@hourly | Run once an hour, “0 * * * *”.
Examples
```
#### Run ntpdate command every hour ####
@hourly /path/to/ntpdate
```
### More about /etc/crontab file and /etc/cron.d/* directories
/etc/crontab is system crontabs file. Usually only used by root user or daemons to configure system wide jobs. All individual user must must use crontab command to install and edit their jobs as described above. /var/spool/cron/ or /var/cron/tabs/ is directory for personal user crontab files. It must be backup with users home directory.
Understanding Default /etc/crontab
Typical /etc/crontab file entries:
```
SHELL=/bin/bash
PATH=/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=root
HOME=/
# run-parts
01 * * * * root run-parts /etc/cron.hourly
02 4 * * * root run-parts /etc/cron.daily
22 4 * * 0 root run-parts /etc/cron.weekly
42 4 1 * * root run-parts /etc/cron.monthly
```
First, the environment must be defined. If the shell line is omitted, cron will use the default, which is sh. If the PATH variable is omitted, no default will be used and file locations will need to be absolute. If HOME is omitted, cron will use the invoking users home directory.
Additionally, cron reads the files in /etc/cron.d/ directory. Usually system daemon such as sa-update or sysstat places their cronjob here. As a root user or superuser you can use following directories to configure cron jobs. You can directly drop your scripts here. The run-parts command run scripts or programs in a directory via /etc/crontab file:
Directory |Description
|:-- |:--
/etc/cron.d/ | Put all scripts here and call them from /etc/crontab file.
/etc/cron.daily/ | Run all scripts once a day
/etc/cron.hourly/ | Run all scripts once an hour
/etc/cron.monthly/ | Run all scripts once a month
/etc/cron.weekly/ | Run all scripts once a week
### Backup cronjob
```
# crontab -l > /path/to/file
# crontab -u user -l > /path/to/file
```
--------------------------------------------------------------------------------
via: https://www.unixmen.com/add-cron-jobs-linux-unix/?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%3A+unixmenhowtos+%28Unixmen+Howtos+%26+Tutorials%29
作者:[Duy NguyenViet][a]
译者:[译者ID](https://github.com/译者ID)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译,[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://www.unixmen.com/author/duynv/
[1]: http://www.manpager.com/linux/man8/cron.8.html
[2]: http://www.linuxsecrets.com/
[3]: http://www.linuxsecrets.com/linux-hardware/

View File

@ -1,319 +0,0 @@
LFCS 第十讲:学习简单的 Shell 脚本编程和文件系统故障排除
================================================================================
Linux 基金会发起了 LFCS 认证 (Linux Foundation Certified Sysadmin, Linux 基金会认证系统管理员),这是一个全新的认证体系,主要目标是让全世界任何人都有机会考取认证。认证内容为 Linux 中间系统的管理,主要包括:系统运行和服务的维护、全面监控和分析的能力以及问题来临时何时想上游团队请求帮助的决策能力
![Basic Shell Scripting and Filesystem Troubleshooting](http://www.tecmint.com/wp-content/uploads/2014/11/lfcs-Part-10.png)
LFCS 系列第十讲
请看以下视频,这里边介绍了 Linux 基金会认证程序。
youtube 视频
<video src="https://dn-linuxcn.qbox.me/static%2Fvideo%2FIntroducing%20The%20Linux%20Foundation%20Certification%20Program-Y29qZ71Kicg.mp4" controls="controls" width="100%">
</video>
本讲是系列教程中的第十讲,主要集中讲解简单的 Shell 脚本编程和文件系统故障排除。这两块内容都是 LFCS 认证中的必备考点。
### 理解终端 (Terminals) 和 Shell ###
首先要声明一些概念。
- Shell 是一个程序,它将命令传递给操作系统来执行。
- Terminal 也是一个程序,作为最终用户,我们需要使用它与 Shell 来交互。比如,下边的图片是 GNOME Terminal。
![Gnome Terminal](http://www.tecmint.com/wp-content/uploads/2014/11/Gnome-Terminal.png)
Gnome Terminal
启动 Shell 之后,会呈现一个命令提示符 (也称为命令行) 提示我们 Shell 已经做好了准备,接受标准输入设备输入的命令,这个标准输入设备通常是键盘。
你可以参考该系列文章的 [第一讲 使用命令创建、编辑和操作文件][1] 来温习一些常用的命令。
Linux 为提供了许多可以选用的 Shell下面列出一些常用的
**bash Shell**
Bash 代表 Bourne Again Shell它是 GNU 项目默认的 Shell。它借鉴了 Korn shell (ksh) 和 C shell (csh) 中有用的特性,并同时对性能进行了提升。它同时也是 LFCS 认证中所涵盖的风发行版中默认 Shell也是本系列教程将使用的 Shell。
**sh Shell**
Bash Shell 是一个比较古老的 shell一次多年来都是多数类 Unix 系统的默认 shell。
**ksh Shell**
Korn SHell (ksh shell) 也是一个 Unix shell是贝尔实验室 (Bell Labs) 的 David Korn 在 19 世纪 80 年代初的时候开发的。它兼容 Bourne shell ,并同时包含了 C shell 中的多数特性。
一个 shell 脚本仅仅只是一个可执行的文本文件,里边包含一条条可执行命令。
### 简单的 Shell 脚本编程 ###
As mentioned earlier, a shell script is born as a plain text file. Thus, can be created and edited using our preferred text editor. You may want to consider using vi/m (refer to [Usage of vi Editor Part 2][2] of this series), which features syntax highlighting for your convenience.
Type the following command to create a file named myscript.sh and press Enter.
# vim myscript.sh
The very first line of a shell script must be as follows (also known as a shebang).
#!/bin/bash
It “tells” the operating system the name of the interpreter that should be used to run the text that follows.
Now its time to add our commands. We can clarify the purpose of each command, or the entire script, by adding comments as well. Note that the shell ignores those lines beginning with a pound sign # (explanatory comments).
#!/bin/bash
echo This is Part 10 of the 10-article series about the LFCS certification
echo Today is $(date +%Y-%m-%d)
Once the script has been written and saved, we need to make it executable.
# chmod 755 myscript.sh
Before running our script, we need to say a few words about the $PATH environment variable. If we run,
echo $PATH
from the command line, we will see the contents of $PATH: a colon-separated list of directories that are searched when we enter the name of a executable program. It is called an environment variable because it is part of the shell environment a set of information that becomes available for the shell and its child processes when the shell is first started.
When we type a command and press Enter, the shell searches in all the directories listed in the $PATH variable and executes the first instance that is found. Lets see an example,
![Linux Environment Variables](http://www.tecmint.com/wp-content/uploads/2014/11/Environment-Variable.png)
Environment Variables
If there are two executable files with the same name, one in /usr/local/bin and another in /usr/bin, the one in the first directory will be executed first, whereas the other will be disregarded.
If we havent saved our script inside one of the directories listed in the $PATH variable, we need to append ./ to the file name in order to execute it. Otherwise, we can run it just as we would do with a regular command.
# pwd
# ./myscript.sh
# cp myscript.sh ../bin
# cd ../bin
# pwd
# myscript.sh
![Execute Script in Linux](http://www.tecmint.com/wp-content/uploads/2014/11/Execute-Script.png)
Execute Script
#### Conditionals ####
Whenever you need to specify different courses of action to be taken in a shell script, as result of the success or failure of a command, you will use the if construct to define such conditions. Its basic syntax is:
if CONDITION; then
COMMANDS;
else
OTHER-COMMANDS
fi
Where CONDITION can be one of the following (only the most frequent conditions are cited here) and evaluates to true when:
- [ -a file ] → file exists.
- [ -d file ] → file exists and is a directory.
- [ -f file ] →file exists and is a regular file.
- [ -u file ] →file exists and its SUID (set user ID) bit is set.
- [ -g file ] →file exists and its SGID bit is set.
- [ -k file ] →file exists and its sticky bit is set.
- [ -r file ] →file exists and is readable.
- [ -s file ]→ file exists and is not empty.
- [ -w file ]→file exists and is writable.
- [ -x file ] is true if file exists and is executable.
- [ string1 = string2 ] → the strings are equal.
- [ string1 != string2 ] →the strings are not equal.
[ int1 op int2 ] should be part of the preceding list, while the items that follow (for example, -eq > is true if int1 is equal to int2.) should be a “children” list of [ int1 op int2 ] where op is one of the following comparison operators.
- -eq > is true if int1 is equal to int2.
- -ne > true if int1 is not equal to int2.
- -lt > true if int1 is less than int2.
- -le > true if int1 is less than or equal to int2.
- -gt > true if int1 is greater than int2.
- -ge > true if int1 is greater than or equal to int2.
#### For Loops ####
This loop allows to execute one or more commands for each value in a list of values. Its basic syntax is:
for item in SEQUENCE; do
COMMANDS;
done
Where item is a generic variable that represents each value in SEQUENCE during each iteration.
#### While Loops ####
This loop allows to execute a series of repetitive commands as long as the control command executes with an exit status equal to zero (successfully). Its basic syntax is:
while EVALUATION_COMMAND; do
EXECUTE_COMMANDS;
done
Where EVALUATION_COMMAND can be any command(s) that can exit with a success (0) or failure (other than 0) status, and EXECUTE_COMMANDS can be any program, script or shell construct, including other nested loops.
#### Putting It All Together ####
We will demonstrate the use of the if construct and the for loop with the following example.
**Determining if a service is running in a systemd-based distro**
Lets create a file with a list of services that we want to monitor at a glance.
# cat myservices.txt
sshd
mariadb
httpd
crond
firewalld
![Script to Monitor Linux Services](http://www.tecmint.com/wp-content/uploads/2014/11/Monitor-Services.png)
Script to Monitor Linux Services
Our shell script should look like.
#!/bin/bash
# This script iterates over a list of services and
# is used to determine whether they are running or not.
for service in $(cat myservices.txt); do
systemctl status $service | grep --quiet "running"
if [ $? -eq 0 ]; then
echo $service "is [ACTIVE]"
else
echo $service "is [INACTIVE or NOT INSTALLED]"
fi
done
![Linux Service Monitoring Script](http://www.tecmint.com/wp-content/uploads/2014/11/Monitor-Script.png)
Linux Service Monitoring Script
**Lets explain how the script works.**
1). The for loop reads the myservices.txt file one element of LIST at a time. That single element is denoted by the generic variable named service. The LIST is populated with the output of,
# cat myservices.txt
2). The above command is enclosed in parentheses and preceded by a dollar sign to indicate that it should be evaluated to populate the LIST that we will iterate over.
3). For each element of LIST (meaning every instance of the service variable), the following command will be executed.
# systemctl status $service | grep --quiet "running"
This time we need to precede our generic variable (which represents each element in LIST) with a dollar sign to indicate its a variable and thus its value in each iteration should be used. The output is then piped to grep.
The quiet flag is used to prevent grep from displaying to the screen the lines where the word running appears. When that happens, the above command returns an exit status of 0 (represented by $? in the if construct), thus verifying that the service is running.
An exit status different than 0 (meaning the word running was not found in the output of systemctl status $service) indicates that the service is not running.
![Services Monitoring Script](http://www.tecmint.com/wp-content/uploads/2014/11/Services-Monitoring-Script.png)
Services Monitoring Script
We could go one step further and check for the existence of myservices.txt before even attempting to enter the for loop.
#!/bin/bash
# This script iterates over a list of services and
# is used to determine whether they are running or not.
if [ -f myservices.txt ]; then
for service in $(cat myservices.txt); do
systemctl status $service | grep --quiet "running"
if [ $? -eq 0 ]; then
echo $service "is [ACTIVE]"
else
echo $service "is [INACTIVE or NOT INSTALLED]"
fi
done
else
echo "myservices.txt is missing"
fi
**Pinging a series of network or internet hosts for reply statistics**
You may want to maintain a list of hosts in a text file and use a script to determine every now and then whether theyre pingable or not (feel free to replace the contents of myhosts and try for yourself).
The read shell built-in command tells the while loop to read myhosts line by line and assigns the content of each line to variable host, which is then passed to the ping command.
#!/bin/bash
# This script is used to demonstrate the use of a while loop
while read host; do
ping -c 2 $host
done < myhosts
![Script to Ping Servers](http://www.tecmint.com/wp-content/uploads/2014/11/Script-to-Ping-Servers.png)
Script to Ping Servers
Read Also:
- [Learn Shell Scripting: A Guide from Newbies to System Administrator][3]
- [5 Shell Scripts to Learn Shell Programming][4]
### Filesystem Troubleshooting ###
Although Linux is a very stable operating system, if it crashes for some reason (for example, due to a power outage), one (or more) of your file systems will not be unmounted properly and thus will be automatically checked for errors when Linux is restarted.
In addition, each time the system boots during a normal boot, it always checks the integrity of the filesystems before mounting them. In both cases this is performed using a tool named fsck (“file system check”).
fsck will not only check the integrity of file systems, but also attempt to repair corrupt file systems if instructed to do so. Depending on the severity of damage, fsck may succeed or not; when it does, recovered portions of files are placed in the lost+found directory, located in the root of each file system.
Last but not least, we must note that inconsistencies may also happen if we try to remove an USB drive when the operating system is still writing to it, and may even result in hardware damage.
The basic syntax of fsck is as follows:
# fsck [options] filesystem
**Checking a filesystem for errors and attempting to repair automatically**
In order to check a filesystem with fsck, we must first unmount it.
# mount | grep sdg1
# umount /mnt
# fsck -y /dev/sdg1
![Scan Linux Filesystem for Errors](http://www.tecmint.com/wp-content/uploads/2014/11/Check-Filesystem-Errors.png)
Check Filesystem Errors
Besides the -y flag, we can use the -a option to automatically repair the file systems without asking any questions, and force the check even when the filesystem looks clean.
# fsck -af /dev/sdg1
If were only interested in finding out whats wrong (without trying to fix anything for the time being) we can run fsck with the -n option, which will output the filesystem issues to standard output.
# fsck -n /dev/sdg1
Depending on the error messages in the output of fsck, we will know whether we can try to solve the issue ourselves or escalate it to engineering teams to perform further checks on the hardware.
### 总结 ###
We have arrived at the end of this 10-article series where have tried to cover the basic domain competencies required to pass the LFCS exam.
For obvious reasons, it is not possible to cover every single aspect of these topics in any single tutorial, and thats why we hope that these articles have put you on the right track to try new stuff yourself and continue learning.
If you have any questions or comments, they are always welcome so dont hesitate to drop us a line via the form below!
--------------------------------------------------------------------------------
via: http://www.tecmint.com/linux-basic-shell-scripting-and-linux-filesystem-troubleshooting/
作者:[Gabriel Cánepa][a]
译者:[GHLandy](https://github.com/GHLandy)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创翻译,[Linux中国](https://linux.cn/) 荣誉推出
[a]:http://www.tecmint.com/author/gacanepa/
[1]:http://www.tecmint.com/sed-command-to-create-edit-and-manipulate-files-in-linux/
[2]:http://www.tecmint.com/vi-editor-usage/
[3]:http://www.tecmint.com/learning-shell-scripting-language-a-guide-from-newbies-to-system-administrator/
[4]:http://www.tecmint.com/basic-shell-programming-part-ii/

View File

@ -0,0 +1,180 @@
Part 12 - LFCS: How to Explore Linux with Installed Help Documentations and Tools
==================================================================================
Because of the changes in the LFCS exam requirements effective Feb. 2, 2016, we are adding the necessary topics to the [LFCS series][1] published here. To prepare for this exam, your are highly encouraged to use the [LFCE series][2] as well.
![](http://www.tecmint.com/wp-content/uploads/2016/03/Explore-Linux-with-Documentation-and-Tools.png)
>LFCS: Explore Linux with Installed Documentations and Tools Part 12
Once you get used to working with the command line and feel comfortable doing so, you realize that a regular Linux installation includes all the documentation you need to use and configure the system.
Another good reason to become familiar with command line help tools is that in the [LFCS][3] and [LFCE][4] exams, those are the only sources of information you can use no internet browsing and no googling. Its just you and the command line.
For that reason, in this article we will give you some tips to effectively use the installed docs and tools in order to prepare to pass the **Linux Foundation Certification** exams.
### Linux Man Pages
A man page, short for manual page, is nothing less and nothing more than what the word suggests: a manual for a given tool. It contains the list of options (with explanation) that the command supports, and some man pages even include usage examples as well.
To open a man page, use the **man command** followed by the name of the tool you want to learn more about. For example:
```
# man diff
```
will open the manual page for `diff`, a tool used to compare text files line by line (to exit, simply hit the q key.).
Lets say we want to compare two text files named `file1` and `file2` in Linux. These files contain the list of packages that are installed in two Linux boxes with the same distribution and version.
Doing a `diff` between `file1` and `file2` will tell us if there is a difference between those lists:
```
# diff file1 file2
```
![](http://www.tecmint.com/wp-content/uploads/2016/03/Compare-Two-Text-Files-in-Linux.png)
>Compare Two Text Files in Linux
where the `<` sign indicates lines missing in `file2`. If there were lines missing in `file1`, they would be indicated by the `>` sign instead.
On the other hand, **7d6** means line **#7** in file should be deleted in order to match `file2` (same with **24d22** and **41d38**), and 65,67d61 tells us we need to remove lines **65** through **67** in file one. If we make these corrections, both files will then be identical.
Alternatively, you can display both files side by side using the `-y` option, according to the man page. You may find this helpful to more easily identify missing lines in files:
```
# diff -y file1 file2
```
![](http://www.tecmint.com/wp-content/uploads/2016/03/Compare-and-List-Difference-of-Two-Files.png)
>Compare and List Difference of Two Files
Also, you can use `diff` to compare two binary files. If they are identical, `diff` will exit silently without output. Otherwise, it will return the following message: “**Binary files X and Y differ**”.
### The help Option
The `--help` option, available in many (if not all) commands, can be considered a short manual page for that specific command. Although it does not provide a comprehensive description of the tool, it is an easy way to obtain information on the usage of a program and a list of its available options at a quick glance.
For example,
```
# sed --help
```
shows the usage of each option available in sed (the stream editor).
One of the classic examples of using `sed` consists of replacing characters in files. Using the `-i` option (described as “**edit files in place**”), you can edit a file without opening it. If you want to make a backup of the original contents as well, use the `-i` option followed by a SUFFIX to create a separate file with the original contents.
For example, to replace each occurrence of the word `Lorem` with `Tecmint` (case insensitive) in `lorem.txt` and create a new file with the original contents of the file, do:
```
# less lorem.txt | grep -i lorem
# sed -i.orig 's/Lorem/Tecmint/gI' lorem.txt
# less lorem.txt | grep -i lorem
# less lorem.txt.orig | grep -i lorem
```
Please note that every occurrence of `Lorem` has been replaced with `Tecmint` in `lorem.txt`, and the original contents of `lorem.txt` has been saved to `lorem.txt.orig`.
![](http://www.tecmint.com/wp-content/uploads/2016/03/Replace-A-String-in-File.png)
>Replace A String in Files
### Installed Documentation in /usr/share/doc
This is probably my favorite pick. If you go to `/usr/share/doc` and do a directory listing, you will see lots of directories with the names of the installed tools in your Linux system.
According to the [Filesystem Hierarchy Standard][5], these directories contain useful information that might not be in the man pages, along with templates and configuration files to make configuration easier.
For example, lets consider `squid-3.3.8` (version may vary from distribution to distribution) for the popular HTTP proxy and [squid cache server][6].
Lets `cd` into that directory:
```
# cd /usr/share/doc/squid-3.3.8
```
and do a directory listing:
```
# ls
```
![](http://www.tecmint.com/wp-content/uploads/2016/03/List-Files-in-Linux.png)
>Linux Directory Listing with ls Command
You may want to pay special attention to `QUICKSTART` and `squid.conf.documented`. These files contain an extensive documentation about Squid and a heavily commented configuration file, respectively. For other packages, the exact names may differ (as **QuickRef** or **00QUICKSTART**, for example), but the principle is the same.
Other packages, such as the Apache web server, provide configuration file templates inside `/usr/share/doc`, that will be helpful when you have to configure a standalone server or a virtual host, to name a few cases.
### GNU info Documentation
You can think of info documents as man pages on steroids. As such, they not only provide help for a specific tool, but also they do so with hyperlinks (yes, hyperlinks in the command line!) that allow you to navigate from a section to another using the arrow keys and Enter to confirm.
Perhaps the most illustrative example is:
```
# info coreutils
```
Since coreutils contains the [basic file, shell and text manipulation utilities][7] which are expected to exist on every operating system, you can reasonably expect a detailed description for each one of those categories in info **coreutils**.
![](http://www.tecmint.com/wp-content/uploads/2016/03/Info-Coreutils.png)
>Info Coreutils
As it is the case with man pages, you can exit an info document by pressing the `q` key.
Additionally, GNU info can be used to display regular man pages as well when followed by the tool name. For example:
```
# info tune2fs
```
will return the man page of **tune2fs**, the ext2/3/4 filesystems management tool.
And now that were at it, lets review some of the uses of **tune2fs**:
Display information about the filesystem on top of **/dev/mapper/vg00-vol_backups**:
```
# tune2fs -l /dev/mapper/vg00-vol_backups
```
Set a filesystem volume name (Backups in this case):
```
# tune2fs -L Backups /dev/mapper/vg00-vol_backups
```
Change the check intervals and `/` or mount counts (use the `-c` option to set a number of mount counts and `/` or the `-i` option to set a check interval, where **d=days, w=weeks, and m=months**).
```
# tune2fs -c 150 /dev/mapper/vg00-vol_backups # Check every 150 mounts
# tune2fs -i 6w /dev/mapper/vg00-vol_backups # Check every 6 weeks
```
All of the above options can be listed with the `--help` option, or viewed in the man page.
### Summary
Regardless of the method that you choose to invoke help for a given tool, knowing that they exist and how to use them will certainly come in handy in the exam. Do you know of any other tools that can be used to look up documentation? Feel free to share with the Tecmint community using the form below.
Questions and other comments are more than welcome as well.
--------------------------------------------------------------------------------
via: http://www.tecmint.com/linux-basic-shell-scripting-and-linux-filesystem-troubleshooting/
作者:[Gabriel Cánepa][a]
译者:[译者ID](https://github.com/译者ID)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创翻译,[Linux中国](https://linux.cn/) 荣誉推出
[a]:http://www.tecmint.com/author/gacanepa/
[1]: http://www.tecmint.com/sed-command-to-create-edit-and-manipulate-files-in-linux/
[2]: http://www.tecmint.com/installing-network-services-and-configuring-services-at-system-boot/
[3]: http://www.tecmint.com/sed-command-to-create-edit-and-manipulate-files-in-linux/
[4]: http://www.tecmint.com/installing-network-services-and-configuring-services-at-system-boot/
[5]: http://www.tecmint.com/linux-directory-structure-and-important-files-paths-explained/
[6]: http://www.tecmint.com/configure-squid-server-in-linux/
[7]: http://www.tecmint.com/sed-command-to-create-edit-and-manipulate-files-in-linux/
[8]:

View File

@ -0,0 +1,185 @@
Part 13 - LFCS: How to Configure and Troubleshoot Grand Unified Bootloader (GRUB)
=====================================================================================
Because of the changes in the LFCS exam requirements effective Feb. 2, 2016, we are adding the necessary topics to the [LFCS series][1] published here. To prepare for this exam, your are highly encouraged to use the [LFCE series][2] as well.
![](http://www.tecmint.com/wp-content/uploads/2016/03/Configure-Troubleshoot-Grub-Boot-Loader.png)
>LFCS: Configure and Troubleshoot Grub Boot Loader Part 13
In this article we will introduce you to GRUB and explain why a boot loader is necessary, and how it adds versatility to the system.
The [Linux boot process][3] from the time you press the power button of your computer until you get a fully-functional system follows this high-level sequence:
* 1. A process known as **POST** (**Power-On Self Test**) performs an overall check on the hardware components of your computer.
* 2. When **POST** completes, it passes the control over to the boot loader, which in turn loads the Linux kernel in memory (along with **initramfs**) and executes it. The most used boot loader in Linux is the **GRand Unified Boot loader**, or **GRUB** for short.
* 3. The kernel checks and accesses the hardware, and then runs the initial process (mostly known by its generic name “**init**”) which in turn completes the system boot by starting services.
In Part 7 of this series (“[SysVinit, Upstart, and Systemd][4]”) we introduced the [service management systems and tools][5] used by modern Linux distributions. You may want to review that article before proceeding further.
### Introducing GRUB Boot Loader
Two major **GRUB** versions (**v1** sometimes called **GRUB Legacy** and **v2**) can be found in modern systems, although most distributions use **v2** by default in their latest versions. Only **Red Hat Enterprise Linux 6** and its derivatives still use **v1** today.
Thus, we will focus primarily on the features of **v2** in this guide.
Regardless of the **GRUB** version, a boot loader allows the user to:
* 1). modify the way the system behaves by specifying different kernels to use,
* 2). choose between alternate operating systems to boot, and
* 3). add or edit configuration stanzas to change boot options, among other things.
Today, **GRUB** is maintained by the **GNU** project and is well documented in their website. You are encouraged to use the [GNU official documentation][6] while going through this guide.
When the system boots you are presented with the following **GRUB** screen in the main console. Initially, you are prompted to choose between alternate kernels (by default, the system will boot using the latest kernel) and are allowed to enter a **GRUB** command line (with `c`) or edit the boot options (by pressing the `e` key).
![](http://www.tecmint.com/wp-content/uploads/2016/03/GRUB-Boot-Screen.png)
>GRUB Boot Screen
One of the reasons why you would consider booting with an older kernel is a hardware device that used to work properly and has started “acting up” after an upgrade (refer to [this link][7] in the AskUbuntu forums for an example).
The **GRUB v2** configuration is read on boot from `/boot/grub/grub.cfg` or `/boot/grub2/grub.cfg`, whereas `/boot/grub/grub.conf` or `/boot/grub/menu.lst` are used in **v1**. These files are NOT to be edited by hand, but are modified based on the contents of `/etc/default/grub` and the files found inside `/etc/grub.d`.
In a **CentOS 7**, heres the configuration file that is created when the system is first installed:
```
GRUB_TIMEOUT=5
GRUB_DISTRIBUTOR="$(sed 's, release .*$,,g' /etc/system-release)"
GRUB_DEFAULT=saved
GRUB_DISABLE_SUBMENU=true
GRUB_TERMINAL_OUTPUT="console"
GRUB_CMDLINE_LINUX="vconsole.keymap=la-latin1 rd.lvm.lv=centos_centos7-2/swap crashkernel=auto vconsole.font=latarcyrheb-sun16 rd.lvm.lv=centos_centos7-2/root rhgb quiet"
GRUB_DISABLE_RECOVERY="true"
```
In addition to the online documentation, you can also find the GNU GRUB manual using info as follows:
```
# info grub
```
If youre interested specifically in the options available for /etc/default/grub, you can invoke the configuration section directly:
```
# info -f grub -n 'Simple configuration'
```
Using the command above you will find out that `GRUB_TIMEOUT` sets the time between the moment when the initial screen appears and the system automatic booting begins unless interrupted by the user. When this variable is set to `-1`, boot will not be started until the user makes a selection.
When multiple operating systems or kernels are installed in the same machine, `GRUB_DEFAULT` requires an integer value that indicates which OS or kernel entry in the GRUB initial screen should be selected to boot by default. The list of entries can be viewed not only in the splash screen shown above, but also using the following command:
### In CentOS and openSUSE:
```
# awk -F\' '$1=="menuentry " {print $2}' /boot/grub2/grub.cfg
```
### In Ubuntu:
```
# awk -F\' '$1=="menuentry " {print $2}' /boot/grub/grub.cfg
```
In the example shown in the below image, if we wish to boot with the kernel version **3.10.0-123.el7.x86_64** (4th entry), we need to set `GRUB_DEFAULT` to `3` (entries are internally numbered beginning with zero) as follows:
```
GRUB_DEFAULT=3
```
![](http://www.tecmint.com/wp-content/uploads/2016/03/Boot-System-with-Old-Kernel-Version.png)
>Boot System with Old Kernel Version
One final GRUB configuration variable that is of special interest is `GRUB_CMDLINE_LINUX`, which is used to pass options to the kernel. The options that can be passed through GRUB to the kernel are well documented in the [Kernel Parameters file][8] and in [man 7 bootparam][9].
Current options in my **CentOS 7** server are:
```
GRUB_CMDLINE_LINUX="vconsole.keymap=la-latin1 rd.lvm.lv=centos_centos7-2/swap crashkernel=auto vconsole.font=latarcyrheb-sun16 rd.lvm.lv=centos_centos7-2/root rhgb quiet"
```
Why would you want to modify the default kernel parameters or pass extra options? In simple terms, there may be times when you need to tell the kernel certain hardware parameters that it may not be able to determine on its own, or to override the values that it would detect.
This happened to me not too long ago when I tried **Vector Linux**, a derivative of **Slackware**, on my 10-year old laptop. After installation it did not detect the right settings for my video card so I had to modify the kernel options passed through GRUB in order to make it work.
Another example is when you need to bring the system to single-user mode to perform maintenance tasks. You can do this by appending the word single to `GRUB_CMDLINE_LINUX` and rebooting:
```
GRUB_CMDLINE_LINUX="vconsole.keymap=la-latin1 rd.lvm.lv=centos_centos7-2/swap crashkernel=auto vconsole.font=latarcyrheb-sun16 rd.lvm.lv=centos_centos7-2/root rhgb quiet single"
```
After editing `/etc/defalt/grub`, you will need to run `update-grub` (Ubuntu) or `grub2-mkconfig -o /boot/grub2/grub.cfg` (**CentOS** and **openSUSE**) afterwards to update `grub.cfg` (otherwise, changes will be lost upon boot).
This command will process the boot configuration files mentioned earlier to update `grub.cfg`. This method ensures changes are permanent, while options passed through GRUB at boot time will only last during the current session.
### Fixing Linux GRUB Issues
If you install a second operating system or if your GRUB configuration file gets corrupted due to human error, there are ways you can get your system back on its feet and be able to boot again.
In the initial screen, press `c` to get a GRUB command line (remember that you can also press `e` to edit the default boot options), and use help to bring the available commands in the GRUB prompt:
![](http://www.tecmint.com/wp-content/uploads/2016/03/Fix-Grub-Issues-in-Linux.png)
>Fix Grub Configuration Issues in Linux
We will focus on **ls**, which will list the installed devices and filesystems, and we will examine what it finds. In the image below we can see that there are 4 hard drives (`hd0` through `hd3`).
Only `hd0` seems to have been partitioned (as evidenced by msdos1 and msdos2, where 1 and 2 are the partition numbers and msdos is the partitioning scheme).
Lets now examine the first partition on `hd0` (**msdos1**) to see if we can find GRUB there. This approach will allow us to boot Linux and there use other high level tools to repair the configuration file or reinstall GRUB altogether if it is needed:
```
# ls (hd0,msdos1)/
```
As we can see in the highlighted area, we found the `grub2` directory in this partition:
![](http://www.tecmint.com/wp-content/uploads/2016/03/Find-Grub-Configuration.png)
>Find Grub Configuration
Once we are sure that GRUB resides in (**hd0,msdos1**), lets tell GRUB where to find its configuration file and then instruct it to attempt to launch its menu:
```
set prefix=(hd0,msdos1)/grub2
set root=(hd0,msdos1)
insmod normal
normal
```
![](http://www.tecmint.com/wp-content/uploads/2016/03/Find-and-Launch-Grub-Menu.png)
>Find and Launch Grub Menu
Then in the GRUB menu, choose an entry and press **Enter** to boot using it. Once the system has booted you can issue the `grub2-install /dev/sdX` command (change `sdX` with the device you want to install GRUB on). The boot information will then be updated and all related files be restored.
```
# grub2-install /dev/sdX
```
Other more complex scenarios are documented, along with their suggested fixes, in the [Ubuntu GRUB2 Troubleshooting guide][10]. The concepts explained there are valid for other distributions as well.
### Summary
In this article we have introduced you to GRUB, indicated where you can find documentation both online and offline, and explained how to approach an scenario where a system has stopped booting properly due to a bootloader-related issue.
Fortunately, GRUB is one of the tools that is best documented and you can easily find help either in the installed docs or online using the resources we have shared in this article.
Do you have questions or comments? Dont hesitate to let us know using the comment form below. We look forward to hearing from you!
--------------------------------------------------------------------------------
via: http://www.tecmint.com/linux-basic-shell-scripting-and-linux-filesystem-troubleshooting/
作者:[Gabriel Cánepa][a]
译者:[译者ID](https://github.com/译者ID)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创翻译,[Linux中国](https://linux.cn/) 荣誉推出
[a]: http://www.tecmint.com/author/gacanepa/
[1]: http://www.tecmint.com/sed-command-to-create-edit-and-manipulate-files-in-linux/
[2]: http://www.tecmint.com/installing-network-services-and-configuring-services-at-system-boot/
[3]: http://www.tecmint.com/linux-boot-process/
[4]: http://www.tecmint.com/linux-boot-process-and-manage-services/
[5]: http://www.tecmint.com/best-linux-log-monitoring-and-management-tools/
[6]: http://www.gnu.org/software/grub/manual/
[7]: http://askubuntu.com/questions/82140/how-can-i-boot-with-an-older-kernel-version
[8]: https://www.kernel.org/doc/Documentation/kernel-parameters.txt
[9]: http://man7.org/linux/man-pages/man7/bootparam.7.html
[10]: https://help.ubuntu.com/community/Grub2/Troubleshooting

View File

@ -0,0 +1,103 @@
一位跨平台开发者的自白
=============================================
![](https://opensource.com/sites/default/files/styles/image-full-size/public/images/business/business_clouds.png?itok=cucHuJnU)
Andreia Gaita[1]将会在OSCON开源大会上发表一个题为[跨平台开发者的自白][2]的演讲。她长期从事于开源工作并且为Mono[3]【译者注:一个致力于开创.NET在Linux上使用的开源工程】工程做着贡献。Andreia任职于GitHub她的工作是专注于为Visual Studio构建github上的可扩展管理器。
我在她发表演讲前就迫不及待的想要问她一些关于跨平台开发的事作为一名跨平台开发者她已经有了16年的学习经验了。
![](https://opensource.com/sites/default/files/images/life/Interview%20banner%20Q%26A.png)
**在你跨平台工作的过程中,你使用过的最简单的和最难的代码语言是什么?**
很少讨论某种语言的好坏,大多数是关于对于这种语言的库和工具的易用性。编译器、解释器以及构建器语言决定了用它们做跨平台开发的难易程度(不论它是否可能)能够实现UI和本地系统访问的函数库的可用性都决定了开发时兼容操作系统的程度。如果这样想我认为C#最适合完成跨平台开发工作。这种语言有它自己的特色它允许本地快速唤醒和精确的内存地址如果你希望你的代码能够与系统和本地函数库进行交互那么你就会需要C#。当我需要特殊的系统集成的时候我就会切换到C或者C++。
**你使用的跨平台开发工具或者抽象有哪些?**
我的大部分跨平台工作都是为其他人开发工具和库然后把它们组合起来开发跨平台的应用程序其中大多用到MONO/C#。说真的我不太懂抽象。大多数时候我依赖Mono去完成一个跨平台的app开发以及它的UI或者一个偶然的游戏开发中的Unity3D部分。我经常使用Electron【译者注Atom编辑器的兄弟项目可以用Electron开发桌面应用】。
**你接触过哪些构建系统?它们之间的区别是由于语言还是平台的不同?**
我试着选择适合我使用语言的构建系统。那样 就会很少遇到让我头疼的问题。它需要支持平台和体系结构间的选择、构建智能工件位置多个并行构建以及易配置性等。大多数时候我的项目会结合C/C++和C#同时我也想要为一些开源分支构建相应的配置环境Debug, Release, Windows, OSX, Linux, Android, iOS, etc, etc.)通常也需要为每个构建的智能工件选择带有不同标志的编译器。所以我不得不做很多工作而这种以我的方式进行的工作并没有很多收获。我时常尝试着用不同的构建系统仅仅是想了解到最新的情况但是最终我还是回到使用makefile的情况采用shell和批处理脚本之一与Perl脚本相结合的方式以达到使用他们的目的因为如果我想用户去做很多我做的事情我还是最好选择一种命令行脚本语言这样它在哪里都可以用
**你怎样平衡在这种统一用户接口视觉体验需求上的强烈渴望呢?**
用户接口的跨平台实现很困难。在过去几年中我已经使用了一些跨平台GUI并且我认为一些问题没有最优解。那些问题都基于两种操作你也可以选择一个跨平台工具去做一个UI去用你所喜欢的所有的平台这样感觉不是太对用小的代码库和比较低的维护费用。或者你可以选择去开发一个特有平台的UI那样看起来就会是很本地化并且能很好的使其与一个大型的代码库结合也会有很高的维护费用。这种决定完全取决于APP的类型。它的特色在哪里呢?你有什么资源?你可以把它运行在多少平台上?
最后我认为用户对于这种框架性的“一个UI统治所有”的UI的容忍度更大了就比如Electron。我曾经有个Chromium+C+C#的框架侧项目并且希望我在一天内用C#构建Electron型的app这样的话我就可以做到两全其美了。
**你对构建或者打包有依赖性吗 ?**
我很少谈及依赖性问题。很多次我都被ABI【译者注:应用程序二进制接口】的崩溃、存在冲突的征兆以及包的丢失问题所困扰。我决定我要使用的操作系统的版本都是选择最低的依赖去使问题最小化。通常这就意味着有五种不同的Xcode的副本和OSX框架库 在同样的机器上有五种不同的Visual Studio版本需要相应的被安装多种clang【译者注C语言、C++、Object-C、C++语言的轻量级编译器】和gcc版本一系列的可以运行的其他的VM版本。如果我不能确定我要使用的操作系统的包的规定我时常会连接静态库与子模块之间的依赖确保它们一直可用。大多时候我会避免这些很棘手的问题除非我非常需要使用他们。
**你使用能够持续集成的、代码重读的相关工具吗?**
基本每天都用。这是保持高效的唯一方式。我在一个项目中做的第一件事情是配置跨平台构建脚本保证每件事尽可能自动化完成。当你想要使用多平台的时候CI【译者注持续集成】是至关重要的。在一个机器上没有人能结合所有的不同的平台。并且一旦你的构建过程没有包含所有的平台你就不会注意到你搞砸的事情。在一个共享的多平台代码库中 不同的人拥有不同的平台和特征所以仅有的方法是保证跨团队浏览代码时结合CI和其他分析工具的公平性。这不同于其他的软件项目如果不使用相关的工具就只有失败了。
**你依赖于自动构建测试或者趋向于在每个平台上构建并且进行局部测试吗?**
对于不包括UI的工具和库我通常能够侥幸完成自动构建测试。如果那是一个UI两种方法我都会用到——做一个可靠的可自动编写脚本的UI因为基本没有GUI工具所以我不得不在去创建UI自动化工具这种工具可以工作在所有的我用到的平台上或者我也可以手动完成。如果一个项目使用一个定制的UI工具一个像Unity3D那样做的OpenGL UI ),开发自动化的可编写脚本工具和更多的自动化工具就相当容易。不过,没有什么东西会像人类一样通过双击而搞砸事情。
**如果你要做跨平台开发你想要在不同的平台上使用不同的编辑器比如在Windows上使用Visual Studio在Linux上使用Qt Creator在Mac上使用XCode吗还是你更趋向于使用Eclipse这样的可以在所有平台上使用的编辑器**
我喜欢使用不同的编辑器构建系统。我更喜欢在不同的带有构建脚本的IDE上保存项目文件可以使增加IDE变得更容易这些脚本可以为他们支持的平台去驱动IDE开始工作。对于一个开发者来说编辑器是最重要的工具开发者花费时间和精力去学习使用各种编辑器但是它们都不能相互替代。我使用我最喜欢的编辑器和工具每个人也应该能使用他们最喜爱的工具。
**在跨平台开发的时候你更喜欢使用什么开发环境和IDE呢**
跨平台开发者好像被诅咒一样他们不得不选择小众化的编辑器去完成大多数跨平台的工作。我爱用Visual Studio但是我不能依赖它完成除windows平台外的工作你可能不想让windows成为你的初级交叉编译平台所以我不会使用它作为我的初级集成开发环境。即使我这么做了跨平台开发者的潜意识也知道有可能会用到很多平台。这就意味着必须很熟悉他们——使用一种平台上的编辑器就必须知道这种操作系统的设置运行方式以及它的局限性等。做这些事情就需要头脑清醒我的捷径是加强记忆我不得不依赖于跨平台编辑器。所以我使用Emacs 和Sublime。
**你最喜欢的过去跨平台项目是什么**
我一直很喜欢Mono,并且得心应手在一些开发中大多数的项目都是用一些方法围绕着它进行的。Gluezilla曾经是我在多年前开发的一个Mozilla【译者注Mozilla基金会为支持和领导开源Mozilla项目而设立的非营利组织】结合器可以C#开发的app嵌入到web浏览器试图中并且看起来很明显。在这一点上我开发过一个窗体app它是在linux上开发的它运行在带有一个嵌入GTK试图的windows系统上并且这个系统将会运行一个Mozilla浏览器试图。CppSharp项目(以前叫做Cxxi更早时叫做CppInterop)是一个我开始结合绑定有C#的C++库的项目这样就可以唤醒和创建实例来把C#结合到C++中。这样做的话它在运行的时候就能够发现所使用的平台以及用来创建本地运行库的编译器而且还为它生成正确的C#绑定。这多么有趣啊。
**你怎样看跨平台开发的未来趋势呢?**
我们构建本地应用程序的方式已经改变了,我觉得在各种桌面操作系统之间存在差异,而且这种差异将会变得更加微妙;所以构建跨平台的应用程序将会更加容易,而且这种应用程序即使没有在本平台也可以完全兼容。不好的是,这可能意味着应用程序很难获得,并且当在操作系统上使用的时候功能得不到最好的发挥。我们知道怎样把库和工具以及运行环境的跨平台开发做的更好,但是跨平台应用程序的开发仍然需要我们的努力。
--------------------------------------------------------------------------------
via: https://opensource.com/business/16/5/oscon-interview-andreia-gaita
作者:[Marcus D. Hanwell ][a]
译者:[vim-kakali](https://github.com/vim-kakali)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创翻译,[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/mhanwell
[1]: https://twitter.com/sh4na
[2]: http://conferences.oreilly.com/oscon/open-source-us/public/schedule/detail/48702
[3]: http://www.mono-project.com/

View File

@ -0,0 +1,67 @@
安卓的下一场革命:不安装即可使用应用!
===================================================================
谷歌安卓的一项新创新将让你可以使用没有在你的设备上安装的应用。现在已经有了一些原型了。
还记得某人给你发了一个链接,要求你安装一个应用来查看的情形吗?
是否要安装这个应用来查看一个一次性的链接,这个困境一定让你感到很挫败。而且,应用安装本身也会消耗你不少宝贵的时间。
上述场景可能大多数人都经历过,或者说大多数现代科技用户都经历过。尽管如此,我们都接受这是正确且合理的过程。
真的吗?
针对这个问题谷歌的安卓部门给出了一个全新的,开箱即用的答案:
### Android Instant Apps
Android Instant Apps 声称第一时间帮你摆脱这样的两难境地,让你简单地点击链接(见打开链接的示例)然后直接开始使用这个应用。
另一个真实生活场景的例子,如果你想停车但是没有停车码表的配对应用,有了 Instant Apps 在这种情况下就方便多了。
根据谷歌的信息,你可以简单地将你的手机和码表触碰,停车应用就会直接显示在你的屏幕上,并且准备就绪可以使用。
#### 它是怎么工作的?
Instant Apps 和你已经熟悉的应用基本相同,只有一个不同——这些应用为了满足你完成某项任务的需要,只提供给你已经经过**裁剪和模块化**的应用关键部分。
例如,展开打开链接的场景作为例子,为了查看一个链接,你不需要拥有一个可以写,发送,做咖啡或其它特性的全功能应用。你所需要的全部就是查看功能——而这就是你所会获取到的部分。
这样应用就可以快速打开,让你可以完成你的目标任务。
![](http://www.iwillfolo.com/wordpress/wp-content/uploads/2016/05/AIA-demo.jpg)
>AIA 示例
![](https://4.bp.blogspot.com/-p5WOrD6wVy8/VzyIpsDqULI/AAAAAAAADD0/xbtQjurJZ6EEji_MPaY1sLK5wVkXSvxJgCKgB/s800/B%2526H%2B-%2BDevice%2B%2528Final%2529.gif)
>B&H 图片(通过谷歌搜索)
![](https://2.bp.blogspot.com/-q5ApCzECuNA/VzyKa9l0t2I/AAAAAAAADEI/nYhhMClDl5Y3qL5-wiOb2J2QjtGWwbF2wCLcB/s800/BuzzFeed-Device-Install%2B%2528Final%2529.gif)
>BuzzFeedVideo通过一个共享链接
![](https://2.bp.blogspot.com/-mVhKMMzhxms/VzyKg25ihBI/AAAAAAAADEM/dJN6_8H7qkwRyulCF7Yr2234-GGUXzC6ACLcB/s800/Park%2Band%2BPay%2B-%2BDevice%2Bwith%2BMeter%2B%2528Final%2529.gif)
>停车与支付(例)(通过 NFC
听起来很棒,不是吗?但是其中还有很多技术方面的问题需要解决。
比如,从安全的观点来说:如果任何应用从理论上来说都能在你的设备上运行,甚至你都不用安装它——你要怎么保证设备远离恶意软件攻击?
因此,为了消除这类威胁,谷歌还在这个项目上努力,目前只有少数合作伙伴,未来将逐步扩展。
谷歌最终计划在明年发布 AIAAndroid Instant Apps
相关:[介绍 Android Instant Apps][1]
--------------------------------------------------------------------------------
via: http://www.iwillfolo.com/androids-next-revolution-use-apps-even-without-installing-them/
作者:[iwillfolo][a]
译者:[alim0x](https://github.com/alim0x)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译,[Linux中国](https://linux.cn/) 荣誉推出
[a]: http://www.iwillfolo.com
[1]: http://android-developers.blogspot.co.il/2016/05/android-instant-apps-evolving-apps.html?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed:+blogspot/hsDu+%28Android+Developers+Blog%29

View File

@ -0,0 +1,38 @@
谷歌会用基于信任的认证措施取代密码吗?
===========================================================================
![](http://www.iwillfolo.com/wordpress/wp-content/uploads/2016/05/Trust-API-Google-replaces-passwords.jpg)
一个谷歌新开发的认证措施会评估你的登录有多可靠并且基于一个“信任分Trust Score”认证你的登录。
这个谷歌项目的名字是 Abacus它的目标是让你摆脱讨厌的密码记忆和输入。
在最近的 Google I/O 开发者大会上,谷歌引入了自这个雄心勃勃的项目而来的新特性,称作“**Trust API**”。
“如果一切进展顺利”,这个 APIApplication Programming Interface应用程序编程接口会在年底前供安卓开发者使用。API 会利用安卓设备上不同的传感器来识别用户并创建一个他们称之为“信任分Trust Score”的结果。
基于这个信任分,一个需要登录认证的应用可以验证你确实可以授权登录,从而不会提示需要密码。
![](http://www.iwillfolo.com/wordpress/wp-content/uploads/2016/05/Abacus-to-Trust-API.jpg)
>Abacus 到 Trust API
### 需要思考的地方
尽管这个想法,明智的功能,听起来很棒——减轻了密码认证的负担。
但从另一面来说,这是不是谷歌又一次逼迫我们(有意或无意)为了方便使用而放弃我们的隐私?
是否值得?这取决于你的决定...
--------------------------------------------------------------------------------
via: http://www.iwillfolo.com/will-google-replace-passwords-with-a-new-trust-based-authentication-method/
作者:[iWillFolo][a]
译者:[alim0x](https://github.com/alim0x)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译,[Linux中国](https://linux.cn/) 荣誉推出
[a]: http://www.iwillfolo.com/

View File

@ -1,464 +0,0 @@
通过Dockerize这篇博客来开启我们的Docker之旅
===
>这篇文章将包含Docker的基本概念以及如何通过创建一个定制的Dockerfile来Dockerize一个应用
>作者Benjamin Cane2015-12-01 10:00:00
Docker是2年前从某个idea中孕育而生的有趣技术世界各地的公司组织都积极使用它来部署应用。在今天的文章中我将教你如何通过"Dockerize"一个现有的应用来开始我们的Docker运用。问题中的应用指的就是这篇博客
## 什么是Docker
当我们开始学习Docker基本概念时让我们先去搞清楚什么是Docker以及它为什么这么流行。Docker是一个操作系统容器管理工具它通过将应用打包在操作系统容器中来方便我们管理和部署应用。
### 容器 vs. 虚拟机
容器虽和虚拟机并不完全相似,但它也是一种提供**操作系统虚拟化**的方式。但是,它和标准的虚拟机还是有不同之处的。
标准虚拟机一般会包括一个完整的操作系统,操作系统包,最后还有一至两个应用。这都得益于为虚拟机提供硬件虚拟化的管理程序。这样一来,一个单一的服务器就可以将许多独立的操作系统作为虚拟客户机运行了。
容器和虚拟机很相似,它们都支持在单一的服务器上运行多个操作环境,只是,在容器中,这些环境并不是一个个完整的操作系统。容器一般只包含必要的操作系统包和一些应用。它们通常不会包含一个完整的操作系统或者硬件虚拟化程序。这也意味着容器比传统的虚拟机开销更少。
容器和虚拟机常被误认为是两种抵触的技术。虚拟机采用同一个物理服务器,来提供全功能的操作环境,该环境会和其余虚拟机一起共享这些物理资源。容器一般用来隔离运行中的应用进程,运行进程将在单独的主机中运行,以保证隔离后的进程之间不能相互影响。事实上,容器和**BSD Jails**以及`chroot`进程的相似度,超过了和完整虚拟机的相似度。
### Docker在容器的上层提供了什么
Docker不是一个容器运行环境事实上只是一个容器技术并不包含那些帮助Docker支持[Solaris Zones](https://blog.docker.com/2015/08/docker-oracle-solaris-zones/)和[BSD Jails](https://wiki.freebsd.org/Docker)的技术。Docker提供管理打包和部署容器的方式。虽然一定程度上虚拟机多多少少拥有这些类似的功能但虚拟机并没有完整拥有绝大多数的容器功能即使拥有这些功能用起来都并没有Docker来的方便。
现在我们应该知道Docker是什么了然后我们将从安装Docker并部署一个公共的预构建好的容器开始学习Docker是如何工作的。
## 从安装开始
默认情况下Docker并不会自动被安装在您的计算机中所以第一步就是安装Docker包我们的教学机器系统是Ubuntu 14.0.4所以我们将使用Apt包管理器来执行安装操作。
```
# apt-get install docker.io
Reading package lists... Done
Building dependency tree
Reading state information... Done
The following extra packages will be installed:
aufs-tools cgroup-lite git git-man liberror-perl
Suggested packages:
btrfs-tools debootstrap lxc rinse git-daemon-run git-daemon-sysvinit git-doc
git-el git-email git-gui gitk gitweb git-arch git-bzr git-cvs git-mediawiki
git-svn
The following NEW packages will be installed:
aufs-tools cgroup-lite docker.io git git-man liberror-perl
0 upgraded, 6 newly installed, 0 to remove and 0 not upgraded.
Need to get 7,553 kB of archives.
After this operation, 46.6 MB of additional disk space will be used.
Do you want to continue? [Y/n] y
```
为了检查当前是否有容器运行,我们可以执行`docker`命令,加上`ps`选项
```
# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
```
`docker`命令中的`ps`功能类似于Linux的`ps`命令。它将显示可找到的Docker容器以及各自的状态。由于我们并没有开启任何Docker容器所以命令没有显示任何正在运行的容器。
## 部署一个预构建好的nginx Docker容器
我比较喜欢的Docker特性之一就是Docker部署预先构建好的容器的方式就像`yum`和`apt-get`部署包一样。为了更好地解释我们来部署一个运行着nginx web服务器的预构建容器。我们可以继续使用`docker`命令,这次选择`run`选项。
```
# docker run -d nginx
Unable to find image 'nginx' locally
Pulling repository nginx
5c82215b03d1: Download complete
e2a4fb18da48: Download complete
58016a5acc80: Download complete
657abfa43d82: Download complete
dcb2fe003d16: Download complete
c79a417d7c6f: Download complete
abb90243122c: Download complete
d6137c9e2964: Download complete
85e566ddc7ef: Download complete
69f100eb42b5: Download complete
cd720b803060: Download complete
7cc81e9a118a: Download complete
```
`docker`命令的`run`选项用来通知Docker去寻找一个指定的Docker镜像然后开启运行着该镜像的容器。默认情况下Docker容器在前台运行这意味着当你运行`docker run`命令的时候你的shell会被绑定到容器的控制台以及运行在容器中的进程。为了能在后台运行该Docker容器我们可以使用`-d` (**detach**)标志。
再次运行`docker ps`命令可以看到nginx容器正在运行。
```
# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
f6d31ab01fc9 nginx:latest nginx -g 'daemon off 4 seconds ago Up 3 seconds 443/tcp, 80/tcp desperate_lalande
```
从上面的打印信息中,我们可以看到正在运行的名为`desperate_lalande`的容器,它是由`nginx:latest image`译者注nginx最新版本的镜像构建而来得。
### Docker镜像
镜像是Docker的核心特征之一类似于虚拟机镜像。和虚拟机镜像一样Docker镜像是一个被保存并打包的容器。当然Docker不只是创建镜像它还可以通过Docker仓库发布这些镜像Docker仓库和包仓库的概念差不多它让Docker能够模仿`yum`部署包的方式来部署镜像。为了更好地理解这是怎么工作的,我们来回顾`docker run`执行后的输出。
```
# docker run -d nginx
Unable to find image 'nginx' locally
```
我们可以看到第一条信息是Docker不能在本地找到名叫nginx的镜像。这是因为当我们执行`docker run`命令时告诉Docker运行一个基于nginx镜像的容器。既然Docker要启动一个基于特定镜像的容器那么Docker首先需要知道那个指定镜像。在检查远程仓库之前Docker首先检查本地是否存在指定名称的本地镜像。
因为系统是崭新的不存在nginx镜像Docker将选择从Docker仓库下载之。
```
Pulling repository nginx
5c82215b03d1: Download complete
e2a4fb18da48: Download complete
58016a5acc80: Download complete
657abfa43d82: Download complete
dcb2fe003d16: Download complete
c79a417d7c6f: Download complete
abb90243122c: Download complete
d6137c9e2964: Download complete
85e566ddc7ef: Download complete
69f100eb42b5: Download complete
cd720b803060: Download complete
7cc81e9a118a: Download complete
```
这就是第二部分打印信息显示给我们的内容。默认Docker会使用[Docker Hub](https://hub.docker.com/)仓库该仓库由Docker公司维护。
和Github一样在Docker Hub创建公共仓库是免费的私人仓库就需要缴纳费用了。当然部署你自己的Docker仓库也是可以实现的事实上只需要简单地运行`docker run registry`命令就行了。但在这篇文章中,我们的重点将不是讲解如何部署一个定制的注册服务。
### 关闭并移除容器
在我们继续构建定制容器之前我们先清理Docker环境我们将关闭先前的容器并移除它。
我们利用`docker`命令和`run`选项运行一个容器,所以,为了停止该相同的容器,我们简单地在执行`docker`命令时,使用`kill`选项,并指定容器名。
```
# docker kill desperate_lalande
desperate_lalande
```
当我们再次执行`docker ps`,就不再有容器运行了
```
# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
```
但是,此时,我们这是停止了容器;虽然它不再运行,但仍然存在。默认情况下,`docker ps`只会显示正在运行的容器,如果我们附加`-a` (all) 标识,它会显示所有运行和未运行的容器。
```
# docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
f6d31ab01fc9 5c82215b03d1 nginx -g 'daemon off 4 weeks ago Exited (-1) About a minute ago desperate_lalande
```
为了能完整地移除容器,我们在用`docker`命令时,附加`rm`选项。
```
# docker rm desperate_lalande
desperate_lalande
```
虽然容器被移除了;但是我们仍拥有可用的**nginx**镜像(译者注:镜像缓存)。如果我们重新运行`docker run -d nginx`Docker就无需再次拉取nginx镜像即可启动容器。这是因为我们本地系统中已经保存了一个副本。
为了列出系统中所有的本地镜像,我们运行`docker`命令,附加`images`选项。
```
# docker images
REPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZE
nginx latest 9fab4090484a 5 days ago 132.8 MB
```
## 构建我们自己的镜像
截至目前我们已经使用了一些基础的Docker命令来开启停止和移除一个预构建好的普通镜像。为了"Dockerize"这篇博客,我们需要构建我们自己的镜像,也就是创建一个**Dockerfile**。
在大多数虚拟机环境中如果你想创建一个机器镜像首先你需要建立一个新的虚拟机安装操作系统安装应用最后将其转换为一个模板或者镜像。但在Docker中所有这些步骤都可以通过Dockerfile实现全自动。Dockerfile是向Docker提供构建指令去构建定制镜像的方式。在这一章节我们将编写能用来部署这篇博客的定制Dockerfile。
### 理解应用
我们开始构建Dockerfile之前第一步要搞明白我们需要哪些东西来部署这篇博客。
博客本质上是由静态站点生成器生成的静态HTML页面这个静态站点是我编写的名为**hamerkop**。这个生成器很简单,它所做的就是生成该博客站点。所有的博客源码都被我放在了一个公共的[Github仓库](https://github.com/madflojo/blog)。为了部署这篇博客我们要先从Github仓库把博客内容拉取下来然后安装**Python**和一些**Python**模块,最后执行`hamerkop`应用。我们还需要安装**nginx**,来运行生成后的内容。
截止目前这些还是一个简单的Dockerfile但它却给我们展示了相当多的[Dockerfile语法]((https://docs.docker.com/v1.8/reference/builder/))。我们需要克隆Github仓库然后使用你最喜欢的编辑器编写Dockerfile我选择`vi`
```
# git clone https://github.com/madflojo/blog.git
Cloning into 'blog'...
remote: Counting objects: 622, done.
remote: Total 622 (delta 0), reused 0 (delta 0), pack-reused 622
Receiving objects: 100% (622/622), 14.80 MiB | 1.06 MiB/s, done.
Resolving deltas: 100% (242/242), done.
Checking connectivity... done.
# cd blog/
# vi Dockerfile
```
### FROM - 继承一个Docker镜像
第一条Dockerfile指令是`FROM`指令。这将指定一个现存的镜像作为我们的基础镜像。这也从根本上给我们提供了继承其他Docker镜像的途径。在本例中我们还是从刚刚我们使用的**nginx**开始,如果我们想重新开始,我们可以通过指定`ubuntu:latest`来使用**Ubuntu** Docker镜像。
```
## Dockerfile that generates an instance of http://bencane.com
FROM nginx:latest
MAINTAINER Benjamin Cane <ben@bencane.com>
```
除了`FROM`指令,我还使用了`MAINTAINER`它用来显示Dockerfile的作者。
Docker支持使用`#`作为注释我将经常使用该语法来解释Dockerfile的部分内容。
### 运行一次测试构建
因为我们继承了**nginx** Docker镜像我们现在的Dockerfile也就包括了用来构建**nginx**镜像的[Dockerfile](https://github.com/nginxinc/docker-nginx/blob/08eeb0e3f0a5ee40cbc2bc01f0004c2aa5b78c15/Dockerfile)中所有指令。这意味着此时我们可以从该Dockerfile中构建出一个Docker镜像然后从该镜像中运行一个容器。虽然最终的镜像和**nginx**镜像本质上是一样的但是我们这次是通过构建Dockerfile的形式然后我们将讲解Docker构建镜像的过程。
想要从Dockerfile构建镜像我们只需要在运行`docker`命令的时候,加上**build**选项。
```
# docker build -t blog /root/blog
Sending build context to Docker daemon 23.6 MB
Sending build context to Docker daemon
Step 0 : FROM nginx:latest
---> 9fab4090484a
Step 1 : MAINTAINER Benjamin Cane <ben@bencane.com>
---> Running in c97f36450343
---> 60a44f78d194
Removing intermediate container c97f36450343
Successfully built 60a44f78d194
```
上面的例子,我们使用了`-t` (**tag**)标识给镜像添加"blog"的标签。本质上我们只是在给镜像命名如果我们不指定标签就只能通过Docker分配的**Image ID**来访问镜像了。本例中从Docker构建成功的信息可以看出**Image ID**值为`60a44f78d194`。
除了`-t`标识外,我还指定了目录`/root/blog`。该目录被称作"构建目录"它将包含Dockerfile以及其他需要构建该容器的文件。
现在我们构建成功,下面我们开始定制该镜像。
### 使用RUN来执行apt-get
用来生成HTML页面的静态站点生成器是用**Python**语言编写的所以在Dockerfile中需要做的第一件定制任务是安装Python。我们将使用Apt包管理器来安装Python包这意味着在Dockerfile中我们要指定运行`apt-get update`和`apt-get install python-dev`;为了完成这一点,我们可以使用`RUN`指令。
```
## Dockerfile that generates an instance of http://bencane.com
FROM nginx:latest
MAINTAINER Benjamin Cane <ben@bencane.com>
## Install python and pip
RUN apt-get update
RUN apt-get install -y python-dev python-pip
```
如上所示我们只是简单地告知Docker构建镜像的时候要去执行指定的`apt-get`命令。比较有趣的是,这些命令只会在该容器的上下文中执行。这意味着,即使容器中安装了`python-dev`和`python-pip`,但主机本身并没有安装这些。说的更简单点,`pip`命令将只在容器中执行,出了容器,`pip`命令不存在。
还有一点比较重要的是Docker构建过程中不接受用户输入。这说明任何被`RUN`指令执行的命令必须在没有用户输入的时候完成。由于很多应用在安装的过程中需要用户的输入信息,所以这增加了一点难度。我们例子,`RUN`命令执行的命令都不需要用户输入。
### 安装Python模块
**Python**安装完毕后我们现在需要安装Python模块。如果在Docker外做这些事我们通常使用`pip`命令然后参考博客Git仓库中名叫`requirements.txt`的文件。在之前的步骤中,我们已经使用`git`命令成功地将Github仓库"克隆"到了`/root/blog`目录;这个目录碰巧也是我们创建`Dockerfile`的目录。这很重要因为这意味着Dokcer在构建过程中可以访问Git仓库中的内容。
当我们执行构建后Docker将构建的上下文环境设置为指定的"构建目录"。这意味着目录中的所有文件都可以在构建过程中被使用,目录之外的文件(构建环境之外)是不能访问的。
为了能安装需要的Python模块我们需要将`requirements.txt`从构建目录拷贝到容器中。我们可以在`Dockerfile`中使用`COPY`指令完成这一需求。
```
## Dockerfile that generates an instance of http://bencane.com
FROM nginx:latest
MAINTAINER Benjamin Cane <ben@bencane.com>
## Install python and pip
RUN apt-get update
RUN apt-get install -y python-dev python-pip
## Create a directory for required files
RUN mkdir -p /build/
## Add requirements file and run pip
COPY requirements.txt /build/
RUN pip install -r /build/requirements.txt
```
在`Dockerfile`中我们增加了3条指令。第一条指令使用`RUN`在容器中创建了`/build/`目录。该目录用来拷贝生成静态HTML页面需要的一切应用文件。第二条指令是`COPY`指令,它将`requirements.txt`从"构建目录"(`/root/blog`)拷贝到容器中的`/build/`目录。第三条使用`RUN`指令来执行`pip`命令;安装`requirements.txt`文件中指定的所有模块。
当构建定制镜像时,`COPY`是条重要的指令。如果在Dockerfile中不指定拷贝文件Docker镜像将不会包含requirements.txt文件。在Docker容器中所有东西都是隔离的除非在Dockerfile中指定执行否则容器中不会包括需要的依赖。
### 重新运行构建
现在我们让Docker执行了一些定制任务现在我们尝试另一次blog镜像的构建。
```
# docker build -t blog /root/blog
Sending build context to Docker daemon 19.52 MB
Sending build context to Docker daemon
Step 0 : FROM nginx:latest
---> 9fab4090484a
Step 1 : MAINTAINER Benjamin Cane <ben@bencane.com>
---> Using cache
---> 8e0f1899d1eb
Step 2 : RUN apt-get update
---> Using cache
---> 78b36ef1a1a2
Step 3 : RUN apt-get install -y python-dev python-pip
---> Using cache
---> ef4f9382658a
Step 4 : RUN mkdir -p /build/
---> Running in bde05cf1e8fe
---> f4b66e09fa61
Removing intermediate container bde05cf1e8fe
Step 5 : COPY requirements.txt /build/
---> cef11c3fb97c
Removing intermediate container 9aa8ff43f4b0
Step 6 : RUN pip install -r /build/requirements.txt
---> Running in c50b15ddd8b1
Downloading/unpacking jinja2 (from -r /build/requirements.txt (line 1))
Downloading/unpacking PyYaml (from -r /build/requirements.txt (line 2))
<truncated to reduce noise>
Successfully installed jinja2 PyYaml mistune markdown MarkupSafe
Cleaning up...
---> abab55c20962
Removing intermediate container c50b15ddd8b1
Successfully built abab55c20962
```
上述输出所示,我们可以看到构建成功了,我们还可以看到另外一个有趣的信息` ---> Using cache`。这条信息告诉我们Docker在构建该镜像时使用了它的构建缓存。
### Docker构建缓存
当Docker构建镜像时它不仅仅构建一个单独的镜像事实上在构建过程中它会构建许多镜像。从上面的输出信息可以看出在每一"步"执行后Docker都在创建新的镜像。
```
Step 5 : COPY requirements.txt /build/
---> cef11c3fb97c
```
上面片段的最后一行可以看出Docker在告诉我们它在创建一个新镜像因为它打印了**Image ID**;`cef11c3fb97c`。这种方式有用之处在于Docker能在随后构建**blog**镜像时将这些镜像作为缓存使用。这很有用处因为这样Docker就能加速同一个容器中新构建任务的构建流程。从上面的例子中我们可以看出Docker没有重新安装`python-dev`和`python-pip`包Docker则使用了缓存镜像。但是由于Docker并没有找到执行`mkdir`命令的构建缓存,随后的步骤就被一一执行了。
Docker构建缓存一定程度上是福音但有时也是噩梦。这是因为使用缓存或者重新运行指令的决定在一个很狭窄的范围内执行。比如如果`requirements.txt`文件发生了修改Docker会在构建时检测到该变化然后Docker会重新执行该执行那个点往后的所有指令。这得益于Docker能查看`requirements.txt`的文件内容。但是,`apt-get`命令的执行就是另一回事了。如果提供Python包的**Apt** 仓库包含了一个更新的python-pip包Docker不会检测到这个变化转而去使用构建缓存。这会导致之前旧版本的包将被安装。虽然对`python-pip`来说,这不是主要的问题,但对使用了某个致命攻击缺陷的包缓存来说,这是个大问题。
出于这个原因抛弃Docker缓存定期地重新构建镜像是有好处的。这时当我们执行Docker构建时我简单地指定`--no-cache=True`即可。
## 部署博客的剩余部分
Python包和模块安装后接下来我们将拷贝需要用到的应用文件然后运行`hamerkop`应用。我们只需要使用更多的`COPY` and `RUN`指令就可完成。
```
## Dockerfile that generates an instance of http://bencane.com
FROM nginx:latest
MAINTAINER Benjamin Cane <ben@bencane.com>
## Install python and pip
RUN apt-get update
RUN apt-get install -y python-dev python-pip
## Create a directory for required files
RUN mkdir -p /build/
## Add requirements file and run pip
COPY requirements.txt /build/
RUN pip install -r /build/requirements.txt
## Add blog code nd required files
COPY static /build/static
COPY templates /build/templates
COPY hamerkop /build/
COPY config.yml /build/
COPY articles /build/articles
## Run Generator
RUN /build/hamerkop -c /build/config.yml
```
现在我们已经写出了剩余的构建指令,我们再次运行另一次构建,并确保镜像构建成功。
```
# docker build -t blog /root/blog/
Sending build context to Docker daemon 19.52 MB
Sending build context to Docker daemon
Step 0 : FROM nginx:latest
---> 9fab4090484a
Step 1 : MAINTAINER Benjamin Cane <ben@bencane.com>
---> Using cache
---> 8e0f1899d1eb
Step 2 : RUN apt-get update
---> Using cache
---> 78b36ef1a1a2
Step 3 : RUN apt-get install -y python-dev python-pip
---> Using cache
---> ef4f9382658a
Step 4 : RUN mkdir -p /build/
---> Using cache
---> f4b66e09fa61
Step 5 : COPY requirements.txt /build/
---> Using cache
---> cef11c3fb97c
Step 6 : RUN pip install -r /build/requirements.txt
---> Using cache
---> abab55c20962
Step 7 : COPY static /build/static
---> 15cb91531038
Removing intermediate container d478b42b7906
Step 8 : COPY templates /build/templates
---> ecded5d1a52e
Removing intermediate container ac2390607e9f
Step 9 : COPY hamerkop /build/
---> 59efd1ca1771
Removing intermediate container b5fbf7e817b7
Step 10 : COPY config.yml /build/
---> bfa3db6c05b7
Removing intermediate container 1aebef300933
Step 11 : COPY articles /build/articles
---> 6b61cc9dde27
Removing intermediate container be78d0eb1213
Step 12 : RUN /build/hamerkop -c /build/config.yml
---> Running in fbc0b5e574c5
Successfully created file /usr/share/nginx/html//2011/06/25/checking-the-number-of-lwp-threads-in-linux
Successfully created file /usr/share/nginx/html//2011/06/checking-the-number-of-lwp-threads-in-linux
<truncated to reduce noise>
Successfully created file /usr/share/nginx/html//archive.html
Successfully created file /usr/share/nginx/html//sitemap.xml
---> 3b25263113e1
Removing intermediate container fbc0b5e574c5
Successfully built 3b25263113e1
```
### 运行定制的容器
成功的一次构建后,我们现在就可以通过运行`docker`命令和`run`选项来运行我们定制的容器和之前我们启动nginx容器一样。
```
# docker run -d -p 80:80 --name=blog blog
5f6c7a2217dcdc0da8af05225c4d1294e3e6bb28a41ea898a1c63fb821989ba1
```
我们这次又使用了`-d` (**detach**)标识来让Docker在后台运行。但是我们也可以看到两个新标识。第一个新标识是`--name`这用来给容器指定一个用户名称。之前的例子我们没有指定名称因为Docker随机帮我们生成了一个。第二个新标识是`-p`,这个标识允许用户从主机映射一个端口到容器中的一个端口。
之前我们使用的基础**nginx**镜像分配了80端口给HTTP服务。默认情况下容器内的端口通道并没有绑定到主机系统。为了让外部系统能访问容器内部端口我们必须使用`-p`标识将主机端口映射到容器内部端口。上面的命令,我们通过`-p 8080:80`语法将主机80端口映射到容器内部的80端口。
经过上面的命令,我们的容器似乎成功启动了,我们可以通过执行`docker ps`核实。
```
# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
d264c7ef92bd blog:latest nginx -g 'daemon off 3 seconds ago Up 3 seconds 443/tcp, 0.0.0.0:80->80/tcp blog
```
## 总结
截止目前我们拥有了正在运行的定制Docker容器。虽然在这篇文章中我们只接触了一些Dockerfile指令用法但是我们还是要讨论所有的指令。我们可以检查[Docker's reference page](https://docs.docker.com/v1.8/reference/builder/)来获取所有的Dockerfile指令用法那里对指令的用法说明得很详细。
另一个比较好的资源是[Dockerfile Best Practices page](https://docs.docker.com/engine/articles/dockerfile_best-practices/)它有许多构建定制Dockerfile的最佳练习。有些技巧非常有用比如战略性地组织好Dockerfile中的命令。上面的例子中我们将`articles`目录的`COPY`指令作为Dockerfile中最后的`COPY`指令。这是因为`articles`目录会经常变动。所以,将那些经常变化的指令尽可能地放在最后面的位置,来最优化那些可以被缓存的步骤。
通过这篇文章我们涉及了如何运行一个预构建的容器以及如何构建然后部署定制容器。虽然关于Docker你还有许多需要继续学习的地方但我想这篇文章给了你如何继续开始的好建议。当然如果你认为还有一些需要继续补充的内容在下面评论即可。
--------------------------------------
via:http://bencane.com/2015/12/01/getting-started-with-docker-by-dockerizing-this-blog/?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%3A+bencane%2FSAUo+%28Benjamin+Cane%29
作者Benjamin Cane
译者:[su-kaiyao](https://github.com/su-kaiyao)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创翻译,[Linux中国](http://linux.cn/) 荣誉推出

View File

@ -1,119 +0,0 @@
启用Nginx/Apache的PHP-FPM多实例
================================================================================
PHP-FPM作为FastCGI进程管理器而广为熟知它是PHP FastCGI实现的改进带有更为有用的功能用于处理高负载的服务器和网站。下面列出其中一些功能
### 新功能 ###
- 拥有具有优雅启动/停止选项的高级进程管理能力。
- 可以以监听不同端口以及使用不同PHP配置的不同用户身份/组身份来运行进程。
- 错误日志记录。
- 支持上传加速。
- 用于在处理一些耗时任务时结束请求和清空所有数据的特别功能。
- 同时支持动态和静态子进程重生。
- 支持IP地址限制。
在本文中我将要讨论的是在运行EA3下CPanel 11.52的CentOS 7服务器上与Nginx和Apache一起安装PHP-FPM以及如何来通过CPanel管理这些安装好的多个PHP-FPM实例。
Before going to the installation procedures, let us take a look on the pre-requisites.
### 先决条件 ###
1. 启用 Mod_proxy_fcgi模块
2. 启用 MPM_Event
由于我们要将PHP-FPM安装到一台EA3服务器我们需要运行EasyApache来编译Apache以启用这些模块。
你们可以参考我以前写的关于如何在Apache服务器上安装Nginx作为反向代理的文档来确认Nginx的安装。
这里,我将再次简述那些安装步骤。具体细节,你可以参考我之前写的**如何在CentOS 7/CPanel服务器上配置Nginx反向代理**一文。
步骤 1安装Epel仓库
步骤 2安装nDeploy RPM仓库这是此次安装中最为**重要**的步骤。
步骤 3使用yum从nDeploy仓库安装nDeploy和Nginx插件。
步骤 4启用/配置Nginx为反向代理。
完成这些步骤后下面为服务器中所有可用PHP版本安装PHP-FPM包EA3使用remi仓库来安装这些包。你可以运行这个nDeploy脚本来下载所有的包。
root@server1 [~]# /opt/nDeploy/scripts/easy_php_setup.sh
Loaded plugins: fastestmirror, tsflags, universal-hooks
EA4 | 2.9 kB 00:00:00
base | 3.6 kB 00:00:00
epel/x86_64/metalink | 9.7 kB 00:00:00
epel | 4.3 kB 00:00:00
extras | 3.4 kB 00:00:00
updates | 3.4 kB 00:00:00
(1/2): epel/x86_64/updateinfo | 460 kB 00:00:00
(2/2): epel/x86_64/primary_db
运行该脚本将为PHP 54PHP 55PHP 56和PHP 70安装所有这些FPM包。
Installed Packages
php54-php-fpm.x86_64 5.4.45-3.el7.remi @remi
php55-php-fpm.x86_64 5.5.31-1.el7.remi @remi
php56-php-fpm.x86_64 5.6.17-1.el7.remi @remi
php70-php-fpm.x86_64 7.0.2-1.el7.remi @remi
在以上安装完成后你需要为Apache启用PHP-FPM SAPI。你可以运行下面这个脚本来启用PHP-FPM实例。
root@server1 [~]# /opt/nDeploy/scripts/apache_php-fpm_setup.sh enable
mod_proxy_fcgi.c
Please choose one default PHP version from the list below
PHP70
PHP56
PHP54
PHP55
Provide the exact desired version string here and press ENTER: PHP54
ConfGen:: lxblogger
ConfGen:: blogr
ConfGen:: saheetha
ConfGen:: satest
which: no cagefsctl in (/usr/local/jdk/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/usr/local/bin:/usr/X11R6/bin:/root/bin)
info [rebuildhttpdconf] Missing owner for domain server1.centos7-test.com, force lookup to root
Built /usr/local/apache/conf/httpd.conf OK
Waiting for “httpd” to restart gracefully …waiting for “httpd” to initialize ……
…finished.
它会问你需要运行哪个PHP版本作为服务器默认版本你可以输入那些细节内容然后继续配置并为现存的域生成虚拟主机文件。
我选择了PHP 54作为我服务器上的默认PHP-FPM版本。
![confirm-php-fpm](http://blog.linoxide.com/wp-content/uploads/2016/01/confirm-php-fpm-1024x525.png)
虽然服务器配置了PHP-FPM 54但是我们可以通过CPanel为各个独立的域修改PHP-FPM实例。
下面我将通过一些截图来为你们说明一下怎样通过CPanel为各个独立域修改PHP-FPM实例。
Nginx插件的安装将为你的域的CPanel提供一个Nginx Webstack图标你可以点击该图标来配置你的Web服务器。我已经登陆进了我其中的一个CPanel来配置相应的Web服务器。
请看这些截图。
![nginx webstack](http://blog.linoxide.com/wp-content/uploads/2016/01/nginx-webstack.png)
![nginxicon1](http://blog.linoxide.com/wp-content/uploads/2016/01/nginxicon1-1024x253.png)
现在你可以根据需要为选中的主域配置web服务器这里我已经选择了主域saheetha.com。我已经继续通过自动化配置选项来进行了因为我不需要添加任何手动设置。
![nginx_auto_proxy](http://blog.linoxide.com/wp-content/uploads/2016/01/nginx_auto_proxy-1024x408.png)
当Nginx配置完后你可以在这里为你的域选择PHP-FPM实例。
![php-fpm1](http://blog.linoxide.com/wp-content/uploads/2016/01/php-fpm1-1024x408.png)
![php54](http://blog.linoxide.com/wp-content/uploads/2016/01/php54-1024x169.png)
![php55](http://blog.linoxide.com/wp-content/uploads/2016/01/php55.png)
就像你在截图中所看到的我服务器上的默认PHP-FPM是**PHP 54**而我正要将我的域的PHP-FPM实例单独修改成**PHP 55**。当你为你的域修改PHP-FPM后你可以通过访问**phpinfo**页面来确认。
谢谢你们参考本文,我相信这篇文章会给你提供不少信息和帮助。我会为你们推荐关于这个内容的有价值的评论 :)。
--------------------------------------------------------------------------------
via: http://linoxide.com/linux-how-to/enable-multiple-php-fpm-instances-nginx-apache/
作者:[Saheetha Shameer][a]
译者:[GOLinux](https://github.com/GOLinux)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译,[Linux中国](https://linux.cn/) 荣誉推出
[a]:http://linoxide.com/author/saheethas/

View File

@ -1,67 +0,0 @@
七步开始你的 Linux 系统管理员生涯
===============================================
Linux 现在是个大热门。每个人都在寻求 Linux 才能。招聘人员对有 Linux 经验的人求贤若渴,还有无数的职位虚位以待。但是如果你是 Linux 新手,又想要赶上这波热潮,该从何开始下手呢?
1. 安装 Linux
这应该是不言而喻的,但学习 Linux 的第一关键就是安装 Linux。LFS101x 和 LFS201 课程都包含第一次安装和配置 Linux 的详细内容。
2. 完成 LFS101x 课程
如果你是 Linux 完完全全的新手,最佳的起点是免费的 Linux 课程 [LFS101x Introduction](https://www.edx.org/course/introduction-linux-linuxfoundationx-lfs101x-2)。这个在线课程在 edX.org探索 Linux 系统管理员和终端用户常用的各种工具和技能以及日常 Linux 工作环境。该课程是为有一定经验但较少或没有接触过 Linux 的电脑用户设计的,不论他们是在个人还是企业环境中工作。这个课程会从图形界面和命令行教会你有用的 Linux 知识,让你能够了解主流的 Linux 发行版。
3. 看看 LFS201 课程
在你完成 LFS101x 之后,你就准备好开始进入 Linux 更加复杂的任务了,这是成为一名专业的系统管理员所必须的。为了掌握这些技能,你应该看看 [LFS201 Essentials of Linux System Administration](http://training.linuxfoundation.org/linux-courses/system-administration-training/essentials-of-system-administration) 这个课程。该课程对每个话题进行了深度的解释和介绍,还有大量的练习和实验,帮助你获得相关主题实际的上手经验。
如果你更愿意有个教练或者你的雇主对将你培养成 Linux 系统管理员有兴趣,你可能会对 LFS220 Linux System Administration 有兴趣。这个课程有 LFS201 中所有的主题,但是它是由专家专人教授的,帮助你进行实验以及解答你在课程主题中的问题。
4. 练习!
熟能生巧,和对任何乐器或运动适用一样,这对 Linux 来说也一样适用。在你安装 Linux 之后,经常使用它。一遍遍地练习关键任务,直到你不需要参考材料也能轻而易举地完成。练习命令行和图形界面的输入输出。这些练习能够保证你掌握成为成功的 Linux 系统管理员所必需的知识和技能。
5. 获得认证
在你完成 LFS201 或 LFS220 并且充分练习之后,你现在已经准备好获得系统管理员的认证了。你需要这个证书,因为你需要向雇主证明你拥有一名专业 Linux 系统管理员必需的技能。
现在有一些不同的 Linux 证书,它们有它们的独到之处。但是,它们里大部分不是在特定发行版(如红帽)上认证,就是纯粹的知识测试,没有演示 Linux 的实际技能。Linux 基金会认证系统管理员Linux Foundation Certified System Administrator证书对想要一个灵活的有意义的初级证书的人来说是个优秀的替代。
6. 参与进来
如果你所在的地方有本地 Linux 用户组Linux Users GroupLUG的话这时候你可能还想要考虑加入他们。这些组织通常由各种年龄和经验水平的人组成所以不管你的 Linux 经验水平如何,你都能找到和你类似技能水平的人互助,或是更高水平的 Linux 用户来解答你的问题以及介绍有用的资源。要想知道你附近有没有 LUG上 meet.com 看看,或是附近的大学,又或是上网搜索一下。
还有不少在线社区可以在你学习 Linux 的时候帮助你。这些站点和社区向 Linux 新手和有经验的管理员都能够提供帮助和支持:
- [Linux Admin subreddit](https://www.reddit.com/r/linuxadmin)
- [Linux.com](http://www.linux.com/)
- [training.linuxfoundation.org](http://training.linuxfoundation.org/)
- [http://community.ubuntu.com/help-information/](http://community.ubuntu.com/help-information/)
- [https://forums.opensuse.org/forum.php](https://forums.opensuse.org/forum.php)
- [http://wiki.centos.org/Documentation](http://wiki.centos.org/Documentation)
7. 学会热爱文档
最后但同样重要的是,如果你困在 Linux 的某些地方,别忘了 Linux 包含的文档。使用命令 manmanual手册info 和 help你从系统内就可以找到 Linux 几乎所有方面的信息。这些内置资源的用处再夸大也不为过,你会发现你在生涯中始终会用到,所以你可能最好早点掌握使用它们。
想要了解更多开始你 Linux IT 生涯的信息?查看我们免费的电子书“[开始你 Linux IT 生涯的简短指南](http://training.linuxfoundation.org/sysadmin-it-career-guide)”。
[立刻下载](http://training.linuxfoundation.org/sysadmin-it-career-guide)
------------------------------------------------------------------------------
via: http://www.linux.com/news/featured-blogs/191-linux-training/834644-7-steps-to-start-your-linux-sysadmin-career
作者:[linux.com][a]
译者:[alim0x](https://github.com/alim0x)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创翻译,[Linux中国](https://linux.cn/) 荣誉推出
[a]:linux.com

View File

@ -1,76 +0,0 @@
混合云计算的9大关键趋势
========================================
自从几年前云计算的概念受到IT界的关注以来公有云、私有云和混合云这三种云计算方式都有了可观的演进。其中混合云计算方式是最热门的云计算方式在接受调查的公司中有[88%的公司](https://www.greenhousedata.com/blog/hybrid-continues-to-be-most-popular-cloud-option-adoption-accelerating)将混合云计算摆在至关重要的地位。
混合云计算的疾速演进意味着一两年前的传统观念已经过时了。为此我们询问了几个行业分析师混合云在2016年的走势将会如何我们得到了几个比较有意思的答案。
1. **2016年可能是我们将混合云投入使用的一年。**
混合云从本质上来说依赖于私有云,这对企业来说是比较难实现的。事实上,亚马逊,谷歌和微软的公有云已经进行了大量的投资,并且起步也比较早。私有云拖了混合云发展和使用的后腿。
私有云没有得到这么多的投资,这是有私有云的性质决定的。私有云意味着维护和投资你自己的数据中心。许多公有云提供商正在推动企业减少或者消除他们的数据中心。
然而得益于OpenStack的发展和微软的 Azure Stack ,这两者基本上就是封装在一个盒子里的私有云,我们将会看到私有云慢慢追上公有云的发展步伐。支持混合云的工具、基础设施和架构也变得更加健壮。
2. **容器微服务和unikernels将会促进混合云的发展。**
分析师预言到2016年底这些原生云技术会或多或少成为主流的。这些云技术正在快速成熟将会成为虚拟机的一个替代品而虚拟机需要更多的资源。
更重要的是,他们既能工作在在线场景,也能工作在离线场景。容器化和编排允许快速的扩大规模,进行公有云和私有云之间的服务迁移,使你能够更容易移动你的服务。
3. **数据和相关性占据核心舞台。**
所有的云计算方式都处在发展模式。这使得云计算变成了一个技术类的故事。咨询公司[Avoa](http://avoa.com/2016/01/01/2016-is-the-year-of-data-and-relevance/)称,随着云趋于成熟,数据和相关性变得越来越重要。起初,云计算和大数据都是关于怎么吸收尽可能多的数据,然后他们担心如何处理这海量的数据。
2016年相关组织将会继续锤炼如何进行数据收集和使用的相关技术。在必须处理的技术和文化方面仍然有待提高。但是2016年应该重新将关注点放在从各个方面考虑的数据重要性上发现最相关的信息而不只是数据的数量。
4. **云服务将超越按需工作负载。**
AWS(Amazon Web Services)起初是提供给程序员或者是开发人员能够快速启动虚拟机,做一些工作然后离线的一个地方。这就是按需使用的本质。要让这些服务持续运行,几乎需要全天候工作。
然而IT组织正开始作为服务代理为内部用户提供各种IT服务。可以是内部IT服务公有云基础架构提供商平台服务和软件服务。
他们将越来越多的认识到想云管理平台这样的工具的价值。云管理平台可以提供针对不同服务的基于策略的一致性管理。他们也将看到像提高可移植性的容器等技术的价值。然而,云服务代理,在不同云之间快速移动的工作负载进行价格套利或者相关原因的意义上来讲,仍然是行不通的。
5. **服务提供商转变成了云服务提供商。**
到目前为止购买云服务成了直销模式。AWS EC2 服务的使用者通常变成了购买者通过官方认证渠道或者通过影子IT。但是随着云服务越来越全面提供的服务菜单越来越复杂越来越多的人转向了经销商服务提供商转变成了他们IT服务的购买者。
2nd Watch (2nd Watch是为企业提供云管理的 AWS 的首选合作伙伴)最近的一项调查发现在美国将近85%的IT高管愿意支付一个小的溢价从渠道商那里购买公有云服务如果购买过程变得不再那么复杂。根据调查这85%的高管有五分之四的愿意支付额外的15%或者更多。三分之一的受访高管表示,他们可以使用帮助来购买、使用和管理公有云服务。
6. **物联网和云对于2016年的意义好比移动和云对2012年的意义。**
物联网获得了广泛的关注,更重要的是,物联网已经从测试场景进行了实际应用。云的分布式特性使得云成为了物联网非常重要的一部分,对于工业物联网,与后端系统交互的机械和重型设备,混合云将会成为最自然的驱动者,连接,数据采集和处理将会发生在混合云环境中,这得益于私有云在安全和隐私方面的好处。
7. **NIST 对云的定义开始瓦解。**
2011年美国国家标准与技术研究院发布了“[ NIST 对于云计算的定义](http://csrc.nist.gov/publications/nistpubs/800-145/SP800-145.pdf)”PDF这个定义成为了私有云、公有云、混合云和 aas模板的标准定义。
然而随着时间的推移定义开始改变。Iaas变得更加复杂开始支持OpenStack[Swift](https://wiki.openstack.org/wiki/Swift) 对象存储和神经网络这样的项目。Paas似乎正在消退因为Paas和传统的中间件开发几乎无异。Saas只是通过浏览器进行访问的应用也正在失去发展动力因为许多app和服务提供了许多云接口你可以通过各种手段调用接口不仅仅通过浏览器。
8. **分析变得更加重要**
对于混合云计算来说,分析将会成为一个巨大的增长机遇,云计算具有规模大、灵活性高的优势,使得云计算非常适合需要海量数据的分析工作。对于某些分析方式,比如高度敏感的数据,私有云仍然是主导地位但是私有云也是混合云的一部分。因此,无论如何,混合云计算胜出。
9. **安全仍然是一个非常紧迫的问题。**
随着混合云计算在2016年的发展以及对物联网和容器等新技术的引进这同时也增加了更多的脆弱可攻破的地方从而导致数据泄露。先增加使用新技术的趋势然后再去考虑安全性这种问题经常发生同时还有缺少经验的工程师不去考虑系统的安全问题总有一天你会尝到灾难的后果的。
当一项新技术出来管理规范总是落后于安全问题产生后然后我们才考虑去保护技术。容器就是一个很鲜明的例子。你可以从Docker下周各种示例容器但是你知道你下载的东西来自哪里么在人们在对容器内容不知情的情况下下载并运行了容器之后Docker不得不重新加上安全验证。
像Path和Snapchat这样的移动技术在智能手机市场火起来之后也出现了重大的安全问题。一项新技术被恶意利用无可避免。所以安全研究人员需要通过各种手段来保证新技术的安全性。很有可能在部署之后才会发现安全问题。
------------------------------------------------------------------------------
via: http://www.datamation.com/cloud-computing/9-key-trends-in-hybrid-cloud-computing.html
作者:[Andy Patrizio][a]
译者:[棣琦](https://github.com/sonofelice)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创翻译,[Linux中国](https://linux.cn/) 荣誉推出
[a]:http://www.datamation.com/author/Andy-Patrizio-90720.html

View File

@ -1,50 +0,0 @@
新的Docker数据中心管理套件使容器化变得更加井然有序
===============================================================================
![](https://tctechcrunch2011.files.wordpress.com/2016/02/shutterstock_119411227.jpg?w=738)
[Docker][1]今天宣布了一个新的容器控制中心称为Docker数据中心DDC被设计用于大型和小型企业能够创建、管理和分发容器的一个集成管理控制台。
DDC是由包括Docker Universal Control Plane也是今天发布和Docker Trusted Registry等不同的商业组件组成。它也包括了开源组件比如Docker Engine。这个主意能让公司能够在一个中心管理界面中就能够管理整个Docker化程序的生命周期。
产品SVP Scott Johnston告诉TechCrunch“客户催使了这个新工具的产生。公司不仅喜欢Docker给他们带来的敏捷性它们也希望在创建和分发容器的过程中可以进行行政、安全和管理。”
Johnston说“公司称这个为容器即服务Caas大多是是因为当客户来询问这个管理的类型时它们是这样描述的。”
![](https://tctechcrunch2011.files.wordpress.com/2016/02/screen-shot-2016-02-23-at-7-56-54-am.png?w=680&h=401)
>Docker免费镜像
像许多开源项目那样Docker首先获得了许多开发者的追随但是它也很快在那些想直接追踪管理它们的开发者的公司中流行。
这就是DDC设计的目的。它给开发者创建容器化应用的敏捷性也让运维变得井井有条。
实际中这意味着开发者可以创建一系列容器化的组件,批准部署后就可以获得一个完全认证的镜像。这可以让开发这一系列的程序中拉取他们所需而不必每次重新发明轮子。这可以加速应用的开发和部署(理论上提升了容器提供的灵活性)。
这方面吸引了Beta客户ADP。工资服务业巨头特别喜欢让这个中心镜像仓库提供给开发人员。
ADP的CTO Keith Fulton在声明中称“作为我们将关键业务微服务化倡议的一部分ADP正在研究能够然开发人员可以利用IT审核过的中央库和安全的核心服务进行快速迭代的方案。”
Docker在2010年由dotcloud的Solomon Hykes发布。他在2013年将公司的重心移到Docker上并在[8月dotCloud][2]2014年完全聚焦在Docker上。
根据CrunchBase的消息公司几年来在5轮融资后势如破竹般获得了1亿8000万美元融资自从成为Docker后获得了1亿6千8百万美元。吸引投资者关注的是Docker提供了一种称为容器的现在分发应用的方式可以构建、管理何分发分布式应用。
容器化可以让开发者创建由多个小的分布在不同服务器上的分布式应用,而不是一个运行在一个单独服务器上的独立应用。
DDC每月每节点150美金起。
--------------------------------------------------------------------------------
via: http://linoxide.com/linux-how-to/calico-virtual-private-networking-docker/
作者:[ Ron Miller][a]
译者:[geekpi](https://github.com/geekpi)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译,[Linux中国](https://linux.cn/) 荣誉推出
[a]:http://techcrunch.com/author/ron-miller/
[1]: https://www.docker.com/
[2]: http://techcrunch.com/2014/08/04/docker-sells-dotcloud-to-cloudcontrol-to-focus-on-core-container-business/

View File

@ -1,53 +0,0 @@
NODEOS: NODE爱好者的Linux发行版
================================================
![](http://itsfoss.com/wp-content/uploads/2016/05/node-os-linux.jpg)
[NodeOS][1]是一个基于[Node.js][2]的操作系统,自去年的首个[发布候选版][3]之后正朝着它的1.0版本进发。
如果你是第一次听到它NodeOS是首个在[Linux][5]内核之上由Node.js和[npm][4]驱动的操作系统。[Jacob Groundwater][6]仔2013年中介绍了这个项目。操作系统中用到的主要技术是
- **Linux 内核**: 这个系统内置了Linux内核
- **Node.js 运行时**: Node作为主要的运行时
- **npm 包管理**: npm作为包管理
NodeOS源码托管在[Github][7]上因此任何感兴趣的人都可以轻松贡献或者报告bug。用户可以从源码构建或者使用[预编译镜像][8]。构建过程及使用可以在项目仓库中找到。
NodeOS背后的思想是提供足够npm运行的环境剩余的功能就可以来自npm包管理。因此用户可以使用大量的大约250,000的包并且这个数目每天都还在增长。并且所有的都是开源的你可以根据你的需要很容易地打补丁或者增加更多的包。
NodeOS核心开发被分离成了不同的层基本的结构包含
- **barebones** 带有可以启动到Node.js REPL的initramfs的自定义内核
- **initramfs** =用于挂载用户分区以及启动系统的initram文件系统
- **rootfs** 托管linux内核及initramfs文件的只读分区
- **usersfs** 多用户文件系统(如传统系统一样)
NodeOS的目标是可以仔任何平台上运行包括- **真实的硬件用户计算机或者SoC**、**云平台、虚拟机、PaaS提供商容器**Docker和Vagga等等。如今看来它做得似乎不错。在3.3号NodeOS的成员[Jesús Leganés Combarro][9]在Github上[宣布][10]
>**NodeOS不再是一个玩具系统了**,它现在开始可以用在有实际需求的生产环境中了。
因此如果你是Node.js的死忠或者乐于尝试新鲜事物这或许值得你一试。在相关的文章中你应该了解这些[Linux发行版的具体用法][11]
--------------------------------------------------------------------------------
via: http://itsfoss.com/nodeos-operating-system/?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%3A+ItsFoss+%28Its+FOSS%21+An+Open+Source+Blog%29
作者:[Munif Tanjim][a]
译者:[geekpi](https://github.com/geekpi)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译,[Linux中国](https://linux.cn/) 荣誉推出
[a]: http://itsfoss.com/author/munif/
[1]: http://node-os.com/
[2]: https://nodejs.org/en/
[3]: https://github.com/NodeOS/NodeOS/releases/tag/v1.0-RC1
[4]: https://www.npmjs.com/
[5]: http://itsfoss.com/tag/linux/
[6]: https://github.com/groundwater
[7]: https://github.com/nodeos/nodeos
[8]: https://github.com/NodeOS/NodeOS/releases
[9]: https://github.com/piranna
[10]: https://github.com/NodeOS/NodeOS/issues/216
[11]: http://itsfoss.com/weird-ubuntu-based-linux-distributions/

View File

@ -0,0 +1,65 @@
分享的未来:整合 Pydio 与 ownCloud
=========================================================
![](https://opensource.com/sites/default/files/styles/image-full-size/public/images/business/BIZ_darwincloud_520x292_0311LL.png?itok=5yWIaEDe)
>图片来源 :
opensource.com
开源共享生态圈内容纳了许多各异的项目,他们每一个都能提供出自己的解决方案,且每一个都不按套路来。有很多原因导致你选择开源的解决方案,而非 Dropbox、Google Drive、iCloud 或 OneDrive 这些商业的解决方案。这些商业的解决方案虽然能让你不必为如何管理数据担心,但也理所应当的带着种种限制,其中就包含对于原有基础结构的控制和整合不足。
对于用户而言仍有相当一部分文件分享和同步的替代品可供选择,其中就包括了 Pydio 和 ownCloud。
### Pydio
Pydio Put your data in orbit 把你的数据放上轨道) 项目由一位作曲家 Charles du Jeu 发起,起初他也只是需要一种与乐队成员分享大型音频文件的方法。[Pydio][1] 是一种文件分享与同步的解决方案,综合了多存储后端,设计时还同时考虑了开发者和系统管理员两方面。在世界各地有逾百万的下载量,已被翻译成 27 种语言。
项目在很开始的时候便开源了,先是在 [SourceForge][2] 上茁壮的成长,现在已在 [GitHub][3] 上安了家.。
用户界面基于 Google 的 [Material 设计][4]。用户可以使用现有的传统的文件基础结构或是本地部署 Pydio并通过 web、桌面和移动端应用随时随地地管理自己的东西。对于管理员来说细粒度的访问权限绝对是配置访问时的利器。
在 [Pydio 社区][5]你可以找到许多让你增速的资源。Pydio 网站 [对于如何为 Pydio GitHub 仓库贡献][6] 给出了明确的指导方案。[论坛][7]中也包含了开发者板块和社区。
### ownCloud
[ownCloud][8] 在世界各地拥有逾 8 百万的用户,并且开源,支持自托管文件同步,且共享技术。同步客户端支持所有主流平台并支持 WebDAV 通过 web 界面实现。ownCloud 拥有简单的使用界面,强大的管理工具,和大规模的共享及协作功能——以满足用户管理数据时的需求。
ownCloud 的开放式架构是通过 API 和为应用提供平台来实现可扩展性的。迄今已有逾 300 款应用功能包括处理像日历、联系人、邮件、音乐、密码、笔记等诸多数据类型。ownCloud 由一个数百位贡献者的国际化的社区开发,安全,并且能做到为小到一个树莓派大到好几百万用户的 PB 级存储集群量身定制。
### 联合共享 Federated sharing
文件共享开始转向团队合作时代,而标准化为合作提供了坚实的土壤。
联合共享——一个由 [OpenCloudMesh][9] 项目提供的新开放标准,就是在这个方向迈出的一步。先不说别的,在支持该标准的服务端上,可以像 Pydio 和 ownCloud 那样分享文件和文件夹。
ownCloud 7 率先引入,这种服务端到服务端的分享方式可以让你挂载远程服务端上共享的文件,实际上就是创建你所有云的云。你可以直接创建共享链接,让用户在其他支持联合云共享的服务端上使用。
实现这个新的 API 允许存储解决方案之间更深层次的集成,同时保留了原有平台的安全,控制和属性。
“交换和共享文件是当下和未来不可或缺的东西。”ownCloud 的创始人 Frank Karlitschek 说道:“正因如此,采用联合和分布的方式而非集中的数据孤岛就显得至关重要。[联合共享]的设计初衷便是在保证安全和用户隐私的同时追求分享的无缝、至简之道。”
### 下一步是什么呢?
正如 OpenCloudMesh 做的那样,将会通过像 Pydio 和 ownCloud 这样的机构和公司合作推广这一文件共享的新开放标准。ownCloud 9 已经引入联合服务端间交换用户列表的功能,让你的用户在你的服务器上享有和你同样的无缝体验。将来,一个中央地址簿服务(联合!)集合,用以检索其他联合云 ID 的想法可能会把云间合作推向一个新的高度。
这一举措无疑有助于日益开放的技术社区中的那些成员方便地讨论开发并推动“OCM 分享 API”作为一个厂商中立协议。所有领导 OCM 项目的合作伙伴都全心致力于开放 API 的设计原理,并欢迎其他开源的文件分享和同步社区参与并加入其中。
--------------------------------------------------------------------------------
via: https://opensource.com/business/16/5/sharing-files-pydio-owncloud
作者:[ben van 't ende][a]
译者:[martin2011qi](https://github.com/martin2011qi)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译,[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/benvantende
[1]: https://pydio.com/
[2]: https://sourceforge.net/projects/ajaxplorer/
[3]: https://github.com/pydio/
[4]: https://www.google.com/design/spec/material-design/introduction.html
[5]: https://pydio.com/en/community
[6]: https://pydio.com/en/community/contribute
[7]: https://pydio.com/forum/f
[8]: https://owncloud.org/
[9]: https://wiki.geant.org/display/OCM/Open+Cloud+Mesh

View File

@ -0,0 +1,78 @@
在OpenStack云中测试Fedora 24 Beta
===========================================
![](https://major.io/wp-content/uploads/2012/01/fedorainfinity.png)
虽然离[Fedora 24][1]还有几周你可以今天就测试Fedora 24 Beta了。这是一个[窥探新特性][2]的好机会并且可以帮助找出仍需要修复的bug。
[Fedora Cloud][3]镜像可以从你最喜欢的[本地镜像][4]或者[Fedora的服务器][5]中下载。本篇文章我将向你展示如何将这个镜像导入Openstack环境并且测试Fedora 24 Beta。
最后说一下这还是beta软件。目前对我来说是可靠的但是你的体验可能会不同。我建议你等到正式版发布再在上面部署关键的应用。
### 导入镜像
旧版的glance客户端版本1允许你在Openstack环境中导入一个URL镜像。由于我Openstack云的连接速度1 Gbps比我家 (大约20 mbps上传速度)快这个功能对我很有用。然而从URL导入的功能[在glance v2中被移除了]。[OpenStackClient][7]也不支持这个功能。
现在由两个选择:
- 安装旧版的glance客户端
- 使用 Horizon (网页面板)
获取旧版本的glance是有挑战性的。Openstack自由发布的需求文件[对glance客户端没有最高版本上限][8],并且很难找到让旧版客户端工作的依赖文件。
让我们使用Horizon来回到写这篇文章的原因。
### 在Horizon中添加一个镜像
登录Horizon面板点击Compute->Image. 点击页面右上方的“+”创建新镜像,一个新的窗口会显示出来。并且窗口中有这些信息:
- **Name**: Fedora 24 Cloud Beta
- **Image Source**: Image位置
- **Image Location**: http://mirrors.kernel.org/fedora/releases/test/24_Beta/CloudImages/x86_64/images/Fedora-Cloud-Base-24_Beta-1.6.x86_64.qcow2
- **Format**: QCOW2 QEMU Emulator
- **Copy Data**: 确保勾选了
完成后,你会看到这个:
![](https://major.io/wp-content/uploads/2016/05/horizon_image.png)
点击创建镜像接着会显示一段时间的Saving。一旦切换到Active你可以构建一个实例了。
### 构建实例
既然我们在Horizon我们可以完成构建过程了。
在镜像列表页面找出我们上传的镜像并且点击右边的启动实例。一个新的窗口会显示出来。下拉框中应该已经选择了Fedora 24 Beta的镜像。在这里选择一个实例名选择一个安全组和密钥对在Access & Security中和网络在Networking标签。确保选择有足够容量的存储m1.tiny还不够
点击启动并且等待实例启动。
一旦实例构建完成你可以作为fedora用户通过ssh连接。如果你的[安全组允许连接][9]并且你的密钥对正确配置了你应该在Fedora 24 Beta中了
还不确定接下来做什么?有下面几点建议:
- 升级所有的包并且重启(确保你测试的是最新的更新)
- 安装一些相似的应用并且验证它们可以正常工作
- 测试你已有的自动化或者配置管理工具
- 打开bug报告
--------------------------------------------------------------------------------
via: https://major.io/2016/05/24/test-fedora-24-beta-openstack-cloud/
作者:[major.io][a]
译者:[geekpi](https://github.com/geekpi)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译,[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://major.io/about-the-racker-hacker/
[1]: https://fedoraproject.org/wiki/Releases/24/Schedule
[2]: https://fedoraproject.org/wiki/Releases/24/ChangeSet
[3]: https://getfedora.org/en/cloud/
[4]: https://admin.fedoraproject.org/mirrormanager/mirrors/Fedora/24/x86_64
[5]: https://getfedora.org/en/cloud/download/
[6]: https://wiki.openstack.org/wiki/Glance-v2-v1-client-compatability
[7]: http://docs.openstack.org/developer/python-openstackclient/
[8]: https://github.com/openstack/requirements/blob/stable/liberty/global-requirements.txt#L159
[9]: https://major.io/2016/05/16/troubleshooting-openstack-network-connectivity/

View File

@ -0,0 +1,121 @@
把你的旧笔记本变成 Chromebook
========================================
![](https://www.linux.com/sites/lcom/files/styles/rendered_file/public/cloud-ready-main.jpg?itok=gtzJVSq0)
>学习如何用 CloudReady 在你的旧电脑上安装 Chrome OS
Linux 之年就在眼前。根据[报道][1]Google 在 2016 年第一季度卖出了比苹果卖出的 Macbook 更多的 Chromebook。并且Chromebook 即将变得更加激动人心。在 Google I/O 大会上Google 宣布安卓 Google Play 商店将在 6 月中旬来到 Chromebook这让用户能够在他们的 Chrome OS 设备上运行安卓应用。
但是,你不需要购买一台全新的使用 Chrome OS 的笔记本,你可以轻松地将你的旧笔记本或电脑转换成强大的 Chromebook。我在一台 Dell Mini 和一台 2009 年购买的 Dell 笔记本上进行了尝试。那两台设备都在吃灰,而且本来注定是要被回收的,因为现代的操作系统和桌面环境,比如 UnityPlasma 以及 Gnome 它们跑不动。
如果你手边有旧设备,你可以轻松地将它变成 Chromebook。你还可以在你的笔记本上安装 Chrome OS 双系统,这样你就可以同时享受不同系统的优点了。
多亏了 Chrome OS 的开源基础,有很多方案可以让你在你的设备上安装 Chrome OS。我试过几个但我最喜欢的方案是 [Neverware][2] 的 CloudReady。这家公司提供一个免费的社区支持版的系统还有一个商业支持版每台设备每年 49 美元。好消息是所有的授权都是可转移的,所以如果你卖掉或捐掉了设备,你也可以将 Neverware 授权转让给新用户。
### 你需要什么
在你开始在笔记本上安装 CloudReady 之前,你需要一些准备:
- 一个容量大于等于 4GB 的 USB 存储设备
- 打开 Chrome 浏览器,到 Google Chrome Store 去安装 [Chromebook Recovery UtilityChrome 恢复工具)][3]
- 更改目标机器的 BIOS 设置以便能从 USB 启动
### 开始
Neverware 提供两个版本的 CloudReady 镜像32 位和 64 位。从下载页面[下载][4]合适你硬件的系统版本。
解压下载的 zip 文件,你会得到一个 chromiumos_image.bin 文件。现在插入 U 盘并打开 Chromebook recovery utility。点击工具右上角的齿轮选择 erase recovery media擦除恢复媒介如图 1
![](https://www.linux.com/sites/lcom/files/styles/rendered_file/public/cloudready-erase.png?itok=1si1QrCL)
>图 1选择 erase recovery media。[image:cloudready-erase]
接下来,选择目标 USB 驱动器并把它格式化。格式化完成后,再次打开右上齿轮,这次选择 use local image使用本地镜像。浏览解压的 bin 文件并选中,选好 USB 驱动器,点击继续,然后点击创建按钮(图 2。它会开始将镜像写入驱动器。
![](https://www.linux.com/sites/lcom/files/styles/rendered_file/public/cloudready-create.png?itok=S1FGzRp-)
>图 2创建 CloudReady 镜像。[Image:cloudready-create]
驱动器写好可启动的 CloudReady 之后,插到目标 PC 上并启动。系统启动进 Chromium OS 需要一小段时间。启动之后,你会看到图 3 中的界面。
![](https://www.linux.com/sites/lcom/files/styles/rendered_file/public/cloud-ready-install-1.jpg?itok=D6SjlIQ4)
>图 3准备好安装 CloudReady。
![](https://www.linux.com/sites/lcom/files/styles/floated_images/public/cloud-ready-install-single_crop.jpg?itok=My2rUjYC)
>图 4单系统选项。
到任务栏选择 Install CloudReady安装 CloudReady
你可以安装 Chromium OS 和其它系统的双系统启动,但另一个系统这时应该已经安装好了。
在下一个窗口选择单系统(图 4或是双系统图 5
按照下一步按钮说明选择安装。
![](https://www.linux.com/sites/lcom/files/styles/floated_images/public/cloud-ready-install-dual_crop.jpg?itok=Daywck_s)
>图 5双系统选项。
整个过程最多 20 分钟左右,这取决于存储媒介和处理能力。安装完成后,电脑会关闭并重启。
重启之后,你会看到网络设置页面(图 6。让人激动的是虽然我在相同硬件上要给 Linux 发行版安装无线驱动,到了 Chromium OS 这里是开箱即用的。
你连上无线网络之后,系统会自动查找更新并提供 Adobe Flash 安装。安装完成后,你会看到 Chromium OS 登录界面。现在你只需登录你的 Gmail 账户开始使用你的“Chromebook”即可。
![](https://www.linux.com/sites/lcom/files/styles/rendered_file/public/cloud-ready-post-install-network.jpg?itok=gSX2fQZS)
>图 6网络设置。
### 让 Netflix 正常工作
如果你想要播放 Netflix 或其它 DRM 保护流媒体站点,你需要做一些额外的工作。转到设置并点击安装 Widevine 插件(图 7
![](https://www.linux.com/sites/lcom/files/styles/rendered_file/public/install_widevine.png?itok=bUJaRmyx0)
>图 7安装 Widevine。
![](https://www.linux.com/sites/lcom/files/styles/floated_images/public/user-agent-changer.jpg?itok=5QDCLrZk)
>图 8安装 User Agent Switcher.
现在你需要使用 user agent switcher 这个伎俩(图 8
到 Chrome Webstore 去安装 [User Agent Switcher][5]。插件安装完成后,它会自动添加到浏览器的书签栏。
右键点击 agent switcher 图标并创建一个新条目(图 9
```
Name: "CloudReady Widevine"
String: "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/535.11 (KHTML, like Gecko) Ubuntu/16.10 Chrome/49.0.1453.93"
Group: "Chrome" (应该被自动填上了)
Append: "Replace"
Indicator Flag: "IE"
```
点击“添加Add”。
![](https://www.linux.com/sites/lcom/files/styles/rendered_file/public/spoof-netflix.png?itok=8DEZK4Pl)
>图 9为 CloudReady 创建条目。
然后到“permanent spoof list永久欺骗列表”选项中将 CloudReady Widevine 添加为 [www.netflix.com](http://www.netflix.com) 的永久 UA 串。
现在,重启机器,你就可以观看 Netflix 和其它一些服务了。
--------------------------------------------------------------------------------
via: https://www.linux.com/learn/turn-your-old-laptop-chromebook
作者:[SWAPNIL BHARTIYA][a]
译者:[alim0x](https://github.com/alim0x)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译,[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://www.linux.com/users/arnieswap
[1]: https://chrome.googleblog.com/2016/05/the-google-play-store-coming-to.html
[2]: http://www.neverware.com/#introtext-3
[3]: https://chrome.google.com/webstore/detail/chromebook-recovery-utili/jndclpdbaamdhonoechobihbbiimdgai?hl=en
[4]: http://www.neverware.com/freedownload
[5]: https://chrome.google.com/webstore/detail/user-agent-switcher-for-c/djflhoibgkdhkhhcedjiklpkjnoahfmg

View File

@ -0,0 +1,162 @@
在 Ubuntu Server 16.04 LTS 上安装 LAMP
=========================================================
LAMP方案是一系列自由和开源软件的集合包含了 **Linux**, web服务器 (**Apache**), 数据库服务器 (**MySQL / MariaDB**) 和 **PHP** (脚本语言). LAMP是那些需要安装和构建动态网页应用的基础平台比如WordPress, Joomla, OpenCart and Drupal。
在这篇文章中我将描述如何在Ubuntu Server 16.04 LTS 上安装LAMP众所周知Ubuntu是一个基于linux的操作系统因此它构成了LAMP的第一个部分在接下来的操作中我将默认你已经安装了 Ubuntu Server 16.04。
### Apache2 web服务器的安装 :
在Ubuntu linux中web 服务器称之为 Apache2我们可以利用下面的命令来安装它
```
linuxtechi@ubuntu:~$ sudo apt update
linuxtechi@ubuntu:~$ sudo apt install apache2 -y
```
当安装Apache2包之后Apache2相关的服务将会在重启后变成可用状态和自动运行在某些情况下如果你的Apache2服务并没有自动可用和启动你可以利用如下命令来启用它。
```
linuxtechi@ubuntu:~$ sudo systemctl start apache2.service
linuxtechi@ubuntu:~$ sudo systemctl enable apache2.service
linuxtechi@ubuntu:~$ sudo systemctl status apache2.service
```
如果你开启了Ubuntu的防火墙ufw那么你可以使用如下的命令来解除web服务器的端口(80和443)限制
```
linuxtechi@ubuntu:~$ sudo ufw status
Status: active
linuxtechi@ubuntu:~$ sudo ufw allow in 'Apache Full'
Rule added
Rule added (v6)
linuxtechi@ubuntu:~$
```
### 现在开始访问你的web服务器 :
打开浏览器并输入服务器的IP地址或者主机名
(http://IP_Address_OR_Host_Name),在我的例子中我的服务器IP是192.168.1.13
![](http://www.linuxtechi.com/wp-content/uploads/2016/05/Apache2-Ubuntu-server-16.04-1024x955.jpg)
### 数据库服务器的安装r (MySQL Server 5.7) :
MySQL 和 MariaDB 都是 Ubuntu 16.04 中的数据库服务器. MySQL Server 和 MariaDB Server的安装包都可以在Ubuntu的默认软件源中找到我们可以选择其中的一个来安装.通过下面的命令来在终端中安装mysql服务器
```
linuxtechi@ubuntu:~$ sudo apt install mysql-server mysql-client
```
在安装过程中它会要求你设置mysql服务器root帐户的密码.
![](http://www.linuxtechi.com/wp-content/uploads/2016/05/Enter-root-password-mysql-server-ubuntu-16-04.jpg)
确认root帐户的密码并点击确定
![](http://www.linuxtechi.com/wp-content/uploads/2016/05/confirm-root-password-mysql-server-ubuntu-16-04.jpg)
Mysql 服务器的安装到此已经结束了, MySQL 服务会自动变成可用状态和自动启动.我们可以通过如下的命令来校验Mysql服务的状态
```
linuxtechi@ubuntu:~$ sudo systemctl status mysql.service
```
### MariaDB Server的安装 :
在终端中利用如下的命令来安装 Mariadb 10.0 服务器。
```
linuxtechi@ubuntu:~$ sudo apt install mariadb-server
```
运行如下的命令来设置mariadb root帐户的密码还可以用来关闭某些选项比如关闭远程登录功能。
```
linuxtechi@ubuntu:~$ sudo mysql_secure_installation
```
### PHP脚本语言的安装:
PHP 7 已经存在于Ubuntu的软件源中了在终端中执行如下的命令来安装PHP 7:
```
linuxtechi@ubuntu:~$ sudo apt install php7.0-mysql php7.0-curl php7.0-json php7.0-cgi php7.0 libapache2-mod-php7.0
```
创建一个简单的php页面并且将它移动到 apache的文档根目录下 (/var/ww/html)
```
linuxtechi@ubuntu:~$ vi samplepage.php
<?php
phpinfo();
?>
```
在vi中编辑之后保存并退出该文件。
```
linuxtechi@ubuntu:~$ sudo mv samplepage.php /var/www/html/
```
现在你可以从web浏览器中访问这个页面,
输入 : “http://<Server_IP>/samplepage.php” ,你可以看到如下页面.
![](http://www.linuxtechi.com/wp-content/uploads/2016/05/Sample-PHP-Page-Ubuntu-Server-16-04.jpg)
以上的页面向我们展示了PHP已经完全安装成功了
### phpMyAdmin的安装:
phpMyAdmin可以让我们通过它的web界面来执行所有和数据库管理和其他数据库操作相关的任务这个安装包已经存在于Ubuntu的软件源中
利用如下的命令来在Ubuntu server 16.04 LTS中安装phpMyAdmin
```
linuxtechi@ubuntu:~$ sudo apt install php-mbstring php7.0-mbstring php-gettext
linuxtechi@ubuntu:~$ sudo systemctl restart apache2.service
linuxtechi@ubuntu:~$ sudo apt install phpmyadmin
```
在以下的安装过程中它会提示我们选择phpMyAdmin运行的目标服务器
选择 Apache2 并点击确定
![](http://www.linuxtechi.com/wp-content/uploads/2016/05/Web-Server-for-phpMyAdmin-Ubuntu-Server-16-04.jpg)
点击确定来配置phpMyAdmin管理的数据库
![](http://www.linuxtechi.com/wp-content/uploads/2016/05/configure-database-for-phpmyadmin-ubuntu-server-16-04.jpg)
指定phpMyAdmin向数据库服务器注册时所用的密码
![](http://www.linuxtechi.com/wp-content/uploads/2016/05/Select-Password-for-phpMyadmin-ubuntu-16-04-1024x433.jpg)
确认phpMyAdmin所需的密码并点击确认
![](http://www.linuxtechi.com/wp-content/uploads/2016/05/confirm-password-for-phpmyadmin-ubuntu-server-16-04.jpg)
现在可以开始尝试访问phpMyAdmin, 打开浏览器并输入 : “http://Server_IP_OR_Host_Name/phpmyadmin”
利用我们安装时设置的 root帐户和密码
![](http://www.linuxtechi.com/wp-content/uploads/2016/05/phpMyAdmin-Ubuntu-Server-16-04-1024x557.jpg)
当我们点击“Go”的时候将会重定向到如下所示的 phpMyAdminweb界面
![](http://www.linuxtechi.com/wp-content/uploads/2016/05/phpMyAdmin-portal-overview-ubuntu-server-16-04-1024x557.jpg)
到现在LAMP方案已经被成功安装和使用了欢迎分享你的反馈和评论。
--------------------------------------------------------------------------------
via: http://www.linuxtechi.com/lamp-stack-installation-on-ubuntu-server-16-04/
作者:[Pradeep Kumar][a]
译者:[陆建波](https://github.com/lujianbo)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译,[Linux中国](https://linux.cn/) 荣誉推出
[a]: http://www.linuxtechi.com/author/pradeep/

View File

@ -0,0 +1,181 @@
在 Ubuntu Linux 中使用 WEBP 图片
=========================================
![](http://itsfoss.com/wp-content/uploads/2016/05/support-webp-ubuntu-linux.jpg)
>简介:这篇指南会向你展示如何在 Linux 下查看 WebP 图片以及将 WebP 图片转换为 JPEG 或 PNG 格式。
### 什么是 WEBP
Google 为图片推出 [WebP 文件格式][0]已经超过五年了。Google 说WebP 提供有损和无损压缩,相比 JPEG 压缩WebP 压缩文件大小能更小约 25%。
Google 的目标是让 WebP 成为 web 图片的新标准但是我没能看到这一切发生。已经五年过去了除了谷歌的生态系统以外它仍未被接受成为一个标准。但正如我们所知的Google 对它的技术很有进取心。几个月前 Google 将 Google Plus 的所有图片改为了 WebP 格式。
如果你用 Google Chrome 从 Google Plus 上下载那些图片,你会得到 WebP 图片,不论你之前上传的是 PNG 还是 JPEG。这都不是重点。真正的问题在于当你尝试着在 Ubuntu 中使用默认的 GNOME 图片查看器打开它时你会看到如下错误:
> **Could not find XYZ.webp无法找到 XYZ.webp**
> **Unrecognized image file format未识别文件格式**
![](http://itsfoss.com/wp-content/uploads/2016/05/WebP-images-Ubuntu-Linux-1.png)
>GNOME 图片查看器不支持 WebP 图片
在这个教程里,我们会看到
- 如何在 Linux 中添加 WebP 支持
- 支持 WebP 图片的程序列表
- 如何将 WebP 图片转换到 PNG 或 JPEG
- 如何将 WebP 图片直接下载为 PNG 格式
### 如何在 Ubuntu 以及其它 Linux 发行版中查看 WebP 图片
[GNOME 图片查看器][3]是许多 Linux 发行版的默认图片查看器,包括 Ubuntu它不支持 WebP 图片。目前也没有可用的插件给 GNOME 图片查看器添加 WebP 支持。
这无非是意味着我们不能在 Linux 上用 GNOME 图片查看器打开 WebP 文件而已。一个更好的替代品,[gThumb][4],默认就支持 WebP 图片。
要在 Ubuntu 以及其它基于 Ubuntu 的发行版上安装 gThumb 的话,使用以下命令:
```
sudo apt-get install gthumb
```
一旦安装完成,你就可以简单地右键点击 WebP 图片,选择 gThumb 来打开它。你现在应该可以看到如下画面:
![](http://itsfoss.com/wp-content/uploads/2016/05/WebP-images-Ubuntu-Linux-2.jpeg)
>gThumb 中显示的 WebP 图片
### 让 gThumb 成为 Ubuntu 中 WebP 图片的默认应用
对 Ubuntu 新手而言,如果你想要让 gThumb 成为打开 WebP 文件的默认应用,跟着以下步骤操作:
#### 步骤 1右键点击 WebP 文件选择属性。
![](http://itsfoss.com/wp-content/uploads/2016/05/WebP-images-Ubuntu-Linux-3.png)
>从右键菜单中选择属性
#### 步骤 2转到打开方式标签选择 gThumb 并点击设置为默认。
![](http://itsfoss.com/wp-content/uploads/2016/05/WebP-images-Ubuntu-Linux-4.png)
>让 gThumb 成为 Ubuntu 中 WebP 图片的默认应用
### 让 gThumb 成为所有图片的默认应用
gThumb 的功能比图片查看器更多。举个例子,你可以做一些简单的编辑,给图片添加滤镜等。添加滤镜的效率没有 XnRetro在[ Linux 下添加类似 Instagram 滤镜效果][5]的专用工具)那么高,但它还是有一些基础的滤镜可以用。
我非常喜欢 gThumb 并且决定让它成为默认的图片查看器。如果你也想在 Ubuntu 中让 gThumb 成为所有图片的默认默认应用,遵照以下步骤操作:
#### 步骤1打开系统设置
![](http://itsfoss.com/wp-content/uploads/2014/04/System_Settings_ubuntu_1404.jpeg)
#### 步骤2转到详情Details
![](http://itsfoss.com/wp-content/uploads/2013/11/System_settings_Ubuntu_1.jpeg)
#### 步骤3在这里将 gThumb 设置为图片的默认应用
![](http://itsfoss.com/wp-content/uploads/2016/05/WebP-images-Ubuntu-Linux-5.png)
### Linux 上打开 WebP 文件的替代程序
可能你不喜欢 gThumb。如果这样的话你可以选择下列应用来在 Linux 中查看 WebP 图片:
- [XnView][6](非开源)
- GIMP 加上非官方 WebP 插件,可以从这个 [PPA][7] 安装,支持到 Ubuntu 15.10。我会在另一篇文章里提到。
- [Gwenview][8]
### 在 Linux 中将 WebP 图片转换为 PNG 和 JPEG
在 Linux 上转换 WebP 图片有两种途径:
- 命令行
- 图形界面
#### 1.在 Linux 使用命令行转换 WebP 图片
你需要先安装 WebP 工具。打开终端并使用下列命令:
```
sudo apt-get install webp
```
##### 将 JPEG/PNG 转换为 WebP
我们将使用 cwebp 命令(它代表压缩为 WebP 吗?)来将 JPEG 或 PNG 文件转换为 WebP。命令格式是这样的
```
cwebp -q [图片质量] [JPEG/PNG_文件名] -o [WebP_文件名]
```
举个例子,你可以使用下列命令:
```
cwebp -q 90 example.jpeg -o example.webp
```
##### 将 WebP 转换为 JPEG/PNG
要将 WebP 图片转换为 JPEG 或 PNG我们将使用 dwebp 命令。命令格式是:
```
dwebp [WebP_文件名] -o [PNG_文件名]
```
该命令的一个例子:
```
dwebp example.webp -o example.png
```
#### 2.使用图形工具将 WebP 转换为 JPEG/PNG
要实现这个目标,我们要使用 XnConvert它是免费的应用但不是开源的。你可以从他们的网站上下载安装文件
[下载 XnConvert][1]
XnConvert 是个强大的工具,你可以用它来批量修改图片尺寸。但在这个教程里,我们只能看到如何将单个 WebP 图片转换为 PNG/JPEG。
打开 XnConvert 并选择输入文件:
![](http://itsfoss.com/wp-content/uploads/2016/05/WebP-images-Ubuntu-Linux-6.jpeg)
在输出标签,选择你想要的输出格式。选择完后点击转换。
![](http://itsfoss.com/wp-content/uploads/2016/05/WebP-images-Ubuntu-Linux-7.jpeg)
要将 WebP 图片转换为 PNGJPEG 或其它你选择的图片格式,这就是你所需要做的一切了。
### 在 Chrome 浏览器中直接将 WebP 图片下载为 PNG
也许你一点都不喜欢 WebP 图片格式,也不想在 Linux 仅仅为了查看 WebP 图片而安装一个新软件。如果你不得不将 WebP 文件转换以备将来使用,这会是件更痛苦的事情。
一个解决这个问题更简单,不那么痛苦的途径是安装一个 Chrome 扩展 Save Image as PNG。有了这个插件你可以右键点击 WebP 图片并直接存储为 PNG 格式。
![](http://itsfoss.com/wp-content/uploads/2016/05/WebP-images-Ubuntu-Linux-8.png)
>在 Google Chrome 中将 WebP 图片保存为 PNG 格式
[获取 Save Image as PNG 扩展][2]
### 你的选择是?
我希望这个详细的教程能够帮你在 Linux 上获取 WebP 支持并帮你转换 WebP 图片。你在 Linux 怎么处理 WebP 图片?你使用哪个工具?以上描述的方法中,你最喜欢哪一个?
----------------------
via: http://itsfoss.com/webp-ubuntu-linux/?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%3A+ItsFoss+%28Its+FOSS%21+An+Open+Source+Blog%29
作者:[Abhishek Prakash][a]
译者:[alim0x](https://github.com/alim0x)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创翻译,[Linux中国](https://linux.cn/) 荣誉推出
[a]: http://itsfoss.com/author/abhishek/
[0]: https://developers.google.com/speed/webp/
[1]: http://www.xnview.com/en/xnconvert/#downloads
[2]: https://chrome.google.com/webstore/detail/save-image-as-png/nkokmeaibnajheohncaamjggkanfbphi?utm_source=chrome-ntp-icon
[3]: https://wiki.gnome.org/Apps/EyeOfGnome
[4]: https://wiki.gnome.org/Apps/gthumb
[5]: http://itsfoss.com/add-instagram-effects-xnretro-ubuntu-linux/
[6]: http://www.xnview.com/en/xnviewmp/#downloads
[7]: https://launchpad.net/~george-edison55/+archive/ubuntu/webp
[8]: https://userbase.kde.org/Gwenview

View File

@ -0,0 +1,138 @@
在 Ubuntu 16.04 上安装使用 VBoxManage 以及 VBoxManage 命令行选项的用法
=================
VirtualBox 拥有一套命令行工具,然后你可以使用 VirtualBox 的命令行界面 (CLI) 对远端无界面的服务器上的虚拟机进行管理操作。在这篇教程中,你将会学到如何在没有 GUI 的情况下使用 VBoxManage 创建、启动一个虚拟机。VBoxManage 是 VirtualBox 的命令行界面,你可以在你的主机操作系统的命令行中来用它实现对 VirtualBox 的所有操作。VBoxManage 拥有图形化用户界面所支持的全部功能,而且它支持的功能远不止这些。它提供虚拟引擎的所有功能,甚至包含 GUI 还不能实现的那些功能。如果你想尝试不同的用户界面而不仅仅是 GUI或者更改虚拟机更多高级和实验性的配置那么你就需要用到命令行。
当你想要在 VirtualBox 上创建或运行虚拟机时,你会发现 VBoxManage 非常有用,你只需要使用远程主机的终端就够了。这对于服务器来说是一种常见的情形,因为在服务器上需要进行虚拟机的远程操作。
### 准备工作
在开始使用 VBoxManage 的命令行工具前,确保在运行着 Ubuntu 16.04 的服务器上,你拥有超级用户的权限或者你能够使用 sudo 命令,而且你已经在服务器上安装了 Oracle Virtual Box。 然后你需要安装 VirtualBox 扩展包这是运行远程桌面环境访问无界面启动虚拟机所必须的。headless的翻译拿不准翻译为无界面启动
### 安装 VBoxManage
通过 [Virtual Box Download Page][1] 这个链接,你能够获取你所需要的软件扩展包的最新版本,扩展包的版本和你安装的 VirtualBox 版本需要一致!
![](http://linuxpitstop.com/wp-content/uploads/2016/06/12.png)
也可以用下面这条命令来获取 VBoxManage 扩展。
```
$ wget http://download.virtualbox.org/virtualbox/5.0.20/Oracle_VM_VirtualBox_Extension_Pack-5.0.20-106931.vbox-extpack
```
![](http://linuxpitstop.com/wp-content/uploads/2016/06/21.png)
运行下面这条命令,确认 VBoxManage 已经成功安装在你的机器上。
```
$ VBoxManage list extpacks
```
![](http://linuxpitstop.com/wp-content/uploads/2016/06/31.png)
### 在 Ubuntu 16.04 上使用 VBoxManage
接下来我们将要使用 VBoxManage 向你展现通过命令行终端工具来新建和管理虚拟机是多么的简单。
运行下面的命令,新建一个将用来安装 Ubuntu 系统的虚拟机。
```
# VBoxManage createvm --name Ubuntu16.04 --register
```
在运行了这条命令之后VBoxMnage 将会新建一个叫 做“Ubuntu16.vbox” 的虚拟机,这个虚拟机的位置是家目录路径下的 “VirtualBox VMs/Ubuntu16/Ubuntu16.04.vbox”。在上面这条命令中“createvm” 是用来新建虚拟机,“--name” 定义了虚拟机的名字,而 “registervm” 命令是用来注册虚拟机的。
现在,使用下面这条命令为虚拟机创建一个硬盘镜像。
```
$ VBoxManage createhd --filename Ubuntu16.04 --size 5124
```
这里“createhd” 用来创建硬盘镜像,“--filename” 用来指定虚拟机的名称,也就是创建的硬盘镜像名称。“--size” 表示硬盘镜像的空间容量,空间容量的单位总是 MB。我们指定了 5Gb也就是 5124 MB。
接下来我们需要设置操作系统类型,如果要安装 Linux 系的系统,那么用下面这条命令指定系统类型为 Linux 或者 Ubuntu 或者 Fedora 之类的。
```
$ VBoxManage modifyvm Ubuntu16.04 --ostype Ubuntu
```
用下面这条命令来设置虚拟系统的内存大小,也就是从主机中分配到虚拟机系统的内存。
```
$ VBoxManage modifyvm Ubuntu10.10 --memory 512
```
![](http://linuxpitstop.com/wp-content/uploads/2016/06/52.png)
现在用下面这个命令为虚拟机创建一个存储控制器。
```
$ VBoxManage storagectl Ubuntu16.04 --name IDE --add ide --controller PIIX4 --bootable on
```
这里的 “storagect1” 是给虚拟机创建存储控制器的,“--name” 指定了虚拟机里需要创建、更改或者移除的存储控制器的名称。“--add” 选项指明系统总线类型,可选的选项有 ide / sata / scsi / floppy存储控制器必须要连接到系统总线。“--controller” 选择主板的类型,主板需要根据需要的存储控制器选择,可选的选项有 LsiLogic / LSILogicSAS / BusLogic / IntelAhci / PIIX3 / PIIX4 / ICH6 / I82078。最后的 “--bootable” 表示控制器是否可以引导。
上面的命令创建了叫做 IDE 的存储控制器。然后虚拟设备就能通过 “storageattach” 命令连接到控制器。
然后运行下面这个命令来创建一个叫做 SATA 的存储控制器,它将会连接到硬盘镜像上。
```
$ VBoxManage storagectl Ubuntu16.04 --name SATA --add sata --controller IntelAhci --bootable on
```
将之前创建的硬盘镜像和 CD/DVD 驱动器加载到 IDE 控制器。将 Ubuntu 的安装光盘插到 CD/DVD 驱动器上。然后用 “storageattach” 命令连接存储控制器和虚拟机。
```
$ VBoxManage storageattach Ubuntu16.04 --storagectl SATA --port 0 --device 0 --type hdd --medium "your_iso_filepath"
```
用媒体把 SATA 存储控制器连接到 Ubuntu16.04 虚拟机中,也就是之前创建的虚拟硬盘镜像里。
运行下面的命令添加像网络连接,音频之类的功能。
```
$ VBoxManage modifyvm Ubuntu10.10 --nic1 nat --nictype1 82540EM --cableconnected1 on
$ VBoxManage modifyvm Ubuntu10.10 --vram 128 --accelerate3d on --audio alsa --audiocontroller ac97
```
通过指定你想要启动虚拟机的名称,用下面这个命令启动虚拟机。
```
$ VBoxManage startvm Ubuntu16.04
```
然后会打开一个新窗口,新窗口里虚拟机通过关联文件中引导。
![](http://linuxpitstop.com/wp-content/uploads/2016/06/62.png)
你可以用接下来的命令来关掉虚拟机。
```
$ VBoxManage controlvm Ubuntu16.04 poweroff
```
“controlvm” 命令用来控制虚拟机的状态,可选的选项有 pause / resume / reset / poweroff / savestate / acpipowerbutton / acpisleepbutton。controlvm 有很多选项,用下面这个命令来查看它支持的所有选项。
```
$VBoxManage controlvm
```
![](http://linuxpitstop.com/wp-content/uploads/2016/06/81.png)
完结!
从这篇文章中,我们了解了 Oracle Virtual Box 中一个十分实用的工具,就是 VBoxManage包含了 VBoxManage 的安装和在 Ubuntu 16.04 系统上的使用。文章包含详细的教程, 通过 VBoxManage 中实用的命令来创建和管理虚拟机。希望这篇文章对你有帮助,另外别忘了分享你的评论或者建议。
--------------------------------------------------------------------------------
via: http://linuxpitstop.com/install-and-use-command-line-tool-vboxmanage-on-ubuntu-16-04/
作者:[Kashif][a]
译者:[GitFuture](https://github.com/GitFuture)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译,[Linux中国](https://linux.cn/) 荣誉推出
[a]: http://linuxpitstop.com/author/kashif/
[1]: https://www.virtualbox.org/wiki/Downloads

View File

@ -0,0 +1,218 @@
你应该知道的基础 Git 命令
=====================================
![](http://itsfoss.com/wp-content/uploads/2016/06/Download-Git-Sheet.jpg)
*简介:这个快速指南将向你展示所有的基础 Git 命令以及用法。你可以下载这些命令作为快速参考。*
我们在早先一篇文章中已经见过快速指南和 [Vi cheat sheet 下载][1]了。在这篇文章里,我们将会看到开始使用 Git 所需要的基础命令。
### GIT
[Git][2] 是一个分布式版本控制系统,它被用在大量开源项目中。它是在 2005 年由 Linux 创始人 [Linus Torvalds][3] 写就的。这个程序允许非线性的项目开发,并且能够通过存储在本地服务器高效处理大量数据。在这个教程里,我们将要和 Git 愉快玩耍并学习如何开始使用它。
我在这个教程里使用 Ubuntu但你可以使用你选择的任何发行版。除了安装以外剩下的所有命令在任何 Linux 发行版上都是一样的。
### 安装 GIT
要安装 git 执行以下命令:
```
sudo apt-get install git-core
```
在它完成下载之后,你就安装好了 Git 并且可以使用了。
### 设置 GIT
在 Git 安装之后,不论是从 apt-get 还是从源码安装,你需要将你的用户名和邮箱地址复制到 gitconfig 文件。你可以访问 ~/.gitconfig 这个文件。
全新安装 Git 之后打开它会是完全空白的页面:
```
sudo vim ~/.gitconfig
```
你也可以使用以下命令添加所需的信息。将user替换成你的用户名user@example.com替换成你的邮箱。
```
git config --global user.name "User"
git config --global user.email user@example.com
```
然后你就完成设置了。现在让我们开始 Git。
### 仓库:
创建一个新目录,打开它并运行以下命令:
```
git init
```
![](http://itsfoss.com/wp-content/uploads/2016/05/Playing-around-git-1-1024x173.png)
这个命令会创建一个新的 git 仓库。你的本地仓库由三个 git 维护的“树”组成。
第一个是你的**工作目录**,保存实际的文件。第二个是索引,实际上扮演的是暂存区,最后一个是 HEAD它指向你最后一个 commit 提交。
使用 git clone /path/to/repository 签出你的仓库(从你刚创建的仓库或服务器上已存在的仓库)。
### 添加文件并提交:
你可以用以下命令添加改动:
```
git add <filename>
```
这会添加一个新文件到暂存区以提交。如果你想添加每个新文件,输入:
```
git add --all
```
添加文件之后可以使用以下命令检查状态:
```
git status
```
![](http://itsfoss.com/wp-content/uploads/2016/05/Playing-around-git-2-1024x219.png)
正如你看到的,那里已经有一些变化但还没有提交。现在你需要提交这些变化,使用:
```
git commit -m "提交信息"
```
![](http://itsfoss.com/wp-content/uploads/2016/05/playing-around-git-3-1024x124.png)
你也可以这么做(首选):
```
git commit -a
```
然后写下你的提交信息。现在你的文件提交到了 HEAD但还不在你的远程仓库中。
### 推送你的改动
你的改动在你本地工作副本的 HEAD 中。如果你还没有从一个已存在的仓库克隆或想将你的仓库连接到远程服务器,你需要先添加它:
```
git remote add origin <服务器地址>
```
现在你可以将改动推送到指定的远程服务器。要将改动发送到远程服务器,运行:
```
git push -u origin master
```
### 分支:
分支用于开发特性,它们之间是互相独立的。主分支 master 是你创建一个仓库时的“默认”分支。使用其它分支用于开发,在完成时将它合并回主分支。
创建一个名为“mybranch”的分支并切换到它之上
```
git checkout -b mybranch
```
![](http://itsfoss.com/wp-content/uploads/2016/05/Playing-around-Git-4--1024x145.jpg)
你可以使用这个命令切换回主分支:
```
git checkout master
```
如果你想删除这个分支,执行:
```
git branch -d mybranch
```
![](http://itsfoss.com/wp-content/uploads/2016/05/Playing-around-Git-5-1-1024x181.jpg)
除非你将分支推送到远程服务器上,否则该分支对其他人是不可用的,所以只需把它推送上去:
```
git push origin <分支名>
```
### 更新和合并
要将你本地仓库更新到最新提交,运行:
```
git pull
```
在你的工作目录获取和合并远程变动。要合并其它分支到你的活动分支(如 master使用
```
git merge <分支>
```
在这两种情况下git 会尝试自动合并auto-merge改动。不幸的是这不总是可能的可能会导致冲突。你需要负责通过编辑 git 显示的文件,手动合并那些冲突。改动之后,你需要用以下命令将它们标记为已合并:
```
git add <文件名>
```
在合并改动之前,你也可以使用以下命令预览:
```
git diff <源分支> <目标分支>
```
### GIT 日志:
你可以这么查看仓库历史:
```
git log
```
要查看每个提交一行样式的日志你可以用:
```
git log --pretty=oneline
```
或者也许你想要看一个所有分支的 ASCII 艺术树,带有标签和分支名:
```
git log --graph --oneline --decorate --all
```
如果你只想看哪些文件改动过:
```
git log --name-status
```
在这整个过程中如果你需要任何帮助,你可以用 git --help。
Git 棒不棒!!!祝贺你你已经会 git 基础了。如果你愿意的话,你可以从下面这个链接下载这些基础 Git 命令作为快速参考:
[下载 Git Cheat Sheet][4]
--------------------------------------------------------------------------------
via: http://itsfoss.com/basic-git-commands-cheat-sheet/
作者:[Rakhi Sharma][a]
译者:[alim0x](https://github.com/alim0x)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译,[Linux中国](https://linux.cn/) 荣誉推出
[a]: http://itsfoss.com/author/rakhi/
[1]: http://itsfoss.com/download-vi-cheat-sheet/
[2]: https://git-scm.com/
[3]: https://en.wikipedia.org/wiki/Linus_Torvalds
[4]: https://drive.google.com/open?id=0By49_3Av9sT1bXpINjhvU29VNUU

View File

@ -0,0 +1,316 @@
LFCS 第十讲:学习简单的 Shell 脚本编程和文件系统故障排除
================================================================================
Linux 基金会发起了 LFCS 认证 (Linux Foundation Certified Sysadmin, Linux 基金会认证系统管理员),这是一个全新的认证体系,主要目标是让全世界任何人都有机会考取认证。认证内容为 Linux 中间系统的管理,主要包括:系统运行和服务的维护、全面监控和分析的能力以及问题来临时何时想上游团队请求帮助的决策能力
![Basic Shell Scripting and Filesystem Troubleshooting](http://www.tecmint.com/wp-content/uploads/2014/11/lfcs-Part-10.png)
LFCS 系列第十讲
请看以下视频,这里边介绍了 Linux 基金会认证程序。
<video src="https://dn-linuxcn.qbox.me/static%2Fvideo%2FIntroducing%20The%20Linux%20Foundation%20Certification%20Program-Y29qZ71Kicg.mp4" controls="controls" width="100%">
</video>
本讲是系列教程中的第十讲,主要集中讲解简单的 Shell 脚本编程和文件系统故障排除。这两块内容都是 LFCS 认证中的必备考点。
### 理解终端 (Terminals) 和 Shell ###
首先要声明一些概念。
- Shell 是一个程序,它将命令传递给操作系统来执行。
- Terminal 也是一个程序,作为最终用户,我们需要使用它与 Shell 来交互。比如,下边的图片是 GNOME Terminal。
![Gnome Terminal](http://www.tecmint.com/wp-content/uploads/2014/11/Gnome-Terminal.png)
Gnome Terminal
启动 Shell 之后,会呈现一个命令提示符 (也称为命令行) 提示我们 Shell 已经做好了准备,接受标准输入设备输入的命令,这个标准输入设备通常是键盘。
你可以参考该系列文章的 [第一讲 使用命令创建、编辑和操作文件][1] 来温习一些常用的命令。
Linux 为提供了许多可以选用的 Shell下面列出一些常用的
**bash Shell**
Bash 代表 Bourne Again Shell它是 GNU 项目默认的 Shell。它借鉴了 Korn shell (ksh) 和 C shell (csh) 中有用的特性,并同时对性能进行了提升。它同时也是 LFCS 认证中所涵盖的风发行版中默认 Shell也是本系列教程将使用的 Shell。
**sh Shell**
Bash Shell 是一个比较古老的 shell一次多年来都是多数类 Unix 系统的默认 shell。
**ksh Shell**
Korn SHell (ksh shell) 也是一个 Unix shell是贝尔实验室 (Bell Labs) 的 David Korn 在 19 世纪 80 年代初的时候开发的。它兼容 Bourne shell ,并同时包含了 C shell 中的多数特性。
一个 shell 脚本仅仅只是一个可执行的文本文件,里边包含一条条可执行命令。
### 简单的 Shell 脚本编程 ###
如前所述,一个 shell 脚本就是一个纯文本文件,因此,可以使用自己喜欢的文本编辑器来创建和编辑。你可以考虑使用 vi/vim (参考本系列 [第二部分 - vi/vim 编辑器的使用][2]),它的语法高亮让我的编辑工作非常方便。
输入如下命令来创建一个名为 myscript.sh 的脚本文件:
# vim myscript.sh
shell 脚本的第一行 (著名的 [shebang 符](http://smilejay.com/2012/03/linux_shebang/)) 必须如下:
#!/bin/bash
这条语句“告诉”操作系统需要用那个解释器来运行这个脚本文件之后命令。
现在可以添加需要执行的命令了。通过注释我们可以声明每一条命令或者整个脚本的具体含义。注意shell 会忽略掉以井号 (#) 开始的语句。
#!/bin/bash
echo 这是关于 LFCS 认证系列的第十部分
echo 今天是 $(date +%Y-%m-%d)
编写并保存脚本之后,通过以下命令来是脚本文件称为可执行文件:
# chmod 755 myscript.sh
在执行脚本之前,我们需要说一下环境变量 ($PATH),运行:
echo $PATH
我们就会看到环境变量 ($PATH) 的具体内容:当输入命令是系统搜索可执行程序的目录,每一项之间使用冒号 (:) 隔开。称它为环境变量,是因为他本是就是 shell 环境的一部分 —— 当 shell 第每次启动时 shell 及其子进程可以获取的一系列信息。
当我们输入一个命令并按下回车时shell 会搜索 $PATH 变量中列出的目录并执行第一个知道的实例。请看如下例子:
![Linux Environment Variables](http://www.tecmint.com/wp-content/uploads/2014/11/Environment-Variable.png)
环境变量
假如存在两个同名的可执行程序,一个在 /usr/local/bin另一个在 /usr/bin则会执行环境变量中最先列出的那个并忽略另外一个。
如果我们自己编写的脚本没有在 $PATH 变量列出目录的其中一个,则需要输入 ./filename 来执行它。而如果存储在 $PATH 变量中的任意一个目录,我们就可以像运行其他命令一样来运行之前编写的脚本了。
# pwd
# ./myscript.sh
# cp myscript.sh ../bin
# cd ../bin
# pwd
# myscript.sh
![Execute Script in Linux](http://www.tecmint.com/wp-content/uploads/2014/11/Execute-Script.png)
执行脚本
#### if 条件语句 ####
无论何时,当你需要在脚本中根据某个命令的运行结果来采取相应动作时,你应该使用 if 结构来定义条件。基本语法如下:
if CONDITION; then
COMMANDS;
else
OTHER-COMMANDS
fi
其中CONDITION 为如下情形的任意一项 (仅列出常用的),并且达到以下条件时返回 true
- [ -a file ] → 指定文件存在。
- [ -d file ] → 指定文件存在,并且是一个目录。
- [ -f file ] → 指定文件存在,并且是一个普通文件。
- [ -u file ] → 指定文件存在,并设置了 SUID。
- [ -g file ] → 指定文件存在,并设置了 SGID。
- [ -k file ] → 指定文件存在,并设置了“黏连 (Sticky)”位。
- [ -r file ] → 指定文件存在,并且文件可读。
- [ -s file ] → 指定文件存在,并且文件为空。
- [ -w file ] → 指定文件存在,并且文件可写入·
- [ -x file ] → 指定文件存在,并且可执行。
- [ string1 = string2 ] → 字符串相同。
- [ string1 != string2 ] → 字符串不相同。
[ int1 op int2 ] 为前述列表中的一部分,紧跟着的项 (例如: -eq > int1 与 int2 相同时返回 true) 则是 [ int1 op int2 ] 的一个子项, 其中 op 为以下比较操作符。
- -eq > int1 等于 int2 时返回 true。
- -ne > int1 不等于 int2 时返回 true。
- -lt > int1 小于 int2 时返回 true。
- -le > int1 小于或等于 int2 时返回 true。
- -gt > int1 大于 int2 时返回 true。
- -ge > int1 大于或等于 int2 时返回 true。
#### for 循环语句 ####
循环语句可以在某个条件下重复执行某个命令。基本语法如下:
for item in SEQUENCE; do
COMMANDS;
done
其中item 为每次执行 COMMANDS 时,在 SEQUENCE 中匹配到的值。
#### While 循环语句 ####
该循环结构会一直执行重复的命令,直到控制命令执行的退出状态值等于 0 时 (即执行成功) 停止。基本语法如下:
while EVALUATION_COMMAND; do
EXECUTE_COMMANDS;
done
其中EVALUATION_COMMAND 可以是任何能够返回成功 (0) 或失败 (0 以外的值) 的退出状态值的命令EXECUTE_COMMANDS 则可以是任何的程序、脚本或者 shell 结构体,包括其他的嵌套循环。
#### 综合使用 ####
我们会通过以下例子来演示 if 条件语句和 for 循环语句。
**在基于 systemd 的发行版中探测某个服务是否在运行**
先建立一个文件,列出我们想要想要查看的服务名。
# cat myservices.txt
sshd
mariadb
httpd
crond
firewalld
![Script to Monitor Linux Services](http://www.tecmint.com/wp-content/uploads/2014/11/Monitor-Services.png)
使用脚本监控 Linux 服务
我们编写的脚本看起来应该是这样的:
#!/bin/bash
# This script iterates over a list of services and
# is used to determine whether they are running or not.
for service in $(cat myservices.txt); do
systemctl status $service | grep --quiet "running"
if [ $? -eq 0 ]; then
echo $service "is [ACTIVE]"
else
echo $service "is [INACTIVE or NOT INSTALLED]"
fi
done
![Linux Service Monitoring Script](http://www.tecmint.com/wp-content/uploads/2014/11/Monitor-Script.png)
Linux 服务监控脚本
**我们来解释一下这个脚本的工作流程**
1). for 循环每次读取 myservices.txt 文件中的一项记录,每一项纪录表示一个服务的通用变量名。各项记录组成如下:
# cat myservices.txt
2). 以上命令由圆括号括着,并在前面添加美元符,表示它需要从 myservices.txt 的记录列表中取值作为变量传递给 for 循环。
3). 对于记录列表中的每一项纪录 (即每一项纪录的服务变量),都会这行以下动作:
# systemctl status $service | grep --quiet "running"
此时,需要在每个通用变量名 (即每一项纪录的服务变量) 的前面添加美元符,以表明它是作为变量来传递的。其输出则通过管道符传给 grep。
其中,-quiet 选项用于阻止 grep 命令将出现 "running" 的行回显到屏幕。当 grep 捕获到 "running" 时,则会返回一个退出状态码 "0" (在 if 结构体表示为 $?),由此确认某个服务正在运行中。
如果退出状态码是非零值 (即 systemctl status $service 命令中的回显中没有出现 "running"),则表明某个服务为运行。
![Services Monitoring Script](http://www.tecmint.com/wp-content/uploads/2014/11/Services-Monitoring-Script.png)
服务监控脚本
我们可以增加一步,在开始循环之前,先确认 myservices.txt 是否存在。
#!/bin/bash
# This script iterates over a list of services and
# is used to determine whether they are running or not.
if [ -f myservices.txt ]; then
for service in $(cat myservices.txt); do
systemctl status $service | grep --quiet "running"
if [ $? -eq 0 ]; then
echo $service "is [ACTIVE]"
else
echo $service "is [INACTIVE or NOT INSTALLED]"
fi
done
else
echo "myservices.txt is missing"
fi
**Ping 一系列网络或者 Internet 主机名以获取应答数据**
你可能想把自己维护的主机写入一个文本文件,并使用脚本探测它们是否能够 ping 得通 (脚本中的 myhosts 可以随意替换为你想要的名称)。
内置的 read shell 命令将告诉 while 循环一行行的读取 myhosts并将读取的每行内容传给 host 变量,随后 host 变量传递给 ping 命令。
#!/bin/bash
# This script is used to demonstrate the use of a while loop
while read host; do
ping -c 2 $host
done < myhosts
![Script to Ping Servers](http://www.tecmint.com/wp-content/uploads/2014/11/Script-to-Ping-Servers.png)
使用脚本 Ping 服务器
扩展阅读:
- [Learn Shell Scripting: A Guide from Newbies to System Administrator][3]
- [5 Shell Scripts to Learn Shell Programming][4]
### 文件系统排除 ###
尽管 Linux 是一个很稳定的操作系统,但仍然会因为某些原因出现崩溃 (比如以外断电等),正好你有一个 (或者更多个) 文件系统未能正确卸载Linux 重启的时候就会自动检测其中可能发生的错误。
此外,每次系统正常启动的时候,都会在文件系统挂载之前校验它们的完整度。而这些全部都依赖于 fsck 工具 ("文件系统校验")。
如果对 fsck 进行设定它除了校验文件系统的完整性之外还可以尝试修复错误。fsck 能否成功修复错误,取决于文件系统的损伤程度;如果可以修复,被损坏部分的文件会恢复到位于每个文件系统根目录的 lost+found。
最后但同样重要的是,我们必须注意,如果拔掉系统正在写入数据的 USB 设备同样会发生错误,甚至可能发生硬件损坏。
fsck 的基本用如下:
# fsck [options] filesystem
**检查文件系统错误并尝试自动修复**
想要使用 fsck 检查文件系统,我们需要首先卸载文件系统。
# mount | grep sdg1
# umount /mnt
# fsck -y /dev/sdg1
![Scan Linux Filesystem for Errors](http://www.tecmint.com/wp-content/uploads/2014/11/Check-Filesystem-Errors.png)
检查文件系统错误
除了 -y 选项,我们也可以使用 -a 选项来自动修复文件系统错误,而不必做出交互式应答,并在文件系统看起来 "干净" 的情况下强制校验。
# fsck -af /dev/sdg1
如果只是要找出什么地方发生了错误 (不用再检测到错误的时候修复),我们开使用 -n 选项,这样只会讲文集系统错误输出到标准输出设备。
# fsck -n /dev/sdg1
根据 fsck 输出的错误信息,我们可以知道是否可以自己修复或者需要将问题提交给工程师团队来做详细的硬件校验。
### 总结 ###
至此,系列教程的十讲就全部结束了,全系列教程涵盖了通过 LFCS 测试所需的基础内容。
但显而易见的,本系列的十讲并不足以在单个主题方面做到全面描述,我们希望这一系列教程可以成为你学习的基础素材,并一直保持学习的热情。
我们欢迎你提出任何问题或者建议,所以你可以毫不犹豫的通过以下链接联系我们。
--------------------------------------------------------------------------------
via: http://www.tecmint.com/linux-basic-shell-scripting-and-linux-filesystem-troubleshooting/
作者:[Gabriel Cánepa][a]
译者:[GHLandy](https://github.com/GHLandy)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创翻译,[Linux中国](https://linux.cn/) 荣誉推出
[a]:http://www.tecmint.com/author/gacanepa/
[1]:http://www.tecmint.com/sed-command-to-create-edit-and-manipulate-files-in-linux/
[2]:http://www.tecmint.com/vi-editor-usage/
[3]:http://www.tecmint.com/learning-shell-scripting-language-a-guide-from-newbies-to-system-administrator/
[4]:http://www.tecmint.com/basic-shell-programming-part-ii/

View File

@ -1,230 +0,0 @@
Flowsnow translating...
LFCS系列第九讲: 使用Yum RPM Apt Dpkg Aptitude Zypper进行Linux包管理
================================================================================
去年八月, Linux基金会宣布了一个全新的LFCSLinux Foundation Certified SysadminLinux基金会认证系统管理员认证计划这对广大系统管理员来说是一个很好的机会管理员们可以通过绩效考试来表明自己可以成功支持Linux系统的整体运营。 当需要的时候一个Linux基金会认证的系统管理员有足够的专业知识来确保系统高效运行提供第一手的故障诊断和监视并且为工程师团队在问题升级时提供智能决策。
![Linux Package Management](http://www.tecmint.com/wp-content/uploads/2014/11/lfcs-Part-9.png)
Linux基金会认证系统管理员 第九讲
请观看下面关于Linux基金会认证计划的演示。
youtube 视频
<iframe width="720" height="405" frameborder="0" allowfullscreen="allowfullscreen" src="http://www.youtube.com/embed/Y29qZ71Kicg"></iframe>
本文是本系列十套教程中的第九讲今天在这篇文章中我们会引导你学习Linux包管理这也是LFCS认证考试所需要的。
### 包管理 ###
简单的说,包管理是系统中安装和维护软件的一种方法,其中维护也包含更新和卸载。
在Linux早期程序只以源代码的方式发行还带有所需的用户使用手册和必备的配置文件甚至更多。现如今大多数发行商使用默认的预装程序或者被称为包的程序集合。用户使用这些预装程序或者包来安装该发行版本。然而Linux最伟大的一点是我们仍然能够获得程序的源代码用来学习、改进和编译。
**包管理系统是如何工作的**
如果某一个包需要一定的资源,如共享库,或者需要另一个包,据说就会存在依赖性问题。所有现在的包管理系统提供了一些解决依赖性的方法,以确保当安装一个包时,相关的依赖包也安装好了
**打包系统**
几乎所有安装在现代Linux系统上的软件都会在互联网上找到。它要么能够通过中央库中央库能包含几千个包每个包都已经构建、测试并且维护好了发行商得到要么能够直接得到可以下载和手动安装的源代码。
由于不同的发行版使用不同的打包系统Debian的*.deb文件/ CentOS的*.rpm文件/ openSUSE的专门为openSUSE构建的*.rpm文件因此为一个发行版本开发的包会与其他发行版本不兼容。然而大多数发行版本都可能是LFCS认证的三个发行版本之一。
**高级和低级打包工具**
为了有效地进行包管理的任务,你需要知道,你将有两种类型的实用工具:低级工具(能在后端实际安装,升级,卸载包文件),以及高级工具(负责确保能很好的执行依赖性解决和元数据检索的任务,元数据也称为关于数据的数据)。
注:表格
<table cellspacing="0" border="0">
<colgroup width="200">
</colgroup>
<colgroup width="200">
</colgroup>
<colgroup width="200">
</colgroup>
<tbody>
<tr>
<td bgcolor="#AEA79F" align="CENTER" height="18" style="border: 1px solid #000001;"><b><span style="color: black;">发行版</span></b></td>
<td bgcolor="#AEA79F" align="CENTER" style="border: 1px solid #000001;"><b><span style="color: black;">低级工具</span></b></td>
<td bgcolor="#AEA79F" align="CENTER" style="border: 1px solid #000001;"><b><span style="color: black;">高级工具</span></b></td>
</tr>
<tr class="alt">
<td bgcolor="#FFFFFF" align="LEFT" height="18" style="border: 1px solid #000001;"><span style="color: black;">&nbsp;Debian版及其衍生版</span></td>
<td bgcolor="#FFFFFF" align="LEFT" style="border: 1px solid #000001;"><span style="color: black;">&nbsp;dpkg</span></td>
<td bgcolor="#FFFFFF" align="LEFT" style="border: 1px solid #000001;"><span style="color: black;">&nbsp;apt-get / aptitude</span></td>
</tr>
<tr>
<td bgcolor="#FFFFFF" align="LEFT" height="18" style="border: 1px solid #000001;"><span style="color: black;">&nbsp;CentOS版</span></td>
<td bgcolor="#FFFFFF" align="LEFT" style="border: 1px solid #000001;"><span style="color: black;">&nbsp;rpm</span></td>
<td bgcolor="#FFFFFF" align="LEFT" style="border: 1px solid #000001;"><span style="color: black;">&nbsp;yum</span></td>
</tr>
<tr class="alt">
<td bgcolor="#FFFFFF" align="LEFT" height="18" style="border: 1px solid #000001;"><span style="color: black;">&nbsp;openSUSE版</span></td>
<td bgcolor="#FFFFFF" align="LEFT" style="border: 1px solid #000001;"><span style="color: black;">&nbsp;rpm</span></td>
<td bgcolor="#FFFFFF" align="LEFT" style="border: 1px solid #000001;"><span style="color: black;">&nbsp;zypper</span></td>
</tr>
</tbody>
</table>
让我们来看下低级工具和高级工具的描述。
dpkg的是基于Debian系统中的一个低级包管理器。它可以安装删除提供有关资料并建立*.deb包但它不能自动下载并安装它们相应的依赖包。
- 阅读更多: [15个dpkg命令实例][1]
apt-get是Debian和衍生版的高级包管理器并提供命令行方式从多个来源检索和安装软件包其中包括解决依赖性。和dpkg不同的是apt-get不是直接基于.deb文件工作而是基于包的正确名称。
- 阅读更多: [25个apt-get命令实力][2]
Aptitude是基于Debian的系统的另一个高级包管理器它可用于快速简便的执行管理任务安装升级和删除软件包还可以自动处理解决依赖性。与atp-get和额外的包管理器相比它提供了相同的功能例如提供对包的几个版本的访问。
rpm是Linux标准基础LSB兼容发布版使用的一种包管理器用来对包进行低级处理。就像dpkgrpm可以查询安装检验升级和卸载软件包并能被基于Fedora的系统频繁地使用比如RHEL和CentOS。
- 阅读更多: [20个rpm命令实例][3]
相对于基于RPM的系统yum增加了系统自动更新的功能和带依赖性管理的包管理功能。作为一个高级工具和apt-get或者aptitude相似yum基于库工作。
- 阅读更多: [20个yum命令实例][4]
-
### 低级工具的常见用法 ###
你用低级工具处理最常见的任务如下。
**1. 从已编译(*.deb或*.rpm的文件安装一个包**
这种安装方法的缺点是没有提供解决依赖性的方案。当你在发行版本库中无法获得某个包并且又不能通过高级工具下载安装时,你很可能会从一个已编译文件安装该包。因为低级工具不需要解决依赖性问题,所以当安装一个没有解决依赖性的包时会出现出错并且退出。
# dpkg -i file.deb [Debian版和衍生版]
# rpm -i file.rpm [CentOS版 / openSUSE版]
**注意** 不要试图在CentOS中安装一个为openSUSE构建的.rpm文件反之亦然
**2. 从已编译文件中更新一个包**
同样,当中央库中没有某安装包时,你只能手动升级该包。
# dpkg -i file.deb [Debian版和衍生版]
# rpm -U file.rpm [CentOS版 / openSUSE版]
**3. 列举安装的包**
当你第一次接触一个已经在工作中的系统时,很可能你会想知道安装了哪些包。
# dpkg -l [Debian版和衍生版]
# rpm -qa [CentOS版 / openSUSE版]
如果你想知道一个特定的包安装在哪儿, 你可以使用管道命令从以上命令的输出中去搜索,这在这个系列的[操作Linux文件 第一讲][5] 中有介绍。假定我们需要验证mysql-common这个包是否安装在Ubuntu系统中。
# dpkg -l | grep mysql-common
![Check Installed Packages in Linux](http://www.tecmint.com/wp-content/uploads/2014/11/Check-Installed-Package.png)
检查安装的包
另外一种方式来判断一个包是否已安装。
# dpkg --status package_name [Debian版和衍生版]
# rpm -q package_name [CentOS版 / openSUSE版]
例如让我们找出sysdig包是否安装在我们的系统。
# rpm -qa | grep sysdig
![Check sysdig Package](http://www.tecmint.com/wp-content/uploads/2014/11/Check-sysdig-Package.png)
检查sysdig包
**4. 查询一个文件是由那个包安装的**
# dpkg --search file_name
# rpm -qf file_name
例如pw_dict.hwm文件是由那个包安装的
# rpm -qf /usr/share/cracklib/pw_dict.hwm
![Query File in Linux](http://www.tecmint.com/wp-content/uploads/2014/11/Query-File-in-Linux.png)
Linux中查询文件
### 高级工具的常见用法 ###
你用高级工具处理最常见的任务如下。
**1. 搜索包**
aptitude更新将会更新可用的软件包列表并且aptitude搜索会根据包名进行实际性的搜索。
# aptitude update && aptitude search package_name
在搜索所有选项中yum不仅可以通过包名还可以通过包的描述搜索程序包。
# yum search package_name
# yum search all package_name
# yum whatprovides “*/package_name”
假定我们需要一个名为sysdig的包要知道的是我们需要先安装然后才能运行。
# yum whatprovides “*/sysdig”
![Check Package Description in Linux](http://www.tecmint.com/wp-content/uploads/2014/11/Check-Package-Description.png)
检查包描述
whatprovides告诉yum搜索一个含有能够匹配上述正则表达式的文件的包。
# zypper refresh && zypper search package_name [在openSUSE上]
**2. 从仓库安装一个包**
当安装一个包时,在包管理器解决了所有依赖性问题后,可能会提醒你确认安装。需要注意的是运行更新或刷新(根据所使用的软件包管理器)不是绝对必要,但是考虑到安全性和依赖性的原因,保持安装的软件包是最新的是一个好的系统管理员的做法。
# aptitude update && aptitude install package_name [Debian版和衍生版]
# yum update && yum install package_name [CentOS版]
# zypper refresh && zypper install package_name [openSUSE版]
**3. 卸载包**
按选项卸载将会卸载软件包,但把配置文件保留完好,然而清除包从系统中完全删去该程序。
# aptitude remove / purge package_name
# yum erase package_name
---注意要卸载的openSUSE包前面的减号 ---
# zypper remove -package_name
在默认情况下,大部分(如果不是全部)的包管理器会提示你,在你实际卸载之前你是否确定要继续卸载。所以,请仔细阅读屏幕上的信息,以避免陷入不必要的麻烦!
**4. 显示包的信息**
下面的命令将会显示birthday这个包的信息。
# aptitude show birthday
# yum info birthday
# zypper info birthday
![Check Package Information in Linux](http://www.tecmint.com/wp-content/uploads/2014/11/Check-Package-Information.png)
检查包信息
### 总结 ###
作为一个系统管理员包管理器是你不能回避的东西。你应该立即准备使用本文中介绍的这些工具。希望你在准备LFCS考试和日常工作中会觉得这些工具好用。欢迎在下面留下您的意见或问题我们将尽可能快的回复你。
--------------------------------------------------------------------------------
via http://www.tecmint.com/linux-package-management/
作者:[Gabriel Cánepa][a]
译者:[Flowsnow](https://github.com/Flowsnow)
校对:[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创翻译,[Linux中国](https://linux.cn/) 荣誉推出
[a]:http://www.tecmint.com/author/gacanepa/
[1]:http://www.tecmint.com/dpkg-command-examples/
[2]:http://www.tecmint.com/useful-basic-commands-of-apt-get-and-apt-cache-for-package-management/
[3]:http://www.tecmint.com/20-practical-examples-of-rpm-commands-in-linux/
[4]:http://www.tecmint.com/20-linux-yum-yellowdog-updater-modified-commands-for-package-mangement/
[5]:http://www.tecmint.com/sed-command-to-create-edit-and-manipulate-files-in-linux/