יצירה וניהול של ערוצי התראות באמצעות API

במסמך הזה מוסבר איך ליצור ולנהל ערוצי התראות באמצעות ספריות לקוח או באמצעות Google Cloud CLI. שתי האפשרויות האלה מפעילות את Cloud Monitoring API. מערכת Cloud Monitoring משתמשת בערוצי התראות כדי להודיע לכם או לצוות התמיכה שלכם כשמתקיים התנאי של מדיניות התראות. יש כמה סוגים של ערוצים זמינים. כל סוג מתואר בתיאור של ערוץ ההתראות. ערוץ התראות מסוג מסוים הוא מופע של המתאר של אותו סוג. מדיניות ההתראות כוללת הפניות לערוצי ההתראות שבהם יש להשתמש כנתיבי התראות.

כדי להשתמש בערוץ התראות במדיניות התראות, צריך ליצור אותו קודם. מתקבלים תיאורים של ערוצי ההתראות, אבל צריך ליצור את הערוצים לפני שאפשר להשתמש בהם.

במאמר יצירה וניהול של ערוצי התראות מוסבר איך מגדירים ערוצי התראות באמצעות מסוף Google Cloud .

דוגמאות הקוד שמופיעות במסמך הזה נלקחו מדוגמה של API של מדיניות התראות, שמתוארת במאמר דוגמה: גיבוי ושחזור.

מידע על ה-API

המשאב NotificationChannel תומך בפעולות שמאפשרות לכם לנהל את ערוצי ההתראות. הוא תומך גם בפעולות שקשורות לניהול השדה verificationStatus של ערוץ:

  • שליחת קוד אימות
  • יצירת קוד להעתקת סטטוס האימות של ערוץ מאומת לערוצים זהים אחרים באותו פרויקט או בפרויקט חדש
  • אימות הערוץ באמצעות הקוד שנוצר בשתי הפעולות הקודמות

מידע נוסף זמין במסמכי העיון של notificationChannels.

לפני שמתחילים

רשימת הסוגים של ערוצי התראות

ב-Monitoring יש מספר סוגים מובנים של ערוצי התראות. כל אחד מהסוגים האלה מתואר בNotificationChannelDescriptor. למתארים האלה יש שדה type, והערך של השדה הזה משמש כמזהה כשיוצרים מופעים של סוג הערוץ הזה. כדי לאחזר רשימה של סוגי ערוצים שאפשר ליצור באמצעות Cloud Monitoring API או Google Cloud CLI, מזינים את הפקודה הבאה:

$ gcloud beta monitoring channel-descriptors list --format='value(type)'
campfire
email
google_chat
hipchat
pagerduty
pubsub
slack
sms
webhook_basicauth
webhook_tokenauth

מידע נוסף על ערוצי התראות זמין במאמר יצירה וניהול של ערוצי התראות.

אם ערוץ ההתראות המועדף שלכם לא נתמך, כדאי ליצור צינור שמתבסס על שליחת ההתראות ל-Pub/Sub. דוגמה ל-Python שמשתמשת ב-Flask זמינה במאמר יצירת התראות בהתאמה אישית באמצעות Cloud Monitoring ו-Cloud Run. דוגמאות נוספות זמינות במאגר Git של העברת התראות מ-Cloud.

כדי לאחזר את כל תיאורי הערוצים בפרויקט Google Cloud , משתמשים בשיטה notificationChannelDescriptors.list. המתארים שאוחזרו הם לקריאה בלבד.

אם אתם מחפשים תיאור ספציפי ואתם יודעים את השם שלו, אתם יכולים להשתמש בשיטה notificationChannelDescriptors.get כדי לאחזר רק את תיאור הערוץ הזה. השם של מתאר הערוץ הוא בפורמט projects/[PROJECT_ID]/notificationChannelDescriptors/[CHANNEL_TYPE]. [CHANNEL_TYPE] חייב להיות אחד מהסוגים שצוינו קודם. לדוגמה:

projects/[PROJECT_ID]/notificationChannelDescriptors/email

gcloud

כדי לראות את כל התיאורים של ערוצי ההתראות בפרויקט Google Cloud , משתמשים בפקודה gcloud beta monitoring channel-descriptors list:

gcloud beta monitoring channel-descriptors list

אם הפקודה list מסתיימת ללא שגיאות, היא מחזירה רשימה של כל תיאורי הערוצים בפרויקט שצוין. לדוגמה, תיאור הערוץ email יופיע ברשימה כך:

    ---
    description: A channel that sends notifications via email.
    displayName: Email
    labels:
    - description: An address to send email.
      key: email_address
    name: projects/[PROJECT_ID]/notificationChannelDescriptors/email
    type: email
    ---

כל תיאורי הערוצים כוללים את השדות הבאים:

  • ‫name: שם המשאב המלא של מתאר הערוץ
  • ‫type: החלק בשם שמציין את סוג הערוץ
  • ‫displayName: תיאור של השדה type, למטרות תצוגה
  • ‫description: תיאור קצר של הערוץ
  • ‫labels: קבוצה של שדות שספציפיים לסוג הערוץ. לכל סוג ערוץ יש קבוצה משלו של תוויות.

כשיוצרים ערוץ, נוצר גם שדה enabled עם הערך true כברירת מחדל.

כדי לציין מתאר ערוץ יחיד, משתמשים ב-gcloud beta monitoring channel-descriptors describe ומציינים את השם של מתאר הערוץ. אין צורך לציין את השם המוגדר במלואו. לדוגמה, שתי הפקודות האלה מחזירות את הרישום שלמעלה:

gcloud beta monitoring channel-descriptors describe email

gcloud beta monitoring channel-descriptors describe projects/[PROJECT_ID]/notificationChannelDescriptors/email

מידע נוסף זמין במאמרים בנושא gcloud beta monitoring channel-descriptors list וdescribe. הפקודה describe תואמת ל-method notificationChannelDescriptors.get ב-API.

