Skip to content

日志里几百万条 IPv6,别一条条查归属地:按 /48 前缀聚合,请求量砍掉九成(Go 实现) ​

朋友的日志平台每天进 1200 万条访问记录,IPv6 占三成八。运营想要一张「访客省份分布」的图,运维小哥接了活,写了段循环:读一行日志,调一次 IP 归属地接口,写回 ClickHouse。跑了一晚上,进度条动了不到 2%。

算一下就知道跑不完。456 万条 IPv6 记录,免费接口 60 次/分钟,不吃不睡要 52 天。花点钱上 VIP 当然能解决,但这里有个更根本的问题被忽略了:这 456 万条记录,实际落在多少条不同的「网络」上?

一、IPv6 不是「一人一个地址」,是「一人一个 /64」 ​

IPv4 时代我们习惯一个地址对应一条记录。IPv6 完全不同,运营商是按块分配的:

前缀长度通常给谁数量级
/32一家运营商(或一个大型 IDC)全国几十个
/48一个省网、一个地市、一个企业专线每运营商上万
/56部分家宽小区—
/64一个用户、一个家庭路由器一个 /48 下有 65536 个

也就是说,一个家庭宽带用户随手就能拿到一整个 /64,里面的地址数量是 2 的 64 次方。日志里看到的「几百万个不同 IPv6」,绝大部分来自同一批 /48。

这不是理论。我拿几个地址实测了一遍,同一家运营商 2408:8000 这个 /32 下面:

查询的地址归属地运营商
2408:8000:1000::1北京 / 北京中国联通城域网
2408:8000:1000:1::5北京 / 北京中国联通城域网
2408:8000:2000::9天津 / 天津中国联通城域网
2408:8000:ffff::1山东 / 济南中国联通城域网
240e:1:1000::1黑龙江 / 齐齐哈尔中国电信城域网

两个结论:

  1. 同一个 /48 内的地址,归属地完全一致(前两行);
  2. 同一个 /32 下,不同 /48 会跨市甚至跨省(后面三行)。

所以聚合的粒度只能是 /48。按 /32 聚合会把北京、天津、济南算成一个城市;按 /64 聚合省不了多少请求,因为一个用户本来就可能用到多个 /64。

二、动手之前,先把地址写法归一 ​

IPv6 的写法比 IPv4 花得多,日志里常见这几种,不归一化会白白多出几倍的「不同前缀」:

  • 完整写法:2408:0800:1000:0000:0000:0000:0000:0001
  • 压缩写法:2408:8000:1000::1
  • 大小写混用:240e:0:9000::1 和 240E:0:9000::1 是同一个地址(十六进制不分大小写)
  • 带方括号:access log 里常见 [2408:8000:1000::1],直接丢进查询会报 400,得先剥掉括号
  • IPv4 映射地址:::ffff:114.114.114.114——这个最容易出错,它本质上是个 IPv4 地址,直接当 IPv6 查,城市信息会缺
  • 带 zone:fe80::1%eth0,链路本地地址,日志里出现直接丢掉

Go 的标准库 net/netip 把这几种都能吃掉:netip.ParseAddr 解析、Is4In6() 判断映射地址、Unmap() 转回 IPv4、Prefix(48) 取前缀。不引第三方库。

三、Go 实现 ​

流程很短:读日志 → 解析地址 → 归一化 → 取 /48 前缀 → 计数 → 对每个前缀的「代表地址」查一次。

go
// ipv6_prefix_geo.go —— 按 /48 前缀聚合日志里的 IPv6,再批量补归属地
package main

import (
	"bufio"
	"encoding/json"
	"flag"
	"fmt"
	"net/http"
	"net/netip"
	"os"
	"sort"
	"strings"
	"time"
)

const api = "https://ip9.com.cn/get"

type geo struct {
	Country string `json:"country"`
	Prov    string `json:"prov"`
	City    string `json:"city"`
	ISP     string `json:"isp"`
}

