Como navegar por tipos de recurso e métrica

Nesta página, explicamos como usar a API Monitoring para automatizar todas estas tarefas:

• conseguir uma lista ou descrição dos tipos de métricas personalizadas;
• Conseguir uma lista ou descrição dos tipos de métricas integradas, que podem ajudar você a criar métricas personalizadas. Essa lista também aparece na documentação. Consulte Lista de métricas.
• Conseguir uma lista ou descrição dos tipos de recursos monitorados disponíveis, que você pode usar para rotular os dados de série temporal das métricas personalizadas. Essa lista também aparece na documentação. Consulte Lista de recursos monitorados.

Para ver uma introdução sobre esses conceitos, consulte Métricas, séries temporais e recursos.

Nesta página, descrevemos os métodos metricDescriptors.list e get, e também os monitoredResourceDescriptors.list e get. Há várias maneiras de usá-los:

• Para executar os métodos sem gravar códigos, o API Explorer baseado em formulários é usado nos exemplos das guias PROTOCOLO nesta página. Consulte API Explorer para ver mais informações sobre essa ferramenta.

• Para saber como usar os métodos nas linguagens de programação selecionadas, consulte as amostras de códigos executáveis nesta página.

Métricas de navegação do BindPlane

As métricas do BindPlane são encontradas em Metrics Explorer. Todas as métricas do BindPlane são mostradas com um tipo de recurso generic_node, e o nome da métrica é prefixado com external.googleapis.com/bluemedora/generic_node/.

Para ver informações sobre as fontes disponíveis no BindPlane, leia a documentação Origens do BindPlane.

Espaço de trabalho não obrigatório

Exceto ao trabalhar com métricas personalizadas, é possível usar qualquer projeto existente nas invocações metricDescriptors.list e get, mesmo que o projeto não esteja em um espaço de trabalho. Se você estiver trabalhando com métricas personalizadas, especifique o projeto em que elas serão definidas.

Também é possível usar qualquer projeto existente com os métodos monitoredResourceDescriptors.list e get.

Como listar descritores de métrica

Os descritores de métrica são os esquemas que definem métricas integradas e personalizadas. Navegue pelos descritores disponíveis para descobrir detalhes sobre as métricas que interessam você.

No momento, há mais de 900 métricas integradas. Consulte a Lista de métricas completa como referência.

Para obter mais informações sobre como os tipos de métricas são nomeados, consulte Convenções de nomenclatura.

Exemplo: como listar tipos de métrica

Para obter uma lista atual de tipos de métricas, use o método metricDescriptors.list. Para restringir o conjunto de tipos de métricas retornados, use um filtro. Veja tipos de valor e tipos de métrica para ajudar a decidir quais tipos de métricas serão pesquisados.

Protocolo

Veja a seguir exemplos de parâmetros para metricDescriptors.list para retornar métricas do Compute Engine:

• nome: projects/[PROJECT_ID]
• filter: metric.type = starts_with("compute.googleapis.com")
• fields: metricDescriptors.type,metricDescriptors.displayName

Faça o teste!

Antes de clicar no botão Execute, altere [PROJECT_ID] para um ID válido.

O resultado de amostra a seguir mostra três das muitas métricas do Compute Engine que correspondem ao filtro:

"metricDescriptors": [
      {
       "displayName": "Dropped bytes",
       "type": "compute.googleapis.com/firewall/dropped_bytes_count"
      },
      {
       "displayName": "Dropped packets",
       "type": "compute.googleapis.com/firewall/dropped_packets_count"
      },
      {
       "displayName": "Reserved cores.",
       "type": "compute.googleapis.com/instance/cpu/reserved_cores"
      },
      ...
    ]
    

O valor type aqui identifica o descritor de métrica, como compute.googleapis.com/firewall/dropped_packets_count. Às vezes, esse valor também é chamado “tipo de métrica” ou “nome do tipo de métrica”.

C#

Ver no GitHub Feedback

public static object ListMetrics(string projectId)
    {
        MetricServiceClient client = MetricServiceClient.Create();
        ProjectName projectName = new ProjectName(projectId);
        PagedEnumerable<ListMetricDescriptorsResponse, MetricDescriptor> metrics = client.ListMetricDescriptors(projectName);
        foreach (MetricDescriptor metric in metrics)
        {
            Console.WriteLine($"{metric.Name}: {metric.DisplayName}");
        }
        return 0;
    }

