Crea políticas de alertas con la API

Una política de alertas se representa en la API de Cloud Monitoring con un objeto AlertPolicy, que describe un conjunto de condiciones que indican un estado potencialmente en mal estado en tu sistema.

En este documento, se describe lo siguiente:

  • Cómo la API de Monitoring representa las políticas de alertas
  • Los tipos de condiciones que proporciona la API de Monitoring para las políticas de alertas
  • Cómo crear una política de alertas con Google Cloud CLI bibliotecas cliente.

Estructura de una política de alertas

La estructura AlertPolicy define los componentes de una política de alertas. Cuando creas una política, especificas valores para el los siguientes campos AlertPolicy:

  • displayName: Es una etiqueta descriptiva para la política.
  • documentation: Te recomendamos que uses este campo para proporcionar información que ayude a los equipos de respuesta a incidentes. Para obtener más información, consulta Cómo anotar notificaciones con documentación definida por el usuario.
  • userLabels: Cualquier etiqueta definida por el usuario adjunta a la política. Información sobre el uso de etiquetas con alertas, consulta Anota incidentes con etiquetas.
  • conditions[]: Es un array de estructuras Condition.
  • combiner: Es un operador lógico que determina cómo controlar varias condiciones.
  • notificationChannels[]: Es un array de nombres de recursos, cada uno de los cuales identifica una NotificationChannel
  • alertStrategy: Especifica lo siguiente:
    • La rapidez con la que Monitoring cierra los incidentes cuando dejan de llegar datos
    • Para las políticas de alertas basadas en métricas, ya sea y envía una notificación cuando se cierra un incidente.
    • Para las políticas de alertas basadas en métricas, si están habilitadas las notificaciones repetidas y el intervalo entre ellas. Para obtener más información, consulta Configura notificaciones repetidas para políticas de alertas basadas en métricas.

También puedes especificar el campo severity cuando usas la API de Cloud Monitoring y la consola de Google Cloud. Este campo te permite definir el nivel de gravedad de de seguridad sobre posibles incidentes. Si no especificas una gravedad, Luego, Cloud Monitoring establece la gravedad de la política de alertas en No Severity.

Existen otros campos que puedes usar, según las condiciones que crees.

Cuando una política de alertas contiene una condición, se envía una notificación cuando se cumple esa condición. Para obtener información sobre las notificaciones cuando las políticas de alertas contienen varias condiciones, consulta Políticas con varias condiciones y Cantidad de notificaciones por política.

Cuando creas o modificas la política de alertas, Monitoring otros campos también, incluido el campo name. El valor del campo name es el nombre del recurso de la política de alertas, que la identifica. El nombre del recurso tiene el siguiente formato:

projects/PROJECT_ID/alertPolicies/POLICY_ID

Tipos de condiciones en la API

La API de Cloud Monitoring admite varios tipos de condiciones en la Estructura de Condition. Existen varios tipos de condiciones para las políticas de alertas basadas en métricas y uno para las políticas de alertas basadas en registros. En las siguientes secciones, se describen los tipos de condiciones disponibles.

Condiciones para las políticas de alertas basadas en métricas

Para crear una política de alertas que supervise los datos de las métricas, incluidas las métricas puedes usar los siguientes tipos de condiciones:

Condiciones de métricas basadas en filtros

Las condiciones MetricAbsence y MetricThreshold usan Filtros de supervisión para seleccionar los datos de series temporales para supervisar. Otros campos en la estructura de condición especifican cómo filtrar, agrupar y agregar los datos. Para obtener más información sobre estos conceptos, consulta Filtrado y agregación: manipulación de series temporales.

Si usas el tipo de condición MetricAbsence, puedes crear una condición. que se cumple solo cuando todas las series temporales están ausentes. Esta condición usa el parámetro aggregations para agregar varias series temporales en una sola. Para obtener más información, consulta la referencia de MetricAbsence en la documentación de la API.

Una política de alertas de ausencia de métricas requiere que se hayan escrito algunos datos previamente. Para obtener más información, consulta Crea políticas de alertas de ausencia de métricas.

