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

באמצעות Cloud Monitoring API ו-Google Cloud CLI, אתם יכולים ליצור מדיניות התראות מקובצי JSON או YAML, או באמצעות ספריות לקוח. כל אובייקט AlertPolicy מגדיר את התנאים שמבוססים על מדדים או על יומנים, שמצביעים על סטטוס לא תקין במערכת, יחד עם ערוצי ההתראות ואסטרטגיות ההתראות.

כשמשתמשים ב-Monitoring API, צריך לבצע אימות באמצעות פרטי כניסה של משתמש קצה ולא באמצעות מפתח API. לדוגמה, אתם יכולים לספק אסימון OAuth 2.0 למשתמש או לחשבון שירות. למידע נוסף, קראו את המאמר שימוש ב-OAuth 2.0 לגישה ל-Google APIs ואת המאמר אימות לממשקי API ולשירותים של Google Cloud .

התכונה הזו נתמכת רק בפרויקטים ב- Google Cloud . בהגדרות של App Hub, בוחרים את הפרויקט המארח או את פרויקט הניהול של App Hub.

המבנה של מדיניות התראות

המבנה AlertPolicy מגדיר את הרכיבים של מדיניות התראה. כשיוצרים מדיניות, מציינים ערכים בשדות הבאים של AlertPolicy:

אפשר גם לציין את השדה severity כשמשתמשים ב-Cloud Monitoring API ובמסוף Google Cloud . בשדה הזה אפשר להגדיר את רמת החומרה של ההתראות. אם לא מציינים רמת חומרה, מערכת Cloud Monitoring מגדירה את רמת החומרה של מדיניות ההתראה ל-No Severity.

יש שדות אחרים שאפשר להשתמש בהם, בהתאם לתנאים שאתם יוצרים.

כשמדיניות התראה מכילה תנאי אחד, נשלחת התראה כשהתנאי הזה מתקיים. למידע על התראות כשיש כמה תנאים במדיניות ההתראות, קראו את המאמרים מדיניות עם כמה תנאים ומתי Cloud Monitoring שולח התראות ויוצר התרעות.

כשיוצרים או משנים את מדיניות ההתראות, המערכת של Monitoring מגדירה גם שדות אחרים, כולל השדה name. הערך של השדה name הוא שם המשאב של מדיניות ההתראה, שמזהה את המדיניות. שם המשאב מופיע בפורמט הבא:

projects/PROJECT_ID/alertPolicies/POLICY_ID

בביטוי הקודם:

  • ‫PROJECT_ID: מזהה הפרויקט. בהגדרות של App Hub, בוחרים את הפרויקט המארח או את פרויקט הניהול של App Hub.
  • ‫POLICY_ID: המזהה של מדיניות ההתראה

סוגי התנאים ב-API

‫Cloud Monitoring API תומך במגוון סוגי תנאים במבנה Condition. יש כמה סוגי תנאים לכללי מדיניות התראות שמבוססים על מדדים, וסוג אחד לכללי מדיניות התראות שמבוססים על יומנים. בקטעים הבאים מתוארים סוגי התנאים הזמינים.

תנאים לכללי מדיניות התראות שמבוססים על מדדים

כדי ליצור מדיניות התראות שמנטרת נתוני מדדים, כולל מדדים מבוססי-יומנים, אתם יכולים להשתמש בסוגי התנאים הבאים:

תנאים להערכת מדדים שמבוססים על מסננים

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

אם משתמשים בסוג התנאי MetricAbsence, אפשר ליצור תנאי שמתקיים רק כשכל סדרות הזמנים חסרות. התנאי הזה משתמש בפרמטר aggregations כדי לצבור כמה סדרות זמנים לסדרת זמנים אחת. מידע נוסף מופיע במאמרי העזרה של ה-API בקטע MetricAbsence.

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

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

תנאים למדדים שמבוססים על PromQL

התנאי PrometheusQueryLanguageCondition משתמש בשאילתות של Prometheus Query Language‏ (PromQL) כדי לבחור ולשנות את נתוני סדרת זמנים למעקב. התנאי יכול לחשב יחס בין מדדים, להעריך השוואות בין מדדים ועוד.

אם משתמשים בתנאי PrometheusQueryLanguageCondition, הוא חייב להיות התנאי היחיד במדיניות ההתראות. למידע נוסף, ראו מדיניות התראות באמצעות PromQL.

תנאים להצגת התראות על יחסים

אתם יכולים ליצור מדיניות התראות של סף מדדים כדי לעקוב אחרי היחס בין שני מדדים. אפשר ליצור את כללי המדיניות האלה באמצעות סוג התנאי MetricThreshold או PrometheusQueryLanguageCondition. אפשר גם להשתמש ב-PromQL ישירות במסוף Google Cloud . אי אפשר ליצור או לנהל תנאים שמבוססים על יחס באמצעות הממשק הגרפי ליצירת תנאי סף.

