Membuat kebijakan pemberitahuan menggunakan API

Kebijakan pemberitahuan direpresentasikan di Cloud Monitoring API oleh objek AlertPolicy, yang menjelaskan serangkaian kondisi yang menunjukkan status yang berpotensi buruk di sistem Anda.

Dokumen ini menjelaskan hal berikut:

  • Cara Monitoring API menampilkan kebijakan pemberitahuan.
  • Jenis kondisi yang disediakan Monitoring API untuk kebijakan pemberitahuan.
  • Cara membuat kebijakan pemberitahuan menggunakan Google Cloud CLI atau library klien.

Struktur kebijakan pemberitahuan

Struktur AlertPolicy menentukan komponen kebijakan pemberitahuan. Saat membuat kebijakan, Anda menentukan nilai untuk kolom AlertPolicy berikut:

Anda juga dapat menentukan kolom severity saat menggunakan Cloud Monitoring API dan konsol Google Cloud. Kolom ini memungkinkan Anda menentukan tingkat keparahan insiden. Jika Anda tidak menentukan tingkat keparahan, Cloud Monitoring akan menetapkan tingkat keparahan kebijakan pemberitahuan ke No Severity.

Ada kolom lain yang dapat Anda gunakan, bergantung pada kondisi yang Anda buat.

Jika kebijakan pemberitahuan berisi satu kondisi, notifikasi akan dikirim saat kondisi tersebut terpenuhi. Untuk informasi tentang notifikasi saat kebijakan pemberitahuan berisi beberapa kondisi, lihat Kebijakan dengan beberapa kondisi dan Jumlah notifikasi per kebijakan.

Saat Anda membuat atau mengubah kebijakan pemberitahuan, Pemantauan juga menetapkan kolom lain, termasuk kolom name. Nilai kolom name adalah nama resource untuk kebijakan pemberitahuan, yang mengidentifikasi kebijakan. Nama resource memiliki format berikut:

projects/PROJECT_ID/alertPolicies/POLICY_ID

Jenis kondisi di API

Cloud Monitoring API mendukung berbagai jenis kondisi dalam struktur Condition. Ada beberapa jenis kondisi untuk kebijakan pemberitahuan berbasis metrik, dan satu untuk kebijakan pemberitahuan berbasis log. Bagian berikut menjelaskan jenis kondisi yang tersedia.

Kondisi untuk kebijakan pemberitahuan berbasis metrik

Untuk membuat kebijakan pemberitahuan yang memantau data metrik, termasuk metrik berbasis log, Anda dapat menggunakan jenis kondisi berikut:

Kondisi metrik berbasis filter

Kondisi MetricAbsence dan MetricThreshold menggunakan Filter pemantauan untuk memilih data deret waktu yang akan dipantau. Kolom lain dalam struktur kondisi menentukan cara memfilter, mengelompokkan, dan menggabungkan data. Untuk informasi selengkapnya tentang konsep ini, lihat Pemfilteran dan agregasi: memanipulasi deret waktu.

Jika menggunakan jenis kondisi MetricAbsence, Anda dapat membuat kondisi yang hanya terpenuhi jika semua deret waktu tidak ada. Kondisi ini menggunakan parameter aggregations untuk menggabungkan beberapa deret waktu menjadi satu deret waktu. Untuk mengetahui informasi selengkapnya, lihat referensi MetricAbsence dalam dokumentasi API.

Kebijakan pemberitahuan tanpa metrik mengharuskan beberapa data telah ditulis sebelumnya; untuk informasi selengkapnya, lihat Membuat kebijakan pemberitahuan tanpa metrik.

Jika Anda ingin mendapatkan notifikasi berdasarkan nilai yang diprediksi, konfigurasikan kebijakan pemberitahuan untuk menggunakan jenis kondisi MetricThreshold dan menetapkan kolom forecastOptions. Jika kolom ini tidak ditetapkan, data yang diukur akan dibandingkan dengan nilai minimum. Namun, jika kolom ini ditetapkan, data yang diprediksi akan dibandingkan dengan nilai minimum. Untuk mengetahui informasi selengkapnya, lihat Membuat kebijakan pemberitahuan nilai metrik yang diperkirakan.

Kondisi metrik berbasis MQL

Kondisi MonitoringQueryLanguageCondition menggunakan Monitoring Query Language (MQL) untuk memilih dan memanipulasi data deret waktu yang akan dipantau. Anda dapat membuat kebijakan pemberitahuan yang membandingkan nilai dengan nilai minimum atau menguji tidak adanya nilai dengan jenis kondisi ini. Jika Anda menggunakan kondisi MonitoringQueryLanguageCondition, kondisi tersebut harus menjadi satu-satunya kondisi dalam kebijakan pemberitahuan Anda. Untuk mengetahui informasi selengkapnya, lihat Kebijakan pemberitahuan dengan MQL.

