今日头条极速版下载

第2步：填写红包邀请码：Q09817188

今日头条极速版邀请

第3步：获得专属红包奖励，当天即可提现到支付宝。

今日头条极速版赚钱

第4步：每天看看新闻，做做日常任务，还有其他的（比如走路赚钱、吃饭补贴、睡觉赚钱），获得的金币每天凌晨会自动转换成余额，均可提现。

PS：偷偷告诉你，还可以种种水果，1分钱包邮哦。

列举几个最基础的 DSL 语句，所有长达成百上千行的 DSL 都是由这些基础语法组合起来的。

一、环境

• Ubuntu 14.04/16、04
• JDK1.8
• Elasticsearch 5.3
• Kibana 5.3.2

二、DSL介绍

Query DSL 又叫查询表达式，是一种非常灵活又富有表现力的查询语言，采用 JSON 接口的方式实现丰富的查询，并使你的查询语句更灵活、更精确、更易读且易调试。

我平时喜欢借助 Kibana 来执行 DSL 语句，它能够辅助自己开发，也能用于 debug 和研究。

实际项目中一般封装一下第三方引擎来实现业务，而这些语法转换成 DSL 后经常有成百上千行，但其实一点也不复杂。不管是过滤、聚合还是嵌套，只要理解了最基本的语法，都是很好解读的。

这篇文章主要还是记录下我平时常用的几个 DSL，防止隔得时间久了，裸写 DSL 不一定写得出来。

三、全文查询

1. match_all

/_search 查找整个ES中所有索引的内容，/ 前面可以加上索引名，多个索引名之前用英文逗号分割。
下面这个语法是 match_all 查询，Kibana 能够自动补全代码，最简单。

GET /_search
{
  "query": {
    "match_all": {}
  }
}

2. match

下边的例子就表示查找 host 为 wenyuanblog.com 的所有记录。

POST /wenyuanblog-2018.03.02/_search
{
  "query": {
    "match": {
      "host": "wenyuanblog.com"
    }
  }
}

3. multi_match

在多个字段上执行相同的 match 查询，下边的例子就表示查询 host 或 http_referer 字段中包含 wenyuanblog.com 的记录。

GET /wenyuanblog-2018.03.02/_search
{
  "query": {
    "multi_match": {
      "query": "wenyuanblog.com",
      "fields": [
        "host",
        "http_referer"
      ]
    }
  }
}

4. query_string

可以在查询里边使用 AND 或者 OR 来完成复杂的查询。

下边的例子表示查找 host 为 a.wenyuanblog.com 或者 b.wenyuanblog.com 的所有记录。

GET /wenyuanblog-2018.03.02/_search
{
  "query": {
    "query_string": {
      "query": "(a.wenyuanblog.com) OR (b.wenyuanblog.com)",
      "fields": [
        "host"
      ]
    }
  }
}

也可以组合更多的条件完成更复杂的查询请求。

下边的例子表示查询（host 为 a.wenyuanblog.com）或者是（host 为 b.wenyuanblog.com 且 status 为 404）的所有记录。

GET /wenyuanblog-2018.03.02/_search
{
  "query": {
    "query_string": {
      "query": "host:a.wenyuanblog.com OR (host:b.wenyuanblog.com AND status:404)"
    }
  }
}

与其相类似的还有个 simple_query_string 的关键字，可以将 query_string 中的 AND 或 OR 用 + 或 | 这样的符号替换掉。

5. term

term 可以用来精确匹配，精确匹配的值可以是数字、时间、布尔值或者是设置了 not_analyzed 不分词的字符串。

GET /wenyuanblog-2018.03.02/_search
{
  "query": {
    "term": {
      "status": {
        "value": 404
      }
    }
  }
}

term 对输入的文本不进行分析，直接精确匹配输出结果，如果要同时匹配多个值可以使用 terms。

GET /wenyuanblog-2018.03.02/_search
{
  "query": {
    "terms": {
      "status": [
        403,
        404
      ]
    }
  }
}

6. range

range 用来查询落在指定区间内的数字或者时间。
下边的例子表示搜索所有状态为 200 到 399 之间的数据，这里的操作符主要有四个 gt 大于，gte 大于等于，lt 小于，lte 小于等于。

GET /wenyuanblog-2018.03.02/_search
{
  "query": {
    "range": {
      "status": {
        "gte": 200,
        "lte": 399
      }
    }
  }
}

当使用日期作为范围查询时，我们需要注意下日期的格式，官方支持的日期格式主要有两种：

① 时间戳，注意是毫秒粒度。

GET /wenyuanblog-2018.03.02/_search
{
  "query": {
    "range": {
      "@timestamp": {
        "gte": 1519920000000,
        "lte": 1519956000000,
        "format": "epoch_millis"
      }
    }
  }
}

② 日期字符串。

GET /wenyuanblog-2018.03.02/_search
{
  "query": {
    "range": {
      "@timestamp": {
        "gte": "2018-03-02 00:00:00",
        "lte": "2018-03-03",
        "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd",
        "time_zone": "+08:00"
      }
    }
  }
}

选择哪种方式根据实际情况决定，我们业务中用时间戳的情况居多。

如果采用日期字符串的方式，那么可以使用 format 字段指定匹配的日期格式，如果格式有多个就用 || 分开，像例子中那样，不过建议用同样的日期格式。

如果日期中缺少年月日这些内容，那么缺少的部分会用 unix 的开始时间（即 1970年1月1日）填充，当你将 “format”:”dd” 指定为格式时，那么 “gte”:10 将被转换成 1970-01-10T00:00:00.000Z。

Elasticsearch 中默认使用的是 UTC 时间，所以我们在使用时要通过 time_zone 来设置好时区，以免出错。

7. exists

查询出存在某字段的文档。

GET /wenyuanblog-2018.03.02/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "exists": {
            "field": "visitor.name"
          }
        }
      ]
    }
  },
  "from": 0,
  "size": 100
}

8. bool组合查询

通常我们可能需要将很多个条件组合在一起查出最后的结果，这个时候就需要使用 ES 提供的 bool 来实现了。
布尔查询支持的子查询类型共有四种，分别是：must，should，must_not 和 filter。

must：类似于 SQL 中的 AND ，必须包含；
must_not：类似于 SQL 中的 NOT，必须不包含；
should：文档应该匹配 should 子句查询的一个或多个；
filter：过滤器，文档必须匹配该过滤条件，跟 must 子句的唯一区别是，filter 不会对结果进行相关性评分 _score，换言之当我们的业务中无相关性的要求时，建议查询的过程中多用 filter。

下面是一个组合查询的例子，我们要查询 host 为 wenyuanblog.com 且 http_x_forworded_for 为 47.97.12.69 且 status 不为 200 的所有数据。

GET /wenyuanblog-2018.03.02/_search
{
  "query": {
    "bool": {
      "filter": [
        {
          "match": {
            "host": "wenyuanblog.com"
          }
        },
        {
          "match": {
            "http_x_forwarded_for": "47.97.12.69"
          }
        }
      ],
      "must_not": {
        "match": {
          "status": 200
        }
      }
    }
  }
}

这里再说一下 should。通常情况下，should 子句是数组字段，包含多个 should 子查询，默认情况下，匹配的文档必须满足其中一个子查询条件。

但我们可以通过显式设置布尔查询的参数 minimum_should_match 的值，从而改变默认匹配行为。该参数控制一个文档必须匹配的 should 子查询的数量，它有很多种配置方式：

如果设置为数字 3，表示至少需要匹配 3 个 should 子句；如果设置为一个百分比，例如 “minimum_should_match”:75%，则至少满足 75% 且向下取整（5个 should 子句，5*75%=3.75，向下取整为 3，也就是至少匹配 3 个 should 子句）。

下面是个例子。（注：在 bool query 中 minimum_should_match 只能紧跟在 should 的后面，放其他地方会出异常）

