Verfügbarkeitsdiagnosen verwalten

Eine Verfügbarkeitsdiagnose ist eine Anfrage, die an eine Ressource gesendet wird, um zu sehen, ob sie antwortet. Mit Verfügbarkeitsdiagnosen können Sie die Verfügbarkeit einer VM-Instanz, eines App Engine-Dienstes, einer URL oder eines AWS-Load-Balancers ermitteln.

Sie können die Verfügbarkeit einer Ressource überwachen, indem Sie eine Benachrichtigungsrichtlinie erstellen, die einen Vorfall erstellt, wenn die Verfügbarkeitsdiagnose fehlschlägt. Die Benachrichtigungsrichtlinie kann so konfiguriert werden, dass Sie per E-Mail oder über einen anderen Kanal benachrichtigt werden. Diese Benachrichtigung kann Details zur Ressource enthalten, die nicht reagiert hat. Sie haben auch die Möglichkeit, die Ergebnisse von Verfügbarkeitsdiagnosen in den Monitoring-Dashboards zur Verfügbarkeitsdiagnose zu beobachten.

Diese Seite enthält Anleitungen für Folgendes:

  • Neue Verfügbarkeitsdiagnose erstellen
  • Dashboard für eine Verfügbarkeitsdiagnose ansehen
  • Verfügbarkeitsdiagnose bearbeiten
  • Verfügbarkeitsdiagnose löschen

Im Abschnitt Nächste Schritte finden Sie Links zu Preisseiten und zu Seiten, auf denen Sie die Verfügbarkeitsdiagnosen überwachen.

Hinweis

  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 geprüfte Ressource keine externe IP-Adresse hat, kann sie von Verfügbarkeitsdiagnosen nicht erreicht werden.
  2. Die Verfügbarkeitsdiagnose lädt keine Seitenassets und führt kein JavaScript aus. Die Standardkonfiguration einer Verfügbarkeitsdiagnose umfasst keine Authentifizierung.

    Bei HTTP und HTTPS ruft die Prüfung die Daten von dieser URL ab, wenn die Antwort eine Weiterleitung zu einer anderen URL ist. Zuletzt prüft die Verfügbarkeitsdiagnose die Daten, um festzustellen, ob die Diagnose erfolgreich war oder fehlgeschlagen ist.

    Für den Erfolg müssen die folgenden Bedingungen erfüllt sein:

    • Der HTTP-Status ist Success.
    • Es gibt für die Daten keinen erforderlichen Inhalt bzw. der erforderliche Inhalt ist vorhanden.

Verfügbarkeitsprüfung erstellen

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

Console

