Membuat kebijakan pemberitahuan menggunakan API

Kebijakan pemberitahuan diwakili dalam Cloud Monitoring API oleh objek AlertPolicy, yang menjelaskan serangkaian kondisi yang menunjukkan status sistem Anda yang berpotensi tidak sehat.

Dokumen ini menjelaskan hal berikut:

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

Fitur ini hanya didukung untuk Google Cloud project. Untuk konfigurasi App Hub, pilih project host App Hub atau project pengelolaan folder yang mendukung aplikasi.

Struktur kebijakan pemberitahuan

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

• displayName: Label deskriptif untuk kebijakan.
• documentation: Sebaiknya gunakan kolom ini untuk memberikan informasi yang membantu petugas penanganan insiden. Untuk mengetahui informasi selengkapnya, lihat Memberikan anotasi pada notifikasi menggunakan dokumentasi yang ditentukan pengguna.

• userLabels: Label yang ditentukan pengguna yang dilampirkan ke kebijakan. Kebijakan pemberitahuan, insiden, dan notifikasi menampilkan label ini. Untuk mengetahui informasi tentang penggunaan label dengan pemberitahuan, lihat Anotasi insiden dengan label.

• conditions[]: Array struktur Condition.

• combiner: Operator logika yang menentukan cara menangani beberapa kondisi.

• notificationChannels[]: array nama resource, yang masing-masing mengidentifikasi NotificationChannel.

• alertStrategy: Menentukan hal berikut:

  • Seberapa cepat Monitoring menutup insiden saat data berhenti diterima.
  • Untuk kebijakan pemberitahuan berbasis metrik, apakah Monitoring mengirimkan notifikasi saat insiden ditutup.
  • Untuk kebijakan pemberitahuan berbasis metrik, apakah notifikasi berulang diaktifkan, dan interval antara notifikasi tersebut. Untuk mengetahui informasi selengkapnya, lihat Mengonfigurasi notifikasi berulang untuk kebijakan pemberitahuan berbasis metrik.

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 mengetahui 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, Monitoring juga akan 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

Pada ekspresi sebelumnya:

• PROJECT_ID: ID project. Untuk konfigurasi App Hub, pilih project host App Hub atau project pengelolaan folder yang mendukung aplikasi.
• POLICY_ID: ID kebijakan pemberitahuan

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:

• MetricAbsence
• MetricThreshold
• MonitoringQueryLanguageCondition
• PrometheusQueryLanguageCondition

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 mengagregasi data. Untuk mengetahui informasi selengkapnya tentang konsep ini, lihat Pemfilteran dan agregasi: memanipulasi deret waktu.

Jika Anda menggunakan jenis kondisi MetricAbsence, Anda dapat membuat kondisi yang terpenuhi hanya 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 mengetahui informasi selengkapnya, lihat Membuat kebijakan pemberitahuan tanpa metrik.

