Linux

Nginx 日志对于大部分人来说是个未被发掘的宝藏，总结之前做某日志分析系统的经验，和大家分享一下 Nginx 日志的纯手工分析方式。

Nginx 日志相关配置有 2 个地方：access_log 和 log_format 。

默认的格式：

access_log /data/logs/nginx-access.log;
log_format old '$remote_addr [$time_local] $status $request_time $body_bytes_sent '
    '"$request" "$http_referer" "$http_user_agent"';

相信大部分用过 Nginx 的人对默认 Nginx 日志格式配置都很熟悉，对日志的内容也很熟悉。但是默认配置和格式虽然可读，但是难以计算。

Nginx 日志刷盘相关策略可配置：

比如，设置 buffer，buffer 满 32k 才刷盘；假如 buffer 不满 5s 钟强制刷盘的配置如下：

access_log /data/logs/nginx-access.log buffer=32k flush=5s;

这决定了是否实时看到日志以及日志对磁盘 IO 的影响。

Nginx 日志能够记录的变量还有很多没出现在默认配置中：

比如：

• 请求数据大小：$request_length
• 返回数据大小：$bytes_sent
• 请求耗时：$request_time
• 所用连接序号：$connection
• 当前连接发生请求数：$connection_requests

Nginx 的默认格式不可计算，需要想办法转换成可计算格式，比如用控制字符 ^A (Mac 下 ctrl+v ctrl+a 打出)分割每个字段。

log_format 的格式可以变成这样：

log_format new '$remote_addr^A$http_x_forwarded_for^A$host^A$time_local^A$status^A'
    '$request_time^A$request_length^A$bytes_sent^A$http_referer^A$request^A$http_user_agent';

这样之后就通过常见的 Linux 命令行工具进行分析了：

• 查找访问频率最高的 URL 和次数：

  cat access.log | awk -F ‘^A’ ‘{print $10}’ | sort | uniq -c

• 查找当前日志文件 500 错误的访问：

  cat access.log | awk -F ‘^A’ ‘{if($5 == 500) print $0}’

• 查找当前日志文件 500 错误的数量：

  cat access.log | awk -F ‘^A’ ‘{if($5 == 500) print $0}’ | wc -l

• 查找某一分钟内 500 错误访问的数量:

  cat access.log | awk -F ‘^A’ ‘{if($5 == 500) print $0}’ | grep ’09:00’ | wc-l

• 查找耗时超过 1s 的慢请求：

  tail -f access.log | awk -F ‘^A’ ‘{if($6>1) print $0}’

• 假如只想查看某些位：

  tail -f access.log | awk -F ‘^A’ ‘{if($6>1) print $3″|”$4}’

• 查找 502 错误最多的 URL：

  cat access.log | awk -F ‘^A’ ‘{if($5==502) print $11}’ | sort | uniq -c

• 查找 200 空白页

  cat access.log | awk -F ‘^A’ ‘{if($5==200 && $8 < 100) print $3″|”$4″|”$11″|”$6}’

• 查看实时日志数据流

  tail -f access.log | cat -e

  或者

  tail -f access.log | tr ‘^A’ ‘|’

总结

照着这个思路可以做很多其他分析，比如 UA 最多的访问；访问频率最高的 IP；请求耗时分析；请求返回包大小分析；等等。

这就是一个大型 Web 日志分析系统的原型，这样的格式也是非常方便进行后续大规模 batching 和 streaming 计算。

来源：http://blog.eood.cn/nginx_logs

前言

无论是个人的VPS还是企业允许公网访问的服务器，如果开放22端口的SSH密码登录验证方式，被众多黑客暴力猜解捅破菊花也可能是经常发生的惨剧。企业可以通过防火墙来做限制，普通用户也可能借助修改22端口和强化弱口令等方式防护，但目前相对安全和简单的方案则是让SSH使用密钥登录并禁止口令登录。

这是最相对安全的登录管理方式

生成PublicKey

建议设置并牢记passphrase密码短语，以Linux生成为例

Linux：ssh-keygen -t rsa

[私钥 (id_rsa) 与公钥 (id_rsa.pub)]

Windows：SecurCRT/Xshell/PuTTY

[SSH-2 RSA 2048]

#生成SSH密钥对
ssh-keygen -t rsa
Generating public/private rsa key pair.
#建议直接回车使用默认路径
Enter file in which to save the key (/root/.ssh/id_rsa):
#输入密码短语（留空则直接回车）
Enter passphrase (empty for no passphrase):
#重复密码短语
Enter same passphrase again:
Your identification has been saved in /root/.ssh/id_rsa.
Your public key has been saved in /root/.ssh/id_rsa.pub.
The key fingerprint is:
aa:8b:61:13:38:ad:b5:49:ca:51:45:b9:77:e1:97:e1 root@localhost.localdomain
The key's randomart image is:
+--[ RSA 2048]----+
|    .o.          |
|    ..   . .     |
|   .  . . o o    |
| o.  . . o E     |
|o.=   . S .      |
|.*.+   .         |
|o.*   .          |
| . + .           |
|  . o.           |
+-----------------+

复制密钥对

也可以手动在客户端建立目录和authorized_keys，注意修改权限

#复制公钥到无密码登录的服务器上,22端口改变可以使用下面的命令
#ssh-copy-id -i ~/.ssh/id_rsa.pub "-p 10022 user@server"
ssh-copy-id -i ~/.ssh/id_rsa.pub root@192.168.15.241

修改SSH配置文件

#编辑sshd_config文件
vi /etc/ssh/sshd_config
#禁用密码验证
PasswordAuthentication no
#启用密钥验证
RSAAuthentication yes
PubkeyAuthentication yes
#指定公钥数据库文件
AuthorsizedKeysFile .ssh/authorized_keys

重启SSH服务前建议多保留一个会话以防不测

#RHEL/CentOS系统
service sshd restart
#ubuntu系统
service ssh restart
#debian系统
/etc/init.d/ssh restart

手动增加管理用户

可以在== 后加入用户注释标识方便管理

echo 'ssh-rsa XXXX' >>/root/.ssh/authorized_keys
# 复查
cat /root/.ssh/authorized_keys

扩展阅读

• SSH原理与运用 – http://www.ruanyifeng.com/blog/2011/12/ssh_remote_login.html
• 使用公钥验证登录 SSH – https://www.linode.com/docs/networking/ssh/use-public-key-authentication-with-ssh

来源：http://wsgzao.github.io/post/ssh/

MariaDB作为Mysql的一个分支，在开源项目中已经广泛使用，例如大热的openstack，所以，为了保证服务的高可用性，同时提高系统的负载能力，集群部署是必不可少的。

MariaDB Galera Cluster 介绍

MariaDB Galera Cluster 是开源的 MariaDB同步多主机集群。它仅支持XtraDB/ InnoDB存储引擎（虽然有对MyISAM实验支持 – 看wsrep_replicate_myisam系统变量）。

主要功能:

• 同步复制
• 真正的multi-master，即所有节点可以同时读写数据库
• 自动的节点成员控制，失效节点自动被清除
• 新节点加入数据自动复制
• 真正的并行复制，行级
• 用户可以直接连接集群，使用感受上与MySQL完全一致

优势:

• 因为是多主，所以不存在Slavelag(延迟)
• 不存在丢失事务的情况
• 同时具有读和写的扩展能力
• 更小的客户端延迟
• 节点间数据是同步的,而Master/Slave模式是异步的,不同slave上的binlog可能是不同的

技术:

Galera集群的复制功能基于Galeralibrary实现,为了让MySQL与Galera library通讯，特别针对MySQL开发了wsrep API。

Galera插件保证集群同步数据，保持数据的一致性，靠的就是可认证的复制，工作原理如下图： 

当客户端发出一个commit的指令，在事务被提交之前，所有对数据库的更改都会被 write-set 收集起来,并且将write-set 纪录的内容发送给其他节点。

write-set 将在每个节点进行认证测试，测试结果决定着节点是否应用write-set更改数据。

如果认证测试失败，节点将丢弃 write-set ；如果认证测试成功，则事务提交。

1 安装环境准备

安装MariaDB集群至少需要3台服务器（如果只有两台的话需要特殊配置，请参照官方文档）

在这里，我列出试验机器的配置：

操作系统版本：centos7

• node4:10.128.20.16
• node5:10.128.20.17
• node6:10.128.20.18

