Querying a Resolver Access Logging Configuration

Function

This API is used to query a resolver access logging configuration.

Calling Method

For details, see Calling APIs.

Authorization Information

Each account has all the permissions required to call all APIs, but IAM users must be assigned the required permissions.

If you are using role/policy-based authorization, see Permissions Policies and Supported Actions for details on the required permissions.
If you are using identity policy-based authorization, no identity policy-based permission required for calling this API.

URI

GET /v2/resolver/queryloggingconfig/{id}

**Table 1** Path Parameters
Parameter	Mandatory	Type	Description
id	Yes	String	The log stream ID.

Request Parameters

**Table 2** Request header parameters
Parameter	Mandatory	Type	Description
X-Auth-Token	Yes	String	Definition The user token. The token can be obtained by calling an IAM API. The value of X-Subject-Token in the response header is the user token. For details about how to obtain a user token, seeObtaining a User Token. Constraints N/A Range N/A Default Value N/A

Response Parameters

Status code: 200

**Table 3** Response body parameters
Parameter	Type	Description
resolver_query_log_config	ResolverQueryLogConfig object	Objects of the Resolver access logs.

**Table 4** ResolverQueryLogConfig
Parameter	Type	Description
id	String	ID of the Resolver access log, which is a resource identifier in UUID format.
lts_group_id	String	Log group ID.
lts_topic_id	String	Log stream ID.
vpc_ids	Array of strings	The IDs of the associated VPCs.

Status code: 400

**Table 5** Response body parameters
Parameter	Type	Description
code	String	Definition Error code Range N/A
message	String	Definition Error description Range N/A

Status code: 500

**Table 6** Response body parameters
Parameter	Type	Description
code	String	Definition Error code Range N/A
message	String	Definition Error description Range N/A

Example Requests

None

Example Responses

Status code: 200

Querying a resolver access logging configuration

{
  "resolver_query_log_config" : {
    "id" : "2f9bd47dbdab4d74a02e1484d68401ea",
    "lts_group_id" : "7c89b584-8984-405f-862e-b3bc0d791405",
    "lts_topic_id" : "8c8785f6-aad7-41c1-9c88-9c500d2ac435",
    "vpc_ids" : [ "ce84922c-5da5-4d09-89ac-d5f9de878a51" ]
  }
}

SDK Sample Code

The SDK sample code is as follows.

      
       
         
         
           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.dns.v2.region.DnsRegion;
import com.huaweicloud.sdk.dns.v2.*;
import com.huaweicloud.sdk.dns.v2.model.*;


public class ShowResolverQueryLogConfigSolution {

    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);

        DnsClient client = DnsClient.newBuilder()
                .withCredential(auth)
                .withRegion(DnsRegion.valueOf("<YOUR REGION>"))
                .build();
        ShowResolverQueryLogConfigRequest request = new ShowResolverQueryLogConfigRequest();
        request.withId("{id}");
        try {
            ShowResolverQueryLogConfigResponse response = client.showResolverQueryLogConfig(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());
        }
    }
}

          

        

      
     

      
       
         
         
           # coding: utf-8

import os
from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkdns.v2.region.dns_region import DnsRegion
from huaweicloudsdkcore.exceptions import exceptions
from huaweicloudsdkdns.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 = DnsClient.new_builder() \
        .with_credentials(credentials) \
        .with_region(DnsRegion.value_of("<YOUR REGION>")) \
        .build()

    try:
        request = ShowResolverQueryLogConfigRequest()
        request.id = "{id}"
        response = client.show_resolver_query_log_config(request)
        print(response)
    except exceptions.ClientRequestException as e:
        print(e.status_code)
        print(e.request_id)
        print(e.error_code)
        print(e.error_msg)

          

        

      
     

      
       
         
         
           package main

import (
	"fmt"
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/core/auth/basic"
    dns "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/dns/v2"
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/services/dns/v2/model"
    region "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/dns/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 := dns.NewDnsClient(
        dns.DnsClientBuilder().
            WithRegion(region.ValueOf("<YOUR REGION>")).
            WithCredential(auth).
            Build())

    request := &model.ShowResolverQueryLogConfigRequest{}
	request.Id = "{id}"
	response, err := client.ShowResolverQueryLogConfig(request)
	if err == nil {
        fmt.Printf("%+v\n", response)
    } else {
        fmt.Println(err)
    }
}

          

        

      
     