יצירת ערוץ התראות

אפשר ליצור ערוצי התראות עבור פרויקטים ב- Google Cloud באמצעות קובצי JSON או YAML באמצעות Google Cloud CLI, ואפשר גם ליצור אותם באופן פרוגרמטי.

כדי ליצור ערוץ התראות, צריך לספק ערכים לשדות בתיאור שלו. רובם, כמו type, נפוצים בכל תיאורי ערוצי ההתראות. אפשר לעיין בnotificationChannelDescriptors.

לכל תיאור יש גם קבוצה של תוויות, והקבוצה הזו משתנה בין התיאורים. כדי לראות את קבוצת התוויות של מתאר מסוים, מאחזרים את המתאר באמצעות הפקודה gcloud beta monitoring channel-descriptors describe שמתוארת במאמר רשימת סוגי ערוצי ההתראות. לדוגמה, כשמאחזרים את תיאור הערוץ email מוצגת תווית אחת:

    labels:
    - description: An address to send email.
      key: email_address

‫pubsub channel descriptor מכיל גם תווית אחת שמזהה את נושא ה-Pub/Sub. עם זאת, ערוצים יכולים להכיל כמה תוויות. לדוגמה, לתיאור הערוץ slack יש שתי תוויות:

    labels:
    - description: A permanent authentication token provided by Slack. This field is obfuscated by returning only a few characters of the key when fetched.
      key: auth_token
    - description: The Slack channel to which to post notifications.
      key: channel_name

אחזור של תיאור הערוץ webhook_basicauth מציג כמה תוויות:

    labels:
    - description: The password. The field is obfuscated when the channel is fetched.
      key: password
    - description: The public URL to which to publish the webhook.
      key: url
    - description: The username.
      key: username

בין אם יוצרים ערוץ חדש באופן פרוגרמטי או משורת הפקודה, הערך של type במפרט צריך להיות זהה לערך של השדה type בתיאור המתאים של ערוץ ההתראות. מפתחות התוויות הנדרשים צריכים להיות זהים לאלה שמופיעים בתיאור הערוץ.

חלק מהתוויות תואמות לפרטי הכניסה שמשמשים לאימות מול הספק. כשיוצרים ערוץ, צריך לקבל את הערכים של התוויות האלה מהספק. כדי לקבל פרטי כניסה, יכול להיות שתצטרכו להשתמש בדף ליצירת מפתח API באתר של הספק או להשלים תהליך כניסה באמצעות OAuth אצל הספק. הפרטים הספציפיים לגבי קבלת פרטי כניסה כאלה תלויים בספק המסוים.

לדוגמה, הקטע הבא מציג את ההגדרה של ערוץ התראות חדש pubsub ב-JSON:

    {
      "type": "pubsub",
      "displayName": "Notifications",
      "description": "Pub/Sub channel for notifications",
      "labels": {
        "topic": "projects/[PROJECT_ID]/topics/notificationTopic"
      },
    }

הערך type (pubsub) ומפתח התווית היחיד (topic) תואמים לשדות type ו-labels.key בתיאור הערוץ המתאים.

הערוצים מופעלים כברירת מחדל. אם רוצים ליצור ערוץ לא פעיל, אפשר לכלול את השדה enabled עם הערך false.

בדוגמאות הבאות מוסבר איך ליצור ערוצי התראות.

gcloud

כדי ליצור ערוץ התראות בפרויקט Google Cloud , משתמשים בפקודה gcloud beta monitoring channels create. כדי לטעון את הערוץ מקובץ, משתמשים בדגל --channel-content-from-file כדי לציין את הקובץ.

בדוגמה הבאה נוצר ערוץ Pub/Sub חדש מקובץ pubsub-channel.json:

gcloud beta monitoring channels create --channel-content-from-file="pubsub-channel.json"

אם הפקודה מסתיימת ללא שגיאות, היא מחזירה את השם של הערוץ החדש, למשל:

    Created notification channel [projects/[PROJECT_ID]/notificationChannels/1355376463305411567].

מידע נוסף זמין במפרט של השיטה ב-gcloud beta monitoring channels create.

C#

כדי לבצע אימות ב-Monitoring, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית. 

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)
    {
        try
        {
            bool updated = false;
            Console.WriteLine("Updating channel.\n{0}",
                channel.DisplayName);
            // This field is immutable and it is illegal to specify a
            // non-default value (UNVERIFIED or VERIFIED) in the
            // Create() or Update() operations.
            channel.VerificationStatus = NotificationChannel.Types
                .VerificationStatus.Unspecified;
            if (isSameProject)
                try
                {
                    channelClient.UpdateNotificationChannel(
                        null, channel);
                    updated = true;
                }
                catch (Grpc.Core.RpcException e)
                when (e.Status.StatusCode == StatusCode.NotFound)
                { }
            if (!updated)
            {
                // The channel no longer exists.  Recreate it.
                string oldName = channel.Name;
                channel.Name = null;
                var response = channelClient.CreateNotificationChannel(
                    projectName, channel);
                channelNameMap.Add(oldName, response.Name);
            }
        }
        catch (Exception e)
        {
            // If one failed, continue trying to update the others.
            exceptions.Add(e);
        }
    }
    foreach (AlertPolicy policy in backup.Policies)
    {
    }
    if (exceptions.Count > 0)
    {
        throw new AggregateException(exceptions);
    }
}

Node.js

כדי לבצע אימות ב-Monitoring, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית. 


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

// Creates clients
const alertClient = new monitoring.AlertPolicyServiceClient();
const notificationClient = new monitoring.NotificationChannelServiceClient();

