דוגמאות למרכזי בקרה ולפריסות

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

כדי להתקין הגדרות מוכנות מראש של מרכז בקרה ב-JSON לשירותי Google Cloud מ-GitHub, קראו את המאמר התקנת תבנית של מרכז בקרה.

מתי כדאי להשתמש ב-API או ב-Google Cloud CLI

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

צריך להשתמש ב-API גם כשרוצים להוסיף את הווידג'ט של הפלייסהולדר הריק למרכז הבקרה.

שימוש ב-MQL או ב-PromQL עם ה-API

כדי ליצור לוחות בקרה, משתמשים ב-method‏ dashboards.create. מעבירים ל-method של ה-API אובייקט Dashboard, שמכיל רשומה אחת לכל ווידג'ט שמוצג במרכז הבקרה.

כשבווידג'ט מוצגים נתונים של סדרת זמנים, כמו בווידג'ט של תרשים, הרשומה שלו באובייקט Dashboard מכילה אובייקט TimeSeriesQuery. האובייקט הזה מתאר את נתוני סדרת הזמנים שיוצגו בתרשים, ואתם מציינים את הנתונים האלה באמצעות מסנן מעקב, שאילתת MQL או שאילתת PromQL:

• כדי להשתמש במסנני מעקב, ממלאים את השדה timeSeriesFilter. הדוגמאות בדף הזה משתמשות במסננים של Cloud Monitoring.

• כדי להשתמש בשאילתת MQL, מאכלסים את השדה timeSeriesQueryLanguage. מידע נוסף זמין במאמר יצירת תרשימים.

• כדי להשתמש בשאילתת PromQL, מאכלסים את השדה prometheusQuery. למידע כללי, ראו PromQL ב-Cloud Monitoring.

פריסות של מרכז הבקרה

בקטע הזה מוסבר על הפריסות השונות של מרכז הבקרה.

מרכז הבקרה בGridLayout

בלוח הבקרה הזה מוצגת GridLayout עם שלושה ווידג'טים.

{
  "displayName": "Grid Layout Example",
  "gridLayout": {
    "columns": "2",
    "widgets": [
      {
        "title": "Widget 1",
        "xyChart": {
          "dataSets": {
            "timeSeriesQuery": {
              "timeSeriesFilter": {
                "filter": "metric.type=\"agent.googleapis.com/nginx/connections/accepted_count\"",
                "aggregation": {
                  "perSeriesAligner": "ALIGN_RATE"
                }
              },
              "unitOverride": "1"
            },
            "plotType": "LINE"
          },
          "timeshiftDuration": "0s",
          "yAxis": {
            "label": "y1Axis",
            "scale": "LINEAR"
          }
        }
      },
      {
        "text": {
          "content": "Widget 2"
        }
      },
      {
        "title": "Widget 3",
        "xyChart": {
          "dataSets": {
            "timeSeriesQuery": {
              "timeSeriesFilter": {
                "filter": "metric.type=\"agent.googleapis.com/nginx/connections/accepted_count\"",
                "aggregation": {
                  "perSeriesAligner": "ALIGN_RATE"
                }
              },
              "unitOverride": "1"
            },
            "plotType": "STACKED_BAR"
          },
          "timeshiftDuration": "0s",
          "yAxis": {
            "label": "y1Axis",
            "scale": "LINEAR"
          }
        }
      }
    ]
  }
}

לוח הבקרה נראה כמו בדוגמה הבאה:

מרכז הבקרה בMosaicLayout

בלוח הבקרה הזה מוצג MosaicLayout עם שני ווידג'טים.

{
  "displayName": "Mosaic Layout Example",
  "mosaicLayout": {
    "columns": 12,
    "tiles": [
      {
        "xPos": 2,
        "yPos": 2,
        "width": 7,
        "height": 2,
        "widget": {
          "title": "CPU utilization in us-central1-a",
          "scorecard": {
            "timeSeriesQuery": {
              "timeSeriesFilter": {
                "filter": "metric.type=\"compute.googleapis.com/instance/cpu/utilization\" resource.type=\"gce_instance\" resource.label.zone=\"us-central1-a\"",
                "aggregation": {
                  "perSeriesAligner": "ALIGN_MEAN",
                  "crossSeriesReducer": "REDUCE_MAX"
                }
              },
              "unitOverride": "1"
            },
            "gaugeView": {
              "upperBound": 1.5
            },
            "thresholds": [
              {
                "value": 0.8,
                "color": "YELLOW",
                "direction": "ABOVE"
              },
              {
                "value": 1,
                "color": "RED",
                "direction": "ABOVE"
              }
            ]
          }
        }
      },
      {
        "xPos": 1,
        "yPos": 5,
        "width": 4,
        "height": 4,
        "widget": {
          "title": "My Chart",
          "xyChart": {
            "dataSets": [
              {
                "timeSeriesQuery": {
                  "timeSeriesFilter": {
                    "filter": "metric.type=\"compute.googleapis.com/instance/cpu/utilization\" resource.type=\"gce_instance\"",
                    "aggregation": {
                      "perSeriesAligner": "ALIGN_MEAN",
                      "crossSeriesReducer": "REDUCE_MAX",
                      "groupByFields": [
                        "resource.label.zone"
                      ]
                    }
                  },
                  "unitOverride": "'1'"
                },
                "plotType": "LINE",
                "minAlignmentPeriod": "60s"
              }
            ],
            "yAxis": {
              "label": "y1Axis",
              "scale": "LINEAR"
            }
          }
        }
      }
    ]
  }
}

לוח הבקרה נראה כמו בדוגמה הבאה:

מרכז בקרה בRowLayout

בלוח הבקרה הזה מוצג RowLayout עם שלושה ווידג'טים.

{
  "displayName": "Row Layout Example",
  "rowLayout": {
    "rows": [
      {
        "weight": "1",
        "widgets": [
          {
            "text": {
              "content": "Widget 1",
              "format": "MARKDOWN"
            }
          },
          {
            "text": {
              "content": "Widget 2",
              "format": "MARKDOWN"
            }
          },
          {
            "text": {
              "content": "Widget 3",
              "format": "MARKDOWN"
            }
          }
        ]
      }
    ]
  }
}

לוח הבקרה נראה כמו בדוגמה הבאה:

מרכז הבקרה בColumnLayout

בלוח הבקרה הזה מוצגת ColumnLayout עם שלושה ווידג'טים.

{
  "displayName": "Column Layout Example",
  "columnLayout": {
    "columns": [
      {
        "weight": "1",
        "widgets": [
          {
            "text": {
              "content": "Widget 1",
              "format": "MARKDOWN"
            }
          },
          {
            "text": {
              "content": "Widget 2",
              "format": "MARKDOWN"
            }
          },
          {
            "text": {
              "content": "Widget 3",
              "format": "MARKDOWN"
            }
          }
        ]
      }
    ]
  }
}

לוח הבקרה נראה כמו בדוגמה הבאה:

הפעלת אירועים בלוח הבקרה, והוספת מסננים ותוויות

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

הפעלת אירועים במרכזי בקרה

כדי להגדיר לוח בקרה שיציג אירועים, כמו אירוע עדכון של Google Kubernetes Engine או אירוע כשל של מכונה וירטואלית, צריך לכלול שדה annotations באובייקט Dashboard. השדה annotations מכיל מופע של אובייקט DashboardAnnotations, שמכיל שני שדות:

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

