M&M

MySQL常用SQL语句

2024-11-10T03:53:52.000Z

SQL语句大致可以分为四类，DDL(例如: CREATE、DROP、ALTER), DML(例如: INSERT、DELETE、UPDATE), DCL(例如: GRANT、REVOKE), DQL(例如: SELECT)

DDL数据定义语言

`CREATE`

CREATE常用搭配：CREATE DATABASE、CREATE TABLE、CREATE INDEX、CREATE USER，分别是创建数据库、创建表、创建索引、创建用户。

创建数据库：

1
2
3

CREATE DATABASE [IF NOT EXISTS] database_name [CHARACTER SET charset_name] [COLLATE collation_name];
-- 例如
CREATE DATABASE database_name;

创建表：

CREATE TABLE table_name (
    column1 datatype,
    column2 datatype,
    column3 datatype,
   ....
);
-- 例如
CREATE TABLE table_name (
  id int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT '自增ID',
  account varchar(500) DEFAULT NULL COMMENT '用户’,
  PRIMARY KEY (`id`),
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='测试';

创建索引

-- 普通索引
CREATE INDEX index_name ON table_name (column1, column2, …);
-- 例如
CREATE INDEX idx_account_level ON table_name (account, level);
-- 唯一索引
CREATE UNIQUE INDEX index_name ON table_name (column1, column2, …);
-- 例如
CREATE UNIQUE INDEX uk_account_level ON table_name (account, level);

创建用户

1
2
3

CREATE USER [IF NOT EXISTS] account_name IDENTIFIED BY 'password';  
-- 例如
CREATE USER 'username'@'localhost' IDENTIFIED BY 'password';

`DROP`

DROP常用搭配：DROP DATABASE、DROP TABLE、DROP INDEX、DROP USER，分别是删除数据库、删除表、删除索引、删除用户。

删除数据库

1
2
3

DROP DATABASE [IF EXISTS] db_name；
-- 例如
DROP DATABASE database_name；

删除表

1
2
3

DROP TABLE [IF EXISTS] table_name; 
-- 例如
DROP TABLE table_name；

删除索引

1
2
3

DROP INDEX index_name ON table_name;
-- 例如
DROP INDEX idx_account_level ON table_name;

删除用户

1
2
3

DROP USER [IF EXISTS] user [, user] …
-- 例如
DROP USER 'username'@'localhost';

`ALTER`

ALTER常用搭配：ALTER DATABASE、ALTER TABLE、ALTER USER，分别是更改数据库、更改表、更改用户。

更改数据库

ALTER DATABASE [database_name] alter_option …
-- 更改默认数据库字符集
ALTER DATABASE database_name CHARACTER SET=utf8;
-- 更改默认数据库排序规则
ALTER DATABASE database_name COLLATE utf8_general_ci; 
-- 数据库是否只读，1只读，0非只读
ALTER DATABASE database_name READ ONLY = 1;

更改表

ALTER TABLE table_name [alter_option [, alter_option] ...] [partition_options]
-- 修改表存储引擎更改为InnoDB
ALTER TABLE table_name ENGINE=InnoDB;
-- 重置当前的自动增量值
ALTER TABLE table_name AUTO_INCREMENT=13;
-- 更改默认表字符集
ALTER TABLE table_name CHARACTER SET=utf8mb4; 
-- 添加或更改表注释
ALTER TABLE table_name COMMENT='comment';
-- 删除表的列或多列 
ALTER TABLE table_name DROP COLUMN a, DROP COLUMN b; 
-- a列重命名为b，并将其定义更改为BIGINT NOT NULL
ALTER TABLE table_name CHANGE a b BIGINT NOT NULL; 
-- 只更改b列的定义不改列名
ALTER TABLE table_name CHANGE b b INT NOT NULL; 
-- 只更改b列的定义不改列名，MODIFY只需要指定一次列名s
ALTER TABLE table_name MODIFY b INT NOT NULL; 
-- b列后面新增c列
ALTER TABLE table_name ADD c varchar(10) DEFAULT '' COMMENT 'xxxxx' AFTER b; 
-- 指定列字符集
ALTER TABLE table_name MODIFY c VARCHAR(10) CHARACTER SET utf8mb4 DEFAULT '' COMMENT 'xxxxx'

更改用户

ALTER USER [IF EXISTS] user_identity [IDENTIFIED BY 'password'] [password_option | lock_option] [comment]
-- 修改用户密码
ALTER USER username@'%' IDENTIFIED BY '123';
-- 修改用户注释
ALTER USER username@'%' COMMENT "test user"
-- 锁定用户
ALTER USER username@'%' ACCOUNT LOCK;
-- 解锁用户
ALTER USER username@'%' ACCOUNT UNLOCK;

DML数据操作语言

`INSERT`

数据插入

-- 插入一条或多条记录
INSERT INTO table_name (column1, column2, column3, …) VALUES (value1, value2, value3, …), (value1, value2, value3, …);
-- 复制表t1中所有列数据插入t2
INSERT INTO t2 SELECT * FROM t1 WHERE id=1;
-- 复制表t1中部分列数据插入t2
INSERT INTO t2 (column1, column2, column3, …) SELECT column1, column2, column3, … FROM t1 WHERE id=1;

`DELETE`

数据删除

DELETE FROM table_name [WHERE Clause]
-- 删除符合条件的记录
DELETE FROM table_name WHERE id=1;
-- 删除表所有记录
DELETE FROM table_name;

`UPDATE`

数据更新

1
2
3

UPDATE table_name SET column1=value1, column2=value2, … WHERE condition;
-- 例如
UPDATE table_name SET a=1,b='ok' WHERE id=1;

DCL数据控制语句

`GRANT`

授权用户数据库权限或角色

GRANT privilege1, privilege2, privilege3...ON object_type TO user_or_role1, user_or_role2, user_or_role3...[WITH GRANT OPTION]
-- 赋予用户数据库所有表数据增、删、改、查的权限
GRANT select, insert, update, delete ON dbname.* TO username@'%';
-- 赋予用户修改数据库所有表结构创建、删除、修改的权限
GRANT create,alter,drop ON dbname.* TO username@'%';
-- 赋予用户操作索引的权限
GRANT index ON dbname.* TO username@'%';
-- 赋予用户数据库所有权限
GRANT ALL PRIVILEGES ON dbname TO username@'%';
-- 被赋予权限的用户，如果需要分享权限给其它用户，需要加上 WITH GRANT OPTION;
GRANT select, insert, update, delete ON dbname.* TO username@'%' WITH GRANT OPTION;
-- 刷新权限立即生效
FLUSH PRIVILEGES

`REVOKE`

回收用户数据库权限或角色

REVOKE privilege1, privilege2, privilege3...ON object_type FROM user_or_role1, user_or_role2, user_or_role3...[WITH GRANT OPTION]
/* 用法与GRANT类似，之需要将关键字TO换成FROM即可 */
-- 回收用户数据库所有表数据增、删、改、查的权限
REVOKE select, insert, update, delete ON dbname.* FROM username@'%';
-- 刷新权限立即生效
FLUSH PRIVILEGES

DQL数据查询语言

`SELECT`

查询数据

-- 单个表数据查询
SELECT column1, column2, … FROM table_name [WHERE condition] [GROUP BY column_name [ASC | DESC]] [HAVING condition] [ORDER BY column_name [ASC | DESC]] [LIMIT number OFFSET offset];

--- JOIN连接多个表数据关联查询：
/*
INNER JOIN：获取两个表中字段匹配关系的记录,INNER可以省略不写
LEFT JOIN：获取左表所有记录，即使右表没有对应匹配的记录
RIGHT JOIN：获取右表所有记录，即使左表没有对应匹配的记录
*/
SELECT a.column1, b.column2, … FROM table1 a INNER JOIN table2 b ON a.colx = b.coly [WHERE condition];

-- UNION合并多个SELECT查询结果集:
/*
UNION连接两个及以上SELECT结果集并去除重复的记录
每个SELECT语句的列数和对应位置的数据类型必须相同
*/
SELECT column1, column2, … FROM table1 WHERE condition1 UNION [ALL | DISTINCT] SELECT column1, column2, … FROM table2 WHERE condition2 [UNION [ALL | DISTINCT] SELECT ...]

其它

`数据删除`

DELETE、TRUNCATE、DROP删除表数据的区别

DELETE是DML可以回滚，TRUNCATE、DROP是DDL不能回滚
DELETE、TRUNCATE只是删除数据，DROP删除数据和表结构
执行速度DROP>TRUNCATE>DELETE

`SHOW`

-- 列出实例数据库
SHOW DATABASES [like_or_where]
-- 查看建库语句
SHOW CREATE DATABASE dbname
-- 查看数据库表详细信息
SHOW TABLE STATUS [FROM db_name] [like_or_where]
-- 列出数据库表
SHOW [FULL] TABLES [FROM db_name] [like_or_where]
-- 查看建表语句
SHOW CREATE TABLE tablename
-- 查看当前打开的非临时表
SHOW OPEN TABLES [FROM db_name] [like_or_where]
-- 查看实例支持的存储引擎
SHOW ENGINES
-- 查看存储引擎状态
SHOW ENGINE engine_name {STATUS | MUTEX}
-- 例如
SHOW ENGINE INNODB STATUS;
-- 查看用户权限
SHOW GRANTS FOR user
-- 例如
SHOW GRANTS FOR username@'%';
-- 查看表索引信息
SHOW INDEX FROM tablename
-- 查看master状态
SHOW MASTER STATUS
-- 查看slave状态
SHOW SLAVE STATUS [FOR CHANNEL channel]
-- 查看实例所有插件信息
SHOW PLUGINS
-- 查看权限表
SHOW PRIVILEGES
-- 查看当前实例活跃线程
SHOW [FULL] PROCESSLIST

GO交叉编译

2024-11-09T03:23:45.000Z

直接编译

如果项目代码或者引用的包没有用到CGO代码，则可以直接指定系统GOOS和平台GOARCH，编译即可。

参数说明

CGO_ENABLED : CGO_ENABLED表示是否使用了CGO，交叉编译如果没有则关闭即可
GOOS: 目标系统平台
- Mac对应darwin
- Linux对应linux
- Windows对应windows
GOARCH: 目标架构平台386、amd64、arm、arm64等,个人电脑一般都是amd64架构
- 386也称x86对应32位操作系统
- amd64也称x64对应64位操作系统
- arm与arm64这种架构一般用于嵌入式开发

1	$ GOOS=linux GOARCH=amd64 go build -mod=vendor -ldflags "-s -w" -o name

CGO代码编译

CGO作为Go语言和C语言之间的桥梁，其使用场景可以分为两种：Go调用C程序和C调用Go程序。

参数说明

GOARM, 只有GOARCH是arm64才有效, 表示arm的版本, 只能是5,6,7其中之一, 默认6
CGO_ENABLED, 是否支持CGO交叉汇编, 值只能是0, 1, 默认情况下是0, 启用交叉汇编比较麻烦
CC, 当支持交叉汇编时(即 CGO_ENABLED=1), 编译目标文件使用的C编译器，例如: arm-linux-gnueabi-gcc
CXX, 当支持交叉汇编时(即 CGO_ENABLED=1), 编译目标文件使用的C++编译器，例如: arm-linux-gnueabi-g++
AR, 当支持交叉汇编时(即 CGO_ENABLED=1), 编译目标文件使用的创建库文件命令

ARM32

交叉编译，目标为ARM32位Linux系统平台，C编译器指定为arm-linux-gnueabi-gcc
当前项目使用了CGO，目标文件使用了C编译器，故需要指定C编译器arm-linux-gnueabi-gcc
ARM32位编译器下载地址，下载解压后，将对应bin目录添加到环境变量即可

1	$ GOOS=linux GOARCH=arm CGO_ENABLED=1 CC=arm-linux-gnueabi-gcc go build

ARM64

交叉编译，目标为ARM64位Linux系统平台，C编译器指定为aarch64-linux-gnu-gcc
当前项目使用了CGO，目标文件使用了C编译器，故需要指定C编译器arm-linux-gnueabi-gcc
ARM64位编译器下载地址，下载解压，将对应bin目录添加到环境变量即可

1	$ GOOS=linux GOARCH=arm64 CGO_ENABLED=1 CC=aarch64-linux-gnu-gcc go build

特定编译

如果项目用到了特定的C语言库库，可能是需要对该库单独编译处理的，比如libpcap这个C语言库。

参数说明

CGO_LDFLAGS 链接参数，主要包含要链接库的检索目录和要链接库的名字, 因为历史遗留问题，链接库不支持相对路径，我们必须为链接库指定绝对路径
CGO_CFLAGS 编译参数，主要是头文件的检索路径

1、先编译目标系统架构的libpcap版本，只编译不安装，以arm64为例

$ cd /tmp
$ wget http://www.tcpdump.org/release/libpcap-1.9.0.tar.gz
$ tar -zxvf libpcap-1.9.0.tar.gz
$ cd libpcap-1.9.0
$ export CC=aarch64-linux-gnu-gcc
$ ./configure --host=aarch64-linux --with-pcap=linux
$ make

2、然后再交叉编译中，指定编译好的链接库或头文件位置

1	$ CGO_ENABLED=1 GOOS=linux GOARCH=arm64 CC=aarch64-linux-gnu-gcc CGO_LDFLAGS="-L/tmp/libpcap-1.9.0" CGO_CFLAGS="-I/tmp/libpcap-1.9.0" go build

Vagrant共享目录双向同步等问题

2020-07-29T07:05:08.000Z

vagrant共享目录不能双向同步文件

Vagrant 如果在共享目录的时候无法双向同步，在启动的时日志提示信息，提示系统缺失Virtualbox Guest Additions插件

1	No guest additions were detected on the base box for this VM!

解决方法

安装vagrant-vbguest插件，重新启动虚拟机后会自动在虚拟机里面编译安装Virtualbox Guest Additions插件

1
2
3

$ vagrant plugin install vagrant-vbguest
# 可选
$ vagrant vbguest

关闭默认挂载目录

1	$ config.vm.synced_folder ".","/vagrant",disabled:true

配置共享目录，虚拟机的挂载位置不能使用默认目录/vagrant，这里用/share目录

1	$ config.vm.synced_folder "./code", "/share"

重启虚拟机，完成挂载配置更新

vagrant默认磁盘空间不够

vagrant创建虚拟机，默认磁盘只有8GB，可能不够用

解决方法

安装插件vagrant-disksize，默认由8G变为40G，另外还可以手动配置调整到更大空间

1	$ vagrant plugin install vagrant-disksize

vagrant CPU负载飙高大于100%+

Vagrant + VirtualBox 搭建的开发环境，如果VirtualBox进程CPU负载莫名其妙飙高到100%+，电脑风扇响个不停

解决办法

这个貌似是VirtualBox的BUG，手动在VirtualBox里面关掉虚拟机的声卡(虚拟机->设置->声音->勾掉启用声音选项)，即可

开源一个生成API项目的模板

2019-10-31T12:42:31.000Z

前言

用 Django + Django-REST-framework 开发后端API接口有一段时间了，工作中每开发一个新的微服务，都需要配置同样的项目结构或设置相同的配置项，不仅浪费时间并且有还容易出错。
用cookiecutter可以基于模板生成项目，这样就可以解决这些问题了。
我从日常的项目中抽离了一些最基本的功能做成了一个模板，希望能帮助遇到同样困惑的朋友，如果能提供一个解决问题的思路或方向就是最大的收获了。

地址

项目传送门 Django RestFramework API 项目模板

Iris非对称签名认证

2019-10-21T02:58:58.000Z

API接口有多种认证方式，例如基础认证(用户名/密码)、apikey(秘钥)、token(令牌)、JWT(令牌)、signature(签名)等。非对称签名认证应用广泛，接下来从客户端到服务端简单实现非对称签名，签名算法采用HMAC SHA256。

数字签名

数字签名技术是将摘要信息用发送者的私钥加密，与原文一起传送给接收者。接收者只有用发送者的公钥才能解密被加密的摘要信息，然后用HASH函数对收到的原文产生一个摘要信息，与解密的摘要信息对比。如果相同，则说明收到的信息是完整的，否则说明信息被修改，因此数字签名能保证信息传输过程中完整性、提供信息发送者的身份认证和不可抵赖性。可以用数字签名来做API认证。

签名过程

使用随机函数生成公私钥对，例如

1 2	公钥: "8thcm24furn0likp" 私钥: "PnA4tIBlKBbUV5iVQloLrvBoTbMR03el"

选择合适的摘要签名信息，可以采用当前时间

1	摘要信息: "date: 2019-10-21 10:58:58"

将摘要信息用HMAC SHA256进程签名，并对原始的二进制数据进行Base64编码，得到签名值

1	签名值: "33xn46YabD78N372yw+WV4NvNSTRrRbmAV7mcz0vDUQ="

客户端header组装，x-api-key用来传输公钥，date用来传输摘要信息，authorization用来传输完整的签名信息

1
2
3

'x-api-key': '8thcm24furn0likp',
'date': '2019-10-21 10:58:58',
'authorization': 'Signature keyId="8thcm24furn0likp",algorithm="hmac-sha256",signature="33xn46YabD78N372yw+WV4NvNSTRrRbmAV7mcz0vDUQ="'

签名实现

python可以基于HTTPSignatureAuth来实现

# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from httpsig.requests_auth import HTTPSignatureAuth
import requests
import datetime


class SignatureAuthHttp(object):
    def __init__(self, key='8thcm24furn0likp', secret='PnA4tIBlKBbUV5iVQloLrvBoTbMR03el'):
        self.auth = HTTPSignatureAuth(key=key, secret=secret)
        self.header = {
            'Content-Type': 'application/json',
            'X-Api-Key': key,
            'Date': datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        }

    def httpGet(self, url):
        return requests.get(url, auth=self.auth, header=self.header)

如果是Kong的上游请求需要进行签名认证，可以基于openssl.hmac和ngx模块实现

local BasePlugin = require "kong.plugins.base_plugin"
local req_set_header = ngx.req.set_header
local openssl_hmac = require "openssl.hmac"

local UpstreamAuthSignatureHandler = BasePlugin:extend()

function UpstreamAuthSignatureHandler:new()
  UpstreamAuthSignatureHandler.super.new(self, "upstream-auth-signature")
end

function UpstreamAuthSignatureHandler:access(conf)
  UpstreamAuthSignatureHandler.super.access(self)

  local key = conf.key
  local secret = conf.secret
  local date = os.date("%Y-%m-%d %H:%M:%S", os.time())
  local signature_salt = string.format("date: %s", date)
  local signature = openssl_hmac.new(secret, "sha256"):final(signature_salt)
  local authorization = string.format('Signature keyId="%s",algorithm="hmac-sha256",signature="%s"', key, ngx.encode_base64(signature))

  req_set_header("date", date)
  req_set_header("x-api-key", key)
  req_set_header("authorization", authorization)

end

UpstreamAuthSignatureHandler.PRIORITY = 850

return UpstreamAuthSignatureHandler

验证签名

首先，服务端通过客户端请求传输的header信息，获取摘要信息、签名值、公钥并找到本地对应的私钥，然后使用同样的算法用私钥对摘要信息进行签名，最后通过对比传输的签名值和本地签名值是否一致，来判断认证的有效性。

基于Iris框架的实现

// SignatureAuth 判断签名是否有效
func SignatureAuth(ctx iris.Context) {
  // 通过header获取签名信息
  auth := ctx.GetHeader("Authorization")
  date := ctx.GetHeader("date")
  authKey := ctx.GetHeader("x-api-key")
  if auth == "" || date == "" || authKey == "" {
    ctx.StatusCode(401)
    ctx.JSON(iris.Map{"code": 1, "msg": "error", "data": "invalid authentication"})
    return
  }

  // 设置签名信息失效时间，这里为10s
  loc, _ := time.LoadLocation("PRC")
  t, _ := time.ParseInLocation("2006-01-02 15:04:05", date, loc)
  
  if time.Since(t).Seconds() > 10 {
    ctx.StatusCode(401)
    ctx.JSON(iris.Map{"code": 1, "msg": "error", "data": "invalid authentication"})
    return
  }

  // 获取签名值
  authInfo := strings.Split(auth, ",")
  authSignature := strings.Split(authInfo[2], "\"")[1]

  // 获取本地私钥
  userProfile, err := models.GetAPISecret(authKey)
  if err != nil {
    ctx.StatusCode(401)
    ctx.JSON(iris.Map{"code": 1, "msg": "error", "data": "invalid authentication"})
    return
  }

  // 使用同样的算法用私钥对摘要信息进行签名
  mac := hmac.New(sha256.New, []byte(userProfile.APISecret))
  mac.Write([]byte("date: " + date))
  signature := base64.StdEncoding.EncodeToString(mac.Sum(nil))

  // 对比传输的签名值和本地签名值
  if authSignature == signature {
    ctx.Next()
  } else {
    ctx.StatusCode(401)
    ctx.JSON(iris.Map{"code": 1, "msg": "error", "data": "invalid authentication"})
    return
  }
}

给需要认证的API添加拦截器

func before(ctx iris.Context) {
  SignatureAuth(ctx)
}

func InitRouter() *iris.Application {
  r := iris.New()
  r.Use(recover.New())

  r.Use(before)

  api := r.Party("/api/xxx")
  {
    ... ...
    api.Get("/xxx", v.xxx)
    ... ...
  }

  return r
}

测试，未通过签名认证认返回信息

{
  "code": 1,
  "data": "invalid authentication",
  "msg": "error"
}

Iris服务端跨域

2019-09-17T01:53:41.000Z

参考文章

Nginx配置跨域请求 Access-Control-Allow-Origin *
Nginx配置跨域访问
 CORS跨域资源共享

CORS

CROS全称是跨域资源共享 (Cross-origin resource sharing)，跨域资源共享(CORS)标准新增了一组 HTTP 首部字段，允许服务器声明哪些源站有权限访问哪些资源。另外，规范要求，对那些可能对服务器数据产生副作用的HTTP请求方法（特别是GET以外的HTTP请求，或者搭配某些MIME类型的POST请求），浏览器必须首先使用OPTIONS方法发起一个预检请求（preflight request），从而获知服务端是否允许该跨域请求。服务器确认允许之后，才发起实际的 HTTP 请求。在预检请求的返回中，服务器端也可以通知客户端，是否需要携带身份凭证（包括 Cookies 和 HTTP 认证相关数据）。

问题和解决方法

服务端默认是不被允许跨域的，当浏览器跨域访问出现403跨域错误的时候No 'Access-Control-Allow-Origin' header is present on the requested resource。两种解决方法，使用Nginx作为反向代理服务器，对响应添加对应的头信息，服务端自身实现，允许跨域。不管哪种方式都是添加响应头信息Access-Control-Allow-Origin *，表示服务端可以接受所有的请求源Origin，即接受所有跨域的请求。

服务端允许跨域

通过nginx作为反向代理服务器，解决跨域问题网上有很多教程，这里就不不累述了。主要描述下怎样在服务端自身实现跨域，这样是比较理想的解决方法，可以通过Iris cors 中间件实现，也可以自己代码实现。

Iris cors 中间件

实例代码可以参考文章 CORS跨域资源共享

代码实现

自定义middleware包新增函数Cors。给所有请求添加头信息Access-Control-Allow-Origin *，如果是OPTIONS方法的预请求，成功响应并添加对应的头信息，状态码响应204或者200。不设置状态码默认响应301，预请求响应失败会造成最后跨域访问失败。

package middleware

import (
  "github.com/kataras/iris"
)

// Cors 实现服务端跨域
func Cors(ctx iris.Context) {
  ctx.Header("Access-Control-Allow-Origin", "*")
  if ctx.Request().Method == "OPTIONS" {
    ctx.Header("Access-Control-Allow-Methods", "GET,POST,PUT,DELETE,PATCH,OPTIONS")
    ctx.Header("Access-Control-Allow-Headers", "Content-Type, Accept, Authorization")
    ctx.StatusCode(204)
    return
  }
  ctx.Next()
}

如果API接口没有实现OPTIONS方法，需要给所有接口设置缺省的OPTIONS方法，不然捕捉不到对应API接口的OPTIONS请求。

package routers

import (
  "github.com/kataras/iris"
  "github.com/kataras/iris/middleware/recover"
  ...
)

// InitRouter 路由初始化
func InitRouter() *iris.Application {
  r := iris.New()
  r.Use(recover.New())

  ...
  
  // common
  common := r.Party("/")
  {
    common.Options("*", func(ctx iris.Context) {
      ctx.Next()
    })
    ...
  }

  ...

  return r
}

然后在所有请求前面添加拦截器，使用自定义的中间件r.Use(cors)。

package routers

import (
  "github.com/kataras/iris"
  "github.com/kataras/iris/middleware/recover"
  "github.com/xiaomastack/hobby/middleware"
  ...
)

func cors(ctx iris.Context) {
  middleware.Cors(ctx)
}

// InitRouter 路由初始化
func InitRouter() *iris.Application {
  r := iris.New()
  r.Use(recover.New())

  // cors
  r.Use(cors)
  ...
  
  // common
  common := r.Party("/")
  {
    common.Options("*", func(ctx iris.Context) {
      ctx.Next()
    })
    ...
  }

  ...

  return r
}

用OPTIONS方法请求任一API接口，可以测试是否生效，如下返回的结果显示已生效。

$ curl -X OPTIONS -vv http://localhost:8080/hs
*   Trying ::1...
* TCP_NODELAY set
* Connected to localhost (::1) port 8080 (#0)
> OPTIONS /hs HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.54.0
> Accept: */*
>
< HTTP/1.1 204 No Content
< Access-Control-Allow-Headers: Content-Type, Accept, Authorization
< Access-Control-Allow-Methods: GET,POST,PUT,DELETE,PATCH,OPTIONS
< Access-Control-Allow-Origin: *
< Date: Tue, 17 Sep 2019 03:03:18 GMT
<
* Connection #0 to host localhost left intact

Kong多认证插件

2019-08-21T13:24:51.000Z

Kong支持 同时启用多个身份认证 (Auth)插件，允许客户端使用不同的身份验证方法来访问指定的服务 (Services)或路由(Routes)。

创建一个消费者

创建消费者

创建消费者 devops

$ curl -X POST --url http://localhost:8001/consumers/ --data "username=devops"
{
  "custom_id":null,
  "created_at":1566380171,
  "username":"devops",
  "id":"a1b6c169-f6e3-482e-a477-2d09d14dce8b"
}

生成key-auth认证秘钥

为消费者 devops生成秘钥凭证，可以指定key值，也可以让插件自动生成key值，建议插件自动生成

$ curl -X POST --url http://localhost:8001/consumers/devops/key-auth/
{
  "key": "OLCgYhkbjfZueFBQ7qe3nOYuWiUdOiiN",
  "created_at": 1566382283,
  "consumer": {
    "id": "a1b6c169-f6e3-482e-a477-2d09d14dce8b"
  },
  "id": "e9dafd25-5e18-4ec1-a41d-b4fc9ea20208"
}

可以通过接口/key-auths查看所有消费者的秘钥，通过/consumers/{consumer}/key-auth接口查看指定消费者的秘钥。

生成JWT凭证

$ curl -X POST http://localhost:8001/consumers/devops/jwt \
> -H "Content-Type: application/x-www-form-urlencoded"
{
  "rsa_public_key": null,
  "created_at": 1566382780,
  "consumer": {
    "id": "a1b6c169-f6e3-482e-a477-2d09d14dce8b"
  },
  "id": "c0296bae-b9bd-4835-b433-95dff237bb4b",
  "algorithm": "HS256",
  "secret": "EGUUr9v99DMGwIk9SpBxvigjzFi5GsBZ",
  "key": "GiweuLOEAwSO9cxkibug7MaBfdJE4NPB"
}

可以通过/jwts接口查看所有消费者的jwt凭证，通过/consumers/{consumer}/jwt接口查看指定消费者的凭证。

启用多个认证插件

插件可以应用于Route，Service，Global，这里以Global为例。并同时启动key-auth和jwt认证插件。

启用key-auth认证插件

$ curl -X POST --url http://localhost:8001/plugins/ --data "name=key-auth"
{
  "created_at": 1566381363,
  "config": {
    "key_names": [
      "apikey"
    ],
    "run_on_preflight": true,
    "anonymous": null,
    "hide_credentials": false,
    "key_in_body": false
  },
  "id": "947db416-1f3a-4a54-a5ff-75b6a55206d7",
  "service": null,
  "enabled": true,
  "run_on": "first",
  "consumer": null,
  "route": null,
  "name": "key-auth"
}

启用jwt认证插件

$ curl -X POST --url http://localhost:8001/plugins/ --data "name=jwt"
{
  "created_at": 1566383438,
  "config": {
    "secret_is_base64": false,
    "key_claim_name": "iss",
    "cookie_names": [],
    "maximum_expiration": 0,
    "claims_to_verify": null,
    "anonymous": null,
    "run_on_preflight": true,
    "uri_param_names": [
      "jwt"
    ]
  },
  "id": "fc54429b-73cd-4215-8f4d-35a21c6a389e",
  "service": null,
  "enabled": true,
  "run_on": "first",
  "consumer": null,
  "route": null,
  "name": "jwt"
}

多重认证-AND

Kong启用多个认证插件后，默认的执行逻辑是 AND。例如启用了两个认证插件key-auth和jwt，那么每次的请求必须提供这两个插件的认证信息，必须通过所有认证插件的认证，才会将下游的请求转发到上游。

使用key-auth 认证方式，请求状态401，返回jwt插件的未认证信息提示{"message":"Unauthorized"}

$ curl -i -X GET --url http://192.168.1.100:8000/api/test/ \
-H "apikey: OLCgYhkbjfZueFBQ7qe3nOYuWiUdOiiN"
HTTP/1.1 401 Unauthorized
... ... ...

{"message":"Unauthorized"}

使用 jwt 认证方式，请求状态401，返回key-auth插件的未认证信息提示{"message":"No API key found in request"}

$ curl -i -X GET --url http://192.168.1.100:8000/api/test/ \
> -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJHaXdldUxPRUF3U085Y3hraWJ1ZzdNYUJmZEpFNE5QQiJ9.UjxuXIu4yI6VyZeoDIfrMLpqggKE4n63o_IQMbygPFA"
HTTP/1.1 401 Unauthorized
... ... ...

{"message":"No API key found in request"}

同时使用key-auth和jwt 认证方式，成功返回请求数据，请求状态200

$ curl -i -X GET --url http://192.168.1.100:8000/api/test/ \
> -H "apikey: OLCgYhkbjfZueFBQ7qe3nOYuWiUdOiiN" \
> -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJHaXdldUxPRUF3U085Y3hraWJ1ZzdNYUJmZEpFNE5QQiJ9.UjxuXIu4yI6VyZeoDIfrMLpqggKE4n63o_IQMbygPFA"
HTTP/1.1 200 OK
... ... ...

多种认证-OR

Kong启用多个认证插件后，默认的执行逻辑是 AND，当认证插件都启用匿名访问后，执行逻辑将会变为 OR。

在不启用匿名访问的时候，auth插件将始终执行身份验证，如果未经过验证，则返回40x响应。当启用匿名访问后auth插件只会在未经过身份验证的情况下执行身份验证，如果身份验证失败，它不会返回40x响应，而是将匿名使用者设置为有效的消费者，那么当调用多个auth插件时，就会导致 OR + 匿名访问的逻辑。如果配合request-termination plugin插件拦截匿名访问的请求，禁止匿名访问，就可以达到多种认证 OR的效果。

创建匿名消费者

$ curl -X POST --url http://localhost:8001/consumers/ \
> --data "username=anonymous"
{
  "custom_id": null,
  "created_at": 1566388995,
  "username": "anonymous",
  "id": "958e85d7-e39d-4d2c-b8a9-888e25dbeed5"
}

启用匿名访问

key-auth插件启用匿名访问，插件id为947db416-1f3a-4a54-a5ff-75b6a55206d7，匿名用户id为958e85d7-e39d-4d2c-b8a9-888e25dbeed5

1 2	$ curl -X PATCH --url http://localhost:8001/plugins/947db416-1f3a-4a54-a5ff-75b6a55206d7/ \ > --data "config.anonymous=958e85d7-e39d-4d2c-b8a9-888e25dbeed5"

jwt插件启用匿名访问，插件id为fc54429b-73cd-4215-8f4d-35a21c6a389e，匿名用户id为958e85d7-e39d-4d2c-b8a9-888e25dbeed5

1 2	$ curl -X PATCH --url http://localhost:8001/plugins/fc54429b-73cd-4215-8f4d-35a21c6a389e/ \ > --data "config.anonymous=958e85d7-e39d-4d2c-b8a9-888e25dbeed5"

启用匿名访问后，请求将不需要认证

1
2
3

$ curl -i -X GET --url http://192.168.1.100:8000/api/test/
HTTP/1.1 200 OK
... ... ...

拦截匿名请求

启用request-termination插件

$ curl -X POST http://localhost:8001/plugins/ \
> --data "name=request-termination" \
> --data "config.status_code=401" \
> --data "config.content_type=application/json; charset=utf-8" \
> --data "config.body={\"message\": \"Authentication required\"}"

{
  "created_at": 1566391156,
  "config": {
    "status_code": 401,
    "content_type": "application/json; charset=utf-8",
    "body": "{\"message\": \"Authentication required\"}",
    "message": null
  },
  "id": "e5ff19cf-006d-4fcd-ae00-5837bc5d6938",
  "service": null,
  "enabled": true,
  "run_on": "first",
  "consumer": null,
  "route": null,
  "name": "request-termination"
}

匿名消费者anonymous启用该拦截插件，插件id为e5ff19cf-006d-4fcd-ae00-5837bc5d6938，匿名消费者id为958e85d7-e39d-4d2c-b8a9-888e25dbeed5

1 2	$ curl -X PATCH http://localhost:8001/plugins/e5ff19cf-006d-4fcd-ae00-5837bc5d6938/ \ --data "consumer.id=958e85d7-e39d-4d2c-b8a9-888e25dbeed5"

此时匿名请求已被拦截

$ curl -i -X GET --url http://192.168.1.100:8000/api/test/
HTTP/1.1 401 Unauthorized
... ... ...

{"message": "Authentication required"}

但是只要通过任一种验证，即可成功请求数据

# key-auth
$ curl -i -X GET http://192.168.1.100:8000/api/test/ \
> -H "apikey: OLCgYhkbjfZueFBQ7qe3nOYuWiUdOiiN"
HTTP/1.1 200 OK
... ... ...
# jwt
$ curl -i -X GET http://192.168.1.100:8000/api/test/ \
> -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJHaXdldUxPRUF3U085Y3hraWJ1ZzdNYUJmZEpFNE5QQiJ9.UjxuXIu4yI6VyZeoDIfrMLpqggKE4n63o_IQMbygPFA"
HTTP/1.1 200 OK
... ...

此时的多认证插件(Auth)执行逻辑是 OR

Kong高可用方案

2019-08-16T03:14:29.000Z

前言

只要 kong 的后端数据库做到了高可用，kong 的高可用水到渠成。

架构图

安装Kong

到 Kong官网下载相应的rpm安装包或者获取下载链接。
下载安装包

1	$ wget https://bintray.com/kong/kong-community-edition-rpm/download_file?file_path=centos/6/kong-community-edition-1.0.0.el6.noarch.rpm

安装

1	$ yum install kong-community-edition-1.0.0.el6.noarch.rpm

配置

$ grep -Ev '^#|^$|^ ' kong.conf
plugins = bundled,upstream-auth-signature,upstream-url-penetrate             # kong的可选自定义插件
proxy_listen = 0.0.0.0:6002, 0.0.0.0:6443 ssl             # kong的服务地址
admin_listen = 127.0.0.1:6001, 127.0.0.1:6444 ssl             # kong的后台管理地址
pg_host = 192.168.1.100             # 这里填写PostgreSQL集群Pgpool的VIP地址
pg_port = 9999                  # Pgpool服务端口
pg_user = kong                  # 用户名
pg_password = kong              # 用户密码
pg_database = kong              # 数据库名

用其中某个节点，来初始化数据库

Kong版本高于0.14.1
$ kong migrations bootstrap

Kong版本低于0.15.0
$ kong migrations up [-c /etc/kong/kong.conf]

各个节点启动服务

1	$ kong start [-c /etc/kong/kong.conf]

各个节点配置nginx反向代理

cat kong.conf
server {
    listen 80;
    server_name kong.domain.com;

    location / {
        proxy_connect_timeout 120s;
        proxy_read_timeout 120s;
        proxy_send_timeout 120s;
        proxy_pass http://192.168.1.10:6002;
    }
}

测试服务

1 2	$ curl http://kong.domain.com/ {"message":"no route and no API found with those values"}

Pgpool-II集群的高可用

2019-08-16T03:07:27.000Z

集群准备

role	ip	PostgreSQL	Pgpool-II	port
master	192.168.1.3	10.9	4.0.5	5432
slave	192.168.1.2	10.9	4.0.5	5432
vip	192.168.1.100	–	–	–

其中watchdog端口9000，pcp端口9898，psql服务连接端口9999

查看集群节点状态 show pool_nodes;

$ psql -p 9999 -h 192.168.1.100 -U postgres
Password for user postgres:
psql (10.6, server 10.9)
Type "help" for help.

postgres=# show pool_nodes;
 node_id |   hostname    | port | status | lb_weight |  role   | select_cnt | load_balance_node 
---------+---------------+------+--------+-----------+---------+------------+-------------------
 0       | 192.168.1.3   | 5432 | up     | 0.500000  | primary | 5          | true                             
 1       | 192.168.1.2   | 5432 | up     | 0.500000  | standby | 0          | false                             
(2 rows)

Pgpool服务挂了

vip目前在master端，先测试非vip端pgpool服务不可用，再测试vip端pgpool服务不可用。

非vip端pgpool不可用

停止pgpool服务

1	$ systemctl stop pgpool.service

查看节点状态，服务未中断

$ psql -p 9999 -h 192.168.1.100 -U postgres
Password for user postgres:
psql (10.6, server 10.9)
Type "help" for help.

postgres=# show pool_nodes;
 node_id |   hostname    | port | status | lb_weight |  role   | select_cnt | load_balance_node 
---------+---------------+------+--------+-----------+---------+------------+-------------------
 0       | 192.168.1.3   | 5432 | up     | 0.500000  | primary | 5          | false                             
 1       | 192.168.1.2   | 5432 | up     | 0.500000  | standby | 0          | true                             
(2 rows)

vip端pgpool不可用

停止pgpool服务

1	$ systemctl stop pgpool.service

此时 非vip端的pgpool 会主动接管vip继续对外提供服务

$ ifconfig eth0:0
eth0:0: flags=4163  mtu 1500
        inet 192.168.1.100  netmask 255.255.255.0  broadcast 192.168.1.255
        ether fa:f2:7d:42:75:00  txqueuelen 1000  (Ethernet)

查看节点状态，服务被接管后，继续对外提供服务

$ psql -p 9999 -h 192.168.1.100 -U postgres
Password for user postgres:
psql (10.6, server 10.9)
Type "help" for help.

postgres=# show pool_nodes;
 node_id |   hostname    | port | status | lb_weight |  role   | select_cnt | load_balance_node 
---------+---------------+------+--------+-----------+---------+------------+-------------------
 0       | 192.168.1.3   | 5432 | up     | 0.500000  | primary | 5          | true                             
 1       | 192.168.1.2   | 5432 | up     | 0.500000  | standby | 0          | false                             
(2 rows)

PostgreSQL挂了

standby不可用

停止postgresql服务

1
2
3

$ pg_ctl stop
waiting for server to shut down.... done
server stopped

此时集群节点状态会发生变化，standby节点变为down，此时集群仍然可以继续对外提供服务。

$ psql -p 9999 -h 192.168.1.100 -U postgres
Password for user postgres:
psql (10.6, server 10.9)
Type "help" for help.

postgres=# show pool_nodes;
 node_id |   hostname    | port | status | lb_weight |  role   | select_cnt | load_balance_node 
---------+---------------+------+--------+-----------+---------+------------+-------------------
 0       | 192.168.1.3   | 5432 | up     | 0.500000  | primary | 5          | true                             
 1       | 192.168.1.2   | 5432 | down     | 0.500000  | standby | 0          | false                             
(2 rows)

重新启动 standby 节点，模拟节点修复，重新将该节点加入集群

$ pg_ctl start
... ... ...
done
server started

$ pcp_attach_node -h 192.168.1.100 -p 9898 -U postgres -n 1
Password:
pcp_attach_node -- Command Successful

standby 重新加入集群后，状态变为up，继续对外服务。

$ psql -p 9999 -h 192.168.1.100 -U postgres
Password for user postgres:
psql (10.6, server 10.9)
Type "help" for help.

postgres=# show pool_nodes;
 node_id |   hostname    | port | status | lb_weight |  role   | select_cnt | load_balance_node 
---------+---------------+------+--------+-----------+---------+------------+-------------------
 0       | 192.168.1.3   | 5432 | up     | 0.500000  | primary | 5          | true                             
 1       | 192.168.1.2   | 5432 | up     | 0.500000  | standby | 0          | false                             
(2 rows)

primary不可用

当前 192.168.1.2 是 primary

$ psql -p 9999 -h 192.168.1.100 -U postgres
Password for user postgres:
psql (10.6, server 10.9)
Type "help" for help.

postgres=# show pool_nodes;
 node_id |   hostname    | port | status | lb_weight |  role   | select_cnt | load_balance_node 
---------+---------------+------+--------+-----------+---------+------------+-------------------
 0       | 192.168.1.3   | 5432 | up     | 0.500000  | standby | 5          | true                             
 1       | 192.168.1.2   | 5432 | up     | 0.500000  | primary | 0          | false                             
(2 rows)

停止192.168.1.2 上面的 postgresql服务

1
2
3

$ pg_ctl stop
waiting for server to shut down.... done
server stopped

此时查看节点状态，集群检查到 192.168.1.2 服务不可用后，自动切换 192.168.1.3 为 primary，继续对外提供服务，此时集群可读写。

$ psql -p 9999 -h 192.168.1.100 -U postgres
Password for user postgres:
psql (10.6, server 10.9)
Type "help" for help.

postgres=# show pool_nodes;
 node_id |   hostname    | port | status | lb_weight |  role   | select_cnt | load_balance_node 
---------+---------------+------+--------+-----------+---------+------------+-------------------
 0       | 192.168.1.3   | 5432 | up     | 0.500000  | primary | 5          | true                             
 1       | 192.168.1.2   | 5432 | down   | 0.500000  | standby | 0          | false                             
(2 rows)

postgres=# create database kong;
CREATE DATABASE
postgres=# drop database kong;
DROP DATABASE

修复节点 192.168.1.2 的服务，然后重新加入集群作为 standby 继续对外提供服务。如果主备时间线不同步，需要用 pg_rewind 命令修复时间线，然后再启动服务。

$ mv recovery.done recovery.conf
$ pg_ctl start
$ pcp_attach_node -h 192.168.1.100 -p 9898 -U postgres -n 1
Password:
pcp_attach_node -- Command Successful

节点成功加入集群，其状态为 up

$ psql -p 9999 -h 192.168.1.100 -U postgres
Password for user postgres:
psql (10.6, server 10.9)
Type "help" for help.

postgres=# show pool_nodes;
 node_id |   hostname    | port | status | lb_weight |  role   | select_cnt | load_balance_node 
---------+---------------+------+--------+-----------+---------+------------+-------------------
 0       | 192.168.1.3   | 5432 | up     | 0.500000  | primary | 5          | true                             
 1       | 192.168.1.2   | 5432 | up     | 0.500000  | standby | 0          | false                             
(2 rows)

基于Pgpool-II的PostgreSQL集群

2019-08-16T02:36:57.000Z

安装Pgpool-II

Pgpool-II 是一个位于 PostgreSQL服务器和 PostgreSQL数据库客户端之间的中间件，Pgpool-II提供了连接池（Connection Pooling）、复制（Replication）、负载均衡（Load Balancing）、缓存（In Memory Query Cache）、看门狗（Watchdog）、超出限制链接（Limiting Exceeding Connections）等功能，可以基于这些特性来搭建PostgreSQL高可用集群。

yum安装

官方参考地址
Yum Repository
Installation from RPM

安装CentOS7的yum源。

1	$ yum install http://www.pgpool.net/yum/rpms/4.0/redhat/rhel-7-x86_64/pgpool-II-release-4.0-1.noarch.rpm

安装支持PostgreSQL10版本的pgpool-II

$ yum install pgpool-II-pg10
$ yum install pgpool-II-pg10-debuginfo
$ yum install pgpool-II-pg10-devel
$ yum install pgpool-II-pg10-extensions

服务开机启动

1	$ systemctl enable pgpool.service

启动/停止服务

1 2	$ systemctl start pgpool.service $ systemctl stop pgpool.service

配置Pgpool-II

参考文章

pgpool-II的安装及使用

PGPool-II+PG流复制实现HA主备切换

实例准备

role	ip	PostgreSQL	Pgpool-II	port
master	192.168.1.3	10.9	4.0.5	5432
slave	192.168.1.2	10.9	4.0.5	5432
vip	192.168.1.100	–	–	–

watchdog端口9000，pcp端口9898，psql服务连接端口9999

架构图

配置系统环境

配置程序运行的用户和组为 postgres

# 创建或修改目录权限
$ chown -R postgres.postgres /etc/pgpool-II
$ mkdir /var/run/pgpool/
$ chown postgres.postgres /var/run/pgpool/

# 修改pgpool运行用户和组为postgres
$ vi /usr/lib/systemd/system/pgpool.service

User=postgres
Group=postgres

配置认证方式

配置pool_hba.conf，要么都是trust，要么都是md5验证方式，这里采用了md5验证方式如下设置

# "local" is for Unix domain socket connections only
local   all         all                               md5
# IPv4 local connections:
host    all         all         127.0.0.1/32          md5
host    all         all         ::1/128               md5
host    all         all         0.0.0.0/0             md5

配置pg_hba.conf，认证方式保持一致

# "local" is for Unix domain socket connections only
local   all             all                                     md5
# IPv4 local connections:
host    all             all             127.0.0.1/32            md5
host    all             all             0.0.0.0/0               md5
# IPv6 local connections:
host    all             all             ::1/128                 md5

非必要可选步骤，为了集群可扩展性，可以将复制的认证条件放宽

# Allow replication connections from localhost, by a user with the
# replication privilege.
local   replication     all                                     md5
host    replication     all             127.0.0.1/32            md5
host    replication     all             ::1/128                 md5
host    replication     all         192.168.1.0/24        md5

配置pcp

pcp.conf 配置用于pgpool自己登陆管理使用的，一些操作pgpool的工具会要求提供密码等，配置如下

配置用户名密码

$ pg_md5 postgres
e8a48653851e28c69d0506508fb27fc5

$ vi pcp.conf
# USERID:MD5PASSWD
postgres:e8a48653851e28c69d0506508fb27fc5

添加pg数据库用户密码

在pgpool中添加pg数据库的用户名和密码，数据库登录用户是postgres，这里输入登录密码

$ pg_md5 -p -m -u postgres pool_passwd
password:

# 输入密码后，会生成一个pool_passwd文件
$ cat pool_passwd
postgres:md53175bce1d3201d16594cebf9d7eb3f9d

配置系统命令权限

$ chmod +s /sbin/ifconfig
$ chmod +s /sbin/ip
$ chmod +s /sbin/ifup
$ chmod +s /bin/ping
$ chmod +s /sbin/arping

配置 `pgpool.conf`

`primary`

1	$ cp pgpool.conf.sample-stream pgpool.conf

编辑内容如下

# - pgpool Connection Settings -
listen_addresses = '*'
port = 9999

# - pgpool Communication Manager Connection Settings -
pcp_listen_addresses = '*'
pcp_port = 9898

# - Backend Connection Settings -
backend_hostname0 = '192.168.1.3'
backend_port0 = 5432
backend_weight0 = 1
backend_data_directory0 = '/var/lib/pgsql/10/data'
backend_flag0 = 'ALLOW_TO_FAILOVER'

backend_hostname1 = '192.168.1.2'
backend_port1 = 5432
backend_weight1 = 1
backend_data_directory1 = '/var/lib/pgsql/10/data'
backend_flag1 = 'ALLOW_TO_FAILOVER'

# - Authentication -
enable_pool_hba = on
pool_passwd = 'pool_passwd'
authentication_timeout = 60

# FILE LOCATIONS
pid_file_name = '/var/run/pgpool/pgpool.pid'

# CONNECTION POOLING
connection_cache = on

# REPLICATION MODE
replication_mode = off

# LOAD BALANCING MODE
load_balance_mode = on

# MASTER/SLAVE MODE
master_slave_mode = on
master_slave_sub_mode = 'stream'

# - Streaming -
sr_check_period = 5
sr_check_user = 'repuser'
sr_check_password = 'repuser'
sr_check_database = 'postgres'

# HEALTH CHECK
health_check_period = 10
health_check_timeout = 10
health_check_user = 'postgres'
health_check_password = 'postgres'
health_check_database = 'postgres'

# FAILOVER AND FAILBACK
failover_command = '/var/lib/pgsql/10/failover_stream.sh %H'

# WATCHDOG
use_watchdog = on
wd_hostname = '192.168.1.3'
wd_port = 9000
delegate_IP = '192.168.1.100'
if_cmd_path = '/sbin'
if_up_cmd = 'ifconfig eth0:0 inet $_IP_$ netmask 255.255.255.0'
if_down_cmd = 'ifconfig eth0:0 down'

# -- heartbeat mode --
heartbeat_destination0 = '192.168.1.2'
heartbeat_device0 = 'eth0'

# - Other pgpool Connection Settings -
other_pgpool_hostname0 = '192.168.1.2'
other_pgpool_port0 = 9999
other_wd_port0 = 9000

`standby`

编辑内容如下

# - pgpool Connection Settings -
listen_addresses = '*'
port = 9999

# - pgpool Communication Manager Connection Settings -
pcp_listen_addresses = '*'
pcp_port = 9898

# - Backend Connection Settings -
backend_hostname0 = '192.168.1.3'
backend_port0 = 5432
backend_weight0 = 1
backend_data_directory0 = '/var/lib/pgsql/10/data'
backend_flag0 = 'ALLOW_TO_FAILOVER'

backend_hostname1 = '192.168.1.2'
backend_port1 = 5432
backend_weight1 = 1
backend_data_directory1 = '/var/lib/pgsql/10/data'
backend_flag1 = 'ALLOW_TO_FAILOVER'

# - Authentication -
enable_pool_hba = on
pool_passwd = 'pool_passwd'
authentication_timeout = 60

# FILE LOCATIONS
pid_file_name = '/var/run/pgpool/pgpool.pid'

# CONNECTION POOLING
connection_cache = on

# REPLICATION MODE
replication_mode = off

# LOAD BALANCING MODE
load_balance_mode = on

# MASTER/SLAVE MODE
master_slave_mode = on
master_slave_sub_mode = 'stream'

# - Streaming -
sr_check_period = 5
sr_check_user = 'repuser'
sr_check_password = 'repuser'
sr_check_database = 'postgres'

# HEALTH CHECK
health_check_period = 10
health_check_timeout = 10
health_check_user = 'postgres'
health_check_password = 'postgres'
health_check_database = 'postgres'

# FAILOVER AND FAILBACK
failover_command = '/var/lib/pgsql/10/failover_stream.sh %H'

# WATCHDOG
use_watchdog = on
wd_hostname = '192.168.1.2'
wd_port = 9000
delegate_IP = '192.168.1.100'
if_cmd_path = '/sbin'
if_up_cmd = 'ifconfig eth0:0 inet $_IP_$ netmask 255.255.255.0'
if_down_cmd = 'ifconfig eth0:0 down'

# -- heartbeat mode --
heartbeat_destination0 = '192.168.1.3'
heartbeat_device0 = 'eth0'

# - Other pgpool Connection Settings -
other_pgpool_hostname0 = '192.168.1.3'
other_pgpool_port0 = 9999
other_wd_port0 = 9000

`failover_stream.sh`

配置failover_stream.sh脚本，内容如下：

$ pwd
/var/lib/pgsql/10
$ touch failover_stream.sh
$ chmod u+x failover_stream.sh
$ cat failover_stream.sh
#! /bin/sh
# Failover command for streaming replication.
# Arguments: $1: new master hostname.

new_master=$1
trigger_command="/usr/bin/pg_ctl promote -D /var/lib/pgsql/10/data"

# Prompte standby database.
/usr/bin/ssh -T $new_master $trigger_command

exit 0;

设置主机互信

配置ssh秘钥，分别在master、slave上生成ssh密钥对，并设置主机互信。

$ ssh-keygen -t rsa -b 1024
$ cd ~/.ssh
$ pwd
/var/lib/pgsql/.ssh
$ touch authorized_keys
$ chmod 600 authorized_keys

# 将master公钥id_rsa.pub内容拷贝到salve认证文件authorized_keys，同理将slave公钥id_rsa.pub内容拷贝到master认证文件authorized_keys

# 测试主机互信
# salve
$ ssh postgres@192.168.1.3
# master
$ ssh postgres@192.168.1.2

如果这个脚本的执行目标是本地，并且ssh本地登陆没有设置免秘钥，那么这个脚本会一直卡在输入密码的阶段，这时候主备自动切换过程就阻塞了。如果 pgpool和 postgresql在同一台机器部署，需要添加本地登陆免秘钥。

$ pwd
/var/lib/pgsql
$ cd .ssh/
$ ls
authorized_keys  id_rsa  id_rsa.pub
$ cat id_rsa.pub >> authorized_keys

启动集群

分别启动master、slave的PostgreSQL服务

1	$ systemctl start postgresql-10.service

分别启动各节点Pgpool-II服务

1	$ systemctl start pgpool.service

集群状态

用vip登录集群，查看状态

$ psql -p 9999 -h 192.168.1.100 -U postgres
Password for user postgres:
psql (10.9)
Type "help" for help.

postgres=# show pool_nodes;
 node_id |   hostname    | port | status | lb_weight |  role   | select_cnt | load_balance_node | replication_delay | last_status_change
---------+---------------+------+--------+-----------+---------+------------+-------------------+-------------------+---------------------
 0       | 192.168.1.3   | 5432 | up     | 0.500000  | primary | 5          | true              | 0                 | 2019-08-08 16:11:26
 1       | 192.168.1.2   | 5432 | up     | 0.500000  | standby | 3          | false             | 0                 | 2019-08-08 16:13:14
(2 rows)

至此，基于 Pgpool-II 中间件的 PostgreSQL 集群搭建完成。

`PCP`命令

获取节点数

# 获取192.168.1.3可见节点数
$ pcp_node_count -h 192.168.1.3 -p 9898 -U postgres
Password:
2
# 获取192.168.1.2可见节点数
$ pcp_node_count -h 192.168.1.2 -p 9898 -U postgres
Password:
2

获取节点信息

# 查看节点0信息
$ pcp_node_info -h 192.168.1.3 -p 9898 -U postgres 0
Password:
192.168.1.3 5432 2 0.500000 up primary 0 2019-08-08 16:11:26
# 查看节点1信息
$ pcp_node_info -h 192.168.1.3 -p 9898 -U postgres 1
Password:
192.168.1.2 5432 2 0.500000 up standby 0 2019-08-08 16:13:14
$

从pgpool-II中脱离一个节点
该命令将节点slave从pgpool-II中脱离。一般如果需要维护某个数据库节点、或不希望pgpool-II将连接分发到该节点时，需要将该节点从pgpool-II中用该命令脱离。
1
$ pcp_detach_node -h 192.168.1.100 -p 9898 -U postgres -n 1
为pgpool-II关联一个节点
该命令将节点slave关联到pgpool-II中。当维护结束，或新添加一个节点后，可以将节点添加到pgpool-II。
另外，如果该节点由于主机或数据库故障导致检测到数据库为启动时，即使后期服务器重新修复、数据库手工启动，也需要执行attach操作。同时需要注意从两个节点上观察是否节点都已经attach。
1
$ pcp_attach_node -h 192.168.1.100 -p 9898 -U postgres -n 1

PostgreSQL主备切换

2019-08-16T02:17:37.000Z

前言

PostgreSQL双节点高可用构架中，如果主库宕机或挂了，高可用系统会提升备库为新主库对外继续服务。对于原主库的处理，可以删掉后重搭新备库，也可以降级为备库继续服务。

触发方式

PostgreSQL热备(HOT-Standby)如果主库出现异常，备库如何激活，来替换主库工作，有2种方式可以选择

备库配置文件 recovery.conf 中有配置项 trigger_file ，它是激活从库的触发文件，当它存在就会激活从库。
在备库上执行 pg_ctl promote 命令激活。

文件触发

如果备库配置文件 recovery.conf 配置项 trigger_file 不为空，例如：

1	trigger_file = '/var/lib/pgsql/10/data/trigger_standby'

创建文件/var/lib/pgsql/10/data/trigger_standby，就可以激活备库。

1	$ touch /var/lib/pgsql/10/data/trigger_standby

命令触发

在备库上执行命令 pg_ctl promote 就可以激活备库。

1	$ pg_ctl promote

主备切换

状态标识

数据字典表pg_stat_replication 、命令 pg_controldata、进程、自带的函数 pg_is_in_recovery() 都可以区别或判断实例的主备状态。

主库标识 in production

1 2	$ pg_controldata \| grep 'Database cluster state' Database cluster state: in production

备库标识 in archive recovery

1 2	$ pg_controldata \| grep 'Database cluster state' Database cluster state: in archive recovery

关闭主库

在主库执行 pg_ctl stop 模拟主库宕机。

1
2
3

$ pg_ctl stop
waiting for server to shut down.... done
server stopped

这时备库日志会报错，提示 primary 主库连接不上

$ tailf /var/lib/pgsql/10/data/log/postgresql-Tue.log
TCP/IP connections on port 5432?
2019-08-06 18:00:19.399 CST [21594] FATAL:  could not connect to the primary server: could not connect to server: Connection refused
Is the server running on host "192.168.1.2" and accepting

激活备库

在备库执行 pg_ctl promote 激活备库

1
2
3

$ pg_ctl promote
waiting for server to promote.... done
server promoted

备库激活后可以插入数据，变为可读写。这时配置文件 recovery.conf 变为 recovery.done。

备库被激活，标识变为 in production

1
2
3

$ pg_controldata | grep 'Database cluster state'
Database cluster state:               in production
-bash-4.2$

此时备库已被激活，可以读写

1 2	postgres=# create database test; CREATE DATABASE

重做备库

将宕机原主库修复好后，重新作为新主库的备库

前期准备

编辑新主库认证文件 pg_hba.conf，新增对原主库的认证方式，如果存在可以跳过此步骤。

1 2	host all all 192.168.1.2/32 trust host replication repuser 192.168.1.2/32 md5

pg_ctl reload 使配置生效

1 2	$ pg_ctl reload server signaled

新主库新增归档目录 pg_archive，如果存在可以跳过此步骤。

1	$ mkdir /var/lib/pgsql/10/pg_archive

新备库新增文件认证文件 .pgpass ，如果存在可以跳过此步骤。

$ pwd
/var/lib/pgsql
$ cat .pgpass
192.168.1.3:5432:postgres:repuser:repuser

新备库配置文件需要确认以下参数

hot_standby = on
max_standby_streaming_delay = 30s
wal_receiver_status_interval = 10s
hot_standby_feedback = on

删除再搭建备库

删除原主库数据

1	$ rm -rf /var/lib/pgsql/10/data/*

从新主库拷贝数据

1
2
3

$ pg_basebackup -h 192.168.1.3 -U repuser -D /var/lib/pgsql/10/data/ -X stream -P
Password:
40584/40584 kB (100%), 1/1 tablespace

拷贝配置文件 recovery.conf.sample 或 recovery.done 为 recovery.conf

1	cp /usr/pgsql-10/share/recovery.conf.sample /var/lib/pgsql/10/data/recovery.conf

更新配置文件 recovery.conf

1
2
3

standby_mode = on
primary_conninfo = 'host=192.168.1.3 port=5432 user=repuser password=repuser application_name=standby002'
recovery_target_timeline = 'latest'

启动新备库

1	$ pg_ctl start

直接降级为备库

拷贝配置文件 recovery.conf.sample 或 recovery.done 为 recovery.conf

1	cp /usr/pgsql-10/share/recovery.conf.sample /var/lib/pgsql/10/data/recovery.conf

更新配置文件 recovery.conf

1
2
3

standby_mode = on
primary_conninfo = 'host=192.168.1.3 port=5432 user=repuser password=repuser application_name=standby002'
recovery_target_timeline = 'latest'

同步时间线，由于数据发生了变化，可能造成当前主备的时间线不一致，可以先用 pg_rewind 同步下时间线

$ pg_rewind --target-pgdata=/var/lib/pgsql/10/data --source-server='host=192.168.1.3 port=5432 user=postgres dbname=postgres' -P
connected to server
source and target cluster are on the same timeline
no rewind required

启动新备库

1	$ pg_ctl start

PostgreSQL同步复制

2019-08-06T05:56:41.000Z

同步与异步区别

PostgreSQL流复制默认是异步的。如果主服务器崩溃，那么某些已被提交的事务可能还没有被复制到从服务器，会导致数据丢失。数据的丢失量与故障转移时的复制延迟成比例。

同步复制能够保证一个事务的所有修改都能被传送到同步的从服务器。提高了事务提交标准的持久化级别，这种保护级别被称为2-safe复制。

同步复制时，写事务的每次提交将一直等待，直到该提交在主服务器和从服务器上都已被写入到磁盘上的预写日志中。数据会被丢失的唯一可能性是主服务器和后备服务器在同一时间都崩溃。

一旦流复制已经被配置，配置同步复制就只需要一个额外的配置步骤，将synchronous_standby_names设置为一个非空值。 synchronous_commit也必须被设置为on，但由于这是默认值，通常不需要改变。同步模式比异步模式增加了响应时间，用性能换取了安全。

设置application_name

更新备库配置文件 recovery.conf 中的 primary_conninfo 参数，默认值为 walreceiver ，需要指定该实例的 application_name 。

更新前

1	primary_conninfo = 'host=192.168.1.2 port=5432 user=repuser password=repuser'

主库查询复制状态为

select application_name, client_addr, sync_state from pg_stat_replication;
 application_name |  client_addr  | sync_state
------------------+---------------+------------
 walreceiver      | 192.168.1.3 | async
(1 row)

更新后

1	primary_conninfo = 'host=192.168.1.2 port=5432 user=repuser password=repuser application_name=standby003'

重启从库服务，主库查询复制状态为

select application_name, client_addr, sync_state from pg_stat_replication;
 application_name |  client_addr  | sync_state
------------------+---------------+------------
 standby003       | 192.168.1.3 | async
(1 row)

根据 application_name 参数，可以看出实例名更改已经生效为 standby003

设置synchronous_standby_names

更新主服务器的postgresql.conf文件

1	synchronous_standby_names = 'standby003'

重启主库服务，主库查询复制状态为

select application_name, client_addr, sync_state from pg_stat_replication;
 application_name |  client_addr  | sync_state
------------------+---------------+------------
 standby003       | 192.168.1.3 | sync
(1 row)

根据sync_state参数，可以看出复制模式是同步状态。

synchronous_standby_names

同步复制支持一个或多个同步从服务器，提交的事务会一直等待，直到所有同步从服务器都确认收到了数据为止。该参数支持三种配置方式。

1	[FIRST] num_sync ( standby_name [, ...] )

关键字FIRST加上num_sync，指定基于优先级的同步复制。例如，FIRST 3 (s1, s2, s3, s4) 名称出现在列表前面3个的从服务器被赋予更高的优先级，并将被视为同步复制。在列表后面出现的其它从服务器为潜在的同步从服务器。如果当前的某些同步从服务器断开连接，列表后面的从服务器，优先级将被提高，从而转变为同步从服务器，其中关键字FIRST是可选的。

1	ANY num_sync ( standby_name [, ...] )

关键字ANY加上num_sync，指定基于数量的同步复制，例如，ANY 3 (s1, s2, s3, s4) 每个提交至少被s1、s2、 s3 和s4中的任意三个从服务器同步复制。

1	standby_name [, ...]

与第一个使用FIRST和num_sync等于1的语法相同。例如，FIRST 1 (s1, s2)和s1, s2具有相同的含义：选择s1或s2作为同步服务器。特殊项*匹配任何备用服务器名称。

PostgreSQL流复制热备

2019-08-06T05:48:15.000Z

PostgreSQL在9.0之后引入了主从的流复制机制，从服务器通过tcp流从主服务器中同步相应的数据。流复制允许备库更新，同时也能提供只读服务，流复制默认是异步的。

实例准备

role	ip	port	version
master	192.168.1.2	5432	10.9
slave	192.168.1.3	5432	10.9

架构图

配置主库

创建复制用户

初始化数据库

1
2
3

$ rm -rf /var/lib/pgsql/10/data/*
$ /usr/pgsql-10/bin/postgresql-10-setup initdb
Initializing database ... OK

启动数据库

1	$ systemctl start postgresql-10

创建用户repuser，并赋予复制和登录的权限。

$ su - postgres
$ psql
psql (10.9)
Type "help" for help.

postgres=# CREATE USER repuser REPLICATION LOGIN CONNECTION LIMIT 2 ENCRYPTED PASSWORD 'repuser';
CREATE ROLE
postgres=# \q

更新认证方式

编辑配置文件pg_hba.conf，新增

1 2	host all all 192.168.1.3/32 trust host replication repuser 192.168.1.3/32 md5

更新PostgreSQL配置

编辑配置文件postgresql.conf

listen_addresses = '*'
wal_log_hints = on
archive_mode = on
archive_command = 'cp %p /var/lib/pgsql/10/pg_archive/%f'
wal_keep_segments = 64

新增归档目录 pg_archive

1	$ mkdir /var/lib/pgsql/10/pg_archive

重启主库

1	$ systemctl restart postgresql-10

配置从库

初始化数据库

1
2
3

$ rm -rf /var/lib/pgsql/10/data/*
$ /usr/pgsql-10/bin/postgresql-10-setup initdb
Initializing database ... OK

新增文件`.pgpass`

在postgres用户根目录下创建.pgpass，并追加认证信息

$ touch .pgpass
$ chmod 0600 .pgpass
$ cat .pgpass
192.168.1.2:5432:postgres:repuser:repuser

从主节点拷贝数据到从节点

$ su - postgres
Last login: Mon Aug  5 17:27:20 CST 2019 on pts/0
$ pg_basebackup -h 192.168.1.2 -U repuser -D /var/lib/pgsql/10/data/ -X stream -P
Password:
24308/24308 kB (100%), 1/1 tablespace

配置recovery.conf

拷贝配置文件recovery.conf.sample为recovery.conf

1	$ cp /usr/pgsql-10/share/recovery.conf.sample /var/lib/pgsql/10/data/recovery.conf

更新配置文件recovery.conf

1
2
3

standby_mode = on
primary_conninfo = 'host=192.168.1.2 port=5432 user=repuser password=repuser'
recovery_target_timeline = 'latest'

配置postgresql.conf

listen_addresses = '*'
wal_log_hints = on
wal_keep_segments = 64
hot_standby_feedback = on

重启从库

1	$ systemctl restart postgresql-10

验证

在主节点上命令验证

postgres=# select application_name, client_addr, sync_state from pg_stat_replication;
 application_name |  client_addr  | sync_state
------------------+---------------+------------
 walreceiver      | 192.168.1.3 | async
(1 row)

说明192.168.1.3是从服务器，在接收流，而且是异步流复制。

可以分别在主、从节点上运行 ps -ef | grep postgres来查看进程验证

主服务器有一个 wal sender 进程

1 2	$ ps -ef \| grep postgres postgres 20645 19653 0 22:14 ? 00:00:00 postgres: wal sender process repuser 192.168.1.3(59176) streaming 0/70029E0

从服务器有一个 wal receiver 进程

1 2	$ ps -ef \| grep postgres postgres 18019 18012 0 22:14 ? 00:00:00 postgres: wal receiver process streaming 0/7002A18

CentOS7安装PostgreSQL

2019-08-05T05:49:54.000Z

关于PostgreSQL与MySQL的比较，可以参考 PostgreSQL 与 MySQL 相比，优势何在？

环境

1 2	CentOS Linux release 7.4.1708 (Core) PostgreSQL 10.9

系统设置

修改最大用户进程数

vi /etc/security/limits.conf添加

*          soft     nproc          65535
*          hard     nproc          65535
*          soft     nofile         65535
*          hard     nofile         65535

修改文件句柄数

vi /etc/sysctl.conf添加

1	fs.file-max = 65535

安装

不同系统，不同版本安装都有差异。在官网选择对应的系统环境和安装版本，页面会给出对应的安装指导，官方指导
下面按照官方指导一步一步安装

安装PostgreSQL仓库

1	$ yum install https://download.postgresql.org/pub/repos/yum/reporpms/EL-7-x86_64/pgdg-redhat-repo-latest.noarch.rpm

安装客户端

1	$ yum install postgresql10

安装服务端

1	$ yum install postgresql10-server

加入开机启动项

1	$ systemctl enable postgresql-10.service

初始化数据库

1	$ /usr/pgsql-10/bin/postgresql-10-setup initdb

启动数据库服务

1	$ systemctl start postgresql-10

检查运行状态

$ systemctl status postgresql-10
● postgresql-10.service - PostgreSQL 10 database server
   Loaded: loaded 
 ... ... ...
Aug 02 17:59:44 wytestssssfat02042202 systemd[1]: Started PostgreSQL 10 database server.
Hint: Some lines were ellipsized, use -l to show in full.

设置用户密码

$ su - postgres
Last login: Mon Aug  5 11:09:14 CST 2019 on pts/0
# 默认用户postgres
-bash-4.2$ psql
psql (10.9)
Type "help" for help.

postgres=# \password
# 设置密码为 '******'
Enter new password:
Enter it again:
# 保存退出
postgres=# \q

修改监听地址

编辑配置文件postgresql.conf

1 2	listen_addresses = '*' #listen_addresses = 'localhost'

修改客户端认证方式

编辑配置文件pg_hba.conf

1
2
3

# IPv4 local connections:
host    all             all             127.0.0.1/32            ident
host    all             all             192.168.1.0/24          md5

配置文件pg_hba.conf，配置项说明，可以参考 PostgreSQL 中的客户端认证

TYPE 连接类型，表示允许用哪些方式连接数据库，它允许以下几个值：
- local通过 Unix socket 的方式连接。
- host通过 TCP/IP 的方式连接，它能匹配 SSL 和 non-SSL 连接。
- hostssl只允许 SSL 连接。
- hostnossl只允许 non-SSL 连接。
DATABASE 可连接的数据库，它有以下几个特殊值：
- all 匹配所有数据库。
- sameuser 可连接和用户名相同的数据库。
- samerole 可连接和角色名相同的数据库。
- replication 允许复制连接，用于集群环境下的数据库同步。除了上面这些特殊值之外，我们可以写特定的数据库，可以用逗号 (,) 来分割多个数据库。
USER 可连接数据库的用户，值有三种写法：
- all 匹配所有用户。
- 特定数据库用户名。
- 特定数据库用户组，需要在前面加上 + (如：+admin)。
ADDRESS 可连接数据库的地址，有以下几种形式：
- all 匹配所有 IP 地址。
- samehost 匹配该服务器的 IP 地址。
- samenet 匹配该服务器子网下的 IP 地址。
- ipaddress/netmask (如：172.20.143.89⁄32)，支持 IPv4 与 IPv6。
- 如果上面几种形式都匹配不上，就会被当成是 hostname。注意: 只有 host, hostssl, hostnossl 会应用个字段。
METHOD 连接数据库时的认证方式，常见的有几个特殊值：
- trust 无条件通过认证。
- reject 无条件拒绝认证。
- md5 用 md5 加密密码进行认证。
- password 用明文密码进行认证，不建议在不信任的网络中使用。
- ident 从一个 ident 服务器 (RFC1413) 获得客户端的操作系统用户名并且用它作为被允许的数据库用户名来认证，只能用在 TCP/IP 的类型中 (即 host, hostssl, hostnossl)。
- peer 从内核获得客户端的操作系统用户名并把它用作被允许的数据库用户名来认证，只能用于本地连接 (即 local)。
- 其他特殊值可以在官方文档中查阅。简单来说，ident 和 peer 都要求客户端操作系统中存在对应的用户。注意: 上面列举的只有 md5 和 password 是需要密码的，其他方式都不需要输入密码认证。

重启服务

1	$ systemctl restart postgresql-10

连接测试

psql 是 PostgreSQL 的客户端程序，要连接 PostgreSQL 数据库，我们需要指定以下内容：

-d or --dbname 数据库名
-h or --host 主机名
-p or --port 端口号，默认5432 端口
-U or --username 用户名

$ psql -h 192.168.1.2 -U postgres
Password for user postgres:
psql (10.9)
Type "help" for help.

postgres=# \q

写一个Kong前端URI通配符传递插件

2019-01-19T07:33:18.000Z

场景

如果Kong前端uris配置正则表达式，虽然Kong能够捕获正则表达式的值，但是它不会用该值去替换上游upstream_url里面预设变量，例如：
前端uris配置

1	/api/testmap/(?\d+)

上游upstream_url配置类似这样

1	http://192.168.1.3:10000/api/testmap/{id}

前端发起请求

1
2
3

curl http://10.0.0.111/api/testmap/1/
curl http://10.0.0.111/api/testmap/2/
curl http://10.0.0.111/api/testmap/3/

上游upstream_url的值都是

1	http://192.168.1.3:10000/api/testmap/{id}

解决思路

既然Kong能够捕获正则表达式的值，只需要用Kong捕获的值，对upstream_url进行正则替换即可。

获取

如果，Kong前端uris配置为

1	/api/testmap/(?\d+)

那么，Kong将捕获的值，以table类型存储在变量ngx.ctx.router_matches.uri_captures中。
如果，前端发起的请求为

1	curl http://10.0.0.111/api/testmap/2/

那么ngx.ctx.router_matches.uri_captures变量的值为

1	{"2", id = "2"}

需要注意的是，如果uris里面没有正则表达式，那么变量ngx.ctx.router_matches.uri_captures的值为nil，而不是一个table。

替换

定义upstream_url里面的变量时候，需要有一定的特征。
例如，uris定义为

1	/api/testmap/(?\d+)

那么，upstream_url定义的时候，就将id用特需符号标识，比如用{}来标识这是一个待替换的变量

1	http://192.168.1.3:10000/api/testmap/{id}

做一个table的循环，k是待替换的变量，v是最后替换的值。

for k, v in pairs(uri_captures) do
  if type(k) == "string" then
    local tag_string = string.format("{%s}", k)
    upstream_uri = string.gsub(upstream_uri, tag_string, v)
  end
end

重置

变量替换好后，需要重置upstream_uri的值。有个坑就是，Kong版本大于等于0.11.0后，不支持用ngx.req.set_uri()重置upstream_uri的值，需要用ngx.var.upstream_uri重置upstream_uri。
官方更新日志是这么说的：

The upstream URI is now determined via the Nginx $upstream_uri variable. Custom plugins using the ngx.req.set_uri() API will not be taken into consideration anymore. One must now set the ngx.var.upstream_uri variable from the Lua land.

代码

插件的核心代码handler.lua

local BasePlugin = require "kong.plugins.base_plugin"

local UpstreamUrlPenetrateHandler = BasePlugin:extend()

function UpstreamUrlPenetrateHandler:new()
  UpstreamUrlPenetrateHandler.super.new(self, "upstream-url-penetrate")
end

function UpstreamUrlPenetrateHandler:access()
  UpstreamUrlPenetrateHandler.super.access(self)

  local uri_captures = ngx.ctx.router_matches.uri_captures
  local upstream_uri = ngx.var.upstream_uri

  if type(uri_captures) == "table" then
    for k, v in pairs(uri_captures) do
      if type(k) == "string" then
        local tag_string = string.format("{%s}", k)
        upstream_uri = string.gsub(upstream_uri, tag_string, v)
      end
    end
    ngx.var.upstream_uri = upstream_uri
  end

end

UpstreamUrlPenetrateHandler.PRIORITY = 100

return UpstreamUrlPenetrateHandler

该插件也适用于uris包含多个正则表达式的场景。
插件GitHub开源地址kong-plugin-upstream-url-penetrate

写一个Kong上游转发签名认证插件

2019-01-17T05:39:31.000Z

场景

微服务API接口认证的方式有很多，Kong官网关于上游API认证的插件只有一个Upstream HTTP Basic Authentication，是基于基本的用户名和密码认证的。其它的都是前端认证认证插件。如果后端微服务API采用的是HMAC-SHA256签名认证，就接入不了了，怎么办？首先Google了一番，没有找到此类插件。那么问题来了，如果要用这种认证方式接入Kong，那么就要自己写插件造轮子了。

签名认证过程

API的签名认证用的是Python的httpsig模块，签名算法采用HMAC-SHA256。由于是相对于后端来说，Kong的转发相当于客户端请求，要完成这个插件就需要了解HMAC-SHA256签名的详细认证过程。
通过阅读和调试httpsig模块相关代码，签名的过程是以下这样的:

客户端获取自己的公私钥对

1 2	local key = conf.key local secret = conf.secret

计算加密消息

加密的消息一般采用当前时间date

1	local date = os.date("%Y-%m-%d %H:%M:%S", os.time())

加密

将自己的密钥和加密消息，用HMAC-SHA256算法进行签名。

1 2	local signature_salt = string.format("date: %s", date) local signature = openssl_hmac.new(secret, "sha256"):final(signature_salt)

组装和注入

将date，x-api-key，authorization三个值注入到HTTP头字段HTTP header fields。其中authorization字段格式有一定的要求，必须包含公钥Signature keyId、签名算法algorithm、签名signature，类似这样的字符串

1	'authorization': u'Signature keyId="d1eaffbcb543r357",algorithm="hmac-sha256",signature="pp18H0zla/kvKZP/jAKCTkgqiVO92RRAqTsybZJao/o="'

组装authorization字段，signature的值需要对原始签名的二进制数据进行Base64编码。

1	local authorization = string.format('Signature keyId="%s",algorithm="hmac-sha256",signature="%s"', key, ngx.encode_base64(signature))

用ngx.req.set_header注入相应值。其中的date字段值是签名时用的加密消息，x-api-key是自己的公钥。

1
2
3

req_set_header("date", date)
req_set_header("x-api-key", key)
req_set_header("authorization", authorization)

最后得到的HTTP头字段类似这样

{
  'accept-encoding': 'gzip, deflate', 'accept': '*/*', \
  'user-agent': 'xxxxxx/xxx', 'connection': 'keep-alive', \
  'x-api-key': 'd1eaffbcb543r357', 'date': '2019-01-16 17:22:46',\
  'content-type': 'application/json', \
  'authorization': u'Signature keyId="d1eaffbcb543r357",algorithm="hmac-sha256",signature="pp18H0zla/kvKZP/jAKCTkgqiVO92RRAqTsybZJao/o="'
}

认证

后端微服务拿到公钥、加密消息、签名算法后，先查询公钥对应的私钥，在用一样的签名算法，计算私钥和加密消息，如果得到的结果一样，那么就认证成功，如果不一样那么就认证失败，返回相应错误。

代码

插件的核心代码handler.lua，目前只支持HMAC-SHA256签名认证，自己动手改一改就可以支持其它签名认证了。

local BasePlugin = require "kong.plugins.base_plugin"
local req_set_header = ngx.req.set_header
local openssl_hmac = require "openssl.hmac"

local UpstreamAuthSignatureHandler = BasePlugin:extend()

function UpstreamAuthSignatureHandler:new()
  UpstreamAuthSignatureHandler.super.new(self, "upstream-auth-signature")
end

function UpstreamAuthSignatureHandler:access(conf)
  UpstreamAuthSignatureHandler.super.access(self)

  local key = conf.key
  local secret = conf.secret
  local date = os.date("%Y-%m-%d %H:%M:%S", os.time())
  local signature_salt = string.format("date: %s", date)
  local signature = openssl_hmac.new(secret, "sha256"):final(signature_salt)
  local authorization = string.format('Signature keyId="%s",algorithm="hmac-sha256",signature="%s"', key, ngx.encode_base64(signature))

  req_set_header("date", date)
  req_set_header("x-api-key", key)
  req_set_header("authorization", authorization)

end

UpstreamAuthSignatureHandler.PRIORITY = 850

return UpstreamAuthSignatureHandler

插件GitHub开源地址kong-plugin-upstream-auth-signature

Kong API Gateway 安装

2019-01-14T11:22:25.000Z

安装PostgreSQL

说明

不同系统，不同版本安装都有差异。上官网选择对应的系统环境和安装版本，页面会给出对应的安装指导。
PostgreSQL官网
比如选择版本10，系统CentOS，平台64位。

安装详情

安装PostgreSQL仓库

1	$ yum install https://download.postgresql.org/pub/repos/yum/10/redhat/rhel-6-x86_64/pgdg-centos10-10-2.noarch.rpm

安装客户端

1	$ yum install postgresql10

安装服务端

1	$ yum install postgresql10-server

加入开机启动项

1	$ chkconfig postgresql-10 on

为了登录不报以下错误:

psql: FATAL: Peer authentication failed for user “xxxx”
psql: FATAL: Ident authentication failed for user “xxxx”

需要修改/var/lib/pgsql/10/data/pg_hba.conf配置文件

将以下两行配置peer和ident都修改为trust

修改前

# "local" is for Unix domain socket connections only
local   all             all                                     peer
# IPv4 local connections:
host    all             all             127.0.0.1/32            ident

修改后

# "local" is for Unix domain socket connections only
local   all             all                                     trust
# IPv4 local connections:
host    all             all             127.0.0.1/32            trust

初始化数据库

1	$ service postgresql-10 initdb

启动数据库服务

1	$ service postgresql-10 start

新建数据库kong

新建数据库kong，用户和密码分别为kong和test

$ su - postgres
-bash-4.1$ psql
psql (10.6)
Type "help" for help.

postgres=# create user kong with password 'test';
CREATE ROLE
postgres=# create database kong owner kong;
CREATE DATABASE
postgres=# grant all privileges on database kong to kong;
GRANT
postgres=# \q
-bash-4.1$ exit
$

测试数据库连接性

$ psql --username=kong -h127.0.0.1 --password
用户 kong 的口令：
psql (10.6)
输入 "help" 来获取帮助信息.
kong=> \q

$ psql --username=kong --password
用户 kong 的口令：
psql (10.6)
输入 "help" 来获取帮助信息.

kong=> \q

$ psql --username=kong
psql (10.6)
输入 "help" 来获取帮助信息.

kong=> \q

至此，数据库准备完毕。

安装Kong

到Kong官网下载相应的rpm安装包“Kong下载”，或者获取下载链接。
下载安装包

1	$ wget https://bintray.com/kong/kong-community-edition-rpm/download_file?file_path=centos/6/kong-community-edition-1.0.0.el6.noarch.rpm

安装

1	$ yum install kong-community-edition-1.0.0.el6.noarch.rpm

配置

$ cd /etc/kong/
$ cp kong.conf.default kong.conf

修改admin_listen的ip为0.0.0.0

修改前
#admin_listen = 127.0.0.1:8001, 127.0.0.1:8444 ssl

修改后
admin_listen = 0.0.0.1:8001, 0.0.0.1:8444 ssl

修改kong.conf配置文件，配置数据库连接

pg_host = 127.0.0.1             # The PostgreSQL host to connect to.
pg_port = 5432                  # The port to connect to.
pg_timeout = 5000               # Defines the timeout (in ms), for connecting,
                                 # reading and writing.

pg_user = kong                  # The username to authenticate if required.
pg_password = test              # The password to authenticate if required.
pg_database = kong              # The database name to connect to.

初始化数据库并启动服务

Kong版本高于0.14.1
$ kong migrations bootstrap
$ kong start [-c /etc/kong/kong.conf]

Kong版本低于0.15.0
$ kong migrations up [-c /etc/kong/kong.conf]
$ kong start [-c /etc/kong/kong.conf]

测试服务

1
2
3

$ curl http://localhost:8001/
或者
$ curl http://192.168.1.3:8001/

测试返回一串json格式数据，则安装启动服务成功。
Kong还有可视化的控制面板kong-dashboard，项目地址是kong-dashboard。由于Kong提供了完善的REST API接口，习惯接口操作就不需要安装kong-dashboard了。

用logging + Middleware记录Django API请求日志

2019-01-11T07:48:12.000Z

场景

用Django REST framework来构建Result API，需要记录用户请求的时间、方法、数据、响应状态等。

实现方法

用Python的logging模块结合Django框架的Middleware，来将每次API请求的详细信息记录下来。

settings新增LOGGING配置

定义一个专门记录API日志的logger，命名为api。

# LOGGING settings
LOG_DIR = BASE_DIR + "/log"
LOGGING = {
    'version': 1,
    'disable_existing_loggers': True,
    'formatters': {
        'standard': {
            'format': '%(asctime)s FuncName:%(funcName)s LINE:%(lineno)d [%(levelname)s]- %(message)s'
        },
        'simple': {
            'format': '%(levelname)s %(message)s'
        },
        'verbose': {
            'format': '%(levelname)s %(asctime)s %(module)s %(funcName)s %(message)s'
        },
    },
    'filters': {
        'require_debug_false': {
            '()': 'django.utils.log.RequireDebugFalse'
        }
    },
    'handlers': {
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',
            'formatter': 'standard'
        },
        'default': {
            'level': 'INFO',
            'class': 'logging.handlers.RotatingFileHandler',
            'filename': os.path.join(LOG_DIR, 'info.log'),
            'maxBytes': 1024*1024*50,   # 50 MB
            'backupCount': 2,
            'formatter': 'standard',
        },
        'default_debug': {
            'level': 'DEBUG',
            'class': 'logging.handlers.RotatingFileHandler',
            'filename': os.path.join(LOG_DIR, 'debug.log'),
            'maxBytes': 1024*1024*50,  # 50 MB
            'backupCount': 2,
            'formatter': 'standard',
        },
        'request_handler': {
            'level': 'DEBUG',
            'class': 'logging.handlers.RotatingFileHandler',
            'filename': os.path.join(LOG_DIR, 'common.log'),
            'maxBytes': 1024*1024*50,  # 50 MB
            'backupCount': 2,
            'formatter': 'standard',
        },
        'restful_api': {
            'level': 'DEBUG',
            'class': 'logging.handlers.RotatingFileHandler',
            'filename': os.path.join(LOG_DIR, 'api.log'),
            'maxBytes': 1024*1024*50,  # 50 MB
            'backupCount': 2,
            'formatter': 'verbose',
        },
    },
    'loggers': {
        'django': {
            'handlers': ['console', 'default_debug'],
            'level': 'INFO',
            'propagate': False
        },
        'django.request': {
            'handlers': ['request_handler'],
            'level': 'INFO',
            'propagate': False
        },
        'common': {
            'handlers': ['default', 'console'],
            'level': 'INFO',
            'propagate': True
        },
        'api': {
            'handlers': ['restful_api'],
            'level': 'INFO',
            'propagate': True
        },
    }
}