async function replaceChannels() {
  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const projectId = 'YOUR_PROJECT_ID';
  // const alertPolicyId = '123456789012314';
  // const channelIds = [
  //   'channel-1',
  //   'channel-2',
  //   'channel-3',
  // ];

  const notificationChannels = channelIds.map(id =>
    notificationClient.projectNotificationChannelPath(projectId, id)
  );

  for (const channel of notificationChannels) {
    const updateChannelRequest = {
      updateMask: {
        paths: ['enabled'],
      },
      notificationChannel: {
        name: channel,
        enabled: {
          value: true,
        },
      },
    };
    try {
      await notificationClient.updateNotificationChannel(
        updateChannelRequest
      );
    } catch (err) {
      const createChannelRequest = {
        notificationChannel: {
          name: channel,
          notificationChannel: {
            type: 'email',
          },
        },
      };
      const newChannel =
        await notificationClient.createNotificationChannel(
          createChannelRequest
        );
      notificationChannels.push(newChannel);
    }
  }

  const updateAlertPolicyRequest = {
    updateMask: {
      paths: ['notification_channels'],
    },
    alertPolicy: {
      name: alertClient.projectAlertPolicyPath(projectId, alertPolicyId),
      notificationChannels: notificationChannels,
    },
  };
  const [alertPolicy] = await alertClient.updateAlertPolicy(
    updateAlertPolicyRequest
  );
  console.log(`Updated ${alertPolicy.name}.`);
}
replaceChannels();

Go

כדי לבצע אימות ב-Monitoring, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית. 


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

כדי לבצע אימות ב-Monitoring, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית. 

private static Map<String, String> restoreNotificationChannels(
    String projectId, List<NotificationChannel> channels, boolean isSameProject)
    throws IOException {
  Map<String, String> newChannelNames = Maps.newHashMap();
  try (NotificationChannelServiceClient client = NotificationChannelServiceClient.create()) {
    for (NotificationChannel channel : channels) {
      // Update channel name if project ID is different.
      boolean channelUpdated = false;
      if (isSameProject) {
        try {
          NotificationChannel updatedChannel =
              client.updateNotificationChannel(NOTIFICATION_CHANNEL_UPDATE_MASK, channel);
          newChannelNames.put(channel.getName(), updatedChannel.getName());
          channelUpdated = true;
        } catch (Exception e) {
          channelUpdated = false;
        }
      }
      if (!channelUpdated) {
        NotificationChannel newChannel =
            client.createNotificationChannel(
                ProjectName.of(projectId),
                channel.toBuilder().clearName().clearVerificationStatus().build());
        newChannelNames.put(channel.getName(), newChannel.getName());
      }
    }
  }
  return newChannelNames;
}

PHP

כדי לבצע אימות ב-Monitoring, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית. 

use Google\Cloud\Monitoring\V3\Client\NotificationChannelServiceClient;
use Google\Cloud\Monitoring\V3\CreateNotificationChannelRequest;
use Google\Cloud\Monitoring\V3\NotificationChannel;

/**
 * @param string $projectId Your project ID
 */
function alert_create_channel(string $projectId): void
{
    $channelClient = new NotificationChannelServiceClient([
        'projectId' => $projectId,
    ]);
    $projectName = 'projects/' . $projectId;

    $channel = new NotificationChannel();
    $channel->setDisplayName('Test Notification Channel');
    $channel->setType('email');
    $channel->setLabels(['email_address' => 'fake@example.com']);
    $createNotificationChannelRequest = (new CreateNotificationChannelRequest())
        ->setName($projectName)
        ->setNotificationChannel($channel);

    $channel = $channelClient->createNotificationChannel($createNotificationChannelRequest);
    printf('Created notification channel %s' . PHP_EOL, $channel->getName());
}

Python

כדי לבצע אימות ב-Monitoring, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית. 

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)

דוגמה: יצירת ערוץ התראות ב-Slack

כדי להגדיר ערוץ התראות לאפליקציית Slack:

  1. מגדירים את אפליקציית Slack:

    1. אם עדיין אין לכם אפליקציית Slack, אתם יכולים ליצור אחת ולהתקין אותה במרחב העבודה שלכם לפי ההוראות במסמכי העזרה של Slack.
    2. מגדירים את אפליקציית Slack עם היקף הרשאות ל-OAuth עבור chat:write ו-chat:write.public.
    3. מעתיקים את טוקן ה-OAuth של משתמש הבוט של האפליקציה.

  2. יוצרים קובץ שמגדיר את התצורה של ערוץ ההתראות. כוללים תווית שבה למפתח auth_token יש את הערך של טוקן הגישה ל-OAuth של משתמש הבוט באפליקציית Slack. לדוגמה:

    {
  "description": "A Slack notification channel",
  "displayName": "Slack",
  "type": "slack",
  "enabled": true,
  "labels": {
    "auth_token": "OAUTH_TOKEN_VALUE",
    "channel_name": "SLACK_CHANNEL_NAME"
  }
}

  3. מריצים את הפקודה הבאה כדי ליצור את ערוץ ההתראות:

    gcloud beta monitoring channels create --channel-content-from-file="FILE_NAME"

הצגת רשימה של ערוצי התראות בפרויקט

כדי לאחזר את כל ערוצי ההתראות ב Google Cloud פרויקט, משתמשים ב-method‏ notificationChannels.list. השיטה הזו תומכת גם באפשרויות filter ו-orderBy להגבלת התוצאות ולמיון שלהן. מידע נוסף זמין במאמר בנושא מיון וסינון.

אם אתם מחפשים ערוץ ספציפי ואתם יודעים את השם שלו, אתם יכולים להשתמש בשיטה notificationChannels.get כדי לאחזר רק את הערוץ הזה. השם של ערוץ הוא בפורמט projects/[PROJECT_ID]/notificationChannels/[CHANNEL_ID], לדוגמה:

    projects/[PROJECT_ID]/notificationChannels/1355376463305411567

כשמאחזרים ערוץ, יכול להיות שערכים רגישים כמו טוקנים לאימות ומפתחות API יוסתרו מסיבות אבטחה. אם אתם יוצרים ערוץ חדש על ידי העתקה של ערוץ קיים, צריך לתקן את כל הערכים המוסתרים.

