Explora tipos de métricas y recursos

En esta página, se explica cómo usar la API de Monitoring para hacer lo siguiente:

  • Obtener una lista o una descripción de tus tipos de métricas personalizadas
  • Obtener una lista o una descripción de los tipos de métricas integradas, que pueden ayudarte a diseñar tus métricas personalizadas. Esta lista también aparece en la documentación; consulta Lista de métricas.
  • Obtener una lista o una descripción de los tipos de recursos supervisados disponibles, que puedes usar para etiquetar los datos de las series temporales de tus métricas personalizadas. Esta lista también aparece en la documentación; consulta la Lista de recursos supervisados.

Para obtener una introducción a estos conceptos, consulta Métricas, series temporales y recursos.

En esta página, se describen los métodos metricDescriptors.list y get, además de los métodos monitoredResourceDescriptors.list y get. Existen varias formas de usar estos métodos:

  • Para ejecutar los métodos sin escribir ningún código, en los ejemplos de las pestañas PROTOCOLO de esta página se usa el Explorador de API basado en formularios. (Consulta Explorador de API para obtener más información sobre esta herramienta).

  • Para aprender a usar los métodos de los lenguajes de programación seleccionados, consulta las muestras de códigos ejecutables en esta página.

Explora métricas de BindPlane

Las métricas de BindPlane se pueden encontrar en Explorador de métricas. Todas las métricas de BindPlane se muestran con un tipo de recurso de generic_node, y el nombre de la métrica tiene el prefijo external.googleapis.com/bluemedora/generic_node/.

Para obtener información acerca de las fuentes disponibles en BindPlane, consulta la documentación de fuentes de BindPlane.

No se requiere espacio de trabajo

Excepto cuando trabajas con métricas personalizadas, puedes usar cualquier proyecto existente en invocaciones metricDescriptors.list y get, incluso si el proyecto no está en un lugar de trabajo. Si trabajas con métricas personalizadas, debes especificar el proyecto donde se definen las métricas personalizadas.

También puedes usar cualquier proyecto existente con los métodos monitoredResourceDescriptors.list y get.

Enumera descriptores de métricas

Los descriptores de métricas son los esquemas que definen métricas integradas y personalizadas. Si exploras los descriptores de métricas disponibles, puedes obtener más información sobre las métricas que te interesan.

En la actualidad, hay más de 900 métricas integradas. Consulta la Lista de métricas completa para obtener información de referencia.

Para obtener más información sobre el nombre de los tipos de métricas, consulta Convenciones de nombres.

Ejemplo: enumera tipos de métricas

Para obtener una lista actual de tipos de métricas, usa el método metricDescriptors.list. Para limitar el conjunto de tipos de métricas que se muestran, usa un filtro. Consulta Tipos de valores y clases de métricas para obtener ayuda con la elección de los tipos de métricas que se deben buscar.

Protocolo

Los siguientes son parámetros de muestra para metricDescriptors.list a fin de mostrar las métricas de Compute Engine:

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

Probar

Antes de hacer clic en el botón Ejecutar, cambia [PROJECT_ID] por un ID válido.

El siguiente resultado de muestra presenta tres de las muchas métricas de Compute Engine que coinciden con el 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"
  },
  ...
]

El valor type aquí identifica el descriptor de métrica, por ejemplo, compute.googleapis.com/firewall/dropped_packets_count. A veces, este valor también se denomina “tipo de métrica” o “nombre de 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

# Your Google Cloud Platform project ID
# project_id = "YOUR_PROJECT_ID"

client = Google::Cloud::Monitoring.metric_service
project_name = client.project_path project: project_id

results = client.list_metric_descriptors name: project_name
results.each do |descriptor|
  p descriptor.type
end

Consulta Soluciona problemas de llamadas a la API si tienes dificultades.

Ejemplo: obtén descriptores de métricas

Para obtener más detalles sobre un tipo de métrica, recupera el descriptor de métrica completo con el método metricDescriptors.get.

Para recuperar un descriptor de métrica específico, necesitas el nombre completo del descriptor. Este valor se construye a partir de dos componentes:

  • Un prefijo que consta de projects/[PROJECT_ID]/metricDescriptors
  • El valor type que identifica el descriptor de métrica, por ejemplo, compute.googleapis.com/firewall/dropped_packets_count. Consulta la pestaña PROTOCOLO en Ejemplo: enumera tipos de métricas para obtener más información sobre el valor type

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