Go

Ver no GitHub Feedback

    import (
    	"context"
    	"fmt"
    	"io"

    	monitoring "cloud.google.com/go/monitoring/apiv3"
    	"google.golang.org/api/iterator"
    	monitoringpb "google.golang.org/genproto/googleapis/monitoring/v3"
    )

    // listMetrics lists all the metrics available to be monitored in the API.
    func listMetrics(w io.Writer, projectID string) error {
    	ctx := context.Background()
    	c, err := monitoring.NewMetricClient(ctx)
    	if err != nil {
    		return err
    	}

    	req := &monitoringpb.ListMetricDescriptorsRequest{
    		Name: "projects/" + projectID,
    	}
    	iter := c.ListMetricDescriptors(ctx, req)

    	for {
    		resp, err := iter.Next()
    		if err == iterator.Done {
    			break
    		}
    		if err != nil {
    			return fmt.Errorf("Could not list metrics: %v", err)
    		}
    		fmt.Fprintf(w, "%v\n", resp.GetType())
    	}
    	fmt.Fprintln(w, "Done")
    	return nil
    }
    

Java

Ver no GitHub Feedback

// Your Google Cloud Platform project ID
    String projectId = System.getProperty("projectId");

    final MetricServiceClient client = MetricServiceClient.create();
    ProjectName name = ProjectName.of(projectId);

    ListMetricDescriptorsRequest request = ListMetricDescriptorsRequest
        .newBuilder()
        .setName(name.toString())
        .build();
    ListMetricDescriptorsPagedResponse response = client.listMetricDescriptors(request);

    System.out.println("Listing descriptors: ");

    for (MetricDescriptor d : response.iterateAll()) {
      System.out.println(d.getName() + " " + d.getDisplayName());
    }

Node.js

Ver no GitHub Feedback

// Imports the Google Cloud client library
    const monitoring = require('@google-cloud/monitoring');

    // Creates a client
    const client = new monitoring.MetricServiceClient();

    /**
     * TODO(developer): Uncomment and edit the following lines of code.
     */
    // const projectId = 'YOUR_PROJECT_ID';

    const request = {
      name: client.projectPath(projectId),
    };

    // Lists metric descriptors
    const [descriptors] = await client.listMetricDescriptors(request);
    console.log('Metric Descriptors:');
    descriptors.forEach(descriptor => console.log(descriptor.name));
    

PHP

Ver no GitHub Feedback

use Google\Cloud\Monitoring\V3\MetricServiceClient;

    /**
     * Example:
     * ```
     * list_descriptors($projectId);
     * ```
     *
     * @param string $projectId Your project ID
     */
    function list_descriptors($projectId)
    {
        $metrics = new MetricServiceClient([
            'projectId' => $projectId,
        ]);

        $projectName = $metrics->projectName($projectId);
        $descriptors = $metrics->listMetricDescriptors($projectName);

        printf('Metric Descriptors:' . PHP_EOL);
        foreach ($descriptors->iterateAllElements() as $descriptor) {
            printf($descriptor->getName() . PHP_EOL);
        }
    }

Python

Ver no GitHub Feedback

client = monitoring_v3.MetricServiceClient()
    project_name = client.project_path(project_id)
    for descriptor in client.list_metric_descriptors(project_name):
        print(descriptor.type)

Ruby

Ver no GitHubFeedback

client = Google::Cloud::Monitoring::Metric.new
    project_name = Google::Cloud::Monitoring::V3::MetricServiceClient.project_path project_id
    results = client.list_metric_descriptors project_name
    results.each do |descriptor|
      p descriptor.type
    end

Veja Troubleshooting API calls (em inglês) se tiver dificuldade.

Exemplo: como conseguir descritores de métrica

Para ver mais detalhes sobre um tipo de métrica, recupere o descritor de métrica completo usando o método metricDescriptors.get.

Para recuperar um descritor de métrica específico, você precisa do nome completo dele. Esse valor é criado a partir de dois componentes:

