自定义监控

package main

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"net/url"
	"sort"
	"strconv"
	"strings"
	"time"
)

type verifyInfo struct {
	httpMothod      string
	path            string
	secretAccessKey string
	describeUsers   *describeUsers
}

type describeUsers struct {
	AccessKeyID      string `json:"access_key_id"`
	Action           string `json:"action"`
	SignatureMethod  string `json:"signature_method"`
	SignatureVersion int    `json:"signature_version"`
	Version          int    `json:"version"`
	Zone             string `json:"zone"`
	TimeStamp        string `json:"time_stamp"`
}

func hmacSha256(data string, secret string) []byte {
	h := hmac.New(sha256.New, []byte(secret))
	h.Write([]byte(data))
	return h.Sum(nil)
}

func formatParams(v interface{}) (map[string]interface{}, error) {
	paramMap := make(map[string]interface{})
	jsonBuf, err := json.Marshal(v)
	if err != nil {
		return nil, err
	}
	err = json.Unmarshal(jsonBuf, &paramMap)
	if err != nil {
		return nil, err
	}
	return paramMap, nil
}

func sortParams(params map[string]interface{}) string {
	var keys []string
	for k := range params {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	var parts []string
	for _, key := range keys {
		value := url.QueryEscape(strVal(params[key]))
		value = strings.Replace(strings.Replace(value, ":", "%3A", -1), " ", "%20", -1)
		parts = append(parts, key+"="+value)
	}
	return strings.Join(parts, "&")
}

func constructSignature(httpMothod, reqUrl, requestStr, key string) string {
	signaturePre := httpMothod + "\n" + reqUrl + "\n" + requestStr
	hmacShaStr := hmacSha256(signaturePre, key)
	base64Str := base64.StdEncoding.EncodeToString(hmacShaStr)
	signature := strings.TrimSpace(base64Str)
	signature = strings.Replace(signature, " ", "+", -1)
	signature = url.QueryEscape(signature)
	return signature
}

func strVal(value interface{}) string {
	var key string
	if value == nil {
		return key
	}
	switch value.(type) {
	case int:
		it := value.(int)
		key = strconv.Itoa(it)
	case string:
		key = value.(string)
	default:
		newValue, _ := json.Marshal(value)
		key = string(newValue)
	}
	return key
}

func (v *verifyInfo) buildVerifyStr() (string, error) {
	params, err := formatParams(v.describeUsers)
	if err != nil {
		return "", err
	}
	sortParams := sortParams(params)
	signature := constructSignature(v.httpMothod, v.path, sortParams, v.secretAccessKey)
	rsqParams := sortParams + "&signature=" + signature
	return rsqParams, nil
}


func main() {
	vi := &verifyInfo{
		httpMothod:      "GET",
		path:            "/iaas/",
		secretAccessKey: "SECRETACCESSKEY",
		describeUsers: &describeUsers{
			AccessKeyID:      "QYACCESSKEYIDEXAMPLE",
			Action:           "DescribeUsers",
			SignatureMethod:  "HmacSHA256",
			SignatureVersion: 1,
			Version:          1,
			Zone:             "sh1",
			TimeStamp:        time.Now().Format("2006-01-02T15:04:05Z"),
		},
	}

	result, _ := vi.buildVerifyStr()
	fmt.Println(result)
}

type successRespJson struct {
	Message interface{} `json:"message,required"`
	RetCode int         `json:"ret_code,required"`
}

func Verify(url string) int {
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return 1
	}
	tr := &http.Transport{
		TLSClientConfig: &tls.Config{InsecureSkipVerify: true, Renegotiation: tls.RenegotiateOnceAsClient},
	}
	cli := http.Client{
		Transport:     tr,
		CheckRedirect: nil,
		Jar:           nil,
		Timeout:       0,
	}
	response, _:= cli.Do(req)
	defer response.Body.Close()
	body, _:= ioutil.ReadAll(response.Body)
	var vr successRespJson
	if response.StatusCode == http.StatusOK {
		if err := json.Unmarshal(body, &vr); err != nil {
			return 1
		}
	}
	return vr.RetCode
}

