Help Center/ Application Operations Management/ API Reference/ APIs/ Prometheus Instance/ Creating a Recording Rule for a Prometheus Instance
Updated on 2024-06-28 GMT+08:00

Creating a Recording Rule for a Prometheus Instance

Function

This API is used to create a recording rule for a Prometheus instance.

Calling Method

For details, see Calling APIs.

URI

POST /v1/{project_id}/{prometheus_instance}/aom/api/v1/rules

Table 1 Path Parameters

Parameter

Mandatory

Type

Description

project_id

Yes

String

Project ID obtained from IAM. Generally, a project ID contains 32 characters.

prometheus_instance

Yes

String

Prometheus instance ID.

Request Parameters

Table 2 Request header parameters

Parameter

Mandatory

Type

Description

X-Auth-Token

Yes

String

User token obtained from IAM.

Content-Type

Yes

String

Content type, which is application/json.

Table 3 Request body parameters

Parameter

Mandatory

Type

Description

recording_rule

Yes

String

Recording rule.

Response Parameters

Status code: 500

Table 4 Response body parameters

Parameter

Type

Description

error_code

String

Error code.

error_msg

String

Error message.

error_type

String

Error type.

trace_id

String

Trace ID.

Example Requests

Create a recording rule for a Prometheus instance.

https://{Endpoint}/v1/{project_id}/{prometheus_instance}/aom/api/v1/rules

{
  "recording_rule" : "groups:\n    - name: apiserver_request_total\n      interval: 60s\n      rules:\n        - record: job_instance_mode:apiserver_request_total:avg_rate5m\n          expr: avg by (job, instance, mode) (rate(apiserver_request_total[5m]))\n          labels:\n            team: operations\n        - record: job:apiserver_request_total:sum_rate10m\n          expr: sum by (job)(rate(apiserver_request_total[10m]))\n          labels:\n            team: operations"
}

Example Responses

Status code: 204

OK: The request is successful.

""

Status code: 500

The recording rule already exists.

{
  "error_code" : "AOM.5001019",
  "error_msg" : "recording rule exist for the prometheus instance"
}

SDK Sample Code

The SDK sample code is as follows.

Java

Create a recording rule for a Prometheus instance.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
package com.huaweicloud.sdk.test;

import com.huaweicloud.sdk.core.auth.ICredential;
import com.huaweicloud.sdk.core.auth.BasicCredentials;
import com.huaweicloud.sdk.core.exception.ConnectionException;
import com.huaweicloud.sdk.core.exception.RequestTimeoutException;
import com.huaweicloud.sdk.core.exception.ServiceResponseException;
import com.huaweicloud.sdk.aom.v2.region.AomRegion;
import com.huaweicloud.sdk.aom.v2.*;
import com.huaweicloud.sdk.aom.v2.model.*;


public class CreateRecordingRuleSolution {

    public static void main(String[] args) {
        // The AK and SK used for authentication are hard-coded or stored in plaintext, which has great security risks. It is recommended that the AK and SK be stored in ciphertext in configuration files or environment variables and decrypted during use to ensure security.
        // In this example, AK and SK are stored in environment variables for authentication. Before running this example, set environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment
        String ak = System.getenv("CLOUD_SDK_AK");
        String sk = System.getenv("CLOUD_SDK_SK");

        ICredential auth = new BasicCredentials()
                .withAk(ak)
                .withSk(sk);

        AomClient client = AomClient.newBuilder()
                .withCredential(auth)
                .withRegion(AomRegion.valueOf("<YOUR REGION>"))
                .build();
        CreateRecordingRuleRequest request = new CreateRecordingRuleRequest();
        RecordingRuleRequest body = new RecordingRuleRequest();
        body.withRecordingRule("groups:
    - name: apiserver_request_total
      interval: 60s
      rules:
        - record: job_instance_mode:apiserver_request_total:avg_rate5m
          expr: avg by (job, instance, mode) (rate(apiserver_request_total[5m]))
          labels:
            team: operations
        - record: job:apiserver_request_total:sum_rate10m
          expr: sum by (job)(rate(apiserver_request_total[10m]))
          labels:
            team: operations");
        request.withBody(body);
        try {
            CreateRecordingRuleResponse response = client.createRecordingRule(request);
            System.out.println(response.toString());
        } catch (ConnectionException e) {
            e.printStackTrace();
        } catch (RequestTimeoutException e) {
            e.printStackTrace();
        } catch (ServiceResponseException e) {
            e.printStackTrace();
            System.out.println(e.getHttpStatusCode());
            System.out.println(e.getRequestId());
            System.out.println(e.getErrorCode());
            System.out.println(e.getErrorMsg());
        }
    }
}

Python

Create a recording rule for a Prometheus instance.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
# coding: utf-8

import os
from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkaom.v2.region.aom_region import AomRegion
from huaweicloudsdkcore.exceptions import exceptions
from huaweicloudsdkaom.v2 import *

if __name__ == "__main__":
    # The AK and SK used for authentication are hard-coded or stored in plaintext, which has great security risks. It is recommended that the AK and SK be stored in ciphertext in configuration files or environment variables and decrypted during use to ensure security.
    # In this example, AK and SK are stored in environment variables for authentication. Before running this example, set environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment
    ak = os.environ["CLOUD_SDK_AK"]
    sk = os.environ["CLOUD_SDK_SK"]

