In Messwerten und Ressourcentypen suchen

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

In diesem Dokument wird erläutert, wie Sie mit der Cloud Monitoring API Listen oder Beschreibungen für Folgendes abrufen:

  • In Ihrem Projekt definierte benutzerdefinierte Messwerttypen.
  • Messwerttypen von Drittanbietern mit Zeitachsendaten in Ihrem Projekt. Von BindPlane generierte Messwerte sind Beispiele für Messwerte von Drittanbietern. BindPlane-Messwerte haben das Präfix external.googleapis.com/bluemedora/generic_node/.
  • Von Google Cloud bereitgestellte integrierte Messwerttypen. Diese Messwerttypen können Ihnen beim Entwerfen Ihrer benutzerdefinierten Messwerte helfen. Informationen zu diesen Messwerten finden Sie in der Dokumentation. Weitere Informationen finden Sie in der Liste der Messwerte.
  • Überwachte Ressourcentypen für Ihr Projekt. Informationen zu diesen Ressourcen finden Sie in der Dokumentation. Siehe Liste der überwachten Ressourcen.

Es gibt mehrere Möglichkeiten, die auf dieser Seite beschriebenen API-Methoden zu verwenden:

  • Sie können die Methoden ausführen, ohne Code schreiben zu müssen. In den Beispielen auf den Tabs Protokoll auf dieser Seite wird der formularbasierte APIs Explorer verwendet. (Weitere Informationen zu diesem Tool finden Sie unter APIs Explorer.)

  • An den Beispielen mit ausführbarem Code auf dieser Seite können Sie sehen, wie die Methoden in bestimmten Programmiersprachen aufgerufen werden.

Hinweis

Messwertdeskriptoren auflisten

Messwertdeskriptoren sind die Schemas, die Messwerte definieren. Bei den verfügbaren Messwertdeskriptoren finden Sie Details zu den gewünschten Messwerten:

  • Integrierte Messwerte: Sie können API-Anfragen an jedes vorhandene Projekt senden oder die Dokumentation zu Messwertlisten verwenden.
  • Benutzerdefinierte und externe Messwerte: Sie müssen die API-Anfrage an ein Projekt senden, in dem der benutzerdefinierte Messwert definiert ist oder in dem Zeitachsendaten für den Messwert vorhanden sind.

Weitere Informationen zur Benennung von Messwerttypen finden Sie unter Namenskonventionen.

Messwerttypen auflisten

Eine aktuelle Liste der Messwertdeskriptoren erhalten Sie mit der Methode metricDescriptors.list. Verwenden Sie einen Filter, um die zurückgegebenen Messwerttypen einzugrenzen. Hilfe bei der Entscheidung, nach welchen Messwerttypen gesucht werden soll, finden Sie unter Werttypen und Messwertarten.

Protokoll

Im Folgenden finden Sie Beispielparameter für metricDescriptors.list für die Rückgabe von Compute Engine-Messwerten:

  • Name: projects/PROJECT_ID
  • Filter: metric.type = starts_with("compute.googleapis.com")

Jetzt testen

Bevor Sie auf die Schaltfläche Execute (Ausführen) klicken, ersetzen Sie PROJECT_ID durch eine gültige ID.

Das folgende Ausgabebeispiel enthält zwei der zahlreichen Compute Engine-Messwerte, die dem Filter entsprechen:

    "metricDescriptors": [
      {
        "name": "projects/PROJECT_ID/metricDescriptors/compute.googleapis.com/firewall/dropped_bytes_count",
        "labels": [{...}],
         ...
         "description": "Count of incoming bytes dropped by the firewall.",
         "displayName": "Dropped bytes",
         "type": "compute.googleapis.com/firewall/dropped_bytes_count",
         ...
      },
      {
         "name": "projects/PROJECT_ID/metricDescriptors/compute.googleapis.com/firewall/dropped_packets_count",
         "labels": [{...}],
         ...
         "description": "Count of incoming packets dropped by the firewall.",
         "displayName": "Dropped packets",
         "type": "compute.googleapis.com/firewall/dropped_packets_count",
      },
      ...
    ]