type response struct {
	Ret  int  `json:"ret"`
	Data *geo `json:"data"`
}

type bucket struct {
	prefix string
	sample netip.Addr
	count  int
}

// prefixOf 返回「代表地址 + 前缀字符串」:IPv4 按 /24,IPv6 按 /48
func prefixOf(a netip.Addr) (netip.Addr, string) {
	if a.Is4() {
		p, _ := a.Prefix(24)
		return p.Addr(), p.String()
	}
	p, _ := a.Prefix(48)
	return p.Addr(), p.String()
}

func query(ip string) (geo, error) {
	client := &http.Client{Timeout: 6 * time.Second}
	res, err := client.Get(api + "?ip=" + ip)
	if err != nil {
		return geo{}, err
	}
	defer res.Body.Close()
	if res.StatusCode != http.StatusOK {
		return geo{}, fmt.Errorf("HTTP %d", res.StatusCode)
	}
	var r response
	if err := json.NewDecoder(res.Body).Decode(&r); err != nil {
		return geo{}, err
	}
	if r.Ret != 200 || r.Data == nil {
		return geo{}, fmt.Errorf("ret=%d", r.Ret)
	}
	return *r.Data, nil
}

func main() {
	file := flag.String("f", "access.log", "日志文件,每行第一列是客户端 IP")
	top := flag.Int("n", 10, "输出访问量前 N 个前缀")
	interval := flag.Duration("i", 1100*time.Millisecond, "两次请求的间隔,免费版 60 次/分钟")
	flag.Parse()

	f, err := os.Open(*file)
	if err != nil {
		fmt.Fprintln(os.Stderr, "打开日志失败:", err)
		os.Exit(1)
	}
	defer f.Close()

	buckets := map[string]*bucket{}
	lines, skipped, private := 0, 0, 0
	sc := bufio.NewScanner(f)
	sc.Buffer(make([]byte, 0, 64*1024), 1024*1024)
	for sc.Scan() {
		lines++
		fields := strings.Fields(sc.Text())
		if len(fields) == 0 {
			continue
		}
		a, err := netip.ParseAddr(strings.Trim(fields[0], "[]"))
		if err != nil {
			skipped++
			continue
		}
		if a.Is4In6() {
			a = a.Unmap() // ::ffff:1.2.3.4 要当 IPv4 查,否则查不到城市
		}
		if a.IsLoopback() || a.IsPrivate() || a.IsLinkLocalUnicast() {
			private++
			continue
		}
		rep, key := prefixOf(a)
		b := buckets[key]
		if b == nil {
			b = &bucket{prefix: key, sample: rep}
			buckets[key] = b
		}
		b.count++
	}
	if err := sc.Err(); err != nil {
		fmt.Fprintln(os.Stderr, "读日志出错:", err)
		os.Exit(1)
	}

	list := make([]*bucket, 0, len(buckets))
	for _, b := range buckets {
		list = append(list, b)
	}
	sort.Slice(list, func(i, j int) bool { return list[i].count > list[j].count })

	fmt.Printf("日志 %d 行,去重后 %d 个前缀(跳过私网/回环 %d 行,非法地址 %d 行)\n\n",
		lines, len(list), private, skipped)
	fmt.Printf("%-22s %8s  %-6s %-8s %s\n", "前缀", "请求数", "省份", "城市", "运营商")

	cache := map[string]geo{}
	failed := 0
	for i, b := range list {
		if i >= *top {
			break
		}
		g, ok := cache[b.prefix]
		if !ok {
			var err error
			for attempt := 0; attempt < 2; attempt++ {
				g, err = query(b.sample.String())
				if err == nil {
					break
				}
				time.Sleep(*interval) // 撞限速或网络抖动,隔一拍重试
			}
			if err != nil {
				failed++
				fmt.Printf("%-22s %8d  %s\n", b.prefix, b.count, "查询失败: "+err.Error())
				continue
			}
			cache[b.prefix] = g
			time.Sleep(*interval)
		}
		fmt.Printf("%-22s %8d  %-6s %-8s %s\n", b.prefix, b.count, g.Prov, g.City, g.ISP)
	}
	if failed > 0 {
		fmt.Printf("\n失败 %d 个前缀,稍后重跑会用已落盘的结果补齐\n", failed)
	}
}

