Überwachung für Code Engine

Verschaffen Sie sich einen Einblick in die Leistung Ihrer Workloads, die mit IBM Cloud® Code Engine bereitgestellt werden. Metriken können Ihnen helfen, Engpässe zu ermitteln und potenzielle Probleme in Produktionsumgebungen vorherzusagen.

Mit dem IBM Cloud® Monitoring-Service können Sie Ihre Code Engine-Workloads überwachen. Code Engine leitet ausgewählte Informationen zu Ihren Workloads an Monitoring weiter, sodass Sie bestimmte Metriken wie Anforderungen, Revisionen und Dauer überwachen können.

IBM Cloud Monitoring-Serviceinstanz einrichten

Um Ihre Dashboards für Kundenkennzahlen unter Code Engine in Monitoring einzurichten, müssen Sie eine Instanz von Monitoring erstellen und anschließend „Platform Metrics“ in derselben Region aktivieren, in der sich die Code Engine-Projekte befinden, die Sie überwachen möchten. Wenn Sie über Bereitstellungen in mehreren Regionen verfügen, müssen Sie Monitoring einrichten und Plattformmetriken für jede Region aktivieren. Weitere Informationen finden Sie im Lernprogramm zur Einführung in Monitoring.

Gehen Sie wie folgt vor, um Monitoring einzurichten:

Wählen Sie im Navigationsmenü von IBM Cloud die Option Beobachtbarkeit aus.
Wählen Sie Überwachung aus.
Verwenden Sie entweder eine vorhandene Monitoring-Serviceinstanz oder erstellen Sie eine neue Serviceinstanz.
Wenn die Instanz bereit ist, aktivieren Sie die Plattformmetriken, indem Sie auf Plattformmetriken konfigurieren klicken.
Wählen Sie eine Region und anschließend eine Monitoring-Instanz in dieser Region aus. Wenn Sie über Bereitstellungen in mehreren Regionen verfügen, müssen Sie Monitoring einrichten und Plattformmetriken für jede Region aktivieren.

Sie können auch die Überwachung über Ihr Code Engine-Dashboard starten, indem Sie die Option Überwachung starten auswählen.

Sie können die Dashboards anpassen, indem Sie eine Kopie einer Dashboardvorlage erstellen und bearbeiten.

Auf IBM Cloud Monitoring-Metriken zugreifen

Gehen Sie wie folgt vor, um Ihre Code Engine-Dashboards für Kundenmetriken in Monitoring anzuzeigen:

Wählen Sie im Navigationsmenü von IBM Cloud die Option Beobachtbarkeit aus.
Wählen Sie Überwachung aus.
Klicken Sie in der Spalte „Ansicht“ Ihrer Überwachungsinstanz auf „Dashboard“, um das Dashboard für Ihre Überwachungsinstanz zu öffnen.
Wählen Sie im Navigationsmenü Dashboards->IBM->IBM Code Engine Projektübersicht oder Dashboards->IBM->IBM Code Engine Funktionen Übersicht aus. Falls das Dashboard „ Code Engine “ nicht im Menü angezeigt wird, können Sie die Überwachung über Ihre Anwendung oder Ihren Job unter „ Code Engine “ starten, indem Sie „Überwachung hinzufügen“ auswählen.
Wählen Sie die 10M -Zeitachse oder höher aus. Da die Daten der Plattformmetriken eine 1-Minuten-Granularität aufweisen, ist die erste Zeitachse, in der Metriken angezeigt werden, die Zeitachse 10M .

Sie können das Monitoring-Dashboard jederzeit starten, indem Sie Überwachung im Code Engine-Aktionsmenü auswählen.

Wenn Sie den Dienst „ IBM Cloud Monitoring “ zur Überwachung von Code Engine-Workloads nutzen, kann es zu Verzögerungen kommen, bevor die Daten verarbeitet werden und unter Monitoring verfügbar sind. Beispiel: Direkt nach der Erstellung der Überwachungsinstanz dauert es einige Minuten, bis aussagekräftige Überwachungsdaten angezeigt werden. Bitte beachten Sie, dass es etwa 5 Minuten dauern kann, bis Ihre Überwachungsdaten unter Monitoring angezeigt werden.

Verfügbare Kennzahlen für Code Engine

