Öffentliche Verfügbarkeitsdiagnosen erstellen

In diesem Dokument wird beschrieben, wie Sie eine öffentliche Verfügbarkeitsdiagnose erstellen. Eine öffentliche Verfügbarkeitsdiagnose kann Anfragen von mehreren Standorten im weltweit zu öffentlich zugänglichen URLs oder Google Cloud-Ressourcen, die Ressource antwortet. Informationen zum Erstellen Verfügbarkeitsdiagnosen für private Netzwerke, siehe Private Verfügbarkeitsdiagnosen erstellen

Mit öffentlichen Verfügbarkeitsdiagnosen kann die Verfügbarkeit folgender Elemente ermittelt werden: überwachten Ressourcen:

Links zu Informationen zum Verwalten und Überwachen Ihrer Verfügbarkeitsdiagnosen finden Sie im Abschnitt Weitere Informationen dieses Dokuments.

Verfügbarkeitsdiagnosen

Bei HTTP und HTTPS werden allen URL-Weiterleitungen gefolgt und die endgültige Antwort, die die Verfügbarkeitsdiagnose empfängt, wird zur Bewertung von Erfolgskriterien verwendet. Bei HTTPS-Prüfungen wird die Ablaufzeit des SSL-Zertifikats basierend auf dem Serverzertifikat berechnet, das in der endgültigen Antwort empfangen wurde.

Damit eine Verfügbarkeitsdiagnose erfolgreich ist, müssen die folgenden Bedingungen erfüllt sein:

  • Der HTTP-Status muss den von Ihnen angegebenen Kriterien entsprechen.
  • Für die Antwortdaten ist kein erforderlicher Inhalt vorhanden oder der erforderliche Inhalt ist vorhanden.

Mit Verfügbarkeitsdiagnosen werden keine Seiten-Assets geladen oder JavaScript ausgeführt. Die Konfiguration einer Verfügbarkeitsdiagnose umfasst keine Authentifizierung.

Hinweise

  1. Um die Berechtigungen zu erhalten, die Sie zum Erstellen von Verfügbarkeitsdiagnosen benötigen, bitten Sie Ihren Administrator, Ihnen folgende IAM-Rollen für Ihr Projekt:

    • Monitoring-Bearbeiter (roles/monitoring.editor) – Google Cloud Console-Nutzer
    • Bearbeiter von Konfigurationen für Verfügbarkeitsdiagnosen (roles/monitoring.uptimeCheckConfigEditor) – API-Nutzer
    • Editor für Monitoring-Benachrichtigungsrichtlinien (roles/monitoring.alertPolicyEditor) – API-Nutzer
    • Bearbeiter von Monitoring-Benachrichtigungskanälen (roles/monitoring.notificationChannelEditor) – API-Nutzer

    Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff verwalten.

    Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

  2. Prüfen Sie, ob die Ressource, die Sie prüfen möchten, entweder einen öffentlichen Endpunkt hat oder sich hinter einer konfigurierbaren Firewall befindet.

    Für alle anderen Konfigurationen müssen Sie eine private Verfügbarkeitsdiagnose erstellen. Weitere Informationen finden Sie unter Private Verfügbarkeitsdiagnosen erstellen

  3. Wenn sich Ihre Ressource hinter einer Firewall befindet, konfigurieren Sie diese so, dass eingehender Traffic von den IP-Adressen der Server für die Verfügbarkeitsdiagnose. Für finden Sie unter Listen Sie die IP-Adressen des Verfügbarkeitsdiagnose-Servers auf.

  4. Konfigurieren Sie die Benachrichtigungskanäle, die Sie für den Empfang von Benachrichtigungen verwenden möchten Benachrichtigungen. Wir empfehlen, mehrere Arten von Benachrichtigungen zu erstellen Kanäle. Weitere Informationen finden Sie unter Benachrichtigungskanäle erstellen und verwalten

  5. Identifizieren Sie mindestens drei Diagnosen für Ihre Verfügbarkeitsdiagnose. Die Region USA für Verfügbarkeitsdiagnosen enthält USA_OREGON, USA_IOWA und USA_VIRGINIA Regionen. Alle USA_* Regionen hat eine Diagnose und USA umfasst alle drei. Die anderen Verfügbarkeitsdiagnosen-Regionen, EUROPE, SOUTH_AMERICA und ASIA_PACIFIC haben jeweils einen Wert Checker.

    Wenn Sie in der Google Cloud Console Global oder REGION_UNSPECIFIED bei Verwendung der API, werden Verfügbarkeitsdiagnosen von dieser in allen Regionen für Verfügbarkeitsdiagnosen.

