Benachrichtigungsrichtlinien mit der API erstellen

Eine Benachrichtigungsrichtlinie wird in der Cloud Monitoring API durch ein Objekt des Typs AlertPolicy repräsentiert. Dieses definiert eine Reihe von Bedingungen, die auf einen potenziell fehlerhaften Systemstatus hinweisen.

In diesem Dokument wird Folgendes beschrieben:

  • Wie die Monitoring API Benachrichtigungsrichtlinien darstellt
  • Die Bedingungstypen, die die Monitoring API für Benachrichtigungsrichtlinien bietet
  • Erstellen einer Benachrichtigungsrichtlinie mit der Google Cloud CLI oder Clientbibliotheken

Diese Funktion wird nur für Google Cloud -Projekte unterstützt. Wählen Sie für App Hub-Konfigurationen das App Hub-Hostprojekt oder das Verwaltungsprojekt aus.

Struktur einer Benachrichtigungsrichtlinie

In der AlertPolicy-Struktur werden die Komponenten einer Benachrichtigungsrichtlinie definiert. Wenn Sie eine Richtlinie erstellen, geben Sie Werte für die folgenden AlertPolicy-Felder an:

  • displayName: Ein beschreibendes Label für die Richtlinie.
  • documentation: Wir empfehlen, dieses Feld zu verwenden, um Informationen bereitzustellen, die den Vorfallmanagern helfen. Weitere Informationen finden Sie unter Benachrichtigungen mit benutzerdefinierter Dokumentation versehen.

  • userLabels: Alle benutzerdefinierten Labels, die der Richtlinie zugewiesen sind. Diese Labels werden in Benachrichtigungsrichtlinien, Vorfällen und Benachrichtigungen angezeigt. Informationen zur Verwendung von Labels mit Benachrichtigungen finden Sie unter Vorfälle mit Labels versehen.

  • conditions[]: Ein Array von Condition-Strukturen.

  • combiner: Ein logischer Operator, der bestimmt, wie mehrere Bedingungen verarbeitet werden.

  • notificationChannels[]: Ein Array von Ressourcennamen, die jeweils einen NotificationChannel identifizieren.

  • alertStrategy: Gibt Folgendes an:

    • Wie schnell Monitoring Vorfälle schließt, wenn keine Daten mehr eingehen
    • Ob Monitoring bei messwertbasierten Benachrichtigungsrichtlinien eine Benachrichtigung sendet, wenn ein Vorfall geschlossen wird
    • Ob bei messwertbasierte Benachrichtigungsrichtlinien die Wiederholung von Benachrichtigungen aktiviert ist und wie groß das Intervall zwischen diesen Benachrichtigungen ist Weitere Informationen finden Sie unter Wiederholte Benachrichtigungen für messwertbasierte Benachrichtigungsrichtlinien konfigurieren.

Sie können das Feld severity auch angeben, wenn Sie die Cloud Monitoring API und die Google Cloud Console verwenden. In diesem Feld können Sie den Schweregrad von Vorfällen definieren. Wenn Sie keinen Schweregrad angeben, wird der Schweregrad der Benachrichtigungsrichtlinie in Cloud Monitoring auf No Severity festgelegt.

Je nach den von Ihnen erstellten Bedingungen können Sie weitere Felder verwenden.

Wenn eine Benachrichtigungsrichtlinie genau eine Bedingung enthält, wird eine Benachrichtigung gesendet, wenn diese Bedingung erfüllt ist. Informationen zu Benachrichtigungen, wenn Benachrichtigungsrichtlinien mehrere Bedingungen enthalten, finden Sie unter Richtlinien mit mehreren Bedingungen und Wann Monitoring Benachrichtigungen sendet und Vorfälle erstellt.

Wenn Sie die Benachrichtigungsrichtlinie erstellen oder ändern, legt Monitoring auch andere Felder fest, einschließlich des Felds name. Der Wert des Felds name ist der Ressourcenname für die Benachrichtigungsrichtlinie. Der Ressourcenname hat das folgende Format:

projects/PROJECT_ID/alertPolicies/POLICY_ID

Im vorherigen Ausdruck gilt Folgendes:

  • PROJECT_ID: die Kennung des Projekts. Wählen Sie für App Hub-Konfigurationen das App Hub-Hostprojekt oder das Verwaltungsprojekt aus.
  • POLICY_ID: die ID der Benachrichtigungsrichtlinie.

Bedingungstypen in der API

Die Cloud Monitoring API unterstützt eine Vielzahl von Bedingungstypen in der Condition-Struktur. Es gibt mehrere Bedingungstypen für messwertbasierte Benachrichtigungsrichtlinien und einen für logbasierte Benachrichtigungsrichtlinien. In den folgenden Abschnitten werden die verfügbaren Bedingungstypen beschrieben.