Tabelle 1: Verfügbare Metriken für Code Engine
Metrikname
`ibm_codeengine_application_actual_instances`
`ibm_codeengine_application_requested_instances`
`ibm_codeengine_application_not_ready_instances`
`ibm_codeengine_application_pending_instances`
`ibm_codeengine_application_desired_instances`
`ibm_codeengine_application_terminating_instances`
`ibm_codeengine_application_requests_total`
`ibm_codeengine_application_revision_count`
`ibm_codeengine_application_service_count`
`ibm_codeengine_application_route_count`
`ibm_codeengine_application_target_concurrency_per_pod`
`ibm_codeengine_application_panic_request_concurrency`
`ibm_codeengine_application_stable_request_concurrency`
`ibm_codeengine_application_panic_mode`
`ibm_codeengine_functions_activations`
`ibm_codeengine_functions_exceeded_limit`
`ibm_codeengine_functions_execution_time_count`
`ibm_codeengine_functions_execution_time_sum`
`ibm_codeengine_functions_init_time_count`
`ibm_codeengine_functions_init_time_sum`
`ibm_codeengine_functions_status_success`
`ibm_codeengine_functions_status_error_application`
`ibm_codeengine_functions_status_error_developer`
`ibm_codeengine_jobruns`

`ibm_codeengine_application_actual_instances`

Die Anzahl der Pods, die momentan zugeordnet sind.

Mit dieser Metrik können Sie das Verhalten der automatischen Anwendungsskalierung beobachten und feststellen, wie viele Anwendungsinstanzen ausgeführt werden. Überwachen Sie diesen Wert, um festzustellen, ob Sie die konfigurierbaren Werte für Ihre Anwendung anpassen müssen.

Die Anzahl der laufenden Instanzen einer App wird je nach Konfigurationseinstellungen und Ihrer Auslastung automatisch erhöht oder verringert. Die Anwendungsskalierung ist konfigurierbar. Siehe Anwendungsskalierung konfigurieren und beachten Sie die Anwendungsstandardwerte und -grenzwerte.

Tabelle 2: Anzahl der Pods, die momentan zugeordnet sind
Metadaten	Beschreibung
`Metric Name`	`ibm_codeengine_application_actual_instances`
`Metric Type`	`gauge`
`Value Type`	`none`
`Segment By`	`Service instance, name of the namespace, project name, application name, application revision name`

`ibm_codeengine_application_requested_instances`

Anzahl der Pods, die vom Autoscaler bei Kubernetes angefordert wurden.

Mit dieser Metrik können Sie das Verhalten der automatischen Anwendungsskalierung beobachten. Überwachen Sie diesen Wert, um festzustellen, ob Sie die konfigurierbaren Werte für Ihre Anwendung anpassen müssen.

Tabelle 3: Anzahl der vom Autoscaler angeforderten Pods
Metadaten	Beschreibung
`Metric Name`	`ibm_codeengine_application_requested_instances`
`Metric Type`	`gauge`
`Value Type`	`none`
`Segment By`	`Service instance, name of the namespace, project name, application name, application revision name`

`ibm_codeengine_application_not_ready_instances`

Anzahl der Pods, die aktuell nicht bereit sind.

Mit dieser Metrik können Sie feststellen, ob Probleme mit Ihrer aktiven Anwendung vorliegen.

Anwendungsinstanzen, die sich im Status Nicht bereit befinden, können Anforderungen nicht bedienen. Dieser Status Nicht bereit zeigt an, dass etwas verhindert, dass die App bereit wird.

Tabelle 4: Anzahl der Pods, die derzeit nicht bereit sind
Metadaten	Beschreibung
`Metric Name`	`ibm_codeengine_application_not_ready_instances`
`Metric Type`	`gauge`
`Value Type`	`none`
`Segment By`	`Service instance, name of the namespace, project name, application name, application revision name`

`ibm_codeengine_application_pending_instances`

Anzahl der Pods, die aktuell anstehen.

Mit dieser Metrik können Sie feststellen, ob Probleme mit Ihrer aktiven Anwendung vorliegen.

Sie können anstehende Anwendungen beobachten, wenn Sie die automatische Anwendungsskalierung beobachten. Anstehende Anwendungsinstanzen warten auf die Terminierung. Wenn Ihre Anwendung im Wartestatus bleibt, kann sie möglicherweise nicht gestartet werden, weil nicht genügend Ressourcen, wie z. B. Speicher oder CPU, zur Verfügung stehen. Siehe Unterstützte Speicher-und CPU-Kombinationen.