Si quieres recibir notificaciones según un valor previsto, configura tu política de alertas para usar Tipo de condición MetricThreshold y para establecer forecastOptions . Cuándo si no se establece este campo, los datos medidos se comparan con un umbral. Sin embargo, cuando se establece este campo, los datos previstos se comparan con un umbral. Para obtener más información, consulta Crea políticas de alertas de valores de métricas previstos.

Condiciones de métricas basadas en MQL

La condición MonitoringQueryLanguageCondition usa el lenguaje de consulta de Monitoring (MQL) para seleccionar y manipular los datos de series temporales que se supervisarán. Puedes crear políticas de alertas que comparen valores con un umbral o prueben la ausencia de valores con este tipo de condición. Si usas una condición MonitoringQueryLanguageCondition, debe ser la única en tu política de alertas. Para obtener más información, consulta Políticas de alertas con MQL.

Condiciones de métricas basadas en PromQL

La condición PrometheusQueryLanguageCondition usa consultas del lenguaje de consulta de Prometheus (PromQL) para seleccionar y manipular los datos de series temporales que se supervisarán. Tu condición puede calcular una proporción de métricas, evaluar comparaciones de métricas y mucho más.

Si usas una condición PrometheusQueryLanguageCondition, esta debe ser la única condición en tu política de alertas. Para obtener más información, consulta Políticas de alertas con PromQL.

Condiciones para alertar sobre proporciones

Puedes crear políticas de alertas de límite de métrica para supervisar la proporción de dos métricas. Puedes crear estas políticas con El tipo de condición MetricThreshold o MonitoringQueryLanguageCondition. También puedes usar MQL directamente en la consola de Google Cloud. No puedes crear o administrar condiciones basadas en razones usando la interfaz gráfica para crear de las condiciones de umbral.

Recomendamos usar MQL para crear políticas de alertas basadas en la proporción. MQL te permite compilar consultas más potentes y flexibles de las que puedes compilar con el tipo de condición MetricTheshold Filtros de supervisión. Por ejemplo, con una condición MonitoringQueryLanguageCondition, puedes calcular la proporción de una métrica de indicador a una métrica delta. Para ver ejemplos, consulta los ejemplos de políticas de alertas de MQL.

Si usas la condición MetricThreshold, el numerador y el denominador de la proporción debe tener el mismo MetricKind. Para obtener una lista de métricas y sus propiedades, consulta Listas de métricas.

En general, es mejor calcular las proporciones según las series temporales recopiladas para un solo tipo de métrica mediante el uso de valores de etiquetas. Una proporción calculada sobre dos los diferentes tipos de métricas están sujetos a anomalías debido a diversos los puntos y las ventanas de alineación.

Por ejemplo, supongamos que tienes dos tipos de métricas, un recuento total de RPC y un recuento de errores de RPC, y deseas calcular la proporción de las RPC del recuento de errores sobre el total de RPC. Las RPC con errores se cuentan en las series temporales de ambos tipos de métricas. Por lo tanto, existe la posibilidad de que, cuando alinees el tiempo, serie, una RPC fallida no aparece en el mismo intervalo de alineación para en ambas series temporales. Esta diferencia puede ocurrir por varias razones, incluidas las siguientes:

  • Debido a que hay dos series temporales diferentes que graban el mismo evento, no hay dos valores de contador subyacentes que implementan la colección, no se actualizan de forma atómica.
  • Las tasas de muestreo pueden variar. Cuando las series temporales se alinean con una política de entrada, los recuentos de un solo evento pueden aparecer en la alineación adyacente en las series temporales para las diferentes métricas.

La diferencia en la cantidad de valores en los intervalos de alineación correspondientes puede generar valores de proporción error/total sin sentido, como 1/0 o 2/1.

Es menos probable que las proporciones de números más grandes generen valores sin sentido. Puedes obtener números más grandes por agregación, ya sea mediante una ventana de alineación más larga que el período de muestreo o mediante la agrupación de datos para ciertas etiquetas. Estas técnicas minimizan el efecto de las pequeñas diferencias en el la cantidad de puntos en un intervalo determinado. Es decir, una disparidad de dos puntos es más significativo cuando la cantidad esperada de puntos en un intervalo es 3 que cuando el número esperado es 300.

