In Messwerten und Ressourcentypen suchen

Auf dieser Seite wird erläutert, wie Sie mit der Monitoring API Folgendes tun:

  • Eine Liste oder Beschreibung Ihrer benutzerdefinierten Messwerttypen abrufen
  • Eine Liste oder Beschreibung integrierter Messwerttypen abrufen, um benutzerdefinierte Messwerte zu erstellen. Diese Liste wird auch in der Dokumentation aufgeführt. Weitere Informationen finden Sie unter Messwertliste.
  • Eine Liste oder Beschreibung der verfügbaren überwachten Ressourcentypen abrufen, um die Zeitachsendaten der benutzerdefinierten Messwerte mit Labels zu versehen. Diese Liste wird auch in der Dokumentation aufgeführt (siehe Liste überwachter Ressourcen).

Eine Einführung in diese Konzepte finden Sie unter Messwerte, Zeitachsen und Ressourcen.

Auf dieser Seite werden die Methoden metricDescriptors.list und get sowie monitoredResourceDescriptors.list und get beschrieben. Diese Methoden können auf verschiedene Arten verwendet werden:

  • 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 API Explorer dafür verwendet. (Weitere Informationen zu diesem Tool finden Sie unter API Explorer.)

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

Messwerte von BindPlane durchsuchen

Messwerte von BindPlane finden Sie im Metrics Explorer. Alle BindPlane-Messwerte werden mit dem Ressourcentyp generic_node angezeigt und der Messwertname hat das Präfix external.googleapis.com/bluemedora/generic_node/.

Informationen zu den verfügbaren Quellen in BindPlane finden Sie in der Dokumentation BindPlane-Quellen.

Kein Arbeitsbereich erforderlich

Außer bei der Arbeit mit benutzerdefinierten Messwerten können Sie jedes vorhandene Projekt in metricDescriptors.list- und get-Aufrufen verwenden, auch wenn sich das Projekt nicht in einem Arbeitsbereich befindet. Wenn Sie mit benutzerdefinierten Messwerten arbeiten, geben Sie das Projekt an, in dem die benutzerdefinierten Messwerte definiert sind.

Sie können auch ein vorhandenes Projekt mit den Methoden monitoredResourceDescriptors.list und get verwenden.

Messwertdeskriptoren auflisten

Messwertdeskriptoren sind die Schemas, die integrierte und benutzerdefinierte Messwerte definieren. In den verfügbaren Messwertdeskriptoren finden Sie Details zu den gewünschten Messwerten.

Derzeit gibt es über 900 integrierte Messwerte. In der vollständigen Messwertliste können Sie alle nachschlagen.

Weitere Informationen zur Benennung von Messwerttypen finden Sie unter Namenskonventionen.

Beispiel: Messwerttypen auflisten

Eine aktuelle Liste der Messwerttypen erhalten Sie mit der Methode metricDescriptors.list. Verwenden Sie einen Filter, um die zurückgegebenen Messwerttypen einzugrenzen. Unter Werttypen und Messwertarten finden Sie Informationen dazu, welche Messwerttypen gesucht werden sollen.

Protokoll

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

  • Name: projects/[PROJECT_ID]
  • Filter: metric.type = starts_with("compute.googleapis.com")
  • Felder: metricDescriptors.type,metricDescriptors.displayName

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 drei der zahlreichen Compute Engine-Messwerte, die dem Filter entsprechen:

"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"
  },
  ...
]

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"
	"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 = 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 Fehler bei API-Aufrufen beheben.

Beispiel: Messwertdeskriptoren abrufen

Um weitere Details zu einem Messwerttyp zu erhalten, rufen Sie den vollständigen Messwertdeskriptor mithilfe der metricDescriptors.get-Methode ab.

Sie brauchen dazu den vollständigen Namen des Deskriptors. Dieser Wert setzt sich aus zwei Komponenten zusammen:

  • 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 type-Wert finden Sie auf dem Tab PROTOKOLL im Abschnitt Beispiel: Messtypen auflisten.

Beispiel: 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:

{
  "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(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 Fehler bei API-Aufrufen beheben.

Überwachte Ressourcen auflisten

Überwachte Ressourcen sind überwachbare Cloudentitäten. In den vorhandenen überwachten Ressourcentypen finden Sie die Entitäten mit Messwerten.

Derzeit gibt es etwa 100 verschiedene überwachte Ressourcendeskriptoren. Siehe dazu die Liste überwachter Ressourcen.

Eine Einführung in Messwertdeskriptoren und überwachte Ressourcen finden Sie unter Messwerte, Zeitachsen und Ressourcen.

Sie können jedes vorhandene Projekt in monitoredResourceDescriptors.list- und get-Aufrufen verwenden, auch wenn sich das Projekt nicht in einem Arbeitsbereich befindet.

Beispiel: Ressourcentypen auflisten

Verwenden Sie die Methode monitoredResourceDescriptors.list, um eine aktuelle Liste der überwachten Ressourcentypen von der Monitoring API abzurufen und Ihre Projekt-ID anzugeben.

Protokoll

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

  • Name: projects/[PROJECT_ID]
  • Felder: resourceDescriptors.type

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": "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 = 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 Fehler bei API-Aufrufen beheben.

Ressourcendeskriptoren abrufen

Rufen Sie die vollständige Beschreibung mit der Methode monitoredResourceDescriptors.get ab, um weitere Details zu überwachten Ressourcentypen zu erhalten.

Sie brauchen dazu den vollständigen Namen des Deskriptors. Dieser Wert setzt sich aus zwei Komponenten zusammen:

  • Ein Präfix bestehend aus projects/[PROJECT_ID]/monitoredResourceDescriptors.
  • Der Wert type, der den Messwertdeskriptor angibt, z. B. gce_instance. Weitere Informationen zum type-Wert finden Sie auf dem Tab PROTOKOLL im Bereich Beispiel: Ressourcentypen auflisten.

Beispiel: 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": "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 = (
    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 Fehler bei API-Aufrufen beheben.

Ressourcen suchen

Überwachte Ressourcenobjekte finden Sie in den Zeitachsendaten. Es ist in den meisten Fällen erkennbar, welche Messwerte überwachte Ressourcen eines bestimmten Typs enthalten. Wenn Sie beispielsweise eine überwachte Ressource des Typs gce_instance abrufen möchten, sehen Sie sich Zeitachsendaten aus einem Messwert wie compute.googleapils.com/instance/cpu/utilization an. Nachdem Sie eine geeignete Messwertzeitachse ermittelt haben, finden Sie weitere Informationen unter Zeitachsendaten lesen.