Tabelle 5: Anzahl der anstehenden Pods
Metadaten	Beschreibung
`Metric Name`	`ibm_codeengine_application_pending_instances`
`Metric Type`	`gauge`
`Value Type`	`none`
`Segment By`	`Service instance, name of the namespace, project name, application name, application revision name`

`ibm_codeengine_application_desired_instances`

Anzahl der Pods, die der Autoscaler zuordnen möchte.

Tabelle 6: Anzahl der Pods, die der Autoscaler zuordnen möchte
Metadaten	Beschreibung
`Metric Name`	`ibm_codeengine_application_desired_instances`
`Metric Type`	`gauge`
`Value Type`	`none`
`Segment By`	`Service instance, name of the namespace, project name, application name, application revision name`

`ibm_codeengine_application_terminating_instances`

Anzahl der Pods, die aktuell beendet werden.

Mit dieser Metrik können Sie das Verhalten der automatischen Anwendungsskalierung beobachten. Überwachen Sie diesen Wert, um festzustellen, ob eine Anwendung beendet wird, wenn für Anwendungen ein Scale-down durchgeführt wird.

Tabelle 7: Anzahl der Pods, die momentan beendet werden
Metadaten	Beschreibung
`Metric Name`	`ibm_codeengine_application_terminating_instances`
`Metric Type`	`gauge`
`Value Type`	`none`
`Segment By`	`Service instance, name of the namespace, project name, application name, application revision name`

`ibm_codeengine_application_requests_total`

Gesamtzahl der HTTPS-Anforderungen an die Anwendung.

Verwenden Sie diese Kennzahl, um die Anzahl der „ HTTPS “-Anfragen zu überwachen, die bei Ihrer Anwendung eingehen.

Tabelle 8: Gesamtzahl der „ HTTPS “-Anfragen an die Anwendung
Metadaten	Beschreibung
`Metric Name`	`ibm_codeengine_application_requests_total`
`Metric Type`	`gauge`
`Value Type`	`none`
`Segment By`	`Service instance, name of the namespace, project name, application name, application revision name, http status code`

`ibm_codeengine_application_revision_count`

Anzahl der Revisionen pro Anwendung.

Mit dieser Metrik können Sie die Anzahl der Überarbeitungen pro Anwendung beobachten.

Eine Anwendung enthält eine oder mehrere Versionen. Bei jeder Aktualisierung einer Anwendungskonfigurationseigenschaft wird eine neue Überarbeitung der Anwendung erstellt. Code Engine hat ein Kontingent für die Anzahl der Apps und App-Revisionen in einem Projekt. Weitere Informationen zu Grenzwerten für Projekte finden Sie im Thema Projektkontingente.

Tabelle 9: Anzahl der Überarbeitungen pro Anwendung
Metadaten	Beschreibung
`Metric Name`	`ibm_codeengine_application_revision_count`
`Metric Type`	`gauge`
`Value Type`	`none`
`Segment By`	`Service instance, name of the namespace, project name, application name`

`ibm_codeengine_application_service_count`

Anzahl der Anwendungen pro Projekt.

Mit dieser Metrik können Sie feststellen, wie viele Anwendungen in Ihrem Projekt vorhanden sind.

Code Engine hat eine Quote für die Anzahl der Apps und App-Revisionen in einem Projekt. Weitere Informationen zu Grenzwerten für Projekte finden Sie im Thema Projektkontingente.

Tabelle 10: Anzahl der Anwendungen pro Projekt
Metadaten	Beschreibung
`Metric Name`	`ibm_codeengine_application_service_count`
`Metric Type`	`gauge`
`Value Type`	`none`
`Segment By`	`Service instance, name of the namespace, project name, application name`

`ibm_codeengine_application_route_count`

Anzahl der Routen pro Anwendung.

Code Engine unterstützt nur eine Route pro Anwendung.

Tabelle 11: Anzahl der Routen pro Anwendung
Metadaten	Beschreibung
`Metric Name`	`ibm_codeengine_application_route_count`
`Metric Type`	`gauge`
`Value Type`	`none`
`Segment By`	`Service instance, name of the namespace, project name, application name`