GET /wenyuanblog-2018.03.02/_search
{
  "query": {
    "bool": {
      "should": [
        {
          "match": {
            "host": "a.wenyuanblog.com"
          }
        },
        {
          "match": {
            "host": "b.wenyuanblog.com"
          }
        },
        {
          "match": {
            "host": "c.wenyuanblog.com"
          }
        }
      ],
      "minimum_should_match": 2
    }
  }
}

9. sort

sort 是排序，也是很常用的查询，这里我举个按时间（@timestamp）倒叙查询的例子。

GET /wenyuanblog-2018.03.02/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "@timestamp": {
        "order": "desc"
      }
    }
  ]
}

四、聚合查询

1. 分桶

根据 host 字段的值进行分桶（有点类似于 SQL 中的 group by），这里的 host_bucket 是我给该桶起的名字。

GET /wenyuanblog-2018.03.02/_search
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "host_bucket": {
      "terms": {
        "field": "host"
      }
    }
  }
}

2. 度量

计算出 latency 字段的最大值（metric 有点类似于 SQL 的 avg、max、min），这里的 max_latency 是我给该度量起的名字。

GET /wenyuanblog-2018.03.02/_search
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "max_latency": {
      "max": {
        "field": "latency"
      }
    }
  }
}

五、业务应用

实际业务中的一些需求，属于较综合的查询语法。

1. 聚合结果进行排序

关键词：aggregations，terms，order。

先过滤出 host 字段值为 “wenyuanblog.com” 的记录，然后对 源IP 进行分桶聚合，最后根据聚合查询到的 文档数量倒序排序。

GET /wenyuanblog-2019.05.*/_search
{
  "query": {
    "bool": {
      "filter": [
        {
          "range": {
            "@timestamp": {
              "to": 1557503999000,
              "from": 1557417600000
            }
          }
        },
        {
          "term": {
            "host": "wenyuanblog.com"
          }
        }
      ]
    }
  },
  "from": 0,
  "size": 0,
  "aggregations": {
    "src_ip_bucket": {
      "terms": {
        "field": "http.src_ip.dotted",
        "size": 10,
        "order": {
          "_count": "desc"
        }
      }
    }
  }
}

2. IP范围过滤+分桶+度量+脚本+排序

关键词：range，aggregations，terms，metric，script，order。

先根据 IP范围 过滤，同时排除指定 host；
接着对 源IP 进行分桶聚合，再计算 进流量、出流量 在该时间段内的总和，用脚本计算出 总流量（进流量+出流量） ，最后根据 总流量（进流量+出流量） 数值大小进行倒序排序。

使用groovy：

GET /wenyuanblog-2019.05.*/_search
{
  "query": {
    "bool": {
      "filter": [
        {
          "bool": {
            "must": [
              {
                "range": {
                  "@timestamp": {
                    "to": 1557503999000,
                    "from": 1557417600000
                  }
                }
              },
              {
                "range": {
                  "http.src_ip.dotted": {
                    "to": "10.255.255.255",
                    "from": "10.0.0.0"
                  }
                }
              },
              {
                "bool": {
                  "must_not": [
                    {
                      "terms": {
                        "host": [
                          "a.wenyuanblog.com",
                          "b.wenyuanblog.com"
                        ]
                      }
                    }
                  ]
                }
              }
            ]
          }
        }
      ]
    }
  },
  "from": 0,
  "size": 0,
  "aggs": {
    "appid_bucket": {
      "terms": {
        "field": "http.src_ip.dotted",
        "order": {
          "sum_total_bytes": "desc"
        },
        "size": 100
      },
      "aggs": {
        "sum_in_bytes": {
          "sum": {
            "field": "http.in_bytes"
          }
        },
        "sum_out_bytes": {
          "sum": {
            "field": "http.out_bytes"
          }
        },
        "sum_total_bytes": {
          "sum": {
            "script": {
              "lang": "groovy",
              "inline": "doc['http.in_bytes'].value + doc['http.out_bytes'].value"
            }
          }
        }
      }
    }
  }
}

使用 painless，修改 script 部分如下：

"sum_total_bytes": {
  "sum": {
    "script": {
      "lang": "painless",
      "inline": "doc['tcp.in_bytes'].value + doc['tcp.out_bytes'].value"
    }
  }
}

以前一直用 groovy，因为比较好用。但最近两年的某个版本开始将其 Deprecation 了，官方推荐使用 painless。
painless 也能实现一些脚本语法，具体可以上官网查询。

3. IP范围过滤+聚合过滤+度量

关键词：range，aggregations，filter，metric。

先根据 IP范围 过滤，然后开始聚合，筛选出 目的端口 是 80、443 的数据，再计算这些数据中（80、443端口） 进流量、出流量 在该时间段内的总和。

至于为什么要在聚合中进行过滤而不是在聚合前就过滤，是因为下面语句只是完整 dsl 的一部分，该查询业务还要同时对其它端口进行聚合操作。

GET /wenyuanblog-2019.05.*/_search
{
  "query": {
    "bool": {
      "filter": [
        {
          "bool": {
            "must": [
              {
                "range": {
                  "@timestamp": {
                    "to": 1557503999000,
                    "from": 1557417600000
                  }
                }
              },
              {
                "range": {
                  "http.src_ip.dotted": {
                    "to": "10.255.255.255",
                    "from": "10.0.0.0"
                  }
                }
              }
            ]
          }
        }
      ]
    }
  },
  "from": 0,
  "size": 0,
  "aggs": {
    "dport_80_443": {
      "filter": {
        "bool": {
          "must": [
            {
              "terms": {
                "http.dport": [
                  80,
                  443
                ]
              }
            }
          ]
        }
      },
      "aggs": {
        "sum_in_bytes": {
          "sum": {
            "field": "http.in_bytes"
          }
        },
        "sum_out_bytes": {
          "sum": {
            "field": "http.out_bytes"
          }
        }
      }
    }
  }
}

六、总结

ES 很强大，它支持的查询有很多，这里我只是列举了平时在 Kibana 中经常调试的 DSL。

还有很多实际业务中经常用到的模糊查询（wildcard、regexp、prefix）、nested 查询、多层聚合等等，基本上都是先封装第三方引擎，然后开发时转成 DSL 并 copy 到 Kibana 进行验证和查错。

更复杂的应用这里就不列举出来了，必要时候官方文档是最好的资料。

总结Elasticsearch各种备份与迁移方案，亲测。
详细记录了具体步骤。

一、环境

• Ubuntu 14.04/16、04
• JDK1.8
• Elasticsearch 5.3
• Kibana 5.3.2

二、单节点环境

1. 创建备份存储目录

sudo mkdir /media/es/es_backup
# 该目录要是elasticsearch可访问的，我们的环境一般是elasticsearch用户
chown -R elasticsearch:elasticsearch /media/es/es_backup/

2. 修改elasticsearch.yml文件

修改 elasticsearch.yml 文件，添加 path.repo 配置。

vim elasticsearch.yml
# 增加一行如下：
path.repo: ["/media/es/es_backup"]

3. 重启Elasticsearch

4. 创建仓库

借助 Kibana 操作。

# 创建仓库，创建一个名为my_backup的仓库
PUT _snapshot/my_backup
{
  "type": "fs",
  "settings": {
    "location": "/media/es/es_backup",
    "compress": true
  }
}

# 检查仓库是否创建成功（my_backup为之前创建的仓库名称） 
GET _snapshot/my_backup

# 删除仓库
DELETE _snapshot/my_backup

5. 备份索引数据

# 给所有索引创建快照
PUT _snapshot/my_backup/snapshot_name        

# 针对具体的index创建快照备份
# 其中my_backup是仓库名称，snapshot_name是快照的名字
# ignore_unavailable在创建快照的过程中会忽略不存在的索引，默认情况下，如果没有设置，在索引不存在的情况下快照请求将会失败
# include_global_state能够防止集群的全局状态被作为快照的一部分存储起来
# 多个索引间不要加空格，否则只会对第一个索引操作（我踩过坑！！！）
PUT _snapshot/my_backup/snapshot_name?wait_for_completion=true
{
  "indices": "index_1,index_2",
  "ignore_unavailable": true,
  "include_global_state": false
}

