go 操作 zabbix API

zabbix API 自定义库

package zabbix

import (
	"bytes"
	"crypto/tls"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"time"
)

type JsonRPCResponse struct {
	Jsonrpc string      `json:"jsonrpc"`
	Error   ZabbixError `json:"error"`
	Result  interface{} `json:"result"`
	Id      int         `json:"id"`
}

type JsonRPCRequest struct {
	Jsonrpc string      `json:"jsonrpc"`
	Method  string      `json:"method"`
	Params  interface{} `json:"params"`
	Auth    string      `json:"auth,omitempty"`
	Id      int         `json:"id"`
}

type ZabbixError struct {
	Code    int    `json:"code"`
	Message string `json:"message"`
	Data    string `json:"data"`
}

func (z *ZabbixError) Error() string {
	return z.Data
}

type API struct {
	url    string
	user   string
	passwd string
	id     int
	auth   string
}


const (
	//zabbix 服务器的IP和url
	IP = "0.0.0.0"
	Url = "http://"+IP+"/zabbix"
)

//server, user, passwd string,
func NewAPI(params ...string) (*API, error) {
	if len(params) == 3 && params[0] != "" && params[1] != "" && params[2] != "" {
		return &API{params[0] + "/api_jsonrpc.php", params[1], params[2], 1, ""}, nil
	}
	if len(params) == 1 && params[0] != "" {
		return &API{id: 1, url: Url + "/api_jsonrpc.php", auth: params[0]}, nil
	}
	return nil, errors.New("new API 参数错误")
}
func (api *API) GetAuth() string {
	return api.auth
}
func (api *API) ZabbixRequest(method string,data interface{}) (JsonRPCResponse, error) {
	// Setup our JSONRPC Request data x
	id := api.id
	api.id = api.id + 1
	jsonobj := JsonRPCRequest{"2.0", method, data, api.auth, id}
	encoded, err := json.Marshal(jsonobj)
	if err != nil {
		return JsonRPCResponse{}, err
	}
	// Setup our HTTP request
	//client := &http.Client{}
	tr := &http.Transport{ //解决x509: certificate signed by unknown authority
		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
	}
	client := &http.Client{
		Timeout:   30 * time.Second,
		Transport: tr, //解决x509: certificate signed by unknown authority
	}
	request, err := http.NewRequest("POST", api.url, bytes.NewBuffer(encoded))
	if err != nil {
		return JsonRPCResponse{}, err
	}
	request.Header.Add("Content-Type", "application/json-rpc")
	if api.auth != "" {
		// XXX Not required in practice, check spec
		//request.SetBasicAuth(api.user, api.passwd)
		//request.Header.Add("Authorization", api.auth)
	}
	// Execute the request
	response, err := client.Do(request)
	if err != nil {
		return JsonRPCResponse{}, err
	}
	/**
	  We can't rely on response.ContentLength because it will
	  be set at -1 for large responses that are chunked. So
	  we treat each API response as streamed data.
	*/
	var result JsonRPCResponse
	var buf bytes.Buffer

	_, err = io.Copy(&buf, response.Body)
	if err != nil {
		return JsonRPCResponse{}, err
	}

	err = json.Unmarshal(buf.Bytes(), &result)
	if err != nil {
		return JsonRPCResponse{}, err
	}

	response.Body.Close()

	return result, nil
}

func (api *API) Login() (bool, error) {
	params := make(map[string]string, 0)
	params["user"] = api.user
	params["password"] = api.passwd

	response, err := api.ZabbixRequest("user.login",params)
	if err != nil {
		fmt.Printf("Error: %s\n", err)
		return false, err
	}

	if response.Error.Code != 0 {
		return false, &response.Error
	}

	api.auth = response.Result.(string)
	return true, nil
}

func (api *API) LogOut() {
	response, err := api.ZabbixRequest("user.logout",map[string]interface{}{})
	fmt.Println(response,err)
	fmt.Println("退出zabbix登录。。。。。。")
	if err != nil || response.Result != true {
		fmt.Printf("logout Error: %s\n", err)
	}

}

func LoginAndHandle(url string,user string,password string) (*API) {
	//定义url，zabbix登陆使用的用户名及密码

	api,err := NewAPI(url,user,password)
	if err != nil {
		fmt.Println("NewAPI  fail")
	}
	login,err :=api.Login()
	if login {
		fmt.Println("login auth ok")
	}else{
		fmt.Println("login auth fail",err)
	}
	//defer api.LogOut()
	return api
}


// 请求数据的封装，然后转给 AllMethodHandles() 函数使用
func AllMethodHandleData(methodData string) (map[string]interface{}) {
	var data map[string]interface{}
	jsonstr := fmt.Sprintf(`%s`,methodData)
	json.Unmarshal([]byte(jsonstr),&data)
	return data
}

// 将请求的方法，还有请求的数据，发送到zabbix，
func (api *API)AllMethodHandles(method string,methodData string) (interface{}) {
	data := AllMethodHandleData(methodData)
	result,err:=api.ZabbixRequest(method,data)
	if err != nil {
		return nil
	}
	if result.Error.Code != 0 {
		err = errors.New(result.Error.Message)
		return nil
	}
	resultdata := result.Result
	return resultdata
}

使用示例

• 按照示例，参考 zabbix API 官网 https://www.zabbix.com/documentation/4.0/zh/manual/api/
  提交的数据，修改这些数据，如示例，hostGetData,hostUpdataData,itemGetData 等等