自定义日志记录中间件ApiLoggingMiddleware

在合适的位置新建文件middleware.py，自定义日志记录中间件ApiLoggingMiddleware。

# -*- coding: utf-8 -*-
from __future__ import unicode_literals

import logging
import json


class ApiLoggingMiddleware(object):
    def __init__(self, get_response):
        self.get_response = get_response
        self.apiLogger = logging.getLogger('api')

    def __call__(self, request):
        try:
            body = json.loads(request.body)
        except Exception:
            body = dict()
        body.update(dict(request.POST))
        response = self.get_response(request)
        if request.method != 'GET':
            self.apiLogger.info("{} {} {} {} {} {}".format(
                request.user, request.method, request.path, body,
                response.status_code, response.reason_phrase))
        return response

在settings中加入中间件ApiLoggingMiddleware

由于中间件对request的处理是顺序执行的，对response处理是逆序执行的，故将ApiLoggingMiddlewar放在MIDDLEWARE_CLASSES的最后面。

MIDDLEWARE_CLASSES = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    'lib.mypath.middleware.ApiLoggingMiddleware',
]

记录效果

INFO 2019-01-11 15:28:50,652 middleware process_response username POST /api/product/ {u'csrfmiddlewaretoken': [u'jAlRDXXXXXXXXzK8UnluvSzaz2yacdDzTwRE005aCVvYnINSG7xvraqi0Pu5QHur'], u'code': [u'test'], u'name': [u'\u53d1\u5e03\u7cfb\u7edf']} 201 Created
INFO 2019-01-11 15:29:10,598 middleware process_response username GET /api/product/9/ {} 200 OK
INFO 2019-01-11 15:29:15,252 middleware process_response username PUT /api/product/9/ {u'code': [u'test'], u'name': [u'\u53d1\u5e03']} 200 OK
INFO 2019-01-11 15:29:27,603 middleware process_response username DELETE /api/product/9/ {} 200 OK
INFO 2019-01-11 15:29:37,961 middleware process_response username GET /api/product/ {} 200 OK