Bedingungen für messwertbasierte Benachrichtigungsrichtlinien

Zum Erstellen einer Benachrichtigungsrichtlinie, die Messwertdaten überwacht, einschließlich logbasierter Messwerte, können Sie die folgenden Bedingungstypen verwenden:

Filterbasierte Messwertbedingungen

In den Bedingungen MetricAbsence und MetricThreshold werden Monitoring-Filter verwendet, um die zu überwachenden Zeitreihendaten auszuwählen. Andere Felder in der Bedingungsstruktur geben an, wie die Daten gefiltert, gruppiert und aggregiert werden. Weitere Informationen zu diesen Konzepten finden Sie unter Filtern und Aggregation: Zeitachsen bearbeiten.

Wenn Sie den Bedingungstyp MetricAbsence verwenden, können Sie eine Bedingung erstellen, die nur erfüllt ist, wenn alle Zeitreihen fehlen. In dieser Bedingung wird der Parameter aggregations verwendet, um mehrere Zeitreihen in einer einzigen Zeitreihe zu aggregieren. Weitere Informationen finden Sie in der MetricAbsence-Referenz in der API-Dokumentation.

Eine Benachrichtigungsrichtlinie für fehlende Messwerte erfordert, dass zuvor einige Daten geschrieben wurden. Weitere Informationen finden Sie unter Benachrichtigungsrichtlinien für fehlende Messwerte erstellen.

Wenn Sie Benachrichtigungen basierend auf einem prognostizierten Wert erhalten möchten, konfigurieren Sie Ihre Benachrichtigungsrichtlinie so, dass der Bedingungstyp MetricThreshold verwendet und das Feld forecastOptions festgelegt wird. Wenn dieses Feld nicht festgelegt ist, werden die gemessenen Daten mit einem Grenzwert verglichen. Ist dieses Feld jedoch festgelegt, werden die vorhergesagten Daten mit einem Grenzwert verglichen. Weitere Informationen finden Sie unter Benachrichtigungsrichtlinien für prognostizierte Messwerte erstellen.

PromQL-basierte Messwertbedingungen

In der Bedingung PrometheusQueryLanguageCondition werden PromQL-Abfragen (Prometheus Query Language) verwendet, um die zu überwachenden Zeitreihendaten auszuwählen und zu bearbeiten. Mit Ihrer Bedingung können Sie unter anderem das Verhältnis von Messwerten berechnen und Messwertvergleiche auswerten.

Wenn Sie eine PrometheusQueryLanguageCondition-Bedingung verwenden, muss dies die einzige Bedingung in Ihrer Benachrichtigungsrichtlinie sein. Weitere Informationen finden Sie unter PromQL-basierte Benachrichtigungsrichtlinien.

Bedingungen für Benachrichtigungen zu Verhältnissen

Sie können Benachrichtigungsrichtlinien mit Messwertgrenzwerten erstellen, um das Verhältnis von zwei Messwerten zu überwachen. Zur Erstellung dieser Richtlinien kann entweder der Bedingungstyp MetricThreshold oder der Bedingungstyp PrometheusQueryLanguageCondition verwendet werden. Sie können PromQL auch direkt in der Google Cloud Console verwenden. Über die grafische Benutzeroberfläche zum Erstellen von Grenzwertbedingungen lassen sich keine verhältnisbasierten Bedingungen erstellen oder verwalten.

Wir empfehlen die Verwendung von PromQL, um verhältnisbasierte Benachrichtigungsrichtlinien zu erstellen. Mit PromQL können Sie leistungsstärkere und flexiblere Abfragen erstellen, als es mit dem Bedingungstyp MetricTheshold und mit Monitoring-Filtern möglich ist. Mit einer PrometheusQueryLanguageCondition-Bedingung können Sie beispielsweise das Verhältnis eines absoluten Messwerts zu einem Deltamesswert berechnen.

Wenn Sie die Bedingung MetricThreshold verwenden, müssen Zähler und Nenner des Verhältnisses dieselbe MetricKind haben. Eine Liste der Messwerte und ihrer Eigenschaften finden Sie unter Messwertliste.

Im Allgemeinen ist es am besten, Verhältnisse basierend auf Zeitreihen zu berechnen, die unter Verwendung von Labelwerten für einen einzelnen Messwerttyp erfasst wurden. Ein Verhältnis, das anhand von zwei verschiedenen Messwerttypen berechnet wird, können aufgrund unterschiedlicher Stichprobenzeiträume und Ausrichtungsfenster Anomalien auftreten.