以第一行为例，node4为 hostname ，10.128.20.16为 ip ，在三台机器修改 /etc/hosts 文件，我的文件如下：

10.128.20.16 node4
10.128.20.17 node5
10.128.20.18 node6

为了保证节点间相互通信，需要禁用防火墙设置（如果需要防火墙，则参照官方网站增加防火墙信息设置）

在三个节点分别执行命令：

systemctl stop firewalld

然后将 /etc/sysconfig/selinux 的 selinux 设置成 disabled ,这样初始化环境就完成了。

2 安装 MariaDB Galera Cluster

[root@node4 ~]# yum install -y mariadb mariadb-galera-server mariadb-galera-common galera rsync

[root@node5 ~]# yum install -y mariadb mariadb-galera-server mariadb-galera-common galera rsync

[root@node6 ~]# yum install -y mariadb mariadb-galera-server mariadb-galera-common galera rsync

3 配置 MariaDB Galera Cluster

初始化数据库服务，只在一个节点进行

[root@node4 mariadb]# systemctl start mariadb
[root@node4 mariadb]# mysql_secure_installation
NOTE: RUNNING ALL PARTS OF THIS SCRIPT IS RECOMMENDED FOR ALL MariaDB
      SERVERS IN PRODUCTION USE!  PLEASE READ EACH STEP CAREFULLY!
In order to log into MariaDB to secure it, we'll need the current
password for the root user.  If you've just installed MariaDB, and
you haven't set the root password yet, the password will be blank,
so you should just press enter here.
Enter current password for root (enter for none):
OK, successfully used password, moving on...
Setting the root password ensures that nobody can log into the MariaDB
root user without the proper authorisation.
Set root password? [Y/n]
New password:
Re-enter new password:
Password updated successfully!
Reloading privilege tables..
 ... Success!
By default, a MariaDB installation has an anonymous user, allowing anyone
to log into MariaDB without having to have a user account created for
them.  This is intended only for testing, and to make the installation
go a bit smoother.  You should remove them before moving into a
production environment.
Remove anonymous users? [Y/n] n
 ... skipping.
Normally, root should only be allowed to connect from 'localhost'.  This
ensures that someone cannot guess at the root password from the network.
Disallow root login remotely? [Y/n] y
 ... Success!
By default, MariaDB comes with a database named 'test' that anyone can
access.  This is also intended only for testing, and should be removed
before moving into a production environment.
Remove test database and access to it? [Y/n] n
 ... skipping.
Reloading the privilege tables will ensure that all changes made so far
will take effect immediately.
Reload privilege tables now? [Y/n] y
 ... Success!
Cleaning up...
All done!  If you've completed all of the above steps, your MariaDB
installation should now be secure.
Thanks for using MariaDB!

关闭数据库，修改 /etc/my.cnf.d/galera.cnf

[root@node4 mariadb]# systemctl stop mariadb

[root@node4 ~]# vim /etc/my.cnf.d/galera.cnf

修改以下内容：

[mysqld]
......
wsrep_provider = /usr/lib64/galera/libgalera_smm.so
wsrep_cluster_address = "gcomm://node4,node5,node6"
wsrep_node_name = node4
wsrep_node_address=10.128.20.16
#wsrep_provider_options="socket.ssl_key=/etc/pki/galera/galera.key; socket.ssl_cert=/etc/pki/galera/galera.crt;"

提示：如果不用ssl的方式认证的话，请把 wsrep_provider_options 注释掉。

将此文件复制到node5、node6，注意要把 wsrep_node_name 和 wsrep_node_address 改成相应节点的hostname 和 ip。

4 启动 MariaDB Galera Cluster 服务

[root@node4 ~]# /usr/libexec/mysqld --wsrep-new-cluster --user=root &

观察日志：

[root@node4 ~]# tail -f /var/log/mariadb/mariadb.log
150701 19:54:17 [Note] WSREP: wsrep_load(): loading provider library 'none'
150701 19:54:17 [Note] /usr/libexec/mysqld: ready for connections.
Version: '5.5.40-MariaDB-wsrep'  socket: '/var/lib/mysql/mysql.sock'  port: 3306  MariaDB Server, wsrep_25.11.r4026

出现 ready for connections ,证明我们启动成功，继续启动其他节点：

[root@node5 ~]# systemctl start mariadb

[root@node6 ~]# systemctl start mariadb

可以查看 /var/log/mariadb/mariadb.log，在日志可以看到节点均加入了集群中。

警告⚠：--wsrep-new-cluster 这个参数只能在初始化集群使用，且只能在一个节点使用。

5 查看集群状态

我们可以关注几个关键的参数：

wsrep_connected = on 链接已开启

wsrep_local_index = 1 在集群中的索引值

wsrep_cluster_size =3 集群中节点的数量

wsrep_incoming_addresses = 10.128.20.17:3306,10.128.20.16:3306,10.128.20.18:3306 集群中节点的访问地址

6 验证数据同步

我们在 node4 上新建数据库 galera_test ,然后在 node5 和 node6 上查询，如果可以查询到 galera_test 这个库，说明数据同步成功，集群运行正常。

[root@node4 ~]# mysql  -uroot  -proot  -e  "create database galera_test"

[root@node5 ~]# mysql  -uroot  -proot  -e  "show databases"
+--------------------+
| Database           |
+--------------------+
| information_schema |
| galera_test        |
| mysql              |
| performance_schema |
+--------------------+

[root@node6 ~]# mysql  -uroot  -proot  -e  "show databases"
+--------------------+
| Database           |
+--------------------+
| information_schema |
| galera_test        |
| mysql              |
| performance_schema |
+--------------------+

至此，我们的 MariaDB Galera Cluster 已经成功部署。

参考文章

• http://galeracluster.com/documentation-webpages/ 
• https://mariadb.com/kb/en/mariadb/getting-started-with-mariadb-galera-cluster/ 

来源：http://code.oneapm.com/database/2015/07/02/mariadb-galera-cluster/

老规矩，开场白，刚开始用mysqldump，备份100G+的数据库，再加上服务器繁忙，备份速度像蜗牛似的，于是寻找更高效的备份方法。网上都说用xtrabackup比较适合备份大的数据库，而且备份效率也高，就尝试使用一次，结果明显感觉比mysqldump 备份与恢复速度就是快不少，那以后就用它了。大礼拜日的在家也没事，结合生产环境，写了这篇文档，刚接触的朋友，可以参考下，不多说，入正题！

1、初次备份前准备工作

1.1 了解备份方式

• 热备份：读写不受影响（mysqldump–>innodb）
• 温备份：仅可以执行读操作（mysqldump–>myisam）
• 冷备份：离线备份，读写都不可用
• 逻辑备份：将数据导出文本文件中（mysqldump）
• 物理备份：将数据文件拷贝（xtrabackup、mysqlhotcopy）
• 完整备份：备份所有数据
• 增量备份：仅备份上次完整备份或增量备份以来变化的数据
• 差异备份：仅备份上次完整备份以来变化的数据

   1.2 创建备份用户

mysql> grant reload,lock tables,replication client on *.* to 'bak'@'localhost' identified by 'bak2015';
mysql> flush privileges;

1.3 安装方式

CentOS：

# rpm -ivh http://www.percona.com/downloads/percona-release/redhat/0.1-3/percona-release-0.1-3.noarch.rpm
# yum install percona-xtrabackup

xtrabackup2.2不支持MySQL5.1的Innodb引擎，如需要可安装2.0版本。

Ubuntu：

# sudo apt-get install xtrabackup  

14.04默认有这个包，14.04之前版本如果没有在这个地址下载对应的版本。

1.4 了解常用参数

• –user=     #指定数据库备份用户
• –password=  #指定数据库备份用户密码
• –port=     #指定数据库端口
• –host=     #指定备份主机
• –socket=    #指定socket文件路径
• –databases=  #备份指定数据库,多个空格隔开，如–databases=”dbname1 dbname2″，不加备份所有库
• –defaults-file=       #指定my.cnf配置文件
• –apply-log         #日志回滚
• –incremental=          #增量备份，后跟增量备份路径
• –incremental-basedir=     #增量备份，指上次增量备份路径
• –redo-only         #合并全备和增量备份数据文件
• –copy-back         #将备份数据复制到数据库，数据库目录要为空
• –no-timestamp          #生成备份文件不以时间戳为目录名
• –stream=             #指定流的格式做备份，–stream=tar，将备份文件归档
• –remote-host=user@ip DST_DIR #备份到远程主机