func main() {
	result := "access_key_id=CCDJRDKCCKZYTEXANZJD&action=DescribeUsers&signature_method=HmacSHA256&signature_version=1&time_stamp=2020-12-23T14%3A03%3A44Z&version=1&zone=sh1&signature=d6eMFDgO3E6wBqbbn2AydX%2BxQws7iD%2BtSgfGF6Lq7Uo%3D"
	url := "https://api.qingcloud.com/iaas/" + "?" + result
	fmt.Println(Verify(url))
}

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"math/rand"
	"net/http"
	"strconv"
	"time"
)

type monitorData struct {
	UserId    string  `json:"user_id"`
	Namespace string  `json:"namespace"`
	Data      []meters `json:"data"`
}

type meters struct {
	Source       string `json:"source"`
	UserId       string `json:"user_id"`
	Tags         string `json:"tags"`
	GroupId      string `json:"group_id"`
	ResourceId   string `json:"resource_id"`
	ResourceName string `json:"resource_name"`
	ResourceType string `json:"resource_type"`
	RootUserId   string `json:"root_user_id"`
	Meter        string `json:"meter"`
	Region       string `json:"region"`
	Value        int    `json:"value"`
	ValueType    string `json:"value_type"`
	TimeStamp    string `json:"time_stamp"`
}

type date struct {
	UploadCount int `json:"upload_count"`
}

type ret struct {
	Data date `json:"data"`
	RetCode int `json:"ret_code"`
}

var client = http.Client{
	Timeout: 10 * time.Second,
}

func HttpPostJson(url string, data interface{}, result interface{}) error {
	buf := bytes.NewBuffer(nil)
	encoder := json.NewEncoder(buf)
	if err := encoder.Encode(data); err != nil {
		return err
	}

	request, err := http.NewRequest(http.MethodPost, url, buf)
	if err != nil {
		return err
	}

	request.Header.Add("Content-Type", "application/json")
	request.Header.Add("Content-Type", "charset=UTF-8")
	response, err := client.Do(request)
	if err != nil {
		return err
	}
	defer response.Body.Close()

	decoder := json.NewDecoder(response.Body)
	if err = decoder.Decode(&result); err != nil {
		return err
	}
	fmt.Println(result)
	return nil
}

func main() {

    for {
	    timeStamp := time.Now().UTC().Format("2006-01-02T15:04:05Z")
		rand.Seed(time.Now().UnixNano())
		flag := strconv.Itoa(rand.Intn(16))
		p := monitorData{
			UserId: "usr-12345678",
			Namespace: "cloudsat-test",
			Data: []meters{
				{
					Source: "dylan-test",
					UserId: "usr-12345678",
					Tags: "role=master,interface=eth10",
					GroupId: "group1",
					ResourceId: "i-instance-"+flag ,
					ResourceName: "name"+flag,
					ResourceType: "instance",
					RootUserId: "usr-12345678",
					Meter: "cpu",
					Region: "sh1",
					Value: rand.Intn(100),
					ValueType: "percent",
					TimeStamp:timeStamp,
				},{
					Source: "dylan-test",
					UserId: "usr-12345678",
					Tags: "role=master,interface=eth10",
					GroupId: "group1" ,
					ResourceId: "i-instance-"+flag ,
					ResourceName: "name"+flag,
					ResourceType: "instance",
					RootUserId: "usr-12345678",
					Meter: "memory",
					Region: "sh1",
					Value: rand.Intn(100),
					ValueType: "percent",
					TimeStamp:timeStamp,
				},
			},
		}
		var r ret

		url := `http://cloudsat.qingcloud.com/api/sh1/v1/custom/UploadMonitorData?access_key_id=CCDJRDKCCKZYTEXANZJD&action=DescribeUsers&signature_method=HmacSHA256&signature_version=1&time_stamp=2020-12-23T09%3A52%3A10Z&version=1&zone=sh1&signature=vorfODyQzKD0v4En7y5mdwkvUe4OZGQcDdQU5xBSjio%3D`
		err := HttpPostJson(url,p,r)
		if err != nil {
			fmt.Println(err)
		}
		time.Sleep(time.Duration(1)*time.Second)
	}

}