Kondisi metrik berbasis PromQL

Kondisi PrometheusQueryLanguageCondition menggunakan kueri Prometheus Query Language (PromQL) untuk memilih dan memanipulasi data deret waktu yang akan dipantau. Kondisi Anda dapat menghitung rasio metrik, mengevaluasi perbandingan metrik, dan lainnya.

Jika Anda menggunakan kondisi PrometheusQueryLanguageCondition, kondisi tersebut harus menjadi satu-satunya kondisi dalam kebijakan pemberitahuan Anda. Untuk mengetahui informasi selengkapnya, lihat Kebijakan pemberitahuan dengan PromQL.

Kondisi untuk pemberitahuan rasio

Anda dapat membuat kebijakan pemberitahuan batas metrik untuk memantau rasio dua metrik. Anda dapat membuat kebijakan ini menggunakan jenis kondisi MetricThreshold atau MonitoringQueryLanguageCondition. Anda juga dapat menggunakan MQL langsung di konsol Google Cloud. Anda tidak dapat membuat atau mengelola kondisi berbasis rasio menggunakan antarmuka grafis untuk membuat kondisi nilai minimum.

Sebaiknya gunakan MQL untuk membuat kebijakan pemberitahuan berbasis rasio. MQL memungkinkan Anda membuat kueri yang lebih efektif dan fleksibel daripada yang dapat Anda buat menggunakan jenis kondisi MetricTheshold dan filter Pemantauan. Misalnya, dengan kondisi MonitoringQueryLanguageCondition, Anda dapat menghitung rasio metrik pengukur terhadap metrik delta. Untuk contoh, lihat contoh kebijakan pemberitahuan MQL.

Jika Anda menggunakan kondisi MetricThreshold, pembilang dan penyebut rasio harus memiliki MetricKind yang sama. Untuk mengetahui daftar metrik dan propertinya, lihat Daftar metrik.

Secara umum, sebaiknya hitung rasio berdasarkan deret waktu yang dikumpulkan untuk satu jenis metrik, dengan menggunakan nilai label. Rasio yang dihitung berdasarkan dua jenis metrik yang berbeda dapat mengalami anomali karena periode pengambilan sampel dan periode penyelarasan yang berbeda.

Misalnya, Anda memiliki dua jenis metrik yang berbeda, jumlah RPC total dan jumlah error RPC, dan Anda ingin menghitung rasio RPC jumlah error terhadap total RPC. RPC yang tidak berhasil dihitung dalam deret waktu dari kedua jenis metrik. Oleh karena itu, ada kemungkinan bahwa, saat Anda menyelaraskan deret waktu, RPC yang tidak berhasil tidak muncul dalam interval perataan yang sama untuk kedua deret waktu. Perbedaan ini dapat terjadi karena beberapa alasan, termasuk:

  • Karena ada dua deret waktu berbeda yang mencatat peristiwa yang sama, ada dua nilai penghitung dasar yang menerapkan pengumpulan, dan nilai tersebut tidak diperbarui secara atomik.
  • Frekuensi sampling mungkin berbeda. Jika deret waktu diselaraskan ke periode umum, jumlah untuk satu peristiwa mungkin muncul dalam interval penyesuaian yang berdekatan dalam deret waktu untuk metrik yang berbeda.

Perbedaan jumlah nilai dalam interval perataan yang sesuai dapat menyebabkan nilai rasio error/total yang tidak masuk akal seperti 1/0 atau 2/1.

Rasio angka yang lebih besar cenderung tidak menghasilkan nilai yang tidak masuk akal. Anda bisa mendapatkan angka yang lebih besar dengan agregasi, baik dengan menggunakan periode penyelarasan yang lebih lama dari periode pengambilan sampel, atau dengan mengelompokkan data untuk label tertentu. Teknik ini meminimalkan efek perbedaan kecil dalam jumlah titik dalam interval tertentu. Artinya, perbedaan dua titik lebih signifikan jika jumlah titik yang diharapkan dalam interval adalah 3 daripada jika jumlah yang diharapkan adalah 300.

Jika menggunakan jenis metrik bawaan, Anda mungkin tidak punya pilihan selain menghitung rasio di seluruh jenis metrik untuk mendapatkan nilai yang Anda butuhkan.

Jika Anda mendesain metrik kustom yang mungkin menghitung hal yang sama—seperti RPC yang menampilkan status error—dalam dua metrik yang berbeda, sebaiknya pertimbangkan metrik tunggal, yang menyertakan setiap penghitungan hanya sekali. Misalnya, Anda menghitung RPC dan ingin melacak rasio RPC yang tidak berhasil terhadap semua RPC. Untuk mengatasi masalah ini, buat satu jenis metrik untuk menghitung RPC, dan gunakan label untuk mencatat status pemanggilan, termasuk status "OK". Kemudian, setiap nilai status, error, atau "OK", dicatat dengan memperbarui satu penghitung untuk kasus tersebut.