Angenommen, Sie haben zwei verschiedene Messwerttypen, eine RPC-Gesamtzahl und eine RPC-Fehlerzahl und Sie möchten das Verhältnis von Fehler- zu Gesamtzahl berechnen. Die fehlgeschlagenen RPCs werden in der Zeitreihe beider Messwerttypen gezählt. Daher ist es möglich, dass beim Ausrichten der Zeitreihe ein nicht erfolgreicher RPC nicht für beide Zeitreihen im selben Ausrichtungsintervall angezeigt wird. Dieser Unterschied kann z. B. folgende Gründe haben:

  • Da zwei verschiedene Zeitreihen dasselbe Ereignis aufzeichnen, gibt es zwei zugrunde liegende Zählerwerte, die die Sammlung implementieren. Diese werden nicht atomar aktualisiert.
  • Die Stichprobenraten können abweichen. Wenn die Zeitreihen auf einen gemeinsamen Zeitraum ausgerichtet sind, kann die Anzahl für ein einzelnes Ereignis in angrenzenden Ausrichtungsintervallen in den Zeitreihen für die verschiedenen Messwerte angezeigt werden.

Die unterschiedliche Anzahl der Werte in den entsprechenden Ausrichtungsintervallen kann zu einem unsinnigen error/total-Verhältniswert führen, z. B. 1/0 oder 2/1.

Bei Verhältnissen größerer Zahlen ist es weniger wahrscheinlich, dass unsinnige Werte entstehen. Sie können größere Zahlen durch Aggregation erreichen, indem Sie entweder ein Ausrichtungsfenster verwenden, das länger als der Stichprobenzeitraum ist, oder durch das Gruppieren von Daten für bestimmte Labels. Durch diese Verfahren wird der Effekt kleiner Unterschiede in der Anzahl der Punkte in einem gegebenen Intervall minimiert. Das heißt, ein Zwei-Punkte-Unterschied in einem Intervall ist bei einer erwarteten Anzahl von 3 Punkten signifikanter als bei einer erwarteten Anzahl von 300.

Wenn Sie integrierte Messwerttypen verwenden, haben Sie möglicherweise keine andere Wahl, als die Verhältnisse zwischen den Messwerttypen zu berechnen, um den von Ihnen benötigten Wert zu erhalten.

Wenn Sie benutzerdefinierte Messwerte entwerfen, die die gleiche Sache – wie RPCs, die den Fehlerstatus zurückgeben, – in zwei verschiedenen Messwerten zählen könnten, sollten Sie stattdessen einen einzigen Messwert in Betracht ziehen, der jede Zählung nur einmal enthält. Angenommen, Sie zählen RPCs und möchten das Verhältnis von nicht erfolgreichen RPCs zur Gesamtzahl aller RPCs verfolgen. Zur Lösung dieses Problems erstellen Sie einen einzelnen Messwerttyp, um RPCs zu zählen, und verwenden ein Label, um den Status des Aufrufs, einschließlich des Status „OK“, aufzuzeichnen. Dann wird jeder Statuswert bzw. jeder Fehler und jedes „OK“ aufgezeichnet, indem für diesen Fall ein einzelner Zähler aktualisiert wird.

Bedingung für logbasierte Benachrichtigungsrichtlinien

Verwenden Sie den Bedingungstyp LogMatch, um eine logbasierte Benachrichtigungsrichtlinie zu erstellen, durch die Sie benachrichtigt werden, wenn in Ihren Logeinträgen eine Nachricht auftritt, die Ihrem Filter entspricht. Wenn Sie eine LogMatch-Bedingung verwenden, muss dies die einzige Bedingung in Ihrer Benachrichtigungsrichtlinie sein.

Versuchen Sie nicht, den Bedingungstyp LogMatch in Verbindung mit logbasierten Messwerten zu verwenden. Benachrichtigungsrichtlinien, mit denen logbasierte Messwerte überwacht werden, sind messwertbasierte Richtlinien. Weitere Informationen zur Entscheidung zwischen Benachrichtigungsrichtlinien, mit denen entweder logbasierte Messwerte oder Logeinträge überwacht werden, finden Sie unter Logs überwachen.

Die in den Beispielen im Dokument Benachrichtigungsrichtlinien über API verwalten verwendeten Benachrichtigungsrichtlinien sind messwertbasierte Benachrichtigungsrichtlinien, obwohl die Prinzipien für logbasierte Benachrichtigungsrichtlinien identisch sind. Weitere Informationen zu logbasierten Benachrichtigungsrichtlinien finden Sie in der Cloud Logging-Dokumentation unter Logbasierte Benachrichtigungsrichtlinie mit der Monitoring API erstellen.

