还在为获取公网IP地址而烦恼吗？ipify API让你告别curl ifconfig.me的尴尬时代

还在为获取公网IP地址而烦恼吗？ipify API让你告别curl ifconfig.me的尴尬时代

【免费下载链接】ipify-apiA public IP API service.项目地址: https://gitcode.com/gh_mirrors/ip/ipify-api

作为开发者，你一定经历过这样的场景：凌晨三点，部署在云端的服务突然宕机，需要快速获取服务器公网IP来排查防火墙规则，结果对着终端敲了十几遍curl ifconfig.me却得到各种奇怪的响应。或者，在自动化脚本中需要动态获取IP地址，却发现传统的IP查询服务要么响应慢，要么格式混乱，要么干脆不可用。这种"IP地址焦虑症"是不是很熟悉？🤔

痛点场景：当IP查询成为开发路上的绊脚石

想象一下这些真实场景：

1. 云服务器自动化部署：你写了个自动化脚本，需要动态获取新创建服务器的公网IP来配置DNS记录，结果发现常用的IP查询服务被墙了
2. 动态IP监控：家庭宽带用户需要监控自己的动态IP变化，但现有的工具要么太复杂，要么收费
3. 跨地域服务发现：分布式系统需要自动发现各个节点的公网IP来进行节点间通信
4. 安全审计日志：需要记录客户端的真实公网IP地址，但Nginx后面的应用拿到的总是负载均衡器的IP

这些问题看似简单，实则在生产环境中经常成为"隐形杀手"。传统的解决方案要么不稳定，要么格式不统一，要么存在单点故障风险。

技术拆解：ipify如何做到每月300亿次请求的稳定性

让我们深入ipify的核心源码，看看这个看似简单的服务背后有哪些技术亮点：

核心架构：极简主义的胜利

打开main.go文件，你会发现整个服务的启动代码不到50行：