    credentials = BasicCredentials(ak, sk)

    client = AomClient.new_builder() \
        .with_credentials(credentials) \
        .with_region(AomRegion.value_of("<YOUR REGION>")) \
        .build()

    try:
        request = CreateRecordingRuleRequest()
        request.body = RecordingRuleRequest(
            recording_rule="groups:
    - name: apiserver_request_total
      interval: 60s
      rules:
        - record: job_instance_mode:apiserver_request_total:avg_rate5m
          expr: avg by (job, instance, mode) (rate(apiserver_request_total[5m]))
          labels:
            team: operations
        - record: job:apiserver_request_total:sum_rate10m
          expr: sum by (job)(rate(apiserver_request_total[10m]))
          labels:
            team: operations"
        )
        response = client.create_recording_rule(request)
        print(response)
    except exceptions.ClientRequestException as e:
        print(e.status_code)
        print(e.request_id)
        print(e.error_code)
        print(e.error_msg)

Go

Create a recording rule for a Prometheus instance.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
package main

import (
	"fmt"
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/core/auth/basic"
    aom "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/aom/v2"
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/services/aom/v2/model"
    region "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/aom/v2/region"
)

func main() {
    // The AK and SK used for authentication are hard-coded or stored in plaintext, which has great security risks. It is recommended that the AK and SK be stored in ciphertext in configuration files or environment variables and decrypted during use to ensure security.
    // In this example, AK and SK are stored in environment variables for authentication. Before running this example, set environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment
    ak := os.Getenv("CLOUD_SDK_AK")
    sk := os.Getenv("CLOUD_SDK_SK")

    auth := basic.NewCredentialsBuilder().
        WithAk(ak).
        WithSk(sk).
        Build()

    client := aom.NewAomClient(
        aom.AomClientBuilder().
            WithRegion(region.ValueOf("<YOUR REGION>")).
            WithCredential(auth).
            Build())

    request := &model.CreateRecordingRuleRequest{}
	request.Body = &model.RecordingRuleRequest{
		RecordingRule: "groups:
    - name: apiserver_request_total
      interval: 60s
      rules:
        - record: job_instance_mode:apiserver_request_total:avg_rate5m
          expr: avg by (job, instance, mode) (rate(apiserver_request_total[5m]))
          labels:
            team: operations
        - record: job:apiserver_request_total:sum_rate10m
          expr: sum by (job)(rate(apiserver_request_total[10m]))
          labels:
            team: operations",
	}
	response, err := client.CreateRecordingRule(request)
	if err == nil {
        fmt.Printf("%+v\n", response)
    } else {
        fmt.Println(err)
    }
}

More

For SDK sample code of more programming languages, see the Sample Code tab in API Explorer. SDK sample code can be automatically generated.

Status Codes

Status Code

Description

204

OK: The request is successful.

500

The recording rule already exists.

Error Codes

See Error Codes.