gcloud

כדי להציג רשימה של כל ערוצי ההתראות בפרויקט Google Cloud , משתמשים בפקודה gcloud beta monitoring channels list:

gcloud beta monitoring channels list

אם הפקודה מסתיימת ללא שגיאות, היא מחזירה רשימה של כל הערוצים בפרויקט שצוין.list לדוגמה, הפקודה שלמעלה עשויה להחזיר רשימה שכוללת את הרשומות הבאות:

    ---
    description: E-mail channel created by gcloud as a test
    displayName: test e-mail channel
    enabled: false
    labels:
      email_address: user@example.com
    name: projects/[PROJECT_ID]/notificationChannels/1355376463305411567
    type: email
    ---
    description: Pub/Sub channel for notifications
    displayName: Notifications
    enabled: true
    labels:
      topic: projects/[PROJECT_ID]/topics/notificationTopic
    name: projects/[PROJECT_ID]/notificationChannels/1355376463305411567
    type: pubsub

כדי להציג ערוץ יחיד, משתמשים ב-gcloud beta monitoring channels describe ומציינים את שם הערוץ. לדוגמה, הפקודה הזו מחזירה את ערוץ Pub/Sub שמוצג ברשימה שלמעלה:

gcloud beta monitoring channels describe projects/[PROJECT_ID]/notificationChannels/1355376463305411567




מידע נוסף זמין במאמרים בנושא gcloud beta monitoring channels list וdescribe. הפקודה describe תואמת ל-method notificationChannels.get ב-API.



  




  
  
  
  
  
  
  
  
  
  

  









  
  
  
  
  







  
  
  




  









  
    
  



  




  
  
C#

  
  
    
    

      
      
    

    

      כדי לבצע אימות ב-Monitoring, צריך להגדיר את Application Default Credentials.
      מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.
      
    

      






    
  
  
  
  






  
  














  






  
    
  
  











  









  




  



  


  
static void ListNotificationChannels(string projectId)
{
    var client = NotificationChannelServiceClient.Create();
    var response = client.ListNotificationChannels(new ProjectName(projectId));
    foreach (NotificationChannel channel in response)
    {
        Console.WriteLine(channel.Name);
        if (channel.DisplayName != null)
        {
            Console.WriteLine(channel.DisplayName);
        }
        Console.WriteLine();
    }
}































  
  




  
  
  
  
  
  
  
  
  
  

  









  
  
  
  
  







  
  
  




  









  
    
  



  




  
  
Node.js

  
  
    
    

      
      
    

    

      כדי לבצע אימות ב-Monitoring, צריך להגדיר את Application Default Credentials.
      מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.
      
    

      






    
  
  
  
  






  
  














  






  
    
  
  











  









  




  



  


  

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

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

async function deleteChannels() {
  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const projectId = 'YOUR_PROJECT_ID';
  // const filter = 'A filter for selecting policies, e.g. description:"cloud"';

  const request = {
    name: client.projectPath(projectId),
    filter,
  };
  const channels = await client.listNotificationChannels(request);
  console.log(channels);
  for (const channel of channels[0]) {
    console.log(`Deleting channel ${channel.displayName}`);
    try {
      await client.deleteNotificationChannel({
        name: channel.name,
      });
    } catch (err) {
      // ignore error
    }
  }
}
deleteChannels();






























  
  




  
  
  
  
  
  
  
  
  
  

  









  
  
  
  
  







  
  




  









  
    
  



  




  
  
Go

  
  
    
    

      
      
    

    

      כדי לבצע אימות ב-Monitoring, צריך להגדיר את Application Default Credentials.
      מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.
      
    

      






    
  
  
  
  






  
  














  






  
    
  
  











  









  




  



  


  
channelClient, err := monitoring.NewNotificationChannelClient(ctx)
if err != nil {
	return err
}
defer channelClient.Close()
channelReq := &monitoringpb.ListNotificationChannelsRequest{
	Name: "projects/" + projectID,
	// Filter:  "", // See https://cloud.google.com/monitoring/api/v3/sorting-and-filtering.
	// OrderBy: "", // See https://cloud.google.com/monitoring/api/v3/sorting-and-filtering.
}
channelIt := channelClient.ListNotificationChannels(ctx, channelReq)
for {
	resp, err := channelIt.Next()
	if err == iterator.Done {
		break
	}
	if err != nil {
		return err
	}
	b.Channels = append(b.Channels, &channel{resp})
}






























  
  




  
  
  
  
  
  
  
  
  
  

  









  
  
  
  
  







  
  
  




  









  
    
  



  




  
  
Java

  
  
    
    

      
      
    

    

      כדי לבצע אימות ב-Monitoring, צריך להגדיר את Application Default Credentials.
      מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.
      
    

      






    
  
  
  
  






  
  














  






  
    
  
  











  









  




  



  


  
private static List<NotificationChannel> getNotificationChannels(String projectId)
    throws IOException {
  List<NotificationChannel> notificationChannels = Lists.newArrayList();
  try (NotificationChannelServiceClient client = NotificationChannelServiceClient.create()) {
    ListNotificationChannelsPagedResponse listNotificationChannelsResponse =
        client.listNotificationChannels(ProjectName.of(projectId));
    for (NotificationChannel channel : listNotificationChannelsResponse.iterateAll()) {
      notificationChannels.add(channel);
    }
  }
  return notificationChannels;
}






























  
  




  
  
  
  
  
  
  
  
  
  

  









  
  
  
  
  







  
  




  









  
    
  



  




  
  
PHP

  
  
    
    

      
      
    

    

      כדי לבצע אימות ב-Monitoring, צריך להגדיר את Application Default Credentials.
      מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.
      
    

      






    
  
  
  
  






  
  














  






  
    
  
  











  









  




  



  


  