func main() { router := httprouter.New() router.GET("/", api.GetIP) // 设置404/405处理器 router.NotFound = http.HandlerFunc(api.NotFound) router.MethodNotAllowed = http.HandlerFunc(api.MethodNotAllowed) // 添加CORS支持 handler := cors.Default().Handler(router) port := os.Getenv("PORT") if port == "" { port = "3000" } log.Println("Starting HTTP server on port:", port) log.Fatal(http.ListenAndServe(":"+port, handler)) }

这种极简设计带来了几个关键优势：

• 启动速度快：Go语言的静态编译特性让服务可以在毫秒级启动
• 内存占用低：单二进制文件部署，无需复杂的运行时环境
• 故障恢复快：进程崩溃后可以快速重启

IP提取逻辑：正确处理X-Forwarded-For头

在api/get_ip.go中，最核心的IP提取逻辑只有一行代码：

ip := net.ParseIP(strings.Split(r.Header.Get("X-Forwarded-For"), ",")[0]).String()

这行代码包含了几个重要的设计决策：

1. 优先使用X-Forwarded-For：正确处理反向代理场景
2. 取第一个IP：遵循RFC标准，第一个IP总是原始客户端IP
3. 自动解析IPv4/IPv6：net.ParseIP函数自动处理两种格式

多格式支持：一次请求，多种选择

ipify最贴心的设计之一是支持多种返回格式：

if format, ok := r.Form["format"]; ok && len(format) > 0 { jsonStr, _ := json.Marshal(models.IPAddress{ip}) switch format[0] { case "json": w.Header().Set("Content-Type", "application/json") fmt.Fprintf(w, string(jsonStr)) return case "jsonp": callback := "callback" if val, ok := r.Form["callback"]; ok && len(val) > 0 { callback = val[0] } w.Header().Set("Content-Type", "application/javascript") fmt.Fprintf(w, callback+"("+string(jsonStr)+");") return } }

这种设计让前端开发者可以直接在浏览器中调用，无需担心跨域问题。

实战演练：从零开始部署你的私有ipify服务

第一步：快速部署到Heroku（5分钟搞定）

如果你需要立即使用，最简单的方式是使用Heroku一键部署：

# 克隆项目 git clone https://gitcode.com/gh_mirrors/ip/ipify-api cd ipify-api # 创建Heroku应用 heroku create your-ipify-instance # 部署 git push heroku main # 验证部署 curl https://your-ipify-instance.herokuapp.com/

第二步：本地开发环境搭建

想要深入了解ipify的工作原理？让我们在本地搭建一个开发环境：

# 1. 安装Go语言环境（如果还没有） # Ubuntu/Debian sudo apt-get install golang-go # macOS brew install go # 2. 设置GOPATH export GOPATH=$HOME/go export PATH=$PATH:$GOPATH/bin # 3. 获取项目源码 go get -u github.com/rdegges/ipify-api # 4. 进入项目目录并编译 cd $GOPATH/src/github.com/rdegges/ipify-api go build # 5. 运行服务 PORT=8080 ./ipify-api

第三步：各种语言的客户端实现

Python版本：

import requests def get_public_ip(format='text'): """获取公网IP地址""" url = 'http://api.ipify.org' if format == 'json': url += '?format=json' elif format == 'jsonp': url += '?format=jsonp&callback=myCallback' response = requests.get(url) return response.text if format == 'text' else response.json() # 使用示例 print(f"纯文本格式: {get_public_ip('text')}") print(f"JSON格式: {get_public_ip('json')}")

JavaScript/Node.js版本：

// 浏览器端 async function getIP() { const response = await fetch('https://api.ipify.org?format=json'); const data = await response.json(); console.log('你的IP地址是:', data.ip); return data.ip; } // Node.js端 const https = require('https'); function getPublicIP() { return new Promise((resolve, reject) => { https.get('https://api.ipify.org?format=json', (resp) => { let data = ''; resp.on('data', (chunk) => data += chunk); resp.on('end', () => resolve(JSON.parse(data))); }).on('error', reject); }); }

Shell脚本版本：

#!/bin/bash # 获取IP地址并设置环境变量 export PUBLIC_IP=$(curl -s https://api.ipify.org) # 或者在脚本中使用 if [ -z "$PUBLIC_IP" ]; then echo "无法获取公网IP地址" exit 1 fi echo "服务器公网IP: $PUBLIC_IP" # 自动更新DNS记录（示例） # curl -X PUT "https://api.cloudflare.com/client/v4/zones/ZONE_ID/dns_records/RECORD_ID" \ # -H "Authorization: Bearer $API_TOKEN" \ # -H "Content-Type: application/json" \ # --data "{\"type\":\"A\",\"name\":\"example.com\",\"content\":\"$PUBLIC_IP\"}"

避坑指南：ipify使用中的常见问题与解决方案

问题1：为什么有时候获取的IP地址不准确？

原因分析：

• 客户端使用了代理服务器
• 服务部署在多层反向代理后面
• 网络运营商使用了NAT转换

解决方案：

// 改进的IP获取逻辑，支持多种头部 func getClientIP(r *http.Request) string { // 尝试从不同头部获取IP headers := []string{ "X-Real-IP", "X-Forwarded-For", "CF-Connecting-IP", // Cloudflare "True-Client-IP", // Akamai } for _, header := range headers { if ip := r.Header.Get(header); ip != "" { // 处理多个IP的情况（逗号分隔） ips := strings.Split(ip, ",") if len(ips) > 0 { return strings.TrimSpace(ips[0]) } } } // 最后回退到RemoteAddr host, _, _ := net.SplitHostPort(r.RemoteAddr) return host }

问题2：如何防止API被滥用？

解决方案：添加简单的速率限制

import ( "time" "sync" ) type RateLimiter struct { requests map[string][]time.Time mu sync.RWMutex limit int window time.Duration } func NewRateLimiter(limit int, window time.Duration) *RateLimiter { return &RateLimiter{ requests: make(map[string][]time.Time), limit: limit, window: window, } } func (rl *RateLimiter) Allow(ip string) bool { rl.mu.Lock() defer rl.mu.Unlock() now := time.Now() // 清理过期请求 validRequests := []time.Time{} for _, t := range rl.requests[ip] { if now.Sub(t) <= rl.window { validRequests = append(validRequests, t) } } // 检查是否超过限制 if len(validRequests) >= rl.limit { return false } // 记录新请求 validRequests = append(validRequests, now) rl.requests[ip] = validRequests return true }

问题3：IPv6支持不完整？

解决方案：确保正确处理IPv6地址

func parseIP(ipStr string) (net.IP, error) { ip := net.ParseIP(ipStr) if ip == nil { return nil, fmt.Errorf("无效的IP地址: %s", ipStr) } // 如果是IPv4映射的IPv6地址，转换为IPv4 if ip.To4() != nil { return ip.To4(), nil } return ip, nil }

进阶玩法：把ipify集成到你的技术栈中

场景1：动态DNS更新系统

import schedule import time import requests import cloudflare class DynamicDNS: def __init__(self, zone_id, record_name, api_token): self.zone_id = zone_id self.record_name = record_name self.api_token = api_token self.last_ip = None def get_current_ip(self): """使用ipify获取当前公网IP""" try: response = requests.get('https://api.ipify.org?format=json', timeout=5) return response.json()['ip'] except: # 备用方案 response = requests.get('https://api64.ipify.org?format=json', timeout=5) return response.json()['ip'] def update_dns_if_needed(self): """如果IP发生变化，更新DNS记录""" current_ip = self.get_current_ip() if current_ip != self.last_ip: print(f"IP地址变化: {self.last_ip} -> {current_ip}") # 更新Cloudflare DNS记录 headers = { 'Authorization': f'Bearer {self.api_token}', 'Content-Type': 'application/json' } data = { 'type': 'A', 'name': self.record_name, 'content': current_ip, 'ttl': 120, # 2分钟TTL，快速传播变化 'proxied': True # 启用Cloudflare代理 } response = requests.put( f'https://api.cloudflare.com/client/v4/zones/{self.zone_id}/dns_records/{self.record_id}', headers=headers, json=data ) if response.status_code == 200: self.last_ip = current_ip print("DNS记录更新成功") else: print(f"DNS更新失败: {response.text}") def run(self): """启动定时任务""" # 每5分钟检查一次IP变化 schedule.every(5).minutes.do(self.update_dns_if_needed) while True: schedule.run_pending() time.sleep(1) # 使用示例 ddns = DynamicDNS( zone_id='your_zone_id', record_name='home.yourdomain.com', api_token='your_api_token' ) ddns.run()

场景2：分布式系统节点发现

package main import ( "encoding/json" "fmt" "net/http" "sync" "time" ) type NodeRegistry struct { nodes map[string]NodeInfo mu sync.RWMutex } type NodeInfo struct { IP string `json:"ip"` Region string `json:"region"` Services []string `json:"services"` LastSeen time.Time `json:"last_seen"` } func NewNodeRegistry() *NodeRegistry { return &NodeRegistry{ nodes: make(map[string]NodeInfo), } } func (nr *NodeRegistry) RegisterNode(nodeID string, region string, services []string) error { // 使用ipify获取节点的公网IP resp, err := http.Get("http://api.ipify.org?format=json") if err != nil { return fmt.Errorf("无法获取公网IP: %v", err) } defer resp.Body.Close() var result struct { IP string `json:"ip"` } if err := json.NewDecoder(resp.Body).Decode(&result); err != nil { return fmt.Errorf("解析IP响应失败: %v", err) } nr.mu.Lock() defer nr.mu.Unlock() nr.nodes[nodeID] = NodeInfo{ IP: result.IP, Region: region, Services: services, LastSeen: time.Now(), } return nil } func (nr *NodeRegistry) GetNodesByService(service string) []NodeInfo { nr.mu.RLock() defer nr.mu.RUnlock() var matchingNodes []NodeInfo for _, node := range nr.nodes { for _, s := range node.Services { if s == service { matchingNodes = append(matchingNodes, node) break } } } return matchingNodes } // 使用示例 func main() { registry := NewNodeRegistry() // 节点注册自己 go func() { for { registry.RegisterNode("node-1", "us-west", []string{"api", "database"}) time.Sleep(30 * time.Second) // 每30秒更新一次 } }() // 其他节点可以发现服务 http.HandleFunc("/discover", func(w http.ResponseWriter, r *http.Request) { service := r.URL.Query().Get("service") nodes := registry.GetNodesByService(service) json.NewEncoder(w).Encode(nodes) }) http.ListenAndServe(":8080", nil) }

场景3：安全审计与威胁检测

import redis import hashlib from datetime import datetime, timedelta class IPThreatDetector: def __init__(self, redis_client): self.redis = redis_client self.suspicious_patterns = [ "扫描", # 端口扫描特征 "爆破", # 密码爆破 "注入", # SQL注入尝试 ] def analyze_request(self, ip, user_agent, path): """分析请求是否可疑""" # 获取客户端真实IP（如果使用了代理） public_ip = self.get_public_ip_if_needed(ip) # 检查请求频率 request_key = f"req:{public_ip}:{datetime.now().strftime('%Y%m%d%H')}" request_count = self.redis.incr(request_key) self.redis.expire(request_key, 3600) # 1小时过期 if request_count > 1000: # 每小时超过1000次请求 self.mark_as_suspicious(public_ip, "高频请求") return True # 检查User-Agent if not user_agent or len(user_agent) < 10: self.mark_as_suspicious(public_ip, "异常User-Agent") return True # 检查路径模式 for pattern in self.suspicious_patterns: if pattern in path: self.mark_as_suspicious(public_ip, f"可疑路径: {path}") return True return False def get_public_ip_if_needed(self, ip): """如果需要，使用ipify获取公网IP""" # 如果是私有IP地址，说明客户端在NAT后面 if ip.startswith(("10.", "172.16.", "192.168.")): try: response = requests.get('https://api.ipify.org?format=json', timeout=2) return response.json()['ip'] except: return ip # 回退到原始IP return ip def mark_as_suspicious(self, ip, reason): """标记可疑IP""" key = f"suspicious:{ip}" self.redis.hset(key, "last_seen", datetime.now().isoformat()) self.redis.hset(key, "reason", reason) self.redis.expire(key, 86400) # 24小时 # 发送警报 self.send_alert(ip, reason) def send_alert(self, ip, reason): """发送安全警报""" print(f"[SECURITY ALERT] 可疑IP: {ip}, 原因: {reason}") # 这里可以集成到Slack、邮件、短信等通知系统

性能优化：让ipify飞起来

缓存策略优化

package cache import ( "sync" "time" ) type IPCache struct { cache map[string]CacheEntry mu sync.RWMutex ttl time.Duration } type CacheEntry struct { ip string timestamp time.Time } func NewIPCache(ttl time.Duration) *IPCache { return &IPCache{ cache: make(map[string]CacheEntry), ttl: ttl, } } func (c *IPCache) Get(key string) (string, bool) { c.mu.RLock() entry, exists := c.cache[key] c.mu.RUnlock() if !exists { return "", false } // 检查是否过期 if time.Since(entry.timestamp) > c.ttl { c.mu.Lock() delete(c.cache, key) c.mu.Unlock() return "", false } return entry.ip, true } func (c *IPCache) Set(key, ip string) { c.mu.Lock() defer c.mu.Unlock() c.cache[key] = CacheEntry{ ip: ip, timestamp: time.Now(), } } // 在API处理器中使用缓存 func GetIPWithCache(w http.ResponseWriter, r *http.Request) { cacheKey := r.RemoteAddr if cachedIP, ok := ipCache.Get(cacheKey); ok { // 返回缓存的IP w.Header().Set("Content-Type", "text/plain") fmt.Fprintf(w, cachedIP) return } // 正常获取IP逻辑 ip := getClientIP(r) // 缓存结果 ipCache.Set(cacheKey, ip) w.Header().Set("Content-Type", "text/plain") fmt.Fprintf(w, ip) }

连接池优化

import ( "net/http" "time" ) var httpClient = &http.Client{ Timeout: time.Second * 10, Transport: &http.Transport{ MaxIdleConns: 100, MaxIdleConnsPerHost: 10, IdleConnTimeout: 90 * time.Second, TLSHandshakeTimeout: 10 * time.Second, ExpectContinueTimeout: 1 * time.Second, }, } // 使用优化的HTTP客户端 func getIPFromUpstream() (string, error) { req, err := http.NewRequest("GET", "https://api.ipify.org?format=json", nil) if err != nil { return "", err } req.Header.Set("User-Agent", "ipify-client/1.0") resp, err := httpClient.Do(req) if err != nil { return "", err } defer resp.Body.Close() // ... 处理响应 }

监控与告警：确保服务高可用

Prometheus监控指标

package metrics import ( "github.com/prometheus/client_golang/prometheus" "github.com/prometheus/client_golang/prometheus/promauto" ) var ( requestsTotal = promauto.NewCounterVec( prometheus.CounterOpts{ Name: "ipify_requests_total", Help: "Total number of IP requests", }, []string{"format", "status"}, ) requestDuration = promauto.NewHistogramVec( prometheus.HistogramOpts{ Name: "ipify_request_duration_seconds", Help: "Duration of IP requests", Buckets: prometheus.DefBuckets, }, []string{"format"}, ) activeConnections = promauto.NewGauge( prometheus.GaugeOpts{ Name: "ipify_active_connections", Help: "Number of active connections", }, ) ) // 在处理器中记录指标 func InstrumentedGetIP(w http.ResponseWriter, r *http.Request) { start := time.Now() format := r.URL.Query().Get("format") if format == "" { format = "text" } activeConnections.Inc() defer activeConnections.Dec() // 处理请求 GetIP(w, r, nil) duration := time.Since(start).Seconds() requestDuration.WithLabelValues(format).Observe(duration) // 根据状态码记录 status := "200" // 简化示例，实际需要获取状态码 requestsTotal.WithLabelValues(format, status).Inc() }

健康检查端点

func HealthCheck(w http.ResponseWriter, r *http.Request) { // 检查数据库连接 // 检查外部依赖 // 检查系统资源 health := map[string]interface{}{ "status": "healthy", "timestamp": time.Now().Unix(), "version": "1.0.0", "metrics": map[string]interface{}{ "goroutines": runtime.NumGoroutine(), "memory_mb": getMemoryUsageMB(), }, } w.Header().Set("Content-Type", "application/json") json.NewEncoder(w).Encode(health) } // 在路由中注册 router.GET("/health", HealthCheck)

总结：为什么选择ipify？

经过深入的技术分析和实践演练，我们可以看到ipify不仅仅是一个简单的IP查询服务，它代表了一种极简、高效、可靠的技术哲学：

1. 极简设计：单文件核心逻辑，易于理解和维护
2. 高性能：Go语言编译，毫秒级响应时间
3. 高可靠：每月300亿次请求的实战验证
4. 易扩展：支持自定义部署和功能扩展
5. 社区活跃：开源项目，持续维护和更新

无论你是需要快速集成IP查询功能的开发者，还是希望学习如何构建高可用API服务的架构师，ipify都提供了绝佳的学习和实践机会。它的源码简洁明了，设计思路清晰，是理解现代API服务设计的优秀案例。

现在就开始你的ipify之旅吧！无论是使用官方的api.ipify.org服务，还是部署自己的私有实例，这个简单而强大的工具都将为你的项目带来实实在在的价值。记住，好的工具不在于功能有多复杂，而在于能否完美解决实际问题——ipify正是这样的工具。🚀

【免费下载链接】ipify-apiA public IP API service.项目地址: https://gitcode.com/gh_mirrors/ip/ipify-api