Como navegar por tipos de recurso e métricas

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 ajudam 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ê usa 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.

Esta página descreve os métodos metricDescriptors.list e get e os métodos 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.

Espaço de trabalho não obrigatório

Exceto quando está trabalhando com métricas personalizadas, você pode 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.

É possível também 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ê.

Atualmente, há mais de 900 métricas integradas. Consulte a Lista de métricas completa para ver uma referência.

Para ver mais informações sobre como os tipos de métricas são nomeados, consulte Regras de nomeação.

Exemplo: como listar tipos de métrica

Para ver uma lista atual com os tipos de métricas, use o método metricDescriptors.list. Use um filtro para restringir o conjunto de tipos de métricas que são retornados. Consulte Tipos de métricas para decidir quais nomes de tipo de métricas pesquisar.

Protocolo

Os itens a seguir são parâmetros de amostra de metricDescriptors.list para retornar métricas do Compute Engine:

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

Faça o teste!

Antes de clicar no botão Executar, 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"
  },
  ...
]

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

C#

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

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

// 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

// 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

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

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

Ruby

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

Consulte Solução de problemas de chamadas da API 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 que consiste em 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 mais informações sobre o valor type.

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

Protocolo

Para ver 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 Executar, 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#

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

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

// 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

// 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.metricDescriptorPath(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

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

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

Ruby

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

Consulte Solução de problemas de chamadas da API 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]
  • campos: resourceDescriptors.type

Faça o teste!

Antes de clicar no botão Executar, 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#

        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

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

// 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

// 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

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

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

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

Consulte Solução de problemas de chamadas da API 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 que consiste em 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.

Por exemplo: projects/[PROJECT_ID]/monitoredResourceDescriptors/gce_instance.

Protocolo

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

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

Faça o teste!

Antes de clicar no botão Executar, 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#

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

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

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

// 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.monitoredResourceDescriptorPath(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

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

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

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

Consulte Como solucionar problemas de chamadas da API se tiver dificuldade.

Encontrar recursos

Objetos de recurso monitorados são incluídos em dados de série temporal. Geralmente, é possível adivinhar quais métricas incluem recursos monitorados de tipos específicos. Por exemplo, se você quiser ver um recurso monitorado gce_instance, consulte os dados de série temporal a partir 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.

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Stackdriver Monitoring
Precisa de ajuda? Acesse nossa página de suporte.