2、完整备份与恢复

2.1 完整备份 

# innobackupex --user=bak --password='bak2015' /mysql_backup  

2.2 备份恢复

# innobackupex --defaults-file=/etc/mysql/my.cnf --copy-back /home/loongtao/mysql_backup/2015-02-08_11-56-48/

2.3 备份文件说明

# ls 2015-02-08_11-56-48

• backup-my.cnf：记录innobackup使用到mysql参数
• xtrabackup_binary：备份中用到的可执行文件
• xtrabackup_checkpoints：记录备份的类型、开始和结束的日志序列号
• xtrabackup_logfile：备份中会开启一个log copy线程，用来监控innodb日志文件（ib_logfile），如果修改就会复制到这个文件

3、完整备份+增量备份与恢复

3.1 完整备份

# innobackupex --user=bak --password='bak2015' /mysql_backup

备份后位置是：/mysql_backup/2015-02-08_11-56-48

3.2 增量备份1

# innobackupex --user=bak --password='bak2015' --incremental /data1/mysql_backup --incremental-basedir=/mysql_backup/2015-02-08_11-56-48  #指定上次完整备份目录

3.3 增量备份2

# innobackupex --user=bak --password='bak2015' --incremental /data1/mysql_backup --incremental-basedir=/mysql_backup/2015-02-08_12-16-06  #指定上次增量备份目录

3.4 查看xtrabackup_checkpoints文件

一目了然，可以看到根据日志序号来增量备份

3.5 备份恢复

3.5.1 备份恢复思路

