Golang Uptime Robot API v2 客户端与封装库使用指南

Uptime Robot 是一个流行的网站监控服务，其 API v2 允许开发者以编程方式管理监控项。下面我将介绍如何使用 Golang 与 Uptime Robot API v2 交互，包括直接调用 API 和使用封装库 github.com/bitfield/uptimerobot。

1. 直接调用 Uptime Robot API v2

首先，我们来看如何直接使用 HTTP 客户端与 API 交互：

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
)

const (
	apiKey      = "your_api_key"
	apiEndpoint = "https://api.uptimerobot.com/v2/"
)

type Monitor struct {
	ID             int    `json:"id"`
	FriendlyName   string `json:"friendly_name"`
	URL            string `json:"url"`
	Type           int    `json:"type"`
	Status         int    `json:"status"`
	Interval       int    `json:"interval"`
	CreateDateTime int    `json:"create_datetime"`
}

type GetMonitorsResponse struct {
	Stat       string    `json:"stat"`
	Pagination struct{}  `json:"pagination"`
	Monitors   []Monitor `json:"monitors"`
}

func getMonitors() ([]Monitor, error) {
	url := apiEndpoint + "getMonitors"

	payload := map[string]string{
		"api_key":      apiKey,
		"format":       "json",
		"logs":         "1",
		"response_times": "1",
	}

	jsonPayload, _ := json.Marshal(payload)
	resp, err := http.Post(url, "application/json", bytes.NewBuffer(jsonPayload))
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	body, _ := ioutil.ReadAll(resp.Body)

	var response GetMonitorsResponse
	if err := json.Unmarshal(body, &response); err != nil {
		return nil, err
	}

	if response.Stat != "ok" {
		return nil, fmt.Errorf("API request failed")
	}

	return response.Monitors, nil
}

func main() {
	monitors, err := getMonitors()
	if err != nil {
		fmt.Printf("Error getting monitors: %v\n", err)
		return
	}

	fmt.Println("Your Uptime Robot Monitors:")
	for _, m := range monitors {
		fmt.Printf("ID: %d, Name: %s, URL: %s, Status: %d\n", 
			m.ID, m.FriendlyName, m.URL, m.Status)
	}
}

2. 使用 uptimerobot 封装库

github.com/bitfield/uptimerobot 是一个第三方库，提供了更简洁的 API 封装。

安装

go get github.com/bitfield/uptimerobot

使用示例

package main

import (
	"fmt"
	"log"

	"github.com/bitfield/uptimerobot"
)

func main() {
	// 创建客户端
	client := uptimerobot.New("your_api_key")

	// 获取所有监控项
	monitors, err := client.GetMonitors()
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println("Your Uptime Robot Monitors:")
	for _, m := range monitors {
		fmt.Printf("ID: %d, Name: %s, URL: %s, Status: %s\n",
			m.ID, m.FriendlyName, m.URL, m.Status)
	}

	// 创建新监控项
	newMonitor := uptimerobot.Monitor{
		FriendlyName: "Example Site",
		URL:         "https://example.com",
		Type:        uptimerobot.TypeHTTP,
	}
	createdMonitor, err := client.CreateMonitor(newMonitor)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Created monitor with ID %d\n", createdMonitor.ID)

	// 删除监控项
	err = client.DeleteMonitor(createdMonitor.ID)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Deleted monitor with ID %d\n", createdMonitor.ID)
}

3. 命令行客户端实现

下面是一个简单的命令行客户端实现：

package main

import (
	"flag"
	"fmt"
	"log"
	"os"

	"github.com/bitfield/uptimerobot"
)

var (
	apiKey   string
	action   string
	name     string
	url      string
	monitorID int
)

func init() {
	flag.StringVar(&apiKey, "key", "", "Uptime Robot API key")
	flag.StringVar(&action, "action", "list", "Action to perform (list|create|delete)")
	flag.StringVar(&name, "name", "", "Monitor friendly name (for create)")
	flag.StringVar(&url, "url", "", "URL to monitor (for create)")
	flag.IntVar(&monitorID, "id", 0, "Monitor ID (for delete)")
}

func main() {
	flag.Parse()

	if apiKey == "" {
		apiKey = os.Getenv("UPTIMEROBOT_API_KEY")
		if apiKey == "" {
			log.Fatal("API key must be provided via -key flag or UPTIMEROBOT_API_KEY environment variable")
		}
	}

	client := uptimerobot.New(apiKey)

	switch action {
	case "list":
		listMonitors(client)
	case "create":
		createMonitor(client)
	case "delete":
		deleteMonitor(client)
	default:
		log.Fatalf("Unknown action: %s", action)
	}
}

func listMonitors(client *uptimerobot.Client) {
	monitors, err := client.GetMonitors()
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println("Your Uptime Robot Monitors:")
	for _, m := range monitors {
		fmt.Printf("ID: %d, Name: %s, URL: %s, Status: %s\n",
			m.ID, m.FriendlyName, m.URL, m.Status)
	}
}

func createMonitor(client *uptimerobot.Client) {
	if name == "" || url == "" {
		log.Fatal("Both -name and -url are required for create action")
	}

	newMonitor := uptimerobot.Monitor{
		FriendlyName: name,
		URL:         url,
		Type:        uptimerobot.TypeHTTP,
	}

	monitor, err := client.CreateMonitor(newMonitor)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Successfully created monitor with ID %d\n", monitor.ID)
}

func deleteMonitor(client *uptimerobot.Client) {
	if monitorID == 0 {
		log.Fatal("Monitor ID must be provided with -id flag for delete action")
	}

	err := client.DeleteMonitor(monitorID)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Successfully deleted monitor with ID %d\n", monitorID)
}

4. 高级功能

监控间隔设置

// 创建每5分钟检查一次的监控
newMonitor := uptimerobot.Monitor{
	FriendlyName: "Critical Service",
	URL:         "https://critical.example.com",
	Type:        uptimerobot.TypeHTTP,
	Interval:    5, // 以分钟为单位
}

获取监控日志

logs, err := client.GetMonitorLogs(monitorID)
if err != nil {
	log.Fatal(err)
}

for _, logEntry := range logs {
	fmt.Printf("%s: %s (%dms)\n", 
		logEntry.DateTime, logEntry.Type, logEntry.Duration)
}

总结

本文介绍了三种与 Uptime Robot API v2 交互的方式：

1. 直接使用 HTTP 客户端调用原始 API
2. 使用 github.com/bitfield/uptimerobot 封装库
3. 构建命令行客户端

封装库提供了更简洁的 API 和类型安全，适合大多数用例。对于特殊需求，可以直接调用 API。命令行客户端可以作为日常管理工具使用。

记得妥善保管你的 API 密钥，不要将其硬编码在代码中或提交到版本控制系统。