# 查看指定仓库下所有快照
GET _snapshot/my_backup/_all

# 查看具体某一个快照的信息
GET _snapshot/my_backup/snapshot_name/_status

# 删除快照，要指定仓库名和快照名
# 也能用于取消一个正在进行的快照创建过程，会删除备份了一半的快照
DELETE _snapshot/my_backup/snapshot_name

这里我取一个仓库名为 my_backup，快照名为 alert_snap，要备份的 index 为 .nina_view 和 cc-zabbix-2018.01.05。

6. 将数据迁移到另一个环境

# 备份创建好之后，在仓库目录/media/es/es_backup里是这样的：
-rw-r--r-- 1 elasticsearch elasticsearch  317 Jan 22 17:44 index-0
-rw-r--r-- 1 elasticsearch elasticsearch    8 Jan 22 17:44 index.latest
drwxr-xr-x 4 elasticsearch elasticsearch 4096 Jan 22 17:44 indices/
-rw-r--r-- 1 elasticsearch elasticsearch  103 Jan 22 17:44 meta-9KWgeCYtSBqqVrfD42bsNw.dat
-rw-r--r-- 1 elasticsearch elasticsearch  237 Jan 22 17:44 snap-9KWgeCYtSBqqVrfD42bsNw.dat

7. 在目标环境下，重复上面1~4步，建立仓库

将源集群的备份内容（/media/es/es_backup 里的所有文件），复制到迁移目标的仓库目录里，接下来就是类似批量导入了。

# 如果索引已经存在目标的集群，需要先关闭索引，恢复数据后再开启
POST /index_name/_close
POST _snapshot/my_backup/snapshot_name/_restore
POST /index_name/_open

# 从快照中恢复指定的索引，并给索引重命名
# indices里面可以写多个索引名，中间用逗号隔开
# rename_pattern可以写完整的索引名，也可以用正则匹配索引名的局部
# rename_replacement将替换rename_pattern中匹配到的局部(如果是正则,不是将整个索引名都替换)
#下面这条语句会把index_1,index_2恢复为restored_index_1和restored_index_2
POST /_snapshot/my_backup/snapshot_1/_restore
{
  "indices": "index_1,index_2",
  "rename_pattern": "index_(.+)",
  "rename_replacement": "restored_index_$1"
}

# 查看恢复的状态
GET _snapshot/my_backup/snapshot_name/_status 

三、集群-多节点环境

1. 创建共享目录

(todo…我没实施过，感觉挺麻烦的，不太推荐)
使用 sshfs 在 ES 集群中每个节点的相同位置挂载一个共享目录。

假设 ES 集群有三个节点：192.168.1.10，192.168.1.11，192.168.1.12，

我这里共享目录用了 /data/es_backup，ES 备份仓库目录(也是共享目录的挂在点)用了 /mnt/es_backup，可以根据实际情况调整。

# 在每个节点上安装sshfs
sudo apt-get install sshfs

# 选取其中一个节点的目录(非系统盘)作为共享目录 </br>
# 假设选择的节点ip为192.168.1.10：
mkdir /data/es_backup
chown -R elasticsearch:elasticsearch /data/es_backup
chmod -R 777 /data/es_backup

# 在每个ES节点的相同位置创建存放ES仓库的目录
mkdir /mnt/es_backup
chown -R elasticsearch:elasticsearch /mnt/es_backup
chmod -R 777 /mnt/es_backup
# 每个节点挂载共享目录，执行同样的操作。$user为用户，一般为root，回车后输入密码，其中的参数-o allow_other允许了其他用户访问这个目录
sshfs $user@192.168.1.10:/data/es_backup /mnt/es_backup -o allow_other
# 如果修改了默认ssh端口, 比如23566, 则可以这样:
sshfs $user@192.168.1.10:/data/es_backup /mnt/es_backup -p 23566 -o allow_other

# 测试运行ES的用户是否有对共享目录的写权限
sudo su - elasticsearch
touch /mnt/es_backup/test.txt

# 修改每个节点的elasticsearch.yml文件，添加path.repo配置
path.repo: ["/mnt/es_backup"]

接下来的操作和上面单节点一样，重启 es，建立仓库，创建快照等等。

# 在共享目录下为集群创建共享仓库
PUT _snapshot/my_backup
{
  "type": "fs",
  "settings": {
    "location": "/mnt/es_backup",
    "compress": true
  }
}
# 后面步骤省略...

最后补充一下：取消挂载共享目录，不要直接删除挂载目录，在每个节点下执行下面命令：

# 这个命令会断开远程连接同时清空 /mnt/es_backup 目录。
fusermount -u /mnt/es_backup

类似的实现文件共享的方法还有 nfs 和 samba（支持 window 和 linux 互相访问）。

2. 借助第三方工具

第三方迁移工具，网上看了下，主要有三个：

• elasticsearch-dump
• elasticsearch-exporter
• elasticsearch-migration

优点：方便，快速。支持的功能很多(数据迁移、mapping迁移等等)。

缺点：原理是用了 scroll+bulk，百万、千万级别条数的数据可以使用，数据量过大还是老老实实用我上面整理的快照方法吧。
备注：对 ES 操作时候，一些报错没有捕获到并写入 log。比如我们只允许自动创建 cc- 开头的索引，迁移生成的新索引需要改名为别的名字，你会发现迁移完，数据没有进去，这也算是第三方工具的不足之处，不过它应该会不断完善。

四、总结

不管是运维也好，开发也好，对数据的备份和迁移是经常要做的事。针对环境的不同特别是数据量的差异，需要适时选择合适的方式。

有时候也要根据自己的具体需求而定，比如为了辅助自己开发，需要回放数据，那完全可以编写一些简单的脚本来实现。

我写过几个简单的脚本，放在 GitHub 上：

• es_replay
  开发测试用途（数据导出、去重、构造和导入）
• es_assistant
  一些用于协助开发和测试的 es 交互脚本
• es_monitor
  Elaticsearch 部署机的信息采集脚本（这个是很久很久以前写的，那时候刚学 ES，能直接用，功能上没问题，但代码完全可以更优化一下，最近忙着学其他东西，所以一直没去动它。）

现在官方已经出到了ES7 beta，不过现在为止用的最多也是比较稳定的是5.x。
这里我简单记录下针对5.x版本的部署配置过程，暂不考虑优化（后面再总结优化相关的笔记）。

一、环境

• Ubuntu 14.04/16、04
• JDK1.8
• Elasticsearch 5.6

二、安装JDK

1. 下载安装

http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html

将刚刚下载的文件拷贝到 /opt 目录下，
解压 jdk 到当前目录，使用命令 tar -zxvf jdk-8u161-linux-x64.tar.gz

修改文件名 mv jdk1.8.0_161 jdk1.8
至此，jdk1.8 已经全部安装完成了。

2. 配置环境变量

修改 vim /etc/profile ，最底部添加:

# Sun JDK profile
export JAVA_HOME=/opt/jdk1.8
export JRE_HOME=${JAVA_HOME}/jre  
export CLASSPATH=.:${JAVA_HOME}/lib:${JRE_HOME}/lib  
export PATH=${JAVA_HOME}/bin:$PATH

运行 source /etc/profile，使 /etc/profile 文件生效。

使用 java -version 和 javac -version 命令查看 jdk 版本及其相关信息，不会出现 command not found 错误，且显示的版本信息与前面安装的一致。

echo $JAVA_HOME, echo $CLASSPATH, echo $PATH，看看自己的配置是否都正确。

3. 开机设置

每次重启服务器的时候，会发现 jdk 版本不正确，或者使用 java -version 显示不是所需版本，使用　javac -version 会出现 command not found 错误。

解决方法是再次运行 source /etc/profile，使 /etc/profile 文件生效。显然每次这么操作很麻烦。

因此我们编辑 vim ~/.bashrc，最后加一句

source /etc/profile