• מערך של אובייקטי EventAnnotation. כל אובייקט מכיל את הפרטים הבאים:

  • שדה displayName, שמאפשר להגדיר את התווית במתג הספציפי לאירוע. אם לא מציינים את השדה הזה או אם הערך של השדה הזה הוא מחרוזת ריקה, מוצג שם ברירת המחדל של האירוע.
  • שדה enabled, שקובע את הערך של המתג של האירוע. כשהאפשרות true, המתג נמצא במצב on והאירועים מוצגים במרכז הבקרה. כשהאפשרות false, המתג נמצא במצב off.
  • שדה eventType, שמכיל ערך מהספירה EventType.
  • השדה filter, שמאפשר לציין שאילתה שרוצים להוסיף לשאילתה הספציפית לאירוע. כשהערך של השדה הזה הוא מחרוזת ריקה, המערכת משתמשת בשאילתה הספציפית לאירוע.
  • השדה resourceNames, שמאפשר להגדיר רשימה של פרויקטים ב-Google Cloud שבהם רוצים לחפש אירועים. אם השדה הזה הוא מערך ריק, החיפוש מתבצע בפרויקט שנבחר.

בדוגמה הבאה מוצג שדה annotations שמציין אירוע של Google Kubernetes Engine:

{
  "displayName": "Annotation example",
  "annotations": {
    "defaultResourceNames": [],
    "eventAnnotations": [
      {
        "displayName": "",
        "enabled": true,
        "eventType": "GKE_CLUSTER_UPDATE",
        "filter": "resource.labels.cluster_name=my-cluster",
        "resourceNames": []
      }
    ]
  },
  "dashboardFilters": [],
  "mosaicLayout": {
  ...
  },
  "labels": {}
}

בדוגמה הקודמת, השדה filter משמש להגבלת השאילתה לאשכול my-cluster. השדה displayName מוגדר כמחרוזת ריקה, ולכן שם ברירת המחדל של סוג האירוע מוצג במתג של האירוע. לבסוף, מכיוון שהשדה resourceNames מוגדר למערך ריק, נשלחת שאילתה לרשומות ביומן בפרויקט Google Cloud הנוכחי.

הוספת מסננים ומשתנים למרכז הבקרה

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

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

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

הוספת תוויות למרכז הבקרה

בדוגמה הזו מוצג אובייקט Dashboard שמציין את התווית בשם playbook.

{
  "displayName": "Example",
  "mosaicLayout": {
    "columns": 12,
    "tiles": [
      ...
    ]
  },
  "dashboardFilters": [],
  "labels": {
    "playbook": ""
  }
}

כפי שמוצג בדוגמה הקודמת, השדה labels מוטמע בתור map, והשדות key ו-value הם מחרוזות. כשמוסיפים תווית ללוח בקרה, מגדירים את key לשם התווית, ומגדירים את השדה value למחרוזת ריקה.

לא חובה להוסיף תוויות למרכז בקרה.

מרכזי בקרה עם Widgets

בקטע הזה יש דוגמאות ללוחות בקרה שמכילים סוגים שונים של ווידג'טים.

לוח בקרה עם XyChart

בדוגמה הזו מוצג מרכז בקרה עם XyChart בסיסי. אם השתמשתם במסוף Google Cloud כדי ליצור תרשימים במרכזי בקרה, התרשימים האלה הם מופעים של הווידג'ט XyChart.

בדומה לפונקציונליות שקיימת במסוף Google Cloud , ה-API מספק אפשרויות לשינוי PlotType של התרשים או להגדרת מצבי התצוגה של התרשים.

{
  "dashboardFilters": [],
  "displayName": "Example line chart",
  "labels": {},
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
      {
        "height": 16,
        "widget": {
          "title": "VM Instance - CPU utilization [MEAN]",
          "xyChart": {
            "chartOptions": {
              "mode": "COLOR"
            },
            "dataSets": [
              {
                "minAlignmentPeriod": "60s",
                "plotType": "LINE",
                "targetAxis": "Y1",
                "timeSeriesQuery": {
                  "timeSeriesFilter": {
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "crossSeriesReducer": "REDUCE_MEAN",
                      "groupByFields": [
                        "resource.label.\"zone\""
                      ],
                      "perSeriesAligner": "ALIGN_MEAN"
                    },
                    "filter": "metric.type=\"compute.googleapis.com/instance/cpu/utilization\" resource.type=\"gce_instance\""
                  }
                }
              }
            ],
            "thresholds": [],
            "yAxis": {
              "label": "",
              "scale": "LINEAR"
            }
          }
        },
        "width": 24
      }
    ]
  }
}

התרשים במרכז הבקרה נראה דומה לדוגמה הבאה:

בקטע הבא מוסבר איך ליצור ווידג'ט של תרשים ב-Observability Analytics, איך להציג ערך סף בתרשים ואיך להגדיר אם התרשים ישתמש בציר ה-Y השמאלי, בציר ה-Y הימני או בשניהם.

מרכז בקרה עם תרשים של Observability Analytics

בדוגמה הזו מוצג מרכז בקרה עם תרשים של Observability Analytics. קובץ ה-JSON לדוגמה מכיל שאילתת SQL.

{
  "displayName": "Example",
  "dashboardFilters": [],
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
      {
        "width": 24,
        "height": 16,
        "widget": {
          "title": "Sample analytics chart",
          "xyChart": {
            "chartOptions": {
              "mode": "COLOR"
            },
            "dataSets": [
              {
                "breakdowns": [],
                "dimensions": [
                  {
                    "column": "location",
                    "columnType": "STRING",
                    "maxBinCount": 5,
                    "sortColumn": "location",
                    "sortOrder": "SORT_ORDER_ASCENDING"
                  }
                ],
                "measures": [
                  {
                    "aggregationFunction": {
                      "parameters": [],
                      "type": "count"
                    },
                    "column": ""
                  }
                ],
                "plotType": "STACKED_BAR",
                "targetAxis": "Y1",
                "timeSeriesQuery": {
                  "opsAnalyticsQuery": {
                    "queryHandle": "",
                    "sql": "SELECT\n  CAST(JSON_VALUE(resource.labels.location) AS STRING) AS location,\n  severity,\nFROM\n  `VIEW`"
                  }
                }
              }
            ],
            "thresholds": [],
            "yAxis": {
              "label": "",
              "scale": "LINEAR"
            }
          }
        }
      }
    ]
  },
  "labels": {}
}

התרשים במרכז הבקרה נראה דומה לדוגמה הבאה:

מרכז בקרה עם XyChart וסף

בדוגמה הזו מוצג מרכז בקרה עם XyChart בסיסי, סף וציר Y שמאלי מוגדר.

{
  "dashboardFilters": [],
  "displayName": "Example line with threshold",
  "labels": {},
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
      {
        "height": 16,
        "widget": {
          "title": "VM Instance - CPU utilization [MEAN]",
          "xyChart": {
            "chartOptions": {
              "mode": "COLOR"
            },
            "dataSets": [
              {
                "minAlignmentPeriod": "60s",
                "plotType": "LINE",
                "targetAxis": "Y1",
                "timeSeriesQuery": {
                  "timeSeriesFilter": {
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "crossSeriesReducer": "REDUCE_MEAN",
                      "groupByFields": [
                        "resource.label.\"zone\""
                      ],
                      "perSeriesAligner": "ALIGN_MEAN"
                    },
                    "filter": "metric.type=\"compute.googleapis.com/instance/cpu/utilization\" resource.type=\"gce_instance\""
                  }
                }
              }
            ],
            "thresholds": [
              {
                "label": "",
                "targetAxis": "Y1",
                "value": 0.2
              }
            ],
            "yAxis": {
              "label": "",
              "scale": "LINEAR"
            }
          }
        },
        "width": 24
      }
    ]
  }
}