Protocolo

A fin de obtener los detalles de la métrica /firewall/dropped_packets_count de Compute Engine, usa el siguiente parámetro metricDescriptors.get:

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

Probar

Antes de hacer clic en el botón Ejecutar, cambia [PROJECT_ID] por un ID válido.

La siguiente respuesta de ejemplo muestra el descriptor de la 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.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

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

# Your Google Cloud Platform project ID
# project_id = "YOUR_PROJECT_ID"

# Example metric type
# metric_type = "custom.googleapis.com/my_metric"

client = Google::Cloud::Monitoring.metric_service
metric_name = client.metric_descriptor_path project:           project_id,
                                            metric_descriptor: metric_type

descriptor = client.get_metric_descriptor name: metric_name
p descriptor

Consulta Soluciona problemas de llamadas a la API si tienes dificultades.

Enumera recursos supervisados

Los recursos supervisados son entidades de la nube que se pueden supervisar. Cuando navegas por los tipos de recursos supervisados existentes, puedes encontrar las clases de entidades que tienen métricas.

En la actualidad, hay alrededor de 100 descriptores de recursos supervisados diferentes; consulta Lista de recursos supervisados para ver el conjunto completo.

Para obtener una introducción a los descriptores de métricas y los recursos supervisados, consulta Métricas, series temporales y recursos.

Puedes usar cualquier proyecto existente en invocaciones monitoredResourceDescriptors.list y get, incluso si el proyecto no está en un espacio de trabajo.

Ejemplo: enumera tipos de recursos

Para obtener una lista actualizada de los tipos de recursos supervisados de la API de Monitoring, usa el método monitoredResourceDescriptors.list y proporciona tu ID del proyecto.

Protocolo

Para obtener una lista actual de los tipos de recursos supervisados, usa monitoredResourceDescriptors.list con los siguientes parámetros de muestra:

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

Probar

Antes de hacer clic en el botón Ejecutar, cambia [PROJECT_ID] por un ID válido.

En la siguiente respuesta de muestra, se presentan algunos de los tipos de recursos supervisados mostrados:

{
 "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

# Your Google Cloud Platform project ID
# project_id = "YOUR_PROJECT_ID"

client = Google::Cloud::Monitoring.metric_service
project_name = client.project_path project: project_id

results = client.list_monitored_resource_descriptors name: project_name
results.each do |descriptor|
  p descriptor.type
end

Consulta Soluciona problemas de llamadas a la API si tienes dificultades.

Obtén descriptores de recursos

Para obtener más detalles sobre un tipo de recurso supervisado, recupera el descriptor completo con el método monitoredResourceDescriptors.get.

Para recuperar un descriptor de recursos supervisado específico, necesitas el nombre completo del descriptor. Este valor se construye a partir de dos componentes:

  • Un prefijo que consta de projects/[PROJECT_ID]/monitoredResourceDescriptors
  • El valor type que identifica el descriptor de métrica, por ejemplo, gce_instance. Consulta la pestaña PROTOCOLO en Ejemplo: enumera tipos de recursos para obtener más información sobre el valor type

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

Protocolo

A fin de obtener los detalles del tipo de recurso gce_instance, usa el siguiente parámetro monitoredResourceDescriptors.get:

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

Probar

Antes de hacer clic en el botón Ejecutar, cambia [PROJECT_ID] por un ID válido.

En la siguiente respuesta de ejemplo, se muestra el descriptor de este recurso supervisado:

{
  "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.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

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

# Your Google Cloud Platform project ID
# project_id = "YOUR_PROJECT_ID"

# The resource type
# resource_type = "gce_instance"

client = Google::Cloud::Monitoring.metric_service
resource_path = client.monitored_resource_descriptor_path(
  project:                       project_id,
  monitored_resource_descriptor: resource_type
)

result = client.get_monitored_resource_descriptor name: resource_path
p result

Consulta Soluciona problemas de llamadas a la API si tienes dificultades.

Encuentra recursos

Los objetos de recursos supervisados se incluyen en los datos de series temporales. Por lo general, puede adivinar qué métricas incluyen recursos supervisados de tipos específicos. Por ejemplo, si deseas ver un recurso supervisado gce_instance, consulta los datos de series temporales de una métrica como compute.googleapils.com/instance/cpu/utilization. Una vez que identifiques una serie temporal de métricas probable, consulta Lee datos de métricas.