三、安装Elasticsearch

1. 下载安装

登录官网 https://www.elastic.co/cn/downloads。

选择下载 elasticsearch，根据需要选择对应的安装包，这里选择 5.6 版本，下载完后得到 elasticsearch-5.6.0.tar.gz

操作系统中创建一个新用户专门用来管理 es：adduser elasticsearch

用 elasticsearch 用户将 elasticsearch-5.6.0.tar.gz 拷贝到 /opt 目录下。

解压到当前目录，使用命令 tar -zxvf elasticsearch-5.6.0.tar.gz。

删除压缩文件，使用命令 rm -f elasticsearch-5.6.0.tar.gz。

至此，elasticsearch 安装完成

2. ES集群需要改的系统配置

vim /etc/security/limits.conf

* soft nofile 65536
* hard nofile 131072
* soft nproc 2048
* hard nproc 4096
* soft memlock unlimited
* hard memlock unlimited
* - nofile 65536

root soft nofile 65536
root hard nofile 131072
root soft nproc 2048
root hard nproc 4096
root soft memlock unlimited
root hard memlock unlimited
root - nofile 65536

vim /etc/sysctl.conf

vm.max_map_count=655360
vm.swappiness = 0

并执行 sysctl -p

如果是 supervisor 托管的，修改 /etc/supervisord.conf 中的：
minfd = 65536
并重启 supervisor。

3. 修改ES配置文件elasticsearch.yml

bootstrap.memory_lock: false
bootstrap.system_call_filter: false

cluster.name: elasticsearch
node.name: 192.168.10.201
node.master: true
node.data: true
http.enabled: true
network.host: 0.0.0.0
discovery.zen.ping.unicast.hosts: ["192.168.10.198","192.168.10.201"]

http.port: 9200

script.engine.groovy.inline.update: on
script.engine.groovy.inline.search: on
script.engine.groovy.inline.aggs: on
script.max_compilations_per_minute: 10000

path.data: /data/es

action.auto_create_index: cc-*,sc-*,.nina*,.security,.monitoring*,.watches,.triggered_watches,.watcher-history*

同时也要指定一下 jvm.options（同级目录下的一个配置文件） 里的 jvm 虚拟机内存。

4. ES交给supervisor托管

[program:elasticsearch]
user = elasticsearch
startsecs = 3
autostart = true
autorestart = true
startretries = 3
stdout_logfile=NONE
stderr_logfile=NONE
environment = JAVA_HOME="/opt/jdk/", ES_JAVA_OPTS = "-Xms8g -Xmx8g"
command = /opt/elasticsearch/bin/elasticsearch

四、安装Kibana

1. 从官网下载和es一样版本的Kibana

拷贝到 /opt 目录，解压，修改配置文件 kibana.yml。

server.host: "192.168.10.201"
elasticsearch.url: "http://192.168.10.198:9200"

2. Kibana交给supervisor托管

[program:kibana]
startsecs = 3
autostart = true
autorestart = true
startretries = 3
redirect_stderr = true
command = /opt/kibana/bin/kibana
stdout_logfile = /var/log/kibana.log

正向代理与反向代理的区别，以及用Nginx配置实现代理服务。

一、正向代理与反向代理

1. 正向代理

正向代理其实相当于请求的中继，比如说，如果某个网站国内无法访问，也就是被墙了，我可以选择两种方式：
一个是配置代理服务器，第二种就是 VPN。

其实两种技术原理差不太多，如果说我自己访问不到这个网站，而这时可以通过一台可以访问到这个网站的服务器，也就是代理服务器，来进行访问，这台代理服务器，分析我们请求的信息，然后去对应的要去的网站上将内容取回来发给我，这样我就能读到想要访问的网站上的内容了，通过一下图片，可以很清晰的看出其原理：

2. 反向代理

反向代理比正向代理更加透明，客户端并不知道访问的是代理服务器，当客户端请求一个网址的时候，会经过反向代理服务器，而这台反向代理服务器，会根据客户端的请求，将请求转发到内网服务器中，内网服务器处理请求并返回结果到反向代理服务器上，通过反向代理服务器，将结果最终返回到客户端，详情如图：

简单来说：
正向代理代理的是客户端（如通过代理访问谷歌），而反向代理代理的是服务器（如 Nginx 代理 PHP 服务器）。

二、通过SSH反向代理实现内网穿透

1. 背景

我用学校实验室的一台服务器在跑数据，但是这台服务器没有公网 ip，只有学校内网 ip，故我只能到实验室登录。但有时候，需要在宿舍或者家里远程连接这台服务器。

于是，我就用到了反向代理。前提是我有一台公网 ip 的服务器（例如，阿里的学生机，或者 vultr 的 VPS 都可以）。

首先，准备好这两台服务器：

• 学校实验室服务器（SchoolServer）
  • IP：192.168.10.50
  • ssh端口：22
  • 用户：student
  • 密码：helloworld
• 我的外网服务器（MyServer）
  • IP：111.13.100.91
  • ssh端口：22
  • 用户：wenyuanblog
  • 密码：www.wenyuanblog.com

2. 实现原理

在学校内网服务器（以下简称 SchoolServer）中，通过 SSH 设置反向代理，指向我的公网服务器（以下简称 MyServer，该服务器作为反向代理服务器），之后用客户端连接 MyServer 时，MyServer 会把请求转交给 SchoolServer，从而间接登录学校的内网服务器。

整个过程，我们作为客户端是感知不到代理服务器的存在的。客户端是否能感知代理服务器的存在，是区别正向代理和反向代理的关键。

SSH 参数介绍

# 反向代理命令
ssh -fCNR

# 正向代理命令
ssh -fCNL

参数说明

3. 内网服务器操作

登录 SchoolServer，进行如下操作：

# ssh -N -f -R MyServer端口:127.0.0.1:本地端口 MyServer用户@MyServerIP
ssh -N -f -R 20022:127.0.0.1:22 wenyuanblog@111.13.100.91

这句命令的意思是，将 MyServer 的 20022 端口转发至 SchoolServer 22 端口，最后是 MyServer 用户名和 IP。
使用 ps aux | grep ssh 来查看是否运行。

4. 公网服务器操作

登录 MyServer，进行如下操作：

# ssh SchoolServer用户名@127.0.0.1 -p 代理端口 -L MyServerIP:代理端口:127.0.0.1:22
ssh student@127.0.0.1 -p 20022 -L 111.13.100.91:20022:127.0.0.1:22

执行这条命名，输入 student 用户的密码，现在就已经跳转登录到内网服务器了。

保持当前窗口的登录状态，这时候使用 xshell、beyondcompare，就只要在登录的配置项里 IP 填 MyServer 的 IP，端口填 20022 就好了。

三、Nginx配置实现代理服务

1. 背景

到目前为止，我们都还没有用到 Nginx 的代理服务。那什么时候会需要呢，现在有了如下需求：

在学校内网服务器上跑了一个网页（实验室代码库 GitLab），我们需要在宿舍或者家里访问这个内部网页。

该项目是部署在内网的，所以在内网直接访问不会有问题，而从外网访问当然也就访问不到。

• 学校实验室服务器（SchoolServer）
  • IP：192.168.10.50
  • 页面 url：192.168.10.50:8000
• 我的外网服务器（MyServer）
  • IP：111.13.100.91
  • 站点域名：www.wenyuanblog.com

2. 实现原理

还是通过反向代理来实现。

通过 Nginx 实现端口转发，最后可以通过公网服务器的域名+端口号访问学校内网服务器的页面。
即访问 www.wenyuanblog.com:28000 时，将得到 192.168.10.50:8000（实验室代码库）的页面。
当然了，这样配置的话，我不得不记住 28000 这个端口号，显然不方便。

所以下面的配置，我将配置成二级域名的形式，即 gitlab.wenyuanblog.com -> 192.168.10.50:8000

3. 内网服务器操作

登录 SchoolServer，进行如下操作（和二>中一样）：