בדוגמה שלמעלה, קוד ה-JSON מציין שימוש בציר ה-Y השמאלי כי הוא מכיל מבנה y2Axis. בשדה targetAxis, משתמשים ב-"Y1" לציר ה-Y הימני וב-"Y2" לציר ה-Y השמאלי. אם לא מציינים את השדה targetAxis, המערכת משתמשת בציר ה-Y הימני.

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

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

לוח בקרה עם XyChart וSTACKED_AREA PlotType

בלוח הבקרה הזה מוצג XyChart עם STACKED_AREA PlotType.

{
  "dashboardFilters": [],
  "displayName": "Example stacked area",
  "labels": {},
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
      {
        "height": 16,
        "widget": {
          "title": "VM Instance - CPU utilization [MEAN]",
          "xyChart": {
            "chartOptions": {
              "mode": "COLOR"
            },
            "dataSets": [
              {
                "minAlignmentPeriod": "60s",
                "plotType": "STACKED_AREA",
                "targetAxis": "Y1",
                "timeSeriesQuery": {
                  "timeSeriesFilter": {
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "crossSeriesReducer": "REDUCE_MEAN",
                      "groupByFields": [
                        "resource.label.\"zone\""
                      ],
                      "perSeriesAligner": "ALIGN_MEAN"
                    },
                    "filter": "metric.type=\"compute.googleapis.com/instance/cpu/utilization\" resource.type=\"gce_instance\""
                  }
                }
              }
            ],
            "thresholds": [],
            "yAxis": {
              "label": "",
              "scale": "LINEAR"
            }
          }
        },
        "width": 24
      }
    ]
  }
}

התרשים במרכז הבקרה נראה דומה לדוגמה הבאה:

לוח בקרה עם XyChart וSTACKED_BAR PlotType

בלוח הבקרה הזה מוצג XyChart עם STACKED_BAR PlotType.

{
  "dashboardFilters": [],
  "displayName": "Example stacked bar",
  "labels": {},
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
      {
        "height": 16,
        "widget": {
          "title": "VM Instance - CPU utilization [MEAN]",
          "xyChart": {
            "chartOptions": {
              "mode": "COLOR"
            },
            "dataSets": [
              {
                "minAlignmentPeriod": "60s",
                "plotType": "STACKED_BAR",
                "targetAxis": "Y1",
                "timeSeriesQuery": {
                  "timeSeriesFilter": {
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "crossSeriesReducer": "REDUCE_MEAN",
                      "groupByFields": [
                        "resource.label.\"zone\""
                      ],
                      "perSeriesAligner": "ALIGN_MEAN"
                    },
                    "filter": "metric.type=\"compute.googleapis.com/instance/cpu/utilization\" resource.type=\"gce_instance\""
                  }
                }
              }
            ],
            "thresholds": [],
            "yAxis": {
              "label": "",
              "scale": "LINEAR"
            }
          }
        },
        "width": 24
      }
    ]
  }
}

לוח הבקרה נראה כמו בדוגמה הבאה:

מרכז בקרה עם XyChart שמוגדר כהיסטוגרמה

כדי להציג את הנתונים האחרונים כהיסטוגרמה, מגדירים את המערך DataSet.dimensions, שהוא שדה ב-XyChart. היסטוגרמה מספקת מידע על התדירות היחסית של הערך האחרון של כמה סדרות זמנים. כלומר, ציר ה-X מחולק לקטגוריות, וכל אחת מהן תואמת לטווח של ערכים. ציר ה-Y מציין ספירה, שהיא מספר הדגימות שהערכים שלהן נמצאים בטווח של הקטגוריה.

כדי להגדיר היסטוגרמה, במבנה XyChart מבצעים את הפעולות הבאות:

• מגדירים את השדה DataSet.plotType לערך "STACKED_BAR".
• מגדירים את השדה DataSet.dimension.column לערך "metric_value".

אם אתם רוצים לשלוט במודל הקטגוריות במקום לאפשר ל-Cloud Monitoring לקבוע את הקטגוריות על סמך הנתונים שלכם, הוסיפו את השדות הבאים למבנה DataSet.dimension:

• ‫xMin ו-xMax: מוגדרים לערכי המינימום והמקסימום של סוג המדד.

• maxBinCount או numericBinSize: מגדירים את מספר הקטגוריות או את גודל הקטגוריה. אם מגדירים את מספר הקטגוריות, מומלץ שהערך יהיה לפחות 5 ולא יותר מ-50. המספר המקסימלי של קטגוריות הוא 1,000.

קובץ ה-JSON הבא מתאר מרכז בקרה שמציג נתונים באמצעות היסטוגרמה:

{
  "displayName": "Histogram example",
  "dashboardFilters": [],
  "description": "",
  "labels": {},
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
      {
        "height": 16,
        "width": 24,
        "widget": {
          "title": "VM Instance - CPU utilization [MEAN]",
          "xyChart": {
            "chartOptions": {
              "displayHorizontal": false,
              "mode": "COLOR"
            },
            "dataSets": [
              {
                "dimensions": [
                  {
                    "column": "metric_value"
                  }
                ],
                "minAlignmentPeriod": "60s",
                "plotType": "STACKED_BAR",
                "targetAxis": "Y1",
                "timeSeriesQuery": {
                  "timeSeriesFilter": {
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "groupByFields": [],
                      "perSeriesAligner": "ALIGN_MEAN"
                    },
                    "filter": "metric.type=\"compute.googleapis.com/instance/cpu/utilization\" resource.type=\"gce_instance\""
                  }
                }
              }
            ],
            "thresholds": [],
            "yAxis": {
              "scale": "LINEAR"
            }
          }
        }
      }
    ]
  }
}

השדה dataSets.dimensions גורם ל-XyChart להופיע כהיסטוגרמה. ההיסטוגרמה בלוח הבקרה לדוגמה משתמשת בהגדרות ברירת המחדל, ולכן השדה dimension מכיל שדה משנה אחד, "column": "metric_value".

בצילום המסך הבא מוצג XyChart שמוגדר כהיסטוגרמה:

לוח בקרה עם ווידג'ט של XyChart שמגדיר שינוי של טווח הזמן

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

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

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

כדי להגדיר ביטול של טווח זמן, מגדירים את השדה widget.timeRange. בדוגמה הבאה, השדה הזה מוגדר לערך "relativeDuration": "21600s", כלומר בתרשים מוצגים נתונים מ-6 השעות האחרונות:

{
  "displayName": "Test Dashboard",
  "dashboardFilters": [],
  "description": "",
  "labels": {},
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
      {
        "xPos": 24,
        "height": 16,
        "width": 24,
        "widget": {
          "title": "VM Instance - CPU utilization [MEAN]",
          "timeRange": {
            "relativeDuration": "21600s"
          },
          "xyChart": {
            "chartOptions": {
              "displayHorizontal": false,
              "mode": "COLOR"
            },
            "dataSets": [
              {
                "minAlignmentPeriod": "60s",
                "plotType": "LINE",
                "targetAxis": "Y1",
                "timeSeriesQuery": {
                  "timeSeriesFilter": {
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "groupByFields": [],
                      "perSeriesAligner": "ALIGN_MEAN"
                    },
                    "filter": "metric.type=\"compute.googleapis.com/instance/cpu/utilization\" resource.type=\"gce_instance\""
                  }
                }
              }
            ],
            "thresholds": [],
            "yAxis": {
              "scale": "LINEAR"
            }
          }
        }
      }
    ]
  }
}

