Nginx作为中继服务器的时候身份是属于client，那么ip就会被固定，server端ip:port也是固定，那么连接数就受限于Nginx服务器本身的port数量：65535（实际上达不到，会有保留端口）。

因此，可以为Nginx服务器一个网卡配置多个IP，通过增加client端的ip数量来突破限制。Nginx的proxy_bind虽然只能设置单一IP，没办法直接配置数组，但是可以设置变量（也支持透明传输），因此我们可以在不同的请求中对这个变量赋不同的IP，这样就能达到多出口的目的了。split_clients就可以帮我们完成上述功能。

配置文件如下：
```
http {
    ...
     upstream backend {
         server your_proxy_domain;
    }
    server {
        listen 80 default_server;
        server_name _;
        location / {
            proxy_pass http://backend;
            proxy_bind $split_ip;
            proxy_set_header X-Forwarded-For $remote_addr;
        }
    }
    # 只要请求过来，就会根据“uri+客户端端口”计算hash值，选出一个$split_ip，并赋给proxy_bind指令proxy_bind指定，就此玩成了多出口IP的配置
    split_clients "$request_uri$remote_port" $split_ip {
        33%    192.168.16.128;
        33%    192.168.16.129;
        *      192.168.16.130;
    }
}
```
至此，Nginx改造完成，通过增加多个网卡或者IP则单台Nginx对外发起的Connect成倍增加，突破65535限制。

Nginx多出口IP解决代理端口数量限制

# 一、vnstat使用，查看接口统计报告
安装：
yum install  vnstat-1.15-2.el7.x86_64


