Öffentliche Verfügbarkeitsdiagnosen erstellen

Console

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

1. Rufen Sie in der Google Cloud Console die Seite  Uptime-Prüfungen 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.

   

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.

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

        Wenn Sie beispielsweise eine Verfügbarkeitsdiagnose für die URL-Ressource example.com/tester ausführen möchten, setzen Sie das Feld Hostname auf example.com und das Feld Pfad auf /tester.

        Angenommen, Sie haben einen Server in App Engine mit einem Disponenten bereitgestellt, der / und /hello unterstützt. Wenn Sie die Verfügbarkeitsdiagnose für den Handler „/“ ausführen möchten, lassen Sie das Feld Pfad leer. Um die Verfügbarkeitsdiagnose für den /hello-Handler auszuführen, setzen Sie den Wert des Felds Pfad 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 das Feld Gilt für so aus:

        • Um eine Verfügbarkeitsdiagnose für eine einzelne Instanz oder einen einzelnen Load Balancer durchzuführen, wählen Sie Einzeln 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 Gruppe aus und wählen Sie dann im Menü den Gruppennamen aus.

   5. Optional: Legen Sie mit dem Feld Checkhäufigkeit fest, wie oft die Verfügbarkeitsdiagnose ausgeführt werden soll.

   6. Optional: 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.
      • ICMP-Pings: Konfigurieren Sie die Verfügbarkeitsdiagnose so, dass bis zu drei Pings gesendet werden. Weitere Informationen finden Sie unter ICMP-Pings verwenden.
      • Anfragemethode: Wählen Sie für HTTP-Prüfungen die Anfragemethode aus.
      • Textkörper:Geben Sie für HTTP POST-Prüfungen den URL-codierten Textkörper ein. Die Codierung müssen Sie selbst vornehmen. Lassen Sie dieses Feld für alle anderen Prüfungen leer.
      • 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.
      • Benutzerdefinierte Header: Geben Sie benutzerdefinierte Header an und verschlüsseln Sie sie bei Bedarf. Durch die Verschlüsselung werden die Werte der Kopfzeile im Formular ausgeblendet. Verwenden Sie die Verschlüsselung für Header im Zusammenhang mit der Authentifizierung, die für andere nicht sichtbar sein sollen.

      • Authentifizierung: Diese Werte werden als Autorisierungsheader gesendet. Dieses Feld ist für TCP-Diagnosen nicht verfügbar.

        Wählen Sie aus den folgenden Optionen aus:

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

      • SSL-Zertifikatprü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. Verfügbarkeitsdiagnosen schlagen fehl, wenn eine URL ein ungültiges Zertifikat aufweist. Gründe für ein ungültiges Zertifikat sind:

        • Ein abgelaufenes Zertifikat
        • Ein selbst signiertes Zertifikat
        • Ein Zertifikat mit einem nicht übereinstimmenden Domainnamen
        • Ein Zertifikat, das die AIA-Erweiterung (Authority Information Access) verwendet.

        Wenn Sie eine HTTPS-Verfügbarkeitsdiagnose zur Validierung des SSL-Zertifikats erzwingen möchten, wählen Sie SSL-Zertifikate überprüfen aus.

        Wenn Sie die SSL-Zertifikatsvalidierung deaktivieren möchten, entfernen Sie das Häkchen aus dem Kästchen SSL-Zertifikate validieren.

        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 Benachrichtigungsrichtlinie 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 prüfen an.

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

   • Wenn Sie das Zeitlimit für die Verfügbarkeitsdiagnose ändern möchten, verwenden Sie das Feld Antwortzeitlimit. Eine Verfügbarkeitsdiagnose schlägt fehl, wenn innerhalb dieses Zeitraums keine Antwort von mehr als einem Standort empfangen wird.

   • Wenn Sie die Verfügbarkeitsdiagnose so konfigurieren möchten, dass ein Content-Abgleich durchgeführt wird, 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. Angenommen, der Antwortinhalt ist abcd und der Inhaltstyp ist Enthält. Die Verfügbarkeitsdiagnose ist nur dann erfolgreich, wenn die Antwortdaten abcd enthalten. Weitere Informationen finden Sie unter Antwortdaten validieren.
     • Geben Sie den Antwortinhalt ein. Der Antwortinhalt muss ein String sein, der nicht länger als 1.024 Byte ist. In der API ist dies das Objekt ContentMatcher.

   • Wenn Sie verhindern möchten, dass Logeinträge aufgrund von Verfügbarkeitsdiagnosen erstellt werden, entfernen Sie das Häkchen bei Fehler bei der Protokollprüfung.

   • Konfigurieren Sie für die HTTP-Verfügbarkeitschecks die zulässigen Antwortcodes. Standardmäßig kennzeichnen HTTP-Verfügbarkeitsdiagnosen jede 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 eine Benachrichtigungsrichtlinie und konfigurieren Sie 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 fehlschlagen müssen, bevor Benachrichtigungen gesendet werden. Standardmäßig werden Benachrichtigungen gesendet, wenn in mindestens zwei Regionen mindestens eine Minute lang Fehler bei der Verfügbarkeitsdiagnose gemeldet werden.

   3. Klicken Sie im Feld Benachrichtigungskanäle auf arrow_drop_down Menü, wählen Sie die hinzuzufügenden Kanäle aus und klicken Sie auf OK.

      Im Menü sind die Benachrichtigungskanäle für jeden Kanaltyp alphabetisch gruppiert.

   Wenn Sie keine Benachrichtigungsrichtlinie erstellen möchten, muss der Schalter neben der Schaltfläche Keine Benachrichtigung erstellen lauten.