לוח בקרה עם Scorecard בסיסי

בלוח הבקרה הזה מוצג Scorecard בלי מד או תרשים קטן. בדוגמה מוצג ניצול המעבד (CPU) של Compute Engine, ובכרטיס המידע יש שני ערכי סף. סף אחד משתמש בצבע צהוב כדי לציין שניצול המעבד (CPU) הוא מעל 70%, והסף השני משתמש בצבע אדום כדי לציין שניצול המעבד (CPU) הוא מעל 90%.

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

{
  "dashboardFilters": [],
  "displayName": "Example-basic scorecard",
  "labels": {},
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
      {
        "height": 8,
        "widget": {
          "scorecard": {
            "thresholds": [
              {
                "color": "YELLOW",
                "direction": "ABOVE",
                "label": "",
                "value": 0.7
              },
              {
                "color": "RED",
                "direction": "ABOVE",
                "label": "",
                "value": 0.9
              }
            ],
            "timeSeriesQuery": {
              "outputFullDuration": true,
              "timeSeriesFilter": {
                "aggregation": {
                  "alignmentPeriod": "60s",
                  "crossSeriesReducer": "REDUCE_MEAN",
                  "groupByFields": [],
                  "perSeriesAligner": "ALIGN_MEAN"
                },
                "filter": "metric.type=\"compute.googleapis.com/instance/cpu/utilization\" resource.type=\"gce_instance\""
              }
            }
          },
          "title": "VM Instance - CPU utilization [MEAN]"
        },
        "width": 16
      }
    ]
  }
}

הווידג'טים האלה יכולים להציג כמה כרטיסי מידע. לדוגמה, אם הגדרות הצבירה יוצרות שלוש סדרות זמנים, הווידג'ט יציג שלושה כרטיסי מידע, אחד לכל סדרה.

לוח הבקרה נראה כמו בדוגמה הבאה:

מרכז בקרה עם Scorecard עם GaugeView

בלוח הבקרה הזה נוסף מד לכרטיס המידע הבסיסי מהדוגמה הקודמת. באובייקט GaugeView אפשר לציין גבול עליון וגבול תחתון כדי להגדיר את טווח הערכים שיוצגו במד. בכרטיס המידע מוצגים ערכים מ-0 עד 1, אז הגבולות העליונים והתחתונים האלה הגיוניים. כדי להוסיף את המד, מוסיפים את הקוד הבא ל-JSON של כרטיס המידע הבסיסי:

  "gaugeView": {
    "lowerBound": 0,
    "upperBound": 1,
  },

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

{
  "dashboardFilters": [],
  "displayName": "Example-Gauge",
  "labels": {},
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
      {
        "height": 8,
        "widget": {
          "scorecard": {
            "gaugeView": {
              "lowerBound": 0,
              "upperBound": 1
            },
            "thresholds": [
              {
                "color": "YELLOW",
                "direction": "ABOVE",
                "label": "",
                "value": 0.7
              },
              {
                "color": "RED",
                "direction": "ABOVE",
                "label": "",
                "value": 0.9
              }
            ],
            "timeSeriesQuery": {
              "outputFullDuration": true,
              "timeSeriesFilter": {
                "aggregation": {
                  "alignmentPeriod": "60s",
                  "crossSeriesReducer": "REDUCE_SUM",
                  "groupByFields": [
                    "resource.labels.\"zone\""
                  ],
                  "perSeriesAligner": "ALIGN_MEAN"
                },
                "filter": "metric.type=\"compute.googleapis.com/instance/cpu/utilization\" resource.type=\"gce_instance\""
              }
            }
          },
          "title": "VM Instance - CPU utilization [MEAN]"
        },
        "width": 16
      }
    ]
  }
}

הווידג'טים האלה יכולים להציג כמה מדידים. לדוגמה, בצילום המסך הבא מוצג ווידג'ט של Scorecard שהוגדר עם GaugeView, והווידג'ט הזה מציג שלושה מדידים:

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

מרכז בקרה עם Scorecard עם SparkChartView

בלוח הבקרה הזה, המד מהדוגמה הקודמת הוחלף בתרשים קו קטן. האובייקט SparkChartView יכול ליצור תרשימי קו או תרשימי עמודות בכרטיס מידע. בדוגמה הזו משתמשים בקו. כל עוד הערך לא חורג מהסף, הוא מוצג בירוק. כדי להוסיף את התרשים המקוון, מחליפים את אובייקט ה-JSON של gaugeView בתרשים הקודם בערך הבא:

  "sparkChartView": {
    "sparkChartType": "SPARK_LINE"
  },

כרטיס המידע נראה בערך כך:

מרכז בקרה עם ווידג'ט של PieChart

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

כל תרשימי העוגה מוגדרים באמצעות הווידג'ט PieChart. כדי להגדיר את התרשים כך שיוצג בו סכום המדידות האחרונות, מגדירים את השדה chartType לערך DONUT. אחרת, מגדירים בשדה הזה את הערך של PIE.

"pieChart": {
  "chartType": "DONUT",
},

בדוגמה הבאה מוגדר מרכז בקרה עם שני תרשימי עוגה, כשאחד מהם מוגדר כתרשים טבעת:

{
  "dashboardFilters": [],
  "displayName": "Example Pie Donut",
  "labels": {},
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
      {
        "height": 16,
        "widget": {
          "pieChart": {
            "chartType": "DONUT",
            "dataSets": [
              {
                "minAlignmentPeriod": "60s",
                "timeSeriesQuery": {
                  "timeSeriesFilter": {
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "perSeriesAligner": "ALIGN_RATE"
                    },
                    "filter": "metric.type=\"compute.googleapis.com/instance/disk/read_bytes_count\" resource.type=\"gce_instance\"",
                    "secondaryAggregation": {
                      "alignmentPeriod": "60s",
                      "perSeriesAligner": "ALIGN_MEAN"
                    }
                  }
                }
              }
            ]
          },
          "title": "VM Instance - Disk read bytes [MEAN]"
        },
        "width": 24
      },
      {
        "height": 16,
        "widget": {
          "pieChart": {
            "chartType": "PIE",
            "dataSets": [
              {
                "minAlignmentPeriod": "60s",
                "timeSeriesQuery": {
                  "timeSeriesFilter": {
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "perSeriesAligner": "ALIGN_RATE"
                    },
                    "filter": "metric.type=\"compute.googleapis.com/instance/disk/read_bytes_count\" resource.type=\"gce_instance\"",
                    "secondaryAggregation": {
                      "alignmentPeriod": "60s",
                      "perSeriesAligner": "ALIGN_MEAN"
                    }
                  }
                }
              }
            ]
          },
          "title": "VM Instance - Disk read bytes [MEAN]"
        },
        "width": 24,
        "xPos": 24
      },
    ]
  }
}

כפי שמוצג בצילום המסך הבא, שני הווידג'טים מציגים נתונים בתרשים עוגה, כאשר אחד מהם מציג את סכום הערכים האחרונים:

מרכז בקרה עם ווידג'ט של Treemap

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

כשמעיינים בתרשים Treemap, אפשר להשתמש בסמן כדי להפעיל את ההסבר הקצר של המלבן.

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

קוד ה-JSON הבא מגדיר ווידג'ט מסוג Treemap, שצובר את סדרות הזמנים לפי תחום (zone) וסוג אחסון:

