Verfügbarkeitsdiagnosen verwalten

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

In diesem Dokument wird beschrieben, wie Sie Ihre Verfügbarkeitsdiagnosen mithilfe der Google Cloud Console, der Cloud Monitoring API und der Clientbibliotheken verwalten.

Alle Verfügbarkeitsdiagnosen auflisten

Console

  1. Wählen Sie in der Google Cloud Console Monitoring aus oder klicken Sie auf die folgende Schaltfläche:
    Zu Monitoring

  2. Wählen Sie im Navigationsbereich Verfügbarkeitsdiagnosen aus.

    Das folgende Beispiel zeigt eine Seite mit Verfügbarkeitsdiagnosen:

    Übersicht über Beispiele für Verfügbarkeitsdiagnosen mit Filtern

  3. Optional: Fügen Sie Filter hinzu, um die aufgeführten Verfügbarkeitsdiagnosen einzuschränken.

    Jeder Filter besteht aus einem Namen und einem Wert. Sie können den Wert so einstellen, dass er genau mit dem Namen einer Verfügbarkeitsdiagnose oder einer Teilübereinstimmung übereinstimmt. Bei Übereinstimmungen wird nicht zwischen Groß- und Kleinschreibung unterschieden. Um beispielsweise alle Verfügbarkeitsdiagnosen aufzulisten, deren Name default enthält, gehen Sie so vor:

    • Klicken Sie auf Filter table (Filtertabelle) und wählen Sie Display name (Anzeigename) aus.
    • Geben Sie default ein und drücken Sie die Eingabetaste.

    Wenn Sie mehrere Filter haben, werden sie automatisch durch den logischen Wert AND verbunden, sofern Sie nicht den Filter OR einfügen. Im vorherigen Beispiel wird der Filter OR verwendet, damit eine Verfügbarkeitsdiagnose aufgelistet wird, wenn ihr Name default oder Testing check entspricht.

API

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

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

    projects/[PROJECT_ID]

Rufen Sie die Methode projects.uptimeCheckConfigs.get auf, um eine bestimmte Verfügbarkeitsdiagnose zu erhalten. Geben Sie folgenden Parameter an:

C#

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

Java

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

Go


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

Node.js

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

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

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

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

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

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

PHP

use Google\Cloud\Monitoring\V3\UptimeCheckServiceClient;

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

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

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

Python

def list_uptime_check_configs(project_name):
    client = monitoring_v3.UptimeCheckServiceClient()
    configs = client.list_uptime_check_configs(request={"parent": project_name})

    for config in configs:
        pprint.pprint(config)

Ruby

def list_uptime_check_configs project_id
  require "google/cloud/monitoring"

  client = Google::Cloud::Monitoring.uptime_check_service
  project_name = client.project_path project: project_id
  configs = client.list_uptime_check_configs parent: project_name

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

Details zur Verfügbarkeitsdiagnose ansehen