So erstellen Sie eine Verfügbarkeitsdiagnose mithilfe der Google Cloud Console:

  1. Wählen Sie in der Cloud Console Monitoring aus:

    Zu Monitoring

  2. Klicken Sie auf Verfügbarkeitsdiagnosen.

  3. Klicken Sie auf Verfügbarkeitsdiagnose erstellen.

    Dialogfeld zum Erstellen einer Verfügbarkeitsdiagnose

  4. Geben Sie einen beschreibenden Titel für die Verfügbarkeitsdiagnose ein und klicken Sie auf Weiter.

  5. Geben Sie das Ziel der Verfügbarkeitsdiagnose an:

    1. Wählen Sie das Protokoll aus. Sie haben die Optionen HTTP, HTTPS und TCP.

    2. Wählen Sie einen der folgenden Ressourcentypen aus:

      • URL: Eine IPv4-Adresse oder ein Hostname. Pfad und Port werden separat eingegeben.
      • App Engine: Google App Engine-Anwendungen (Module)
      • Instanz: Compute Engine- oder AWS EC2-Instanzen
      • Elastic Load Balancer (Elastic-Load-Balancer): AWS-Load-Balancer
    3. Füllen Sie die protokollspezifischen Felder aus:

      • Geben Sie für TCP-Prüfungen den Port ein.

      • Bei HTTP- und HTTPS-Prüfungen können Sie einen Pfad innerhalb Ihres Hosts oder Ihrer Ressource eingeben. Alle Verfügbarkeitsdiagnosen, die diese Protokolle verwenden, senden eine Anfrage an http://target/path. In diesem Ausdruck ist target für eine URL-Ressource ein Hostname oder eine IP-Adresse. Bei einer App Engine-Ressource ist target ein Hostname, der vom Dienstnamen abgeleitet wird. Für Instanz- und Load-Balancer-Ressourcen ist target eine IP-Adresse, die von dem Namen abgeleitet wird, den Sie für die Ressource oder die Gruppe von Ressourcen angegeben haben.

        Wenn Sie das Feld path leer lassen oder den Wert auf / setzen, wird die Anfrage an http://target/ gesendet.

        Um eine Verfügbarkeitsdiagnose für die URL-Ressource example.com/tester durchzuführen, setzen Sie das Feld für den Hostnamen auf example.com und das Feld für den Pfad auf /tester.

        Angenommen, Sie haben einen Server in App Engine mit einem Disponenten bereitgestellt, der / und /hello unterstützt. Wenn Sie das Pfadfeld leer lassen, wird die Verfügbarkeitsdiagnose an den Handler / gesendet. Um die Verfügbarkeitsdiagnose für den /hello-Handler auszuführen, setzen Sie den Wert des Pfadfelds auf /hello.

    4. Geben Sie die ressourcenspezifischen Felder ein:

      • Geben Sie für URL-Ressourcen den Hostnamen in das Feld Hostname ein. Geben Sie beispielsweise example.com ein.

      • Geben Sie für App Engine-Ressourcen den Dienstnamen in das Feld Dienst ein.

      • Füllen Sie für Elastic Load Balancer- und Instance-Ressourcen die folgenden Felder aus:

        • Um eine Verfügbarkeitsdiagnose für eine einzelne Instanz oder einen einzelnen Load-Balancer durchzuführen, wählen Sie im Feld Gilt für die Option Single aus und wählen Sie dann über das Menü die gewünschte Instanz oder den Load-Balancer aus.
        • Um eine Verfügbarkeitsdiagnose für eine Monitoring-Gruppe durchzuführen, wählen Sie im Feld Gilt für die Option Gruppe aus und wählen Sie dann im Menü den Gruppennamen aus.
    5. Das Feld Checkhäufigkeit steuert, wie oft die Verfügbarkeitsdiagnose ausgeführt wird. Sie können den Standardwert beibehalten oder einen Wert aus dem Optionsmenü auswählen.

    6. Klicken Sie auf Weitere Zieloptionen, um Prüfregionen oder SSL-Zertifikate, Authentifizierung, Header und Ports für HTTP- und HTTPS-Prüfungen zu konfigurieren:

      • Regionen: Wählen Sie die Regionen aus, in denen die Verfügbarkeitsdiagnosen Anfragen erhalten sollen. Eine Verfügbarkeitsdiagnose muss mindestens drei Prüfer enthalten. Es gibt in allen Regionen eine Prüfung, mit Ausnahme von USA, wo es drei Prüfungen gibt. Die Standardeinstellung Global umfasst alle Regionen.
      • Allgemein: Füllen Sie dieses Feld aus, um virtuelle Hosts zu prüfen. Dieses Feld ist für TCP-Diagnosen nicht verfügbar.
      • Port: Geben Sie eine Portnummer an.
      • Benutzerdefinierte Header: Geben Sie benutzerdefinierte Header an und verschlüsseln Sie sie bei Bedarf. Durch die Verschlüsselung werden die Werte der Header im Formular ausgeblendet. Verwenden Sie die Verschlüsselung für Header im Zusammenhang mit der Authentifizierung, die für andere nicht sichtbar sein sollen.

      • 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.

      • SSL-Zertifikatsprüfung: Wenn Sie HTTPS für eine URL-Ressource ausgewählt haben, versucht der Dienst standardmäßig, eine Verbindung über HTTPS herzustellen, und validiert das SSL-Zertifikat. Die Verfügbarkeitsdiagnose schlägt fehl, wenn eine URL ein ungültiges Zertifikat enthält. Mögliche Gründe für ein ungültiges Zertifikat sind ein abgelaufenes Zertifikat, ein selbstsigniertes Zertifikat, ein Zertifikat mit einem Domain-Namen und ein Zertifikat mit der AIA-Erweiterung.

        Wenn Sie eine HTTPS-Verfügbarkeitsdiagnose zur Validierung des SSL-Zertifikats erzwingen möchten, muss SSL-Zertifikate überprüfen ausgewählt sein.

        Wenn Sie die SSL-Zertifikatsprüfung deaktivieren möchten, stellen Sie sicher, dass die Option SSL-Zertifikate überprüfen leer ist.

        Wenn Sie SSL-Zertifikate mit AIA-Erweiterungen (Authority Information Access) haben, müssen Sie die SSL-Zertifikatsprüfung deaktivieren. Diese Zertifikatstypen werden nicht unterstützt und schlagen die Validierungssequenz fehl. In der Regel lautet die Fehlermeldung "Antwort mit SSL-Handshake-Fehler in 10.000 ms".

        Sie können den Messwert monitoring.googleapis.com/uptime_check/time_until_ssl_cert_expires verwenden, um eine Benachrichtigung zu erstellen, die Sie benachrichtigt, bevor Ihr Zertifikat abläuft. Weitere Informationen finden Sie unter Beispielrichtlinien: Richtlinie zur Verfügbarkeitsdiagnose.

        Klicken Sie das Kästchen SSL-Zertifikate überprüfen an.

    7. Klicken Sie auf Weiter.

  6. Konfigurieren Sie die Antwortanforderungen:

    • Wählen Sie im Optionsmenü die Option Antwortzeitüberschreitung aus. Sie können einen Wert zwischen 1 und 60 Sekunden auswählen. Eine Verfügbarkeitsdiagnose schlägt fehl, wenn innerhalb dieses Zeitlimits keine Antwort von mehr als einem Standort empfangen wird.

    • Für den Content-Abgleich muss das Umschaltlabel Content-Abgleich ist aktiviert lauten:

      • Wählen Sie im Optionsmenü die Option Übereinstimmungstyp für Antwortinhalt aus. Dieses Feld bestimmt, wie der Antwortinhalt mit den zurückgegebenen Daten verglichen wird. Wenn der Antwortinhalt beispielsweise abcd und der Inhaltstyp Enthält ist, ist die Verfügbarkeitsdiagnose erfolgreich, wenn die Antwortdaten abcd enthalten. Die Verfügbarkeitsdiagnose schlägt fehl, wenn in der Antwort abcd nicht enthalten ist.
      • Geben Sie den Antwortinhalt ein. Dies muss ein String sein, der nicht länger als 1024 Byte ist. In der API ist dies das Objekt ContentMatcher.
    • Wenn Sie keine Verfügbarkeitsdiagnosen an Cloud Logging senden möchten, deaktivieren Sie Fehler bei der Logprüfung.

    • Klicken Sie auf Weiter.

  7. Benachrichtigungsrichtlinie erstellen Wenn die Verfügbarkeitsdiagnose durch eine Benachrichtigungsrichtlinie überwacht wird, wird ein Vorfall erstellt und eine Benachrichtigung an alle Benachrichtigungskanäle gesendet, die mit der Richtlinie verknüpft sind. Wenn Sie der Richtlinie beispielsweise eine E-Mail-Adresse hinzufügen, wird an diese Adresse eine E-Mail gesendet. Sie können in diesem Schritt die Benachrichtigungsrichtlinie oder nach dem Erstellen der Diagnose eine Benachrichtigungsrichtlinie erstellen.

    Wenn Sie im Rahmen dieses Ablaufs keine Benachrichtigungsrichtlinie erstellen möchten, muss der Schalter neben der Schaltfläche Keine Benachrichtigung erstellen lauten. Klicken Sie auf die Schaltfläche, um den Status zu ändern.

    So erstellen Sie eine Benachrichtigungsrichtlinie im Rahmen dieses Ablaufs:

    1. Der Schalter zum Umschalten lautet Alert erstellen. Klicken Sie gegebenenfalls auf die Schaltfläche.

    2. Geben Sie im Namensfeld einen Namen für die Benachrichtigungsrichtlinie ein oder verwenden Sie den Standardnamen.

    3. Um der Benachrichtigungsrichtlinie einen oder mehrere Benachrichtigungskanäle hinzuzufügen, klicken Sie im Textfeld Benachrichtigungskanäle auf Menü . Wählen Sie die hinzuzufügenden Channels aus und klicken Sie auf OK. Die Benachrichtigungskanäle sind für jeden Kanaltyp alphabetisch gruppiert.

      Wenn ein Benachrichtigungskanal, den Sie der Benachrichtigungsrichtlinie hinzufügen möchten, nicht aufgeführt ist, klicken Sie auf Benachrichtigungskanäle verwalten.

      Benachrichtigungsdialogfeld mit den Schaltflächen zum Aktualisieren und Verwalten von Kanälen.

      Sie werden in einem neuen Browsertab zum Fenster Benachrichtigungskanäle weitergeleitet. Fügen Sie die Benachrichtigungskanäle hinzu, kehren Sie dann zu diesem Tab zurück, klicken Sie auf Aktualisieren und wählen Sie die Benachrichtigungskanäle aus, die der Benachrichtigungsrichtlinie hinzugefügt werden sollen.

    4. Wählen Sie im Feld für die Dauer aus, wie lange die Verfügbarkeitsdiagnosen fehlschlagen müssen, bevor ein Vorfall erstellt wird. Standardmäßig ist die Benachrichtigungsrichtlinie so konfiguriert, dass ein Vorfall erstellt wird, wenn in mindestens zwei Regionen 1 Minute lang Fehler bei der Verfügbarkeitsdiagnose gemeldet werden.

    Informationen zum Deaktivieren, Bearbeiten und Löschen von Benachrichtigungsrichtlinien finden Sie unter Richtlinien verwalten.

  8. Klicken Sie auf Test (Testen), um die Konfiguration der Verfügbarkeitsdiagnose zu prüfen. Wenn das Ergebnis nicht Ihren Erwartungen entspricht, lesen Sie im Abschnitt Diagnose fehlgeschlagen unten nach, korrigieren Sie Ihre Konfiguration und wiederholen Sie den Bestätigungsschritt.

  9. Klicken Sie auf Erstellen. Wenn erforderliche Daten fehlen, schlägt das Speichern fehl und neben den Schaltflächen des Dialogs wird eine Liste der Felder angezeigt, für die Daten erforderlich sind. Nach dem Speichern der Änderungen wird das Dialogfeld Uptime check created (Verfügbarkeitsdiagnose erstellt) angezeigt.

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 Google Cloud-Projekt-ID. Das Format dafür ist:

    projects/PROJECT_ID
    
  • Der Anfragetext muss ein UptimeCheckConfig-Objekt für die neue Verfügbarkeitsdiagnose enthalten. Diese Seite enthält Informationen zu nur wenigen Feldern. Eine vollständige Dokumentation zu diesem Objekt und seinen Feldern finden Sie unter UptimeCheckConfig:

    • Lassen Sie das Feld name des Konfigurationsobjekts leer. Das System legt dieses Feld fest, wenn es das Antwortkonfigurationsobjekt erstellt.

    • Wenn Sie eine HTTP- oder HTTPS-Prüfung konfigurieren, müssen Sie das Feld HttpCheck des Objekts UptimeCheckConfig ausfüllen. Legen Sie in diesem Objekt das Feld requestMethod auf GET oder POST fest. Wenn dieses Feld ausgelassen oder auf METHOD_UNSPECIFIED gesetzt wird, wird eine GET-Anfrage ausgegeben.

      Wenn Sie eine POST-Anfrage konfigurieren, füllen Sie die Felder contentType und body aus.