{
  "displayName": "Example Treemap",
  "dashboardFilters": [],
  "labels": {},
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
      {
        "xPos": 24,
        "height": 16,
        "width": 24,
        "widget": {
          "title": "VM Instance - Write read bytes [SUM]",
          "id": "",
          "treemap": {
            "dataSets": [
              {
                "breakdowns": [],
                "measures": [],
                "timeSeriesQuery": {
                  "outputFullDuration": true,
                  "timeSeriesFilter": {
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "crossSeriesReducer": "REDUCE_SUM",
                      "groupByFields": [
                        "resource.label.\"zone\"",
                        "metric.label.\"storage_type\""
                      ],
                      "perSeriesAligner": "ALIGN_RATE"
                    },
                    "filter": "metric.type=\"compute.googleapis.com/instance/disk/write_bytes_count\" resource.type=\"gce_instance\""
                  },
                  "unitOverride": ""
                }
              }
            ],
            "treemapHierarchy": [
              "resource.label.\"zone\"",
              "metric.label.\"storage_type\""
            ]
          }
        }
      }
    ]
  }
}

בצילום המסך הבא מוצג הווידג'ט של תרשים ה-Treemap עם ההגדרות הקודמות:

בצילום המסך, ההסבר הקצר מוצג למלבן אחד.

מרכז בקרה עם ווידג'ט של TimeSeriesTable

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

כל הטבלאות מצוינות בווידג'ט TimeSeriesTable:

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

  • השדה TimeSeriesQuery מציין את סוג המדד.
  • אם רוצים שהטבלה תציג את הערך המצטבר, שבו הנתונים נצברים בטווח התאריכים שמוגדר בלוח הבקרה, מגדירים את השדה timeSeriesQuery.outputFullDuration לערך true.

• כדי להגדיר את מספר השורות המקסימלי שיוצגו, מגדירים את השדה pickTimeSeriesFilter. לדוגמה, כדי להציג רק את 2 סדרות הזמנים עם הערך הממוצע הגדול ביותר ב-10 הדקות הקודמות, צריך לכלול את הפרטים הבאים:

  "pickTimeSeriesFilter": {
      "direction": "TOP",
      "numTimeSeries": 2,
      "rankingMethod": "METHOD_MEAN"
  },
  

  אם משמיטים את השדה pickTimeSeriesFilter, בטבלה יוצגו עד 300 שורות.

• כדי להגדיר איך הנתונים יוצגו בטבלה, משתמשים בשדה metricVisualization:

  • כדי להציג רק ערך כמו "25%", אפשר להשמיט את השדה הזה או להגדיר את הערך כ-"NUMBER". כשמשתמשים בהגדרה הזו, הווידג'ט מוצג במסוףGoogle Cloud כווידג'ט Table.
  • כדי להציג את הערך ואינדיקטור חזותי של הערך בהשוואה לטווח הערכים האפשריים, מגדירים את הערך של השדה הזה בתור "BAR". כשמשתמשים בהגדרה הזו, הווידג'ט מוצג במסוףGoogle Cloud כווידג'ט Top List.

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

  הערך של השדה "column" חייב להיות מוגדר למפתח תווית או ל-value, שמתייחס לערך האחרון של סדרת הזמן. אפשר להגדיר את השם המוצג של עמודה, ואת היישור של הנתונים בתא בטבלה:

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

  בדוגמה הבאה מוצגות שתי עמודות:

  "columnSettings": [
    {
      "column": "device_name",
      "displayName": "Device",
      "visible": true
    },
    {
      "alignment": "CENTER",
      "column": "value",
      "displayName": "Disk Write Bytes",
      "thresholds": [
        {
          "color": "YELLOW",
          "direction": "ABOVE",
          "value": 4000
        },
        {
          "color": "RED",
          "direction": "ABOVE",
          "value": 5000
        }
      ],
      "visible": true
    }
  ],
  

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

{
  "displayName": "Example",
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
      {
        "width": 44,
        "height": 17,
        "widget": {
          "title": "VM Instance - Disk read bytes [RATE], Disk write bytes [RATE]",
          "timeSeriesTable": {
            "dataSets": [
              {
                "timeSeriesQuery": {
                  "timeSeriesFilter": {
                    "filter": "metric.type=\"compute.googleapis.com/instance/disk/read_bytes_count\" resource.type=\"gce_instance\"",
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "perSeriesAligner": "ALIGN_RATE",
                      "groupByFields": []
                    },
                    "pickTimeSeriesFilter": {
                      "rankingMethod": "METHOD_MEAN",
                      "numTimeSeries": 30,
                      "direction": "TOP"
                    }
                  },
                  "unitOverride": "",
                  "outputFullDuration": true
                },
                "tableTemplate": "",
                "minAlignmentPeriod": "60s"
              },
              {
                "timeSeriesQuery": {
                  "timeSeriesFilter": {
                    "filter": "metric.type=\"compute.googleapis.com/instance/disk/write_bytes_count\" resource.type=\"gce_instance\"",
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "perSeriesAligner": "ALIGN_RATE",
                      "groupByFields": []
                    },
                    "pickTimeSeriesFilter": {
                      "rankingMethod": "METHOD_MEAN",
                      "numTimeSeries": 30,
                      "direction": "TOP"
                    }
                  },
                  "unitOverride": "",
                  "outputFullDuration": true
                },
                "tableTemplate": "",
                "minAlignmentPeriod": "60s"
              }
            ],
            "metricVisualization": "BAR",
            "columnSettings": [
              {
                "column": "Name (from instance_id)",
                "visible": true
              },
              {
                "column": "zone",
                "visible": true
              },
              {
                "column": "device_name",
                "visible": true
              },
              {
                "column": "storage_type",
                "visible": true
              },
              {
                "column": "device_type",
                "visible": true
              },
              {
                "column": "value",
                "visible": true,
                "displayName": "Read bytes"
              },
              {
                "column": "value-1",
                "visible": true,
                "displayName": "Written bytes"
              }
            ],
            "opsAnalyticsSettings": {
              "maxRows": "0",
              "showFilterBar": false,
              "pageSize": "0"
            },
            "displayColumnType": false
          },
          "id": ""
        }
      },
      {
        "yPos": 17,
        "width": 44,
        "height": 16,
        "widget": {
          "title": "VM Instance - Disk write bytes [RATE]",
          "timeSeriesTable": {
            "columnSettings": [
              {
                "column": "device_name",
                "displayName": "Device",
                "visible": true
              },
              {
                "alignment": "LEFT",
                "column": "instance_name",
                "displayName": "Instance name",
                "visible": true
              },
              {
                "column": "storage_type",
                "displayName": "Storage type",
                "visible": true
              },
              {
                "column": "device_type",
                "displayName": "Device Type",
                "visible": true
              },
              {
                "alignment": "CENTER",
                "column": "value",
                "displayName": "Disk Write Bytes",
                "thresholds": [
                  {
                    "color": "YELLOW",
                    "direction": "ABOVE",
                    "label": "",
                    "value": 4000
                  },
                  {
                    "color": "RED",
                    "direction": "ABOVE",
                    "label": "",
                    "value": 5000
                  }
                ],
                "visible": true
              },
              {
                "alignment": "LEFT",
                "column": "Name (from instance_id)",
                "displayName": "ID",
                "visible": true
              }
            ],
            "dataSets": [
              {
                "minAlignmentPeriod": "60s",
                "timeSeriesQuery": {
                  "timeSeriesFilter": {
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "perSeriesAligner": "ALIGN_RATE"
                    },
                    "filter": "metric.type=\"compute.googleapis.com/instance/disk/write_bytes_count\" resource.type=\"gce_instance\""
                  }
                }
              }
            ],
            "displayColumnType": false,
            "metricVisualization": "NUMBER",
            "opsAnalyticsSettings": {
              "maxRows": "0",
              "pageSize": "0",
              "showFilterBar": false
            }
          }
        }
      }
    ]
  },
  "dashboardFilters": [],
  "labels": {}
}