将增量备份1、增量备份2…合并到完整备份，加到一起出来一个新的完整备份，将新的完整备份以拷贝的形式到数据库空目录（rm /var/lib/mysql/* -rf）

3.5.2 预备完整备份

xtrabackup把备份过程中可能有尚未提交的事务或已经提交但未同步数据文件的事务，写到xtrabackup_logfile文件，所以要先通过这个日志文件回滚，把未完成的事务同步到备份文件，保证数据文件处于一致性。

# innobackup --apply-log --redo-only 2015-02-08_11-56-48

3.5.3 合并第一个增量备份

# innobackupex --apply-log --redo-only /mysql_backup/2015-02-08_11-56-48/ --incremental-dir=mysql_backup/2015-02-08_12-16-06

3.5.4 合并第二个增量备份

# innobackupex --apply-log --redo-only /mysql_backup/2015-02-08_11-56-48/ --incremental-dir=mysql_backup/2015-02-08_16-06-53

3.5.5 恢复完整备份

这时2015-02-08_11-56-48完整备份已经包含所有增量备份，可以通过查看checkpoints来核实

# innobackupex --defaults-file=/etc/mysql/my.cnf --copy-back /mysql_backup/2015-02-08_11-56-48/

3.5.6 修改恢复数据文件权限

# chown -R mysql.mysql /var/lib/mysql

3.5.7 启动MySQL,查看数据库恢复情况

# /etc/init.d/mysqld start

4、备份文件归档压缩

4.1 归档并发送到备份服务器

# innobackupex --databases=test --user=bak --password='bak2015' --stream=tar /mysql_backup 2>/mysql_backup/bak.log |ssh root@192.168.18.251 "cat - > /mysql_backup/`date +%F`.tar"

解压：tar -ixvf `date +%F`.tar

4.2 归档备份

# innobackupex --databases=test --user=bak --password='bak2015' --stream=tar /mysql_backup > /mysql_backup/`date +%F`.tar

解压：tar -ixvf `date +%F`.tar

4.3 压缩归档备份

# innobackupex --databases=test --user=bak --password='bak2015' --stream=tar /mysql_backup |gzip >/mysql_backup/`date +%F`.tar.gz

解压：tar -izxvf `date +%F`.tar.gz

来源：http://lizhenliang.blog.51cto.com/7876557/1612800

常见的 Web 应用的压力测试工具

Web 应用压力测试工具有很多，比如 Apache ab，node-ab，Apache JMeter, LoadRunner, httperf。但是这些工具都没能解决一个问题：

如何正确模拟生产环境的流量

如今 Web 应用的架构变得非常复杂，内部包含复杂的各种负载均衡、 服务和 RPC 调用关系，简单的发送 GET 请求到某些 URL 或者 API 接口完全无法模拟真实的流量。假如回放 HTTP 日志，操作又异常麻烦。Tcpcopy 虽然能够复制实时流量，但是操作也很复杂。之前的 亚马逊云平台的迁移 就用到了 Gor 这个工具。

Gor 是 Web 应用压力测试的完美方案

我一直在找一个简单又方便的解决方案，直到找到了 Gor 。Gor 是用 Golang 写的一个 HTTP 实时流量复制工具。只需要在 LB 或者 Varnish 入口服务器上执行一个进程，就可以把生产环境的流量复制到任何地方，比如 Staging 环境、Dev 环境。完美解决了 HTTP 层实时流量复制和压力测试的问题。

Gor 的功能

Gor 支持流量的放大和缩小、频率限制，这样不需要搭建和生产环境一致的服务器集群也可以正确测试。Gor 还支持根据正则表达式过滤流量，这意味着可以单独测试某个 API 服务。还可以修改 HTTP 请求头，比如替换 User-Agent, 或者增加某些 HTTP Header 。

Gor 还可以把请求记录到文件，以备回放和分析。Gor 支持和 ElasticSearch 集成，将流量存入 ES 进行实时分析。

Gor 的常用命令

简单的 HTTP 流量复制：

gor –input-raw :80 –output-http “http://staging.com”

HTTP 流量复制频率控制：

gor –input-tcp :28020 –output-http “http://staging.com|10″

HTTP 流量复制缩小：

gor –input-raw :80 –output-tcp “replay.local:28020|10%”

HTTP 流量记录到本地文件：

gor –input-raw :80 –output-file requests.gor

HTTP 流量回放和压测：

gor –input-file “requests.gor|200%” –output-http “staging.com”

HTTP 流量过滤复制：

gor –input-raw :8080 –output-http staging.com –output-http-url-regexp ^www.

最后

这个 Golang 写的 Gor 是开源的，意味着可以方便的集成到自己的架构中，可以用在压力测试平台、实时流量分析、应用层防火墙等等方面。

有用的链接

• https://github.com/buger/gor
• https://github.com/doubaokun/node-ab
• https://github.com/session-replay-tools/tcpcopy
• https://github.com/httperf/httperf
• https://github.com/buger/gor/blob/master/ELASTICSEARCH.md

来源：http://blog.eood.cn/web-performance-testing-gor

写在前面：无规矩不成方圆。对于刚加入互联网的朋友们，肯定会接触到MySQL，MySQL作为互联网最流行的关系型数据库产品，它有它擅长的地方，也有它不足的短板，针对它的特性，结合互联网大多应用的特点，笔者根据自己多年互联网公司的MySQL DBA经验，现总结出互联网MySQL的一些开发规范，仅供参考。

基础规范 

(1) 使用INNODB存储引擎

(2) 表字符集使用UTF8

(3) 所有表都需要添加注释

(4) 单表数据量建议控制在5000W以内

(5) 不在数据库中存储图⽚、文件等大数据

(6) 禁止在线上做数据库压力测试

(7) 禁⽌从测试、开发环境直连数据库

命名规范 

(1) 库名表名字段名必须有固定的命名长度，12个字符以内

(2) 库名、表名、字段名禁⽌止超过32个字符。须见名之意

(3) 库名、表名、字段名禁⽌止使⽤用MySQL保留字

(4) 临时库、表名必须以tmp为前缀，并以⽇日期为后缀

(5) 备份库、表必须以bak为前缀，并以日期为后缀

库、表、字段开发设计规范

(1) 禁⽌使用分区表

(2) 拆分大字段和访问频率低的字段，分离冷热数据

(3) 用HASH进⾏散表，表名后缀使⽤⼗进制数，下标从0开始

(4) 按日期时间分表需符合YYYY[MM][DD][HH]格式

(5) 采用合适的分库分表策略。例如千库十表、十库百表等 

(6) 尽可能不使用TEXT、BLOB类型

(7) 用DECIMAL代替FLOAT和DOUBLE存储精确浮点数

(8) 越简单越好：将字符转化为数字、使用TINYINT来代替ENUM类型

(9) 所有字段均定义为NOT NULL

(10) 使用UNSIGNED存储非负整数

(11) INT类型固定占用4字节存储

(12) 使用timestamp存储时间

(13) 使用INT UNSIGNED存储IPV4

(14) 使用VARBINARY存储大小写敏感的变长字符串

(15) 禁止在数据库中存储明文密码，把密码加密后存储

(16) 用好数值类型字段

• Tinyint (1Byte)
• smallint (2Byte)
• mediumint (3Byte)
• int (4Byte)
• bigint (8Byte)

类型	字节	最小值	最大值
		(带符号的/无符号的)	(带符号的/无符号的)
TINYINT	1	-128	127
无符号		0	255
SMALLINT	2	-32768	32767
无符号		0	65535
MEDIUMINT	3	-8388608	8388607
无符号		0	16777215
INT	4	-2147483648	2147483647
无符号		0	4294967295
BIGINT	8	-9223372036854775808	9223372036854775807
无符号		0	18446744073709551615

如果数值字段没有那么大，就不要用 bigint

(17) 存储ip最好用int存储而非char(15)

(18) 不允许使用ENUM

(19) 避免使用NULL字段

NULL字段很难查询优化，NULL字段的索引需要额外空间，NULL字段的复合索引无效

(20) 少用text/blob，varchar的性能会比text高很多，实在避免不了blob，请拆表

(21) 数据库中不允许存储大文件，或者照片，可以将大对象放到磁盘上，数据库中存储它的路径

索引规范

(1) 索引的数量要控制：

a、单张表中索引数量不超过5个

b、单个索引中的字段数不超过5个

c、对字符串使⽤用前缀索引，前缀索引长度不超过8个字符

d、建议优先考虑前缀索引，必要时可添加伪列并建立索引

(2) 主键准则

a、表必须有主键

b、不使用更新频繁的列作为主键

c、尽量不选择字符串列作为主键

d、不使用UUID MD5 HASH这些作为主键(数值太离散了)

e、默认使⽤非空的唯一键作为主键

f、建议选择自增或发号器

(3) 重要的SQL必须被索引，比如：

a、UPDATE、DELETE语句的WHERE条件列

b、ORDER BY、GROUP BY、DISTINCT的字段

(4) 多表JOIN的字段注意以下：

a、区分度最大的字段放在前面

b、核⼼SQL优先考虑覆盖索引

c、避免冗余和重复索引

d、索引要综合评估数据密度和分布以及考虑查询和更新比例

(5) 索引禁忌

a、不在低基数列上建立索引，例如“性别”

b、不在索引列进行数学运算和函数运算

(6) 尽量不使用外键

a、外键用来保护参照完整性，可在业务端实现

b、对父表和子表的操作会相互影响，降低可用性

(7) 索引命名

非唯一索引必须以 idx_字段1_字段2命名，唯一所以必须以uniq_字段1_字段2命名，索引名称必须全部小写

(8) 新建的唯一索引必须不能和主键重复

(9) 索引字段的默认值不能为NULL

要改为其他的default或者空。NULL非常影响索引的查询效率。

(10) 反复查看与表相关的SQL，符合最左前缀的特点建立索引。

多条字段重复的语句，要修改语句条件字段的顺序，为其建立一条联合索引，减少索引数量

(11) 能使用唯一索引就要使用唯一索引，提高查询效率

(12)研发要经常使用explain，如果发现索引选择性差，必须让他们学会使用hint

SQL规范

(1) sql语句尽可能简单

大的sql想办法拆成小的sql语句(充分利用QUERY CACHE和充分利用多核CPU)

(2) 事务要简单，整个事务的时间长度不要太长

(3) 避免使用触发器、函数、存储过程

(4) 降低业务耦合度，为sacle out、sharding留有余地

(5) 避免在数据库中进⾏数学运算(MySQL不擅长数学运算和逻辑判断)

(4) 不要用select *，查询哪几个字段就select 这几个字段

(5) sql中使用到OR的改写为用 IN() (or的效率没有in的效率高)

(6) in里面数字的个数建议控制在1000以内

(7) limit分页注意效率。Limit越大，效率越低。可以改写limit，比如例子改写：

select id from tlimit 10000, 10; => select id from t where id > 10000 limit10;

(9) 使用union all替代union

(10) 避免使⽤大表的JOIN

(11) 使用group by 分组、自动排序

(12) 对数据的更新要打散后批量更新，不要一次更新太多数据

(13) 减少与数据库的交互次数

(13) 注意使用性能分析工具：Sql explain / showprofile / mysqlsla

(14) SQL语句要求所有研发，SQL关键字全部是大写，每个词只允许有一个空格

(15) SQL语句不可以出现隐式转换，比如：select id from 表 where id=’1′

(16) IN条件里面的数据数量要少，我记得应该是500个以内，要学会使用exist代替in，exist在一些场景查询会比in快

(17) 能不用NOT IN就不用NOTIN，坑太多了。。会把空和NULL给查出来

(18) 在SQL语句中，禁止使用前缀是%的like

(19) 不使用负向查询，如 not in/like

(19) 关于分页查询：程序里建议合理使用分页来提高效率limit，offset较大要配合子查询使用

(20) 禁止在数据库中跑大查询

(21) 使⽤预编译语句，只传参数，比传递SQL语句更高效；一次解析，多次使用；降低SQL注入概率

(22) 禁止使⽤order by rand()

(23) 禁⽌单条SQL语句同时更新多个表

流程规范

(1) 所有的建表操作需要提前告知该表涉及的查询sql；

(2) 所有的建表需要确定建立哪些索引后才可以建表上线；

(3) 所有的改表结构、加索引操作都需要将涉及到所改表的查询sql发出来告知DBA等相关人员；

(4) 在建新表加字段之前，要求研发至少要提前3天邮件出来，给dba们评估、优化和审核的时间

(5)批量导入、导出数据必须提前通知DBA协助观察

(6) 禁⽌在线上从库执行后台管理和统计类查询

(7) 禁⽌有super权限的应用程序账号存在

(8) 推广活动或上线新功能必须提前通知DBA进⾏行流量评估

(9) 不在业务高峰期批量更新、查询数据库

本文转自《运维帮》

来源：http://mp.weixin.qq.com/s?__biz=MzA3MzYwNjQ3NA==∣=207132223&idx;=1&sn;=f5d98146f28235d91fe3e675cead4ce5&scene;=5#rd

Sphinx是一款基于SQL的高性能全文检索引擎，Sphinx的性能在众多全文检索引擎中也是数一数二的，利用Sphinx，我们可以完成比数据库本身更专业的搜索功能，而且可以有很多针对性的性能优化。

Sphinx的特点

• 快速创建索引：3分钟左右即可创建近100万条记录的索引，并且采用了增量索引的方式，重建索引非常迅速。
• 闪电般的检索速度：尽管是1千万条的大数据量，查询数据的速度也在毫秒级以上，2-4G的文本量中平均查询速度不到0.1秒。
• 为很多脚本语言设计了检索API，如PHP,Python,Perl,Ruby等，因此你可以在大部分编程应用中很方便地调用Sphinx的相关接口。
• 为MySQL设计了一个存储引擎插件，因此如果你在MySQL上使用Sphinx，那简直就方便到家了。
• 支持分布式搜索，可以横向扩展系统性能。

PHP+MySQL+Sphinx 搜索引擎架构图

在MySQL中安装Sphinx

Sphinx在MySQL上安装有两种方式：

• 第一种方式是采用API调用，我们可以使用PHP,Python,Perl,Ruby等编程语言的API函数进行查询，这种方式不必重新编译MySQL，模块间改动比较少，相对灵活。
• 第二种需要重新编译MySQL，将Sphinx以插件的方式编译到MySQL中去，这种方式对程序改动比较少，仅仅需要改动SQL语句即可，但前提是你的MySQL版本必须在5.1以上。

下面是第一种安装方式：

#下载最新稳定版
wget http://www.sphinxsearch.com/downloads/sphinx-0.9.9.tar.gz
tar xzvf sphinx-0.9.9.tar.gz
cd sphinx-0.9.9
./configure --prefix=/usr/local/sphinx/   --with-mysql  --enable-id64
make
make install

Sphinx中文分词插件Coreseek安装

注：coreseek的安装教程来自这里，下面是详细过程：

安装升级autoconf

因为coreseek需要autoconf 2.64以上版本，因此需要升级autoconf，不然会报错。从http://download.chinaunix.net/download.php?id=29328&ResourceID=648 下载autoconf-2.64.tar.bz2，安装方法如下：

tar -jxvf autoconf-2.64.tar.bz2
cd autoconf-2.64
./configure
make
make install

下载coreseek

新版本的coreseek将词典和sphinx源程序放在了一个包中，因此只需要下载coreseek包就可以了。

wget http://www.wapm.cn/uploads/csft/3.2/coreseek-3.2.14.tar.gz

安装mmseg(coreseek所使用的词典)

tar xzvf coreseek-3.2.14.tar.gz
cd mmseg-3.2.14
./bootstrap    #输出的warning信息可以忽略，如果出现error则需要解决
./configure --prefix=/usr/local/mmseg3
make && make install
cd ..

安装coreseek(sphinx)

cd csft-3.2.14
sh buildconf.sh    #输出的warning信息可以忽略，如果出现error则需要解决
./configure --prefix=/usr/local/coreseek  --without-unixodbc --with-mmseg --with-mmseg-includes=/usr/local/mmseg3/include/mmseg/ --with-mmseg-libs=/usr/local/mmseg3/lib/ --with-mysql
make && make install
cd ..

测试mmseg分词和coreseek搜索

备注：需要预先设置好字符集为zh_CN.UTF-8，确保正确显示中文，我的系统字符集为en_US.UTF-8也是可以的。

cd testpack
cat var/test/test.xml  #此时应该正确显示中文
/usr/local/mmseg3/bin/mmseg -d /usr/local/mmseg3/etc var/test/test.xml
/usr/local/coreseek/bin/indexer -c etc/csft.conf --all
/usr/local/coreseek/bin/search -c etc/csft.conf 网络搜索
此时正确的应该返回
words:
1. '网络': 1 documents, 1 hits
2. '搜索': 2 documents, 5 hits

生成 mmseg词库及配置文件

新版本的已经自动生成。

总结

Sphinx作为一款高性能的SQL全文检索引擎，值得开发者继续关注，尤其是它多语言的API支持，使开发者可以更方便地应用。

来源：http://www.codeceo.com/article/sphinx-sql-search-engine.html

现在生产环境MySQL数据库是一主一从，由于业务量访问不断增大，故再增加一台从库。前提是不能影响线上业务使用，也就是说不能重启MySQL服务，为了避免出现其他情况，选择在网站访问量低峰期时间段操作。

 一般在线增加从库有两种方式，一种是通过mysqldump备份主库，恢复到从库，mysqldump是逻辑备份，数据量大时，备份速度会很慢，锁表的时间也会很长。另一种是通过xtrabackup工具备份主库，恢复到从库，xtrabackup是物理备份，备份速度快，不锁表。为什么不锁表？因为自身会监控主库日志，如果有更新的数据，就会先写到一个文件中，然后再回归到备份文件中，从而保持数据一致性。

服务器信息：

• 主库：192.168.18.212（原有）
• 从库1：192.168.18.213（原有）
• 从库2：192.168.18.214（新增）
• 数据库版本：MySQL5.5
• 存储引擎：Innodb
• 测试库名：weibo

一、mysqldump方式

MySQL主从是基于binlog日志，所以在安装好数据库后就要开启binlog。这样好处是，一方面可以用binlog恢复数据库，另一方面可以为主从做准备。

原有主库配置参数如下：

# vi my.cnf
server-id = 1             #id要唯一
log-bin = mysql-bin         #开启binlog日志
auto-increment-increment = 1   #在Ubuntu系统中MySQL5.5以后已经默认是1
auto-increment-offset = 1
slave-skip-errors = all      #跳过主从复制出现的错误

1. 主库创建同步账号

mysql> grant all on *.* to 'sync'@'192.168.18.%' identified by 'sync';

2. 从库配置MySQL

# vi my.cnf
server-id = 3             #这个设置3
log-bin = mysql-bin         #开启binlog日志
auto-increment-increment = 1   #这两个参数在Ubuntu系统中MySQL5.5以后都已经默认是1
auto-increment-offset = 1
slave-skip-errors = all      #跳过主从复制出现的错误

3. 备份主库

# mysqldump -uroot -p123 --routines --single_transaction --master-data=2 --databases weibo > weibo.sql

参数说明：

–routines：导出存储过程和函数

–single_transaction：导出开始时设置事务隔离状态，并使用一致性快照开始事务，然后unlock tables;而lock-tables是锁住一张表不能写操作，直到dump完毕。

–master-data：默认等于1，将dump起始（change master to）binlog点和pos值写到结果中，等于2是将change master to写到结果中并注释。

4. 把备份库拷贝到从库

# scp weibo.sql root@192.168.18.214:/home/root

5. 在主库创建test_tb表，模拟数据库新增数据，weibo.sql是没有的

mysql> create table test_tb(id int,name varchar(30));

6. 从库导入备份库

# mysql -uroot -p123 -e 'create database weibo;'
# mysql -uroot -p123 weibo < weibo.sql

7. 在备份文件weibo.sql查看binlog和pos值

# head -25 weibo.sql
-- CHANGE MASTER TO MASTER_LOG_FILE='mysql-bin.000001', MASTER_LOG_POS=107;   #大概22行

8. 从库设置从这个日志点同步，并启动

mysql> change master to master_host='192.168.18.212',
    -> master_user='sync',
    -> master_password='sync',
    -> master_log_file='mysql-bin.000001',
    -> master_log_pos=107;
mysql> start slave;
mysql> show slave statusG;
ERROR 2006 (HY000): MySQL server has gone away
No connection. Trying to reconnect...
Connection id:    90
Current database: *** NONE ***
*************************** 1. row ***************************
               Slave_IO_State: Waiting for master to send event
                  Master_Host: 192.168.18.212
                  Master_User: sync
                  Master_Port: 3306
                Connect_Retry: 60
              Master_Log_File: mysql-bin.000001
          Read_Master_Log_Pos: 358
               Relay_Log_File: mysqld-relay-bin.000003
                Relay_Log_Pos: 504
        Relay_Master_Log_File: mysql-bin.000001
             Slave_IO_Running: Yes
            Slave_SQL_Running: Yes
......

9. 从库查看weibo库里面的表

可以看到IO和SQL线程均为YES，说明主从配置成功。

mysql> show tables;
+---------------------------+
| Tables_in_weibo           |
+---------------------------+
| test_tb                   |

发现刚才模拟创建的test_tb表已经同步过来！

二、xtrabackup方式（推荐）

在上面配置基础上做实验，先删除掉从库配置：

mysql> stop slave;         #停止同步
mysql> reset slave;        #清除从连接信息
mysql> show slave statusG;   #再查看从状态，可以看到IO和SQL线程都为NO
mysql> drop database weibo;   #删除weibo库

此时，从库现在和新装的一样，继续前进！

1. 主库使用xtrabackup备份

# innobackupex --user=root --password=123 ./

生成一个以时间为命名的备份目录：2015-07-01_16-49-43

# ll 2015-07-01_16-49-43/
total 18480
drwxr-xr-x 5 root root     4096 Jul  1 16:49 ./
drwx------ 4 root root     4096 Jul  1 16:49 ../
-rw-r--r-- 1 root root      188 Jul  1 16:49 backup-my.cnf
-rw-r----- 1 root root 18874368 Jul  1 16:49 ibdata1
drwxr-xr-x 2 root root     4096 Jul  1 16:49 mysql/
drwxr-xr-x 2 root root     4096 Jul  1 16:49 performance_schema/
drwxr-xr-x 2 root root    12288 Jul  1 16:49 weibo/
-rw-r--r-- 1 root root       21 Jul  1 16:49 xtrabackup_binlog_info
-rw-r----- 1 root root       89 Jul  1 16:49 xtrabackup_checkpoints
-rw-r--r-- 1 root root      563 Jul  1 16:49 xtrabackup_info
-rw-r----- 1 root root     2560 Jul  1 16:49 xtrabackup_logfile

2. 把备份目录拷贝到从库上

# scp -r 2015-07-01_16-49-43 root@192.168.18.214:/home/root

3. 从库上把MySQL服务停掉，删除datadir目录，将备份目录重命名为datadir目录

# sudo rm -rf /var/lib/mysql/
# sudo mv 2015-07-01_16-49-43/ /var/lib/mysql
# sudo chown mysql.mysql -R /var/lib/mysql
# sudo /etc/init.d/mysql start
# ps -ef |grep mysql    #查看已经正常启动
mysql     8832     1  0 16:55 ?        00:00:00 /usr/sbin/mysqld

4. 在主库创建test_tb2表，模拟数据库新增数据

mysql> create table test_tb2(id int,name varchar(30));

5. 从备份目录中xtrabackup_info文件获取到binlog和pos位置

# cat /var/lib/mysql/xtrabackup_info
uuid = 201af9db-1fce-11e5-96b0-525400e4239d
name =
tool_name = innobackupex
tool_command = --user=root --password=... ./
tool_version = 1.5.1-xtrabackup
ibbackup_version = xtrabackup version 2.2.11 based on MySQL server 5.6.24 Linux (x86_64) (revision id: )
server_version = 5.5.43-0ubuntu0.12.04.1-log
start_time = 2015-07-01 16:49:43
end_time = 2015-07-01 16:49:46
lock_time = 1
binlog_pos = filename 'mysql-bin.000001', position 429    #这个位置
innodb_from_lsn = 0
innodb_to_lsn = 1598188
partial = N
incremental = N
format = file
compact = N
compressed = N

6. 从库设置从这个日志点同步，并启动

mysql> change master to master_host='192.168.18.212',
    -> master_user='sync',
    -> master_password='sync',
    -> master_log_file='mysql-bin.000001',
    -> master_log_pos=429;
mysql> start slave;
mysql> show slave statusG;
*************************** 1. row ***************************
               Slave_IO_State: Waiting for master to send event
                  Master_Host: 192.168.18.212
                  Master_User: sync
                  Master_Port: 3306
                Connect_Retry: 60
              Master_Log_File: mysql-bin.000001
          Read_Master_Log_Pos: 539
               Relay_Log_File: mysqld-relay-bin.000002
                Relay_Log_Pos: 363
        Relay_Master_Log_File: mysql-bin.000001
             Slave_IO_Running: Yes
            Slave_SQL_Running: Yes
......

7. 从库查看weibo库里面的表

可以看到IO和SQL线程均为YES，说明主从配置成功。

mysql> show tables;
+---------------------------+
| Tables_in_weibo           |
+---------------------------+
| test_tb                   |
| test_tb2                  |

发现刚才模拟创建的test_tb2表已经同步过来。

来源：http://lizhenliang.blog.51cto.com/7876557/1669829

我学习C语言的时候是在大学课程上，老实说，能理解那些语言概念就很不容易了，对于软件包管理这件事听都没听说过。但真实情况下，大部分的软件项目都不可能是从零开始的，我们总要依赖某些开源的或者团队自己开发的工具和框架库来帮助工作，我是学习java的时候才慢慢听说了maven。
maven的核心配置是pom.xml文件，开发者可以根据需要在其中列出项目的依赖包，像这样：

org.springframework
spring-core
4.1.5.RELEASE

maven命令在工作时会找到spring-core所依赖的其它库

$ mvn dependency:tree
......
[INFO] sample_java:sample_java:war:1.0-SNAPSHOT
[INFO] +- org.springframework:spring-core:jar:4.1.5.RELEASE:compile
[INFO] |  - commons-logging:commons-logging:jar:1.2:compile
......

但是这样有个问题，某些间接依赖会导致在不同时候打出不同的包，比如上述这样个例子，两次打包期间如果commons-logging发布了新版本，那么两次打包的内容就不一样了，如果遇到新版本的差异，开发人员可能会莫名其妙。
ruby社区针对这个问题发明了一个叫做bundle的工具，它也有个Gemfile文件用来记录直接的依赖库，类似mvn，但是bundle多了一个功能，工程师可以在当前项目下执行bundle install 命令，bundle系统将根据当前的软件仓库状态计算出间接依赖，并将这些间接依赖锁定到某个版本，内容写在 Gemfile.lock 文件中。比如这个简单的例子：

source 'https://ruby.taobao.org'
gem 'activesupport'

生成的Gemfile.lock是这样：

GEM
remote: https://ruby.taobao.org/
specs:
activesupport (4.2.3)
  i18n (~> 0.7)
  json (~> 1.7, >= 1.7.7)
  minitest (~> 5.1)
  thread_safe (~> 0.3, >= 0.3.4)
  tzinfo (~> 1.1)
i18n (0.7.0)
json (1.8.3)
minitest (5.7.0)
thread_safe (0.3.5)
tzinfo (1.2.2)
  thread_safe (~> 0.1)
PLATFORMS
ruby
DEPENDENCIES
activesupport

当再次执行bundle命令时，bundle系统会根据Gemfile.lock文件来决定间接依赖，所以开发者通常把这个文件放入版本控制系统，确保所有人和线上都用同一份Gemfile.lock，就能避免上述的问题。
我一直觉得bundle的做法是最先进的，不过和做nodejs开发的同学聊天时，了解到了npm的做法颇为特别，虽然不见得比bundle更好，却是各有优劣。
npm的做法是直接把被依赖的库放入当前库的node_modules目录，依赖库也以此类推，它的核心文件是package.json，比如这个例子：

$  cat package.json
{
"name": "sample_js",
"version": "1.0.0",
"dependencies": {
"browserify": "10.2.4"
}
}
$ npm install
$ npm dedupe

查看一下依赖库

$  ls node_modules/browserify/node_modules
JSONStream             concat-stream          glob                   labeled-stream-splicer readable-stream        syntax-error
acorn                  console-browserify     has                    module-deps            readable-wrap          through2
assert                 constants-browserify   htmlescape             os-browserify          resolve                timers-browserify
browser-pack           crypto-browserify      http-browserify        parents                sha.js                 tty-browserify
browser-resolve        defined                https-browserify       path-browserify        shasum                 url
browserify-zlib        deps-sort              indexof                process                shell-quote            util
buffer                 domain-browser         inherits               punycode               stream-browserify      vm-browserify
builtins               duplexer2              insert-module-globals  querystring-es3        string_decoder         xtend
commondir              events                 isarray                read-only-stream       subarg

查看一下依赖库的依赖库

$ ls node_modules/browserify/node_modules/crypto-browserify/node_modules
bn.js           browserify-aes  browserify-sign create-hash     diffie-hellman  parse-asn1      public-encrypt
brorand         browserify-rsa  create-ecdh     create-hmac     elliptic        pbkdf2          randombytes

这种做法实际上是在开发环节就确定并下载了间接依赖的库，可以看做在开发者手里就完成了打包，这么做有什么好处？
相比maven，npm和bundle更具备一致性，无论到哪里，bundle系统都保证使用lock版本，不会有“失控”的依赖库；而相对于bundle，npm可以允许在一个项目中依赖同一个库的不同版本，这比较灵活。
但是这么做也有缺点，有些js开发者就吐槽这一点，认为浪费了内存——不同库依赖同一个库时，都会在自己的node_modules目录下存放一份被依赖库的代码。从这个角度看，bundle又显得有些优势，因为require在同一个ruby进程中是有缓存的，不会额外浪费内存。
打个比方吧，bundle就好像大规模的军事单位，除了作战部队外还有专门的，好处是可以统一划拨管理，降低了维护成本，缺点是有些细微的差别不好满足。而npm就好像一个精干的小分队，每个人带自己适合的食物，虽然可能并不丰富，但是每个单兵都是一个可以独立生存的单元。
我把npm这种方式称为“自带干粮”。软件技术中，“自带干粮”的设计思想有很多应用场景，比如动态编译和静态编译。
如果你喜欢自己从源码编译软件，那么多半熟悉LD_LIBRARY_PATH这个环境变量，这是用来指明动态链接库查找路径的，我们常常把一些模块代码编译为后缀为 so 的动态链接库文件，然后再运行时动态载入。
与之相比，还有一种做法叫静态编译，比如这样的命令：

/opt/apache_src $ ./configure --prefix=/usr/ --enable-file-cache

其中的enable-file-cache是静态编译的选项，使用这类选项，编译工具会将模块直接编译进入最终的执行文件（比如apache的执行文件就是httpd）。
使用动态链接库还是选择静态编译？应该说两种方式各有优劣，前者可以减少内存消耗，避免装入暂时用不到的代码，而后者则是某种角度的“自带干粮”，这样编译的可执行程序，迁移起来比较容易，不会由于目标系统上没有相应的动态链接库而运行失败。
Go语言是 google 创建的一门语言，它有很多独特的设计，其中之一就是——它是静态编译的，这一点曾经让很多人诟病，认为它写一个hello world都要输出很大的可执行文件。
但是从另外一个角度看这个做法很有价值，Go语言的定位是系统级编程，这类程序和应用软件不同，它往往比较底层，本身就是其它软件的基础，因此对稳定性很重视，除了硬件这种不得不考虑的因素，其它方面干扰越少越好，使用静态链接方式产生两个好处：

• 降低迁移成本：在一个linux里编译好的Go程序，通常可以直接copy到其它linux上使用，而如果依赖动态链接库，那么可能由于目标系统上缺乏动态链接库而失败，这样，Go程序的安装复杂性会很高，这对基础的系统软件是不利的。
• 外部错误干扰bug定位：即使目标系统上有所需的动态链接库，也不一定就没有问题，由于版本依赖等问题，目标系统的动态链接库未必和本来设想的相同，如果由于外部错误导致bug，而开发人员并不知道这一情况，对bug定位无疑是一个灾难。

Go语言具备这些好处并不是偶然的，作为大规模集群计算起家的互联网公司，Google对于系统的横向扩展能力、可靠性、故障恢复能力都有很高的要求，自带干粮的语言可以很好的帮助实现这些目标：

• 横向扩展能力：这个和迁移成本相关，由于不再需要动态链接库的配合，应用程序可以很方便完整的在新系统上部署，因此，一旦需要横向扩展，至少在软件安装方面，Go语言就有了很大的便利性。
• 可靠性：Google的哲学是，通过软件而不是硬件提供可靠性。那么，如果硬件的可靠性不可依赖，软件系统的可靠性和容错就要通过类似备份之类的冗余计算来得到，这时，一个“自带干粮”的应用程序显然很容易部署为幂等的集群，因此可以在很大程度上帮助实现冗余计算。
• 故障恢复能力：这将受益于对外部干扰的排除，由于“自带干粮”，Go程序已经包含了bug分析的几乎全部信息，开发人员不需要依靠线上环境，在线下就能分析界定问题。

这样看来，“自带干粮”的做法其实非常适合互联网应用的场景，这里充斥着“集群”、“弹性扩展”、“服务幂等化”的做法，如果我们从事互联网应用领域，那么理解“自带干粮”的做法很有价值。
这个做法其实并不神秘，“自带干粮”的理念的一个重要体现，就是我们很熟悉的“打包”环节。

Linux服务端开发的项目，通常都会有一个“打包”环节，很多人并不完全理解这个环节的作用，实际上，这只是“自带干粮”原则在项目管理中的落实而已。

举两个例子，ruby bundle的打包是这样的：

$ bundle package
...
$ ls -l vendor/cache
total 1744
-rw-r--r--  1 john  staff   322K  7  9 03:48 activesupport-4.2.3.gem
-rw-r--r--  1 john  staff    57K  7  9 03:48 i18n-0.7.0.gem
-rw-r--r--  1 john  staff   149K  7  9 03:48 json-1.8.3.gem
-rw-r--r--  1 john  staff    70K  7  9 03:48 minitest-5.7.0.gem
-rw-r--r--  1 john  staff   118K  7  9 03:48 thread_safe-0.3.5.gem
-rw-r--r--  1 john  staff   144K  7  9 03:48 tzinfo-1.2.2.gem

bundle packge命令把需要使用的gem包统统放入vendor/cache目录，那么当前目录就是一个“自带干粮”的体系。
再看Java：

$ mvn pacakge
...
$ ls -l target/*.war
-rw-r--r--  1 john  staff   1.0M  7  9 03:51 target/sample_java.war

mvn命令最后会输出一个war文件，按照javaEE的相关规范，它自身包含了所有依赖的第三方jar，所以这也是一个“自带干粮”的产出。
结合上面的例子，我们可以得出结论：打包这个行为本质上就是通过“自带干粮”的方式把相关依赖完全纳入控制，这使得我们的交付物能够很容易的在线上水平扩展并减少环境影响。
那么，考虑到大多数语言或者框架都有打包机制，是不是Go语言相对与ruby或者java其实没有什么优势呢？答案是未必，这里需要分开讨论：

• ruby(使用bundle作为包管理工具）：因为是虚拟机语言，通常情况下，bundle的“打包”仅限于ruby语言的各种gem，有些对动态链接库的依赖并没有纳入管理，因此，虽然“自带干粮”却会有“忘记带饭碗”的尴尬情况
• java(使用maven作为包管理工具）：同上，也是虚拟机语言，不过，和ruby不同的是，java由于社区风格的差异，通常习惯于使用pure java的方式解决问题，因此，虽然理论上也可能依赖其它动态链接库，但是实践中很少遇到这种软件包（当然，很少不等于没有）。

显然，由于考虑到操作系统层面的动态链接库问题，ruby和java这种虚拟机语言必须面对打包不完整的问题（与之相比，Go语言除了Glibc基本算是没有依赖），ruby的bundle没有处理这个问题，java则付出了“自己重新搞一遍”的代价。

说到这里自然会产生一个问题——即使是Go，也需要glibc，因此切换OS时还是需要交叉编译技术的，那有没有更“完备”的方案呢？比如把所有依赖都隔离开？
答案是Docker，它把基础库也放入了镜像，因此，从打包这件事来看是Docker image是真正的“自带干粮”并且没有遗漏的做法，未来的Build系统，以Docker image进行交付是大势所趋。

包管理的做法各不相同，然而基本思路差别不大，理解“打包”的目的，是学生和软件工程师的一个重要区别。
来源：http://dockone.io/article/497

意义

文档对于代码的意义不用多说。在golang bolg中已经给出了详细的描述http://blog.golang.org/godoc-documenting-go-code。

我在实战中踩到了不少坑，这里给出更详细的解释以及注意事项。

我们针对golang源码中的注释进行分析得到如下结果。

针对Package的文档

Synopsis

参考http://golang.org/pkg/中的Synopsis。这句话主要出现在针对Package注释中的开头位置。

OverView

参考http://golang.org/pkg/archive/tar/。是针对Package中的注释出现的。如果出现连接，无需标注，生成文档的时候自动会处理成连接

参考例子与注意事项

包： [$GOROOT/src/encoding/json]

文件：encode.go

// Copyright 2010 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package json implements encoding and decoding of JSON objects as defined in
// RFC 4627. The mapping between JSON objects and Go values is described
// in the documentation for the Marshal and Unmarshal functions.
//
// See "JSON and Go" for an introduction to this package:
// http://golang.org/doc/articles/json_and_go.html
package json

从注释中可以看出第四行是断开的，从第四行开始到package json都为针对包的注释。

目录中Synopsis出现内容为：Package json implements encoding and decoding of JSON objects as defined in RFC 4627.

参考注意事项：

1. 在代码的package上面
2. 在上面不能有空行
3. 注释不能断开(中间不能有空行)
4. 最前面一句话会模块的summary会出现在package index中
5. 第一句话以及之后的内容会出现在OverView中

对比文件：decode.go

// Copyright 2010 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Represents JSON data structure using native Go types: booleans, floats,
// strings, arrays, and maps.
package json

在package上面有空行，因此只是针对文件的注释不显示在godoc中。

针对Function

例子：

// Marshaler is the interface implemented by objects that
// can marshal themselves into valid JSON.
type Marshaler interface {
	MarshalJSON() ([]byte, error)
}

我们可以看到：

1. 在函数上面进行注释
2. 中间不能有空行
3. 开始需要 [空格]FunctionName[空格] Summary
4. 然后继续说明
5. 想圈起来说明参数： 加缩进

进阶技巧：

例子同理于：Function Package

// Marshaler is the interface implemented by objects that
/*
can marshal themselves into valid JSON.
*/
type Marshaler interface {
	MarshalJSON() ([]byte, error)
}