Kondisi untuk kebijakan pemberitahuan berbasis log

Untuk membuat kebijakan pemberitahuan berbasis log, yang memberi tahu Anda saat pesan yang cocok dengan filter muncul di entri log, gunakan jenis kondisi LogMatch. Jika Anda menggunakan kondisi LogMatch, kondisi tersebut harus menjadi satu-satunya kondisi dalam kebijakan pemberitahuan Anda.

Jangan mencoba menggunakan jenis kondisi LogMatch bersama dengan metrik berbasis log. Kebijakan pemberitahuan yang memantau metrik berbasis log adalah kebijakan berbasis metrik. Untuk informasi selengkapnya tentang cara memilih antara kebijakan pemberitahuan yang memantau metrik berbasis log atau entri log, lihat Memantau log.

Kebijakan pemberitahuan yang digunakan dalam contoh di dokumen Mengelola kebijakan pemberitahuan menurut API adalah kebijakan pemberitahuan berbasis metrik, meskipun prinsipnya sama untuk kebijakan pemberitahuan berbasis log. Untuk informasi khusus tentang kebijakan pemberitahuan berbasis log, lihat Membuat kebijakan pemberitahuan berbasis log menggunakan Monitoring API dalam dokumentasi Cloud Logging.

Sebelum memulai

Sebelum menulis kode untuk API, Anda harus:

  • Pahami konsep dan terminologi umum yang digunakan dengan kebijakan pemberitahuan; lihat Ringkasan pemberitahuan untuk mengetahui informasi selengkapnya.
  • Pastikan Cloud Monitoring API diaktifkan untuk digunakan; lihat Mengaktifkan API untuk mengetahui informasi selengkapnya.
  • Jika Anda berencana menggunakan library klien, instal library untuk bahasa yang ingin Anda gunakan; lihat Library Klien untuk mengetahui detailnya. Saat ini, dukungan API untuk pemberitahuan hanya tersedia untuk C#, Go, Java, Node.js, dan Python.

  • Jika Anda berencana menggunakan Google Cloud CLI, instal. Namun, jika Anda menggunakan Cloud Shell, Google Cloud CLI sudah diinstal.

    Contoh yang menggunakan antarmuka gcloud juga disediakan di sini. Perhatikan bahwa semua contoh gcloud mengasumsikan bahwa project saat ini telah ditetapkan sebagai target (gcloud config set project [PROJECT_ID]) sehingga pemanggilan menghapus tanda --project eksplisit. ID project saat ini dalam contoh adalah a-gcp-project.

  • Untuk mendapatkan izin yang Anda perlukan guna membuat dan mengubah kebijakan pemberitahuan menggunakan Cloud Monitoring API, minta administrator untuk memberi Anda peran IAM Monitoring AlertPolicy Editor (roles/monitoring.alertPolicyEditor) di project Anda. Untuk mengetahui informasi selengkapnya tentang cara memberikan peran, lihat Mengelola akses ke project, folder, dan organisasi.

    Anda mungkin juga bisa mendapatkan izin yang diperlukan melalui peran khusus atau peran bawaan lainnya.

    Untuk mengetahui informasi mendetail tentang peran IAM untuk Pemantauan, lihat Mengontrol akses dengan Identity and Access Management.

  • Desain aplikasi Anda untuk panggilan Cloud Monitoring API single-thread yang mengubah status kebijakan pemberitahuan di project Google Cloud. Misalnya, panggilan API single-thread yang membuat, memperbarui, atau menghapus kebijakan pemberitahuan.

Membuat kebijakan pemberitahuan

Untuk membuat kebijakan pemberitahuan dalam project, gunakan metode alertPolicies.create. Untuk informasi tentang cara memanggil metode ini, parameternya, dan data respons, lihat halaman referensi alertPolicies.create.

Anda dapat membuat kebijakan dari file JSON atau YAML. Google Cloud CLI menerima file ini sebagai argumen, dan Anda dapat membaca file JSON secara terprogram, mengonversinya menjadi objek AlertPolicy, dan membuat kebijakan darinya menggunakan metode alertPolicies.create. Jika Anda memiliki file konfigurasi JSON atau YAML Prometheus dengan aturan pemberitahuan, gcloud CLI dapat memigrasikannya ke kebijakan pemberitahuan Cloud Monitoring dengan kondisi PromQL. Untuk informasi selengkapnya, lihat Memigrasikan aturan pemberitahuan dan penerima dari Prometheus.

