Verfügbarkeitsdiagnosen verwalten

Stackdriver kann die Verfügbarkeit Ihres Dienstes überprüfen, wenn von verschiedenen Standorten weltweit darauf zugegriffen wird. Sie können die Ergebnisse dieser Verfügbarkeitsdiagnosen in Ihren Benachrichtigungsrichtlinien verwenden oder die Ergebnisse direkt in den Monitoring-Dashboards für Verfügbarkeitsdiagnosen überprüfen.

Diese Seite enthält Anleitungen für Folgendes:

  • Neue Verfügbarkeitsdiagnose erstellen
  • Vorhandene Verfügbarkeitsdiagnosen auflisten
  • Verfügbarkeitsdiagnose bearbeiten
  • Verfügbarkeitsdiagnose löschen

Informationen zum Status Ihrer Verfügbarkeitsdiagnosen und zum Abrufen einer Liste mit IP-Adressen für Verfügbarkeitsdiagnosen finden Sie unter IP-Adressen abrufen. Wenn Sie den Status Ihrer Verfügbarkeitsdiagnosen mithilfe der API ermitteln möchten, überwachen Sie den Messwert monitoring.googleapis.com/uptime_check/check_passed. Weitere Informationen finden Sie in der GCP-Messwertliste.

Vorbereitung

  1. Die Verwendung von Verfügbarkeitsdiagnosen hängt von den Firewalls zum Schutz des Dienstes ab.

    • Wenn die zu prüfende Ressource nicht öffentlich verfügbar ist, müssen Sie die Firewall der Ressource so konfigurieren, dass von den Servern der Verfügbarkeitsdiagnose eingehender Traffic zugelassen wird. Informationen zum Herunterladen dieser Liste mit den IP-Adressen finden Sie unter IP-Adressen abrufen.
    • Wenn die überprüfte Ressource keine externe IP-Adresse hat, kann sie von Verfügbarkeitsdiagnosen nicht erreicht werden.
  2. Bei der Verfügbarkeitsdiagnose werden keine Seitenelemente geladen oder JavaScript ausgeführt. Die Standardkonfiguration einer Verfügbarkeitsdiagnose umfasst keine Authentifizierung. Sie können die Authentifizierung mit den Erweiterten Optionen aktivieren.

    Für HTTP und HTTPS gibt die Verfügbarkeitsdiagnose den Befehl GET aus und ruft die Rohdaten ab. Wenn es sich bei der GET-Antwort um eine Weiterleitung zu einer anderen URL handelt, ruft die Diagnose die Daten von dieser URL ab. Zuletzt prüft die Verfügbarkeitsdiagnose die Daten, um festzustellen, ob die Diagnose erfolgreich war oder fehlgeschlagen ist.

    Es müssen zwei Bedingungen erfüllt sein, damit sie erfolgreich ist:

    • Der HTTP-Status lautet Success.
    • Es gibt für die Daten keinen erforderlichen Inhalt bzw. der erforderliche Inhalt ist vorhanden. Der erforderliche Inhalt wird unter Advanced Options (Erweiterte Optionen) angegeben.

Verfügbarkeitsdiagnosen erstellen

In diesem Abschnitt wird das Erstellen und Konfigurieren von Verfügbarkeitsdiagnosen erläutert.

Konsole

  1. Gehen Sie in der Stackdriver Monitoring-Konsole zu Uptime Checks > Uptime Checks Overview (Verfügbarkeitsdiagnosen > Verfügbarkeitsdiagnose-Übersicht):

    Verfügbarkeitsdiagnose-Übersicht öffnen

  2. Klicken Sie oben rechts auf Add uptime check (Verfügbarkeitsdiagnose hinzufügen).

  3. Füllen Sie im Fenster New uptime check (Neue Verfügbarkeitsdiagnose) die Felder für die Diagnose aus, wie unter Grundlegende Optionen auf dieser Seite beschrieben.

    Verfügbarkeitsdiagnose erstellen

  4. Klicken Sie optional auf Advanced options (Erweiterte Optionen), um auf die Konfiguration für Port, benutzerdefinierte Header und Authentifizierung zuzugreifen. Weitere Informationen finden Sie unter Erweiterte Optionen auf dieser Seite.

  5. Klicken Sie auf Test (Testen), um das Ergebnis der Verfügbarkeitsdiagnose aufzurufen. Wenn das Ergebnis nicht Ihren Erwartungen entspricht, lesen Sie weiter unten den Abschnitt Diagnosefehler, korrigieren Sie Ihre Konfiguration und wiederholen Sie den Test.

  6. Klicken Sie auf Save (Speichern). Sie können eine Verfügbarkeitsdiagnose nicht speichern, wenn ein erforderliches Feld fehlt. Wenn die Schaltfläche Save (Speichern) deaktiviert ist, suchen Sie nach fehlenden Werten. Geben Sie in das Feld Hostname unbedingt einen Namen ein.

API

Rufen Sie die Methode projects.uptimeCheckConfigs.create auf. Legen Sie die Parameter der Methode so fest:

  • parent: Erforderlich. Dies muss der Name des Projekts sein, in dem die Verfügbarkeitsdiagnose erstellt werden soll. Ersetzen Sie [PROJECT_ID] durch Ihre GCP-Projekt-ID.

    projects/[PROJECT_ID]
    
  • Der Anfragetext muss das Objekt UptimeCheckConfig für die neue Verfügbarkeitsdiagnose enthalten. Die Felder im Objekt werden auf dieser Seite in den Abschnitten Grundlegende Optionen und Erweiterte Optionen erläutert.

    Lassen Sie das Feld name des Konfigurationsobjekts leer, da es im gelieferten Konfigurationsobjekt festgelegt wird.

Die Methode create liefert das Objekt UptimeCheckConfig für die neue Konfiguration.

Wenn die erstellte Verfügbarkeitsdiagnose nicht wie erwartet funktioniert, lesen Sie den Abschnitt Diagnosefehler auf dieser Seite.

C#