这样不算断开，写文档的时候就方便多了。

针对BUG

// BUG(src): Mapping between XML elements and data structures is inherently flawed:
// an XML element is an order-dependent collection of anonymous
// values, while a data structure is an order-independent collection
// of named values.
// See package json for a textual representation more suitable
// to data structures.

godoc会先查找：[空格]BUG

然后显示在Package说明文档最下面，例子：http://golang.org/pkg/encoding/xml/。

针对Example

1. 文件名惯用：example_test.go（其他也可以）
2. 包名： apckage_test
3. 方法名：
   • OverView中： Example
   • 方法中： Example[FuncName]
   • 方法中+一些模式：Example[FuncName]_[Mod]

例子查看：http://golang.org/pkg/errors/。

Example文件(example_test.go)：

// Copyright 2012 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package errors_test
import (
	"fmt"
	"time"
)
// MyError is an error implementation that includes a time and message.
type MyError struct {
	When time.Time
	What string
}
func (e MyError) Error() string {
	return fmt.Sprintf("%v: %v", e.When, e.What)
}
func oops() error {
	return MyError{
		time.Date(1989, 3, 15, 22, 30, 0, 0, time.UTC),
		"the file system has gone away",
	}
}
func Example() {
	if err := oops(); err != nil {
		fmt.Println(err)
	}
	// Output: 1989-03-15 22:30:00 +0000 UTC: the file system has gone away
}