• 其他的方法和函数，参考 zabbix API 官网，修改 方法 和提交数据，如示例，hostGet,hostGetData;
  hostUpdata,hostUpdataData;itemGet，itemgetData 等等

package main

import (
	"fmt"
	"zabbix"
)

func main()  {
	//定义url，zabbix登陆使用的用户名及密码
	url := "http://192.168.73.160/api_jsonrpc.php"
	user := "Admin"
	password := "zabbix"

	api := zabbix.LoginAndHandle(url,user,password)
	defer api.LogOut()

	// 主机信息获取
	hostGet := "host.get"
	hostGetData := `{
        "output": ["hostid"],
        "selectGroups": "extend",
        "filter": {
            "host": [
                "Zabbix server"
            ]
        }
	}`
	hostGetResultOut := api.AllMethodHandles(hostGet,hostGetData)
	fmt.Println(hostGetResultOut)

	// 主机创建
	hostCreate := "host.create"
	hostCreateData := `{
        "host": "Linux server5",
        "interfaces": [
            {
                "type": 1,
                "main": 1,
                "useip": 1,
                "ip": "192.168.3.5",
                "dns": "",
                "port": "10050"
            }
        ],
        "groups": [
            {
                "groupid": "2"
            }
        ],
        "templates": [
            {
                "templateid": "10001"
            }
        ],
        "inventory_mode": 0,
        "inventory": {
            "macaddress_a": "01234",
            "macaddress_b": "56768"
        }
	}`
	hostCreateResultOut := api.AllMethodHandles(hostCreate,hostCreateData)
	fmt.Println(hostCreateResultOut)

	// 主机删除
	hostDelete := "host.delete"
	hostDeleteData := `[
     	"10084",
        "10084"
	]`
	hostDeleteResultOut := api.AllMethodHandles(hostDelete,hostDeleteData)
	fmt.Println(hostDeleteResultOut)

	// 主机更新
	hostUpdate := "host.update"
	hostUpdateData := `{
        "hostid": "10126",
        "status": 0
	}`
	hostUpdateResultOut := api.AllMethodHandles(hostUpdate,hostUpdateData)
	fmt.Println(hostUpdateResultOut)

	// 监控项获取
	itemGet := "item.get"
	itemGetData := `{
        "output": "extend",
        "hostids": "10263",
        "search": {
            "key_": "system"
        },
        "sortfield": "name"
	}`
	itemGetResultOut := api.AllMethodHandles(itemGet,itemGetData)
	fmt.Println(itemGetResultOut)

	// 监控项创建
	itemCreate := "item.create"
	itemCreateData := `{
        "name": "Free disk space on $1",
        "key_": "vfs.fs.size[/home/joe/,free]",
        "hostid": "30074",
        "type": 0,
        "value_type": 3,
        "interfaceid": "30084",
        "applications": [
            "609",
            "610"
        ],
        "delay": "30s"
	}`
	itemCreateResultOut := api.AllMethodHandles(itemCreate,itemCreateData)
	fmt.Println(itemCreateResultOut)

	// 监控项删除
	itemDelete := "item.delete"
	itemDeleteData := `[
        "22982",
        "22986"
	]`
	itemDeleteResultOut := api.AllMethodHandles(itemDelete,itemDeleteData)
	fmt.Println(itemDeleteResultOut)

	// 监控项更新
	itemUpdate := "item.update"
	itemUpdateData := `{
        "itemid": "10092",
        "status": 0
	}`
	itemUpdateResultOut := api.AllMethodHandles(itemUpdate,itemUpdateData)
	fmt.Println(itemUpdateResultOut)

	// 触发器获取
	triggerGet := "trigger.get"
	triggerGetData := `{
        "triggerids": "16040",
        "output": "extend",
        "selectFunctions": "extend"
	}`
	triggerGetResultOut := api.AllMethodHandles(triggerGet,triggerGetData)
	fmt.Println(triggerGetResultOut)

	// 触发器创建
	triggerCreate := "trigger.create"
	triggerCreateData := `[
        {
            "description": "Processor load is too high on {HOST.NAME}",
            "expression": "{Linux server:system.cpu.load[percpu,avg1].last()}>5",
            "dependencies": [
                {
                    "triggerid": "17367"
                }
            ]
        },
        {
            "description": "Service status",
            "expression": "{Linux server:log[/var/log/system,Service .* has stopped].strlen()}<>0",
            "dependencies": [
                {
                    "triggerid": "17368"
                }
            ],
            "tags": [
                {
                    "tag": "service",
                    "value": "{{ITEM.VALUE}.regsub(\"Service (.*) has stopped\", \"\\1\")}"
                },
                {
                    "tag": "error",
                    "value": ""
                }
            ]
        }
	]`
	triggerCreateResultOut := api.AllMethodHandles(triggerCreate,triggerCreateData)
	fmt.Println(triggerCreateResultOut)

	// 触发器删除
	triggerDelete := "trigger.delete"
	triggerDeleteData := `[
        "12002",
        "12003"
	]`
	triggerDeleteResultOut := api.AllMethodHandles(triggerDelete,triggerDeleteData)
	fmt.Println(triggerDeleteResultOut)

	// 触发器更新
	triggerUpdata := "trigger.update"
	triggerUpdateData := `{
        "triggerid": "16040",
        "status": 1
	}`
	triggerUpdateResultOut := api.AllMethodHandles(triggerUpdata,triggerUpdateData)
	fmt.Println(triggerUpdateResultOut)
}