Setiap kebijakan pemberitahuan termasuk dalam project cakupan cakupan metrik. Setiap project dapat berisi hingga 500 kebijakan. Untuk panggilan API, Anda harus memberikan “project ID”; gunakan ID project cakupan cakupan metrik sebagai nilai. Dalam contoh ini, ID project pencakupan cakupan metrik adalah a-gcp-project.

Contoh berikut mengilustrasikan pembuatan kebijakan pemberitahuan, tetapi tidak menjelaskan cara membuat file JSON atau YAML yang menjelaskan kebijakan pemberitahuan. Sebagai gantinya, contoh tersebut mengasumsikan bahwa file berformat JSON ada dan mengilustrasikan cara melakukan panggilan API. Untuk contoh file JSON, lihat Contoh kebijakan. Untuk informasi umum tentang pemantauan rasio metrik, lihat Rasio metrik.

gcloud

Untuk membuat kebijakan pemberitahuan dalam project, gunakan perintah gcloud alpha monitoring policies create. Contoh berikut membuat kebijakan pemberitahuan di a-gcp-project dari file rising-cpu-usage.json:

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

Jika berhasil, perintah ini akan menampilkan nama kebijakan baru, misalnya:

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

File rising-cpu-usage.json berisi JSON untuk kebijakan dengan nama tampilan "Rasio perubahan CPU tinggi". Untuk mengetahui detail tentang kebijakan ini, lihat Kebijakan rasio perubahan.

Lihat referensi gcloud alpha monitoring policies create untuk informasi selengkapnya.

C#

Untuk melakukan autentikasi ke Monitoring, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal. 

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

Untuk melakukan autentikasi ke Monitoring, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal. 


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

Untuk melakukan autentikasi ke Monitoring, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal. 

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

Untuk melakukan autentikasi ke Monitoring, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal. 

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

Untuk melakukan autentikasi ke Monitoring, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal. 

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

Untuk melakukan autentikasi ke Monitoring, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal. 

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)

Objek AlertPolicy yang dibuat akan memiliki kolom tambahan. Kebijakan itu sendiri akan memiliki kolom name, creationRecord, dan mutationRecord. Selain itu, setiap kondisi dalam kebijakan juga diberi name. Kolom ini tidak dapat diubah secara eksternal, sehingga tidak perlu menetapkannya saat membuat kebijakan. Tidak ada contoh JSON yang digunakan untuk membuat kebijakan yang menyertakannya, tetapi jika kebijakan yang dibuat darinya diambil setelah pembuatan, kolom tersebut akan ada.

Mengonfigurasi notifikasi berulang untuk kebijakan pemberitahuan berbasis metrik

Secara default, kebijakan pemberitahuan berbasis metrik mengirimkan satu notifikasi ke setiap saluran notifikasi saat insiden dibuka. Namun, Anda dapat mengubah perilaku default dan mengonfigurasi kebijakan pemberitahuan untuk mengirim ulang notifikasi ke semua atau beberapa saluran notifikasi untuk kebijakan pemberitahuan Anda. Notifikasi berulang ini dikirim untuk insiden dengan status Terbuka atau Dikonfirmasi. Interval antara notifikasi ini harus minimal 30 menit dan tidak lebih dari 24 jam, dinyatakan dalam detik.

Untuk mengonfigurasi notifikasi berulang, tambahkan objek AlertStrategy yang berisi setidaknya satu objek NotificationChannelStrategy ke konfigurasi kebijakan pemberitahuan. Objek NotificationChannelStrategy memiliki dua kolom:

  • renotifyInterval: Interval, dalam detik, antara notifikasi berulang.

    Jika Anda mengubah nilai kolom renotifyInterval saat insiden untuk kebijakan pemberitahuan dibuka, hal berikut akan terjadi:

    • Kebijakan pemberitahuan akan mengirimkan notifikasi lain untuk insiden tersebut.
    • Kebijakan pemberitahuan memulai ulang periode interval.

  • notificationChannelNames: Array nama resource saluran notifikasi, yang merupakan string dalam format projects/PROJECT_ID/notificationChannels/CHANNEL_ID, dengan CHANNEL_ID adalah nilai numerik. Untuk informasi tentang cara mengambil ID saluran, lihat Mencantumkan saluran notifikasi dalam project.

Misalnya, contoh JSON berikut menunjukkan strategi pemberitahuan yang dikonfigurasi untuk mengirim notifikasi berulang setiap 1.800 detik (30 menit) ke satu saluran notifikasi:

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

Untuk menghentikan notifikasi berulang untuk sementara, buat penundaan. Untuk mencegah notifikasi berulang, edit kebijakan pemberitahuan menggunakan API dan hapus objek NotificationChannelStrategy.

Langkah selanjutnya