1. 注意文件名为：example_test.go
2. 注意package名为 errors_test
3. 针对Function的注释会出现在网页的Example中
4. 如果函数名直接叫Example会直接显示在OverView中

参考文件(errors_test.go)：

// Copyright 2011 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package errors_test
import (
	"errors"
	"fmt"
	"testing"
)
func TestNewEqual(t *testing.T) {
	// Different allocations should not be equal.
	if errors.New("abc") == errors.New("abc") {
		t.Errorf(`New("abc") == New("abc")`)
	}
	if errors.New("abc") == errors.New("xyz") {
		t.Errorf(`New("abc") == New("xyz")`)
	}
	// Same allocation should be equal to itself (not crash).
	err := errors.New("jkl")
	if err != err {
		t.Errorf(`err != err`)
	}
}
func TestErrorMethod(t *testing.T) {
	err := errors.New("abc")
	if err.Error() != "abc" {
		t.Errorf(`New("abc").Error() = %q, want %q`, err.Error(), "abc")
	}
}
func ExampleNew() {
	err := errors.New("emit macho dwarf: elf header corrupted")
	if err != nil {
		fmt.Print(err)
	}
	// Output: emit macho dwarf: elf header corrupted
}
// The fmt package's Errorf function lets us use the package's formatting
// features to create descriptive error messages.
func ExampleNew_errorf() {
	const name, id = "bimmler", 17
	err := fmt.Errorf("user %q (id %d) not found", name, id)
	if err != nil {
		fmt.Print(err)
	}
	// Output: user "bimmler" (id 17) not found
}