`ibm_codeengine_application_target_concurrency_per_pod`

Anzahl gleichzeitiger Anforderungen, die Sie für jeden Pod zulassen möchten.

Verwenden Sie diesen Messwert, um den für Ihre Anwendung festgelegten Zielwert für den gemeinsamen Zugriff zu beobachten.

Die Zielparallelität für die Anwendungsskalierung ist konfigurierbar. Informationen hierzu finden Sie im Thema Anwendungsskalierung konfigurieren.

Tabelle 12: Die Anzahl der gleichzeitigen Anfragen, die Sie für jeden Pod wünschen
Metadaten	Beschreibung
`Metric Name`	`ibm_codeengine_application_target_concurrency_per_pod`
`Metric Type`	`gauge`
`Value Type`	`none`
`Segment By`	`Service instance, name of the namespace, project name, application name, application revision name`

`ibm_codeengine_application_panic_request_concurrency`

Durchschnittliche Anzahl der Anforderungen im Panikmodus.

Mit dieser Metrik können Sie das Verhalten der automatischen Anwendungsskalierung beobachten. Überwachen Sie diesen Wert, um zu beobachten, ob der Anwendungsdatenverkehr in Bursts ankommt oder ob der Datenverkehr konstant ist.

Während der Modus stable für allgemeine Operationen verwendet wird, hat der Modus panic ein viel kürzeres Fenster und wird verwendet, um eine Anwendungsrevision schnell zu skalieren, wenn ein Datenverkehrsblock auftritt.

Tabelle 13: Durchschnittliche Anzahl der Anforderungen im Panikfenster
Metadaten	Beschreibung
`Metric Name`	`ibm_codeengine_application_panic_request_concurrency`
`Metric Type`	`gauge`
`Value Type`	`none`
`Segment By`	`Service instance, name of the namespace, project name, application name, application revision name`

`ibm_codeengine_application_stable_request_concurrency`

Durchschnittliche Anzahl der Anforderungen im stabilen Modus.

Tabelle 14: Durchschnittliche Anzahl der Anforderungen im stabilen Fenster
Metadaten	Beschreibung
`Metric Name`	`ibm_codeengine_application_stable_request_concurrency`
`Metric Type`	`gauge`
`Value Type`	`none`
`Segment By`	`Service instance, name of the namespace, project name, application name, application revision name`

`ibm_codeengine_application_panic_mode`

Gibt an, ob der Panikmodus aktiviert ist.

Mit dieser Metrik können Sie das Verhalten der automatischen Anwendungsskalierung beobachten. Überwachen Sie diesen Wert, um festzustellen, ob der Panikmodus verwendet wird.

Tabelle 15: Angabe, ob der Panikmodus aktiviert ist
Metadaten	Beschreibung
`Metric Name`	`ibm_codeengine_application_panic_mode`
`Metric Type`	`gauge`
`Value Type`	`none`
`Segment By`	`Service instance, name of the namespace, project name, application name, application revision name`

`ibm_codeengine_functions_activations`

Die Anzahl der aufgerufenen Funktionen.

Tabelle 16: Anzahl der aufgerufenen Funktionen
Metadaten	Beschreibung
`Metric Name`	`ibm_codeengine_functions_activations`
`Metric Type`	`counter`
`Value Type`	`none`
`Segment By`	`Service instance, name of the namespace, project name, function name, function pod name, function type`

`ibm_codeengine_functions_exceeded_limit`

Die Anzahl der Funktionen, die aufgerufen werden, nachdem der Grenzwert für Ihr Projekt überschritten wurde Weitere Informationen zu Grenzwerten für Projekte finden Sie im Thema Projektkontingente.

Tabelle 17: Anzahl der aufgerufenen Funktionen nach Überschreitung des Projektgrenzwerts
Metadaten	Beschreibung
`Metric Name`	`ibm_codeengine_functions_exceeded_limit`
`Metric Type`	`counter`
`Value Type`	`none`
`Segment By`	`Service instance, name of the namespace, project name, function name, function pod name, function type`

`ibm_codeengine_functions_execution_time_count`

Anzahl der aufgerufenen Funktionen, die bis zum Abschluss ausgeführt werden.