# ssh -N -f -R MyServer端口:127.0.0.1:本地端口 MyServer用户@MyServerIP
ssh -N -f -R 28000:127.0.0.1:8000 wenyuanblog@111.13.100.91

这句命令的意思是，将 MyServer 的 28000 端口转发至 SchoolServer 8000 端口，最后是 MyServer 用户名和 IP。

使用 ps aux | grep ssh 来查看是否运行。

4. 公网服务器操作

登录 MyServer，增加一份 Nginx 的配置文件，我习惯放于 /usr/local/nginx/conf/vhosts 目录下，考虑到是代理的配置文件，我取名为 school.proxy。

vim school.proxy，配置如下：

upstream school_gitlab {
        server 127.0.0.1:28000;
}
server {
        listen       80;
        server_name   gitlab.wenyuanblog.com;
        location / {
            proxy_pass http://school_gitlab;
            proxy_set_header Host $host;
        }
        access_log  /var/log/nginx/access/school_gitlab.log;
}

现在，我就可以通过二级域名访问学校实验室的 GitLab 了。

整个过程中，在 MyServer 的数据流向如下：
二级域名访问 -> MyServer:80 -> nginx 分发 -> MyServer:28000 -> SchoolServer:8080

四、补充：用autossh代替ssh

1. 背景

其实整个过程到上面为止已经结束了，目前已经通过反向代理实现内网穿透，平时肯定够用了。
如果想追求更进一步的配置，可以继续往下看。

什么是更进一步的配置呢？

在前面二、三两部分内容的「内网服务器操作」时，我们使用 ssh 建立的反向连接其实很不稳定，长时间不使用连接就会自动释放，这个时候就需要使用 autossh。
autossh 的参数与 ssh 的参数是一致的，但是不同的是，在隧道断开的时候，autossh 会自动重新连接而 ssh 不会。

2. 步骤修改

只需改动一个地方，那就是上面二和三里面的「3. 内网服务器操作」，其他操作不变。

现在如下操作：

Step1. 配置公钥和私钥，实现免密码登录（为后面的脚本做准备）

• 登录内网服务器（SchoolServer）
  切换到普通用户 student，不建议用 root。
  执行命令：ssh-keygen -t rsa -P ''，直接 ssh-keygen 然后三次回车就可以了。
  • -P 表示密码，-P '' 就表示空密码，也可以不用 -P 参数，这样就要三车回车，用 -P 就一次回车。
  • 它在 /home/student 下生成 .ssh 目录，.ssh 下有 id_rsa 和 id_rsa.pub。（这样就生成了公钥/私钥对）
• 把内网服务器（SchoolServer）下的 id_rsa.pub 复制到公网服务器（MyServer）下
  执行命令：scp .ssh/id_rsa.pub wenyuanblog@111.13.100.91:/home/wenyuanblog/id_rsa.pub
  由于还没有免密码登录的，所以要输入密码。
• 公网服务器（MyServer）加入内网服务器（SchoolServer）的公钥
  登录公网服务器（MyServer），切换到 wenyuanblog 账户（下面的步骤不要用 root）。
  如果公网服务器的 wenyuanblog 目录下没有 .ssh 和 authorized_keys 文件则创建这个文件夹和文件。
  把从内网服务器复制的 id_rsa.pub 添加到 .ssh/authorzied_keys 文件里，即执行命令：
  cat id_rsa.pub >> .ssh/authorized_keys
cat .ssh/authorized_keys
chmod 644 .ssh/authorized_keys
  • authorized_keys 的权限要是 644 。
• 内网服务器（SchoolServer）登录公网服务器（MyServer）试试
  回到内网服务器（SchoolServer），用之前的普通用户 student，执行：ssh wenyuanblog@111.13.100.91
  第一次登录要 yes，现在内网机器就可以免密码登录公网机器了。

Step2. 登录内网服务器，启动 autossh，维持 ssh 连接

上面提过，使用 ssh 建立的反向连接很不稳定，长时间不使用连接就会自动释放，这个时候就需要使用 autossh。

一般新机器需要安装 autossh：
yum install autossh（CentOS）
apt-get install autossh（Ubuntu）

切换到 wenyuanblog 用户（非 root 用户），在其 home 目录下创建一个 autossh.sh 脚本，开辟连接到公网服务器的隧道。
autossh.sh 脚本内写入要开辟的端口：

#!/bin/bash
/usr/bin/autossh -NR 0.0.0.0:20022:127.0.0.1:22  -i ~/.ssh/id_rsa wenyuanblog@公网IP -p 22 >> ~/log/ssh_nat.log 2>&1 &
/usr/bin/autossh -NR 0.0.0.0:28000:127.0.0.1:8000 -i ~/.ssh/id_rsa wenyuanblog@公网IP -p 22 >> ~/log/ssh_nat.log 2>&1 &

这两行就分别代替了上面二和三中「3. 内网服务器操作」里的内容。

运行脚本：
chmod +x autossh.sh
sh autossh.sh

使用 ps -ef|grep autossh 和 ps -ef|grep ssh 查看当前运行中的 autossh 任务进程。

其余步骤不变，完成。

自己搜集总结的Nmap常用命令及参数说明。

一、简介

NMap，也就是Network Mapper，是Linux下的网络扫描和嗅探工具包。
nmap是在网络安全渗透测试中经常会用到的强大的扫描器，功能很强大。

二、参数说明

-sP 渗透内网之后判断当前网络哪些主机在线

nmap -sP 192.168.1/255

-vv 显示详细的扫描过程
-sS 使用SYN半开式扫描，这种扫描方式使得扫描结果更加正确（又称半开放,或隐身扫描）

nmap -vv -sS IP

-O 大写O代表OS，判断主机操作系统

nmap -O IP

延时策略
-T(0-5) 默认为 3
0 即 Paranoid 模式。为了避开IDS的检测使扫描速度极慢，nmap串所有的扫描，每隔至少5分钟发送一个包。
1 即 Sneaky 模式。也差不多，只是数据包的发送间隔是15秒。
2 即 Polite 模式。不增加太大的网络负载，串行每个探测，并使每个探测间隔0.4秒。
3 即 Normal 模式。nmap的默认选项，在不使网络过载或者主机/端口丢失的情况下尽可能快速地扫描。
4 即 Aggressive 模式。设置5分钟的超时限制，对每台主机的扫描时间不超过5分钟，并且对每次探测回应的等待时间不超过1.5秒。
5 即 lnsane 模式。只适合快速的网络或者不在意丢失默些信息，每台主机的超时限制为75秒，对每次探测只等待0.3秒。

nmap -sS -T1 IP

-sV 探测端口的服务类型/具体版本等信息

nmap -vv -sV IP

-p 端口号 对某个端口的服务版本进行详细探测，有助于升入的针对性攻击，比如缓冲溢出攻击

nmap -vv -sV IP -p 21

适用于内外网的探测，以内网操作为示例（外网参数同）

简单端口扫描：nmap -vv -sT(sS、sF、sU、sA) 192.168.0.1 -D 127.0.0.1
（-D 伪造的地址）

OS检测：nmap -vv -sS -O 192.168.0.1

RPC鉴别：nmap -sS -sR 192.168.0.1
Linux 上的 portmap 就是一个简单的 RPC 服务，监听端口为111（默认）

Ping 扫射：nmap -sP 172.16.15.0/24

三、十条nmap常用的扫描命令

1）获取远程主机的系统类型及开放端口

nmap -sS -P0 -sV -O <target>

这里的 < target > 可以是单一IP，或主机名，或域名，或子网
-sS TCP SYN 扫描（又称半开放，或隐身扫描）
-P0 允许你关闭 ICMP pings.
-sV 打开系统版本检测
-O 尝试识别远程操作系统
其它选项：
-A 同时启用操作系统指纹识别和版本检测
-v 详细输出扫描情况
nmap -sS -P0 -A -v

2）列出开放了指定端口的主机列表

nmap -sT -p 80 -oG – 192.168.1.* | grep open