בצילום המסך הבא מוצגת הטבלה שהוגדרה קודם:

מרכז בקרה עם ווידג'ט של Text

בדוגמה הזו מוצג לוח בקרה עם ווידג'ט של Text.

{
  "dashboardFilters": [],
  "displayName": "DB2+TE",
  "labels": {},
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
    ...
      {
        "height": 16,
        "widget": {
          "text": {
            "content": "# Support information\n\n\nContact information: [e-mail]\nOnline help: [Playbooks](https://example.com)\n\n",
            "format": "MARKDOWN",
            "style": {
              "backgroundColor": "",
              "fontSize": "FS_LARGE",
              "horizontalAlignment": "H_LEFT",
              "padding": "P_EXTRA_SMALL",
              "textColor": "",
              "verticalAlignment": "V_TOP"
            }
          }
        },
        "width": 24,
        "yPos": 14
      }
    ]
  }
}

הווידג'ט של הטקסט נראה כמו בדוגמה הבאה:

לוח בקרה עם ווידג'ט של AlertChart

בדוגמה הבאה מוצג לוח בקרה עם ווידג'ט של AlertChart:

{
  "category": "CUSTOM",
  "displayName": "Alerting policy chart example",
  "mosaicLayout": {
    "columns": 12,
    "tiles": [
      {
        "height": 4,
        "widget": {
          "alertChart": {
            "name": "projects/my-project/alertPolicies/14205854094151528373"
          }
        },
        "width": 6,
      }
    ]
  }
}

בניגוד לווידג'טים אחרים בלוח הבקרה, לווידג'טים האלה לא מציינים כותרת או מסנן מדדים. במקום זאת, מציינים את שם המשאב של מדיניות ההתראה. הרשומה האחרונה בשדה name היא המזהה של מדיניות ההתראות.

התרשים במרכז הבקרה נראה דומה לדוגמה הבאה:

בדוגמה הזו, מדיניות ההתראות עוקבת אחרי השימוש ב-CPU בשתי מכונות וירטואליות שונות. הקו המקווקו מציג את סף התנאי, שמוגדר ל-50%. הצ'יפ הירוק עם התווית No alerts מציין שאין התראות פתוחות למדיניות ההתראות. אם תציבו את הסמן על הצ'יפ של ההתראות, תיפתח תיבת דו-שיח עם קישור למדיניות ההתראות הבסיסית.

לוח בקרה עם ווידג'ט של ErrorReportingPanel

בדוגמה הבאה מוצג לוח בקרה עם ווידג'ט של ErrorReportingPanel:

{
  "dashboardFilters": [],
  "displayName": "Error reporting widget",
  "labels": {},
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
      {
        "height": 16,
        "widget": {
          "errorReportingPanel": {
            "projectNames": [
              "projects/my-project"
            ],
            "services": [],
            "versions": []
          },
          "title": "Error Reporting Panel"
        },
        "width": 24,
      }
    ]
  }
}

מומלץ להגדיר את הגובה של חלונית דיווח השגיאות ל-16 יחידות לפחות, ואת הרוחב שלה ל-24 יחידות לפחות. בדוגמה הקודמת, גובה הווידג'ט הוא 16 יחידות והרוחב שלו הוא 24 יחידות.

בחלונית של Error Reporting מוצגות קבוצות השגיאות מהפרויקט שנבחר, ואפשר להגביל את קבוצות השגיאות לסוג משאב, שירות או גרסת שירות ספציפיים. הדוגמה הבאה ממחישה חלונית של דיווח על שגיאות:

מרכז בקרה עם ווידג'ט של FilterControl

אם תיצרו משתנה, סרגל הכלים של לוח הבקרה בהתאמה אישית יעודכן ב-Monitoring כדי להציג מסנן למשתנה. שם המסנן הוא סימן דולר $ ואחריו שם המשתנה. לדוגמה, $my-variable. כל מסנן מכיל תפריט שמאפשר לשנות את הערך של המשתנה.

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

1. מוסיפים למרכז הבקרה ווידג'ט מסוג CollapsibleGroup וממקמים את שני התרשימים בקבוצה.

2. מוסיפים ווידג'ט של FilterControl למרכז הבקרה. אתם מגדירים את הווידג'ט הזה למשתנה וגם מוסיפים את הווידג'ט הזה לקבוצה.

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

מרכז הבקרה הבא מכיל ווידג'ט של FilterControl:

{
  "displayName": "Dashboard with filter control widget",
  "dashboardFilters": [
    {
      "filterType": "RESOURCE_LABEL",
      "labelKey": "project_id",
      "stringValue": "my-project",
      "templateVariable": "proj",
      "valueType": "STRING"
    }
  ],
  "description": "",
  "labels": {},
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
      {
        "yPos": 70,
        "height": 5,
        "width": 16,
        "widget": {
          "title": "Project control",
          "filterControl": {
            "templateVariable": "proj"
          }
        }
      }
    ]
  }
}

בדוגמה הקודמת מוגדר משתנה אחד, proj, ונוסף ווידג'ט אחד של FilterControl. בהגדרה הזו, התפריט של המשתנה מועבר מסרגל הכלים של מרכז הבקרה לווידג'ט שנקרא Project control. הווידג'ט הזה מכיל תפריט שבו אפשר לבחור את הפרויקט.

לוח בקרה עם ווידג'ט של IncidentList להצגת רשימת התראות

בדוגמה הבאה מוצג לוח בקרה עם ווידג'ט IncidentList להצגת רשימת התראות:

{
  "category": "CUSTOM",
  "dashboardFilters": [],
  "displayName": "Incident widget",
  "labels": {},
  "mosaicLayout": {
    "columns": 12,
    "tiles": [
      {
        "height": 5,
        "widget": {
          "incidentList": {
            "monitoredResources": [],
            "policyNames": []
          },
          "title": "Alerts"
        },
        "width": 8,
        "xPos": 0,
        "yPos": 0
      }
    ]
  }
}

בדוגמה הקודמת, השדה title מוגדר לערך Alerts, והווידג'ט מוגדר להציג את כל ההתראות למשאבים מסוג gce_instance. כשמגדירים את הווידג'ט הזה, אפשר לבחור כמה כללי מדיניות התראה או כמה סוגי משאבים.

במסוף Google Cloud , הווידג'ט נקרא Alerts. הווידג'ט נראה כמו בדוגמה הבאה:

מרכז בקרה עם ווידג'ט של LogsPanel

בדוגמה הבאה מוצג לוח בקרה עם ווידג'ט של LogsPanel:

{
  "category": "CUSTOM",
  "displayName": "Logs Panel",
  "mosaicLayout": {
    "columns": 12,
    "tiles": [
      {
        "height": 4,
        "widget": {
          "logsPanel": {
            "filter": "",
            "resourceNames": [
              "projects/012012012012"
            ]
          },
          "title": "Logs Panel"
        },
        "width": 6,
        "xPos": 0,
        "yPos": 0
      }
    ]
  }
}

מומלץ להגדיר את הגובה של חלונית היומנים ל-3 יחידות לפחות, ואת הרוחב ל-4 יחידות לפחות. בדוגמה שלמעלה, הגובה של הווידג'ט הוא 4 יחידות והרוחב הוא 6 יחידות.

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

חלונית היומנים נראית דומה לדוגמה הבאה:

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