Jika Anda ingin mendapatkan notifikasi berdasarkan nilai perkiraan, konfigurasi kebijakan pemberitahuan Anda untuk menggunakan jenis kondisi MetricThreshold dan menetapkan kolom forecastOptions. Jika kolom ini tidak ditetapkan, data yang diukur akan dibandingkan dengan nilai minimum. Namun, saat 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 Bahasa Kueri Monitoring (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 tentang 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 secara 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 dengan menggunakan jenis kondisi MetricTheshold dan filter Pemantauan. Misalnya, dengan kondisi MonitoringQueryLanguageCondition, Anda dapat menghitung rasio metrik pengukur dengan 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 untuk dua jenis metrik yang berbeda dapat mengalami anomali karena periode pengambilan sampel dan jendela perataan yang berbeda.

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

• Karena ada dua deret waktu yang berbeda yang mencatat peristiwa yang sama, ada dua nilai penghitung pokok yang menerapkan pengumpulan, dan nilai tersebut tidak diperbarui secara atomik.
• Frekuensi pengambilan sampel mungkin berbeda. Jika deret waktu diselaraskan dengan periode yang sama, jumlah untuk satu peristiwa mungkin muncul dalam interval penyelarasan yang berdekatan dalam deret waktu untuk metrik yang berbeda.

Perbedaan jumlah nilai dalam interval penyelarasan 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 jendela penyelarasan yang lebih panjang daripada 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 poin lebih signifikan jika jumlah poin yang diharapkan dalam interval adalah 3 daripada jika jumlah yang diharapkan adalah 300.

Jika Anda 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 gunakan satu metrik, yang hanya menyertakan setiap hitungan satu kali. 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 Anda 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 mengetahui informasi selengkapnya tentang cara memilih antara kebijakan pemberitahuan yang memantau metrik berbasis log atau entri log, lihat Memantau log Anda.

Kebijakan pemberitahuan yang digunakan dalam contoh di dokumen Mengelola kebijakan pemberitahuan dengan 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.

Cara mengaitkan kebijakan pemberitahuan dengan aplikasi App Hub

Google Cloud membuat dasbor yang membantu Anda memantau aplikasi App Hub. Dasbor ini menampilkan informasi seperti data log dan metrik untuk aplikasi Anda, serta layanan dan beban kerja yang merupakan bagian dari aplikasi. Kebijakan pemberitahuan dan insidennya juga ditampilkan di dasbor ini, jika kebijakan tersebut dikaitkan dengan layanan atau beban kerja aplikasi. Untuk mengetahui informasi selengkapnya tentang Pemantauan Aplikasi, lihat Melihat telemetri aplikasi.

Untuk mengaitkan kebijakan pemberitahuan dengan aplikasi App Hub, lampirkan label dengan kunci berikut ke kebijakan Anda:

• apphub_application_location
• apphub_application_id
• apphub_service_id atau apphub_workload_id

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

Sebelum memulai

Sebelum menulis kode terhadap 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. Dukungan API untuk pemberitahuan hanya tersedia untuk C#, Go, Java, Node.js, dan Python.

• Jika Anda berencana menggunakan Google Cloud CLI, instal terlebih dahulu. 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 tidak menyertakan tanda --project eksplisit. ID project saat ini dalam contoh adalah a-gcp-project. Untuk konfigurasi App Hub, pilih project host App Hub atau project pengelolaan folder yang mendukung aplikasi.

• Untuk mendapatkan izin yang diperlukan guna membuat dan mengubah kebijakan pemberitahuan menggunakan Cloud Monitoring API, minta administrator Anda 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 Monitoring, lihat Mengontrol akses dengan Identity and Access Management.

• Rancang aplikasi Anda untuk membuat panggilan Cloud Monitoring API ber-thread tunggal yang mengubah status kebijakan pemberitahuan dalam projectGoogle Cloud . Misalnya, panggilan API berutas tunggal yang membuat, memperbarui, atau menghapus kebijakan pemberitahuan.

Membuat kebijakan pemberitahuan

Untuk membuat kebijakan pemberitahuan dalam project, gunakan metode alertPolicies.create. Untuk mengetahui 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 dari file tersebut dengan 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 mengetahui informasi selengkapnya, lihat Memigrasikan aturan pemberitahuan dan penerima dari Prometheus.

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

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

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

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

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);
    }
}

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

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()));
    }
  }
}

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();

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());
}

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, jadi tidak perlu menetapkannya saat membuat kebijakan. Tidak ada contoh JSON yang digunakan untuk membuat kebijakan yang menyertakannya, tetapi jika kebijakan yang dibuat dari contoh JSON tersebut diambil setelah pembuatan, kolom 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 maksimal 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 yang berulang.

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

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

• notificationChannelNames: Array nama resource saluran notifikasi, yang berupa string dalam format projects/PROJECT_ID/notificationChannels/CHANNEL_ID, dengan CHANNEL_ID adalah nilai numerik. Untuk mengetahui 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 berikutnya

• Mengelola kebijakan pemberitahuan menurut API
• Membuat dan mengelola saluran notifikasi melalui API