Verfügbarkeitsdiagnose erstellen

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

So erstellen Sie eine Verfügbarkeitsdiagnose für einen externen Load-Balancer, der TCP- oder HTTP/S-Port konfiguriert haben, können Sie dieser Anleitung folgen. Alternativ können Sie die Seite Dienstdetails des Dienstes aufrufen. Klicken Sie dann auf Verfügbarkeitsdiagnose erstellen. Wenn Sie mit der Dienstdetails aufzurufen, sind die dienstspezifischen Felder bereits ausgefüllt.

Console

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

  1. Rufen Sie in der Google Cloud Console die Seite  Verfügbarkeitsdiagnosen auf:

    Verfügbarkeitsdiagnosen aufrufen

    Wenn Sie diese Seite über die Suchleiste suchen, wählen Sie das Ergebnis aus, dessen Zwischenüberschrift Monitoring ist.

  2. Klicken Sie auf Verfügbarkeitsdiagnose erstellen.

    Dialogfeld zum Erstellen einer Verfügbarkeitsdiagnose

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

    1. Wählen Sie das Protokoll aus. Sie können HTTP, HTTPS oder TCP auswählen.

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

      • URL: Eine IPv4-Adresse oder ein Hostname. Pfad und Port werden separat eingegeben.
      • Kubernetes LoadBalancer Service: Kubernetes-Service vom Typ LoadBalancer.
      • Instanz: Compute Engine- oder AWS EC2-Instanzen.
      • App Engine: Google App Engine-Anwendungen (Module)
      • 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.

      • Für HTTP- und HTTPS-Prüfungen können Sie einen Pfad eingeben in Ihrem Host oder Ihrer Ressource. 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 beispielsweise eine Verfügbarkeitsdiagnose für die URL-Ressource durchzuführen, example.com/tester, setzen Sie das Feld Hostname auf example.com und im Feld Pfad auf /tester.

        Angenommen, Sie haben einen Server in App Engine mit einem Disponenten bereitgestellt, der / und /hello unterstützt. Um die Verfügbarkeitsdiagnose an die / lassen Sie das Feld Pfad leer. Um den Verfügbarkeitsdiagnose mit dem Handler /hello, legen Sie den Wert des Pfad auf /hello.

    4. Geben Sie die ressourcenspezifischen Felder ein:

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

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

      • Führen Sie für die Ressourcen Elastic Load Balancer und Instance die folgenden Schritte aus: Gilt für:

        • Um eine Verfügbarkeitsdiagnose für eine einzelne Instanz oder einen Load-Balancer auszuführen, wählen Sie Single aus und verwenden Sie die Instanz oder das Lastenausgleichsmodul auswählen.
        • So senden Sie eine Verfügbarkeitsdiagnose für eine Monitoring-Gruppe: wählen Sie Group (Gruppe) aus und verwenden dann das um den Gruppennamen auszuwählen.

    5. Optional: Um festzulegen, wie oft die Verfügbarkeitsdiagnose ausgeführt wird, verwenden Sie die Methode Feld Häufigkeit überprüfen.

    6. Optional: Zur Auswahl von zu prüfenden Regionen oder zum Konfigurieren von SSL Zertifikate, Authentifizierung, Header und Ports für HTTP und HTTPS Klicken Sie auf Weitere Zieloptionen:

      • Regionen: Wählen Sie die Regionen aus, in denen die Verfügbarkeitsdiagnosen Anfragen erhalten sollen. Eine Verfügbarkeitsdiagnose muss mindestens drei Prüfungen haben. Es gibt in allen Regionen außer den USA eine Prüfung. mit drei Häkchen. Die Standardeinstellung Global umfasst Folgendes: in allen Regionen.
      • ICMP-Pings: Konfigurieren Sie die Verfügbarkeitsdiagnose so, dass bis zu drei Pings an. Weitere Informationen finden Sie unter ICMP-Pings verwenden.
      • Anfragemethode: Wählen Sie für HTTP-Prüfungen die Anfragemethode aus.
      • Body:Geben Sie für HTTP-POST-Prüfungen den URL-codierten Text ein. ich müssen Sie die Codierung selbst vornehmen. Behalten Sie für alle anderen Überprüfungen ist leer.
      • Host header (Host-Header): 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 des Headers 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): Diese Werte werden als Autorisierung gesendet. Header. Dieses Feld ist für TCP-Diagnosen nicht verfügbar.

        Wählen Sie aus den folgenden Optionen aus:

        • Basisauthentifizierung: Geben Sie einen Nutzernamen und . Passwörter werden im Formular immer ausgeblendet.
        • Dienst-Agent-Authentifizierung: Wenn diese Option aktiviert ist, Für das Monitoring wird ein Identitätstoken generiert. Dienst-Agent. Diese Option ist nur verfügbar, für HTTPS-Prüfungen.

      • SSL-Zertifikatvalidierung: wenn Sie für eine URL HTTPS ausgewählt haben Ressource ist, versucht der Dienst standardmäßig, über HTTPS und validieren Sie das SSL-Zertifikat. Verfügbarkeitsdiagnosen schlagen fehl, wenn eine URL ein ungültiges Zertifikat enthält. Gründe für ein ungültiges Zertifikat:

        • Ein abgelaufenes Zertifikat
        • Ein selbst signiertes Zertifikat
        • Ein Zertifikat mit einem abweichenden Domainnamen
        • Ein Zertifikat, das Authority Information Access (AIA) verwendet .

        So erzwingen Sie eine HTTPS-Verfügbarkeitsdiagnose zur Validierung des SSL-Zertifikats: Wählen Sie SSL-Zertifikate validieren aus.

        Löschen Sie zum Deaktivieren der SSL-Zertifikatsvalidierung: SSL-Zertifikate validieren

        Wenn Sie SSL-Zertifikate mit AIA Extensions müssen Sie die SSL-Zertifikatsvalidierung 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".

        Mit dem Messwert monitoring.googleapis.com/uptime_check/time_until_ssl_cert_expires um eine Benachrichtigungsrichtlinie zu erstellen, Zertifikat abläuft. Weitere Informationen finden Sie unter Beispielrichtlinien: Richtlinie zur Verfügbarkeitsdiagnose.

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

  4. Klicken Sie auf Continue (Weiter) und konfigurieren Sie die Antwortanforderungen. Alle Einstellungen in diesem Abschnitt haben Standardwerte:

    • Verwenden Sie zum Ändern des Zeitlimits für die Verfügbarkeitsdiagnose die Methode Antwortzeitlimit. Eine Verfügbarkeitsdiagnose schlägt fehl, wenn keine Die Antwort geht innerhalb dieses Zeitraums von mehreren Standorten ein.

    • So konfigurieren Sie die Verfügbarkeitsdiagnose für den Inhaltsabgleich: Die Ein/Aus-Schaltfläche muss Inhaltsabgleich aktiviert lauten:

      • Wählen Sie im Optionsmenü den Übereinstimmungstyp für Antwort-Content aus. Dieses Feld bestimmt, wie der Antwortinhalt mit den zurückgegebenen Daten verglichen wird. Angenommen, der Antwortinhalt ist abcd und die Keyword-Option für den Inhalt ist Enthält. Verfügbarkeitsdiagnose ist nur erfolgreich, wenn die Antwortdaten abcd enthalten. Weitere Informationen finden Sie unter Antwortdaten validieren
      • Geben Sie den Antwortinhalt ein. Der Antwortinhalt muss ein String sein maximal 1.024 Byte groß ist. In der API enthält dieses Feld den ContentMatcher-Objekt.

    • Um zu verhindern, dass Log-Einträge aufgrund von Verfügbarkeitsdiagnosen erstellt werden, Löschen Sie Logprüffehler.

    • Konfigurieren Sie für die HTTP-Verfügbarkeitsdiagnosen die zulässigen Antwortcodes. Standardmäßig markieren HTTP-Verfügbarkeitsdiagnosen alle 2xx-Antwort als erfolgreiche Antwort.

  5. Klicken Sie auf Weiter und konfigurieren Sie die Benachrichtigungen.

    Wenn Sie benachrichtigt werden möchten, wenn eine Verfügbarkeitsdiagnose fehlschlägt, erstellen Sie einen Benachrichtigungsrichtlinie und konfigurieren Benachrichtigungskanäle für diese Richtlinie:

    1. Optional: Aktualisieren Sie den Namen der Benachrichtigungsrichtlinie.
    2. Optional: Wählen Sie im Feld Dauer aus, wie lange die Verfügbarkeitsdiagnosen dauern sollen. muss fehlschlagen, bevor Benachrichtigungen gesendet werden. Standardmäßig sind Benachrichtigungen wird gesendet, wenn mindestens zwei Regionen fehlgeschlagene Verfügbarkeitsdiagnosen für eine Dauer von mindestens einer Minute.

    3. Führen Sie im Feld Benachrichtigungskanäle folgende Schritte aus: Klicke auf Menü, wähle die Kanäle aus, die du hinzufügen möchtest, und klicken Sie dann auf OK.

      Im Menü sind die Benachrichtigungskanäle alphabetisch für für jeden Channel-Typ.

    Wenn Sie keine Benachrichtigungsrichtlinie erstellen möchten, achten Sie darauf, Der Text der Ein/Aus-Schaltfläche lautet Keine Benachrichtigung erstellen.

  6. Klicken Sie auf Weiter und schließen Sie die Verfügbarkeitsdiagnose ab:

    1. Geben Sie einen aussagekräftigen Titel für die Verfügbarkeitsdiagnose ein.

    2. Optional: So fügen Sie Ihrer Verfügbarkeitsdiagnose benutzerdefinierte Labels hinzu: Gehen Sie so vor:

      1. Klicken Sie auf Nutzerlabels anzeigen.
      2. Geben Sie im Feld Schlüssel einen Namen für das Label ein. Labelnamen müssen mit einem Kleinbuchstaben beginnen und dürfen Folgendes enthalten: Kleinbuchstaben, Ziffern, Unterstriche und Bindestriche. Geben Sie beispielsweise severity ein.
      3. Geben Sie im Feld Wert einen Wert für das Label ein. Labelwerte kann enthalten Kleinbuchstaben, Ziffern, Unterstriche und Bindestriche. Geben Sie beispielsweise critical ein.
      4. Klicken Sie für jedes weitere Label auf Nutzerlabel hinzufügen und geben Sie Schlüssel und Wert des Labels.

    3. Klicken Sie auf Test (Testen), um die Konfiguration der Verfügbarkeitsdiagnose zu prüfen. Wenn das Ergebnis nicht Ihren Erwartungen entspricht, lesen Sie Diagnose fehlgeschlagen. korrigiere deine Konfiguration und wiederhole dann den Bestätigungsschritt.

    4. Klicken Sie auf Erstellen. Wenn Sie Erstellen auswählen und ein Pflichtfeld nicht wird eine Fehlermeldung angezeigt.

