Ichennan

Install Cronolog

Tue, 22 Aug 2017 00:00:00 +0000

install cronolog

yum install -y cronolog

Start And Shutdown

Mon, 21 Aug 2017 00:00:00 +0000

start.sh

nohup ./agent 2>&1 | /usr/local/sbin/cronolog  ./log/agent-%Y-%m-%d.log&

shutdown.sh

ps -ef|grep './agent'|grep -v 'grep'|awk '{print $2}'|xargs  -r kill

build parent project

Tue, 08 Aug 2017 00:00:00 +0000

通过父项目来管理多个模块的子项目

通过父项目来管理子模块，同时可以把静态资源统一放在一个单独的WebProject模块，在打包时进行合并。

父项目pom配置

<?xml version="1.0"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.test</groupId>
    <artifactId>ParentProjectBuild</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    <modules>
        <module>OhterProject</module>
        <module>WebProject</module>
    </modules>
</project>

WebProject的pom配置

<?xml version="1.0"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>cn.test</groupId>
    <artifactId>WebProject</artifactId>
    <version>1.0.0</version>
    <name>SNXYWebProject</name>
    <packaging>war</packaging>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <build.env>DEV</build.env>
        <maven.build.timestamp.format>yyyyMMddHHmmss</maven.build.timestamp.format>
    </properties>
    <dependencies>
        <!-- dependencies -->
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>2.1.1</version>
                <configuration>
                    <warName>war_${project.version}_${build.env}_${maven.build.timestamp}</warName>
                    <archive>
                        <addMavenDescriptor>false</addMavenDescriptor>
                    </archive>
                    <!--
                  过滤掉暂时不需要的jar
                  -->
                    <packagingExcludes>WEB-INF/lib/activation-*.jar, WEB-INF/lib/dx-*.jar</packagingExcludes>
                    <webResources>
                        <!-- 
                        静态资源复制
                        note the order of the following resource elements are important. 
                        if there are duplicate files, the first file copied will win
                       -->
                        <resource>
                            <directory>D:\other\web</directory>
                        </resource>
                    </webResources>
                </configuration>
            </plugin>
            <plugin>
                <!--deploy war to jboss server-->
                <groupId>org.jboss.as.plugins</groupId>
                <artifactId>jboss-as-maven-plugin</artifactId>
                <configuration>
                    <timeout>60000</timeout>
                    <jbossHome>/opt/jboss-eap-6.4</jbossHome>
                    <username>name</username>
                    <password>pass</password>
                    <hostname>192.168.0.1</hostname>
                    <!-- put your IP or hostname -->
                    <port>9999</port>
                </configuration>
                <executions>
                    <execution>
                        <id>upload-war</id>
                        <phase>install</phase>
                        <goals>
                            <goal>deploy</goal>
                        </goals>
                        <configuration>
                            <filename>war_${project.version}_${build.env}_${maven.build.timestamp}.war</filename>
                            <name>test.war</name>
                            <deployEnabled>true</deployEnabled>
                            <force>true</force>
                            <domain>
                                <!-- This configuration is need only if you running JBoss in domain mode -->
                                <server-groups>
                                    <server-group>test</server-group>
                                </server-groups>
                            </domain>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

jenkins pipline config demo

Tue, 08 Aug 2017 00:00:00 +0000

pipeline { 
    agent any  
    environment { 
        JAVA_HOME="D:/Java/jdk1.8.0_131"
    }

    stages {
        stage('Build') { 
            steps { 
               echo 'start build war.' 
               
               dir('D://ProjectBuild'){
                    
                    bat "mvn install -Dmaven.test.skip=true"
                    script {
                        wfile=readFile "D:/ProjectBuild/target/warname.txt"
                    }
               }
            }
        }
        stage('Deploy') { 
            steps { 
                echo "start deploy war with ${wfile}"
                dir("D:/ProjectBuild"){
                bat "mvn install -f pom-deploy-v1.xml -Dwarfile=${wfile}"
            
                }
            }
        }
        stage ('Publish') {
            steps{
              build job: 'update_config', parameters: [
                [$class: 'StringParameterValue', name: 'isPublish', value: "Y"]
              ]
            }
        }
    }
}

Linux Tar

Wed, 28 Jun 2017 00:00:00 +0000

tar -zcvf /targetDir.tar.gz /targetDir

tar -xzvf targetDir.tar.gz

nginx introduction

Mon, 08 May 2017 00:00:00 +0000

Nginx简介

Nginx (“engine x”) 是一个高性能的HTTP和反向代理服务器，也是一个IMAP/POP3/SMTP服务器。Nginx是由Igor Sysoev为俄罗斯访问量第二的Rambler.ru站点开发的，第一个公开版本0.1.0发布于2004年10月4日。

为什么要使用Nginx

高性能
提升后端应用响应速度
提供简单的负载均衡
伸缩性好
动态更新配置

如解决了c10k问题

安装维护方便

在低配置服务器中也表现良好

简单快速上手

简单强大的配置指令

Nginx主要特点

不仅是web服务器，同时也是反向代理和邮件服务器
模块化设计，可按需编译需要的模块
异步服务器

基于异步、事件的设计架构

反向代理和负载均衡
资源占用少、消耗低
极高的性能
支持htt(s)、webSocket、IMAP、POP3、SMTP等协议
SSL终止转换
可扩展的监控和日志功能
优雅重启、无需停机

Nginx的设计架构

核心指令

Nginx提供了一些指令集，通过指令集来配置Nginx的运行方式。Nginx有2种指令集，简单指令和块指令。

简单指令就是名称和参数，以分号结尾。格式为：名称参数; 如worker_processes 1;

块指令就是许多简单指令集，并通过{}来括起来。

常用的简单指令有