Die Methode create gibt das Objekt UptimeCheckConfig für die neue Konfiguration zurück.

Wenn die erstellte Verfügbarkeitsdiagnose nicht wie erwartet funktioniert, lesen Sie den Abschnitt Diagnose fehlgeschlagen 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();
    ProjectName projectName = new ProjectName(projectId);
    // Create the config.
    var newConfig = client.CreateUptimeCheckConfig(
        projectName,
        config,
        CallSettings.FromExpiration(
            Expiration.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


// createGet creates an example uptime check on a GET request.
func createGet(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 GET 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{
					RequestMethod: monitoringpb.UptimeCheckConfig_HttpCheck_GET,
					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 GET: %v", err)
	}
	fmt.Fprintf(w, "Successfully created GET uptime check %q\n", config.GetDisplayName())
	return config, nil
}

// createPost creates an example uptime check on a POST request.
func createPost(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 POST 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{
					RequestMethod: monitoringpb.UptimeCheckConfig_HttpCheck_POST,
					ContentType:   monitoringpb.UptimeCheckConfig_HttpCheck_URL_ENCODED,
					Path:          "/",
					Port:          80,
					Body:          []byte(base64.URLEncoding.EncodeToString([]byte("key: value"))),
				},
			},
			Timeout: &duration.Duration{Seconds: 10},
			Period:  &duration.Duration{Seconds: 300},
		},
	}
	config, err := client.CreateUptimeCheckConfig(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("CreateUptimeCheckConfig POST: %v", err)
	}
	fmt.Fprintf(w, "Successfully created POST 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_get(project_name, host_name=None, display_name=None):
    config = monitoring_v3.types.uptime_pb2.UptimeCheckConfig()
    config.display_name = display_name or "New GET uptime check"
    config.monitored_resource.type = "uptime_url"
    config.monitored_resource.labels.update({"host": host_name or "example.com"})
    config.http_check.request_method = (
        monitoring_v3.enums.UptimeCheckConfig.HttpCheck.RequestMethod.GET
    )
    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

def create_uptime_check_config_post(project_name, host_name=None, display_name=None):
    config = monitoring_v3.types.uptime_pb2.UptimeCheckConfig()
    config.display_name = display_name or "New POST uptime check"
    config.monitored_resource.type = "uptime_url"
    config.monitored_resource.labels.update({"host": host_name or "example.com"})
    config.http_check.request_method = (
        monitoring_v3.enums.UptimeCheckConfig.HttpCheck.RequestMethod.POST
    )
    config.http_check.content_type = (
        monitoring_v3.enums.UptimeCheckConfig.HttpCheck.ContentType.URL_ENCODED
    )
    config.http_check.body = "foo=bar".encode("utf-8")
    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"

  client = Google::Cloud::Monitoring.uptime_check_service
  project_name = client.project_path project: 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 }
  }
  new_config = client.create_uptime_check_config \
    parent:              project_name,
    uptime_check_config: config
  puts new_config.name
  new_config