Mit den Messwerten ibm_codeengine_functions_execution_time_count und ibm_codeengine_functions_execution_time_sum wird die durchschnittliche Ausführungszeit pro aufgerufener Funktion ermittelt.

Tabelle 18: Anzahl der aufgerufenen Funktionen, die die Ausführung abschließen
Metadaten	Beschreibung
`Metric Name`	`ibm_codeengine_functions_execution_time_count`
`Metric Type`	`gauge`
`Value Type`	`none`
`Segment By`	`Service instance, name of the namespace, project name, function name, function pod name`

`ibm_codeengine_functions_execution_time_sum`

Summe der gesamten Ausführungszeit für aufgerufene Funktionen, die bis zum Abschluss ausgeführt werden.

Mit den Messwerten ibm_codeengine_functions_execution_time_count und ibm_codeengine_functions_execution_time_sum wird die durchschnittliche Ausführungszeit pro aufgerufener Funktion ermittelt.

Tabelle 19: Summe aller Ausführungszeiten für aufgerufene Funktionen
Metadaten	Beschreibung
`Metric Name`	`ibm_codeengine_functions_execution_time_sum`
`Metric Type`	`gauge`
`Value Type`	`none`
`Segment By`	`Service instance, name of the namespace, project name, function name, function pod name`

`ibm_codeengine_functions_init_time_count`

Anzahl der Funktionen, die die Initialisierung abschließen, sodass der Code in Code Engine geladen und zur Ausführung bereit ist.

Mit den Messwerten ibm_codeengine_functions_init_time_count und ibm_codeengine_functions_init_time_sum wird die durchschnittliche Initialisierungszeit für aufgerufene Funktionen bestimmt.

Tabelle 20: Anzahl der Funktionen, die die Initialisierung abschließen
Metadaten	Beschreibung
`Metric Name`	`ibm_codeengine_functions_init_time_count`
`Metric Type`	`gauge`
`Value Type`	`none`
`Segment By`	`Service instance, name of the namespace, project name, function name, function pod name`

`ibm_codeengine_functions_init_time_sum`

Summe aller Initialisierungszeiten für aufgerufene Funktionen.

Mit den Messwerten ibm_codeengine_functions_init_time_count und ibm_codeengine_functions_init_time_sum wird die durchschnittliche Initialisierungszeit für aufgerufene Funktionen bestimmt.

Tabelle 21: Summe aller Initialisierungszeiten für aufgerufene Funktionen
Metadaten	Beschreibung
`Metric Name`	`ibm_codeengine_functions_init_time_sum`
`Metric Type`	`gauge`
`Value Type`	`none`
`Segment By`	`Service instance, name of the namespace, project name, function name, function pod name`

`ibm_codeengine_functions_status_success`

Die Anzahl der erfolgreich aufgerufenen Funktionen. Eine Funktion wird in „ Code Engine “ erfolgreich aufgerufen, nachdem die Funktion die Initialisierung abgeschlossen hat, vollständig ausgeführt wurde und Ihr Funktionscode mit dem erfolgreichen Antwortstatuscode „ HTTP “ antwortet.

Tabelle 22: Anzahl der erfolgreich aufgerufenen Funktionen
Metadaten	Beschreibung
`Metric Name`	`ibm_codeengine_functions_status_success`
`Metric Type`	`counter`
`Value Type`	`none`
`Segment By`	`Service instance, name of the namespace, project name, function name, function pod name, function type`

`ibm_codeengine_functions_status_error_application`

Die Anzahl der aufgerufenen Funktionen, die während der Verarbeitung von Code Engine fehlschlagen.

Tabelle 23: Anzahl aufgerufener Funktionen, die in Code Engine
Metadaten	Beschreibung
`Metric Name`	`ibm_codeengine_functions_status_error_application`
`Metric Type`	`counter`
`Value Type`	`none`
`Segment By`	`Service instance, name of the namespace, project name, function name, function pod name, function type`

`ibm_codeengine_functions_status_error_developer`

Anzahl der aufgerufenen Funktionen, die mit einem Fehler in Ihrem Code fehlschlagen.

Tabelle 24: Anzahl der aufgerufenen Funktionen, die mit einem Fehler in Ihrem Code fehlschlagen
Metadaten	Beschreibung
`Metric Name`	`ibm_codeengine_functions_status_error_developer`
`Metric Type`	`counter`
`Value Type`	`none`
`Segment By`	`Service instance, name of the namespace, project name, function name, function pod name, function type`