Benachrichtigungsrichtlinie mit einer App Hub-Anwendung verknüpfen

Google Cloud generiert Dashboards, mit denen Sie Ihre App Hub-Anwendungen überwachen können. Diese Dashboards enthalten Informationen wie Log- und Messwertdaten für Ihre Anwendungen sowie die Dienste und Arbeitslasten, die Teil der Anwendung sind. Benachrichtigungsrichtlinien und die zugehörigen Vorfälle werden in diesen Dashboards auch angezeigt, wenn die Richtlinien mit dem Dienst oder der Arbeitslast einer Anwendung verknüpft sind. Weitere Informationen zum Anwendungsmonitoring finden Sie unter Anwendungstelemetriedaten ansehen.

Wenn Sie eine Benachrichtigungsrichtlinie mit einer App Hub-Anwendung verknüpfen möchten, fügen Sie Ihrer Richtlinie Labels mit den folgenden Schlüsseln hinzu:

  • apphub_application_location
  • apphub_application_id
  • apphub_service_id oder apphub_workload_id
Der Abschnitt userLabels der JSON-Darstellung einer Benachrichtigungsrichtlinie könnte beispielsweise so aussehen: 

  "userLabels": {
    "apphub_service_id": "my-service-id",
    "apphub_application_location": "my-app-location",
    "apphub_application_id": "my-app"
  },

Vorbereitung

Bevor Sie Code für die API schreiben, sollten Sie Folgendes tun:

  • Machen Sie sich mit den allgemeinen Konzepten und der Terminologie vertraut, die in Benachrichtigungsrichtlinien verwendet werden. Weitere Informationen finden Sie unter Benachrichtigungs-Übersicht.
  • Prüfen Sie, ob die Cloud Monitoring API für die Verwendung aktiviert ist. Weitere Informationen finden Sie unter Monitoring API aktivieren.
  • Wenn Sie Clientbibliotheken verwenden möchten, installieren Sie die Bibliotheken für die gewünschten Sprachen. Weitere Informationen finden Sie unter Monitoring-Clientbibliotheken. API-Unterstützung für Benachrichtigungen ist nur für C#, Go, Java, Node.js und Python verfügbar.

  • Wenn Sie die Google Cloud CLI verwenden möchten, installieren Sie sie. Wenn Sie die Cloud Shell verwenden, ist die Google Cloud CLI bereits installiert.

    Sie finden hier auch Beispiele zur Verwendung der gcloud-Schnittstelle. Beachten Sie, dass bei den Beispielen zu gcloud davon ausgegangen wird, dass das aktuelle Projekt bereits mit gcloud config set project [PROJECT_ID] als Ziel festgelegt wurde. Bei Aufrufen wird daher das explizite Flag --project ausgelassen. Die ID des aktuellen Projekts in den Beispielen lautet a-gcp-project. Wählen Sie für App Hub-Konfigurationen das App Hub-Hostprojekt oder das Verwaltungsprojekt aus.

  • Bitten Sie Ihren Administrator, Ihnen für Ihr Projekt die IAM-Rolle Bearbeiter von Monitoring-Benachrichtigungsrichtlinien (roles/monitoring.alertPolicyEditor) zuzuweisen, damit Sie die Berechtigungen zu erhalten, die Sie zum Erstellen und Ändern von Benachrichtigungsrichtlinien mit der Cloud Monitoring API benötigen. Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

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

    Ausführliche Informationen zu IAM-Rollen für Monitoring finden Sie unter Zugriff mit IAM steuern.

  • Entwerfen Sie Ihre Anwendung so, dass Cloud Monitoring API-Aufrufe, die den Status einer Benachrichtigungsrichtlinie in einemGoogle Cloud -Projekt ändern, in einem einzelnen Thread ausgeführt werden. Ein Beispiel sind API-Aufrufe in einem einzelnen Thread, mit denen eine Benachrichtigungsrichtlinie erstellt, aktualisiert oder gelöscht wird.

Benachrichtigungsrichtlinie erstellen

Verwenden Sie zum Erstellen einer Benachrichtigungsrichtlinie in einem Projekt die Methode alertPolicies.create. Informationen zum Aufrufen dieser Methode, zu den zugehörigen Parametern und zu den Antwortdaten finden Sie auf der Referenzseite zu alertPolicies.create.