6. Klicken Sie auf Weiter und führen Sie die Verfügbarkeitsdiagnose durch:

   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:

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

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

   4. Klicken Sie auf Erstellen. Wenn Sie Erstellen auswählen und ein Pflichtfeld nicht ausgefüllt ist, wird eine Fehlermeldung angezeigt.

gcloud

Führen Sie den Befehl gcloud monitoring uptime create aus, um die Verfügbarkeitsdiagnose zu erstellen:

gcloud monitoring uptime create DISPLAY_NAME REQUIRED_FLAGS OPTIONAL_FLAGS

Führen Sie vor dem Ausführen des vorherigen Befehls die folgenden Schritte aus:

• Ersetzen Sie DISPLAY_NAME durch den Namen der Uptime-Prüfung.

• Konfigurieren Sie die REQUIRED_FLAGS so, dass die Ressource angegeben wird, die von der Verfügbarkeitsdiagnose geprüft wird. Mit dem folgenden Befehl wird beispielsweise eine Uptime-Prüfung erstellt, bei der die URL EXAMPLE.com für ein bestimmtes Projekt geprüft wird:

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

  Im vorherigen Befehl werden Werte für jedes Label angegeben, das vom Ressourcentyp uptime-url benötigt wird.

• Konfigurieren Sie die OPTIONAL_FLAGS-Flags, um Standardwerte zu überschreiben. Sie müssen beispielsweise das Flag --protocol setzen, wenn das Protokoll nicht http ist.

API

Rufen Sie die Methode projects.uptimeCheckConfigs.create auf, um eine Verfügbarkeitsdiagnose zu erstellen. 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üllen Sie die Felder contentType, optional customContentType 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 Diagnosefehler auf dieser Seite.

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, um diese Diagnose zu überwachen:

1. Bearbeiten Sie Ihre Terraform-Konfigurationsdatei, fügen Sie eine google_monitoring_uptime_check_config-Ressource hinzu und wenden Sie die Konfigurationsdatei an.

   Das folgende Beispiel zeigt eine Konfiguration, bei der eine öffentliche URL geprüft wird:

   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 beschrieben, wie Sie mit der Google Cloud Console den Benachrichtigungskanal und die Benachrichtigungsrichtlinie erstellen. So wird sichergestellt, dass die Benachrichtigungsrichtlinie nur die Daten überwacht, die von Ihrer Verfügbarkeitsdiagnose generiert werden.

   1. So erstellen Sie einen Benachrichtigungskanal:

      1. Rufen Sie in der Google Cloud Console die Seite notifications 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. Rufen Sie den Kanaltyp auf, den Sie hinzufügen möchten, klicken Sie 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  Uptime-Prüfungen 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 die Verfügbarkeitsdiagnose, wählen Sie more_vert Mehr und dann Benachrichtigungsrichtlinie hinzufügen aus.
      3. Gehen Sie im Dialogfeld zum Bereich Benachrichtigungen und Name, maximieren Sie Benachrichtigungskanäle und treffen Sie Ihre Auswahl.
      4. Geben Sie einen Namen für die Benachrichtigungsrichtlinie ein und klicken Sie dann auf Richtlinie erstellen.

   Sie können eine Benachrichtigungsrichtlinie erstellen, indem Sie Ihrer Konfigurationsdatei eine google_monitoring_alert_policy-Ressource hinzufügen und die neue Konfiguration anwenden.