public static object CreateUptimeCheck(string projectId, string hostName,
    string displayName)
{
    // Define a new config.
    var config = new UptimeCheckConfig()
    {
        DisplayName = displayName,
        MonitoredResource = new MonitoredResource()
        {
            Type = "uptime_url",
            Labels = { { "host", hostName } }
        },
        HttpCheck = new UptimeCheckConfig.Types.HttpCheck()
        {
            Path = "/",
            Port = 80,
        },
        Timeout = TimeSpan.FromSeconds(10).ToDuration(),
        Period = TimeSpan.FromMinutes(5).ToDuration()
    };
    // Create a client.
    var client = UptimeCheckServiceClient.Create();
    string projectName = new ProjectName(projectId).ToString();
    // Create the config.
    var newConfig = client.CreateUptimeCheckConfig(projectName, config,
        CallSettings.FromCallTiming(CallTiming.FromTimeout(TimeSpan.FromMinutes(2))));
    Console.WriteLine(newConfig.Name);
    return 0;
}

Java

private static void createUptimeCheck(
    String projectId, String displayName, String hostName, String pathName) throws IOException {
  CreateUptimeCheckConfigRequest request = CreateUptimeCheckConfigRequest
      .newBuilder()
      .setParent(ProjectName.format(projectId))
      .setUptimeCheckConfig(UptimeCheckConfig
          .newBuilder()
          .setDisplayName(displayName)
          .setMonitoredResource(MonitoredResource
              .newBuilder()
              .setType("uptime_url")
              .putLabels("host", hostName))
          .setHttpCheck(HttpCheck
              .newBuilder()
              .setPath(pathName)
              .setPort(80))
          .setTimeout(Duration.newBuilder().setSeconds(10))
          .setPeriod(Duration.newBuilder().setSeconds(300)))
      .build();
  try (UptimeCheckServiceClient client = UptimeCheckServiceClient.create()) {
    UptimeCheckConfig config = client.createUptimeCheckConfig(request);
    System.out.println("Uptime check created: " + config.getDisplayName());
  } catch (Exception e) {
    usage("Exception creating uptime check: " + e.toString());
    throw e;
  }
}

Go

// create creates an example uptime check.
func create(w io.Writer, projectID string) (*monitoringpb.UptimeCheckConfig, error) {
	ctx := context.Background()
	client, err := monitoring.NewUptimeCheckClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("NewUptimeCheckClient: %v", err)
	}
	defer client.Close()
	req := &monitoringpb.CreateUptimeCheckConfigRequest{
		Parent: "projects/" + projectID,
		UptimeCheckConfig: &monitoringpb.UptimeCheckConfig{
			DisplayName: "new uptime check",
			Resource: &monitoringpb.UptimeCheckConfig_MonitoredResource{
				MonitoredResource: &monitoredres.MonitoredResource{
					Type: "uptime_url",
					Labels: map[string]string{
						"host": "example.com",
					},
				},
			},
			CheckRequestType: &monitoringpb.UptimeCheckConfig_HttpCheck_{
				HttpCheck: &monitoringpb.UptimeCheckConfig_HttpCheck{
					Path: "/",
					Port: 80,
				},
			},
			Timeout: &duration.Duration{Seconds: 10},
			Period:  &duration.Duration{Seconds: 300},
		},
	}
	config, err := client.CreateUptimeCheckConfig(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("CreateUptimeCheckConfig: %v", err)
	}
	fmt.Fprintf(w, "Successfully created uptime check %q\n", config.GetDisplayName())
	return config, nil
}

Node.js

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

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

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

const request = {
  // i.e. parent: 'projects/my-project-id'
  parent: client.projectPath(projectId),
  uptimeCheckConfig: {
    displayName: 'My Uptime Check',
    monitoredResource: {
      // See the Uptime Check docs for supported MonitoredResource types
      type: 'uptime_url',
      labels: {host: hostname},
    },
    httpCheck: {path: '/', port: 80},
    timeout: {seconds: 10},
    period: {seconds: 300},
  },
};

// Creates an uptime check config for a GCE instance
const [uptimeCheckConfig] = await client.createUptimeCheckConfig(request);
console.log('Uptime check created:');
console.log(`ID: ${uptimeCheckConfig.name}`);
console.log(`Display Name: ${uptimeCheckConfig.displayName}`);
console.log(`Resource: %j`, uptimeCheckConfig.monitoredResource);
console.log(`Period: %j`, uptimeCheckConfig.period);
console.log(`Timeout: %j`, uptimeCheckConfig.timeout);
console.log(`Check type: ${uptimeCheckConfig.check_request_type}`);
console.log(
  `Check: %j`,
  uptimeCheckConfig.httpCheck || uptimeCheckConfig.tcpCheck
);
console.log(
  `Content matchers: ${uptimeCheckConfig.contentMatchers
    .map(matcher => matcher.content)
    .join(', ')}`
);
console.log(`Regions: ${uptimeCheckConfig.selectedRegions.join(', ')}`);

PHP

use Google\Cloud\Monitoring\V3\UptimeCheckServiceClient;
use Google\Cloud\Monitoring\V3\UptimeCheckConfig;
use Google\Api\MonitoredResource;

/**
 * Example:
 * ```
 * create_uptime_check($projectId, 'myproject.appspot.com', 'Test Uptime Check!');
 * ```
 *
 * @param string $projectId Your project ID
 * @param string $hostName
 * @param string $displayName
 */
function create_uptime_check($projectId, $hostName = 'example.com', $displayName = 'New uptime check')
{
    $uptimeCheckClient = new UptimeCheckServiceClient([
        'projectId' => $projectId,
    ]);

    $monitoredResource = new MonitoredResource();
    $monitoredResource->setType('uptime_url');
    $monitoredResource->setLabels(['host' => $hostName]);

    $uptimeCheckConfig = new UptimeCheckConfig();
    $uptimeCheckConfig->setDisplayName($displayName);
    $uptimeCheckConfig->setMonitoredResource($monitoredResource);

    $uptimeCheckConfig = $uptimeCheckClient->createUptimeCheckConfig(
        $uptimeCheckClient->projectName($projectId),
        $uptimeCheckConfig
    );

    printf('Created an uptime check: %s' . PHP_EOL, $uptimeCheckConfig->getName());
}

Python

def create_uptime_check_config(project_name, host_name=None,
                               display_name=None):
    config = monitoring_v3.types.uptime_pb2.UptimeCheckConfig()
    config.display_name = display_name or 'New uptime check'
    config.monitored_resource.type = 'uptime_url'
    config.monitored_resource.labels.update(
        {'host': host_name or 'example.com'})
    config.http_check.path = '/'
    config.http_check.port = 80
    config.timeout.seconds = 10
    config.period.seconds = 300

    client = monitoring_v3.UptimeCheckServiceClient()
    new_config = client.create_uptime_check_config(project_name, config)
    pprint.pprint(new_config)
    return new_config