Sie können Richtlinien aus JSON- oder YAML-Dateien erstellen. Die Google Cloud CLI akzeptiert diese Dateien als Argumente. Sie können JSON-Dateien programmatisch lesen, sie in AlertPolicy-Objekte umwandeln und daraus mit der Methode alertPolicies.create Richtlinien erstellen. Wenn Sie eine Prometheus-Konfigurationsdatei im JSON- oder YAML-Format mit einer Benachrichtigungsregel haben, kann die gcloud CLI sie in eine Cloud Monitoring-Benachrichtigungsrichtlinie mit einer PromQL-Bedingung migrieren. Weitere Informationen finden Sie unter Benachrichtigungsregeln und Empfänger aus Prometheus migrieren.

Jede Benachrichtigungsrichtlinie gehört zu einem den Umfang festlegenden Projekt für einen Messwertbereichs. Jedes Projekt kann bis zu 2.000 Richtlinien enthalten. Für API-Aufrufe müssen Sie eine „Projekt-ID“ angeben. Verwenden Sie als Wert die ID des den Umfang festlegenden Projekts für den Messwertbereich. In diesen Beispielen lautet die ID des den Umfang festlegenden Projekts für den Messwertbereich a-gcp-project.

Die folgenden Beispiele veranschaulichen das Erstellen von Benachrichtigungsrichtlinien. Sie zeigen jedoch nicht, wie eine JSON- oder YAML-Datei erstellt wird, die eine Benachrichtigungsrichtlinie beschreibt. Stattdessen wird in den Beispielen davon ausgegangen, dass eine JSON-formatierte Datei vorhanden ist, und es wird veranschaulicht, wie der API-Aufruf erfolgt. Beispiel-JSON-Dateien finden Sie unter Beispielrichtlinien in JSON. Allgemeine Informationen zum Monitoring von Messwertverhältnissen finden Sie unter Verhältnisse von Messwerten.

gcloud

Erstellen Sie eine Benachrichtigungsrichtlinie in einem Projekt mit dem Befehl gcloud alpha monitoring policies create. Im folgenden Beispiel wird eine Benachrichtigungsrichtlinie in a-gcp-project mit der Datei rising-cpu-usage.json erstellt:

gcloud alpha monitoring policies create --policy-from-file="rising-cpu-usage.json"

Bei Erfolg gibt dieser Befehl den Namen der neuen Richtlinie zurück. Beispiel:

Created alert policy [projects/a-gcp-project/alertPolicies/12669073143329903307].

Die Datei rising-cpu-usage.json enthält den JSON-Code für eine Richtlinie mit dem Anzeigenamen „High CPU rate of change“ (Hohe CPU-Änderungsrate). Weitere Informationen zu dieser Richtlinie finden Sie unter Änderungsrichtlinie.

Weitere Informationen finden Sie in der Referenz zu gcloud alpha monitoring policies create.

C#

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

static void RestorePolicies(string projectId, string filePath)
{
    var policyClient = AlertPolicyServiceClient.Create();
    var channelClient = NotificationChannelServiceClient.Create();
    List<Exception> exceptions = new List<Exception>();
    var backup = JsonConvert.DeserializeObject<BackupRecord>(
        File.ReadAllText(filePath), new ProtoMessageConverter());
    var projectName = new ProjectName(projectId);
    bool isSameProject = projectId == backup.ProjectId;
    // When a channel is recreated, rather than updated, it will get
    // a new name.  We have to update the AlertPolicy with the new
    // name.  Track the names in this map.
    var channelNameMap = new Dictionary<string, string>();
    foreach (NotificationChannel channel in backup.Channels)
    {
    }
    foreach (AlertPolicy policy in backup.Policies)
    {
        string policyName = policy.Name;
        // These two fields cannot be set directly, so clear them.
        policy.CreationRecord = null;
        policy.MutationRecord = null;
        // Update channel names if the channel was recreated with
        // another name.
        for (int i = 0; i < policy.NotificationChannels.Count; ++i)
        {
            if (channelNameMap.ContainsKey(policy.NotificationChannels[i]))
            {
                policy.NotificationChannels[i] =
                    channelNameMap[policy.NotificationChannels[i]];
            }
        }
        try
        {
            Console.WriteLine("Updating policy.\n{0}",
                policy.DisplayName);
            bool updated = false;
            if (isSameProject)
                try
                {
                    policyClient.UpdateAlertPolicy(null, policy);
                    updated = true;
                }
                catch (Grpc.Core.RpcException e)
                when (e.Status.StatusCode == StatusCode.NotFound)
                { }
            if (!updated)
            {
                // The policy no longer exists.  Recreate it.
                policy.Name = null;
                foreach (var condition in policy.Conditions)
                {
                    condition.Name = null;
                }
                policyClient.CreateAlertPolicy(projectName, policy);
            }
            Console.WriteLine("Restored {0}.", policyName);
        }
        catch (Exception e)
        {
            // If one failed, continue trying to update the others.
            exceptions.Add(e);
        }
    }
    if (exceptions.Count > 0)
    {
        throw new AggregateException(exceptions);
    }
}