Console

  1. Wählen Sie in der Google Cloud Console Monitoring aus oder klicken Sie auf die folgende Schaltfläche:
    Zu Monitoring
  2. Wählen Sie im Navigationsbereich Verfügbarkeitsdiagnosen aus.

  3. Suchen Sie die gewünschte Verfügbarkeitsdiagnose und klicken Sie auf ihren Namen.

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

    Beispiel für Dashboard zu den Betriebszeitdetails

    Die Seite Verfügbarkeitsdetails 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.
    • Die Labels, die Sie der Verfügbarkeitsdiagnose hinzugefügt haben.

    • 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 checkName) throws IOException {
  // Create UptimeCheckServiceSettings instance for add retry mechanism
  UptimeCheckServiceSettings.Builder uptimeCheckServiceSettingsBuilder =
      UptimeCheckServiceSettings.newBuilder();
  uptimeCheckServiceSettingsBuilder
      .getUptimeCheckConfigSettings()
      .setRetrySettings(
          uptimeCheckServiceSettingsBuilder
              .getUptimeCheckConfigSettings()
              .getRetrySettings()
              .toBuilder()
              .setInitialRetryDelay(org.threeten.bp.Duration.ofMillis(100L))
              .setRetryDelayMultiplier(1.3)
              .setMaxRetryDelay(MAX_RECONNECT_BACKOFF_TIME)
              .setInitialRpcTimeout(MAX_RECONNECT_BACKOFF_TIME)
              .setRpcTimeoutMultiplier(1.0)
              .setMaxRpcTimeout(MAX_RECONNECT_BACKOFF_TIME)
              .setTotalTimeout(MAX_RECONNECT_BACKOFF_TIME)
              .setMaxAttempts(6)
              .build());
  UptimeCheckServiceSettings uptimeCheckServiceSettings =
      uptimeCheckServiceSettingsBuilder.build();

  // create UptimeCheckServiceClient with retry setting
  try (UptimeCheckServiceClient client =
      UptimeCheckServiceClient.create(uptimeCheckServiceSettings)) {
    UptimeCheckConfig config = client.getUptimeCheckConfig(checkName);
    if (config != null) {
      System.out.println(config.toString());
    } else {
      System.out.println("No uptime check config found with ID " + checkName);
    }
  } 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(request={"name": 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

Sie können einige Felder einer Verfügbarkeitsdiagnose ändern. Sie möchten beispielsweise häufiger die Prüfung durchführen oder das Zeitlimit für die Überprüfung der Antwort erhöhen. Wenn die Verfügbarkeitsdiagnose jedoch nicht mit dem richtigen Protokoll, Ressourcentyp oder der richtigen Ressource konfiguriert ist, löschen Sie die aktuelle Verfügbarkeitsdiagnose und erstellen Sie eine neue.

Informationen zum Bearbeiten von Benachrichtigungsrichtlinien finden Sie unter Richtlinien mit der Google Cloud Console verwalten und Benachrichtigungsrichtlinien mit der API verwalten .

Zum Bearbeiten einer öffentlichen Verfügbarkeitsdiagnose können Sie einen der folgenden Tabs verwenden. Verwenden Sie zum Bearbeiten einer privaten Verfügbarkeitsdiagnose den Tab Console oder API:

Console

  1. Wählen Sie in der Google Cloud Console Monitoring aus oder klicken Sie auf die folgende Schaltfläche:
    Zu Monitoring
  2. Wählen Sie im Navigationsbereich Verfügbarkeitsdiagnosen aus.

  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 Test, um zu prüfen, ob die Prüfung funktioniert. Wenn der Test fehlschlägt, finden Sie Informationen zu möglichen Ursachen unter Diagnosefehler.

  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

    Weitere Informationen zur Kennung der Verfügbarkeitsdiagnose finden Sie unter Eindeutige Kennung einer Verfügbarkeitsdiagnose ermitteln.

  • 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 checkName, String hostName, String pathName)
    throws IOException {

  UpdateUptimeCheckConfigRequest request =
      UpdateUptimeCheckConfigRequest.newBuilder()
          .setUpdateMask(FieldMask.newBuilder().addPaths("http_check.path"))
          .setUptimeCheckConfig(
              UptimeCheckConfig.newBuilder()
                  .setName(checkName)
                  .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($configName);
    $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(request={"name": config_name})
    field_mask = field_mask_pb2.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(request={"uptime_check_config": config, "update_mask": 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

Wir empfehlen, dass Sie eine Verfügbarkeitsdiagnose löschen, wenn Sie den überwachten Dienst oder die überwachte Ressource deaktivieren. Hinweis: Achten Sie vor dem Löschen einer Verfügbarkeitsdiagnose darauf, dass keine Benachrichtigungsrichtlinien vorhanden sind, die die Verfügbarkeitsdiagnose überwachen. Wenn eine Verfügbarkeitsdiagnose durch eine Benachrichtigungsrichtlinie überwacht wird, verhindert die Google Cloud Console, dass diese Verfügbarkeitsdiagnose gelöscht wird. Die Cloud Monitoring API generiert jedoch keinen Fehler und verhindert das Löschen. Für die fehlende Diagnose wird kein Vorfall erstellt.

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

Console

  1. Wählen Sie in der Google Cloud Console Monitoring aus oder klicken Sie auf die folgende Schaltfläche:
    Zu Monitoring
  2. Wählen Sie im Navigationsbereich Verfügbarkeitsdiagnosen aus.

  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:

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 checkName) throws IOException {
  try (UptimeCheckServiceClient client = UptimeCheckServiceClient.create()) {
    client.deleteUptimeCheckConfig(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(request={"name": 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

Verfügbarkeitsdiagnose überwachen

Wir empfehlen Ihnen, eine Benachrichtigungsrichtlinie zu erstellen, damit Sie benachrichtigt werden, wenn die Verfügbarkeitsdiagnose fehlschlägt. Weitere Informationen finden Sie unter Benachrichtigungen für Verfügbarkeitsdiagnosen erstellen.

Eindeutige Kennung einer Verfügbarkeitsdiagnose ermitteln

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 Verfügbarkeitsdiagnose eingebettet:

projects/PROJECT_ID/uptimeCheckConfigs/UPTIME_CHECK_ID

Die Verfügbarkeitsdiagnosen-ID ist in der Antwort der Cloud Monitoring API-Methoden enthalten, die Verfügbarkeitsdiagnosen erstellen oder auflisten. Sie finden die Verfügbarkeitsdiagnosen-ID auch im Bereich Konfiguration der Seite Verfügbarkeitsdetails in der Google Cloud Console. Informationen zum Aufrufen der Seite Verfügbarkeitsdetails finden Sie im Abschnitt Details zu Verfügbarkeitsdiagnosen ansehen in diesem Dokument.

Nächste Schritte