use Google\Cloud\Monitoring\V3\Client\NotificationChannelServiceClient;
use Google\Cloud\Monitoring\V3\ListNotificationChannelsRequest;

/**
 * @param string $projectId Your project ID
 */
function alert_list_channels($projectId)
{
    $projectName = 'projects/' . $projectId;
    $channelClient = new NotificationChannelServiceClient([
        'projectId' => $projectId,
    ]);
    $listNotificationChannelsRequest = (new ListNotificationChannelsRequest())
        ->setName($projectName);

    $channels = $channelClient->listNotificationChannels($listNotificationChannelsRequest);
    foreach ($channels->iterateAllElements() as $channel) {
        printf('Name: %s (%s)' . PHP_EOL, $channel->getDisplayName(), $channel->getName());
    }
}






























  
  




  
  
  
  
  
  
  
  
  
  












  
  
  
  
  







  
  
  




  









  
    
  



  




  
  
Python

  
  
    
    

      
      
    

    

      כדי לבצע אימות ב-Monitoring, צריך להגדיר את Application Default Credentials.
      מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.
      
    

      






    
  
  
  
  






  
  














  






  
    
  
  











  









  




  



  


  
def list_notification_channels(project_name):
    """List alert notification channels in a project.

    Arguments:
        project_name (str): The Google Cloud Project to use. The project name
            must be in the format - 'projects/<PROJECT_NAME>'.
    """

    client = monitoring_v3.NotificationChannelServiceClient()
    channels = client.list_notification_channels(name=project_name)
    print(
        tabulate.tabulate(
            [(channel.name, channel.display_name) for channel in channels],
            ("name", "display_name"),
        )
    )
































  
  




  
  
  
  
  
  
  
  
  
  





מחיקת ערוץ התראות מפרויקט



כדי למחוק ערוץ התראות מ Google Cloud פרויקט, משתמשים ב-method‏ notificationChannels.delete ומזינים את השם של ערוץ ההתראות שרוצים למחוק. שם הערוץ הוא הערך של השדה name, ולא של השדה displayName, במופע NotificationChannel.
השם של ערוץ הוא בפורמט projects/[PROJECT_ID]/notificationChannels/[CHANNEL_ID], לדוגמה:



    projects/[PROJECT_ID]/notificationChannels/1355376463305411567




כברירת מחדל, אם מנסים למחוק ערוץ שמופיע בהפניה במדיניות התראות, הערוץ לא יימחק. כדי לכפות את ההסרה של הפניות ממדיניות ההתראות ולמחוק את הערוץ, מגדירים את האפשרות force לערך true. האפשרות הזו מסירה באופן אוטומטי את הערוץ מכל כללי המדיניות שמפנים אליו.







  















  




  









  
    
  






  
  
gcloud

  
  
  
  


כדי למחוק ערוץ התראות, משתמשים בפקודה gcloud beta monitoring channels
delete ומציינים את שם הערוץ שרוצים למחוק. לדוגמה, הפקודה הבאה מוחקת את הערוץ email שנוצר בדוגמה אחרת:


gcloud beta monitoring channels delete projects/[PROJECT_ID]/notificationChannels/1355376463305411567



מידע נוסף מופיע במפרט של השיטה ב-gcloud beta monitoring channels delete.

  




  
  
  
  
  
  
  
  
  
  

  









  
  
  
  
  







  
  
  




  









  
    
  



  




  
  
C#

  
  
    
    

      
      
    

    

      כדי לבצע אימות ב-Monitoring, צריך להגדיר את Application Default Credentials.
      מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.
      
    

      






    
  
  
  
  






  
  














  






  
    
  
  











  









  




  



  


  

using Google.Cloud.Monitoring.V3;
using System;

partial class AlertSnippets
{
    public void DeleteNotificationChannel(
        string channelName = "projects/your-project-id/notificationChannels/123")
    {
        var client = NotificationChannelServiceClient.Create();
        client.DeleteNotificationChannel(
            name: NotificationChannelName.Parse(channelName),
            force: true);
        Console.WriteLine("Deleted {0}.", channelName);
    }
}
































  
  




  
  
  
  
  
  
  
  
  
  

  









  
  
  
  
  







  
  




  









  
    
  



  




  
  
Go

  
  
    
    

      
      
    

    

      כדי לבצע אימות ב-Monitoring, צריך להגדיר את Application Default Credentials.
      מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.
      
    

      






    
  
  
  
  






  
  














  






  
    
  
  











  









  




  



  


  

import (
	"context"
	"fmt"
	"io"

	monitoring "cloud.google.com/go/monitoring/apiv3"
	"cloud.google.com/go/monitoring/apiv3/v2/monitoringpb"
)

// deleteChannel deletes the given channel. channelName should be of the form
// "projects/[PROJECT_ID]/notificationChannels/[CHANNEL_ID]".
func deleteChannel(w io.Writer, channelName string) error {
	ctx := context.Background()

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

	req := &monitoringpb.DeleteNotificationChannelRequest{
		Name: channelName,
	}

	if err := client.DeleteNotificationChannel(ctx, req); err != nil {
		return fmt.Errorf("DeleteNotificationChannel: %w", err)
	}

	fmt.Fprintf(w, "Deleted channel %q", channelName)
	return nil
}































  
  




  
  
  
  
  
  
  
  
  
  

  









  
  
  
  
  







  
  
  




  









  
    
  



  




  
  
Java

  
  
    
    

      
      
    

    

      כדי לבצע אימות ב-Monitoring, צריך להגדיר את Application Default Credentials.
      מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.
      
    

      






    
  
  
  
  






  
  














  






  
    
  
  











  









  




  



  


  
static void deleteNotificationChannel(String channelName) throws IOException {
  String projectId = System.getProperty("projectId");
  try (NotificationChannelServiceClient client = NotificationChannelServiceClient.create()) {
    NotificationChannelName name = NotificationChannelName.of(projectId, channelName);
    client.deleteNotificationChannel(channelName, false);
    System.out.println("Deleted notification channel " + channelName);
  }
}






























  
  




  
  
  
  
  
  
  
  
  
  

  









  
  
  
  
  







  
  




  









  
    
  



  




  
  