更改-p参数来指定端口号。参考“man nmap”中指定地址范围的不同方法。

3）在网络中寻找所有在线主机

nmap -sP 192.168.0.*
# 或者也可用以下命令指定 subnet：
nmap -sP 192.168.0.0/24

4）Ping指定范围内的 IP 地址

nmap -sP 192.168.1.100-254

nmap接受多种寻址符号、多个目标/范围等。

5）在某段子网上查找未占用的IP

nmap -T4 -sP 192.168.2.0/24 && egrep "00:00:00:00:00:00" /proc/net/arp

6）在局域网上扫描Conficker蠕虫病毒

nmap -PN -T4 -p139,445 -n -v -script=smb-check-vulns -script-args safe=1 192.168.0.1-254

将192.168.0.1-256替换成你想要检查的IP

7）扫描网络上的恶意接入点（rogue APs）

nmap -A -p1-85,113,443,8080-8100 -T4 -min-hostgroup 50 -max-rtt-timeout 2000 -initial-rtt-timeout 300 -max-retries 3 -host-timeout 20m -max-scan-delay 1000 -oA wapscan 10.0.0.0/8

我用这个扫描命令成功地在一个非常大的网络中找到许多流氓APs。

8）使用诱饵扫描方法来扫描主机端口
在扫描端口时使用诱饵，以避免被系统管理员捕获

sudo nmap -sS 192.168.0.10 -D 192.168.0.2

扫描目标设备/计算机（192.168.0.10）上打开的端口，同时设置一个诱饵地址（192.168.0.2）。这将在目标安全日志中显示诱饵ip地址，而不是您的ip。诱饵地址必须是活的。检查/var/log/secure上的目标安全日志，确保它工作正常。

9）子网的反向DNS记录列表

nmap -R -sL 209.85.229.99/27 | awk '{if($3=="not")print"("$2") no PTR";else print$3" is "$2}' | grep '('

10）显示网络上共有多少台Linux及Win设备

sudo nmap -F -O 192.168.1.1-255 | grep "Running: " > /tmp/os; echo "$(cat /tmp/os | grep Linux | wc -l) Linux device(s)"; echo "$(cat /tmp/os | grep Windows | wc -l) Window(s) devices"

四、nmap命令完整思维导图

Linux环境下通过一些命令快速操作数据库。

# 连接mysql（注：-h、-P、-u、-p后面可以不用加空格）
mysql -h主机地址 -P端口 -u用户名 -p用户密码

# 显示数据库
mysql> show databases;

# 使用某个数据库
mysql> use xxx;

# 查看该数据库中的表
mysql> show tables;

# 显示数据表的结构
mysql> describe 表名;

# 显示表中的记录（注意表名大小写）
mysql> select * from 表名;

# 创建数据库
mysql> create database 数据库名;

# 建表  
use 库名;
create table 表名 （跟上字段列表）;
# 例如：创建表user,表中有id（序号，自增），name（姓名）,gender（性别）,birthday（出身年月）四个字段  
mysql> use blog;  
mysql> create table user (id int(3) auto_increment not null primary key, name char(8),gender char(2),birthday date);
mysql> describe name;

# 往表中增加数据
# 例如：增加几条相关纪录。  
mysql> insert into user values('','张三','男','2019-01-01');  
mysql> insert into user values('','李四','女','2020-06-01');
mysql> select * from name;

# 修改表中数据
# 例如：将张三的出生年月改为2019-06-01
mysql> update user set birthday='2019-01-01' where name='张三';  

# 删除某表中的数据  
# 例如：删除名字是张三的数据。  
mysql> delete from user where name='张三';  

# 删库和删表  
mysql> drop database 库名;
mysql> drop table 表名;

# 退出mysql
mysql> exit (回车)

在Windows开发环境下安装MySQL5.7，使用官方免安装软件包，手动启停服务和编写批处理脚本实现MySQL启停。

一、安装

1. 下载免安装软件包

我比较喜欢免安装版本的，比较干净。
到官网的开发者专区下载MySQL（Community版）免安装软件包，
下载地址：https://dev.mysql.com/downloads/mysql/
* 当前最新版本是8.0，如果需要下载其它版本，可以点击页面中的 Looking for previous GA versions? （未来版本超链接入口可能会有变化）

2. 解压压缩包

将下载的软件包解压并重命名到 D:\Program Files\mysql-5.7 目录下。

3. 进入命令行终端

以Window10为例，
【开始】-【搜索程序和文件】输入 cmd，在搜索到的程序图标上点击鼠标右键，选择【以管理员身份运行】。

4. 进入命令行终端

依次输入如下指令：

C:\Windows\system32> d:
D:\> cd D:\Program Files\mysql-5.7\bin

5. 初始化MySQL

初始化可以选择带有随机密码或无密码，建议采用无密码初始化（可以设置密码），以免随机密码丢失。

D:\Program Files\mysql-5.7\bin> mysqld --initialize（随机密码）

D:\Program Files\mysql-5.7\bin> mysqld --initialize-insecure（无密码）

6. 安装mysqld

D:\Program Files\mysql-5.7\bin> mysqld -install

* mysql 用于执行SQL命令，mysqld 用于执行数据库命令。

7. 启动MySQL服务

D:\Program Files\mysql-5.7\bin> net start mysql

8. 登录MySQL

D:\Program Files\mysql-5.7\bin> mysql -u root -p
Enter password:（无密码则直接回车）

二、添加root账号登录密码

1. 停止MySQL服务

D:\Program Files\mysql-5.7\bin> net stop mysql

2. 跳过密码验证

D:\Program Files\mysql-5.7\bin> mysqld --console --skip-grant-tables

此时，当前命令行终端窗口不能再输入命令了，我们需要再打开一个命令行窗口，进入 D:\Program Files\mysql-5.7\bin>，方式和前面一样，即输入下面两行命令：

C:\Windows\system32> d:
D:\> cd D:\Program Files\mysql-5.7\bin

3. 登录MySQL

D:\Program Files\mysql-5.7\bin> mysql -u root -p
Enter password:（无需密码直接回车）

4. 切换数据库

mysql> use mysql;

5. 执行修改密码的语句

当前新版本的MySQL有密码规则：必须包含大写字母、小写字母、特殊符号并且8位以上。
我们这边是强行修改字段的，会有警告，但现在是开发环境，可以不管它，就把密码设置成 123456 即可。

mysql> update mysql.user set authentication_string=password('123456') where user='root';

6. 刷新权限并退出MySQL

mysql> flush privileges;
mysql> quit;

7. 终止mysqld

回到第一个命令行窗口，按 “Ctrl+C” 结束进程或者按 “Ctrl+Alt+Del” 打开任务管理器，结束“mysqld.exe”的进程。

8. 重新启动MySQL服务

D:\Program Files\mysql-5.7\bin> net start mysql

9. 登录MySQL

D:\Program Files\mysql-5.7\bin> mysql -u root -p
Enter password:123456

此时必须使用刚添加的密码才能登录MySQL。

三、编写批处理脚本实现MySQL启停

在前面安装完MySQL后，我们每次开机都是通过输入命令来切换目录、启停MySQL的，长期使用显然比较麻烦，为了偷懒，下面编写一个批处理脚本。

1. 系统环境变量配置

（1）新增系统变量
变量名：MYSQL_HOME
变量值：MySQL解压目录，如 D:\Program Files\mysql-5.7

（2）追加PATH
%MYSQL_HOME%\bin

2. 编写批处理脚本

创建一个文件，并以 .bat 为后缀，如 mysql.bat，打开编辑，输入如下内容。输入后以管理员身份运行。（前提要MySQL已经安装或配置成功）

cls 
@echo off
:设置窗口字体颜色
color 0F 
:设置窗口标题
TITLE MySQL管理程序 by winyuan

call :checkAdmin