gcloud

Führen Sie zum Erstellen der Verfügbarkeitsdiagnose den Befehl gcloud monitoring uptime create-Befehl:

gcloud monitoring uptime create DISPLAY_NAME REQUIRED_FLAGS OPTIONAL_FLAGS

Führen Sie die folgenden Schritte aus, bevor Sie den vorherigen Befehl ausführen:

  • Ersetzen Sie DISPLAY_NAME durch den Namen für Ihre Verfügbarkeitsdiagnose.

  • Konfigurieren Sie REQUIRED_FLAGS, um die geprüfte Ressource anzugeben. die Verfügbarkeitsdiagnose. Mit dem folgenden Befehl wird beispielsweise ein Verfügbarkeitsdiagnose, die die URL EXAMPLE.com auf eine für ein bestimmtes Projekt:

    gcloud monitoring uptime create DISPLAY_NAME \
--resource-labels=host=EXAMPLE.com,project_id=PROJECT_ID \
--resource-type=uptime-url

    Der vorherige Befehl gibt Werte für jedes Label an, das vom Ressourcentyp uptime-url.

  • Konfigurieren Sie die OPTIONAL_FLAGS-Flags, um den Standardwert zu überschreiben Werte. So müssen Sie beispielsweise das Flag --protocol festlegen, wenn der Protokoll ist nicht http.