• Um prefixo composto por projects/[PROJECT_ID]/metricDescriptors.
• O valor de type que identifica o descritor de métrica, por exemplo, compute.googleapis.com/firewall/dropped_packets_count. Consulte a guia PROTOCOLO em Exemplo: como listar tipos de métricas para ver mais informações sobre o valor type.

Exemplo: projects/[PROJECT_ID]/metricDescriptors/compute.googleapis.com/firewall/dropped_packets_count.

Protocolo

Para ver os detalhes da métrica /firewall/dropped_packets_count do Compute Engine, use o seguinte parâmetro para metricDescriptors.get:

• nome: projects/[PROJECT_ID]/metricDescriptors/compute.googleapis.com/firewall/dropped_packets_count

Faça o teste!

Antes de clicar no botão Execute, altere [PROJECT_ID] para um ID válido.

A resposta de amostra a seguir exibe o descritor da métrica:

{
      "type": "compute.googleapis.com/firewall/dropped_packets_count",
      "name": "projects/[PROJECT_ID]/metricDescriptors/compute.googleapis.com/firewall/dropped_packets_count",
      "description": "Delta count of incoming packets dropped by the firewall.",
      "displayName": "Dropped packets",
      "labels": [
       {
        "key": "instance_name",
        "description": "The name of the VM instance."
       }
      ],
      "metricKind": "DELTA",
      "valueType": "INT64",
      "unit": "1"
    }
    

C#

Ver no GitHub Feedback

public static object GetMetricDetails(string projectId, string metricType)
    {
        MetricServiceClient client = MetricServiceClient.Create();
        MetricDescriptorName name = new MetricDescriptorName(projectId, metricType);
        try
        {
            var response = client.GetMetricDescriptor(name);
            string metric = JObject.Parse($"{response}").ToString();
            Console.WriteLine($"{ metric }");
        }
        catch (Grpc.Core.RpcException ex)
            when (ex.Status.StatusCode == Grpc.Core.StatusCode.NotFound)
        { }
        return 0;
    }

Go

Ver no GitHub Feedback

    import (
    	"context"
    	"fmt"
    	"io"

    	monitoring "cloud.google.com/go/monitoring/apiv3"
    	monitoringpb "google.golang.org/genproto/googleapis/monitoring/v3"
    )

    // getMetricDescriptor gets the descriptor for the given metricType and prints
    // information about it. metricType is the type of the metric, for example
    // compute.googleapis.com/firewall/dropped_packets_count.
    func getMetricDescriptor(w io.Writer, projectID, metricType string) error {
    	ctx := context.Background()
    	c, err := monitoring.NewMetricClient(ctx)
    	if err != nil {
    		return fmt.Errorf("NewMetricClient: %v", err)
    	}
    	req := &monitoringpb.GetMetricDescriptorRequest{
    		Name: fmt.Sprintf("projects/%s/metricDescriptors/%s", projectID, metricType),
    	}
    	resp, err := c.GetMetricDescriptor(ctx, req)
    	if err != nil {
    		return fmt.Errorf("could not get custom metric: %v", err)
    	}

    	fmt.Fprintf(w, "Name: %v\n", resp.GetName())
    	fmt.Fprintf(w, "Description: %v\n", resp.GetDescription())
    	fmt.Fprintf(w, "Type: %v\n", resp.GetType())
    	fmt.Fprintf(w, "Metric Kind: %v\n", resp.GetMetricKind())
    	fmt.Fprintf(w, "Value Type: %v\n", resp.GetValueType())
    	fmt.Fprintf(w, "Unit: %v\n", resp.GetUnit())
    	fmt.Fprintf(w, "Labels:\n")
    	for _, l := range resp.GetLabels() {
    		fmt.Fprintf(w, "\t%s (%s) - %s", l.GetKey(), l.GetValueType(), l.GetDescription())
    	}
    	return nil
    }
    

Java

Ver no GitHub Feedback

// Your Google Cloud Platform project ID
    String projectId = System.getProperty("projectId");

    final MetricServiceClient client = MetricServiceClient.create();
    MonitoredResourceDescriptorName name = MonitoredResourceDescriptorName.of(projectId, type);
    MonitoredResourceDescriptor response = client.getMonitoredResourceDescriptor(name);

    System.out.println("Printing monitored resource descriptor: ");
    System.out.println(response);