`ibm_codeengine_jobruns`

Gesamtzahl der Jobausführungen.

Mit dieser Metrik können Sie überwachen, wie viele Jobausführungen in Ihrem Projekt enthalten sind. Code Engine hat ein Kontingent für die Anzahl der Jobs und Jobausführungen in einem Projekt. Weitere Informationen zu Grenzwerten für Projekte finden Sie im Thema Projektkontingente.

Tabelle 25: Gesamtzahl der Jobausführungen
Metadaten	Beschreibung
`Metric Name`	`ibm_codeengine_jobruns`
`Metric Type`	`gauge`
`Value Type`	`none`
`Segment By`	`Service instance, name of the namespace, project name, job Name, jobrun condition`

Attribute für Segmentierung

Globale Attribute

Die folgenden Attribute sind für die Segmentierung aller zuvor aufgelisteten Metriken verfügbar.

Tabelle 26: Globale Attribute
Attribut	Attributname	Attributbeschreibung
`Cloud Type`	`ibm_ctype`	Der Cloudtyp ist einer der Werte `public`, `dedicated` oder `local`.
`Location`	`ibm_location`	Die Position der überwachten Ressource, bei der es sich um eine Region, ein Rechenzentrum oder eine die ganze Welt (global) handeln kann.
`Resource`	`ibm_resource`	Die Ressource, auf die sich die Messungen des Service beziehen. In der Regel wird die Ressource durch einen kennzeichnenden Namen oder eine GUID angegeben.
`Resource Type`	`ibm_resource_type`	Der Typ der Ressource, auf die sich die Messungen des Service beziehen.
`Resource group`	`ibm_resource_group_name`	Die Ressourcengruppe, in der die Serviceinstanz erstellt wurde.
`Scope`	`ibm_scope`	Der Bereich ist das Konto, die Organisation oder die Bereichs-GUID, das bzw. die dieser Metrik zugeordnet ist.
`Service name`	`ibm_service_name`	Der Name des Service, von dem die Metrik generiert wird.

Weitere Attribute

Die folgenden Attribute sind für die Segmentierung von Attributen verfügbar, wie in den vorherigen Tabellen beschrieben. Informationen zu den Segmentierungsoptionen finden Sie unter den einzelnen Metriken.

Tabelle 27: Segmentierungsoptionen
Attribut	Attributname	Attributbeschreibung
`Name of the namespace`	`ibm_codeengine_namespace`	Der Name des Namensbereichs. Diese eindeutige Kennung ist in der Datei „ URL “ Ihrer Anwendung enthalten. Die Standard- URL-Adresse für Anwendungen hat das Format `https://<appname>.<uuid>.<region>.codeengine.appdomain.cloud`, wobei `appname` der Name Ihrer Anwendung ist, `uuid` die automatisch generierte eindeutige Kennung und `region` die Region, in der sich Ihr Code Engine-Projekt befindet. Der UUID-Teil der „ URL “ ist der Name des Namensraums.
`Service instance`	`ibm_service_instance`	Das Serviceinstanzsegment identifiziert die Instanz, der die Metrik zugeordnet ist.
`HTTP status code`	`ibm_codeengine_status`	HTTP-Statuscode
`Application name`	`ibm_codeengine_application_name`	Der Name der Anwendung.
`Application revision name`	`ibm_codeengine_revision_name`	Name der Anwendungsrevision.
`Gateway instance`	`ibm_codeengine_gateway_instance`	Die Gateway-Instanz.
`Job Name`	`ibm_codeengine_job_name`	Name des Jobs, der zum Erstellen der Jobausführung verwendet wird.
`Jobrun condition`	`ibm_codeengine_jobrun_condition`	Der Status des Joblaufs.
`Project name`	`ibm_codeengine_project_name`	Name des Projekts.
`Function name`	`ibm_codeengine_function_name`	Name der aufgerufenen Funktion.
`Function pod name`	`ibm_codeengine_function_podname`	Der Name des Systempods, der die Funktion aufgerufen hat.
`Function type`	`ibm_codeengine_function_type`	Der Typ für den Aufruf der Funktion (`sync` oder `async`).