1. ExampleNew就是针对New的例子
2. ExampleNew_errorf 给例子加名字详细效果可以查看这里

针对godoc命令

我常用两种方式：

1. godoc -http=:6060 直接运行网页上的版本，很方便
2. godoc package [name ...] 在开发的时候文档速查

总结

一般工程中搞定这些基本就够了。详细的还是要动手做一做。

我没搞定的：怎么能显示成Main函数的，并且能跑Goplayground

来源：http://www.philo.top/2015/07/10/golang-doc/

那些相信 Linux 命令行是单调无聊且没有任何乐趣的人们，你们错了，这里有一些有关 Linux 的文章，它们展示着 Linux 是如何的有趣和“淘气” 。

• Linux命令及Linux终端的20个趣事
• 终端中的乐趣：6个有趣的Linux命令行工具
• Linux终端的乐趣之把玩字词计数

在本文中，我将讨论一个名为“lolcat”的小工具 – 它可以在终端中生成彩虹般的颜色。

为终端生成彩虹般颜色的输出的 Lolcat 命令

何为 lolcat ?

Lolcat 是一个针对 Linux，BSD 和 OSX 平台的工具，它类似于 cat 命令，并为 cat的输出添加彩虹般的色彩。 Lolcat 主要用于在 Linux 终端中为文本添加彩虹般的色彩。

