CentOS搭建基于ZIPKIN的数据追踪系统

1. 配置 Java 环境

安装 JDK

Zipkin 使用 Java8

1
yum install java-1.8.0-openjdk* -y

安装完成后，查看是否安装成功：

1
java -version

2. 安装 Zipkin

新建目录

1
mkdir -p /data/release/zipkin && cd "$_"

下载 Zipkin

1
wget -O zipkin.jar 'https://search.maven.org/remote_content?g=io.zipkin.java&a=zipkin-server&v=LATEST&c=exec'

启动 Zipkin

1
java -jar zipkin.jar

Zipkin 默认监听 9411 端口， 使用浏览器访问 http://yourip:9411 或 http://yourdomain.com:9411 即可看到 Zipkin 自带的图形化界面

3. 配置 MySQL 数据持久化方案

Zipkin 支持的持久化方案很多，如： Cassandra, MySQL, Elasticsearch。本实验使用 MySQL 5.7 作为数据持久化方案。

安装 MySQL 5.7

使用 Ctrl + C 退出上个步骤的 Java 进程并下载 rmp 包

1
wget http://dev.mysql.com/get/mysql57-community-release-el7-9.noarch.rpm

安装 rpm 包

1
rpm -Uvh mysql57-community-release-el7-9.noarch.rpm

安装 MySQL

1
yum install mysql-community-server -y

启动 MySQL 服务

1
systemctl start mysqld.service

设置 MySQL 密码

获取 root 临时密码

1
grep 'temporary password' /var/log/mysqld.log | awk '{print $NF}'

使用上一步的获得的临时密码登入 MySQL

1
mysql -uroot -p

设置 MySQL 账户 root 密码

1
ALTER USER 'root'@'localhost' IDENTIFIED BY 'Xx$Zipkin2017';

退出 MySQL, 回到 Bash shell

1
exit;

初始化 Zipkin 数据库

编写初始化脚本

请在 /data/release/zipkin 目录下创建 zipkin_init.sql，参考下面的内容。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
CREATE TABLE IF NOT EXISTS zipkin_spans (
  `trace_id_high` BIGINT NOT NULL DEFAULT 0 COMMENT 'If non zero, this means the trace uses 128 bit traceIds instead of 64 bit',
  `trace_id` BIGINT NOT NULL,
  `id` BIGINT NOT NULL,
  `name` VARCHAR(255) NOT NULL,
  `parent_id` BIGINT,
  `debug` BIT(1),
  `start_ts` BIGINT COMMENT 'Span.timestamp(): epoch micros used for endTs query and to implement TTL',
  `duration` BIGINT COMMENT 'Span.duration(): micros used for minDuration and maxDuration query'
) ENGINE=InnoDB ROW_FORMAT=COMPRESSED CHARACTER SET=utf8 COLLATE utf8_general_ci;
ALTER TABLE zipkin_spans ADD UNIQUE KEY(`trace_id_high`, `trace_id`, `id`) COMMENT 'ignore insert on duplicate';
ALTER TABLE zipkin_spans ADD INDEX(`trace_id_high`, `trace_id`, `id`) COMMENT 'for joining with zipkin_annotations';
ALTER TABLE zipkin_spans ADD INDEX(`trace_id_high`, `trace_id`) COMMENT 'for getTracesByIds';
ALTER TABLE zipkin_spans ADD INDEX(`name`) COMMENT 'for getTraces and getSpanNames';
ALTER TABLE zipkin_spans ADD INDEX(`start_ts`) COMMENT 'for getTraces ordering and range';
CREATE TABLE IF NOT EXISTS zipkin_annotations (
  `trace_id_high` BIGINT NOT NULL DEFAULT 0 COMMENT 'If non zero, this means the trace uses 128 bit traceIds instead of 64 bit',
  `trace_id` BIGINT NOT NULL COMMENT 'coincides with zipkin_spans.trace_id',
  `span_id` BIGINT NOT NULL COMMENT 'coincides with zipkin_spans.id',
  `a_key` VARCHAR(255) NOT NULL COMMENT 'BinaryAnnotation.key or Annotation.value if type == -1',
  `a_value` BLOB COMMENT 'BinaryAnnotation.value(), which must be smaller than 64KB',
  `a_type` INT NOT NULL COMMENT 'BinaryAnnotation.type() or -1 if Annotation',
  `a_timestamp` BIGINT COMMENT 'Used to implement TTL; Annotation.timestamp or zipkin_spans.timestamp',
  `endpoint_ipv4` INT COMMENT 'Null when Binary/Annotation.endpoint is null',
  `endpoint_ipv6` BINARY(16) COMMENT 'Null when Binary/Annotation.endpoint is null, or no IPv6 address',
  `endpoint_port` SMALLINT COMMENT 'Null when Binary/Annotation.endpoint is null',
  `endpoint_service_name` VARCHAR(255) COMMENT 'Null when Binary/Annotation.endpoint is null'
) ENGINE=InnoDB ROW_FORMAT=COMPRESSED CHARACTER SET=utf8 COLLATE utf8_general_ci;
ALTER TABLE zipkin_annotations ADD UNIQUE KEY(`trace_id_high`, `trace_id`, `span_id`, `a_key`, `a_timestamp`) COMMENT 'Ignore insert on duplicate';
ALTER TABLE zipkin_annotations ADD INDEX(`trace_id_high`, `trace_id`, `span_id`) COMMENT 'for joining with zipkin_spans';
ALTER TABLE zipkin_annotations ADD INDEX(`trace_id_high`, `trace_id`) COMMENT 'for getTraces/ByIds';
ALTER TABLE zipkin_annotations ADD INDEX(`endpoint_service_name`) COMMENT 'for getTraces and getServiceNames';
ALTER TABLE zipkin_annotations ADD INDEX(`a_type`) COMMENT 'for getTraces';
ALTER TABLE zipkin_annotations ADD INDEX(`a_key`) COMMENT 'for getTraces';
ALTER TABLE zipkin_annotations ADD INDEX(`trace_id`, `span_id`, `a_key`) COMMENT 'for dependencies job';
CREATE TABLE IF NOT EXISTS zipkin_dependencies (
  `day` DATE NOT NULL,
  `parent` VARCHAR(255) NOT NULL,
  `child` VARCHAR(255) NOT NULL,
  `call_count` BIGINT
) ENGINE=InnoDB ROW_FORMAT=COMPRESSED CHARACTER SET=utf8 COLLATE utf8_general_ci;
ALTER TABLE zipkin_dependencies ADD UNIQUE KEY(`day`, `parent`, `child`);