Ruby

def create_uptime_check_config project_id: nil, host_name: nil, display_name: nil
  require "google/cloud/monitoring/v3"

  client = Google::Cloud::Monitoring::V3::UptimeCheck.new
  project_name = Google::Cloud::Monitoring::V3::UptimeCheckServiceClient.project_path project_id
  config = {
    display_name:       display_name.nil? ? "New uptime check" : display_name,
    monitored_resource: {
      type:   "uptime_url",
      labels: { "host" => host_name.nil? ? "example.com" : host_name }
    },
    http_check:         { path: "/", port: 80 },
    timeout:            { seconds: 10 },
    period:             { seconds: 300 }
  }
  client = Google::Cloud::Monitoring::V3::UptimeCheck.new
  new_config = client.create_uptime_check_config project_name, config
  puts new_config.name
  new_config
end

Es kann bis zu 25 Minuten dauern, bis die Ergebnisse der Verfügbarkeitsdiagnose bei Monitoring eintreffen. Bis dahin meldet das Verfügbarkeitsdiagnose-Dashboard als Status "no data available" (Keine Daten verfügbar).

Grundlegende Optionen

Geben Sie Werte für die Konfiguration der Verfügbarkeitsdiagnose an, um eine neue Verfügbarkeitsdiagnose zu erstellen. Wenn Sie die Verfügbarkeitsdiagnose in der Stackdriver Monitoring-Konsole erstellen, füllen Sie ein Formular aus. Bei Verwendung der API für diesen Zweck geben Sie die entsprechenden Parameter in einem UptimeCheckConfig-Objekt an.

  1. Title (Titel): Ein Name zur Erkennung der Diagnose. Beispiel: Example.com uptime check.

  2. Check Type (Diagnosetyp): Wählen Sie als Protokoll HTTP, HTTPS oder TCP aus.

    Wenn Sie HTTPS auswählen, versucht der Dienst, eine Verbindung über HTTPS herzustellen, das SSL-Zertifikat wird jedoch nicht überprüft. Abgelaufene oder selbstsignierte Zertifikate führen dann beispielsweise nicht dazu, dass eine Diagnose fehlschlägt.

  3. Resource type (Ressourcentyp): Wählen Sie einen der folgenden Ressourcentypen aus.

    • App Engine: Google App Engine-Anwendungen (Module)
    • Elastic Load Balancer (Elastic-Load-Balancer): AWS-Load-Balancer
    • Instance (Instanz): Compute Engine- oder AWS EC2-Instanzen In der API werden sie in gce_instance und aws_ec2_instance unterteilt.
    • URL: Eine beliebige IPv4-Adresse oder ein Hostname. Pfad und Port werden separat eingegeben.
  4. Füllen Sie die Verbindungsinformationen entsprechend dem ausgewählten Diagnose- und Ressourcentyp aus:

    • Applies to (Gilt für) (App Engine, ELB oder Instanz): Sie können die Verfügbarkeitsdiagnose auf eine einzelne Ressource oder eine Gruppe von Ressourcen wie Alle Instanzen anwenden. Eine einzelne Ressource wählen Sie aus den vorhandenen Ressourcen aus, die im Menü aufgeführt sind. Wenn Sie die API verwenden, füllen Sie die überwachte Ressource mit den erforderlichen Ressourcenlabels aus, wie in der Liste überwachter Ressourcen beschrieben.

    • Module (Modul): App Engine. Geben Sie Ihr Anwendungsmodul an.

    • Hostname (Alle außer App Engine): Geben Sie den Hostnamen Ihres Dienstes an. Geben Sie beispielsweise example.com ein.

    • Path (Pfad) (HTTP, HTTPS): Geben Sie einen Pfad im Host oder in der Ressource ein oder verwenden Sie den Standardpfad. Sie können beispielsweise example.com prüfen, wenn Sie dieses Feld leer lassen. Geben Sie example.com/tester ein, um /tester zu prüfen. Lassen Sie das Präfix example.com weg. In der API lassen Sie dieses Feld leer, um den Standardwert / zu verwenden.

    • Port (HTTP, HTTPS, TCP): Wählen Sie einen Port für die Verbindung.

      • Diese Option befindet sich für HTTP- und HTTPS-Diagnosen unter Advanced Options (Erweiterte Optionen).
      • In der API lassen Sie dieses Feld leer, um den Standardwert zu verwenden, nämlich 80 für TCP- oder HTTP-Diagnosen und 443 für HTTPS-Diagnosen.
    • Response content contains the text (Antwort enthält den Text) (HTTP, HTTPS, TCP): Geben Sie einen String ein (max. 1024 Byte). Wenn dieser in der Antwort enthalten ist, gilt die Diagnose als erfolgreich. Die Diagnose gilt als fehlgeschlagen, wenn der String an keiner Stelle in der Antwort vorhanden ist.

      • Dieses Feld wird bei HTTP- und HTTPS-Diagnosen unter Advanced Options (Erweiterte Optionen) angezeigt.
      • In der API ist dies das Objekt ContentMatcher.
  5. Check every (Diagnose alle): 1, 5, 10 oder 15 Minuten. Wenn Sie beispielsweise 5 Minuten auswählen, versucht jeder geografische Standort einmal alle fünf Minuten, Ihren Dienst zu erreichen. Bei Verwendung der standardmäßigen sechs Standorte und bei einer Diagnose alle fünf Minuten erhält der Dienst im Durchschnitt 1,2 Anfragen pro Minute. Findet die Diagnose jede Minute statt, erhält der Dienst durchschnittlich sechs Anfragen pro Minute.

Erweiterte Optionen

Der Abschnitt Advanced Options (Erweiterte Optionen) gilt für HTTP-, HTTPS- und TCP-Diagnosetypen.

Für HTTP und HTTPS gibt die Verfügbarkeitsdiagnose den Befehl GET aus und ruft die Rohdaten ab. Wenn es sich bei der GET-Antwort um eine Weiterleitung zu einer anderen URL handelt, ruft die Diagnose die Daten dieser URL ab. Zuletzt prüft die Verfügbarkeitsdiagnose die Daten, um festzustellen, ob die Diagnose erfolgreich war oder fehlgeschlagen ist.