PHP

  
  
    
    

      
      
    

    

      כדי לבצע אימות ב-Monitoring, צריך להגדיר את Application Default Credentials.
      מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.
      
    

      






    
  
  
  
  






  
  














  






  
    
  
  











  









  




  



  


  
use Google\Cloud\Monitoring\V3\Client\NotificationChannelServiceClient;
use Google\Cloud\Monitoring\V3\DeleteNotificationChannelRequest;

/**
 * @param string $projectId Your project ID
 * @param string $channelId
 */
function alert_delete_channel(string $projectId, string $channelId): void
{
    $channelClient = new NotificationChannelServiceClient([
        'projectId' => $projectId,
    ]);
    $channelName = $channelClient->notificationChannelName($projectId, $channelId);
    $deleteNotificationChannelRequest = (new DeleteNotificationChannelRequest())
        ->setName($channelName);

    $channelClient->deleteNotificationChannel($deleteNotificationChannelRequest);
    printf('Deleted notification channel %s' . PHP_EOL, $channelName);
}






























  
  




  
  
  
  
  
  
  
  
  
  

  









  
  
  
  
  







  
  
  




  









  
    
  



  




  
  
Node.js

  
  
    
    

      
      
    

    

      כדי לבצע אימות ב-Monitoring, צריך להגדיר את Application Default Credentials.
      מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.
      
    

      






    
  
  
  
  






  
  














  






  
    
  
  











  









  




  



  


  

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

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

async function deleteChannels() {
  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const projectId = 'YOUR_PROJECT_ID';
  // const filter = 'A filter for selecting policies, e.g. description:"cloud"';

  const request = {
    name: client.projectPath(projectId),
    filter,
  };
  const channels = await client.listNotificationChannels(request);
  console.log(channels);
  for (const channel of channels[0]) {
    console.log(`Deleting channel ${channel.displayName}`);
    try {
      await client.deleteNotificationChannel({
        name: channel.name,
      });
    } catch (err) {
      // ignore error
    }
  }
}
deleteChannels();






























  
  




  
  
  
  
  
  
  
  
  
  

  









  
  
  
  
  







  
  
  




  









  
    
  



  




  
  
Python

  
  
    
    

      
      
    

    

      כדי לבצע אימות ב-Monitoring, צריך להגדיר את Application Default Credentials.
      מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.
      
    

      






    
  
  
  
  






  
  














  






  
    
  
  











  









  




  



  


  
def delete_notification_channels(project_name, channel_ids, force=None):
    """Delete alert notification channels.

    Arguments:
        project_name (str): The Google Cloud Project to use. The project name
            must be in the format - 'projects/<PROJECT_NAME>'.
        channel_ids list(str): List of IDs of notification channels to delete.
        force (bool): If true, the notification channels are deleted regardless
            of its in use by alert policies. If false, channels that are still
            referenced by an existing alerting policy will fail to be deleted.
    """

    channel_client = monitoring_v3.NotificationChannelServiceClient()
    for channel_id in channel_ids:
        channel_name = "{}/notificationChannels/{}".format(project_name, channel_id)
        try:
            channel_client.delete_notification_channel(name=channel_name, force=force)
            print("Channel {} deleted".format(channel_name))
        except ValueError:
            print("The parameters are invalid")
        except Exception as e:
            print("API call failed: {}".format(e))
































  
  




  
  
  
  
  
  
  
  
  
  




שינוי של ערוץ התראות



כדי לשנות ערוץ התראות, משתמשים ב-method ‏notificationChannels.patch (ב-API בארכיטקטורת REST).
הטמעות אחרות של API ו-Google Cloud CLI קוראות ל-update במקום ל-patch.



פעולת עדכון יכולה להחליף לחלוטין את הערוץ הקיים, או לשנות קבוצת משנה של שדות. לדוגמה, אפשר להפעיל ולהשבית את הערוץ.
השבתה של ערוץ מונעת את המסירה של התראות לערוץ.
השבתה של ערוץ היא בדרך כלל נוחה יותר מאשר הסרה של הערוץ ממדיניות ההתראות שמפנה אליו, אם השינוי אמור להיות זמני.








  















  




  









  
    
  






  
  
gcloud

  
  
  
  


כדי להפעיל ערוץ התראות שהושבת, משתמשים בפקודה gcloud beta monitoring channels update ומספקים את הדגל --enabled. הפקודה הבאה מפעילה את ערוץ ההתראות email שנוצר – במצב מושבת – בדוגמה הקודמת:


gcloud beta monitoring channels update projects/[PROJECT_ID]/notificationChannels/1355376463305411567 --enabled



כדי להשבית ערוץ התראות, משתמשים באותה פקודה ומספקים את הדגל --no-enabled.
מידע נוסף זמין במפרט של השיטה ב-gcloud beta monitoring channels update. הפקודה update תואמת ל-method‏ notificationChannels.patch ב-API בארכיטקטורת REST.



  




  
  
  
  
  
  
  
  
  
  

  









  
  
  
  
  







  
  
  




  









  
    
  



  




  
  
C#

  
  
    
    

      
      
    

    

      כדי לבצע אימות ב-Monitoring, צריך להגדיר את Application Default Credentials.
      מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.
      
    

      






    
  
  
  
  






  
  














  






  
    
  
  











  









  




  



  


  

using Google.Cloud.Monitoring.V3;
using Google.Protobuf.WellKnownTypes;
using System;