登录 Mysql

1
mysql -u root --password='Xx$Zipkin2017'

创建 Zipkin 数据库

1
create database zipkin;

切换数据库

1
use zipkin;

初始化表及索引

1
source /data/release/zipkin/zipkin_init.sql

执行以下命令会看到zipkin_annotations, zipkin_dependencies, zipkin_spans 三张数据表，说明初始化成功了

1
show tables;

退出 MySQL, 回到 Bash shell

1
exit

启动 Zipkin

注： 此处默认使用教程生成的密码

1
2
3
cd /data/release/zipkin
STORAGE_TYPE=mysql MYSQL_HOST=localhost MYSQL_TCP_PORT=3306 MYSQL_DB=zipkin MYSQL_USER=root MYSQL_PASS='Xx$Zipkin2017' \
nohup java -jar zipkin.jar &

4. 创建具有数据上报能力的Demo

搭建 NodeJS 环境

1
2
curl --silent --location https://rpm.nodesource.com/setup_8.x | sudo bash -
yum install nodejs -y

创建Demo目录

创建 /data/release/service_a 目录

1
mkdir -p /data/release/service_a && cd "$_"

使用 NPM 安装相关依赖

请在 /data/release/service_a 目录下创建并编辑 package.json，参考下面的内容。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
{
  "name": "service_a",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {},
  "author": "",
  "license": "ISC",
  "dependencies": {
    "express": "^4.15.3",
    "zipkin": "^0.7.2",
    "zipkin-instrumentation-express": "^0.7.2",
    "zipkin-transport-http": "^0.7.2"
  }
}

安装相关依赖

1
npm install

创建并编辑 app.js

请在 /data/release/service_a 目录下创建 app.js，参考下面的内容。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
const express = require('express');
const {Tracer, ExplicitContext, BatchRecorder} = require('zipkin');
const {HttpLogger} = require('zipkin-transport-http');
const zipkinMiddleware = require('zipkin-instrumentation-express').expressMiddleware;
const ctxImpl = new ExplicitContext();
const recorder = new BatchRecorder({
    logger: new HttpLogger( {
        endpoint: 'http://127.0.0.1:9411/api/v1/spans'
    })
});
const tracer = new Tracer({ctxImpl, recorder});
const app = express();
app.use(zipkinMiddleware({
  tracer,
  serviceName: 'service-a'
}));
app.use('/', (req, res, next) => {
    res.send('hello world');
});
app.listen(3000, () => {
  console.log('service-a listening on port 3000!')
});

启动服务

1
node app.js

该服务监听 3000 端口， 使用浏览器访问 http://yourip:3000 或 http://yourdomain.com:3000 后，看到“hello world” 的文本字样说明服务已经正常工作

5. 部署完成