Es müssen zwei Bedingungen erfüllt sein, damit sie erfolgreich ist:

  1. Der HTTP-Status lautet Success.
  2. Es gibt für die Daten keinen erforderlichen Inhalt bzw. der erforderliche Inhalt ist vorhanden. Der erforderliche Inhalt ist unter Advanced Options (Erweiterten Optionen) angegeben.

Diese Einstellungen sind optional und variieren je nach Diagnosetyp:

  • HTTP Host Header (HTTP-Hostheader): Geben Sie einen Header ein, um virtuelle Hosts zu prüfen. Dieses Feld ist für TCP-Diagnosen nicht verfügbar.

  • Port: Geben Sie eine Portnummer an. Bei TCP-Diagnosen wird dieses Feld unter Basic Options (Grundlegende Optionen) angezeigt.

  • Response content contains the text (Antwort enthält den Text): Geben Sie einen String ein (max. 1024 Byte). Wenn dieser String in der Antwort enthalten ist, gilt die Diagnose als erfolgreich. Bei TCP-Diagnosen wird dieses Feld unter Basic Options (Grundlegende Optionen) angezeigt.

  • Locations (Speicherorte): Wählen Sie die entsprechenden geografischen Regionen aus, in denen die Diagnose Anfragen erhalten soll. Sie müssen genügend Regionen auswählen, um mindestens drei aktive Standorte zu haben. Wenn eine Diagnose erstellt wird, werden die Standorte in jeder Region unter dem Namen der Region aufgeführt. Neue Diagnosestandorte in den ausgewählten Regionen senden automatisch Anfragen an die konfigurierten Ziele. Damit immer von allen verfügbaren Standorten Anfragen gesendet werden, wählen Sie die Standardeinstellung Global aus. Wählen Sie anstelle von Global alle vorhandenen Regionen aus, um von allen Standorten in vorhandenen Regionen Anfragen zu senden, jedoch nicht von neuen Standorten in neuen Regionen.

  • Custom Headers (Benutzerdefinierte Header): Geben Sie benutzerdefinierte Header an und verschlüsseln Sie diese bei Bedarf. Durch die Verschlüsselung werden die Werte der Header im Formular ausgeblendet. Verwenden Sie die Verschlüsselung für Header, die mit der Authentifizierung verbunden sind und für andere Mitglieder Ihres Teams nicht sichtbar sein sollen. Dieses Feld ist für TCP-Diagnosen nicht verfügbar.

  • Healthcheck Timeout (Systemdiagnosen-Zeitlimit): Geben Sie ein Zeitlimit von 1 bis 60 Sekunden an. Eine Verfügbarkeitsdiagnose schlägt fehl, wenn innerhalb des konfigurierten Zeitlimits die Systemdiagnosen von mehr als einem Standort keine Antwort erhalten. Wenn nur eine Systemdiagnose keine Antwort erhält, schlägt die Verfügbarkeitsdiagnose nicht fehl.

  • Authentication (Authentifizierung): Geben Sie einen Nutzernamen und ein Passwort an. Diese Werte werden als Autorisierungsheader gesendet. Wenn Sie hier Werte festlegen, geben Sie keinen Autorisierungsheader an. Wenn Sie hingegen einen Autorisierungsheader angeben, legen Sie hier keine Werte fest. Passwörter werden im Formular immer ausgeblendet. Dieses Feld ist für TCP-Diagnosen nicht verfügbar.

Kennungen für Verfügbarkeitsdiagnosen

Bei der Erstellung der Verfügbarkeitsdiagnose weist Stackdriver dieser eine Kennung zu, die als Verfügbarkeitsdiagnosen-ID bezeichnet wird. Diese Kennung ist in den Ressourcennamen für die neue Verfügbarkeitsdiagnose eingebettet:

projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]

Sie können die Verfügbarkeitsdiagnosen-ID der Antwort eines Methodenaufrufs entnehmen, um Verfügbarkeitsdiagnosen zu erstellen oder aufzulisten. Außerdem finden Sie die Verfügbarkeitsdiagnosen-ID in der Stackdriver Monitoring-Konsole auf der Seite der Verfügbarkeitsdiagnosen im Feld Check ID (Diagnose-ID) des Bereichs Check config (Diagnosekonfiguration).

Verfügbarkeitsdiagnose überprüfen

Wenn Sie eine Verfügbarkeitsdiagnose in der Stackdriver Monitoring Console erstellen, können Sie die Konfiguration vor dem Speichern testen.

Diagnose erfolgreich

Eine Verfügbarkeitsdiagnose ist erfolgreich, wenn zwei Bedingungen erfüllt sind:

  • Der HTTP-Status lautet Success.
  • Es gibt für die Antwort keinen erforderlichen Inhalt bzw. der erforderliche Inhalt ist in der Antwort auffindbar.

Diagnose fehlgeschlagen

Im Folgenden sind einige mögliche Fehlerursachen bei Verfügbarkeitsdiagnosen aufgeführt:

  • Connection Error – Refused (Verbindungsfehler – Abgelehnt): Achten Sie bei Verwendung des Standardverbindungstyps HTTP darauf, dass ein Webserver installiert ist, der auf HTTP-Anfragen reagiert. Dies kann bei einer neuen Instanz passieren, wenn Sie keinen Webserver installiert haben. Siehe dazu Schnellstart für Compute Engine. Bei Verwendung des Verbindungstyps HTTPS müssen Sie unter Umständen zusätzliche Konfigurationsschritte ausführen. Informationen zu Firewallproblemen finden Sie unter IP-Adressen anfordern.
  • Name or service not found (Name oder Dienst nicht gefunden): Der Hostname ist möglicherweise falsch.
  • 403 Forbidden (403 – Verboten): Der Dienst liefert während der Verfügbarkeitsdiagnose einen Fehlercode. Die Standardkonfiguration für den Apache-Webserver liefert diesen Code beispielsweise unter Amazon Linux. Unter bestimmten Linux-Versionen erhalten Sie hingegen den Code 200 (Erfolg). Weitere Informationen finden Sie in der LAMP-Anleitung für Amazon Linux oder in der Dokumentation Ihres Webservers.
  • 404 – Not found (Nicht gefunden): Möglicherweise ist der Pfad falsch.
  • 408 Request timeout (408 – Zeitüberschreitung bei Anfrage) oder keine Antwort: Möglicherweise ist die Portnummer falsch, der Dienst wird nicht ausgeführt oder ist nicht erreichbar oder das Zeitlimit ist zu niedrig. Achten Sie darauf, dass die Firewall Traffic von den für die Verfügbarkeitsdiagnose verwendeten Servern zulässt. Weitere Informationen erhalten Sie unter IP-Adressen abrufen. Das Zeitlimit ist unter Advanced Options (Erweiterte Optionen) im Abschnitt Healthcheck (Systemdiagnose) angegeben.

