自定义监控上报数据规范

{
  "access_key_id":"QYACCESSKEYIDEXAMPLE",
  "action":"DescribeUsers",
  "signature_method":"HmacSHA256",
  "signature_version":1,
  "time_stamp":"2013-08-27T14:30:10Z",
  "version":1,
  "zone":"sh1"
}

{
  "access_key_id":"QYACCESSKEYIDEXAMPLE",
  "action":"DescribeUsers",
  "signature_method":"HmacSHA256",
  "signature_version":1,
  "time_stamp":"2013-08-27T14%3A30%3A10Z",
  "version":1,
  "zone":"sh1"
}

access_key_id=QYACCESSKEYIDEXAMPLE&action=DescribeUsers&signature_method=HmacSHA256&signature_version=1&time_stamp=2013-08-27T14%3A30%3A10Z&version=1&zone=sh1

GET\n/iaas/\naccess_key_id=QYACCESSKEYIDEXAMPLE&action=DescribeUsers&signature_method=HmacSHA256&signature_version=1&time_stamp=2013-08-27T14%3A30%3A10Z&version=1&zone=sh1

import base64
import hmac
import urllib
from hashlib import sha256

# 前面生成的被签名串
string_to_sign = 'GET\n/iaas/\naccess_key_id=QYACCESSKEYIDEXAMPLE&action=DescribeUsers&signature_method=HmacSHA256&signature_version=1&time_stamp=2013-08-27T14%3A30%3A10Z&version=1&zone=sh1'
h = hmac.new(secret_access_key, digestmod=sha256)
h.update(string_to_sign)
sign = base64.b64encode(h.digest()).strip()
signature = urllib.quote_plus(sign)

access_key_id=QYACCESSKEYIDEXAMPLE
&action=DescribeUsers
&signature_method=HmacSHA256
&signature_version=1
&time_stamp=2013-08-27T14%3A30%3A10Z
&version=1
&zone=sh1
&signature=bOQMI8wJ4ikFnadNXc%2BpnVMcUyf83C7b9JO5%2FAvkGyk%3D

access_key_id=QYACCESSKEYIDEXAMPLE
&action=DescribeUsers
&signature_method=HmacSHA256
&signature_version=1
&time_stamp=2013-08-27T14%3A30%3A10Z
&version=1
&zone=sh1
&signature=bOQMI8wJ4ikFnadNXc%2BpnVMcUyf83C7b9JO5%2FAvkGyk%3D

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.shanhe.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)
	}

}

import hmac
import json
import base64
import datetime
import time
from hashlib import sha256
from collections import OrderedDict

try:
    import urllib.parse as urllib
except:
    import urllib
import requests

def sort_value(old_dict):
    items = sorted(old_dict.items())
    new_dict = OrderedDict()
    for item in items:
        new_dict[item[0]] = old_dict[item[0]]
    return new_dict

class UploadMonitorData(object):
    def __init__(self, access_key_id, secret_access_key):
        self.access_key_id = access_key_id
        self.secret_access_key = secret_access_key

        nowtime = datetime.datetime.now()
        self.signature_time = datetime.datetime.strftime(nowtime, "%Y-%m-%dT%H:%M:%SZ")

        self.time_stamp = datetime.datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")
        self.time = datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%SZ")
        self.url = "https://api.shanhe.com/iaas/"
        self.CloudSatUrl = "http://cloudsat.qingcloud.com/api/sh1/v1/custom/UploadMonitorData"
        self.url_path = '/iaas/'
        self.methods = 'GET'

    def post_request(self, post_url):
        headers = {"Content-Type": "application/json; charset=UTF-8"}
        body = {
            "user_id": "usr-8Ljvov6I",
            "namespace": "pt-test",
            "data": [
                {
                    "source": "custom",
                    "user_id": "usr-8Ljvov6I",
                    "resource_id": "i-ets7af6q",
                    "resource_type": "instance",
                    "root_user_id": "usr-8Ljvov6I",
                    "meter": "cpu",
                    "region": "sh1",
                    "value": 99,
                    "value_type": "percent",
                    "time_stamp": self.time_stamp
                }, {
                    "source": "custom",
                    "user_id": "usr-8Ljvov6I",
                    "resource_id": "i-ets7af6q",
                    "resource_type": "instance",
                    "root_user_id": "usr-8Ljvov6I",
                    "meter": "memory",
                    "region": "sh1",
                    "value": 96,
                    "value_type": "percent",
                    "time_stamp": self.time_stamp
                }
            ]
        }
        result = requests.post(url=post_url, headers=headers, data=json.dumps(body))
        print(result.status_code)
        print(result.reason)
        print(result.text)

    def post_monitor_data(self):
        od = OrderedDict()
        od['access_key_id'] = self.access_key_id
        od['action'] = "DescribeUsers"
        od['signature_method'] = "HmacSHA256"
        od['signature_version'] = 1
        od['time_stamp'] = self.signature_time
        od['version'] = 1
        od['zone'] = "sh1"

        od_sort = sort_value(od)
        data = urllib.urlencode(od_sort)
        string_to_sign = self.methods + "\n" + self.url_path + "\n" + data
        print(string_to_sign)
        h = hmac.new(self.secret_access_key.encode(), digestmod=sha256)
        h.update(string_to_sign.encode())
        sign = base64.b64encode(h.digest()).strip()
        signature = urllib.quote_plus(sign)
        post_url = self.CloudSatUrl + "?" + data + "&signature=" + signature
        self.post_request(post_url)

if __name__ == '__main__':
    access_key_id = 'ACCESSKEYID'
    secret_access_key = 'SECRETACCESSKEY'

    while True:
        upload_struct_object = UploadMonitorData(access_key_id, secret_access_key)
        upload_struct_object.post_monitor_data()
        time.sleep(3)