user // 指定用户，默认值nobody

worker_process // 指定worker的进程数

error_log // 指定错误日志的路径和输出级别

pid // 指定进程号输出的文件路径

事件上下文

worker_connections // 指定worker的最大连接数

use // 指定事件模式，默认不指定，则选择最佳方式

http上下文

include // 引用其他配置文件

default_type // 设置默认type

log_format // 日志格式

access_log // 访问日志

核心模块

核心架构

Nginx的应用

web服务

反向代理

负载均衡

Centos Install Go1.7 Git Cronolog

Tue, 11 Apr 2017 00:00:00 +0000

install git

sudo yum install git-all

install go1.7

method1

go download page https://golang.org/dl/

curl -LO https://storage.googleapis.com/golang/go1.7.5.linux-amd64.tar.gz

shasum -a 256 go1.7*.tar.gz

Output

2e4dd6c44f0693bef4e7b46cc701513d74c3cc44f2419bf519d7868b12931ac3 go1.7.5.linux-amd64.tar.gz

sudo tar -C /usr/local -xvzf go1.7.5.linux-amd64.tar.gz

mehtod2

yum install golang

config go env

find / -name go

sudo vi /etc/profile.d/path.sh

export PATH=$PATH:/usr/local/go/bin

vi ~/.bash_profile

GOROOT=/usr/local/go
export GOROOT

GOPATH=/data/go
export GOPATH
PATH=$PATH:$HOME/bin:$GOROOT/bin:$GOPATH/bin

export PATH

source /etc/profile && source ~/.bash_profile

参考资料

https://www.digitalocean.com/community/tutorials/how-to-install-go-1-7-on-centos-7

Best Practices For Rest

Sat, 01 Apr 2017 00:00:00 +0000

http://www.vinaysahni.com/best-practices-for-a-pragmatic-restful-api https://hackernoon.com/restful-api-designing-guidelines-the-best-practices-60e1d954e7c9

https://blog.mwaysolutions.com/2014/06/05/10-best-practices-for-better-restful-api/

https://stormpath.com/blog/secure-your-rest-api-right-way

https://www.slideshare.net/stormpath/secure-your-rest-api-the-right-way

extract log in specified range time

Fri, 03 Mar 2017 00:00:00 +0000

提取某段时间内的日志

使用场景

有时候需要提取指定时间段的日志信息，同时文件比较大不能直接打开，此时可以通过脚本来提取所需的信息，如：

......

此处省略N行

......
16:09:04,973 INFO  [stdout] (StdoutThread) *********
16:09:04,973 INFO  [stdout] (StdoutThread) *********
16:09:04,973 INFO  [stdout] (StdoutThread) *********
16:09:04,973 INFO  [stdout] (StdoutThread) *********
16:09:04,973 INFO  [stdout] (StdoutThread) *********
16:10:04,973 INFO  [stdout] (StdoutThread) *********
16:10:04,973 INFO  [stdout] (StdoutThread) *********
16:10:04,973 INFO  [stdout] (StdoutThread) *********
16:10:04,973 INFO  [stdout] (StdoutThread) *********
16:10:04,973 INFO  [stdout] (StdoutThread) *********
......

此处省略N行

......
17:10:04,973 INFO  [stdout] (StdoutThread) *********
17:10:04,973 INFO  [stdout] (StdoutThread) *********
17:10:04,973 INFO  [stdout] (StdoutThread) *********
17:10:04,973 INFO  [stdout] (StdoutThread) *********
17:10:04,973 INFO  [stdout] (StdoutThread) *********
17:11:04,973 INFO  [stdout] (StdoutThread) *********
17:11:04,973 INFO  [stdout] (StdoutThread) *********
17:11:04,973 INFO  [stdout] (StdoutThread) *********
17:11:04,973 INFO  [stdout] (StdoutThread) *********
17:11:04,973 INFO  [stdout] (StdoutThread) *********
......

需要获取16:10到17:10的数据需要怎么处理呢？

首先日志格式要求第一部分是时间，通过使用cat、grep、head、tail、awk来获取到开始、结束时间的行号，并计算出总共行数。最后通过cat、head、tail来获取指定范围的行。

添加extract.sh，内容如下


#!/bin/bash

# This is simple extract from log file in specified range time
# eg: ./extract.sh test.log "^10:00" "^11:00"