partial class AlertSnippets
{
    public NotificationChannel EnableNotificationChannel(
        string channelName = "projects/your-project-id/notificationChannels/123")
    {
        var client = NotificationChannelServiceClient.Create();
        NotificationChannel channel = new NotificationChannel();
        channel.Enabled = true;
        channel.Name = channelName;
        var fieldMask = new FieldMask { Paths = { "enabled" } };
        channel = client.UpdateNotificationChannel(
            updateMask: fieldMask,
            notificationChannel: channel);
        Console.WriteLine("Enabled {0}.", channel.Name);
        return channel;
    }
}
































  
  




  
  
  
  
  
  
  
  
  
  

  









  
  
  
  
  







  
  




  









  
    
  



  




  
  
Go

  
  
    
    

      
      
    

    

      כדי לבצע אימות ב-Monitoring, צריך להגדיר את Application Default Credentials.
      מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.
      
    

      






    
  
  
  
  






  
  














  






  
    
  
  











  









  




  



  


  

import (
	"context"
	"fmt"
	"io"

	monitoring "cloud.google.com/go/monitoring/apiv3"
	"cloud.google.com/go/monitoring/apiv3/v2/monitoringpb"
	"github.com/golang/protobuf/ptypes/wrappers"
	"google.golang.org/genproto/protobuf/field_mask"
)

// enableChannel enables the given channel. channelName should be of the form
// "projects/[PROJECT_ID]/notificationChannels/[CHANNEL_ID]".
func enableChannel(w io.Writer, channelName string) error {
	ctx := context.Background()

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

	req := &monitoringpb.UpdateNotificationChannelRequest{
		UpdateMask: &field_mask.FieldMask{Paths: []string{"enabled"}},
		NotificationChannel: &monitoringpb.NotificationChannel{
			Name:    channelName,
			Enabled: &wrappers.BoolValue{Value: true},
		},
	}

	if _, err := client.UpdateNotificationChannel(ctx, req); err != nil {
		return fmt.Errorf("EnableNotificationChannel: %w", err)
	}

	fmt.Fprintf(w, "Enabled channel %q", channelName)
	return nil
}































  
  




  
  
  
  
  
  
  
  
  
  

  









  
  
  
  
  







  
  
  




  









  
    
  



  




  
  
Node.js

  
  
    
    

      
      
    

    

      כדי לבצע אימות ב-Monitoring, צריך להגדיר את Application Default Credentials.
      מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.
      
    

      






    
  
  
  
  






  
  














  






  
    
  
  











  









  




  



  


  

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

// Creates clients
const alertClient = new monitoring.AlertPolicyServiceClient();
const notificationClient = new monitoring.NotificationChannelServiceClient();

async function replaceChannels() {
  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const projectId = 'YOUR_PROJECT_ID';
  // const alertPolicyId = '123456789012314';
  // const channelIds = [
  //   'channel-1',
  //   'channel-2',
  //   'channel-3',
  // ];

  const notificationChannels = channelIds.map(id =>
    notificationClient.projectNotificationChannelPath(projectId, id)
  );

  for (const channel of notificationChannels) {
    const updateChannelRequest = {
      updateMask: {
        paths: ['enabled'],
      },
      notificationChannel: {
        name: channel,
        enabled: {
          value: true,
        },
      },
    };
    try {
      await notificationClient.updateNotificationChannel(
        updateChannelRequest
      );
    } catch (err) {
      const createChannelRequest = {
        notificationChannel: {
          name: channel,
          notificationChannel: {
            type: 'email',
          },
        },
      };
      const newChannel =
        await notificationClient.createNotificationChannel(
          createChannelRequest
        );
      notificationChannels.push(newChannel);
    }
  }

  const updateAlertPolicyRequest = {
    updateMask: {
      paths: ['notification_channels'],
    },
    alertPolicy: {
      name: alertClient.projectAlertPolicyPath(projectId, alertPolicyId),
      notificationChannels: notificationChannels,
    },
  };
  const [alertPolicy] = await alertClient.updateAlertPolicy(
    updateAlertPolicyRequest
  );
  console.log(`Updated ${alertPolicy.name}.`);
}
replaceChannels();






























  
  




  
  
  
  
  
  
  
  
  
  

  









  
  
  
  
  







  
  
  




  









  
    
  



  




  
  
Java

  
  
    
    

      
      
    

    

      כדי לבצע אימות ב-Monitoring, צריך להגדיר את Application Default Credentials.
      מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.
      
    

      






    
  
  
  
  






  
  














  






  
    
  
  











  









  




  



  


  
private static Map<String, String> restoreNotificationChannels(
    String projectId, List<NotificationChannel> channels, boolean isSameProject)
    throws IOException {
  Map<String, String> newChannelNames = Maps.newHashMap();
  try (NotificationChannelServiceClient client = NotificationChannelServiceClient.create()) {
    for (NotificationChannel channel : channels) {
      // Update channel name if project ID is different.
      boolean channelUpdated = false;
      if (isSameProject) {
        try {
          NotificationChannel updatedChannel =
              client.updateNotificationChannel(NOTIFICATION_CHANNEL_UPDATE_MASK, channel);
          newChannelNames.put(channel.getName(), updatedChannel.getName());
          channelUpdated = true;
        } catch (Exception e) {
          channelUpdated = false;
        }
      }
      if (!channelUpdated) {
        NotificationChannel newChannel =
            client.createNotificationChannel(
                ProjectName.of(projectId),
                channel.toBuilder().clearName().clearVerificationStatus().build());
        newChannelNames.put(channel.getName(), newChannel.getName());
      }
    }
  }
  return newChannelNames;
}






























  
  




  
  
  
  
  
  
  
  
  
  

  









  
  
  
  
  







  
  




  









  
    
  



  




  
  
PHP

  
  
    
    

      
      
    

    

      כדי לבצע אימות ב-Monitoring, צריך להגדיר את Application Default Credentials.
      מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.
      
    

      






    
  
  
  
  






  
  














  






  
    
  
  











  









  




  



  


  