goto menu
:菜单
:menu
cls
echo. 
echo.========= 请选择您要对MySQL的操作 =========
echo.
echo.1: 启动MySQL
echo.
echo.2: 关闭MySQL
echo. 
echo.3: 重启MySQL
echo. 
echo.4: 退 出
echo.
echo.========= 请输入您要选择的项目序号 =========
set /p id=
if "%id%"=="1" goto startup
if "%id%"=="2" goto shutdown
if "%id%"=="3" goto reboot
if "%id%"=="4" exit
pause

:启动
:startup
echo.
call :checkMySQL 1
echo.启动MySQL......
net start "MySQL"
echo.启动MySQL成功！
pause 
goto menu 

:停止
:shutdown
echo.
call :checkMySQL 2
echo.关闭MySQL......
net stop "MySQL"
echo.关闭MySQL成功！
pause 
goto menu

:重启
:reboot
echo.
call :checkMySQL 2
echo.关闭MySQL......
net stop "MySQL"
echo.关闭MySQL成功！
goto startup
goto menu

:退出
:goout
pause
goto menu

:检查MySQL进程是否存在
:checkMySQL
set /a count=0
for /f "tokens=1 delims= " %%i in ('tasklist /nh ^| find /i "MySQL"') do (set /a count+=1)
if %count% neq 0 if "%1" equ "1" (
  echo 警告：MySQL已启动
  goto goout
)
if %count% equ 0 if "%1" equ "2" (
  echo 警告：MySQL未启动
  goto goout
)

:检查是否是以管理员身份运行
:checkAdmin
echo test am i admin? > %SystemRoot%\System32\wenyuanblog.txt
if not exist %SystemRoot%\System32\wenyuanblog.txt (
  echo 警告：请以管理员身份运行！
  pause
  exit
)
del %SystemRoot%\System32\wenyuanblog.txt

最后，用管理员身份运行 mysql.bat，如下图所示：

参考
django中文网

Python实时获取tcpdump输出。

一、背景

今天有个小需求，要确认客户端有没有往服务端发送udp包，但为了减轻工作量，不想每次到机器上手动执行tcpdump抓包命令。
于是就写了个脚本来释放人力。

二、代码实现

整个脚本我还加了一些其他功能：时间戳、发送端IP提取，数据包分析，数据持久化等。这里都先去掉，仅记录下简单的实时获取tcpdump输出功能。
代码如下：

# -*- coding: utf-8 -*-
# !/usr/bin/env python

# sudo tcpdump -tt -l -nn -c 5 -i enp4s0 udp port 514 or 51414

import subprocess

cmd = ['sudo', 'tcpdump', '-tt', '-l', '-nn', '-c', '5', '-i', 'enp4s0', 'udp', 'port', '514', 'or', '51414']
proc = subprocess.Popen(cmd, stdout=subprocess.PIPE)

while True:
    line = proc.stdout.readline()
    line = line.strip()
    if not line:
        print('tcpdump finished...')
        break
    print(line)

输出如下（实时）：

wenyuanblog@localhost:/home/test/script# python tcpdump_udp.py 
tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on enp4s0, link-type EN10MB (Ethernet), capture size 262144 bytes
1499774951.124178 IP 192.168.10.210.41974 > 192.168.10.251.514: UDP, length 139
1499774953.125664 IP 192.168.10.210.54995 > 192.168.10.251.51414: UDP, length 139
1499774956.128498 IP 192.168.10.210.56748 > 192.168.10.251.514: UDP, length 139
1499774958.129918 IP 192.168.10.210.53883 > 192.168.10.251.51414: UDP, length 139
1499774961.132921 IP 192.168.10.210.58803 > 192.168.10.251.514: UDP, length 139
5 packets captured
6 packets received by filter
0 packets dropped by kernel
tcpdump finished...

以上代码相当于手动执行了 sudo tcpdump -tt -l -nn -c 5 -i enp4s0 udp port 514 or 51414 这条命令。
注意参数-l很重要（行显）。

三、代码实现（更新）

上面的代码能实现tcpdump的功能，但是有一个问题：没有做超时保护。即当程序执行时间过长时kill该进程（这里使用ctrl+c的方式）。
要实现这个功能有很多种方案，例如定时器+多线程等，这里仅演示一种方案，代码如下：

# -*- coding: utf-8 -*-
# !/usr/bin/env python

# sudo tcpdump -tt -l -nn -c 50 -i enp4s0 udp port 514 or 51414

import subprocess
import signal
import time
import os
import re
import json

class CmdServer:

    def __init__(self, cmd, timeout=120):
        '''
        :param cmd: 执行命令（列表形式）
        :param timeout: 任务超时时间（seconds，进程运行超过该时间，kill该进程）
        :param taskname: 任务名称（根据该任务名称记录命令输出信息）
        '''
        self.cmd = cmd
        self.timeout = timeout
        self.base_path = reduce(lambda x, y: os.path.dirname(x), range(1), os.path.abspath(__file__))
        self.output_path = os.path.join(self.base_path, 'data.json')
        self.udp_flow_list = []
        self.begin_time = int(time.time())

    # 执行tcpdump任务
    def run(self):
        if os.path.exists(self.output_path):
            with open(self.output_path, 'r') as f:
                self.udp_flow_list = json.load(f)

        proc = subprocess.Popen(self.cmd, stdout=subprocess.PIPE)
        stdout = ''

        while proc.poll() == None:
            current_time = int(time.time())
            if current_time - self.begin_time >= self.timeout:
                print('tcpdump timeout...')
                proc.send_signal(signal.SIGINT)
                stdout = proc.stdout.read()

        if proc.poll() is not None and not stdout:
            print('tcpdump finished...')
            stdout = proc.stdout.read()

        stdout_list = stdout.split('\n')
        if stdout_list:
            self._merge_data(stdout_list)
            self._save_data()

    # 数据合并（新增/更新）
    def _merge_data(self, stdout_list):
        for line in stdout_list:
            line = line.strip()
            if not line:
                continue
            timestamp = int(float(line.split('IP')[0].strip())) * 1000
            # 源
            src_ip_port_list = re.findall(r'IP(.+?)>', line)
            if not src_ip_port_list:
                continue
            src_ip_port_str = src_ip_port_list[0].strip()
            src_ip = '.'.join(src_ip_port_str.split('.')[0:4])
            # 目的
            dst_ip_port_list = re.findall(r'>(.+?):', line)
            if not dst_ip_port_list:
                continue
            dst_ip_port_str = dst_ip_port_list[0].strip()
            dst_port = dst_ip_port_str.split('.')[-1]

            # 新增/更新latest_timestamp
            src_item = filter(lambda x: src_ip == x['src_ip'], self.udp_flow_list)
            if src_item:
                src_item[0]['dst_port'] = dst_port
                src_item[0]['latest_timestamp'] = timestamp
            else:
                self.udp_flow_list.append(dict(
                    src_ip=src_ip,
                    dst_port=dst_port,
                    latest_timestamp=timestamp
                ))

    # 保存数据
    def _save_data(self):
        # 写入文件
        with open(self.output_path, 'w') as f:
            json.dump(self.udp_flow_list, f, encoding="utf-8", ensure_ascii=False)

if __name__ == '__main__':
    cmd = ['sudo', 'tcpdump', '-tt', '-l', '-nn', '-c', '5', '-i', 'enp4s0', 'udp', 'port', '514', 'or', '51414']
    cmd_server = CmdServer(cmd, 10)
    cmd_server.run()

四、总结

比较简单，仅仅是记录下。如果想基于Python的tcpdump做一些业务上的逻辑，可以参考下面的“参考链接”。
参考
https://blog.csdn.net/wskzgz/article/details/83822780
https://blog.csdn.net/wangqiuyun/article/details/46966839
http://www.cnblogs.com/idvcn/p/8716066.html
https://blog.csdn.net/kobeyan/article/details/4344192
https://blog.csdn.net/xhw88398569/article/details/48022967

异常值检测是数据预处理阶段重要的环节，这篇文章介绍下对于单变量异常值检测的常用方法，通过Python代码实现。

一、什么是异常值