Der Wert type gibt den Messwertdeskriptor an, z. B. compute.googleapis.com/firewall/dropped_packets_count. Dieser Wert wird manchmal auch als "Messwerttyp" oder "Messwerttypname" bezeichnet.

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"
	"cloud.google.com/go/monitoring/apiv3/v2/monitoringpb"
	"google.golang.org/api/iterator"
)

// 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
	}
	defer c.Close()

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

async function listMetricDescriptors() {
  /**
   * 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));
}
listMetricDescriptors();

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

from google.cloud import monitoring_v3

client = monitoring_v3.MetricServiceClient()
project_name = f"projects/{project_id}"
for descriptor in client.list_metric_descriptors(name=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

Wenn Probleme auftreten, lesen Sie Fehlerbehebung bei API-Aufrufen.

Messwertdeskriptoren abrufen

Verwenden Sie die Methode metricDescriptors.get, um Informationen zu einem bestimmten Messwerttyp abzurufen. Diese Methode gibt einen Messwertdeskriptor zurück.

Um einen bestimmten Messwertdeskriptor abzurufen, müssen Sie der API den vollständigen Namen des Messwerts angeben. Der vollständige Name besteht aus zwei Komponenten:

  • Ein Präfix bestehend aus projects/PROJECT_ID/metricDescriptors.
  • Der Wert type, der den Messwertdeskriptor angibt, z. B. compute.googleapis.com/firewall/dropped_packets_count. Weitere Informationen zum Wert type finden Sie auf dem Tab Protokoll in Messwerttypen auflisten.

Im Folgenden finden Sie ein Beispiel für den vollständigen Namen eines Messwerts:

projects/PROJECT_ID/metricDescriptors/compute.googleapis.com/firewall/dropped_packets_count

Protokoll

Verwenden Sie den folgenden Parameter für metricDescriptors.get, um Details zum Compute Engine-Messwert /firewall/dropped_packets_count abzurufen:

  • Name: projects/PROJECT_ID/metricDescriptors/compute.googleapis.com/firewall/dropped_packets_count

Jetzt testen

Bevor Sie auf die Schaltfläche Execute (Ausführen) klicken, ersetzen Sie PROJECT_ID durch eine gültige ID.

Das folgende Antwortbeispiel enthält den Deskriptor des Messwerts:

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

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"
	"cloud.google.com/go/monitoring/apiv3/v2/monitoringpb"
)

// 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)
	}
	defer c.Close()
	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();

async function getMetricDescriptor() {
  /**
   * 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}`);
  });
}
getMetricDescriptor();

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

from google.cloud import monitoring_v3

client = monitoring_v3.MetricServiceClient()
descriptor = client.get_metric_descriptor(name=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

Wenn Probleme auftreten, lesen Sie Fehlerbehebung bei API-Aufrufen.

Überwachte Ressourcen auflisten

Überwachte Ressourcen sind überwachbare Cloudentitäten. Suchen Sie in der Liste der überwachten Ressourcentypen, um Arten von Entitäten mit Messwerten zu finden.

Um Informationen zu überwachten Ressourcen abzurufen, können Sie API-Anfragen an ein vorhandenes Projekt senden oder die Dokumentation zur Liste überwachter Ressourcen verwenden.

Ressourcentypen auflisten

Um eine aktuelle Liste der überwachten Ressourcentypen von der Monitoring API abzurufen, verwenden Sie die Methode monitoredResourceDescriptors.list, und geben Sie Ihre Projekt-ID an.

Protokoll

Verwenden Sie zum Abrufen einer aktuellen Liste der überwachten Ressourcentypen monitoredResourceDescriptors.list mit den folgenden Beispielparametern:

  • Name: projects/PROJECT_ID

Jetzt testen

Bevor Sie auf die Schaltfläche Execute (Ausführen) klicken, ersetzen Sie PROJECT_ID durch eine gültige ID.

Das folgende Antwortbeispiel enthält einige der zurückgegebenen, überwachten Ressourcentypen:

    {
    "resourceDescriptors": [
    {
      "type": "aiplatform.googleapis.com/Endpoint",
      "displayName": "AI Platform Endpoint",
      "description": "A Cloud AI Platform API Endpoint where Models are deployed into it.",
      "labels": [{...}],
      "name": "projects/PROJECT_ID/monitoredResourceDescriptors/aiplatform.googleapis.com/Endpoint",
    },
    {
      "type": "aiplatform.googleapis.com/Featurestore",
      "displayName": "AI Platform Feature Store",
      "description": "A Cloud AI Platform Feature Store.",
      "labels": [{...}],
      "name": "projects/PROJECT_ID/monitoredResourceDescriptors/aiplatform.googleapis.com/Featurestore",
    },

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"
	"cloud.google.com/go/monitoring/apiv3/v2/monitoringpb"
	"google.golang.org/api/iterator"
)

// 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
	}
	defer c.Close()

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

async function listMonitoredResourceDescriptors() {
  /**
   * 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();
  });
}
listMonitoredResourceDescriptors();

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

from google.cloud import monitoring_v3

client = monitoring_v3.MetricServiceClient()
project_name = f"projects/{project_id}"
resource_descriptors = client.list_monitored_resource_descriptors(name=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

Wenn Probleme auftreten, lesen Sie Fehlerbehebung bei API-Aufrufen.

Ressourcendeskriptoren abrufen

Details zu einem bestimmten Typ von überwachter Ressource erhalten Sie mit der Methode monitoredResourceDescriptors.get.

Sie müssen der API den vollständigen Namen des Deskriptors angeben, um einen bestimmten Deskriptor für eine überwachte Ressourcen abzurufen. Der vollständige Name besteht aus zwei Komponenten:

  • Ein Präfix bestehend aus projects/PROJECT_ID/monitoredResourceDescriptors.
  • Der Wert type, der den Deskriptor der überwachten Ressource identifiziert, z. B. gce_instance. Weitere Informationen zum Wert type finden Sie auf dem Tab Protokoll in Ressourcentypen auflisten.

Das folgende Beispiel zeigt den vollständigen Namen einer überwachten Ressource:

projects/PROJECT_ID/monitoredResourceDescriptors/gce_instance

Protokoll

Verwenden Sie den folgenden Parameter für monitoredResourceDescriptors.get method, um Details zum Ressourcentyp gce_instance abzurufen:

  • Name: projects/PROJECT_ID/monitoredResourceDescriptors/gce_instance

Jetzt testen

Bevor Sie auf die Schaltfläche Execute (Ausführen) klicken, ersetzen Sie PROJECT_ID durch eine gültige ID.

Das folgende Antwortbeispiel enthält den Deskriptor dieser überwachten Ressource:

    {
      "type": "gce_instance",
      "displayName": "VM Instance",
      "description": "A virtual machine instance hosted in Compute Engine.",
      "labels": [
        {
          "key": "project_id",
          "description": "The identifier of the Google Cloud 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"
	"cloud.google.com/go/monitoring/apiv3/v2/monitoringpb"
)

// 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)
	}
	defer c.Close()
	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();

async function getMonitoredResourceDescriptor() {
  /**
   * 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}`);
  });
}
getMonitoredResourceDescriptor();

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

from google.cloud import monitoring_v3

client = monitoring_v3.MetricServiceClient()
resource_path = (
    f"projects/{project_id}/monitoredResourceDescriptors/{resource_type_name}"
)
pprint.pprint(client.get_monitored_resource_descriptor(name=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

Wenn Probleme auftreten, lesen Sie Fehlerbehebung bei API-Aufrufen.

Nächste Schritte