if [ $# -lt 2 ]; then
   echo "file name and filter are required"
   exit 2
fi

GET_START_ROW_NUM=`cat $1|grep $2 -n|head -n 1|awk -F ':' '{print $1}'`
START_ROW_NUM=$GET_START_ROW_NUM
END_ROW_NUM=0i
COUNT=0
FILE_NAME="$1.$2"
FILE_NAME="${FILE_NAME//\^/}"
FILE_NAME="${FILE_NAME//\:/}"
RESULT_STR="extract log from row num $START_ROW_NUM "


echo -e '\n******************** start ***********************\n'

if [ "$3" ]; then 

   GET_END_ROW_NUM=`cat $1|grep $3 -n|tail -n 1|awk -F ':' '{print $1}'` 
   END_ROW_NUM=$GET_END_ROW_NUM
   COUNT=$((END_ROW_NUM-START_ROW_NUM))
   FILE_NAME="${FILE_NAME//\^/}"
   FILE_NAME="${FILE_NAME//\:/}"
   RESULT_STR="$RESULT_STR to $END_ROW_NUM count=$COUNT"
   ## extract log in specified range time then write to file
   cat -n $1|tail -n +$START_ROW_NUM|head -n $COUNT > $FILE_NAME

else
   ## extract log in specified start time then write to file
   cat -n $1|tail -n +$START_ROW_NUM > $FILE_NAME

fi

echo "$RESULT_STR write to file $FILE_NAME"

echo -e '\n******************** end **************************\n'

使用方式

./extract.sh filename start_time [end_time]
#时间格式支持正则表达式

获取文件中16:10到17:10的数据

原数据

[root@user mylog]# cat test.log
......
此处省略N行
.....
16:09:04,973 INFO  [stdout] (StdoutThread) *********
16:09:04,973 INFO  [stdout] (StdoutThread) *********
16:09:04,973 INFO  [stdout] (StdoutThread) *********
16:09:04,973 INFO  [stdout] (StdoutThread) *********
16:09:04,973 INFO  [stdout] (StdoutThread) *********
16:10:04,973 INFO  [stdout] (StdoutThread) *********
16:10:04,973 INFO  [stdout] (StdoutThread) *********
16:10:04,973 INFO  [stdout] (StdoutThread) *********
16:10:04,973 INFO  [stdout] (StdoutThread) *********
16:10:04,973 INFO  [stdout] (StdoutThread) *********
......
此处省略N行
.....
17:10:04,973 INFO  [stdout] (StdoutThread) *********
17:10:04,973 INFO  [stdout] (StdoutThread) *********
17:10:04,973 INFO  [stdout] (StdoutThread) *********
17:10:04,973 INFO  [stdout] (StdoutThread) *********
17:10:04,973 INFO  [stdout] (StdoutThread) *********
17:11:04,973 INFO  [stdout] (StdoutThread) *********
17:11:04,973 INFO  [stdout] (StdoutThread) *********
17:11:04,973 INFO  [stdout] (StdoutThread) *********
17:11:04,973 INFO  [stdout] (StdoutThread) *********
17:11:04,973 INFO  [stdout] (StdoutThread) *********
......

执行提取命令

[root@user mylog]# ./extract.sh test.log "^16:10" "^17:10"

******************** start ***********************

extract log from row num 9  to 21 count=12 write to file test.log.1610.1710

******************** end **************************

结果数据

[root@user mylog]# cat test.log.1610.1710 
     9  16:10:04,973 INFO  [stdout] (StdoutThread) *********
    10  16:10:04,973 INFO  [stdout] (StdoutThread) *********
    11  16:10:04,973 INFO  [stdout] (StdoutThread) *********
    12  16:10:04,973 INFO  [stdout] (StdoutThread) *********
    13  16:10:04,973 INFO  [stdout] (StdoutThread) *********
    14  ......
    15  此处省略N行
    16 ......
    17  17:10:04,973 INFO  [stdout] (StdoutThread) *********
    18  17:10:04,973 INFO  [stdout] (StdoutThread) *********
    19  17:10:04,973 INFO  [stdout] (StdoutThread) *********
    20  17:10:04,973 INFO  [stdout] (StdoutThread) *********

docker install in centerOs 6.8

Sat, 18 Feb 2017 00:00:00 +0000

docker安装条件

docker容器运行于64位架构平台，内核版本为2.6.32-431及以上（即>=CentOS 6.5，运行docker时实际提示3.8.0及以上），需要注意的是CentOS 6.5与7.0的安装是有一点点不同的，CentOS-6上docker的安装包叫docker-io，并且来源于Fedora epel库，这个仓库维护了大量的没有包含在发行版中的软件，所以先要安装EPEL，而CentOS-7的docker直接包含在官方镜像源的Extras仓库（CentOS-Base.repo下的[extras]节enable=1启用）。下面将介绍在centerOs 6.8中的安装步骤。

添加EPEL资源库

rpm -iUvh http://dl.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm

yum update -y

安装docker-io

yum -y install docker-io

启动docker

service docker start

设置开机启动

chkconfig docker on

cat/tail/head

Fri, 10 Feb 2017 00:00:00 +0000

cat、tail、head命令

cat -n 文件路径|tail -n +5|head -n 6 // 显示 5 ～ 10 行的内容，包括5 和10

tail -n +iLinNum // 从ILinNum开始显示到结束的内容

tail -n iLinNum // 显示最后 iLinNum 行的内容

head -n iLinNum // 显示开头 iLinNum 行的内容

head -n +iLinNum // 同 head -n iLinNum

head

默认是显示开头前10行。

head /etc/passwd

显示开头前k行。

head -k /etc/passwd head -n k /etc/passwd（注意和下面的有-的区别） head -n +k /etc/passwd

除最后k行外，显示剩余全部内容。

head -n -k /etc/passwd

tail

语法 tail [-n -k ]… [FILE]…

例子默认是显示末尾10行。

tail /etc/passwd

显示末尾k行。

tail -k /etc/passwd tail -n k /etc/passwd（注意和下面的有+的区别） tail -n -k /etc/passwd

从开头第k行开始输出。

tail -n +k /etc/passwd

head和tail组合用法举例

//从第11行开始显示，但不包括最后3行

head -n -3 /etc/passwd |tail -n +11

//显示前20行，但从第11行开始

head -n 20 /etc/passwd |tail -n +11

//显示除最后3行以外的所有行，但只显示最后10行

head -n -3 /etc/passwd |tail -n 10

//显示前20行中的后10行

head -n 20 /etc/passwd |tail -n 10

//从第11行开始显示，但只显示前10行

tail -n +11 /etc/passwd |head -n 10

//从第11行开始显示，但不包括最后3行

tail -n +11 /etc/passwd |head -n -3

//显示最后13行中的前10行

tail -n 13 /etc/passwd |head -n 10

//显示最后13行中除末尾的3行以外的前10行

tail -n 13 /etc/passwd |head -n -3

nginx 配置(带注释)

Fri, 20 Jan 2017 00:00:00 +0000

#定义Nginx运行的用户和用户组
user www www;

#nginx进程数，建议设置为等于CPU总核心数。
worker_processes 8;

#全局错误日志定义类型，[ debug | info | notice | warn | error | crit ]
error_log /var/log/nginx/error.log info;

#进程文件
pid /var/run/nginx.pid;

#一个nginx进程打开的最多文件描述符数目，理论值应该是最多打开文件数（系统的值ulimit -n）与nginx进程数相除，但是nginx分配请求并不均匀，所以建议与ulimit -n的值保持一致。
worker_rlimit_nofile 65535;

#工作模式与连接数上限
events
{
#参考事件模型，use [ kqueue | rtsig | epoll | /dev/poll | select | poll ]; epoll模型是Linux 2.6以上版本内核中的高性能网络I/O模型，如果跑在FreeBSD上面，就用kqueue模型。
use epoll;
#单个进程最大连接数（最大连接数=连接数*进程数）
worker_connections 65535;
}

#设定http服务器
http
{
include mime.types; #文件扩展名与文件类型映射表
default_type application/octet-stream; #默认文件类型
#charset utf-8; #默认编码
server_names_hash_bucket_size 128; #服务器名字的hash表大小
client_header_buffer_size 32k; #上传文件大小限制
large_client_header_buffers 4 64k; #设定请求缓
client_max_body_size 8m; #设定请求缓
sendfile on; #开启高效文件传输模式，sendfile指令指定nginx是否调用sendfile函数来输出文件，对于普通应用设为 on，如果用来进行下载等应用磁盘IO重负载应用，可设置为off，以平衡磁盘与网络I/O处理速度，降低系统的负载。注意：如果图片显示不正常把这个改成off。
autoindex on; #开启目录列表访问，合适下载服务器，默认关闭。
tcp_nopush on; #防止网络阻塞
tcp_nodelay on; #防止网络阻塞
keepalive_timeout 120; #长连接超时时间，单位是秒

#FastCGI相关参数是为了改善网站的性能：减少资源占用，提高访问速度。下面参数看字面意思都能理解。
fastcgi_connect_timeout 300;
fastcgi_send_timeout 300;
fastcgi_read_timeout 300;
fastcgi_buffer_size 64k;
fastcgi_buffers 4 64k;
fastcgi_busy_buffers_size 128k;
fastcgi_temp_file_write_size 128k;

#gzip模块设置
gzip on; #开启gzip压缩输出
gzip_min_length 1k; #最小压缩文件大小
gzip_buffers 4 16k; #压缩缓冲区
gzip_http_version 1.0; #压缩版本（默认1.1，前端如果是squid2.5请使用1.0）
gzip_comp_level 2; #压缩等级
gzip_types text/plain application/x-javascript text/css application/xml;
#压缩类型，默认就已经包含text/html，所以下面就不用再写了，写上去也不会有问题，但是会有一个warn。
gzip_vary on;
#limit_zone crawler $binary_remote_addr 10m; #开启限制IP连接数的时候需要使用

upstream blog.ha97.com {
#upstream的负载均衡，weight是权重，可以根据机器配置定义权重。weigth参数表示权值，权值越高被分配到的几率越大。
server 192.168.80.121:80 weight=3;
server 192.168.80.122:80 weight=2;
server 192.168.80.123:80 weight=3;
}

#虚拟主机的配置
server
{
#监听端口
listen 80;
#域名可以有多个，用空格隔开
server_name www.ha97.com ha97.com;
index index.html index.htm index.php;
root /data/www/ha97;
location ~ .*\.(php|php5)?$
{
fastcgi_pass 127.0.0.1:9000;
fastcgi_index index.php;
include fastcgi.conf;
}
#图片缓存时间设置
location ~ .*\.(gif|jpg|jpeg|png|bmp|swf)$
{
expires 10d;
}
#JS和CSS缓存时间设置
location ~ .*\.(js|css)?$
{
expires 1h;
}
#日志格式设定
log_format access '$remote_addr - $remote_user [$time_local] "$request" '
'$status $body_bytes_sent "$http_referer" '
'"$http_user_agent" $http_x_forwarded_for';
#定义本虚拟主机的访问日志
access_log /var/log/nginx/ha97access.log access;

#对 "/" 启用反向代理
location / {
proxy_pass http://127.0.0.1:88;
proxy_redirect off;
proxy_set_header X-Real-IP $remote_addr;
#后端的Web服务器可以通过X-Forwarded-For获取用户真实IP
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
#以下是一些反向代理的配置，可选。
proxy_set_header Host $host;
client_max_body_size 10m; #允许客户端请求的最大单文件字节数
client_body_buffer_size 128k; #缓冲区代理缓冲用户端请求的最大字节数，
proxy_connect_timeout 90; #nginx跟后端服务器连接超时时间(代理连接超时)
proxy_send_timeout 90; #后端服务器数据回传时间(代理发送超时)
proxy_read_timeout 90; #连接成功后，后端服务器响应时间(代理接收超时)
proxy_buffer_size 4k; #设置代理服务器（nginx）保存用户头信息的缓冲区大小
proxy_buffers 4 32k; #proxy_buffers缓冲区，网页平均在32k以下的设置
proxy_busy_buffers_size 64k; #高负荷下缓冲大小（proxy_buffers*2）
proxy_temp_file_write_size 64k;
#设定缓存文件夹大小，大于这个值，将从upstream服务器传
}

#设定查看Nginx状态的地址
location /NginxStatus {
stub_status on;
access_log on;
auth_basic "NginxStatus";
auth_basic_user_file conf/htpasswd;
#htpasswd文件的内容可以用apache提供的htpasswd工具来产生。
}

#本地动静分离反向代理配置
#所有jsp的页面均交由tomcat或resin处理
location ~ .(jsp|jspx|do)?$ {
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_pass http://127.0.0.1:8080;
}
#所有静态文件由nginx直接读取不经过tomcat或resin
location ~ .*.(htm|html|gif|jpg|jpeg|png|bmp|swf|ioc|rar|zip|txt|flv|mid|doc|ppt|pdf|xls|mp3|wma)$
{ expires 15d; }
location ~ .*.(js|css)?$
{ expires 1h; }
}
}

nginx config

Fri, 20 Jan 2017 00:00:00 +0000

Nginx的配置

user  www www;
worker_processes  4;

error_log  logs/error.log crit;
#error_log  logs/error.log  notice;
#error_log  logs/error.log  info;

pid        logs/nginx.pid;

events {
    use epoll;
    worker_connections  65535;
}

# load modules compiled as Dynamic Shared Object (DSO)
#
#dso {
#    load ngx_http_fastcgi_module.so;
#    load ngx_http_rewrite_module.so;
#}

http {
    include       mime.types;
    default_type  application/octet-stream;

    #log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
    #                  '$status $body_bytes_sent "$http_referer" '
    #                  '"$http_user_agent" "$http_x_forwarded_for"';

    #access_log  logs/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    #keepalive_timeout  0;
    keepalive_timeout  65;

    gzip  on;
    gzip_http_version 1.1;
    gzip_vary on;
    gzip_comp_level 6;
    gzip_proxied any; 
    gzip_types text/plain text/html text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript application/javascript text/x-js;
    gzip_buffers 16 8k; 
    gzip_disable "MSIE [1-6]\.(?!.*SV1)";

    proxy_cache_path /var/nginx/cache levels=1:2 keys_zone=akosha_cache:60m inactive=90m max_size=1000m;


    upstream rewrite_api {
      server 127.0.0.1:4000;
      server 127.0.0.1:4000 backup;
    }

    server {
        listen       80;
        server_name  localhost;

        #charset koi8-r;

        #access_log  logs/host.access.log  main;

        location / {
            root   /data/www;
            index  index.html index.htm;
            if ($request_uri ~* ".(jpg|jpeg|gif|gz|zip|flv|rar|wmv|avi|css|swf|png|htc|ico|mpeg|mpg|txt|mp3|mov|js)(\?v=[0-9.]+)?$") {
               expires 30d;
               access_log off;
               break;
            }
        }

        #error_page  404              /404.html;

        # redirect server error pages to the static page /50x.html
        #
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }
		
        location /api {
           proxy_pass http://127.0.0.1:3000;
        }

        location /rewriteApi {
           rewrite ^/rewriteApi/(.*) /$1 break;
           proxy_pass http://rewrite_api/;
        }

        # proxy the PHP scripts to Apache listening on 127.0.0.1:80
        #
        #location ~ \.php$ {
        #    proxy_pass   http://127.0.0.1;
        #}

        # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
        #
        #location ~ \.php$ {
        #    root           html;
        #    fastcgi_pass   127.0.0.1:9000;
        #    fastcgi_index  index.php;
        #    fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;
        #    include        fastcgi_params;
        #}

        # deny access to .htaccess files, if Apache's document root
        # concurs with nginx's one
        #
        #location ~ /\.ht {
        #    deny  all;
        #}
    }


    # another virtual host using mix of IP-, name-, and port-based configuration
    #
    #server {
    #    listen       8000;
    #    listen       somename:8080;
    #    server_name  somename  alias  another.alias;

    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}


    # HTTPS server
    #
    #server {
    #    listen       443 ssl;
    #    server_name  localhost;

    #    ssl_certificate      cert.pem;
    #    ssl_certificate_key  cert.key;

    #    ssl_session_cache    shared:SSL:1m;
    #    ssl_session_timeout  5m;

    #    ssl_ciphers  HIGH:!aNULL:!MD5;
    #    ssl_prefer_server_ciphers  on;

    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}

}