异常值是在数据集中与其他观察值有很大差距的数据点，它的存在，会对随后的计算结果产生不适当的影响，因此检测异常值并加以适当的处理是十分必要的。

二、异常值的处理

异常值并不都是坏的，了解这一点非常重要。只是简单地从数据中删除异常值，而不考虑它们如何影响结果的话，可能会导致灾难。

“异常值不一定是坏事。这些只是与其他模式不一致的观察。但事实上异常值非常有趣。例如，如果在生物实验中，某只老鼠没有死亡而其他老鼠都死了，去了解为什么将会非常有趣。这可能会带来新的科学发现。因此，检测异常值非常重要。” —— Pierre Lafaye de Micheaux，统计师

对于异常值，一般有如下几种处理：

• 删除含有异常值的记录（是否删除根据实际情况考虑）
• 将异常值视为缺失值，利用缺失值的处理方法进行处理
• 平均值修正（前后两个观测值的平均值）
• 不处理（直接在具有异常值的数据集上进行挖掘）

三、异常值的类型

异常值有两种类型：单变量和多变量（Univariate and Multivariate）。单变量异常值是仅由一个变量中的极值组成的数据点，而多变量异常值是至少两个变量的组合异常分数。假设您有三个不同的变量 – X，Y，Z。如果您在三维空间中绘制这些变量的图形，它们应该形成一种云。位于此云之外的所有数据点都将是多变量异常值。

举个例子：做客户分析，发现客户的年平均收入是80万美元。但是，有两个客户的年收入是4美元和420万美元。这两个客户的年收入明显不同于其他人，那这两个观察结果将被视为异常值，并且是单变量异常值，当我们看到单变量的分布时，可以找到这些异常值。

再举个例子：身高和体重之间的关系。我们对“身高”和“体重”有单变量和双变量分布，如下图所示。

看箱线图（box plot后面会介绍）没有任何异常值，再看散点图（scatter plot），有两个值在一个特定的身高和体重的平均值以下。可见多变量异常值是n维空间中的异常值，必须通过多维度的分布才能体现出来。

如果对异常值不太了解，可以阅读这篇《数据探索指南》，上述部分解释也是从中摘录的。
下面，我主要记录下单变量异常值检测的Python实现。

四、常用异常检测方法

原则上模拟数据集需要样本量足够大，这里仅是演示算法，所以就手动写了有限的样本。
异常值的测量标准有很多，比较常见的是描述性统计法、三西格玛法（3σ法）、箱线图等：

1. 描述性统计

基于常识或经验，假定我们认为大于10的数值是不符合常理的。

下面用Python代码实现用描述性统计求异常值：

# -*- coding: utf-8 -*-

data = [2.78, 1.79, 4.73, 3.81, 2.78, 1.80, 4.81, 2.79, 1.78, 3.32, 10.8, 100.0]
threshold = 10

# 定义描述性统计识别异常值函数
def descriptive_statistics(data):
    return list(filter(lambda x: x > threshold, data))

outliers = descriptive_statistics(data)
print('异常值共有：{0}个，分别是：{1}'.format(len(outliers), outliers))

# 输出：异常值共有：2个，分别是：[10.8, 100.0]

2. 三西格玛（3σ）

当数据服从正态分布时，99%的数值应该位于距离均值3个标准差之内的距离，P(|x−μ|>3σ)≤0.003，当数值超出这个距离，可以认为它是异常值。
正态分布状况下，数值分布表：

注：在正态分布中σ代表标准差，μ代表均值，x=μ为图形的对称轴

下面用Python代码实现用三西格玛求异常值：

# -*- coding: utf-8 -*-

import pandas as pd
import numpy as np

data = [2.78, 1.79, 4.73, 3.81, 2.78, 1.80, 4.81, 2.79, 1.78, 3.32, 10.8, 100.0]

# 定义3σ法则识别异常值函数
def three_sigma(data_series):
    rule = (data_series.mean() - 3 * data_series.std() > data_series) | (data_series.mean() + 3 * data_series.std() < data_series)
    index = np.arange(data_series.shape[0])[rule]
    outliers = data_series.iloc[index]
    return outliers.tolist()

data_series = pd.Series(data)
outliers = three_sigma(data_series)
print('异常值共有：{0}个，分别是：{1}'.format(len(outliers), outliers))

# 输出：异常值共有：1个，分别是：[100.0]

3. 箱线图（box plot）

和3σ原则相比，箱线图依据实际数据绘制，真实、直观地表现出了数据分布的本来面貌，且没有对数据作任何限制性要求（3σ原则要求数据服从正态分布或近似服从正态分布）。
其判断异常值的标准以四分位数和四分位距为基础。四分位数给出了数据分布的中心、散布和形状的某种指示，具有一定的鲁棒性，即25%的数据可以变得任意远而不会很大地扰动四分位数，所以异常值通常不能对这个标准施加影响。鉴于此，箱线图识别异常值的结果比较客观，因此在识别异常值方面具有一定的优越性。
箱线图提供了识别异常值的一个标准，即：
上界 = Q3 + 1.5IQR
下界 = Q1 – 1.5IQR
小于下界或大于上界的值即为异常值。
其中，
Q3称为上四分位数（75%），表示全部观察值中只有四分之一的数据取值比它大；
Q1称为下四分位数（25%），表示全部观察值中只有四分之一的数据取值比它小；
IQR称为四分位数差，这里就是 Q3-Q1；
1.5其实是个参数λ，这个参数通常取1.5（类似于正态分布中的μ±λ）

文字描述可能比较绕，下面用图片来解释下。

第一四分位数 (Q1)，又称“较小四分位数”，等于该样本中所有数值由小到大排列后第25%的数字。
第二四分位数 (Q2)，又称“中位数”，等于该样本中所有数值由小到大排列后第50%的数字。
第三四分位数 (Q3)，又称“较大四分位数”，等于该样本中所有数值由小到大排列后第75%的数字。
Q3与Q1的差距又称四分位距（InterQuartile Range,IQR）。

四分位数的计算参见四分位数和四分位数的计算

下面用Python代码实现用箱线图求异常值：

# -*- coding: utf-8 -*-

import pandas as pd

data = [2.78, 1.79, 4.73, 3.81, 2.78, 1.80, 4.81, 2.79, 1.78, 3.32, 10.8, 100.0]

# 定义箱线图识别异常值函数
def box_plot(data_series):
    q_abnormal_low = data_series.quantile(0.25) - 1.5 * (data_series.quantile(0.75) - data_series.quantile(0.25))
    q_abnormal_up = data_series.quantile(0.75) + 1.5 * (data_series.quantile(0.75) - data_series.quantile(0.25))
    index = (data_series < q_abnormal_low) | (data_series > q_abnormal_up)
    outliers = data_series.loc[index]
    return outliers.tolist()

sorted_data = sorted(data)
data_series = pd.Series(sorted_data)
outliers = box_plot(data_series)
print('异常值共有：{0}个，分别是：{1}'.format(len(outliers), outliers))

# 输出：异常值共有：2个，分别是：[10.8, 100.0]

五、总结

以上是最基础的几种单变量异常值检测方法，没有最好的，只有对当前数据场景最合适的。
后期如果涉及机器学习的数据预处理，我会继续学习和研究多变量异常值的检测，相信会有更有意思的一些算法等着我去学习。
参考
异常检测的N种方法，阿里工程师都盘出来了：https://mp.weixin.qq.com/s/w7SbAHxZsmHqFtTG8ZAXNg
数据探索指南：https://www.analyticsvidhya.com/blog/2016/01/guide-data-exploration/?utm_source=outlierdetectionpyod&utm_medium=blog
Tukey method：https://en.wikipedia.org/wiki/Tukey%27s_range_test
图基（Tukey）检验：一种值得倍加推崇的检验方法：http://blog.sina.com.cn/s/blog_60be90250100eojy.html
如何从大量数据中找出异常值：https://blog.csdn.net/wangyangzhizhou/article/details/83854951
概率论与数理统计 第四版 浙江大学出版社：https://book.douban.com/subject/3165271/