Si usas tipos de métricas integradas, es posible que no tengas más opción que calcular las proporciones entre los tipos de métricas para obtener el valor que necesitas.

Si diseñas métricas personalizadas que pueden contar lo mismo, como las RPC que muestran el estado del error, en dos métricas diferentes, considera una sola métrica, que incluye cada recuento solo una vez. Por ejemplo, supongamos que estás contando las RPC y quieres hacer un seguimiento de la proporción a todos los RPC. Para resolver este problema, crea un tipo de métrica único para contar las RPC y usa una etiqueta para registrar el estado de la invocación, incluido el estado “Correcto”. Luego, cada valor de estado, “OK” o “error” se registra actualizando un solo contador para ese caso.

Condición para políticas de alertas basadas en registros

Para crear una política de alertas basada en registros, que te notifique cuando un mensaje que coinciden con tu filtro aparece en tus entradas de registro, usa el Tipo de condición LogMatch. Si usas una condición LogMatch, esta debe ser la única condición en tu política de alertas.

No intentes usar el tipo de condición LogMatch junto con las variables métricas. Las políticas de alertas que supervisan las métricas basadas en registros se basan en y políticas de seguridad. Para obtener más información sobre cómo elegir entre políticas de alertas que supervisen métricas o entradas de registro basadas en registros, consulta Supervisa tus registros.

Las políticas de alertas usadas en los ejemplos en la El documento Administrar políticas de alertas por API se basa en métricas. alertas políticas, aunque los principios son los mismos para las políticas de alertas basadas en registros. Para obtener información específica sobre las políticas de alertas basadas en registros, consulta Crea una política de alertas basada en registros con la API de Monitoring en la documentación de Cloud Logging.

Antes de comenzar

Antes de escribir el código en la API, debes cumplir con lo siguiente:

  • Estar familiarizado con los conceptos generales y la terminología que se usa con las alertas policies; consulta Descripción general de las alertas para obtener más información información.
  • Asegúrate de que la API de Cloud Monitoring esté habilitada para su uso. Consulta Cómo habilitar la API para obtener más información.
  • Si planeas usar bibliotecas cliente, instálalas para el los idiomas que quieres usar; ver Consulta las bibliotecas cliente para obtener más información. Actualmente, la asistencia de la API para alertas está disponible solo para C#, Go, Java, Node.js y Python.

  • Si planeas usar Google Cloud CLI, instálala. Sin embargo, si usas Cloud Shell, Google Cloud CLI ya está instalada.

    También se proporcionan aquí los ejemplos que usan la interfaz de gcloud. Ten en cuenta que en los ejemplos de gcloud se da por sentado que el proyecto actual ya se estableció como el objetivo (gcloud config set project [PROJECT_ID]), por lo que las invocaciones omiten la marca --project explícita. El ID del proyecto actual en los ejemplos es a-gcp-project.

  • Para obtener los permisos que necesitas para crear y modificar políticas de alertas con la API de Cloud Monitoring, pídele a tu administrador que te otorgue el rol de IAM de editor de AlertPolicy de Monitoring (roles/monitoring.alertPolicyEditor) en tu proyecto. Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

    También puedes obtener los permisos necesarios mediante roles personalizados o cualquier otro rol predefinido.

    Para obtener información detallada sobre los roles de IAM Monitoring, consulta Controla el acceso con Identity and Access Management.

  • Diseña tu aplicación para que realice llamadas a la API de Cloud Monitoring en un subproceso que modiquen el estado de una política de alertas en un proyecto de Google Cloud. Por ejemplo, llamadas a la API de subproceso único que crean, actualizan o borran una política de alertas.

Crea una política de alertas

Para crear una política de alertas en un proyecto, usa el alertPolicies.create. Para obtener información sobre cómo invocar esta de la aplicación, sus parámetros y los datos de respuesta, consulta la página de referencia alertPolicies.create