在 Linux 中安装 Lolcat

1. Lolcat 工具在许多 Linux 发行版的软件仓库中都可获取到，但可获得的版本都有些陈旧，而你可以通过 git 仓库下载和安装最新版本的 lolcat。

由于 Lolcat 是一个 ruby gem 程序，所以在你的系统中必须安装有最新版本的 RUBY。

# apt-get install ruby      [在基于 APT 的系统中]
# yum install ruby          [在基于 Yum 的系统中]
# dnf install ruby          [在基于 DNF 的系统中]

一旦 ruby 软件包安装成功，请确保验证安装的 ruby 的版本。

# ruby --version
ruby 2.1.5p273 (2014-11-13) [x86_64-linux-gnu]

2. 接着使用下面的命令来从 lolcat 的 git 仓库中下载和安装最新版本的 lolcat。

# wget https://github.com/busyloop/lolcat/archive/master.zip
# unzip master.zip
# cd lolcat-master/bin
# gem install lolcat

一旦 lolcat 安装后，你可以检查它的版本号。

# lolcat --version
lolcat 42.0.99 (c)2011 moe@busyloop.net

Lolcat 的用法

3. 在开始使用 lolcat 之前，使用下面的命令来了解它可用的选项和其帮助文档。

# lolcat -h

Lolcat 的帮助文档

4. 接着, 通过管道连接 lolcat 和其他命令，例如 ps, date 和 cal:

# ps | lolcat
# date | lolcat
# cal | lolcat

ps 命令的输出

Date 的输出

Calendar 的输出

5. 使用 lolcat 来展示一个脚本文件的代码:

# lolcat test.sh

用 lolcat 来展示代码

6. 通过管道连接 lolcat 和 figlet 命令。Figlet 是一个展示由常规的屏幕字符组成的巨大字符串的应用。我们可以通过管道将 figlet 的输出连接到 lolcat 中来展示出如下的多彩输出:

# echo I ❤ Tecmint | lolcat
# figlet I Love Tecmint | lolcat

多彩的文字

注: 注意， ❤ 是一个 unicode 字符。要安装 figlet，你需要像下面那样使用 yum 和 apt 来得到这个软件包:

# apt-get figlet
# yum install figlet
# dnf install figlet

7. 给文本赋予彩虹颜色的动画:

$ echo I ❤ Tecmit | lolcat -a -d 500

动的文本

这里选项 -a指的是 Animation(动画)， -d指的是 duration(持续时间)。在上面的例子中，持续 500 次动画。

8. 在彩虹般的颜色下阅读 man 页(例如 man ls):

# man ls | lolcat

多彩地显示文件

9. 通过管道连接 lolcat 和 cowsay。cowsay 是一个可配置的正在思考或说话的奶牛，这个程序也支持其他的动物。

使用下面的命令来安装 cowsay :

# apt-get cowsay
# yum install cowsay
# dnf install cowsay

安装后，使用下面的命令来显示在 cowsay 中的所有动物：

# cowsay -l

样例输出

Cow files in /usr/share/cowsay/cows:
apt beavis.zen bong bud-frogs bunny calvin cheese cock cower daemon default
dragon dragon-and-cow duck elephant elephant-in-snake eyes flaming-sheep
ghostbusters gnu head-in hellokitty kiss kitty koala kosh luke-koala
mech-and-cow meow milk moofasa moose mutilated pony pony-smaller ren sheep
skeleton snowman sodomized-sheep stegosaurus stimpy suse three-eyes turkey
turtle tux unipony unipony-smaller vader vader-koala www

通过管道连接 lolcat 和 cowsay 后的输出，并且使用了‘gnu’形象的 cowfile。

# cowsay -f gnu ☛ Tecmint ☚ is the best Linux Resource Available online | lolcat

使用 Lolcat 的 Cowsay

注: 你可以在将 lolcat 和其他任何命令用管道连接起来在终端中得到彩色的输出。

10. 你可以为最常用的命令创建别名来使得命令的输出呈现出彩虹般的色彩。你可以像下面那样为 ‘ls -l‘ 命令创建别名，这个命令输出一个目录中包含内容的列表。

# alias lolls="ls -l | lolcat"
# lolls

多彩的 Alias 命令

你可以像上面建议的那样，为任何命令创建别名。为了使得别名永久生效，你需要添加相关的代码(上面的代码是 ls -l 的别名) 到 ~/.bashrc 文件中，并登出后再重新登录来使得更改生效。

现在就是这些了。我想知道你是否曾经注意过 lolcat 这个工具？你是否喜欢这篇文章？欢迎在下面的评论环节中给出你的建议和反馈。喜欢并分享我们，帮助我们传播。

---

via: http://www.tecmint.com/lolcat-command-to-output-rainbow-of-colors-in-linux-terminal/

作者：Avishek Kumar 译者：FSSlc 校对：wxy

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

来源：https://linux.cn/article-5798-1.html