Go

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


// restorePolicies updates the project with the alert policies and
// notification channels in r.
func restorePolicies(w io.Writer, projectID string, r io.Reader) error {
	b := backup{}
	if err := json.NewDecoder(r).Decode(&b); err != nil {
		return err
	}
	sameProject := projectID == b.ProjectID

	ctx := context.Background()

	alertClient, err := monitoring.NewAlertPolicyClient(ctx)
	if err != nil {
		return err
	}
	defer alertClient.Close()
	channelClient, err := monitoring.NewNotificationChannelClient(ctx)
	if err != nil {
		return err
	}
	defer channelClient.Close()

	// When a channel is recreated, rather than updated, it will get
	// a new name.  We have to update the AlertPolicy with the new
	// name.  channelNames keeps track of the new names.
	channelNames := make(map[string]string)
	for _, c := range b.Channels {
		fmt.Fprintf(w, "Updating channel %q\n", c.GetDisplayName())
		c.VerificationStatus = monitoringpb.NotificationChannel_VERIFICATION_STATUS_UNSPECIFIED
		updated := false
		if sameProject {
			req := &monitoringpb.UpdateNotificationChannelRequest{
				NotificationChannel: c.NotificationChannel,
			}
			_, err := channelClient.UpdateNotificationChannel(ctx, req)
			if err == nil {
				updated = true
			}
		}
		if !updated {
			req := &monitoringpb.CreateNotificationChannelRequest{
				Name:                "projects/" + projectID,
				NotificationChannel: c.NotificationChannel,
			}
			oldName := c.GetName()
			c.Name = ""
			newC, err := channelClient.CreateNotificationChannel(ctx, req)
			if err != nil {
				return err
			}
			channelNames[oldName] = newC.GetName()
		}
	}

	for _, policy := range b.AlertPolicies {
		fmt.Fprintf(w, "Updating alert %q\n", policy.GetDisplayName())
		policy.CreationRecord = nil
		policy.MutationRecord = nil
		for i, aChannel := range policy.GetNotificationChannels() {
			if c, ok := channelNames[aChannel]; ok {
				policy.NotificationChannels[i] = c
			}
		}
		updated := false
		if sameProject {
			req := &monitoringpb.UpdateAlertPolicyRequest{
				AlertPolicy: policy.AlertPolicy,
			}
			_, err := alertClient.UpdateAlertPolicy(ctx, req)
			if err == nil {
				updated = true
			}
		}
		if !updated {
			req := &monitoringpb.CreateAlertPolicyRequest{
				Name:        "projects/" + projectID,
				AlertPolicy: policy.AlertPolicy,
			}
			if _, err = alertClient.CreateAlertPolicy(ctx, req); err != nil {
				log.Fatal(err)
			}
		}
	}
	fmt.Fprintf(w, "Successfully restored alerts.")
	return nil
}

Java

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

private static void restoreRevisedPolicies(
    String projectId, boolean isSameProject, List<AlertPolicy> policies) throws IOException {
  try (AlertPolicyServiceClient client = AlertPolicyServiceClient.create()) {
    for (AlertPolicy policy : policies) {
      if (!isSameProject) {
        policy = client.createAlertPolicy(ProjectName.of(projectId), policy);
      } else {
        try {
          client.updateAlertPolicy(null, policy);
        } catch (Exception e) {
          policy =
              client.createAlertPolicy(
                  ProjectName.of(projectId), policy.toBuilder().clearName().build());
        }
      }
      System.out.println(String.format("Restored %s", policy.getName()));
    }
  }
}

Node.js

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

const fs = require('fs');

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

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

async function restorePolicies() {
  // Note: The policies are restored one at a time due to limitations in
  // the API. Otherwise, you may receive a 'service unavailable'  error
  // while trying to create multiple alerts simultaneously.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const projectId = 'YOUR_PROJECT_ID';

  console.log('Loading policies from ./policies_backup.json');
  const fileContent = fs.readFileSync('./policies_backup.json', 'utf-8');
  const policies = JSON.parse(fileContent);

  for (const index in policies) {
    // Restore each policy one at a time
    let policy = policies[index];
    if (await doesAlertPolicyExist(policy.name)) {
      policy = await client.updateAlertPolicy({
        alertPolicy: policy,
      });
    } else {
      // Clear away output-only fields
      delete policy.name;
      delete policy.creationRecord;
      delete policy.mutationRecord;
      policy.conditions.forEach(condition => delete condition.name);

      policy = await client.createAlertPolicy({
        name: client.projectPath(projectId),
        alertPolicy: policy,
      });
    }

    console.log(`Restored ${policy[0].name}.`);
  }
  async function doesAlertPolicyExist(name) {
    try {
      const [policy] = await client.getAlertPolicy({
        name,
      });
      return policy ? true : false;
    } catch (err) {
      if (err && err.code === 5) {
        // Error code 5 comes from the google.rpc.code.NOT_FOUND protobuf
        return false;
      }
      throw err;
    }
  }
}
restorePolicies();