מרכז בקרה עם ווידג'ט של CollapsibleGroup

בדוגמה הבאה מוצג לוח בקרה עם ווידג'ט של CollapsibleGroup:

{
  "category": "CUSTOM",
  "displayName": "Group testing",
  "mosaicLayout": {
    "columns": 12,
    "tiles": [
      {
        "height": 4,
        "widget": {
          "collapsibleGroup": {
            "collapsed": false
          },
          "title": "My group"
        },
        "width": 12,
        "xPos": 0,
        "yPos": 0
      },
      {
        "height": 4,
        "widget": {
          "title": "VM Instance - CPU utilization [MEAN]",
          "xyChart": {
            "chartOptions": {
              "mode": "COLOR"
            },
            "dataSets": [
              {
                "minAlignmentPeriod": "60s",
                "plotType": "LINE",
                "targetAxis": "Y1",
                "timeSeriesQuery": {
                  "apiSource": "DEFAULT_CLOUD",
                  "timeSeriesFilter": {
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "crossSeriesReducer": "REDUCE_NONE",
                      "perSeriesAligner": "ALIGN_MEAN"
                    },
                    "filter": "metric.type=\"compute.googleapis.com/instance/cpu/utilization\" resource.type=\"gce_instance\"",
                    "secondaryAggregation": {
                      "alignmentPeriod": "60s",
                      "crossSeriesReducer": "REDUCE_NONE",
                      "perSeriesAligner": "ALIGN_NONE"
                    }
                  }
                }
              }
            ],
            "thresholds": [],
            "timeshiftDuration": "0s",
            "yAxis": {
              "label": "y1Axis",
              "scale": "LINEAR"
            }
          }
        },
        "width": 6,
        "xPos": 0,
        "yPos": 0
      }
    ]
  }
}

בדוגמה הקודמת, הווידג'ט של הקבוצה הניתנת לכיווץ מכיל תרשים אחד שמציג את ניצול המעבד (CPU) של מכונה וירטואלית. ווידג'טים של קבוצות שניתן לכווץ משתרעים על פני שורה שלמה בטבלה. ווידג'ט נכלל בקבוצה אם המיקום (x,y) והגובה של הקבוצה כוללים את המיקום (x,y) של הווידג'ט. בדוגמה הקודמת, הקבוצה נמצאת במיקום (0,0) והגובה שלה הוא 4. הערך xyChart נמצא במיקום (0,0), ולכן הוא נכלל בקבוצה. אבל אם המיקום של התרשים הזה משתנה ל-(0,5), התרשים מוחרג מהקבוצה. לבסוף, אם המיקום (x,y) של ווידג'ט גורם לו להיכלל בקבוצה, יכול להיות שהגובה של הווידג'ט של הקבוצה הניתנת לכיווץ יורחב.

כדי לכלול ווידג'ט של קבוצה בלוח בקרה, צריך להיות לו MosaicLayout.

הווידג'ט של קבוצה שניתן לכווץ נראה כמו בדוגמה הבאה:

מרכז בקרה עם ווידג'ט של SingleViewGroup

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

הווידג'ט SingleViewGroup תומך בשני סגנונות תצוגה, DROPDOWN ו-TAB. ההבדל בין שני הסגנונות האלה הוא הדרך שבה בוחרים איזה חבר בקבוצה להציג. לווידג'טים בסגנון DROPDOWN יש תפריט. בווידג'טים בסגנון TAB יש כרטיסיות בסרגל הכלים של הווידג'ט:

{
  "dashboardFilters": [],
  "displayName": "Example",
  "labels": {},
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
      {
        "height": 16,
        "widget": {
          "singleViewGroup": {
            "displayType": "DROPDOWN"
          },
          "title": "Untitled group"
        },
        "width": 24,
        "yPos": 16
      },
      {
        "height": 16,
        "widget": {
          "title": "VM Instance - Disk read bytes [RATE]",
          "xyChart": {
            "chartOptions": {
              "mode": "COLOR"
            },
            "dataSets": [
              {
                "minAlignmentPeriod": "60s",
                "plotType": "LINE",
                "targetAxis": "Y1",
                "timeSeriesQuery": {
                  "timeSeriesFilter": {
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "perSeriesAligner": "ALIGN_RATE"
                    },
                    "filter": "metric.type=\"compute.googleapis.com/instance/disk/read_bytes_count\" resource.type=\"gce_instance\""
                  }
                }
              }
            ],
            "thresholds": [],
            "yAxis": {
              "label": "",
              "scale": "LINEAR"
            }
          }
        },
        "width": 24,
        "yPos": 16
      },
      {
        "height": 16,
        "widget": {
          "title": "VM Instance - Disk write bytes [RATE]",
          "xyChart": {
            "chartOptions": {
              "mode": "COLOR"
            },
            "dataSets": [
              {
                "minAlignmentPeriod": "60s",
                "plotType": "LINE",
                "targetAxis": "Y1",
                "timeSeriesQuery": {
                  "timeSeriesFilter": {
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "perSeriesAligner": "ALIGN_RATE"
                    },
                    "filter": "metric.type=\"compute.googleapis.com/instance/disk/write_bytes_count\" resource.type=\"gce_instance\""
                  }
                }
              }
            ],
            "thresholds": [],
            "yAxis": {
              "label": "",
              "scale": "LINEAR"
            }
          }
        },
        "width": 24,
        "yPos": 16
      }
    ]
  }
}

כמו שמוצג בדוגמה הקודמת, המערך tiles מכיל אובייקט SingleViewGroup אחד, אבל האובייקט הזה לא מציין אילו אובייקטים הוא מכיל. במקום זאת, החברות באובייקט SingleViewGroup נקבעת לפי הערכים של השדות width ו-yPos. אובייקטים שהערכים שלהם בשדות width ו-yPos תואמים לערכים של האובייקט SingleViewGroup, כלולים באובייקט SingleViewGroup. בדוגמה הקודמת, האובייקט SingleViewGroup מכיל שני תרשימים.

מרכז בקרה עם ווידג'ט של SectionHeader

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

בדוגמה הבאה מוצג לוח בקרה עם תרשים אחד ווידג'ט אחד של SectionHeader:

{
  "dashboardFilters": [],
  "displayName": "Example",
  "labels": {},
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
      {
        "height": 16,
        "widget": {
          "title": "VM Instance - Disk write bytes [RATE]",
          "xyChart": {
            "chartOptions": {
              "mode": "COLOR"
            },
            "dataSets": [
              {
                "minAlignmentPeriod": "60s",
                "plotType": "LINE",
                "targetAxis": "Y1",
                "timeSeriesQuery": {
                  "timeSeriesFilter": {
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "perSeriesAligner": "ALIGN_RATE"
                    },
                    "filter": "metric.type=\"compute.googleapis.com/instance/disk/write_bytes_count\" resource.type=\"gce_instance\""
                  }
                }
              }
            ],
            "thresholds": [],
            "yAxis": {
              "label": "",
              "scale": "LINEAR"
            }
          }
        },
        "width": 24,
        "yPos": 4
      },
      {
        "height": 4,
        "widget": {
          "sectionHeader": {
            "dividerBelow": true,
            "subtitle": "Instance metrics"
          },
          "title": "Metrics"
        },
        "width": 48
      }
    ]
  }
}

באובייקט SectionHeader, הערך של השדה title מוצג גם בווידג'ט וגם בתוכן העניינים. הערך של השדה subtitle מוצג רק על ידי הווידג'ט. כשהערך של dividerBelow הוא true, מתווסף קו מפריד לתוכן העניינים.