Benachrichtigungsrichtlinie erstellen

Wenn Sie über fehlgeschlagene Verfügbarkeitsdiagnosen informiert werden möchten, erstellen Sie eine Benachrichtigungsrichtlinie für die neue Verfügbarkeitsdiagnose. Weitere Informationen dazu finden Sie unter Benachrichtigungen für Verfügbarkeitsdiagnosen.

Verfügbarkeitsdiagnosen auflisten

Zum Auflisten Ihrer aktuellen Verfügbarkeitsdiagnosen gehen Sie so vor:

Konsole

  1. Gehen Sie in der Stackdriver Monitoring-Konsole zu Uptime Checks > Uptime Checks Overview (Verfügbarkeitsdiagnosen > Verfügbarkeitsdiagnose-Übersicht): Die Verfügbarkeitsdiagnosen werden möglicherweise auf mehreren Seiten aufgeführt.

    Verfügbarkeitsdiagnose-Übersicht öffnen

  2. Führen Sie einen der folgenden Schritte aus, um die Liste der Diagnosen zu filtern:

    • Geben Sie im Feld Filter Suchbegriffe ein, um die Liste auf Diagnosen zu beschränken, die diese im Titel enthalten.
    • Verwenden Sie die Schaltfläche links neben dem Feld Filter, um nach Mitgliedern einer bestimmten Gruppe zu filtern.

    Klicken Sie auf eine Verfügbarkeitsdiagnose, um weitere Informationen zu erhalten.

API

Rufen Sie die Methode projects.uptimeCheckConfigs.list auf, um eine Liste der Konfigurationen Ihrer Verfügbarkeitsdiagnosen zu erhalten. Geben Sie folgenden Parameter an:

  • parent: Das Projekt, dessen Verfügbarkeitsdiagnosen Sie auflisten möchten. Das Format dafür ist:

    projects/[PROJECT_ID]
    

Wenn Sie eine bestimmte Verfügbarkeitsdiagnose erhalten möchten, rufen Sie die Methode projects.uptimeCheckConfigs.get auf. Geben Sie folgenden Parameter an:

  • name: Der vollständige Name der Verfügbarkeitsdiagnosekonfiguration.

    projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]
    

    Sie können den Wert für [UPTIME_CHECK_ID] aus der Antwort einer create- oder list-Methode ermitteln. Die ID wird nicht in der Stackdriver Monitoring-Konsole angezeigt.

C#

public static object ListUptimeCheckConfigs(string projectId)
{
    var client = UptimeCheckServiceClient.Create();
    var configs = client.ListUptimeCheckConfigs(
        new ProjectName(projectId).ToString());
    foreach (UptimeCheckConfig config in configs)
    {
        Console.WriteLine(config.Name);
    }
    return 0;
}

Java

private static void listUptimeChecks(String projectId) throws IOException {
  ListUptimeCheckConfigsRequest request = ListUptimeCheckConfigsRequest
      .newBuilder()
      .setParent(ProjectName.format(projectId))
      .build();
  try (UptimeCheckServiceClient client = UptimeCheckServiceClient.create()) {
    ListUptimeCheckConfigsPagedResponse response = client.listUptimeCheckConfigs(request);
    for (UptimeCheckConfig config : response.iterateAll()) {
      System.out.println(config.getDisplayName());
    }
  } catch (Exception e) {
    usage("Exception listing uptime checks: " + e.toString());
    throw e;
  }
}

Go

// list is an example of listing the uptime checks in projectID.
func list(w io.Writer, projectID string) error {
	ctx := context.Background()
	client, err := monitoring.NewUptimeCheckClient(ctx)
	if err != nil {
		return fmt.Errorf("NewUptimeCheckClient: %v", err)
	}
	defer client.Close()
	req := &monitoringpb.ListUptimeCheckConfigsRequest{
		Parent: "projects/" + projectID,
	}
	it := client.ListUptimeCheckConfigs(ctx, req)
	for {
		config, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("ListUptimeCheckConfigs: %v", err)
		}
		fmt.Fprintln(w, config)
	}
	fmt.Fprintln(w, "Done listing uptime checks")
	return nil
}

Node.js

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

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

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

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

// Retrieves an uptime check config
const [uptimeCheckConfigs] = await client.listUptimeCheckConfigs(request);

uptimeCheckConfigs.forEach(uptimeCheckConfig => {
  console.log(`ID: ${uptimeCheckConfig.name}`);
  console.log(`  Display Name: ${uptimeCheckConfig.displayName}`);
  console.log(`  Resource: %j`, uptimeCheckConfig.monitoredResource);
  console.log(`  Period: %j`, uptimeCheckConfig.period);
  console.log(`  Timeout: %j`, uptimeCheckConfig.timeout);
  console.log(`  Check type: ${uptimeCheckConfig.check_request_type}`);
  console.log(
    `  Check: %j`,
    uptimeCheckConfig.httpCheck || uptimeCheckConfig.tcpCheck
  );
  console.log(
    `  Content matchers: ${uptimeCheckConfig.contentMatchers
      .map(matcher => matcher.content)
      .join(', ')}`
  );
  console.log(`  Regions: ${uptimeCheckConfig.selectedRegions.join(', ')}`);
});

PHP

use Google\Cloud\Monitoring\V3\UptimeCheckServiceClient;

/**
 * Example:
 * ```
 * list_uptime_checks($projectId);
 * ```
 */
function list_uptime_checks($projectId)
{
    $uptimeCheckClient = new UptimeCheckServiceClient([
        'projectId' => $projectId,
    ]);

    $pages = $uptimeCheckClient->listUptimeCheckConfigs(
        $uptimeCheckClient->projectName($projectId)
    );

    foreach ($pages->iteratePages() as $page) {
        foreach ($page as $uptimeCheck) {
            print($uptimeCheck->getName() . PHP_EOL);
        }
    }
}