编译运行(标准库就够,不用 go get):

bash
go build -o ipv6geo ipv6_prefix_geo.go
./ipv6geo -f access.log -n 12

拿一份 16 行的样本日志跑,9 秒出结果:

日志 16 行,去重后 7 个前缀(跳过私网/回环 2 行,非法地址 1 行)

前缀                          请求数  省份     城市       运营商
2408:8000:1000::/48           5  北京     北京       中国联通城域网
114.114.114.0/24              2  江苏     南京       电信/联通
2408:8000:2000::/48           2  天津     天津       中国联通城域网
2408:8000:ffff::/48           1  山东     济南       中国联通城域网
240e:0:9000::/48              1  北京     北京       中国电信
240e:1:1000::/48              1  黑龙江    齐齐哈尔     中国电信城域网
2001:da8:200::/48             1  北京     北京       清华大学

16 行日志,7 个前缀,7 次请求,9 秒。放到真实场景:几百万条记录聚成几万个前缀,按 60 次/分钟算,8 小时左右能跑完一轮,之后每天只查增量前缀,十来分钟的事。

注意结果里的 114.114.114.0/24:日志里有一条 ::ffff:114.114.114.114,被 Unmap() 转成 IPv4 后,跟同段的 IPv4 记录合并进了同一个 /24 桶。这是想要的行为——同一个网段不该因为写法不同被算成两条。

四、这套做法会在哪儿出问题 ​

/48 同城不是铁律。 政企专线、跨省大网、IDC 的段,一个 /48 里可能挂多个城市。反过来,运营商做地址动态分配时,同一个用户今天在 :1000::/48、明天在 :2000::/48,会被算成两个城市。要确认你的数据能不能这么聚合,抽 100 个 /48 各取三五个地址查一遍,一致率低于 95% 就得把粒度收细到 /56 或 /64。

long_ip 对 IPv6 恒为 0。 这一点很容易在写库时踩到:IPv4 我们习惯把地址转成整数存区间表,IPv6 转换出来是空的(实测返回 long_ip: 0)。IPv6 要么存字符串,要么把 128 位拆成两个 64 位整数存,别指望一个 BIGINT 装得下。

私网和保留地址返回 200。 10.0.0.1 查出来 country 是「保留」、省市为空、isp 是「内网地址」。代码里如果只判断 ret == 200,这些行会带着空省份进报表。上面脚本在聚合阶段就把私网滤掉了,比事后清洗省事。

精度还是城市级。 /48 聚合只解决「查几次」的问题,不解决「查多准」。IPv6 的归属地精度跟 IPv4 一样是城市,lng/lat 是城市中心点。要区县得用 VIP 版的 area,但 IPv6 的区县覆盖率不如 IPv4,做区县级分析前先抽样看覆盖率。

限速要留在客户端。 接口侧 60 次/分钟是按请求方 IP 算的。你在同一台机器上开 8 个并发的 goroutine,只会一起撞 429。真要提高吞吐,加缓存、做增量、或者上 VIP;不要在客户端狂重试。

总结 ​

日志里的 IPv6 数量吓人,但信息密度极低——几百万条地址,几万个 /48。先归一化、再按 /48 聚合、最后对前缀的代表地址查一次,请求量能砍掉九成以上,这是把「跑不完」变成「每天增量十分钟」的关键一步。

需要现成接口的话,https://ip9.com.cn/get?ip=<地址> 支持 IPv4 和 IPv6,免费版 60 次/分钟、不用注册;字段说明和 VIP 版的区县、ip_type、ip_asn 在 IP9 官网 能查到。