Puedes crear políticas desde archivos JSON o YAML. Google Cloud CLI acepta estos archivos como argumentos. puedes leer archivos JSON de manera programática y convertirlos en AlertPolicy objetos y crearás políticas a partir de ellos Mediante el método alertPolicies.create Si tienes un archivo de configuración JSON o YAML de Prometheus con una regla de alerta, gcloud CLI puede migrarla a una alerta de Cloud Monitoring política con una condición PromQL. Para obtener más información, consulta Migra las reglas de alerta y los receptores de Prometheus.

Cada política de alertas pertenece a un proyecto de permisos de un permiso de métricas. Cada proyecto puede contener hasta 500 políticas. Para las llamadas a la API, debes proporcionar un “ID del proyecto”. usa el Es el ID del proyecto de permisos de un permiso de métricas como el valor. En estos ejemplos, el ID del proyecto de permisos de un permiso de métricas es a-gcp-project.

En los siguientes ejemplos, se ilustra la creación de políticas de alertas, pero no se describe cómo crear un archivo JSON o YAML que describa una política de alertas. En cambio, los ejemplos suponen que un archivo con formato JSON y muestran cómo emitir la llamada a la API. Por ejemplo, archivos JSON, consulta Ejemplos de políticas. Para obtener información general sobre la supervisión de las proporciones de las métricas, consulta Proporciones de las métricas.

gcloud

Para crear una política de alertas en un proyecto, usa el comando gcloud alpha monitoring policies create. En el siguiente ejemplo, se crea una política de alertas en a-gcp-project del archivo rising-cpu-usage.json:

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

Si funciona, este comando muestra el nombre de la política nueva, por ejemplo:

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

El archivo rising-cpu-usage.json contiene el JSON de una política con el nombre visible “Tasa de cambio de CPU alta”. Para obtener más información sobre esta política, consulta Política de tasa de cambio.

Consulta la referencia de gcloud alpha monitoring policies create para obtener más información.

C#

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

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

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 


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

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

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

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

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

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

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

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

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)

El objeto AlertPolicy creado tendrá campos adicionales. La política en sí tendrá los campos name, creationRecord y mutationRecord. Además, cada condición en la política también recibe un name. Estos campos no pueden modificarse de forma externa, por lo que no es necesario configurarlos cuando creas una política. Ninguno de los ejemplos de JSON usados para crear políticas los incluye, pero si las políticas creadas a partir de ellas se recuperan después de la creación, los campos estarán presentes.

Configura notificaciones repetidas para las políticas de alertas basadas en métricas

De forma predeterminada, una política de alertas basada en métricas envía una notificación a cada canal de notificación cuando se abre un incidente. Sin embargo, puedes cambiar el comportamiento predeterminado y configurar una política de alertas para volver a enviar notificaciones a todos o algunos de los canales de notificaciones de tu política de alertas. Estas notificaciones repetidas se envían para incidentes con el estado Abierto o Recibido. El intervalo entre estas notificaciones debe ser de 30 minutos como mínimo y no más de 24 horas, expresada en segundos.

Para configurar notificaciones repetidas, agrega a la configuración de la política de alertas un objeto AlertStrategy que contenga al menos un objeto NotificationChannelStrategy. Un objeto NotificationChannelStrategy tiene dos campos:

  • renotifyInterval: El intervalo, en segundos, entre notificaciones.

    Si cambias el valor del campo renotifyInterval cuando cuando se abre un incidente para la política de alertas, sucede lo siguiente:

    • La política de alertas envía otro para informar sobre el incidente.
    • La política de alertas reinicia el período del intervalo.

  • notificationChannelNames: Es un array de nombres de recursos de canales de notificación, que son cadenas con el formato projects/PROJECT_ID/notificationChannels/CHANNEL_ID, en el que CHANNEL_ID es un valor numérico. Para más información sobre cómo recuperar el ID del canal, consulta Enumera los canales de notificaciones en un proyecto.

En la siguiente muestra de JSON, se muestra una estrategia de alerta configurada para enviar notificaciones repetidas cada 1,800 segundos (30 minutos) a un canal de notificaciones:

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

Para detener temporalmente las notificaciones repetidas, crea una pospuesta. Para evitar notificaciones repetidas, edita la política de alertas con la API y quita el objeto NotificationChannelStrategy.

¿Qué sigue?