Python

def list_uptime_check_configs(project_name):
    client = monitoring_v3.UptimeCheckServiceClient()
    configs = client.list_uptime_check_configs(project_name)

    for config in configs:
        pprint.pprint(config)

Ruby

def list_uptime_check_configs project_id
  require "google/cloud/monitoring/v3"

  client = Google::Cloud::Monitoring::V3::UptimeCheck.new
  project_name = Google::Cloud::Monitoring::V3::UptimeCheckServiceClient.project_path project_id
  configs = client.list_uptime_check_configs project_name

  configs.each { |config| puts config.name }
end

Sie können auch eine einzelne Verfügbarkeitsdiagnose abrufen:

C#

public static object GetUptimeCheckConfig(string configName)
{
    var client = UptimeCheckServiceClient.Create();
    UptimeCheckConfig config = client.GetUptimeCheckConfig(configName);
    if (config == null)
    {
        Console.Error.WriteLine(
            "No configuration found with the name {0}", configName);
        return -1;
    }
    Console.WriteLine("Name: {0}", config.Name);
    Console.WriteLine("Display Name: {0}", config.DisplayName);
    Console.WriteLine("Http Path: {0}", config.HttpCheck.Path);
    return 0;
}

Java

private static void getUptimeCheckConfig(String projectId, String checkName) throws IOException {
  try (UptimeCheckServiceClient client = UptimeCheckServiceClient.create()) {
    String fullCheckName = UptimeCheckConfigName.format(projectId, checkName);
    UptimeCheckConfig config = client.getUptimeCheckConfig(fullCheckName);
    if (config != null) {
      System.out.println(config.toString());
    } else {
      System.out.println(
          "No uptime check config found with name " + checkName + " in project " + projectId);
    }
  } catch (Exception e) {
    usage("Exception getting uptime check: " + e.toString());
    throw e;
  }
}

Go

// get is an example of getting an uptime check. resourceName should be
// of the form `projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]`.
func get(w io.Writer, resourceName string) (*monitoringpb.UptimeCheckConfig, error) {
	ctx := context.Background()
	client, err := monitoring.NewUptimeCheckClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("NewUptimeCheckClient: %v", err)
	}
	defer client.Close()
	req := &monitoringpb.GetUptimeCheckConfigRequest{
		Name: resourceName,
	}
	config, err := client.GetUptimeCheckConfig(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("GetUptimeCheckConfig: %v", err)
	}
	fmt.Fprintf(w, "Config: %v", config)
	return config, nil
}

Node.js

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

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

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

const request = {
  // i.e. name: 'projects/my-project-id/uptimeCheckConfigs/My-Uptime-Check
  name: client.uptimeCheckConfigPath(projectId, uptimeCheckConfigId),
};

console.log(`Retrieving ${request.name}`);

// Retrieves an uptime check config
const [uptimeCheckConfig] = await client.getUptimeCheckConfig(request);
console.log(`ID: ${uptimeCheckConfig.name}`);
console.log(`Display Name: ${uptimeCheckConfig.displayName}`);
console.log(`Resource: %j`, uptimeCheckConfig.monitoredResource);
console.log(`Period: %j`, uptimeCheckConfig.period);
console.log(`Timeout: %j`, uptimeCheckConfig.timeout);
console.log(`Check type: ${uptimeCheckConfig.check_request_type}`);
console.log(
  `Check: %j`,
  uptimeCheckConfig.httpCheck || uptimeCheckConfig.tcpCheck
);
console.log(
  `Content matchers: ${uptimeCheckConfig.contentMatchers
    .map(matcher => matcher.content)
    .join(', ')}`
);
console.log(`Regions: ${uptimeCheckConfig.selectedRegions.join(', ')}`);

PHP

use Google\Cloud\Monitoring\V3\UptimeCheckServiceClient;

/**
 * Example:
 * ```
 * get_uptime_check($projectId, $configName);
 * ```
 *
 * @param string $projectId Your project ID
 * @param string $configName
 */
function get_uptime_check($projectId, $configName)
{
    $uptimeCheckClient = new UptimeCheckServiceClient([
        'projectId' => $projectId,
    ]);

    $uptimeCheck = $uptimeCheckClient->getUptimeCheckConfig($configName);

    print('Retrieved an uptime check:' . PHP_EOL);
    print($uptimeCheck->serializeToJsonString() . PHP_EOL);
}

Python

def get_uptime_check_config(config_name):
    client = monitoring_v3.UptimeCheckServiceClient()
    config = client.get_uptime_check_config(config_name)
    pprint.pprint(config)

Ruby

def get_uptime_check_config config_name
  require "google/cloud/monitoring/v3"

  client = Google::Cloud::Monitoring::V3::UptimeCheck.new
  config = client.get_uptime_check_config config_name
  pp config.to_hash
  config
end

Verfügbarkeitsdiagnosen bearbeiten

Gehen Sie zum Bearbeiten einer Verfügbarkeitsdiagnose so vor:

Konsole

  1. Klicken Sie in der Stackdriver Monitoring-Konsole auf Uptime Checks > Uptime Checks Overview (Verfügbarkeitsdiagnosen > Verfügbarkeitsdiagnose-Übersicht): Die Verfügbarkeitsdiagnosen werden möglicherweise auf mehreren Seiten aufgeführt.

    Verfügbarkeitsdiagnose-Übersicht öffnen

  2. Klicken Sie unter Uptime Checks Overview (Verfügbarkeitsdiagnose-Übersicht) im Menü rechts neben der Zusammenfassung Ihrer Verfügbarkeitsdiagnose auf Edit (Bearbeiten).

  3. Ändern Sie die Werte der Felder nach Bedarf. Sie können nicht alle Felder ändern. Wenn die benutzerdefinierten Headerwerte einer Diagnose ausgeblendet sind, können sie nicht sichtbar gemacht werden.

  4. Klicken Sie auf Test (Testen), um zu überprüfen, ob die Diagnose erfolgreich war. Wenn der Test fehlschlägt, können Sie dem Abschnitt Diagnosefehler mögliche Ursachen entnehmen.

  5. Klicken Sie auf Save (Speichern).

API