nginx 403 forbidden

Fri, 20 Jan 2017 00:00:00 +0000

Nginx 403的问题一般是目录是否存在以及是否有权限引起的问题。

目前是否存在

可以根据nginx的访问日志、错误日志排查访问的路径，然后确认路径是否正确。

权限问题

# chmod 777 /data/www

修改nginx的启动用户,在conf配置文件中，把用户改成root

user  nginx; // 修改成 user root
worker_processes  1;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;
    proxy_read_timeout 1000;

    gzip  on;
    gzip_min_length  1k;
    gzip_buffers     4 16k;
    gzip_http_version 1.0;
    gzip_comp_level 3;
    gzip_types     text/plain application/javascript application/x-javascript text/css application/xml text/xml;
    gzip_vary on;
    
    client_max_body_size 100m;
    include /etc/nginx/conf.d/*.conf;
}

selinux访问限制

若上面的方法还是不行，则查看selinux的状态是否启动

# getenforce

若启动则关闭

临时关闭（不用重启机器）

# setenforce 0  // 设置SELinux 成为permissive模式
                // setenforce 1 设置SELinux 成为enforcing模式

永久关闭，修改配置文件需要重启机器

修改/etc/selinux/config 文件, 将SELINUX=enforcing改为SELINUX=disabled,重启机器即可

Efficient String Concatenation in Go

Thu, 12 Jan 2017 00:00:00 +0000

Go中的高效字符串拼接

本文将比较Go语言中各种不同的字符串拼接方法的性能。为了比较，准备了一些基准测试指标，程序如下

func BenchmarkBufferString(b *testing.B, numConcat int) {
    var ns string
    for i := 0; i < b.N; i++ {
        next := nextString()
        buffer := bytes.NewBufferString("")
        for u := 0; u < numConcat; u++ {
            buffer.WriteString(next())
        }
        ns = buffer.String()
    }
    global = ns
}

为了测试这些指标，我想需要一个方法返回一些字符串，然后把这些字符串拼接成一个新的字符串。这边写了个简单的方法，每次调用返回当前的索引值：

// nextString is an iterator we use to represent a process
// that returns strings that we want to concatenate in order.
func nextString() func() string {
    n := 0
    // closure captures variable n
    return func() string {
        n += 1
        return strconv.Itoa(n)
    }
}

我们测试的方法都会在循环中调用上面的方法，最后的输入如：0123456789101112131415…。考虑到函数调用的开销，因为都有函数调用开销，所以可以忽略不计。现在已经设置好了测试基准，让我们来看看这些方法的的测试性能

方法1：+=

最直接的拼接字符串的方法是使用+=。由于Go中的字符串是不可变的，所以每次字符串的拼接都会生成新的字符串，分配新的内存来存储，这与C++和Basic是不同的。在Go中，每次拼接2个字符串，都会创建一个新的字符串空间，并拷贝2个字符串。当拼接的字符串长度过长时，拷贝会变的很慢，这种方法的时间复杂度是O(N^2)。

方法2：strings.Join

Go的标准库strings提供了join的方法，该方法可以把一个字符串数组拼接在一起。在本次测试例子中，因为没有字符串数组，所以首先需要构建一个字符串数组，构建字符串数组会消耗一些时间，所以会把这部分时间算在测试基准当中。最终拼接会消耗O(N)，但构建字符串消耗了O(N)（平均值），空间消耗O(N)（字符串数组所消耗的空间）。

这边有个使用strings.Join的例子

s := []string{}
for i := 0; i < 1000; i++ {
    s = append(s, "a")
}
fmt.Println(strings.Join(s, ""))

方法3：bytes.Buffer

最后一种方式是使用Go中bytes包的Buffer类型，bytes.Buffer实现了io.Writer，可以在O(N)的时间复杂度下完成字符串的拼接，同时无需额外的内存空间来储存字符串数组。

下面是使用bytes.Buffer的例子

var buffer bytes.Buffer
for i := 0; i < 1000; i++ {
    buffer.WriteString("a")
}
fmt.Println(buffer.String())

现在已经了解完了3种字符串拼接的方法，下面开始执行测试，我会先跳过各种测试中的具体过程，直接来看下那个方法最优。

最佳的是方法3：bytes.Buffer

方法3是最佳的方式，但并不是在所有情况下。下面是比较3种方式，在10000个字符串（小于5个字符），共37KB下时候的测试情况

– 图片 –

上图展示了bytes.Buffer以很大的优势获胜

下面看下每次25个字符，共244KB的情况

– 图片 –

看上去strings.Join和bytes.Buffer差不多，但是还是没bytes.Buffer优秀

我也测试了一些小数量的字符串拼接，这种情况下方法1：+=还是稍微比其他方法快些，所以方法1还是可以用于小量的字符串拼接。

最后，让我们看下方法2中，字符串数组构建的影响有多大。排除字符串数组构建的耗时，同时在遍历时调用nextString，所以测试还是公平的，在来看下测试结果

– 图片 –

当我们忽略方法2的字符串数组构建消耗，那么方法2比方法3略胜一筹。

总结

综上，对于小量的短字符串（少于100个，长度小于10）拼接使用方法1。对于大量字符串，同时需要高效率时，使用方法3，bytes.Buffer是3种方法中最好的。对于需要对已有的字符串数组进行拼接时，使用方法2。

测试过程

下面是对于不同方法，不同拼接数量在我机器（Go 1.2 on Ubuntu 64bit, Intel® Core™ i7-3667U CPU @ 2.00GHz）上执行go test -bench的结果


BenchmarkNaiveConcat10    500000          6403 ns/op
BenchmarkNaiveConcat100    20000         77001 ns/op
BenchmarkNaiveConcat1000         500       3105361 ns/op
BenchmarkNaiveConcat10000          5     236872134 ns/op
BenchmarkJoin10   200000          8129 ns/op
BenchmarkJoin100       50000         51891 ns/op
BenchmarkJoin1000       5000        465179 ns/op
BenchmarkJoin10000       500       5911317 ns/op
BenchmarkBufferString10   200000          7688 ns/op
BenchmarkBufferString100       50000         45027 ns/op
BenchmarkBufferString1000       5000        398311 ns/op
BenchmarkBufferString10000       500       3702906 ns/op

你也可以自己执行下，代码下载https://github.com/hermanschaaf/go-string-concat-benchmarks。一般的测试基准如下


var global string

// benchmarkNaiveConcat provides a benchmark for basic built-in
// Go string concatenation. Because strings are immutable in Go,
// it performs the worst of the tested methods. The time taken to
// set up the array that is appended is not counted towards the
// time for naive concatenation.
func benchmarkNaiveConcat(b *testing.B, numConcat int) {
    var ns string
    for i := 0; i < b.N; i++ {
        next := nextString()
        ns = ""
        for u := 0; u < numConcat; u++ {
            ns += next()
        }
    }
    // we assign to a global variable to make sure compiler
    // or runtime optimizations don't skip over the operations
    // we were benchmarking. This might be unnecessary, but it's
    // safer.
    global = ns
}

参考资料

http://herman.asia/efficient-string-concatenation-in-go

idiomatic go

Thu, 12 Jan 2017 00:00:00 +0000

Go的编码风格

在编码和重构时，go有些惯用方法，下面介绍一些惯用方法。

某些单词的拼写要保持一致性

正确方式


// marshaling
// unmarshaling
// canceling
// cancelation

错误方式

// marshalling
// unmarshalling
// cancelling
// cancellation

某些单词有多种拼写方式，Go有选择其中一个，并在项目编码中保持一致性。参考对比this vs this

句子间使用一个空格

正确方式

// Sentence one. Sentence two.

错误方式

// Sentence one.  Sentence two.

错误变量的命名

正确方式

// Package level exported error.
var ErrSomething = errors.New("something went wrong")

func main() {
	// Normally you call it just "err",
	result, err := doSomething()
	// and use err right away.

	// But if you want to give it a longer name, use "somethingError".
	var specificError error
	result, specificError = doSpecificThing()

	// ... use specificError later.
}

错误方式

var ErrorSomething = errors.New("something went wrong")
var SomethingErr = errors.New("something went wrong")
var SomethingError = errors.New("something went wrong")

func main() {
	var specificErr error
	result, specificErr = doSpecificThing()

	var errSpecific error
	result, errSpecific = doSpecificThing()

	var errorSpecific error
	result, errorSpecific = doSpecificThing()
}

品牌或单词开头大写，其他都小写

正确方式

// Exported.
var OAuthEnabled bool
var GitHubToken string

// Unexported.
var oauthEnabled bool
var githubToken string

错误方式

// Unexported.
var oAuthEnabled bool
var gitHubToken string

添加注释时在双划线后面添加一个空格

正确方式

// This is a comment
// for humans.

错误方式

//This is a comment
//for humans.

注意，注释是不添加空格的

//go:generate go run gen.go

使用defer时，必须保证所带来影响是可忽略的，或者可以增强可读性

若不能增强可读性，如函数只有1-2步就执行完了，那么就不要使用它。

显然，使用defer会带来性能的影响，特别是在秒级操作方法上。

defer的性能测试

包的名称使用单数形式

正确方式

golang.org/x/example/hello
golang.org/x/example/outyet
golang.org/x/mobile/example/basic
golang.org/x/mobile/example/flappy
github.com/shurcooL/tictactoe/player/bad
github.com/shurcooL/tictactoe/player/random

错误方式

golang.org/x/examples/hello
golang.org/x/examples/outyet
golang.org/x/mobile/examples/basic
golang.org/x/mobile/examples/flappy
github.com/shurcooL/tictactoe/players/bad
github.com/shurcooL/tictactoe/players/random

这是为了和go的命名风格保持一致

避免未使用的函数对象变量

正确方式

func (foo) method() {
	...
}

错误方式

func (f foo) method() {
	...
}

如果f未使用，那么可以清楚的知道，foo的方法和属性在method方法中未使用，增强了可读性。

空字符串校验

正确方式

if str == "" {
	...
}

错误方式

if len(str) == 0 {
	...
}

使用len来校验空字符串是正确的，但是len更适合在其他情况下使用。

第一种方式更具有可读性，可以清楚的字段str是字符串而不是数组

互斥锁保护罩

struct {
	...

	rateMu     sync.Mutex
	rateLimits [categories]Rate
	mostRecent rateLimitCategory
}

这里rateMu是一个互斥锁保护罩，它位于所保护的变量的顶部，好比一个帽子一样。所以无需对修改变量进行注释，和下面的效果是一样的。

struct {
	...

	// rateMu protects rateLimits and mostRecent.
	rateMu     sync.Mutex
	rateLimits [categories]Rate
	mostRecent rateLimitCategory
}

但新增无需rateMu保护的变量时，添加一个空行隔开

正确方式


 struct {
 	...

 	rateMu     sync.Mutex
 	rateLimits [categories]Rate
 	mostRecent rateLimitCategory
+
+	common service
 }

错误方式


 struct {
 	...

 	rateMu     sync.Mutex
 	rateLimits [categories]Rate
 	mostRecent rateLimitCategory
+	common     service
 }

不要在flag.Usage中使用os.Exit(2)

正确方式

 flag.Usage = func() {
	fmt.Fprintf(os.Stderr, "Usage of %s:\n", os.Args[0])
	flag.PrintDefaults()
 }

错误方式

flag.Usage = func() {
	fmt.Fprintf(os.Stderr, "Usage of %s:\n", os.Args[0])
	flag.PrintDefaults()
	os.Exit(2)
}

flag包的Usage在处理错误时，已经有对退出进行处理，所以无需再次调用os.Exit(2)

参考资料

https://dmitri.shuralyov.com/idiomatic-go

Goroutine Leak

Thu, 12 Jan 2017 00:00:00 +0000

https://medium.com/golangspec/goroutine-leak-400063aef468#.vg3rkk71v

Go walkthrough io package

Thu, 12 Jan 2017 00:00:00 +0000

https://medium.com/go-walkthrough/go-walkthrough-io-package-8ac5e95a9fbd#.3rb90zu8d

channel buffer vs unbuffer

Sat, 03 Dec 2016 00:00:00 +0000

下面介绍下channel有缓冲区和无缓冲区的区别：

无缓冲区的channel会同时阻塞发送方和接收方，直到双方都准备好。有缓冲区的channel只会在缓冲区满后阻塞发送方。

下面是一个小例子


var c = make(chan int, 5)

func main() {
  go worker(1)
  for i := 0; i < 10; i++ {
    c <- i
    println(i)
  }
}

func worker(id int) {
  for {
    _ = <-c
    time.Sleep(time.Second)
  }
}

上面例子中有一个缓冲区大小为5的channel和一个每次接收数据都睡眠1秒的worker。很明显channel的缓冲区会被快速的填满数据然后阻塞，直到worker开始消费数据。

0
1
2
3
4
5
6 // 等1秒后输出
7 // 等1秒后输出
8 // 等1秒后输出
9 // 等1秒后输出

你会看到0,1,2,3,4,5立即输出，然后6,7,8,9每秒输出一个。因为缓冲区大小为5，当缓冲区填满的过程中，worker也是准备好了接收，在0-4的过程中，worker会接开始接收，在接收后进入sleep一秒，此时缓冲区会被继续填满。所以会看到0-5很快输出，后续每秒输出一次，即worker消费一个缓冲区立即补充一个并阻塞。

缓冲区的channel有何用处呢？让我们来看个简单但是真实的例子：记录web服务请求的日志。我们要记录的服务请求，在并发量大时请求数会达到几千个每秒，为了提高性能，我们会先把日志缓存在内存中，并定时写到硬盘上。先来看下无缓冲区的channel实现：

var channel = make(chan []byte)
func init() {
  go worker(8192)
}

func Log(req *http.Request) {
  channel <- createLog(req)
}

func createLog(req *http.Request) []byte {
  var buffer bytes.Buffer
  buffer.Write([]byte(req.RemoteAddr))
  buffer.Write([]byte("\t"))
  buffer.Write([]byte(req.URL.Path))
  buffer.Write([]byte("\n"))
  return buffer.Bytes()
}

func worker(size int) {
  buffer := make([]byte, size)
  position := 0
  for {
    entry := <- channel
    length := len(entry)
    if length > size {
      //todo handle a message that we can't fit in our buffer (log an error? save directly to disk?)
    }
    if (length + position) > size {
      //todo flush buffer to disk
      //we'll want to write buffer[0:position] to avoid including data from a previous pass
      position = 0
    }
    copy(buffer[position:], entry)
    position += length
  }
}

首先，声明了一个channel和worker，Log方法会根据request构造日志信息并发送给channel，worker会从channel中接收到日志信息，并判断缓存是否还有空间，若有则放到缓存，否则先把缓存中的数据写入硬盘中。

顺便提一下，上面重用了[]byte array，以减少内存分配和垃圾回收。

在正常情况下，能够运行的很好，因为都是在内存中复制bytes。但是当缓存数据需要写入硬盘时，处理request的goroutine将会阻塞当往channel写日志信息时 (channel <- createLog(req))。如何解决？可以通过缓冲区和更多的worker来解决，只需部分改动下：


const workerCount = 4
var channel = make(chan []byte, workerCount)
func init() {
  for i := 0; i < workerCount; i++ {
    go worker(8192)
  }
}

当一个worker在忙于写硬盘时，其他空闲worker可以继续处理日志信息。

原文 http://openmymind.net/Introduction-To-Go-Buffered-Channels/

NSQ的特性和可靠性

Sun, 06 Nov 2016 00:00:00 +0000

NSQ是一个实时分布式消息平台

特性

支持分布式拓扑结构，无单点故障问题
支持横向扩展，无中间人（brokers），可无缝添加多个节点到集群中
基于推送的低延迟消息投递
结合负载均衡和广播的消息路由方式
擅长流（高吞吐）和面向job（低吞吐）的工作负载
内存优先（超过内存队列的消息将写入硬盘中）
消费者可在运行时发现生产者的服务
TLS加密传输
消息数据无格式要求
很少依赖，简单部署，沙箱，有默认配置
在统计、管理和生产者的信息方面都有http接口
整合了实时仪表工具statsd
强大的集群管理接口

可靠性

消息默认不持久化

虽然nsq支持“漏气阀”（–mem-queue-size），消息数量超过消息队列阀门时，消息会被写入硬盘，但是nsq主要还是一个内存消息平台

–mem-queue-size可以设置为0，保证所有的消息被持久化到硬盘。如果nsq的挂了之后，可尽可能的降低影响范围。

消息至少投递一次

意味着消息可以被投递多次（消费者超时、连接断开、重新入列等）。消费者要确保消息操作的幂等性。

消息接收是无序的

你不能依赖于消息投递的顺序，这是因为消息重新入列、内存消息和硬盘消息的结合、每个nsq节点并不共享消息。

消费者最终可以找到所有的消息生产者

服务发现（nsqlookup）的设计是基于最终一致性，nsqlookup并不协调状态或者应答

Ichennan

Install Cronolog

install cronolog

Start And Shutdown

start.sh

shutdown.sh

build parent project

通过父项目来管理多个模块的子项目

父项目pom配置

WebProject的pom配置

jenkins pipline config demo

Linux Tar

nginx introduction

Nginx简介

为什么要使用Nginx

Nginx主要特点

Nginx的设计架构

核心指令

核心模块

核心架构

Nginx的应用

web服务

反向代理

负载均衡

Centos Install Go1.7 Git Cronolog

install git

install go1.7

method1

mehtod2

config go env

参考资料

Best Practices For Rest

extract log in specified range time

提取某段时间内的日志

使用场景

添加extract.sh，内容如下

使用方式

docker install in centerOs 6.8

docker安装条件

添加EPEL资源库

安装docker-io

启动docker

设置开机启动

cat/tail/head

cat、tail、head命令

head

tail

head和tail组合用法举例

nginx 配置(带注释)

nginx config

Nginx的配置

nginx 403 forbidden

目前是否存在

权限问题

selinux访问限制

Efficient String Concatenation in Go

Go中的高效字符串拼接

方法1：+=

方法2：strings.Join

方法3：bytes.Buffer

最佳的是 方法3：bytes.Buffer

总结

测试过程

参考资料

idiomatic go

Go的编码风格

某些单词的拼写要保持一致性

句子间使用一个空格

错误变量的命名

品牌或单词开头大写，其他都小写

添加注释时在双划线后面添加一个空格

使用defer时，必须保证所带来影响是可忽略的，或者可以增强可读性

包的名称使用单数形式

避免未使用的函数对象变量

空字符串校验

互斥锁保护罩

不要在flag.Usage中使用os.Exit(2)

参考资料

Goroutine Leak

Go walkthrough io package

最佳的是方法3：bytes.Buffer