end

Es kann bis zu 5 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).

Kennungen für Verfügbarkeitsdiagnosen

Bei der Erstellung der Verfügbarkeitsdiagnose weist Monitoring 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ügbarkeitsdiagnose-ID im Fenster Betriebszeitdetails im Abschnitt Konfiguration.

Verfügbarkeitsdiagnose überprüfen

Wenn Sie eine Verfügbarkeitsdiagnose in der Cloud 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 ist 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 abrufen.
  • Name or service not found (Name oder Dienst nicht gefunden): Der Hostname ist möglicherweise falsch.
  • 403 Forbidden (403 – Verboten): Der Dienst gibt während der Verfügbarkeitsdiagnose einen Fehlercode zurück. Die Standardkonfiguration für den Apache-Webserver gibt diesen Code beispielsweise unter Amazon Linux zurück. Unter bestimmten Linux-Versionen erhalten Sie hingegen den Code 200 (Success) (200 (Erfolg)). Weitere Informationen finden Sie in der LAMP-Anleitung für Amazon Linux oder in der Dokumentation Ihres Webservers.
  • 404 – Not found (404 – 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 Erweiterte Optionen im Abschnitt Systemdiagnose angegeben.

Verfügbarkeitsdiagnose aufrufen

So rufen Sie eine Verfügbarkeitsdiagnose auf:

Console

So rufen Sie den detaillierten Status einer einzelnen Verfügbarkeitsdiagnose auf:

  1. Wählen Sie in der Cloud Console Monitoring aus:

    Zu Monitoring

  2. Klicken Sie auf Verfügbarkeitsdiagnosen.

  3. Suchen Sie nach der Verfügbarkeitsdiagnose, die Sie sehen möchten, und klicken Sie auf den Namen der Verfügbarkeitsdiagnose, um das Fenster Uptime details (Betriebszeitdetails) aufzurufen.

    Der folgende Screenshot zeigt die Betriebszeitdetails für eine Verfügbarkeitsdiagnose mit dem Namen "My Uptime Check":

    Beispiel für Dashboard zu den Betriebszeitdetails

    Das Fenster Uptime details (Betriebszeitdetails) enthält die folgenden Informationen:

    • Das ausgewählte Zeitintervall. Standardmäßig beträgt das Intervall 1 hour (1 Stunde).
    • Den Namen der Verfügbarkeitsdiagnose. Im Beispiel lautet der Name My Uptime Check.
    • Den Prozentsatz der Verfügbarkeit und die durchschnittliche Latenz. Der Wert Percent uptime (Verfügbarkeit in %) ist ein Prozentsatz, der mit (S/T)*100 berechnet wird, wobei S die Anzahl der erfolgreichen Diagnoseantworten und T die Gesamtzahl der Diagnoseantworten von allen Standorten ist. Bei Gruppendiagnosen werden die Werte von S und T für alle aktuellen Gruppenmitglieder addiert.

      In einem Zeitraum von 25 Minuten würde eine Verfügbarkeitsdiagnose, die eine Minute dauert und für alle Regionen ausgeführt wird, z. B. 25 Anfragen von allen 6 Standorten und damit insgesamt 150 Anfragen erhalten. Wenn das Dashboard eine Verfügbarkeit von 83,3 % meldet, sind 125 von 150 Anfragen erfolgreich.

    • In den Bereichen Passed checks (Erfolgreiche Diagnosen) und Uptime check latency (Latenz der Verfügbarkeitsdiagnose) werden die Anzahl der erfolgreichen Diagnosen und die Latenz jeder Diagnose grafisch als Funktion in Abhängigkeit von der Zeit dargestellt.

    • Im Bereich Current Status (Aktueller Status) wird der Status der letzten Diagnosen angezeigt. Ein grüner Kreis mit einem Häkchen neben einer Region gibt an, wann die letzte Diagnose in dieser Region erfolgreich war. Ein roter Kreis mit einem x weist auf einen Fehler hin.

    • Im Bereich Configuration (Konfiguration) wird die Konfiguration der Verfügbarkeitsdiagnose angezeigt. Diese Daten werden zugewiesen, wenn die Verfügbarkeitsdiagnose erstellt wird. Der Wert Check Id (Diagnose-ID) entspricht dem Wert UPTIME_CHECK_ID in API-Aufrufen.

    • Der Bereich Alert Policies (Benachrichtigungsrichtlinien) enthält Informationen zu den zugehörigen Benachrichtigungsrichtlinien. Im Beispiel-Dashboard wird eine Benachrichtigungsrichtlinie konfiguriert.

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.projectUptimeCheckConfigPath(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"

  client = Google::Cloud::Monitoring.uptime_check_service
  config = client.get_uptime_check_config name: config_name
  pp config.to_h
  config
end

Verfügbarkeitsdiagnose bearbeiten

Das Protokoll der Verfügbarkeitsdiagnose, der Ressourcentyp und die überwachte Ressource können nicht geändert werden. Wenn Sie diese Felder ändern möchten, müssen Sie eine Verfügbarkeitsdiagnose mit der richtigen Konfiguration erstellen. Alle anderen Felder in einer Verfügbarkeitsdiagnose können jedoch nach der Erstellung geändert werden.

Um eine Benachrichtigungsrichtlinie zu bearbeiten, die einer Verfügbarkeitsdiagnose zugeordnet ist, klicken Sie im Navigationsbereich "Monitoring" auf Benachrichtigungen, wählen Sie die zu bearbeitende Richtlinie aus und klicken Sie auf Bearbeiten.

Gehen Sie zum Bearbeiten einer Verfügbarkeitsdiagnose so vor:

Console

  1. Wählen Sie in der Cloud Console Monitoring aus:

    Zu Monitoring

  2. Klicken Sie auf Verfügbarkeitsdiagnosen.

  3. Suchen Sie nach der Verfügbarkeitsdiagnose, die Sie bearbeiten möchten, und führen Sie dann einen der folgenden Schritte aus:

    • Klicken Sie auf Mehr und wählen Sie Bearbeiten aus.
    • Sehen Sie sich die Details zur Verfügbarkeitsdiagnose an und klicken Sie auf Edit (Bearbeiten).
  4. Ä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.

  5. Klicken Sie auf Testen, um zu prüfen, ob die Diagnose erfolgreich war. Wenn der Test fehlschlägt, können Sie dem Abschnitt Diagnose fehlgeschlagen mögliche Ursachen entnehmen.

  6. Klicken Sie auf 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. Dies ist der Ressourcenname der zu bearbeitenden Verfügbarkeitsdiagnose:

    projects/PROJECT_ID/uptimeCheckConfigs/UPTIME_CHECK_ID
    

    Sie können den UPTIME_CHECK_ID aus der Antwort einer create- oder list-Methode abrufen. Die ID wird nicht in der Cloud Console 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 gibt das Objekt UptimeCheckConfig für die geänderte Konfiguration zurück.

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.projectUptimeCheckConfigPath(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"

  client = Google::Cloud::Monitoring.uptime_check_service
  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 uptime_check_config: config,
                                    update_mask:         field_mask
end

Es kann bis zu 5 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ügbarkeitsdiagnose löschen

Wenn Sie versuchen, eine Verfügbarkeitsdiagnose mithilfe der Cloud Console zu löschen und eine Benachrichtigungsrichtlinie vorhanden ist, die von der Verfügbarkeitsdiagnose abhängt, schlägt der Löschvorgang fehl. Wiederholen Sie den Löschvorgang, nachdem Sie die Verfügbarkeitsdiagnose aus allen Benachrichtigungsrichtlinien entfernt haben, die die Prüfung verwenden.

Wenn Sie versuchen, eine Verfügbarkeitsdiagnose mithilfe der Cloud Monitoring API zu löschen, wird die Verfügbarkeitsdiagnose auch dann gelöscht, wenn Benachrichtigungsrichtlinien vorhanden sind, die von der Prüfung abhängen. Es wird kein Fehler generiert. Für die fehlende Diagnose wird kein Vorfall erstellt. Stellen Sie vor dem Löschen einer Verfügbarkeitsdiagnose sicher, dass keine Benachrichtigungsrichtlinien vorhanden sind, die von dieser Prüfung abhängen.

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

Console

  1. Wählen Sie in der Cloud Console Monitoring aus:

    Zu Monitoring

  2. Klicken Sie auf Verfügbarkeitsdiagnosen.

  3. Suchen Sie nach der Verfügbarkeitsdiagnose, die Sie bearbeiten möchten, und führen Sie dann einen der folgenden Schritte aus:

    • Klicken Sie auf Mehr und wählen Sie Löschen aus.
    • Rufen Sie die Details zur Verfügbarkeitsdiagnose auf und klicken Sie dann auf Löschen .

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 UPTIME_CHECK_ID aus der Antwort einer create- oder list-Methode abrufen. Die ID wird nicht in der Cloud Console 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.projectUptimeCheckConfigPath(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

# `config_name` is the `name` field of an UptimeCheckConfig.
# See https://cloud.google.com/monitoring/api/ref_v3/rest/v3/projects.uptimeCheckConfigs#UptimeCheckConfig.
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"

  client = Google::Cloud::Monitoring.uptime_check_service
  client.delete_uptime_check_config name: config_name
  puts "Deleted #{config_name}"
end

Nächste Schritte

  • Informationen zu Preisen und Limits für Verfügbarkeitsdiagnosen erhalten Sie unter Preise und Limits.
  • Eine Liste aller Verfügbarkeitsdiagnosen finden Sie unter Verfügbarkeitsdiagnosen überprüfen.
  • Eine Liste der IP-Adressen, die für die Verfügbarkeitsdiagnosen verwendet werden können, finden Sie unter IP-Adressen abrufen.
  • Prüfen Sie den Messwert monitoring.googleapis.com/uptime_check/check_passed, um den Status Ihrer Verfügbarkeitsdiagnosen mithilfe der API zu ermitteln. Weitere Informationen finden Sie in der Google Cloud-Messwertliste.