Rufen Sie die Methode projects.uptimeCheckConfigs.patch auf. Legen Sie die Parameter der Methode so fest:

  • uptimeCheckConfig.name: Erforderlich. Dies ist Teil der REST-URL. Es ist der Ressourcenname der zu bearbeitenden Verfügbarkeitsdiagnose:

    projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]
    

    Sie können den Wert für [UPTIME_CHECK_ID] aus der Antwort einer create- oder list-Methode ermitteln. Die ID wird nicht in der Stackdriver Monitoring-Konsole angezeigt.

  • updateMask: Optional. Dies ist ein Abfrageparameter: ?updateMask=[FIELD_LIST]. [FIELD_LIST] ist eine durch Kommas getrennte Liste von Feldern im Objekt UptimeCheckConfig, die geändert werden sollte. Beispiel:

    "resource.type,httpCheck.path"
    
  • Der Anfragetext muss das Objekt UptimeCheckConfig mit den neuen Feldwerten enthalten.

Wenn updateMask festgelegt ist, ersetzen nur die in updateMask aufgelisteten Felder die entsprechenden Felder in der vorhandenen Konfiguration. Wenn ein Feld untergeordnete Felder hat und das Feld in der Feldmaske aufgeführt ist, aber keines seiner Unterfelder, dann ersetzen alle Unterfelder dieses Feldes die entsprechenden Felder.

Wenn updateMask nicht festgelegt ist, ersetzt die Konfiguration im Anfragetext die gesamte vorhandene Konfiguration.

Die Methode patch liefert das Objekt UptimeCheckConfig für die geänderte Konfiguration.

C#

public static object UpdateUptimeCheck(string configName,
    string newHttpPath, string newDisplayName)
{
    var client = UptimeCheckServiceClient.Create();
    var config = client.GetUptimeCheckConfig(configName);
    var fieldMask = new FieldMask();
    if (newDisplayName != null)
    {
        config.DisplayName = newDisplayName;
        fieldMask.Paths.Add("display_name");
    }
    if (newHttpPath != null)
    {
        config.HttpCheck.Path = newHttpPath;
        fieldMask.Paths.Add("http_check.path");
    }
    client.UpdateUptimeCheckConfig(config);
    return 0;
}

Java

private static void updateUptimeCheck(
    String projectId, String displayName, String hostName, String pathName) throws IOException {
  String fullCheckName = UptimeCheckConfigName.format(projectId, displayName);

  UpdateUptimeCheckConfigRequest request = UpdateUptimeCheckConfigRequest
      .newBuilder()
      .setUpdateMask(FieldMask
          .newBuilder()
          .addPaths("http_check.path"))
      .setUptimeCheckConfig(UptimeCheckConfig
          .newBuilder()
          .setName(fullCheckName)
          .setMonitoredResource(MonitoredResource
              .newBuilder()
              .setType("uptime_url")
              .putLabels("host", hostName))
          .setHttpCheck(HttpCheck
              .newBuilder()
              .setPath(pathName)
              .setPort(80))
          .setTimeout(Duration.newBuilder().setSeconds(10))
          .setPeriod(Duration.newBuilder().setSeconds(300)))
      .build();
  try (UptimeCheckServiceClient client = UptimeCheckServiceClient.create()) {
    UptimeCheckConfig config = client.updateUptimeCheckConfig(request);
    System.out.println("Uptime check updated: \n" + config.toString());
  } catch (Exception e) {
    usage("Exception updating uptime check: " + e.toString());
    throw e;
  }
}

Go

// update is an example of updating an uptime check. resourceName should be
// of the form `projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]`.
func update(w io.Writer, resourceName, displayName, httpCheckPath string) (*monitoringpb.UptimeCheckConfig, error) {
	ctx := context.Background()
	client, err := monitoring.NewUptimeCheckClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("NewUptimeCheckClient: %v", err)
	}
	defer client.Close()
	getReq := &monitoringpb.GetUptimeCheckConfigRequest{
		Name: resourceName,
	}
	config, err := client.GetUptimeCheckConfig(ctx, getReq)
	if err != nil {
		return nil, fmt.Errorf("GetUptimeCheckConfig: %v", err)
	}
	config.DisplayName = displayName
	config.GetHttpCheck().Path = httpCheckPath
	req := &monitoringpb.UpdateUptimeCheckConfigRequest{
		UpdateMask: &field_mask.FieldMask{
			Paths: []string{"display_name", "http_check.path"},
		},
		UptimeCheckConfig: config,
	}
	config, err = client.UpdateUptimeCheckConfig(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("UpdateUptimeCheckConfig: %v", err)
	}
	fmt.Fprintf(w, "Successfully updated %v", resourceName)
	return config, nil
}

Node.js

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

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

/**
 * TODO(developer): Uncomment and edit the following lines of code.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const uptimeCheckConfigId = 'YOUR_UPTIME_CHECK_CONFIG_ID';
// const displayName = 'A New Display Name';
// const path = '/some/path';

const request = {
  // i.e. name: 'projects/my-project-id/uptimeCheckConfigs/My-Uptime-Check
  name: client.uptimeCheckConfigPath(projectId, uptimeCheckConfigId),
};

console.log(`Updating ${request.name} to ${displayName}`);

// Updates the display name and path on an uptime check config
request.uptimeCheckConfig = {
  name: request.name,
  displayName: displayName,
  httpCheck: {path: path},
};

request.updateMask = {paths: ['display_name', 'http_check.path']};

const [response] = await client.updateUptimeCheckConfig(request);
console.log(`${response.name} config updated.`);

PHP

use Google\Cloud\Monitoring\V3\UptimeCheckServiceClient;
use Google\Protobuf\FieldMask;

/**
 * Example:
 * ```
 * update_uptime_checks($projectId);
 * ```
 */
function update_uptime_checks($projectId, $configName, $newDisplayName = null, $newHttpCheckPath = null)
{
    $uptimeCheckClient = new UptimeCheckServiceClient([
        'projectId' => $projectId,
    ]);

    $uptimeCheck = $uptimeCheckClient->getUptimeCheckConfig($displayName);
    $fieldMask = new FieldMask();
    if ($newDisplayName) {
        $fieldMask->getPaths()[] = 'display_name';
        $uptimeCheck->setDisplayName($newDisplayName);
    }
    if ($newHttpCheckPath) {
        $fieldMask->getPaths()[] = 'http_check.path';
        $uptimeCheck->getHttpCheck()->setPath($newHttpCheckPath);
    }

    $uptimeCheckClient->updateUptimeCheckConfig($uptimeCheck, $fieldMask);

    print($uptimeCheck->serializeToString() . PHP_EOL);
}