PHP

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

use Google\Cloud\Monitoring\V3\AlertPolicy;
use Google\Cloud\Monitoring\V3\AlertPolicy\Condition;
use Google\Cloud\Monitoring\V3\AlertPolicy\Condition\MetricThreshold;
use Google\Cloud\Monitoring\V3\AlertPolicy\ConditionCombinerType;
use Google\Cloud\Monitoring\V3\Client\AlertPolicyServiceClient;
use Google\Cloud\Monitoring\V3\ComparisonType;
use Google\Cloud\Monitoring\V3\CreateAlertPolicyRequest;
use Google\Protobuf\Duration;

/**
 * @param string $projectId Your project ID
 */
function alert_create_policy($projectId)
{
    $alertClient = new AlertPolicyServiceClient([
        'projectId' => $projectId,
    ]);
    $projectName = 'projects/' . $projectId;

    $policy = new AlertPolicy();
    $policy->setDisplayName('Test Alert Policy');
    $policy->setCombiner(ConditionCombinerType::PBOR);
    /** @see https://cloud.google.com/monitoring/api/resources for a list of resource.type */
    /** @see https://cloud.google.com/monitoring/api/metrics_gcp for a list of metric.type */
    $policy->setConditions([new Condition([
        'display_name' => 'condition-1',
        'condition_threshold' => new MetricThreshold([
            'filter' => 'resource.type = "gce_instance" AND metric.type = "compute.googleapis.com/instance/cpu/utilization"',
            'duration' => new Duration(['seconds' => '60']),
            'comparison' => ComparisonType::COMPARISON_LT,
        ])
    ])]);
    $createAlertPolicyRequest = (new CreateAlertPolicyRequest())
        ->setName($projectName)
        ->setAlertPolicy($policy);

    $policy = $alertClient->createAlertPolicy($createAlertPolicyRequest);
    printf('Created alert policy %s' . PHP_EOL, $policy->getName());
}

Python

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

def restore(project_name, backup_filename):
    """Restore alert policies in a project.

    Arguments:
        project_name (str): The Google Cloud Project to use. The project name
            must be in the format - 'projects/<PROJECT_NAME>'.
        backup_filename (str): Name of the file (along with its path) from
            which the alert policies will be restored.
    """
    print(
        "Loading alert policies and notification channels from {}.".format(
            backup_filename
        )
    )
    record = json.load(open(backup_filename, "rt"))
    is_same_project = project_name == record["project_name"]
    # Convert dicts to AlertPolicies.
    policies_json = [json.dumps(policy) for policy in record["policies"]]
    policies = [
        monitoring_v3.AlertPolicy.from_json(policy_json)
        for policy_json in policies_json
    ]
    # Convert dicts to NotificationChannels
    channels_json = [json.dumps(channel) for channel in record["channels"]]
    channels = [
        monitoring_v3.NotificationChannel.from_json(channel_json)
        for channel_json in channels_json
    ]

    # Restore the channels.
    channel_client = monitoring_v3.NotificationChannelServiceClient()
    channel_name_map = {}

    for channel in channels:
        updated = False
        print("Updating channel", channel.display_name)
        # This field is immutable and it is illegal to specify a
        # non-default value (UNVERIFIED or VERIFIED) in the
        # Create() or Update() operations.
        channel.verification_status = (
            monitoring_v3.NotificationChannel.VerificationStatus.VERIFICATION_STATUS_UNSPECIFIED
        )

        if is_same_project:
            try:
                channel_client.update_notification_channel(notification_channel=channel)
                updated = True
            except google.api_core.exceptions.NotFound:
                pass  # The channel was deleted.  Create it below.

        if not updated:
            # The channel no longer exists.  Recreate it.
            old_name = channel.name
            del channel.name
            new_channel = channel_client.create_notification_channel(
                name=project_name, notification_channel=channel
            )
            channel_name_map[old_name] = new_channel.name

    # Restore the alerts
    alert_client = monitoring_v3.AlertPolicyServiceClient()

    for policy in policies:
        print("Updating policy", policy.display_name)
        # These two fields cannot be set directly, so clear them.
        del policy.creation_record
        del policy.mutation_record

        # Update old channel names with new channel names.
        for i, channel in enumerate(policy.notification_channels):
            new_channel = channel_name_map.get(channel)
            if new_channel:
                policy.notification_channels[i] = new_channel

        updated = False

        if is_same_project:
            try:
                alert_client.update_alert_policy(alert_policy=policy)
                updated = True
            except google.api_core.exceptions.NotFound:
                pass  # The policy was deleted.  Create it below.
            except google.api_core.exceptions.InvalidArgument:
                # Annoying that API throws InvalidArgument when the policy
                # does not exist.  Seems like it should throw NotFound.
                pass  # The policy was deleted.  Create it below.

        if not updated:
            # The policy no longer exists.  Recreate it.
            old_name = policy.name
            del policy.name
            for condition in policy.conditions:
                del condition.name
            policy = alert_client.create_alert_policy(
                name=project_name, alert_policy=policy
            )
        print("Updated", policy.name)