用pyenv管理Python开发环境

2018-12-26T05:31:19.000Z

Python项目开发的时候，不同项目用到的Python版本不一样或用到的依赖包不一样。这时候需要做开发环境隔离，给每个项目一个单独的python开发环境。一般用 pyenv 配合 pyenv-virtualenv 插件使用，可以实现Python多开发环境的隔离。

安装

pyenv

pyenv可以用git克隆安装，也可以下载zip后解压安装。下载zip包解压安装

$ wget https://github.com/pyenv/pyenv/archive/v1.2.7.tar.gz
$ tar xvfz v1.2.7.tar.gz
$ mv pyenv-1.2.7 ~/.pyenv
$ echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.bash_profile
$ echo 'export PATH="$PYENV_ROOT/bin:$PATH"' >>~/.bash_profile
$ echo 'eval "$(pyenv init -)"' >>~/.bash_profile
$ source .bash_profile

pyenv安装完成，用pyenv install --list命令查看提供可安装的python版本

$ pyenv install --list
Available versions:
  2.1.3
  2.2.3
  2.3.7
  2.4
  2.4.1
  ... ...
  2.7.15
  ... ...

Python

安装或更新python所需依赖

1
2
3

$ yum install zlib-devel bzip2-devel openssl-devel ncurses-devel \
  sqlite-devel readline-devel tk-devel gdbm-devel db4-devel \
  libpcap-devel xz-devel patch curl nss