Python

def update_uptime_check_config(config_name, new_display_name=None,
                               new_http_check_path=None):
    client = monitoring_v3.UptimeCheckServiceClient()
    config = client.get_uptime_check_config(config_name)
    field_mask = monitoring_v3.types.FieldMask()
    if new_display_name:
        field_mask.paths.append('display_name')
        config.display_name = new_display_name
    if new_http_check_path:
        field_mask.paths.append('http_check.path')
        config.http_check.path = new_http_check_path
    client.update_uptime_check_config(config, field_mask)

Ruby

def update_uptime_check_config config_name: nil, new_display_name: nil, new_http_check_path: nil
  require "google/cloud/monitoring/v3"

  client = Google::Cloud::Monitoring::V3::UptimeCheck.new
  config = { name: config_name }
  field_mask = { paths: [] }
  unless new_display_name.to_s.empty?
    field_mask[:paths].push "display_name"
    config[:display_name] = new_display_name
  end
  unless new_http_check_path.to_s.empty?
    field_mask[:paths].push "http_check.path"
    config[:http_check] = { path: new_http_check_path }
  end
  client.update_uptime_check_config config, update_mask: field_mask
end

Es kann bis zu 25 Minuten dauern, bis die Ergebnisse der neuen Verfügbarkeitsdiagnose angezeigt werden. Bis dahin werden die Ergebnisse der vorherigen Verfügbarkeitsdiagnose in den Dashboards angezeigt und in Benachrichtigungsrichtlinien verwendet.

Verfügbarkeitsdiagnosen löschen

Bevor Sie eine Verfügbarkeitsdiagnose löschen, entfernen Sie diese aus allen Benachrichtigungsrichtlinien, in denen die Diagnose verwendet wird. Wenn Sie die Verfügbarkeitsdiagnose nicht entfernen, können Sie sie nicht über die Monitoring-Konsole löschen. Wenn Sie die Verfügbarkeitsdiagnose über die API löschen, ignoriert die Benachrichtigungsrichtlinie die fehlende Verfügbarkeitsdiagnose. Die Richtlinie erstellt keinen Vorfall für die fehlende Diagnose.

Gehen Sie zum Löschen einer Verfügbarkeitsdiagnose so vor:

Konsole

  1. Klicken Sie in der Stackdriver Monitoring-Konsole auf Uptime Checks > Uptime Checks Overview (Verfügbarkeitsdiagnosen > Verfügbarkeitsdiagnose-Übersicht):

    Verfügbarkeitsdiagnose-Übersicht öffnen

  2. Klicken Sie unter Uptime Checks Overview (Verfügbarkeitsdiagnose-Übersicht) im Menü rechts neben der Zusammenfassung Ihrer Verfügbarkeitsdiagnose auf Edit (Bearbeiten).

API

Rufen Sie die Methode projects.uptimeCheckConfigs.delete auf. Legen Sie den Parameter so fest:

  • name: Erforderlich. Dies ist der Ressourcenname der zu löschenden Verfügbarkeitsdiagnose.

    projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]
    

    Sie können den Wert für [UPTIME_CHECK_ID] aus der Antwort einer create- oder list-Methode ermitteln. Die ID wird nicht in der Stackdriver Monitoring-Konsole angezeigt.

C#

public static object DeleteUptimeCheckConfig(string configName)
{
    var client = UptimeCheckServiceClient.Create();
    client.DeleteUptimeCheckConfig(configName);
    Console.WriteLine($"Deleted {configName}");
    return 0;
}

Java

private static void deleteUptimeCheckConfig(String projectId, String checkName)
    throws IOException {
  try (UptimeCheckServiceClient client = UptimeCheckServiceClient.create()) {
    client.deleteUptimeCheckConfig(UptimeCheckConfigName.format(projectId, checkName));
  } catch (Exception e) {
    usage("Exception deleting uptime check: " + e.toString());
    throw e;
  }
}

Go

// delete is an example of deleting an uptime check. resourceName should be
// of the form `projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]`.
func delete(w io.Writer, resourceName string) error {
	ctx := context.Background()
	client, err := monitoring.NewUptimeCheckClient(ctx)
	if err != nil {
		return fmt.Errorf("NewUptimeCheckClient: %v", err)
	}
	defer client.Close()
	req := &monitoringpb.DeleteUptimeCheckConfigRequest{
		Name: resourceName,
	}
	if err := client.DeleteUptimeCheckConfig(ctx, req); err != nil {
		return fmt.Errorf("DeleteUptimeCheckConfig: %v", err)
	}
	fmt.Fprintf(w, "Successfully deleted %q", resourceName)
	return nil
}

Node.js

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

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

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

const request = {
  // i.e. name: 'projects/my-project-id/uptimeCheckConfigs/My-Uptime-Check
  name: client.uptimeCheckConfigPath(projectId, uptimeCheckConfigId),
};

console.log(`Deleting ${request.name}`);

// Delete an uptime check config
await client.deleteUptimeCheckConfig(request);
console.log(`${request.name} deleted.`);

PHP

use Google\Cloud\Monitoring\V3\UptimeCheckServiceClient;

/**
 * Example:
 * ```
 * delete_uptime_check($projectId, $configName);
 * ```
 *
 * @param string $projectId Your project ID
 * @param string $configName
 */
function delete_uptime_check($projectId, $configName)
{
    $uptimeCheckClient = new UptimeCheckServiceClient([
        'projectId' => $projectId,
    ]);

    $uptimeCheckClient->deleteUptimeCheckConfig($configName);

    printf('Deleted an uptime check: ' . $configName . PHP_EOL);
}

Python

def delete_uptime_check_config(config_name):
    client = monitoring_v3.UptimeCheckServiceClient()
    client.delete_uptime_check_config(config_name)
    print('Deleted ', config_name)

Ruby

def delete_uptime_check_config config_name
  require "google/cloud/monitoring/v3"

  client = Google::Cloud::Monitoring::V3::UptimeCheck.new
  client.delete_uptime_check_config config_name
  puts "Deleted #{config_name}"
end

Hat Ihnen diese Seite weitergeholfen? Teilen Sie uns Ihr Feedback mit:

Feedback geben zu...

Stackdriver Monitoring