Das erstellte AlertPolicy-Objekt enthält zusätzliche Felder. Die Richtlinie selbst hat die Felder name, creationRecord und mutationRecord. Darüber hinaus wird für jede Bedingung in der Richtlinie das Feld name angegeben. Diese Felder können nicht extern geändert werden, sodass sie beim Erstellen einer Richtlinie nicht festgelegt werden müssen. Sie sind in keinem der JSON-Beispiele zum Erstellen von Richtlinien enthalten. Wenn jedoch aus ihnen erstellte Richtlinien abgerufen werden, sind die Felder vorhanden.

Wiederholte Benachrichtigungen für messwertbasierte Benachrichtigungsrichtlinien konfigurieren

Wenn ein Vorfall geöffnet wird, sendet eine messwertbasierte Benachrichtigungsrichtlinie standardmäßig an jeden Benachrichtigungskanal eine Benachrichtigung. Sie können das Standardverhalten jedoch ändern und eine Benachrichtigungsrichtlinie so konfigurieren, dass Benachrichtigungen noch einmal an alle oder einige der Benachrichtigungskanäle für die Benachrichtigungsrichtlinie gesendet werden. Diese wiederholten Benachrichtigungen werden für Vorfälle mit dem Status „Offen“ oder „Bestätigt“ gesendet. Das Intervall zwischen diesen Benachrichtigungen muss mindestens 30 Minuten betragen und darf 24 Stunden (in Sekunden ausgedrückt) nicht überschreiten.

Wenn Sie wiederholte Benachrichtigungen konfigurieren möchten, fügen Sie der Konfiguration der Benachrichtigungsrichtlinie ein AlertStrategy-Objekt hinzu, das mindestens ein NotificationChannelStrategy-Objekt enthält. Ein NotificationChannelStrategy-Objekt hat zwei Felder:

  • renotifyInterval: das Intervall in Sekunden zwischen wiederholten Benachrichtigungen.

    Wenn Sie den Wert des Felds renotifyInterval ändern, während ein Vorfall für die Benachrichtigungsrichtlinie geöffnet ist, passiert Folgendes:

    • Die Benachrichtigungsrichtlinie sendet eine weitere Benachrichtigung für den Vorfall.
    • Das Intervall wird durch die Benachrichtigungsrichtlinie neu gestartet.

  • notificationChannelNames: ein Array von Ressourcennamen für Benachrichtigungskanäle. Das sind Strings im Format projects/PROJECT_ID/notificationChannels/CHANNEL_ID, wobei CHANNEL_ID ein numerischer Wert ist. Informationen zum Abrufen der Kanal-ID finden Sie unter Benachrichtigungskanäle in einem Projekt auflisten.

Im folgenden JSON-Beispiel wird eine Benachrichtigungsstrategie konfiguriert, durch die alle 1.800 Sekunden (30 Minuten) wiederholte Benachrichtigungen an einen Benachrichtigungskanal gesendet werden:

  "alertStrategy": {
    "notificationChannelStrategy": [
      {
        "notificationChannelNames": [
          "projects/PROJECT_ID/notificationChannels/CHANNEL_ID"
        ],
        "renotifyInterval": "1800s"
      }
    ]
  }

Wenn Sie wiederholte Benachrichtigungen vorübergehend anhalten möchten, erstellen Sie eine Pause. Wenn Sie wiederholte Benachrichtigungen vermeiden möchten, bearbeiten Sie die Benachrichtigungsrichtlinie über die API und entfernen Sie das NotificationChannelStrategy-Objekt.

Weitere Informationen