比如安装2.7.15版本的python

1	$ pyenv install 2.7.15 -v

为所有已安装的可执行文件创建shims，如：~/.pyenv/versions/*/bin/*，因此，每当增删了Python版本或带有可执行文件的包(例如celery, uwsgi, pip)以后，都应该执行一次该命令

1	$ pyenv rehash

查看当前已安装python的版本

1
2
3

$ pyenv versions
  system
* 2.7.15 (set by /root/.pyenv/version)

设置系统全局python版本为2.7.15

1	$ pyenv global 2.7.15

优先级

pyenv优先级顺序shell > local > global
global全局Python版本，通过命令pyenv global设置，手动将版本号写入~/.pyenv/version也可以。作用范围是系统。
local本地的Python版本，通过命令pyenv local设置，手动将版本号写入当前目录下的.python-version也可以。作用范围是当前目录，优先级较global高。
shell当前终端的Python版本，通过命令pyenv local设置，手动定义当前终端的PYENV_VERSION环境变量也可以。作用范围是当前终端，优先级比local和global都要高。

pyenv-virtualenv

采用git安装

1 2	$ git clone https://github.com/pyenv/pyenv-virtualenv.git ~/.pyenv/plugins/pyenv-virtualenv $ echo 'eval "$(pyenv virtualenv-init -)"' >> ~/.bash_profile

环境隔离

创建隔离环境命令格式

1	$ pyenv virtualenv Pyhton版本环境名称

例如，创建一个隔离环境devtest，Python版本2.7.15

$ pyenv virtualenv 2.7.15 devtest
New python executable in /root/.pyenv/versions/2.7.15/envs/devtest/bin/python2.7
Also creating executable in /root/.pyenv/versions/2.7.15/envs/devtest/bin/python
Installing setuptools, pip, wheel...done.
Requirement already satisfied: setuptools in /root/.pyenv/versions/2.7.15/envs/devtest/lib/python2.7/site-packages
Requirement already satisfied: pip in /root/.pyenv/versions/2.7.15/envs/devtest/lib/python2.7/site-packages

切换到环境devtest，用pip list可以看到新的环境安装包只有pip、setuptools、wheel。这是一个干净的环境，可以开始一个新的Python项目开发。

$ pyenv activate devtest
pyenv-virtualenv: prompt changing will be removed from future release. configure `export PYENV_VIRTUALENV_DISABLE_PROMPT=1` to simulate the behavior.

(devtest) $ pip list
Package    Version
---------- -------
pip        18.1
setuptools 40.6.3
wheel      0.32.3

退出当前环境

1	$ pyenv deactivate

列出所有的环境

1	$ pyenv virtualenvs

删除环境devtest

1	$ pyenv virtualenv-delete devtest

风水(堪舆)疑惑解答

2018-12-21T11:34:39.000Z

风水是不是迷信

什么是迷信，百度百科是这样解释的

个人认为风水不是迷信而是中华文明传承的一部分，前面专门写过一篇文章简单论证了这个话题风水是迷信,还是你太年轻，其实过度相信科学，不也是一种迷信。

古时候风水这么厉害，为什么没有永垂不朽的帝王或王朝

其实可以反问一句，现在的人都是知识分子都信科学，科学这么厉害，为什么我们不能长生不老，依旧摆脱不了生老病死轮回。风水的核心是气和平衡。为了保持平衡那么它是不会朝极端发展，从而就不会出现永垂不朽的神迹。不管是科学还是大家嗤之以鼻的传统文化，如果它走向极端必将灭亡，平衡才能发展。

风水到底作用多大

风水据个人验证是有作用的，究竟能有多大，能逆天改命还是能巨富石崇比？风水的作用绝对不是这些。一般就是让不好的事情变好；让好的事情变得更好；让失业的人能找到一份工作；让生病的人缓解下痛苦；让家庭变得更和睦；让店铺营业额多点等。退一万步讲，如果相信风水，有很厉害的地师能逆天改命改运，别人也是不会轻易为你做这些，你也不要强求师傅做这些，因为师傅为你们做到了这些，他一定也会失去某些对他很重要的东西。

看风水到底要不要给红包或礼物

这个一定是要给的，作为一种信息的交换，最好有这个交换过程。师傅将布置改造的信息给了福主，那么福主应该用红包或礼物作为交换。金额或礼品分量随意，1块钱也行，师傅开盘了，一定不要他空手而归。

同一个单元楼，户型相同，它们的风水影响一样吗

不一样，有很大的区别，天下没有相同的两片叶子，也没有相同的风水环境。
为什么不一样？因为存在这些可能，造成了它们的不一样。

入住装修的时间不一样可能造成元运不一样；
同一位置不同楼层罗盘量出的方向不一样；
不同的住户他们的装修不一样；
床头朝向，沙发摆放位置，地板颜色不一样；
等等；

风水物品到底有没有用

有用，但是不用这些风水物品同样能达到一样的效果甚至更佳。因为生活可见的物品都可以归于五行之中。
例如：如果调理风水需要放置水，那么用黑色或灰色地毯、鱼缸、饮水机都是可以的。当然买那种流水的风水物品也是有用的，但是没有什么必要。
古人是不大用现代那些眼花缭乱的风水物品的。调理风水如果要风水物品，用平常用到的物品完全可以。最好的风水调理是不见斧凿之痕。
最后提醒一下，网上卖的那些风水物品，貔貅、麒麟是不能乱摆放的，不能放卧室、不靠厕所、不对厨房等，切记不要乱摆放。