展开全文 >>

CentOS搭建JavaWeb开发环境

1. 搭建 Java 开发环境

此教程教大家如何配置 JDK 、Tomcat 和 Mysql

安装 JDK

JDK 是开发Java程序必须安装的软件，我们查看一下 yum 源里面的 JDK：

1
yum list java*

选择适合本机的JDK，并安装：

1
yum install java-1.7.0-openjdk* -y

安装完成后，查看是否安装成功：

1
java -version

安装 Tomcat

Tomcat 是一个应用服务器，是开发和调试 jsp 程序的首选，可以利用它来响应 HTML 页面的访问请求。

进入本地文件夹

1
cd /usr/local

到官网找到 Tomcat 的下载链接，并下载到服务器中, 这里提供了一个快速下载 Tomcat 的地址：

1
wget https://mc.qcloudimg.com/static/archive/fa66329388f85c08e8d6c12ceb8b2ca3/apache-tomcat-7.0.77.tar.gz

解压这个文件夹：

1
tar -zxf apache-tomcat-7.0.77.tar.gz

重命名这个文件：

1
mv apache-tomcat-7.0.77 /usr/local/tomcat7

进入 bin 文件夹

1
cd /usr/local/tomcat7/bin

给这个文件夹下的所有 shell 脚本授予权限：

1
chmod 777 *.sh

开启tomcat服务：

1
./startup.sh

安装 MySQL
使用 yum 安装 MySQL：

1
yum install -y mysql-server mysql mysql-devel

安装完成后，启动 MySQL 服务：

1
service mysqld restart

设置 MySQL 账户 root 密码：

1
/usr/bin/mysqladmin -u root password 'NC7eKyAv'

2. 访问 Tomcat

访问 Tomcat

此时，访问 http://yourip:8080 或 http://yourdomain.com 可访问到刚才启动的 Tomcat 的内置示例页面

展开全文 >>

CentOS搭建FireKylin个人博客

1. 运行环境准备

安装 Node.js

使用 yum 命令安装 Node.js

1
yum install nodejs -y

使用 NPM 安装 PM2

通过 NPM 安装进程管理模块 PM2。它是 Node.js 的一个进程管理模块，之后我们会使用它来管理我们的个人网站进程。

1
npm install pm2 -g

安装 MySQL

使用 yum 安装 MySQL：

1
2
3
wget http://dev.mysql.com/get/mysql-community-release-el7-5.noarch.rpm
rpm -ivh mysql-community-release-el7-5.noarch.rpm
yum install mysql-community-server -y

启动 MySQL 服务：

1
service mysqld restart

设置 MySQL 账户 root 密码：

1
/usr/bin/mysqladmin -u root password '4aE5aOii4Firekylin'

安装 Nginx

在 CentOS 上，可直接使用 yum 来安装 Nginx

1
yum install nginx -y

2. 安装并配置 Firekylin

安装 Firekylin

在服务器上下载安装包

1
wget https://firekylin.org/release/latest.tar.gz

解压安装包

1
tar zvxf latest.tar.gz

安装程序依赖

1
2
cd firekylin
npm install

复制项目下的 pm2_default.json 文件生成新文件 pm2.json

1
cp pm2_default.json pm2.json

修改 pm2.json 文件中的 cwd 配置值为项目的当前路径 /root/firekylin：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
{
  "apps": [{
    "name": "firekylin",
    "script": "www/production.js",
    "cwd": "/root/firekylin",
    "exec_mode": "fork",
    "max_memory_restart": "1G",
    "autorestart": true,
    "node_args": [],
    "args": [],
    "env": {
    }
  }]
}

然后通过以下命令启动项目

1
pm2 startOrReload pm2.json

Firekylin 已经启动成功，使用浏览器直接访问 http://yourip:8360/ 或 http://yourdomain.com:8360即可看到 Firekylin 的配置界面。

配置信息

配置过程输入参数如截图所示，其中数据库信息中的帐号字段设置为 root，密码字段设置为 4aE5aOii4Firekylin，数据库名字段设置为 firekylin，主机字段设置为 127.0.0.1，其他字段使用默认值；后台管理帐号中的帐号字段使用默认值 admin，密码字段设置为 4aE5aOii4Admin：

配置完成后可以通过后台管理帐号设置的帐号和密码登录博客管理后台，其值分别为 admin 和 4aE5aOii4Admin，截图如下所示：

配置 Nginx

下面我们就配置 Nginx 使用域名访问我们的网站了。
复制项目下的 nginx_default.conf 为 nginx.conf

1
cp nginx_default.conf nginx.conf