הערה: אם מסירים את כל הווידג'טים של כותרות הקטעים ממרכז הבקרה, גם תוכן העניינים מוסר.

מרכז בקרה עם ווידג'ט SLO

בדוגמה הבאה מוצג לוח בקרה עם ווידג'ט של SLO:

{
  "dashboardFilters": [],
  "displayName": "Example",
  "labels": {},
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
      {
        "height": 16,
        "widget": {
          "title": "SLO Error Budget: 99.5% - Distribution Cut - Calendar month",
          "xyChart": {
            "chartOptions": {
              "mode": "COLOR"
            },
            "dataSets": [
              {
                "breakdowns": [],
                "dimensions": [],
                "legendTemplate": "Remaining error requests before SLO is burned",
                "measures": [],
                "plotType": "LINE",
                "targetAxis": "Y1",
                "timeSeriesQuery": {
                  "timeSeriesFilter": {
                    "aggregation": {
                      "perSeriesAligner": "ALIGN_NEXT_OLDER"
                    },
                    "filter": "select_slo_budget(\"projects/Project_Number/services/SERVICE_ID/serviceLevelObjectives/SLO_ID\")",
                  },
                  "unitOverride": "1"
                }
              }
            ],
            "thresholds": []
          }
        },
        "width": 24
      }
    ]
  }
}

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

הווידג'ט של ה-SLO נראה כמו בדוגמה הבאה:

מרכז בקרה עם נתוני מעקב

השימוש בתכונה הזו כפוף לתנאי השימוש במוצרים בשלב טרום-GA, שמפורטים בחלק "תנאי שירות הכלליים" בתנאים הספציפיים של השירות. השימוש בתכונות בגרסת טרום-GA הוא "כפי שהן" (As is), ויכול להיות שהתמיכה בהן תהיה מוגבלת. אתם יכולים לקרוא מידע נוסף בקטע תיאור שלבי ההשקה.

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

בלוח הבקרה הזה מוצגים נתוני המעקב כמפת חום ובשתי טבלאות:

{
  "displayName": "Example trace chart",
  "dashboardFilters": [],
  "description": "",
  "labels": {},
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
      {
        "height": 22,
        "width": 48,
        "widget": {
          "title": "Visualizer",
          "xyChart": {
            "chartOptions": {
              "displayHorizontal": false,
              "mode": "COLOR"
            },
            "dataSets": [
              {
                "plotType": "HEATMAP",
                "timeSeriesQuery": {
                  "traceQuery": {
                    "resourceContainer": "projects/my-project",
                    "spanDataValue": "SPAN_DURATION",
                    "spanFilters": {
                      "apphubServices": [],
                      "apphubWorkloads": [],
                      "applicationIds": [],
                      "attributes": [],
                      "displayNames": [
                        "/taskqueue.QueryAndOwnTasks"
                      ],
                      "isRootSpan": false,
                      "kinds": [],
                      "services": [],
                      "status": []
                    }
                  }
                }
              }
            ],
            "thresholds": [],
            "yAxis": {
              "scale": "LINEAR"
            }
          }
        }
      },
      {
        "yPos": 22,
        "height": 16,
        "width": 24,
        "widget": {
          "title": "Grouped span table",
          "timeSeriesTable": {
            "columnSettings": [],
            "dataSets": [
              {
                "breakdowns": [
                  {
                    "aggregationFunction": {
                      "type": "none"
                    },
                    "column": "serviceOrWorkload",
                    "limit": 0,
                    "sortOrder": "SORT_ORDER_NONE"
                  }
                ],
                "timeSeriesQuery": {
                  "traceQuery": {
                    "resourceContainer": "projects/my-project",
                    "spanDataValue": "SPAN_DURATION",
                    "spanFilters": {
                      "apphubServices": [],
                      "apphubWorkloads": [],
                      "applicationIds": [],
                      "attributes": [],
                      "displayNames": [],
                      "isRootSpan": false,
                      "kinds": [],
                      "services": [],
                      "status": []
                    }
                  }
                }
              }
            ],
            "metricVisualization": "NUMBER"
          }
        }
      },
      {
        "yPos": 22,
        "xPos": 24,
        "height": 16,
        "width": 24,
        "widget": {
          "title": "Span table",
          "timeSeriesTable": {
            "columnSettings": [],
            "dataSets": [
              {
                "timeSeriesQuery": {
                  "traceQuery": {
                    "resourceContainer": "projects/my-project",
                    "spanDataValue": "SPAN_DURATION",
                    "spanFilters": {
                      "apphubServices": [],
                      "apphubWorkloads": [],
                      "applicationIds": [],
                      "attributes": [],
                      "displayNames": [],
                      "isRootSpan": false,
                      "kinds": [],
                      "services": [],
                      "status": []
                    }
                  }
                }
              }
            ],
            "metricVisualization": "NUMBER"
          }
        }
      }
    ]
  }
}

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

לוח הבקרה נראה כמו בתמונה הבאה:

מרכז בקרה עם ווידג'ט ריק

בדוגמה הזו מוצג מרכז בקרה עם ווידג'ט ריק של פלייסהולדר. הערך של השדה displayName מופיע בווידג'ט.

{
  "displayName": "Demo Dashboard",
  "gridLayout": {
    "widgets": [
      {
        "blank": {}
      }
    ]
  }
}

לוח הבקרה נראה כמו בדוגמה הבאה:

לוח בקרה עם הגדרות של חשיפת הווידג'טים

מרכז הבקרה הזה מכיל ווידג'ט טקסט ומשתנה. הערך של המשתנה קובע אם ווידג'ט הטקסט יוצג או יוסתר:

• ערך ברירת המחדל של המשתנה show הוא a. הערכים של המשתנה מוגדרים בתור a,‏ b ו-c. מכיוון שהשדה valueType הוא STRING_ARRAY, אפשר להגדיר את המשתנה גם לערכים כמו a or b.

• בווידג'ט הטקסט, הרשומה visibilityCondition מגדירה את החשיפה של הווידג'ט. כשהערך של המשתנה show כולל את b, ווידג'ט הטקסט מוצג. אחרת, ווידג'ט הטקסט לא מוצג.

{
  "displayName": "Conditional Widget Example",
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
      {
        "yPos": 16,
        "width": 24,
        "height": 16,
        "widget": {
          "title": "A text widget",
          "text": {
            "content": "Example showing how to use a custom variable to control visibility.",
            "format": "MARKDOWN",
            "style": {
              "backgroundColor": "#FFFFFF",
              "fontSize": "FS_LARGE",
              "horizontalAlignment": "H_LEFT",
              "padding": "P_EXTRA_SMALL",
              "pointerLocation": "POINTER_LOCATION_UNSPECIFIED",
              "textColor": "#212121",
              "verticalAlignment": "V_TOP"
            }
          },
          "visibilityCondition": {
            "templateVariableCondition": {
              "templateVariable": "show",
              "templateVariableValue": "b",
              "comparator": "REGEX_FULL_MATCH"
            }
          }
        }
      }
    ]
  },
  "dashboardFilters": [
    {
      "labelKey": "",
      "templateVariable": "show",
      "stringArrayValue": {
        "values": [
          "a"
        ]
      },
      "filterType": "VALUE_ONLY",
      "valueType": "STRING_ARRAY",
      "stringArray": {
        "values": [
          "a",
          "b",
          "c"
        ]
      }
    }
  ],
  "labels": {}
}

במאמר הגדרת החשיפה של ווידג'ט מפורטות ההגבלות שקשורות להגדרת החשיפה של ווידג'ט.