API

Rufen Sie zum Erstellen einer Verfügbarkeitsdiagnose die Methode projects.uptimeCheckConfigs.create . 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 einigen 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ühren Sie den folgenden Befehl aus: Das optionale contentType customContentType und body-Feldern.

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

Wenn die erstellte Verfügbarkeitsdiagnose nicht wie erwartet funktioniert, finden Sie weitere Informationen in der Diagnosefehler auf dieser Seite finden.

C#

Richten Sie zur Authentifizierung bei Monitoring Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

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

Richten Sie zur Authentifizierung bei Monitoring Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

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.getName());
  } catch (Exception e) {
    usage("Exception creating uptime check: " + e.toString());
    throw e;
  }
}

Go

Richten Sie zur Authentifizierung bei Monitoring Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 


// 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: %w", 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: %w", 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: %w", 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: %w", err)
	}
	fmt.Fprintf(w, "Successfully created POST uptime check %q\n", config.GetDisplayName())
	return config, nil
}

Node.js

Richten Sie zur Authentifizierung bei Monitoring Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

// 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

Richten Sie zur Authentifizierung bei Monitoring Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

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

/**
 * 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')
{
    $projectName = 'projects/' . $projectId;
    $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);
    $createUptimeCheckConfigRequest = (new CreateUptimeCheckConfigRequest())
        ->setParent($projectName)
        ->setUptimeCheckConfig($uptimeCheckConfig);

    $uptimeCheckConfig = $uptimeCheckClient->createUptimeCheckConfig($createUptimeCheckConfigRequest);

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

Python

Richten Sie zur Authentifizierung bei Monitoring Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

def create_uptime_check_config_get(
    project_id: str, host_name: str = None, display_name: str = None
) -> uptime.UptimeCheckConfig:
    """Creates a new uptime check configuration

    Args:
        project_id: Google Cloud project id where the uptime check is created
        host_name: An example label's value for the "host" label
        display_name: A human friendly name of the configuration

    Returns:
        A structure that describes a new created uptime check
    """
    config = monitoring_v3.UptimeCheckConfig()
    config.display_name = display_name or "New GET uptime check"
    config.monitored_resource = {
        "type": "uptime_url",
        "labels": {"host": host_name or "example.com"},
    }
    config.http_check = {
        "request_method": monitoring_v3.UptimeCheckConfig.HttpCheck.RequestMethod.GET,
        "path": "/",
        "port": 80,
    }
    config.timeout = {"seconds": 10}
    config.period = {"seconds": 300}

    client = monitoring_v3.UptimeCheckServiceClient()
    new_config = client.create_uptime_check_config(
        request={"parent": project_id, "uptime_check_config": config}
    )
    pprint.pprint(new_config)
    return new_config


def create_uptime_check_config_post(
    project_id: str, host_name: str = None, display_name: str = None
) -> uptime.UptimeCheckConfig:
    """Creates a new uptime check configuration

    Args:
        project_id: Google Cloud project id where the uptime check is created
        host_name: An example label's value for the "host" label
        display_name: A human friendly name of the configuration

    Returns:
        A structure that describes a new created uptime check
    """
    config = monitoring_v3.UptimeCheckConfig()
    config.display_name = display_name or "New POST uptime check"
    config.monitored_resource = {
        "type": "uptime_url",
        "labels": {"host": host_name or "example.com"},
    }
    config.http_check = {
        "request_method": monitoring_v3.UptimeCheckConfig.HttpCheck.RequestMethod.POST,
        "content_type": monitoring_v3.UptimeCheckConfig.HttpCheck.ContentType.URL_ENCODED,
        "body": "foo=bar".encode("utf-8"),
        "path": "/",
        "port": 80,
    }
    config.timeout = {"seconds": 10}
    config.period = {"seconds": 300}

    client = monitoring_v3.UptimeCheckServiceClient()
    new_config = client.create_uptime_check_config(
        request={"parent": project_id, "uptime_check_config": config}
    )
    pprint.pprint(new_config)
    return new_config

Ruby

Richten Sie zur Authentifizierung bei Monitoring Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

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

Terraform

Informationen zum Anwenden oder Entfernen einer Terraform-Konfiguration finden Sie unter Grundlegende Terraform-Befehle. Weitere Informationen finden Sie in der Anbieterreferenzdokumentation zu Terraform.

So erstellen Sie eine Verfügbarkeitsdiagnose und eine Benachrichtigungsrichtlinie zur Überwachung dieser Prüfung: Gehen Sie so vor:

  1. Bearbeiten Sie die Terraform-Konfigurationsdatei und fügen Sie einen google_monitoring_uptime_check_config und wenden Sie dann die Konfigurationsdatei an.

    Das folgende Beispiel zeigt eine Konfiguration, die eine Öffentliche URL:

    resource "google_monitoring_uptime_check_config" "example" {
    display_name = "example"
    timeout      = "60s"

    http_check {
        port = "80"
        request_method = "GET"
    }

    monitored_resource {
        type = "uptime_url"
        labels = {
            project_id = "PROJECT_ID"
            host="EXAMPLE.com"
        }
    }

    checker_type = "STATIC_IP_CHECKERS"
}

  2. Optional: Erstellen Sie einen Benachrichtigungskanal und eine Benachrichtigungsrichtlinie:

    In den folgenden Schritten wird die Benachrichtigung in der Google Cloud Console erstellt Kanal und Benachrichtigungsrichtlinie. Dieser Ansatz sorgt dafür, dass die Benachrichtigungsrichtlinie überwacht nur die von Ihrer Verfügbarkeitsdiagnose generierten Daten.

    1. So erstellen Sie einen Benachrichtigungskanal:

      1. Rufen Sie in der Google Cloud Console die Seite  Benachrichtigungen auf:

        Zu Benachrichtigungen

        Wenn Sie diese Seite über die Suchleiste suchen, wählen Sie das Ergebnis aus, dessen Zwischenüberschrift Monitoring ist.

      2. Wählen Sie Benachrichtigungskanäle verwalten aus.
      3. Wähle den Kanaltyp aus, den du hinzufügen möchtest, und klicke auf Hinzufügen. und füllen Sie das Dialogfeld aus.

    2. So erstellen Sie eine Benachrichtigungsrichtlinie:

      1. Rufen Sie in der Google Cloud Console die Seite  Verfügbarkeitsdiagnosen auf:

        Verfügbarkeitsdiagnosen aufrufen

        Wenn Sie diese Seite über die Suchleiste suchen, wählen Sie das Ergebnis aus, dessen Zwischenüberschrift Monitoring ist.

      2. Suchen Sie Ihre Verfügbarkeitsdiagnose, wählen Sie Mehr aus. und wählen Sie dann Benachrichtigungsrichtlinie hinzufügen aus.
      3. Gehen Sie im Dialogfeld zum Abschnitt Benachrichtigungen und Name. Maximieren Sie Benachrichtigungskanäle und treffen Sie Ihre Auswahl.
      4. Benennen Sie die Benachrichtigungsrichtlinie und klicken Sie dann auf Richtlinie erstellen.

    Sie können eine Benachrichtigungsrichtlinie erstellen, indem Sie ein google_monitoring_alert_policy Ressource in Ihre Konfigurationsdatei und wenden die neue Konfiguration an.

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

ICMP-Pings verwenden

Für die Fehlerbehebung bei fehlgeschlagenen öffentlichen Verfügbarkeitsdiagnosen können Sie Folgendes konfigurieren: Verfügbarkeitsdiagnosen senden, um bis zu drei ICMP-Pings während der Prüfung Mithilfe der Pings können Sie zwischen Fehler verursacht werden, z. B. durch Probleme mit der Netzwerkverbindung und durch Zeitüberschreitungen in Ihrer Anwendung.

Standardmäßig senden Verfügbarkeitsdiagnosen keine Pings. Bei jedem Ping werden einige Latenz bei der Verfügbarkeitsdiagnose. Private Verfügbarkeitsdiagnosen können keine Pings senden.

Wenn eine öffentliche Verfügbarkeitsdiagnose fehlschlägt, werden die Ergebnisse der Pings Cloud Logging-Logs. Wenn der Ping fehlschlägt, werden dem Feld httpRequest die folgenden Felder hinzugefügt: im Logeintrag:

  • rtt_usec: Umlaufzeit für jede fehlgeschlagene Ping-Anfrage.
  • unreachable_count: Anzahl der Ping-Anfragen, bei denen der Wert Statuscode ICMP_DEST_UNREACH.
  • no_answer_count: Anzahl der Ping-Anfragen, bei denen das Zeitlimit überschritten wurde und keine Antwort zurückgegeben.

Die Ergebnisse von Pings für erfolgreiche Verfügbarkeitsdiagnosen werden nicht protokolliert.

Pings konfigurieren

Jede Verfügbarkeitsdiagnosen-Konfiguration enthält entweder Ein HttpCheck-Objekt oder ein TcpCheck-Objekt. Beide Objekte enthalten das Feld pingConfig. Geben Sie in diesem Feld die Anzahl der ICMP-Pings an, die bei jeder Prüfung einbezogen werden sollen. Bis zu 3. Standardmäßig werden keine Pings gesendet.

Führen Sie einen der folgenden Schritte aus, um Pings zu konfigurieren:

  • Wenn Sie die Google Cloud Console verwenden, Maximieren Sie More target options (Weitere Zieloptionen) und geben Sie einen Wert für ICMP Pings (ICMP-Pings) ein. ein.

  • Wenn Sie die Cloud Monitoring API verwenden, Verwenden Sie das Objekt PingConfig, Diese hat folgende Struktur:

    {
  "pingsCount": integer
}

    Weitere Informationen zur Verwendung der Monitoring API für Verfügbarkeitsdiagnosen-Konfigurationen finden Sie unter Erstellen Sie eine Verfügbarkeitsdiagnose: API oder Verfügbarkeitsdiagnosen bearbeiten: API

Verfügbarkeitsdiagnose überprüfen

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

Erfolgreiche Prüfungen

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

  • Der HTTP-Status entspricht den ausgewählten Kriterien.
  • Es gibt für die Antwort keinen erforderlichen Inhalt bzw. der erforderliche Inhalt ist in der Antwort auffindbar.

Nicht bestandene Prüfungen

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. Bei einer neuen Instanz kann ein Verbindungsfehler auftreten wenn Sie keinen Webserver installiert haben. sieh dir die Kurzanleitung 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 Listen Sie die IP-Adressen des Verfügbarkeitsdiagnose-Servers auf.
  • 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 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 die 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. Prüfen Sie, ob Ihre Firewall Traffic von den Verfügbarkeitsservern zulässt; Siehe Listen Sie die IP-Adressen des Verfügbarkeitsdiagnose-Servers auf. Das Zeitlimit ist Teil der Antwortvalidierung angegeben.

Wenn die Verfügbarkeitsdiagnose so konfiguriert ist, dass Pings gesendet werden, Fehlgeschlagene Verfügbarkeitsdiagnosen werden in Cloud Logging geschrieben. Weitere Informationen Siehe ICMP-Pings verwenden.

Nächste Schritte