修改 nginx.conf 文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
server {
    listen 80;
    server_name www.yourdomain.com; #将 www.yourdomain.com 替换为之前注册并解析的域名
    root /root/firekylin;
    set $node_port 8360;
    index index.js index.html index.htm;
    location ^~ /.well-known/acme-challenge/ {
      alias /root/firekylin/ssl/challenges/;
      try_files $uri = 404;
    }
    location / {
        proxy_http_version 1.1;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Host $http_host;
        proxy_set_header X-NginX-Proxy true;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_pass http://127.0.0.1:$node_port$request_uri;
        proxy_redirect off;
    }
    location = /development.js {
        deny all;
    }
    location = /testing.js {
        deny all;
    }
    location = /production.js {
        deny all;
    }
}

将 nginx.conf 文件软链到 nginx 配置目录下

1
ln -s /root/firekylin/nginx.conf /etc/nginx/conf.d/firekylin.conf

重启 Nginx

1
service nginx restart

3. 完成

展开全文 >>

CentOS搭建PySpider爬虫服务

1. 环境准备

前置环境部署

在开始部署前，我们需要做一些前置准备 。

yum 更新

1
yum update -y

安装开发编译工具

1
yum install gcc gcc-c++ -y

安装依赖库

1
yum install python-pip python-devel python-distribute libxml2 libxml2-devel python-lxml libxslt libxslt-devel openssl openssl-devel -y

升级pip

1
pip install --upgrade pip

2. 部署 mariadb

由于 CentOS 7 中 MySQL 数据库已从默认的程序列表中移除，我们使用 mariadb 代替。

安装 mariadb

1
yum install mariadb-server mariadb -y

启动 mariadb 服务

1
systemctl start mariadb

设置 root 密码

默认的root用户密码为空，你可以使用以下命令来创建 root 用户的密码（password 后的 uI7AAS5q 可以改为任何你希望设置的密码）：

1
mysqladmin -u root password "uI7AAS5q"

检查是否安装成功

现在你可以尝试通过以下命令来连接到 Mysql 服务器

1
mysql -u root -p

然后输入您刚才设置的密码 （ 默认：uI7AAS5q ），如果一切正常，您应该可以在命令行看到以 MariaDB [(none)]> 或 mysql> 开头的提示了，说明连接成功。

此时输入 SHOW DATABASES; 并回车，应该可以看到类似下面这样的输出，说明一切正常。

1
2
3
4
5
6
7
8
mysql> SHOW DATABASES;
+----------+
| Database |
+----------+
| mysql    |
| test     |
+----------+
2 rows in set (0.13 sec)

完成后，可以通过快捷键 Ctrl+C 或命令行键入 exit 来退出，进入下一步。

3. 部署 redis

下载、解压安装包

下载安装包

1
wget http://download.redis.io/redis-stable.tar.gz

解压安装包

1
tar -xzvf redis-stable.tar.gz

移动解压包到 /usr/local 内

1
mv redis-stable /usr/local/redis

编译安装

1
2
3
cd /usr/local/redis
make
make install

设置 redis 配置

设置配置文件路径

1
2
mkdir -p /etc/redis
cp /usr/local/redis/redis.conf /etc/redis/redis.conf

修改 /etc/redis/redis.conf 文件的 daemonize 配置项为如下：

1
daemonize yes

启动 redis 服务

1
/usr/local/bin/redis-server /etc/redis/redis.conf

4. 部署 pyspider

安装依赖

1
2
3
pip install --upgrade chardet
easy_install mysql-connector==2.1.3
easy_install redis

安装 pyspider

1
pip install pyspider

配置 pyspider

首先创建配置目录

1
mkdir /etc/pyspider

然后 /etc/pyspider 目录下创建 pyspider.conf.json，参考下面的内容。

具体配置的说明文档请参考 官方文档

1
2
3
4
5
6
7
8
9
10
11
{
  "taskdb": "mysql+taskdb://root:uI7AAS5q@127.0.0.1:3306/taskdb",
  "projectdb": "mysql+projectdb://root:uI7AAS5q@127.0.0.1:3306/projectdb",
  "resultdb": "mysql+resultdb://root:uI7AAS5q@127.0.0.1:3306/resultdb",
  "message_queue": "redis://127.0.0.1:6379/db",
  "webui": {
    "username": "root",
    "password": "uI7AAS5q",
    "need-auth": true
  }
}

其中 mysql 配置中的 root 为您 mysql 的用户名， root: 后面的 uI7AAS5q 为您刚设置的密码。

webui 配置中的 username 及 password 为您访问 WebUI 时候需要的用户名，你也可以不设置用户名密码，直接将 need-auth 设为 false 即可。

启动服务

1
pyspider -c /etc/pyspider/pyspider.conf.json