use Google\ApiCore\ApiException;
use Google\Cloud\Monitoring\V3\AlertPolicy;
use Google\Cloud\Monitoring\V3\Client\AlertPolicyServiceClient;
use Google\Cloud\Monitoring\V3\Client\NotificationChannelServiceClient;
use Google\Cloud\Monitoring\V3\CreateAlertPolicyRequest;
use Google\Cloud\Monitoring\V3\CreateNotificationChannelRequest;
use Google\Cloud\Monitoring\V3\NotificationChannel;
use Google\Cloud\Monitoring\V3\NotificationChannel\VerificationStatus;
use Google\Cloud\Monitoring\V3\UpdateAlertPolicyRequest;
use Google\Cloud\Monitoring\V3\UpdateNotificationChannelRequest;

/**
 * @param string $projectId Your project ID
 */
function alert_restore_policies(string $projectId): void
{
    $alertClient = new AlertPolicyServiceClient([
        'projectId' => $projectId,
    ]);

    $channelClient = new NotificationChannelServiceClient([
        'projectId' => $projectId,
    ]);

    print('Loading alert policies and notification channels from backup.json.' . PHP_EOL);
    $projectName = 'projects/' . $projectId;
    $record = json_decode((string) file_get_contents('backup.json'), true);
    $isSameProject = $projectName == $record['project_name'];

    # Convert dicts to AlertPolicies.
    $policies = [];
    foreach ($record['policies'] as $policyArray) {
        $policy = new AlertPolicy();
        $policy->mergeFromJsonString((string) json_encode($policyArray));
        $policies[] = $policy;
    }

    # Convert dicts to NotificationChannels
    $channels = [];
    foreach (array_filter($record['channels']) as $channelArray) {
        $channel = new NotificationChannel();
        $channel->mergeFromJsonString((string) json_encode($channelArray));
        $channels[] = $channel;
    }

    # Restore the channels.
    $channelNameMap = [];
    foreach ($channels as $channel) {
        $updated = false;
        printf('Updating channel %s' . PHP_EOL, $channel->getDisplayName());

        # This field is immutable and it is illegal to specify a
        # non-default value (UNVERIFIED or VERIFIED) in the
        # Create() or Update() operations.
        $channel->setVerificationStatus(
            VerificationStatus::VERIFICATION_STATUS_UNSPECIFIED
        );

        if ($isSameProject) {
            try {
                $updateNotificationChannelRequest = (new UpdateNotificationChannelRequest())
                    ->setNotificationChannel($channel);
                $channelClient->updateNotificationChannel($updateNotificationChannelRequest);
                $updated = true;
            } catch (ApiException $e) {
                # The channel was deleted.  Create it below.
                if ($e->getStatus() !== 'NOT_FOUND') {
                    throw $e;
                }
            }
        }

        if (!$updated) {
            # The channel no longer exists.  Recreate it.
            $oldName = $channel->getName();
            $channel->setName('');
            $createNotificationChannelRequest = (new CreateNotificationChannelRequest())
                ->setName($projectName)
                ->setNotificationChannel($channel);
            $newChannel = $channelClient->createNotificationChannel($createNotificationChannelRequest);
            $channelNameMap[$oldName] = $newChannel->getName();
        }
    }

    # Restore the alerts
    foreach ($policies as $policy) {
        printf('Updating policy %s' . PHP_EOL, $policy->getDisplayName());
        # These two fields cannot be set directly, so clear them.
        $policy->clearCreationRecord();
        $policy->clearMutationRecord();

        $notificationChannels = $policy->getNotificationChannels();

        # Update old channel names with new channel names.
        foreach ($notificationChannels as $i => $channel) {
            if (isset($channelNameMap[$channel])) {
                $notificationChannels[$i] = $channelNameMap[$channel];
            }
        }

        $updated = false;
        if ($isSameProject) {
            try {
                $updateAlertPolicyRequest = (new UpdateAlertPolicyRequest())
                    ->setAlertPolicy($policy);
                $alertClient->updateAlertPolicy($updateAlertPolicyRequest);
                $updated = true;
            } catch (ApiException $e) {
                # The policy was deleted.  Create it below.
                if ($e->getStatus() !== 'NOT_FOUND') {
                    throw $e;
                }
            }
        }

        if (!$updated) {
            # The policy no longer exists.  Recreate it.
            $oldName = $policy->getName();
            $policy->setName('');
            foreach ($policy->getConditions() as $condition) {
                $condition->setName('');
            }
            $createAlertPolicyRequest = (new CreateAlertPolicyRequest())
                ->setName($projectName)
                ->setAlertPolicy($policy);
            $policy = $alertClient->createAlertPolicy($createAlertPolicyRequest);
        }
        printf('Updated %s' . PHP_EOL, $policy->getName());
    }
    print('Restored alert policies and notification channels from backup.json.');
}






























  
  




  
  
  
  
  
  
  
  
  
  

  









  
  
  
  
  







  
  
  




  









  
    
  



  




  
  
Python

  
  
    
    

      
      
    

    

      כדי לבצע אימות ב-Monitoring, צריך להגדיר את Application Default Credentials.
      מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.
      
    

      






    
  
  
  
  






  
  














  






  
    
  
  











  









  




  



  


  
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)
































  
  




  
  
  
  
  
  
  
  
  
  





צפייה ביומנים של ערוצי התראות



אפשר להשתמש ב-Logs Explorer כדי לראות שגיאות בערוץ ההתראות:



    

  1. 


    במסוף Google Cloud , נכנסים לדף 
   Logs Explorer:
   
    כניסה אל Logs Explorer

    

    

    אם משתמשים בסרגל החיפוש כדי למצוא את הדף הזה, בוחרים בתוצאה שכותרת המשנה שלה היא Logging.
    2. 

  2. מזינים ומריצים את השאילתה. לשאילתות שספציפיות לשגיאות בערוצי התראות, אפשר לעיין במאמר שאילתות ב-Cloud Monitoring.
    3.