מומלץ להשתמש ב-PromQL כדי ליצור מדיניות התראות שמבוססת על יחס. בעזרת PromQL אפשר ליצור שאילתות חזקות וגמישות יותר מאשר באמצעות סוג התנאי MetricTheshold ומסנני Monitoring. לדוגמה, באמצעות התנאי PrometheusQueryLanguageCondition אפשר לחשב את היחס בין מדד מסוג gauge למדד מסוג delta.

אם משתמשים בתנאי MetricThreshold, המונה והמכנה של היחס צריכים להיות עם אותו MetricKind. רשימה של מדדים והמאפיינים שלהם מופיעה במאמר רשימות של מדדים.

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

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

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

ההבדל במספר הערכים במרווחי ההתאמה התואמים יכול להוביל לערכי יחס error/total חסרי משמעות, כמו 1/0 או 2/1.

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

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

אם אתם מתכננים מדדים מותאמים אישית שעשויים לספור את אותו הדבר – כמו קריאות RPC שמחזירות סטטוס שגיאה – בשני מדדים שונים, כדאי לשקול במקום זאת מדד יחיד שכולל כל ספירה פעם אחת בלבד. לדוגמה, נניח שאתם סופרים קריאות RPC ורוצים לעקוב אחרי היחס בין קריאות RPC שנכשלו לבין כל קריאות ה-RPC. כדי לפתור את הבעיה, יוצרים סוג מדד אחד לספירת קריאות RPC, ומשתמשים בתווית כדי לתעד את סטטוס ההפעלה, כולל הסטטוס "OK". לאחר מכן, כל ערך סטטוס, שגיאה או "OK", מתועד על ידי עדכון מונה יחיד לאותו מקרה.

תנאי למדיניות התראות מבוססות-יומנים

כדי ליצור מדיניות התראות מבוססת-יומנים, ששולחת התראה כשמופיעה ברשומות ביומן הודעה שתואמת למסנן, משתמשים בסוג התנאי LogMatch. אם משתמשים בתנאי LogMatch, הוא חייב להיות התנאי היחיד במדיניות ההתראות.

אל תנסו להשתמש בסוג התנאי LogMatch בשילוב עם מדדים מבוססי-יומנים. כללי מדיניות התראה שעוקבים אחרי מדדים מבוססי-יומנים הם כללי מדיניות מבוססי-מדדים. למידע נוסף על בחירה בין מדיניות התראות שעוקבות אחרי מדדים מבוססי-יומנים או רשומות ביומן, ראו מעקב אחרי היומנים.

מדיניות ההתראות שמופיעה בדוגמאות במאמר ניהול מדיניות ההתראות באמצעות API מבוססת על מדדים, אבל העקרונות זהים גם למדיניות התראות שמבוססת על יומנים. למידע ספציפי על מדיניות התראות מבוססות-יומנים, קראו את המאמר יצירת מדיניות התראות מבוססות-יומנים באמצעות Monitoring API במסמכי התיעוד של Cloud Logging.

איך משייכים מדיניות התראה לאפליקציה ב-App Hub

‫Google Cloud יוצר מרכזי בקרה שעוזרים לכם לעקוב אחרי האפליקציות ב-App Hub. בלוחות הבקרה האלה מוצג מידע כמו נתוני יומנים ומדדים של האפליקציות, ושל השירותים ועומסי העבודה שהם חלק מהאפליקציה. בלוחות הבקרה האלה מוצגות גם מדיניות ההתראות וההתראות שלהן, כשהמדיניות משויכת לשירות או לעומס העבודה של האפליקציה. למידע נוסף על מעקב אחרי אפליקציות, ראו הצגת נתוני טלמטריה של אפליקציות.

כדי לשייך מדיניות התראות לאפליקציה ב-App Hub, צריך לצרף למדיניות תוויות עם המפתחות הבאים:

  • apphub_application_location
  • apphub_application_id
  • apphub_service_id או apphub_workload_id
לדוגמה, הקטע userLabels בייצוג ה-JSON של מדיניות התראות יכול להיראות כך:

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

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

לפני שכותבים קוד ל-API, צריך:

  • להכיר את המושגים הכלליים ואת המונחים שמשמשים במדיניות התראות. למידע נוסף, קראו את הסקירה הכללית על התראות.
  • מוודאים ש-Cloud Monitoring API מופעל לשימוש. למידע נוסף, ראו הפעלת ה-API.
  • אם אתם מתכננים להשתמש בספריות לקוח, התקינו את הספריות לשפות שבהן אתם רוצים להשתמש. פרטים נוספים זמינים במאמר ספריות לקוח. אפשר להשתמש ב-API כדי להגדיר התראות רק ב-C#‎,‏ Go,‏ Java,‏ Node.js ו-Python.
  • אם אתם מתכוונים להשתמש ב-Google Cloud CLI, אתם צריכים להתקין אותו. עם זאת, אם אתם משתמשים ב-Cloud Shell, כבר מותקן אצלכם Google Cloud CLI.

    כאן מוצגות גם דוגמאות לשימוש בממשק של gcloud. שימו לב שבכל הדוגמאות של gcloud, הפרויקט הנוכחי כבר הוגדר כיעד (gcloud config set project [PROJECT_ID]), ולכן הקריאות לא כוללות את הדגל המפורש --project. בדוגמאות, מזהה הפרויקט הנוכחי הוא a-gcp-project. בהגדרות של App Hub, בוחרים את הפרויקט המארח או את פרויקט הניהול של App Hub.