![image.png](https://blog.sudoeasy.com/static/img/907393fd3010bc559fcff26fdf9990ab.image.png)

# 二、iftop使用，检查带宽使用情况
安装：yum install iftop-1.0-0.21.pre4.el7.x86_64

iftop可以用来监控网卡的实时流量（可以指定网段）、反向解析IP、显示端口信息等

**命令用法：**

-i设定监测的网卡，如：# iftop -i eth1

-B 以bytes为单位显示流量(默认是bits)，如：# iftop -B

-n使host信息默认直接都显示IP，如：# iftop -n

-N使端口信息默认直接都显示端口号，如: # iftop -N

**交互命令：**

按n切换显示本机的IP或主机名;

按s切换是否显示本机的host信息;

按d切换是否显示远端目标主机的host信息;

按t切换显示格式为2行/1行/只显示发送流量/只显示接收流量;

按N切换显示端口号或端口服务名称;

按S切换是否显示本机的端口信息;

按D切换是否显示远端目标主机的端口信息;

按p切换是否显示端口信息;


![image.png](https://blog.sudoeasy.com/static/img/5b3fdbd05e0f59390ad60d2bc46535a8.image.png)

# 三、nethogs使用，按进程实时统计网络带宽利用率(推荐)
命令用法：

1、设置5秒钟刷新一次，通过-d来指定刷新频率：nethogs -d 5

2、监视eth0网络带宽 :nethogs eth0

3、同时监视eth0和eth1接口 : nethogs eth0 eth1
交互命令：
以下是NetHogs的一些交互命令(键盘快捷键)

m : 修改单位
r : 按流量排序
s : 按发送流量排序
q : 退出命令提示符


![image.png](https://blog.sudoeasy.com/static/img/a2a1d4867464651659562d0dceef6163.image.png)


Linux查看进程占用网速和流量使用情况的三个命令：vnstat、iftop、nethogs

nginx全解析

## 改之前

在使用 `gin` 开发接口的时候，返回接口数据是这样写的。

```
type response struct {
	Code int         `json:"code"`
	Msg  string      `json:"msg"`
	Data interface{} `json:"data"`
}

// always return http.StatusOK
c.JSON(http.StatusOK, response{
	Code: 20101,
	Msg:  "用户手机号不合法",
	Data: nil,
})
```

这种写法 `code`、`msg` 都是在哪需要返回在哪定义，没有进行统一管理。

## 改之后

```
// 比如，返回“用户手机号不合法”错误
c.JSON(http.StatusOK, errno.ErrUserPhone.WithID(c.GetString("trace-id")))

// 正确返回
c.JSON(http.StatusOK, errno.OK.WithData(data).WithID(c.GetString("trace-id")))
```

`errno.ErrUserPhone`、`errno.OK` 表示自定义的错误码，下面会看到定义的地方。

`.WithID()` 设置当前请求的唯一ID，也可以理解为链路ID，忽略也可以。

`.WithData()` 设置成功时返回的数据。

下面分享下编写的 `errno` 包源码，非常简单，希望大家不要介意。

## errno 包源码

```
// errno/errno.go

package errno

import (
	"encoding/json"
)

var _ Error = (*err)(nil)

type Error interface {
	// i 为了避免被其他包实现
	i()
	// WithData 设置成功时返回的数据
	WithData(data interface{}) Error
	// WithID 设置当前请求的唯一ID
	WithID(id string) Error
	// ToString 返回 JSON 格式的错误详情
	ToString() string
}

type err struct {
	Code int         `json:"code"`         // 业务编码
	Msg  string      `json:"msg"`          // 错误描述
	Data interface{} `json:"data"`         // 成功时返回的数据
	ID   string      `json:"id,omitempty"` // 当前请求的唯一ID，便于问题定位，忽略也可以
}

func NewError(code int, msg string) Error {
	return &err{
		Code: code,
		Msg:  msg,
		Data: nil,
	}
}

func (e *err) i() {}

func (e *err) WithData(data interface{}) Error {
	e.Data = data
	return e
}

func (e *err) WithID(id string) Error {
	e.ID = id
	return e
}

// ToString 返回 JSON 格式的错误详情
func (e *err) ToString() string {
	err := &struct {
		Code int         `json:"code"`
		Msg  string      `json:"msg"`
		Data interface{} `json:"data"`
		ID   string      `json:"id,omitempty"`
	}{
		Code: e.Code,
		Msg:  e.Msg,
		Data: e.Data,
		ID:   e.ID,
	}

	raw, _ := json.Marshal(err)
	return string(raw)
}

```

```
// errno/code.go

package errno

var (
	// OK
	OK = NewError(0, "OK")

	// 服务级错误码
	ErrServer    = NewError(10001, "服务异常，请联系管理员")
	ErrParam     = NewError(10002, "参数有误")
	ErrSignParam = NewError(10003, "签名参数有误")

	// 模块级错误码 - 用户模块
	ErrUserPhone   = NewError(20101, "用户手机号不合法")
	ErrUserCaptcha = NewError(20102, "用户验证码有误")

	// ...
)
```

## 错误码规则

- 错误码需在 `code.go` 文件中定义。
- 错误码需为 > 0 的数，反之表示正确。

#### 错误码为 5 位数 

| 1 | 01 | 01 |
| :------ | :------ | :------ |
| 服务级错误码 | 模块级错误码 | 具体错误码 |

- 服务级别错误码：1 位数进行表示，比如 1 为系统级错误；2 为普通错误，通常是由用户非法操作引起。
- 模块级错误码：2 位数进行表示，比如 01 为用户模块；02 为订单模块。
- 具体错误码：2 位数进行表示，比如 01 为手机号不合法；02 为验证码输入错误。



06-统一定义 API 错误码

## 概述

开始今天的文章，为什么要自定义错误处理？默认的错误处理方式是什么？

那好，咱们就先说下默认的错误处理。

默认的错误处理是 `errors.New("错误信息")`，这个信息通过 error 类型的返回值进行返回。

举个简单的例子：

```
func hello(name string) (str string, err error) {
	if name == "" {
		err = errors.New("name 不能为空")
		return
	}
	str = fmt.Sprintf("hello: %s", name)
	return
}
```

当调用这个方法时：

```
var name = ""
str, err :=  hello(name)
if err != nil {
	fmt.Println(err.Error())
	return
}
```

这就是默认的错误处理，下面还会用这个例子进行说。

这个默认的错误处理，只是得到了一个错误信息的字符串。

然而...

我还想得到发生错误时的 `时间`、`文件名`、`方法名`、`行号` 等信息。

我还想得到错误时进行告警，比如 `短信告警`、`邮件告警`、`微信告警` 等。

我还想调用的时候，不那么复杂，就和默认错误处理类似，比如：

```
alarm.WeChat("错误信息")
return
```

这样，我们就得到了我们想要的信息（`时间`、`文件名`、`方法名`、`行号`），并通过 `微信` 的方式进行告警通知我们。

同理，`alarm.Email("错误信息")`、`alarm.Sms("错误信息")` 我们得到的信息是一样的，只是告警方式不同而已。

还要保证，我们业务逻辑中，获取错误的时候，只获取错误信息即可。

上面这些想出来的，就是今天要实现的，自定义错误处理，我们就实现之前，先说下 Go 的错误处理。

## 错误处理

```
package main

import (
	"errors"
	"fmt"
)

func hello(name string) (str string, err error) {
	if name == "" {
		err = errors.New("name 不能为空")
		return
	}
	str = fmt.Sprintf("hello: %s", name)
	return
}

func main() {
	var name = ""
	fmt.Println("param:", name)

	str, err := hello(name)
	if err != nil {
		fmt.Println(err.Error())
		return
	}

	fmt.Println(str)
}
```

输出：

```
param: Tom
hello: Tom
```

当 name = "" 时，输出：

```
param:
name 不能为空
```

建议每个函数都要有错误处理，error 应该为最后一个返回值。

咱们一起看下官方 errors.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 implements functions to manipulate errors.
package errors

// New returns an error that formats as the given text.
func New(text string) error {
	return &errorString{text}
}

// errorString is a trivial implementation of error.
type errorString struct {
	s string
}

func (e *errorString) Error() string {
	return e.s
}
```

上面的代码，并不复杂，参照上面的，咱们进行写一个自定义错误处理。

## 自定义错误处理

咱们定义一个 alarm.go，用于处理告警。

废话不多说，直接看代码。

```
package alarm

import (
	"encoding/json"
	"fmt"
	"ginDemo/common/function"
	"path/filepath"
	"runtime"
	"strings"
)

type errorString struct {
	s string
}

type errorInfo struct {
	Time     string `json:"time"`
	Alarm    string `json:"alarm"`
	Message  string `json:"message"`
	Filename string `json:"filename"`
	Line     int    `json:"line"`
	Funcname string `json:"funcname"`
}

func (e *errorString) Error() string {
	return e.s
}

func New (text string) error {
	alarm("INFO", text)
	return &errorString{text}
}

// 发邮件
func Email (text string) error {
	alarm("EMAIL", text)
	return &errorString{text}
}

// 发短信
func Sms (text string) error {
	alarm("SMS", text)
	return &errorString{text}
}

// 发微信
func WeChat (text string) error {
	alarm("WX", text)
	return &errorString{text}
}

// 告警方法
func  alarm(level string, str string) {
	// 当前时间
	currentTime := function.GetTimeStr()

	// 定义 文件名、行号、方法名
	fileName, line, functionName := "?", 0 , "?"

	pc, fileName, line, ok := runtime.Caller(2)
	if ok {
		functionName = runtime.FuncForPC(pc).Name()
		functionName = filepath.Ext(functionName)
		functionName = strings.TrimPrefix(functionName, ".")
	}

	var msg = errorInfo {
		Time     : currentTime,
		Alarm    : level,
		Message  : str,
		Filename : fileName,
		Line     : line,
		Funcname : functionName,
	}

	jsons, errs := json.Marshal(msg)

	if errs != nil {
		fmt.Println("json marshal error:", errs)
	}

	errorJsonInfo := string(jsons)

	fmt.Println(errorJsonInfo)

	if level == "EMAIL" {
		// 执行发邮件

	} else if level == "SMS" {
		// 执行发短信

	} else if level == "WX" {
		// 执行发微信

	} else if level == "INFO" {
		// 执行记日志
	}
}
```

看下如何调用：

```
package v1

import (
	"fmt"
	"ginDemo/common/alarm"
	"ginDemo/entity"
	"github.com/gin-gonic/gin"
	"net/http"
)

func AddProduct(c *gin.Context)  {
	// 获取 Get 参数
	name := c.Query("name")

	var res = entity.Result{}

	str, err := hello(name)
	if err != nil {
		res.SetCode(entity.CODE_ERROR)
		res.SetMessage(err.Error())
		c.JSON(http.StatusOK, res)
		c.Abort()
		return
	}

	res.SetCode(entity.CODE_SUCCESS)
	res.SetMessage(str)
	c.JSON(http.StatusOK, res)
}

func hello(name string) (str string, err error) {
	if name == "" {
		err = alarm.WeChat("name 不能为空")
		return
	}
	str = fmt.Sprintf("hello: %s", name)
	return
}
```

访问：`http://localhost:8080/v1/product/add?name=a`

```
{
    "code": 1,
    "msg": "hello: a",
    "data": null
}
```

未抛出错误，不会输出信息。

访问：`http://localhost:8080/v1/product/add`

```
{
    "code": -1,
    "msg": "name 不能为空",
    "data": null
}
```

抛出了错误，输出信息如下：

```
{"time":"2019-07-23 22:19:17","alarm":"WX","message":"name 不能为空","filename":"绝对路径/ginDemo/router/v1/product.go","line":33,"funcname":"hello"}
```

可能这会有同学说：“用上一篇分享的数据绑定和验证，将传入的参数进行 binding:"required" 也可以实现呀”。

我只能说：“同学呀，你不理解我的良苦用心，这只是个例子，大家可以在一些复杂的业务逻辑判断场景中使用自定义错误处理”。

到这里，报错时我们收到了 `时间`、`错误信息`、`文件名`、`行号`、`方法名` 了。

调用起来，也比较简单。

虽然标记了告警方式，还是没有进行告警通知呀。

我想说，在这里存储数据到队列中，再执行异步任务具体去消耗，这块就不实现了，大家可以去完善。

读取 `文件名`、`方法名`、`行号` 使用的是 `runtime.Caller()`。

我们还知道，Go 有 `panic` 和 `recover`，它们是干什么的呢，接下来咱们就说说。

## panic 和 recover

当程序不能继续运行的时候，才应该使用 panic 抛出错误。

当程序发生 panic 后，在 defer(延迟函数) 内部可以调用 recover 进行控制，不过有个前提条件，只有在相同的 Go 协程中才可以。

panic 分两个，一种是有意抛出的，一种是无意的写程序马虎造成的，咱们一个个说。

有意抛出的 panic：

```
package main

import (
	"fmt"
)

func main() {

	fmt.Println("-- 1 --")

	defer func() {
		if r := recover(); r != nil {
			fmt.Printf("panic: %s\n", r)
		}
		fmt.Println("-- 2 --")
	}()
	
	panic("i am panic")
}
```

输出：

```
-- 1 --
panic: i am panic
-- 2 --
```

无意抛出的 panic：

```
package main

import (
	"fmt"
)

func main() {

	fmt.Println("-- 1 --")

	defer func() {
		if r := recover(); r != nil {
			fmt.Printf("panic: %s\n", r)
		}
		fmt.Println("-- 2 --")
	}()


	var slice = [] int {1, 2, 3, 4, 5}

	slice[6] = 6
}
```

输出：

```
-- 1 --
panic: runtime error: index out of range
-- 2 --
```

上面的两个我们都通过 `recover` 捕获到了，那我们如何在 Gin 框架中使用呢？如果收到 `panic` 时，也想进行告警怎么实现呢？ 

既然想实现告警，先在 ararm.go 中定义一个 `Panic()` 方法，当项目发生 `panic` 异常时，调用这个方法，这样就实现告警了。

```
// Panic 异常
func Panic (text string) error {
	alarm("PANIC", text)
	return &errorString{text}
}
```

那我们怎么捕获到呢？

使用中间件进行捕获，写一个 `recover` 中间件。

```
package recover

import (
	"fmt"
	"ginDemo/common/alarm"
	"github.com/gin-gonic/gin"
)

func Recover()  gin.HandlerFunc {
	return func(c *gin.Context) {
		defer func() {
			if r := recover(); r != nil {
				alarm.Panic(fmt.Sprintf("%s", r))
			}
		}()
		c.Next()
	}
}
```

路由调用中间件：

```
r.Use(logger.LoggerToFile(), recover.Recover())

//Use 可以传递多个中间件。
```

验证下吧，咱们先抛出两个异常，看看能否捕获到？

还是修改 product.go 这个文件吧。

有意抛出 panic：

```
package v1

import (
	"fmt"
	"ginDemo/entity"
	"github.com/gin-gonic/gin"
	"net/http"
)

func AddProduct(c *gin.Context)  {
	// 获取 Get 参数
	name := c.Query("name")

	var res = entity.Result{}

	str, err := hello(name)
	if err != nil {
		res.SetCode(entity.CODE_ERROR)
		res.SetMessage(err.Error())
		c.JSON(http.StatusOK, res)
		c.Abort()
		return
	}

	res.SetCode(entity.CODE_SUCCESS)
	res.SetMessage(str)
	c.JSON(http.StatusOK, res)
}

func hello(name string) (str string, err error) {
	if name == "" {
		// 有意抛出 panic
		panic("i am panic")
		return
	}
	str = fmt.Sprintf("hello: %s", name)
	return
}
```

访问：`http://localhost:8080/v1/product/add`

界面是空白的。

抛出了异常，输出信息如下：

```
{"time":"2019-07-23 22:42:37","alarm":"PANIC","message":"i am panic","filename":"绝对路径/ginDemo/middleware/recover/recover.go","line":13,"funcname":"1"}
```

很显然，定位的文件名、方法名、行号不是我们想要的。

需要调整 `runtime.Caller(2)`，这个代码在 `alarm.go 的 alarm` 方法中。

将 2 调整成 4 ，看下输出信息：

```
{"time":"2019-07-23 22:45:24","alarm":"PANIC","message":"i am panic","filename":"绝对路径/ginDemo/router/v1/product.go","line":33,"funcname":"hello"}
```

这就对了。

无意抛出 panic：

```
// 上面代码不变

func hello(name string) (str string, err error) {
	if name == "" {
		// 无意抛出 panic
		var slice = [] int {1, 2, 3, 4, 5}
		slice[6] = 6
		return
	}
	str = fmt.Sprintf("hello: %s", name)
	return
}
```

访问：`http://localhost:8080/v1/product/add`

界面是空白的。

抛出了异常，输出信息如下：

```
{"time":"2019-07-23 22:50:06","alarm":"PANIC","message":"runtime error: index out of range","filename":"绝对路径/runtime/panic.go","line":44,"funcname":"panicindex"}
```

很显然，定位的文件名、方法名、行号也不是我们想要的。

将 4 调整成 5 ，看下输出信息：

```
{"time":"2019-07-23 22:55:27","alarm":"PANIC","message":"runtime error: index out of range","filename":"绝对路径/ginDemo/router/v1/product.go","line":34,"funcname":"hello"}
```

这就对了。

奇怪了，这是为什么？

在这里，有必要说下 `runtime.Caller(skip)` 了。

skip 指的调用的深度。

为 0 时，打印当前调用文件及行数。

为 1 时，打印上级调用的文件及行数。

依次类推...

在这块，调用的时候需要注意下，我现在还没有好的解决方案。

我是将 skip（调用深度），当一个参数传递进去。

比如：

```
// 发微信
func WeChat (text string) error {
	alarm("WX", text, 2)
	return &errorString{text}
}

// Panic 异常
func Panic (text string) error {
	alarm("PANIC", text, 5)
	return &errorString{text}
}
```

具体的代码就不贴了。

但是，有意抛出 Panic 和 无意抛出 Panic 的调用深度又不同，怎么办？

1、尽量将有意抛出的 Panic 改成抛出错误的方式。

2、想其他办法搞定它。

就到这吧。

## 源码

**下载源码后，请先执行 `dep ensure` 下载依赖包！**

[查看源码](https://github.com/xinliangnote/Go/blob/master/01-Gin框架/codes/05-自定义错误处理)