如果一切正常，现在访问 http://yourip:5000 或 http://yourdomain.com:5000，您应该可以看到 pyspider dashboard 的首页了。

服务能够正常启动后，我们需要让它能够在后台运行，您可以通过以下命令让服务在后台运行

1
nohup pyspider -c /etc/pyspider/pyspider.conf.json &

也可以使用官方推荐的 Supervisor 来启动，这里就不详细介绍了，具体用法可以参考 Supervisor 的文档

*5 部署完成

展开全文 >>

CentOS搭建ShowDoc文档工具

1. 准备 Nginx + PHP 环境

安装 Nginx

使用 yum 安装 Nginx：

1
yum install nginx

修改 /etc/nginx/nginx.conf 文件为如下内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
user nginx;
worker_processes auto;
error_log /var/log/nginx/error.log;
pid /run/nginx.pid;
include /usr/share/nginx/modules/*.conf;
events {
    worker_connections 1024;
}
http {
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';
    access_log  /var/log/nginx/access.log  main;
    sendfile            on;
    tcp_nopush          on;
    tcp_nodelay         on;
    keepalive_timeout   65;
    types_hash_max_size 2048;
    include             /etc/nginx/mime.types;
    default_type        application/octet-stream;
    include /etc/nginx/conf.d/*.conf;
    server {
        listen       80;
        server_name  127.0.0.1;
        root         /var/www/html;
        index index.php index.html
        error_page  404              /404.html;
        location = /40x.html {
        }
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
        }
        location ~ .php$ {
            root           /var/www/html;
            fastcgi_pass   127.0.0.1:9000;
            fastcgi_index  index.php;
            fastcgi_param  SCRIPT_FILENAME  $document_root$fastcgi_script_name;
            include        fastcgi_params;
        }
        location ~ /.ht {
            deny  all;
        }
    }
}

启动 Nginx 并设置为开机启动：

1
2
service nginx start
chkconfig nginx on

安装 PHP

使用 yum 安装 php-fpm：

1
yum install php php-gd php-fpm php-mcrypt php-mbstring php-mysql php-pdo

启动 php-fpm 并设置为开机启动：

1
2
service php-fpm start
chkconfig php-fpm on

2. 创建项目

下载安装 Composer

Composer 是 PHP 的一个依赖管理工具，推荐使用 Composer 创建 ShowDoc 项目。

执行如下命令安装 Composer：

1
2
curl -sS https://getcomposer.org/installer | php
mv composer.phar /usr/local/bin/composer

设置 Composer 使用国内镜像

执行命令设置 Composer 使用国内镜像：

1
composer config -g repo.packagist composer https://packagist.phpcomposer.com

使用 Composer 创建项目

执行命令创建项目：

1
cd /var/www/html/ && composer create-project  showdoc/showdoc

设置 showdoc 目录写权限

执行命令赋予 showdoc 下部分目录的写权限

1
2
3
4
5
6
7
8
chmod a+w showdoc/install
chmod a+w showdoc/Sqlite
chmod a+w showdoc/Sqlite/showdoc.db.php
chmod a+w showdoc/Public/Uploads/
chmod a+w showdoc/Application/Runtime
chmod a+w showdoc/server/Application/Runtime
chmod a+w showdoc/Application/Common/Conf/config.php
chmod a+w showdoc/Application/Home/Conf/config.php

创建完毕，您现在可以通过浏览器访问 http://yourip/showdoc/install/ 或 http://yourdomain.com/showdoc/install/ ，进行语言的选择以后即可通过 http://yourip/showdoc 或 http://yourdomain/showdoc 查看站点效果。

展开全文 >>

CentOS搭建LNMP环境

1. 搭建 Nginx 静态服务器

安装 Nginx

使用 yum 安装 Nginx：

1
yum install nginx -y

修改 /etc/nginx/conf.d/default.conf，去除对 IPv6 地址的监听，可参考下面的代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
server {
    listen       80 default_server;
    # listen       [::]:80 default_server;
    server_name  _;
    root         /usr/share/nginx/html;
    # Load configuration files for the default server block.
    include /etc/nginx/default.d/*.conf;
    location / {
    }
    error_page 404 /404.html;
        location = /40x.html {
    }
    error_page 500 502 503 504 /50x.html;
        location = /50x.html {
    }
}

修改完成后，启动 Nginx：

1
nginx

此时，可访问实验机器外网 HTTP 服务（http://yourip 或 http://yourdomain.com）来确认是否已经安装成功。

将 Nginx 设置为开机自动启动：

1
chkconfig nginx on

2. 安装 MySQL 数据库服务

安装 MySQL

使用 yum 安装 MySQL：

1
yum install mysql-server -y

安装完成后，启动 MySQL 服务：

1
service mysqld restart

设置 MySQL 账户 root 密码：

1
/usr/bin/mysqladmin -u root password 'WyIGmACk'

将 MySQL 设置为开机自动启动：

1
chkconfig mysqld on

3. 搭建 PHP 环境

安装 PHP

使用 yum 安装 PHP：

1
yum install php php-fpm php-mysql -y

安装之后，启动 PHP-FPM 进程：

1
service php-fpm start

启动之后，可以使用下面的命令查看 PHP-FPM 进程监听哪个端口

1
netstat -nlpt | grep php-fpm

把 PHP-FPM 也设置成开机自动启动：

1
chkconfig php-fpm on

4. 配置 Nginx 并运行 PHP 程序

配置 Nginx

在 /etc/nginx/conf.d 目录中新建一个名为 php.conf 的文件，并配置 Nginx 端口 ，配置示例如下：

1
2
3
4
5
6
7
8
9
10
11
server {
    listen 8000;
    # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
    location ~ .php$ {
        root           /usr/share/php;
        fastcgi_pass   127.0.0.1:9000;
        fastcgi_index  index.php;
        fastcgi_param  SCRIPT_FILENAME  $document_root$fastcgi_script_name;
        include        fastcgi_params;
    }
}

修改配置完成后，重启 nginx 服务

1
service nginx restart

这时候，我们就可以在/usr/share/php 目录下新建一个 info.php 文件来检查 php 是否安装成功了，文件内容参考如下：

1
<?php phpinfo(); ?>

此时，访问 http://yourip:8000/info.php 或 http://yourdomain.com:8000/info.php 可浏览到我们刚刚创建的 info.php 页面了

展开全文 >>

CentOS搭建LAMP环境

1. 搭建 MySQL 数据库

安装 MySQL

使用 yum 安装 MySQL：

1
yum install mysql-server -y

安装完成后，启动 MySQL 服务：

1
service mysqld restart

设置 MySQL 账户 root 密码：

1
/usr/bin/mysqladmin -u root password 'NGky9EKq'

2. 安装 Apache 服务

安装 Apache

使用 yum 安装 Apache

1
yum install httpd -y

启动 Apache 服务：

1
service httpd start

3. 安装 PHP

安装 PHP 和 PHP-MYSQL 支持工具：

使用 yum 安装 PHP：

1
yum install php php-mysql -y

4. 检查安装是否成功

检验 PHP 是否安装成功

我们在 /var/www/html 目录下创建一个info.php文件来检查php是否安装成功，示例代码参考如下

1
<?php phpinfo(); ?>

此时，访问 http://yourip/info.php 或 http://yourdomain.com/info.php 可浏览到我们刚刚创建的 info.php 页面了

展开全文 >>

基于CentOS搭建Postfix、Dovecot邮件服务

1. 准备域名

  • 域名注册

  • 域名解析

    域名购买完成后, 需要将域名解析到你的服务器IP

    完成该实验共需要添加两条记录：

    • A 记录

      记录类型：A
      主机记录：@
      记录值：yourip

    • MX 记录

      记录类型：MX
      主机记录：@
      记录值：yourdomain.com（替换为自己域名）

  • 生效检查

    域名设置解析后需要过一段时间才会生效，通过 ping 命令检查域名是否生效 ，如：

    1
    ping yourdomain.com

    如果 ping 命令返回的信息中含有你设置的解析的 IP 地址，说明解析成功。（使用 ctrl + c 停止）

    检查 MX 记录

    替换下面命令中的 yourdomain.com 为您自己的注册的域名：

    1
    nslookup -q=mx yourdomain.com

    如果 nslookup 命令返回的信息中含有你设置的域名的记录值，说明解析成功。

2. 实验之前

配置一个功能完善的邮件服务器并不是一项容易的工作，本实验只是搭建了一个简单的邮件服务器，一些更为强大的功能还需要你去探索。

  • Postfix、Dovecot 简介

    Postfix

    Postfix 是一个标准的 MTA「Mail Transfer Agent」服务器，它负责通过 SMTP 协议管理发送到本机的邮件以及由本机发向外界的邮件。

    Dovecot

    Dovecot 是一个优秀的 IMAP/POP 服务器用以接收外界发送到本机的邮件。

  • Postfix、Dovecot 安装

    在 CentOS 7 上，我们可以直接使用 yum 进行下载安装：

    1
    yum -y install postfix dovecot

3. Postfix

  • 配置 Postfix

    有关教程中配置参数的具体含义，请参照 Postfix 配置文档。

    配置

    在终端中输入以下命令以修改 Postfix 相关配置：

    注意：记得将 yourdomain.com 替换为你自己的域名

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    postconf -e 'myhostname = server.yourdomain.com'
    postconf -e 'mydestination = localhost, localhost.localdomain'
    postconf -e 'myorigin = $mydomain'
    postconf -e 'mynetworks = 127.0.0.0/8'
    postconf -e 'inet_interfaces = all'
    postconf -e 'inet_protocols = all'
    postconf -e 'mydestination = $myhostname, localhost.$mydomain, localhost, $mydomain'
    postconf -e 'home_mailbox = Maildir/'
    postconf -e 'smtpd_sasl_type = dovecot'
    postconf -e 'smtpd_sasl_path = private/auth'
    postconf -e 'smtpd_sasl_auth_enable = yes'
    postconf -e 'broken_sasl_auth_clients = yes'
    postconf -e 'smtpd_sasl_authenticated_header = yes'
    postconf -e 'smtpd_recipient_restrictions = permit_mynetworks, permit_sasl_authenticated, reject_unauth_destination'
    postconf -e 'smtpd_use_tls = yes'
    postconf -e 'smtpd_tls_cert_file = /etc/pki/dovecot/certs/dovecot.pem'
    postconf -e 'smtpd_tls_key_file = /etc/pki/dovecot/private/dovecot.pem'

    配置中 Postfix 使用 sasl 和 tls 来完成身份认证和传输信息加密。

    试验中使用了 Dovecot 默认的 ssl 证书和私钥，如果你需要修改为自己的，请替换最后两行配置的路径。

    配置 smtps

    部分邮件客户端依赖于使用 465 端口提供加密连接，所以我们修改配置，允许 Postfix 使用 465 端口发送邮件。

    打开 /etc/postfix/master.cf 文件，将如下两行前的 # 去除：

    1
    2
    smtps inet n - n - - smtpd
    -o smtpd_tls_wrappermode=yes

    （注意： -o 前要保留空格）

    启动

    使用以下命令，将 Postfix 设为自动启动并首次启动该服务：

    1
    2
    systemctl enable postfix.service
    systemctl start  postfix.service

  • Postfix 日志

    Postfix 系统的日志文件在系统的这个目录下的 /var/log/maillog 文件，此文件记录了 Postfix 服务器的运行状态信息。

4. Dovecot

  • 配置 Dovecot

    修改 dovecot.conf

    打开 /etc/dovecot/dovecot.conf 文件，在最下方加入以下配置：

    1
    2
    3
    4
    5
    6
    7
    ssl_cert = </etc/pki/dovecot/certs/dovecot.pem
    ssl_key = </etc/pki/dovecot/private/dovecot.pem
    protocols = imap pop3 lmtp
    listen = *
    mail_location = Maildir:~/Maildir
    disable_plaintext_auth = no

    如果前面你修改为了自己的 ssl 证书和私钥，请替换开始两行配置的路径。

    修改 10-master.conf

    打开 /etc/dovecot/conf.d/10-master.conf 文件，找到 service auth 部分，将以下行前面的 # 去除：

    1
    2
    3
    unix_listener /var/spool/postfix/private/auth {  
           mode = 0666  
    }

  • 启动 Dovecot

    使用以下命令，将 Dovecot 设为自动启动并首次启动该服务：

    1
    2
    systemctl enable dovecot.service
    systemctl start  dovecot.service

    查看 /var/log/maillog 文件，查看服务是否成功启动。

    如成功启动，日志里应包含如下信息：

    1
    2
    3
    Jun 26 12:00:28 localhost postfix/postfix-script[28338]: starting the Postfix mail system
    Jun 26 12:00:29 localhost postfix/master[28340]: daemon started -- version 2.10.1, configuration /etc/postfix
    Jun 26 12:28:40 localhost dovecot: master: Dovecot v2.2.10 starting up for imap, pop3, lmtp (core dumps disabled)

5. 创建账户

该配置下邮箱账户依赖于系统用户，所以通过添加系统用户的方式创建邮箱账户。

添加用户

在终端中使用 useradd 命令添加用户：

1
useradd test

使用 passwd 命令设置对应用户密码：

1
passwd test

6. 测试

如测试中遇到异常，请查看 maillog 日志文件中的错误信息。

服务器端发送测试

使用 su 命令切换用户：

1
su test

我们可以使用 mail 命令发送邮件，将 xxxx@xxx.com 替换为你的其他邮箱。

1
echo "Mail Content" | mail -s "Mail Subject" xxxx@xxx.com

然后可以前往你的接收方邮箱查收。

展开全文 >>

基于CentOS搭建Docker环境

1. 安装与配置 Docker

  • 安装 Docker

    Docker 软件包已经包括在默认的 CentOS-Extras 软件源里。因此想要安装 docker，只需要运行下面的 yum 命令：

    1
    yum install docker-io -y

    直接yum安装，安装成功后查看版本

    1
    docker -v

    启动docker

    1
    service docker start

    设置开机启动

    1
    chkconfig docker on

  • 配置 Docker

    因为国内访问 Docker Hub 较慢, 可以使用腾讯云提供的国内镜像源, 加速访问 Docker Hub

    依次执行以下命令

    1
    2
    3
    echo "OPTIONS='--registry-mirror=https://mirror.ccs.tencentyun.com'" >> /etc/sysconfig/docker
    systemctl daemon-reload
    service docker restart

2. Docker 的简单操作

  • 下载镜像

    下载一个官方的 CentOS 镜像到本地

    1
    docker pull centos

    下载好的镜像就会出现在镜像列表里

    1
    docker images

  • 运行容器

    这时我们可以在刚才下载的 CentOS 镜像生成的容器内操作了。

    生成一个 centos 镜像为模板的容器并使用 bash shell

    1
    docker run -it centos /bin/bash

    这个时候可以看到命令行的前端已经变成了 [root@(一串 hash Id)] 的形式, 这说明我们已经成功进入了 CentOS 容器。

    在容器内执行任意命令, 不会影响到宿主机, 如下

    1
    mkdir -p /data/simple_docker

    可以看到 /data 目录下已经创建成功了 simple_docker 文件夹

    1
    ls /data

    退出容器

    1
    exit

    查看宿主机的 /data 目录, 并没有 simple_docker 文件夹, 说明容器内的操作不会影响到宿主机

    1
    ls /data

  • 保存容器

    查看所有的容器信息， 能获取容器的id

    1
    docker ps -a

    然后执行如下命令，保存镜像：

    1
    docker commit -m="备注" [CONTAINER_ID] [IMAGE]

  • 完成

展开全文 >>

基于CentOS搭建SVN服务器

1. 安装 SVN 服务端

安装 Subversion

Subversion 是一个版本控制系统，相对于的 RCS 、 CVS ，采用了分支管理系统，它的设计目标就是取代 CVS 。

1
yum install -y subversion

2. 创建 SVN 版本库

创建项目版本库

1
2
mkdir -p /data/svn/myproject
svnadmin create /data/svn/myproject

3. 配置 SVN 信息

  • 配置文件简介

    版本库中的配置目录 conf 有三个文件:

    • authz 是权限控制文件
    • passwd 是帐号密码文件
    • svnserve.conf 是SVN服务综合配置文件

  • 配置权限配置文件 authz

    编辑 authz ，内容参考如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    [groups]            
    #用户组
    admin = admin,root,test  
    #用户组所对应的用户
    [/]                 
    #库目录权限
    @admin = rw         
    #用户组权限
    *=r               
    #非用户组权限

  • 配置账号密码文件 passwd

    编辑 passwd ，内容参考如下：

    1
    2
    3
    4
    5
    6
    [users]
    # harry = harryssecret
    # sally = sallyssecret
    admin = 123456
    root = 123456
    test = 123456

  • 配置 SVN 服务综合配置文件 svnserve.conf

    编辑 svnserve.conf ，内容参考如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    [general]
    # force-username-case = none
    # 匿名访问的权限 可以是read、write，none，默认为read
    anon-access = none
    #使授权用户有写权限
    auth-access = write
    #密码数据库的路径
    password-db = passwd
    #访问控制文件
    authz-db = authz
    #认证命名空间，SVN会在认证提示里显示，并且作为凭证缓存的关键字
    realm = /data/svn/myproject
    [sasl]

4. 启动 SVN 服务

  • 启动 SVN

    1
    svnserve -d -r /data/svn

  • checkout SVN项目

    1
    2
    mkdir -p /data/workspace/myproject
    svn co svn://127.0.0.1/myproject /data/workspace/myproject --username root --password 123456 --force --no-auth-cache

  • 提交文件到 SVN 服务器

    从本地提交文件到 SVN 服务器，其中 root 密码为 /data/svn/myproject/conf/passwd 文件存储的密码

    1
    2
    3
    4
    cd /data/workspace/myproject
    echo test >> test.txt
    svn add test.txt
    svn commit test.txt -m 'test'

    提交成功后可以通过如下命令从本地项目删除文件

    1
    2
    cd /data/workspace/myproject
    rm -rf test.txt

    删除后可以通过 SVN 服务器恢复

    1
    2
    cd /data/workspace/myproject
    svn update

5. 完成

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

热爱编程，<br/>崇尚开源，<br/>喜欢折腾，<br/>Linux爱好者，<br/>追求编写极致优雅的代码。