יצירת מדיניות התראות

כדי ליצור מדיניות התראות בפרויקט, משתמשים ב-method‏ alertPolicies.create. כדי לדעת איך להפעיל את השיטה הזו, מהם הפרמטרים שלה ומהם נתוני התגובה, קראו את דף העזר alertPolicies.create.

אפשר ליצור כללי מדיניות מקובצי JSON או YAML. ‫Google Cloud CLI מקבל את הקבצים האלה כארגומנטים, ואפשר לקרוא קובצי JSON באופן פרוגרמטי, להמיר אותם לאובייקטים מסוג AlertPolicy וליצור מהם כללי מדיניות באמצעות ה-method‏ alertPolicies.create. אם יש לכם קובץ תצורה של Prometheus בפורמט JSON או YAML עם כלל התראה, אתם יכולים להעביר אותו באמצעות ה-CLI של gcloud למדיניות התראה ב-Cloud Monitoring עם תנאי PromQL. למידע נוסף, קראו את המאמר העברת כללי התראות ומקלטים מ-Prometheus.

כל מדיניות התראה שייכת לפרויקט היקף של היקף המדדים בפרויקט. כל פרויקט יכול להכיל עד 2,000 כללי מדיניות. בקריאות ל-API, צריך לספק את מזהה הפרויקט (project ID). הערך שצריך להזין הוא המזהה של הפרויקט שמוגדר כהיקף המדדים. בדוגמאות האלה, המזהה של הפרויקט להיקף המדדים הוא a-gcp-project.

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

gcloud

כדי ליצור מדיניות התראות בפרויקט, משתמשים בפקודה gcloud monitoring policies create. בדוגמה הבאה, מדיניות ההתראה נוצרת ב-a-gcp-project מהקובץ rising-cpu-usage.json:

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

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

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

הקובץ rising-cpu-usage.json מכיל את ה-JSON של מדיניות עם השם המוצג "High CPU rate of change". לפרטים על המדיניות הזו, ראו מדיניות קצב השינוי.

למידע נוסף, עיינו במפרט של השיטה ב-gcloud monitoring policies 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)
    {
    }
    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

כדי לבצע אימות ב-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 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

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

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

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

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

כדי לבצע אימות ב-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)

לאובייקט AlertPolicy שנוצר יהיו שדות נוספים. המדיניות עצמה תכלול את השדות name,‏ creationRecord ו-mutationRecord. בנוסף, כל תנאי במדיניות מקבל גם name. אי אפשר לשנות את השדות האלה באופן חיצוני, ולכן אין צורך להגדיר אותם כשיוצרים מדיניות. הם לא מופיעים באף אחת מדוגמאות ה-JSON שמשמשות ליצירת כללי מדיניות, אבל אם מאחזרים כללי מדיניות שנוצרו מהן אחרי היצירה, השדות יופיעו.

הגדרת התראות חוזרות למדיניות התראות שמבוססת על מדדים

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

כדי להגדיר התראות חוזרות, מוסיפים להגדרות של מדיניות ההתראה אובייקט AlertStrategy שמכיל לפחות אובייקט NotificationChannelStrategy אחד. לאובייקט NotificationChannelStrategy יש שני שדות:

  • renotifyInterval: מרווח הזמן, בשניות, בין התראות חוזרות.

    אם משנים את הערך של השדה renotifyInterval כשנפתחת התראה לגבי מדיניות ההתראות, קורים הדברים הבאים:

    • מדיניות ההתראות שולחת התראה נוספת.
    • מדיניות ההתראה מפעילה מחדש את תקופת המרווח.
  • ‫notificationChannelNames: מערך של שמות משאבים של ערוצי התראות, שהם מחרוזות בפורמט projects/PROJECT_ID/notificationChannels/CHANNEL_ID, כאשר CHANNEL_ID הוא ערך מספרי. במאמר הצגת רשימה של ערוצי התראות בפרויקט מוסבר איך לאחזר את מזהה הערוץ.

לדוגמה, בדגימת ה-JSON הבאה מוצגת אסטרטגיית התראות שמוגדרת לשלוח התראות חוזרות כל 1,800 שניות (30 דקות) לערוץ התראות אחד:

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

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

המאמרים הבאים