脚本中路由跟踪怎样更直观

本文目录导读：

1. 核心思路：将“逐跳列表”转化为“时间线地图”
2. 纯脚本实现（Bash/Python，无需外部依赖）
3. 升级方案：结合地理位置（需要外部数据）
4. 最终极方案：Web 可视化（用 Python + Flask + Leaflet 地图）
5. 即时可用的一站式脚本（推荐 mtr + 管道处理）
6. 根据场景选择

要让脚本中的路由跟踪（traceroute）结果更直观，可以从视觉呈现、信息聚合、异常检测和交互性四个维度入手，以下是几种实用方案，涵盖从简单命令行美化到复杂可视化图表。

核心思路：将“逐跳列表”转化为“时间线地图”

传统 traceroute 输出是一串 IP 和延迟，更直观的方式是：

• 用符号表示延迟高低（如 长度代表毫秒）
• 用颜色表示稳定性（红色=超时/高延迟，绿色=正常）
• 用地图标注地理位置（需要 GeoIP 数据库）

纯脚本实现（Bash/Python，无需外部依赖）

方案A：彩色延迟条（Bash + mtr 或 traceroute）

#!/bin/bash
# 功能：对 traceroute 结果进行彩色柱状图显示
TARGET="8.8.8.8"
traceroute -q 1 -n "$TARGET" | awk '
/^[0-9]+/ {
    hop=$1
    ip=$2
    ms=$(NF-1)  # 通常第4个字段是时间
    if (ms == "*") {
        color="\033[31m"  # 红色 - 超时
        bar="✗"
    } else if (ms+0 > 200) {
        color="\033[31m"  # 红色 - 高延迟
        bar=sprintf("%*s", int(ms/10), "█")
    } else if (ms+0 > 100) {
        color="\033[33m"  # 黄色 - 中延迟
        bar=sprintf("%*s", int(ms/10), "▅")
    } else {
        color="\033[32m"  # 绿色 - 低延迟
        bar=sprintf("%*s", int(ms/10), "▂")
    }
    printf "%2s %-15s %s %4s ms %s\033[0m\n", hop, ip, color, ms, bar
}'

效果：每跳显示绿色/黄色/红色条，超时显示红叉，一眼看出瓶颈集中在哪几跳。

方案B：Python 实时 ASCII 动画（更精细）

import subprocess, re, time, sys
def trace_visual(target="google.com"):
    cmd = ["traceroute", "-q1", "-n", target]
    proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
    print(f"网络路由追踪：{target}")
    print(f"{'跳数':<4} {'IP地址':<16} {'延迟':<6}  可视化")
    print("-"*60)
    for line in iter(proc.stdout.readline, ''):
        match = re.search(r'(\d+)\s+(\S+)\s+(\S+)\s+ms', line)
        if match:
            hop = match.group(1)
            ip = match.group(2)
            ms = float(match.group(3))
            # 生成动态条
            bar_count = min(int(ms/5), 30)  # 最多30个字符
            if ms > 200:
                bar = "🔴" + "▓"*bar_count
            elif ms > 100:
                bar = "🟡" + "▒"*bar_count
            else:
                bar = "🟢" + "░"*bar_count
            print(f"{hop:<4} {ip:<16} {ms:<6.1f} {bar}")
            sys.stdout.flush()
            time.sleep(0.1)  # 模拟实时刷新
    print("-"*60)
    print("追踪完成")
if __name__ == "__main__":
    trace_visual("1.1.1.1")

升级方案：结合地理位置（需要外部数据）

安装 geoiplookup 或使用 ip-api.com 免费 API（注意限流）：

import requests, json, time
def geo_ip(ip):
    try:
        resp = requests.get(f"http://ip-api.com/json/{ip}", timeout=2)
        data = resp.json()
        return f"{data.get('city','?')}, {data.get('country','?')}"
    except:
        return "未知"
# 在以上 Python 代码的循环内加入：
geo = geo_ip(ip)
print(f"{hop:<4} {ip:<16} {ms:<6.1f} {bar:<20} 🌍 {geo}")

效果：每跳旁边显示“北京，中国” -> “东京，日本” -> “洛杉矶，美国”，路径一目了然。

最终极方案：Web 可视化（用 Python + Flask + Leaflet 地图）

适合需要分享或深入分析的路由追踪：

from flask import Flask, render_template_string
import subprocess, re, json
app = Flask(__name__)
def trace_to_geo(target="google.com"):
    # 执行 traceroute 并收集 IP
    result = subprocess.run(["traceroute", "-n", target], capture_output=True, text=True)
    ips = []
    for line in result.stdout.splitlines():
        m = re.search(r'\d+\s+(\S+)', line)
        if m:
            ip = m.group(1)
            if ip != '*':
                ips.append(ip)
    # 用 ip-api 获取经纬度（批量查询更快）
    geos = []
    for i, ip in enumerate(ips):
        try:
            resp = requests.get(f"http://ip-api.com/json/{ip}").json()
            geos.append({"ip": ip, "lat": resp['lat'], "lon": resp['lon'], "loc": f"{resp['city']}, {resp['country']}"})
        except:
            geos.append({"ip": ip, "lat": 0, "lon": 0, "loc": "未知"})
        time.sleep(0.1)  # 延迟避免封IP
    return geos
@app.route('/')
def index():
    data = trace_to_geo("8.8.8.8")  # 可以改为表单输入
    js_data = json.dumps(data)
    return render_template_string("""
    <!DOCTYPE html>
    <html>
      <head>
        <link rel="stylesheet" href="https://unpkg.com/leaflet@1.9.4/dist/leaflet.css" />
        <script src="https://unpkg.com/leaflet@1.9.4/dist/leaflet.js"></script>
        <style>#map { height: 600px; }</style>
      </head>
      <body>
        <h3>路由追踪可视化 - 8.8.8.8</h3>
        <div id="map"></div>
        <script>
          var map = L.map('map').setView([20, 0], 2);
          L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png').addTo(map);
          var points = {{ data|safe }};
          var latlngs = [];
          points.forEach(function(p) {
            if(p.lat && p.lon) {
              var marker = L.marker([p.lat, p.lon]).addTo(map);
              marker.bindPopup(p.loc + '<br>' + p.ip);
              latlngs.push([p.lat, p.lon]);
            }
          });
          L.polyline(latlngs, {color: 'red'}).addTo(map);
          map.fitBounds(latlngs);
        </script>
      </body>
    </html>
    """, data=js_data)
if __name__ == '__main__':
    app.run(debug=True)

效果：打开浏览器，世界地图上用红线连接每一跳，点击标记显示位置和 IP。

即时可用的一站式脚本（推荐 mtr + 管道处理）

如果不想写代码,直接用 mtr 命令：

# 安装 mtr (大多系统自带)
mtr -r -c 5 -n 8.8.8.8 | head -20

-r 生成报告模式，但输出仍是表格，可以配合 mtr --report-wide 或者用 mtr --json 然后自己解析渲染。

根据场景选择

最推荐的标准做法：写一个 Python 脚本，用 subprocess 调用系统 traceroute，解析输出后：用颜色区分延迟等级 + 用简短国家/城市名标注位置 + 输出格式对齐到终端列宽，这样不需要任何额外安装，就实现了“一眼看清网络路径”。