Node.js

Ver no GitHub Feedback

// Imports the Google Cloud client library
    const monitoring = require('@google-cloud/monitoring');

    // Creates a client
    const client = new monitoring.MetricServiceClient();

    /**
     * TODO(developer): Uncomment and edit the following lines of code.
     */
    // const projectId = 'YOUR_PROJECT_ID';
    // const metricId = 'custom.googleapis.com/your/id';

    const request = {
      name: client.projectMetricDescriptorPath(projectId, metricId),
    };

    // Retrieves a metric descriptor
    const [descriptor] = await client.getMetricDescriptor(request);
    console.log(`Name: ${descriptor.displayName}`);
    console.log(`Description: ${descriptor.description}`);
    console.log(`Type: ${descriptor.type}`);
    console.log(`Kind: ${descriptor.metricKind}`);
    console.log(`Value Type: ${descriptor.valueType}`);
    console.log(`Unit: ${descriptor.unit}`);
    console.log('Labels:');
    descriptor.labels.forEach(label => {
      console.log(`  ${label.key} (${label.valueType}) - ${label.description}`);
    });

PHP

Ver no GitHub Feedback

use Google\Cloud\Monitoring\V3\MetricServiceClient;

    /**
     * Example:
     * ```
     * get_descriptor($projectId);
     * ```
     *
     * @param string $projectId Your project ID
     * @param string $metricId  The ID of the Metric Descriptor to get
     */
    function get_descriptor($projectId, $metricId)
    {
        $metrics = new MetricServiceClient([
            'projectId' => $projectId,
        ]);

        $metricName = $metrics->metricDescriptorName($projectId, $metricId);
        $descriptor = $metrics->getMetricDescriptor($metricName);

        printf('Name: ' . $descriptor->getDisplayName() . PHP_EOL);
        printf('Description: ' . $descriptor->getDescription() . PHP_EOL);
        printf('Type: ' . $descriptor->getType() . PHP_EOL);
        printf('Metric Kind: ' . $descriptor->getMetricKind() . PHP_EOL);
        printf('Value Type: ' . $descriptor->getValueType() . PHP_EOL);
        printf('Unit: ' . $descriptor->getUnit() . PHP_EOL);
        printf('Labels:' . PHP_EOL);
        foreach ($descriptor->getLabels() as $labels) {
            printf('  %s (%s) - %s' . PHP_EOL,
                $labels->getKey(),
                $labels->getValueType(),
                $labels->getDescription());
        }
    }

Python

Ver no GitHub Feedback

client = monitoring_v3.MetricServiceClient()
    descriptor = client.get_metric_descriptor(metric_name)
    pprint.pprint(descriptor)

Ruby

Ver no GitHubFeedback

client = Google::Cloud::Monitoring::Metric.new
    descriptor = client.get_metric_descriptor metric_name
    p descriptor

Veja Troubleshooting API calls (em inglês) se tiver dificuldade.

Como listar recursos monitorados

Os recursos monitorados são entidades da nuvem que podem ser acompanhadas. Navegue pelos tipos de recursos monitorados atuais para encontrar os tipos de entidades que têm métricas.

Atualmente, há cerca de 100 descritores de recursos monitorados diferentes. Consulte a Lista de recursos monitorados para ver o conjunto completo.

Para ver uma introdução aos descritores de métrica e aos recursos monitorados, consulte Métricas, séries temporais e recursos.

É possível usar qualquer projeto existente nas invocações monitoredResourceDescriptors.list e get, mesmo que o projeto não esteja em um espaço de trabalho.

Exemplo: como listar tipos de recursos

Para ver uma lista atual de tipos de recursos monitorados da API Monitoring, use o método monitoredResourceDescriptors.list e forneça seu ID do projeto.

Protocolo

Para ver uma lista atual de tipos de recursos monitorados, use monitoredResourceDescriptors.list com os seguintes parâmetros de amostra:

• nome: projects/[PROJECT_ID]
• fields: resourceDescriptors.type

Faça o teste!

Antes de clicar no botão Execute, altere [PROJECT_ID] para um ID válido.

A seguinte resposta de amostra exibe alguns dos tipos de recursos monitorados retornados:

{
     "resourceDescriptors": [
      {
       "type": "api"
      },
      {
       "type": "aws_cloudfront_distribution"
      },
      {
       "type": "aws_dynamodb_table"
      },
      {
       "type": "aws_ebs_volume"
      },
      ...
    }
    

C#

Ver no GitHub Feedback

        public static object ListMonitoredResources(string projectId)
            {
                Console.WriteLine("Starting to List Monitored Resources...");
                MetricServiceClient client = MetricServiceClient.Create();
                ProjectName projectName = new ProjectName(projectId);

                PagedEnumerable<ListMonitoredResourceDescriptorsResponse, MonitoredResourceDescriptor>
                    resources = client.ListMonitoredResourceDescriptors(projectName);
                if (resources != null)
                {
                    foreach (MonitoredResourceDescriptor resource in resources.Take(10))
                    {
                        Console.WriteLine($"{resource.Name}: {resource.DisplayName}");
                    }
                }
                else { Console.WriteLine("No resources found."); }
                return 0;
            }

Go

Ver no GitHub Feedback

    import (
    	"context"
    	"fmt"
    	"io"

    	monitoring "cloud.google.com/go/monitoring/apiv3"
    	"google.golang.org/api/iterator"
    	monitoringpb "google.golang.org/genproto/googleapis/monitoring/v3"
    )

    // listMonitoredResources lists all the resources available to be monitored.
    func listMonitoredResources(w io.Writer, projectID string) error {
    	ctx := context.Background()
    	c, err := monitoring.NewMetricClient(ctx)
    	if err != nil {
    		return err
    	}

    	req := &monitoringpb.ListMonitoredResourceDescriptorsRequest{
    		Name: "projects/" + projectID,
    	}
    	iter := c.ListMonitoredResourceDescriptors(ctx, req)

    	for {
    		resp, err := iter.Next()
    		if err == iterator.Done {
    			break
    		}
    		if err != nil {
    			return fmt.Errorf("Could not list time series: %v", err)
    		}
    		fmt.Fprintf(w, "%v\n", resp)
    	}
    	fmt.Fprintln(w, "Done")
    	return nil
    }
    

Java

Ver no GitHub Feedback

// Your Google Cloud Platform project ID
    String projectId = System.getProperty("projectId");

    final MetricServiceClient client = MetricServiceClient.create();
    ProjectName name = ProjectName.of(projectId);

    ListMonitoredResourceDescriptorsRequest request = ListMonitoredResourceDescriptorsRequest
        .newBuilder()
        .setName(name.toString())
        .build();

    System.out.println("Listing monitored resource descriptors: ");

    ListMonitoredResourceDescriptorsPagedResponse response = client
        .listMonitoredResourceDescriptors(request);

    for (MonitoredResourceDescriptor d : response.iterateAll()) {
      System.out.println(d.getType());
    }

Node.js

Ver no GitHub Feedback

// Imports the Google Cloud client library
    const monitoring = require('@google-cloud/monitoring');

    // Creates a client
    const client = new monitoring.MetricServiceClient();

    /**
     * TODO(developer): Uncomment and edit the following lines of code.
     */
    // const projectId = 'YOUR_PROJECT_ID';

    const request = {
      name: client.projectPath(projectId),
    };

    // Lists monitored resource descriptors
    const [descriptors] = await client.listMonitoredResourceDescriptors(request);
    console.log('Monitored Resource Descriptors:');
    descriptors.forEach(descriptor => {
      console.log(descriptor.name);
      console.log(`  Type: ${descriptor.type}`);
      if (descriptor.labels) {
        console.log(`  Labels:`);
        descriptor.labels.forEach(label => {
          console.log(
            `    ${label.key} (${label.valueType}): ${label.description}`
          );
        });
      }
      console.log();
    });
    

PHP

Ver no GitHub Feedback

use Google\Cloud\Monitoring\V3\MetricServiceClient;

    /**
     * Example:
     * ```
     * list_resources('your-project-id');
     * ```
     *
     * @param string $projectId Your project ID
     */
    function list_resources($projectId)
    {
        $metrics = new MetricServiceClient([
            'projectId' => $projectId,
        ]);
        $projectName = $metrics->projectName($projectId);
        $descriptors = $metrics->listMonitoredResourceDescriptors($projectName);
        foreach ($descriptors->iterateAllElements() as $descriptor) {
            print($descriptor->getType() . PHP_EOL);
        }
    }

Python

Ver no GitHub Feedback

client = monitoring_v3.MetricServiceClient()
    project_name = client.project_path(project_id)
    resource_descriptors = (
        client.list_monitored_resource_descriptors(project_name))
    for descriptor in resource_descriptors:
        print(descriptor.type)

Ruby

Ver no GitHubFeedback

client = Google::Cloud::Monitoring::Metric.new
    project_name = Google::Cloud::Monitoring::V3::MetricServiceClient.project_path project_id
    results = client.list_monitored_resource_descriptors project_name
    results.each do |descriptor|
      p descriptor.type
    end

Veja Troubleshooting API calls (em inglês) se tiver dificuldade.

Como conseguir descritores de recursos

Para ver mais detalhes sobre os tipos de recursos monitorados, recupere o descritor completo usando o método monitoredResourceDescriptors.get.

Para recuperar um descritor de recurso monitorado específico, você precisa do nome completo do descritor. Esse valor é criado a partir de dois componentes:

• Um prefixo composto por projects/[PROJECT_ID]/monitoredResourceDescriptors.
• O valor de type que identifica o descritor de métrica, por exemplo, gce_instance. Consulte a guia PROTOCOLO em Exemplo: como listar tipos de recursos para ver mais sobre o valor type.

Exemplo: projects/[PROJECT_ID]/monitoredResourceDescriptors/gce_instance.

Protocolo

Para ver os detalhes do tipo de recurso gce_instance, use o parâmetro a seguir para o método monitoredResourceDescriptors.get:

• nome: projects/[PROJECT_ID]/monitoredResourceDescriptors/gce_instance

Faça o teste!

Antes de clicar no botão Execute, altere [PROJECT_ID] para um ID válido.

A seguinte resposta de amostra exibe o descritor deste recurso monitorado:

{
      "type": "gce_instance",
      "displayName": "G​C​E VM Instance",
      "description": "A virtual machine instance hosted in Google Compute Engine (G​C​E).",
      "labels": [
        {
          "key": "project_id",
          "description": "The identifier of the GCP project associated with this resource, such as \"my-project\"."
        },
        {
          "key": "instance_id",
          "description": "The numeric VM instance identifier assigned by Compute Engine."
        },
        {
          "key": "zone",
          "description": "The Compute Engine zone in which the VM is running."
        }
      ],
      "name": "projects/[PROJECT_ID]/monitoredResourceDescriptors/gce_instance"
    }
    

C#

Ver no GitHub Feedback

public static object GetMonitoredResource(string projectId, string resourceId)
    {
        MetricServiceClient client = MetricServiceClient.Create();
        MonitoredResourceDescriptorName name = new MonitoredResourceDescriptorName(projectId, resourceId);
        var response = client.GetMonitoredResourceDescriptor(name);
        string resource = JObject.Parse($"{response}").ToString();
        Console.WriteLine($"{ resource }");
        return 0;
    }

Go

Ver no GitHub Feedback

    import (
    	"context"
    	"fmt"
    	"io"

    	monitoring "cloud.google.com/go/monitoring/apiv3"
    	monitoringpb "google.golang.org/genproto/googleapis/monitoring/v3"
    )

    // getMonitoredResource gets the descriptor for the given resourceType and
    // prints information about it. resource should be of the form
    // "projects/[PROJECT_ID]/monitoredResourceDescriptors/[RESOURCE_TYPE]".
    func getMonitoredResource(w io.Writer, resource string) error {
    	ctx := context.Background()
    	c, err := monitoring.NewMetricClient(ctx)
    	if err != nil {
    		return fmt.Errorf("NewMetricClient: %v", err)
    	}
    	req := &monitoringpb.GetMonitoredResourceDescriptorRequest{
    		Name: fmt.Sprintf(resource),
    	}
    	resp, err := c.GetMonitoredResourceDescriptor(ctx, req)
    	if err != nil {
    		return fmt.Errorf("could not get custom metric: %v", err)
    	}

    	fmt.Fprintf(w, "Name: %v\n", resp.GetName())
    	fmt.Fprintf(w, "Description: %v\n", resp.GetDescription())
    	fmt.Fprintf(w, "Type: %v\n", resp.GetType())
    	fmt.Fprintf(w, "Labels:\n")
    	for _, l := range resp.GetLabels() {
    		fmt.Fprintf(w, "\t%s (%s) - %s", l.GetKey(), l.GetValueType(), l.GetDescription())
    	}
    	return nil
    }
    

Java

Ver no GitHub Feedback

void getMonitoredResource(String resourceId) throws IOException {
      String projectId = System.getProperty("projectId");
      MetricServiceClient client = MetricServiceClient.create();
      MonitoredResourceDescriptorName name =
          MonitoredResourceDescriptorName.of(projectId, resourceId);
      MonitoredResourceDescriptor response = client.getMonitoredResourceDescriptor(name);
      System.out.println("Retrieved Monitored Resource: " + gson.toJson(response));
    }

Node.js

Ver no GitHub Feedback

// Imports the Google Cloud client library
    const monitoring = require('@google-cloud/monitoring');

    // Creates a client
    const client = new monitoring.MetricServiceClient();

    /**
     * TODO(developer): Uncomment and edit the following lines of code.
     */
    // const projectId = 'YOUR_PROJECT_ID';
    // const resourceType = 'some_resource_type, e.g. cloudsql_database';

    const request = {
      name: client.projectMonitoredResourceDescriptorPath(
        projectId,
        resourceType
      ),
    };

    // Lists monitored resource descriptors
    const [descriptor] = await client.getMonitoredResourceDescriptor(request);

    console.log(`Name: ${descriptor.displayName}`);
    console.log(`Description: ${descriptor.description}`);
    console.log(`Type: ${descriptor.type}`);
    console.log('Labels:');
    descriptor.labels.forEach(label => {
      console.log(`  ${label.key} (${label.valueType}) - ${label.description}`);
    });

PHP

Ver no GitHub Feedback

use Google\Cloud\Monitoring\V3\MetricServiceClient;

    /**
     * Example:
     * ```
     * get_resource('your-project-id', 'gcs_bucket');
     * ```
     *
     * @param string $projectId Your project ID
     * @param string $resourceType The resource type of the monitored resource.
     */
    function get_resource($projectId, $resourceType)
    {
        $metrics = new MetricServiceClient([
            'projectId' => $projectId,
        ]);

        $metricName = $metrics->monitoredResourceDescriptorName($projectId, $resourceType);
        $resource = $metrics->getMonitoredResourceDescriptor($metricName);

        printf('Name: %s' . PHP_EOL, $resource->getName());
        printf('Type: %s' . PHP_EOL, $resource->getType());
        printf('Display Name: %s' . PHP_EOL, $resource->getDisplayName());
        printf('Description: %s' . PHP_EOL, $resource->getDescription());
        printf('Labels:' . PHP_EOL);
        foreach ($resource->getLabels() as $labels) {
            printf('  %s (%s) - %s' . PHP_EOL,
                $labels->getKey(),
                $labels->getValueType(),
                $labels->getDescription());
        }
    }

Python

Ver no GitHub Feedback

client = monitoring_v3.MetricServiceClient()
    resource_path = client.monitored_resource_descriptor_path(
        project_id, resource_type_name)
    pprint.pprint(client.get_monitored_resource_descriptor(resource_path))

Ruby

Ver no GitHubFeedback

client = Google::Cloud::Monitoring::Metric.new
    resource_path = Google::Cloud::Monitoring::V3::MetricServiceClient.monitored_resource_descriptor_path(
      project_id,
      resource_type
    )

    result = client.get_monitored_resource_descriptor resource_path
    p result

Veja Troubleshooting API calls (em inglês) se tiver dificuldade.

Encontrar recursos

Objetos de recurso monitorados são incluídos em dados de série temporal. No geral, é possível adivinhar quais métricas incluem recursos monitorados de tipos específicos. Por exemplo, caso queira ver um recurso monitorado gce_instance, observe os dados da série temporal de uma métrica como compute.googleapils.com/instance/cpu/utilization. Depois de identificar uma série temporal provável para métricas, consulte Como ler dados de métrica.