Weitere AWS SDK-Beispiele sind im GitHub Repo [AWS Doc SDK Examples](https://github.com/awsdocs/aws-doc-sdk-examples) verfügbar.
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Szenarien für die Verwendung CloudWatch AWS SDKs
Die folgenden Codebeispiele zeigen Ihnen, wie Sie gängige Szenarien in CloudWatch with implementieren AWS SDKs. Diese Szenarien zeigen Ihnen, wie Sie bestimmte Aufgaben erledigen können, indem Sie mehrere Funktionen innerhalb CloudWatch oder in Kombination mit anderen aufrufen AWS-Services. Jedes Szenario enthält einen Link zum vollständigen Quell-Code, wo Sie Anleitungen zum Einrichten und Ausführen des Codes finden.
Szenarien zielen auf eine mittlere Erfahrungsebene ab, um Ihnen zu helfen, Service-Aktionen im Kontext zu verstehen.
**Topics**
+ [Erste Schritte mit Alarmen](cloudwatch_example_cloudwatch_Scenario_GettingStarted_section.md)
+ [Metriken und Alarme verwalten](cloudwatch_example_cloudwatch_Usage_MetricsAlarms_section.md)
+ [Überwachen der Leistung von Amazon DynamoDB](cloudwatch_example_cross_MonitorDynamoDB_section.md)
# Beginnen Sie mit CloudWatch Alarmen mithilfe eines AWS SDK
Wie das aussehen kann, sehen Sie am nachfolgenden Beispielcode:
+ Erstellen Sie einen Alarm.
+ Deaktivieren Sie Alarmaktionen.
+ Beschreiben Sie einen Alarm.
+ Löschen Sie einen Alarm.
------
#### [ SAP ABAP ]
**SDK für SAP ABAP**
Es gibt noch mehr dazu. GitHub Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/cwt#code-examples) einrichten und ausführen.
```
DATA lt_alarmnames TYPE /aws1/cl_cwtalarmnames_w=>tt_alarmnames.
DATA lo_alarmname TYPE REF TO /aws1/cl_cwtalarmnames_w.
"Create an alarm"
TRY.
lo_cwt->putmetricalarm(
iv_alarmname = iv_alarm_name
iv_comparisonoperator = iv_comparison_operator
iv_evaluationperiods = iv_evaluation_periods
iv_metricname = iv_metric_name
iv_namespace = iv_namespace
iv_statistic = iv_statistic
iv_threshold = iv_threshold
iv_actionsenabled = iv_actions_enabled
iv_alarmdescription = iv_alarm_description
iv_unit = iv_unit
iv_period = iv_period
it_dimensions = it_dimensions ).
MESSAGE 'Alarm created' TYPE 'I'.
CATCH /aws1/cx_cwtlimitexceededfault.
MESSAGE 'The request processing has exceeded the limit' TYPE 'E'.
ENDTRY.
"Create an ABAP internal table for the created alarm."
lo_alarmname = NEW #( iv_value = iv_alarm_name ).
INSERT lo_alarmname INTO TABLE lt_alarmnames.
"Disable alarm actions."
TRY.
lo_cwt->disablealarmactions(
it_alarmnames = lt_alarmnames ).
MESSAGE 'Alarm actions disabled' TYPE 'I'.
CATCH /aws1/cx_rt_service_generic INTO DATA(lo_disablealarm_exception).
DATA(lv_disablealarm_error) = |"{ lo_disablealarm_exception->av_err_code }" - { lo_disablealarm_exception->av_err_msg }|.
MESSAGE lv_disablealarm_error TYPE 'E'.
ENDTRY.
"Describe alarm using the same ABAP internal table."
TRY.
oo_result = lo_cwt->describealarms( " oo_result is returned for testing purpose "
it_alarmnames = lt_alarmnames ).
MESSAGE 'Alarms retrieved' TYPE 'I'.
CATCH /aws1/cx_rt_service_generic INTO DATA(lo_describealarms_exception).
DATA(lv_describealarms_error) = |"{ lo_describealarms_exception->av_err_code }" - { lo_describealarms_exception->av_err_msg }|.
MESSAGE lv_describealarms_error TYPE 'E'.
ENDTRY.
"Delete alarm."
TRY.
lo_cwt->deletealarms(
it_alarmnames = lt_alarmnames ).
MESSAGE 'Alarms deleted' TYPE 'I'.
CATCH /aws1/cx_cwtresourcenotfound.
MESSAGE 'Resource being access is not found.' TYPE 'E'.
ENDTRY.
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *API-Referenz zum AWS -SDK für SAP ABAP*.
+ [DeleteAlarms](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)
+ [DescribeAlarms](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)
+ [DisableAlarmActions](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)
+ [PutMetricAlarm](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)
------
# Verwalten Sie CloudWatch Metriken und Alarme mithilfe eines AWS SDK
Wie das aussehen kann, sehen Sie am nachfolgenden Beispielcode:
+ Erstellen Sie einen Alarm, um eine CloudWatch Metrik zu beobachten.
+ Geben Sie Daten in eine Metrik ein und lösen Sie den Alarm aus.
+ Rufen Sie Daten aus dem Alarm ab.
+ Löschen Sie den Alarm.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/cloudwatch#code-examples) einrichten und ausführen.
Erstellen Sie eine Klasse, die CloudWatch Operationen umschließt.
```
from datetime import datetime, timedelta
import logging
from pprint import pprint
import random
import time
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
class CloudWatchWrapper:
"""Encapsulates Amazon CloudWatch functions."""
def __init__(self, cloudwatch_resource):
"""
:param cloudwatch_resource: A Boto3 CloudWatch resource.
"""
self.cloudwatch_resource = cloudwatch_resource
def put_metric_data_set(self, namespace, name, timestamp, unit, data_set):
"""
Sends a set of data to CloudWatch for a metric. All of the data in the set
have the same timestamp and unit.
:param namespace: The namespace of the metric.
:param name: The name of the metric.
:param timestamp: The UTC timestamp for the metric.
:param unit: The unit of the metric.
:param data_set: The set of data to send. This set is a dictionary that
contains a list of values and a list of corresponding counts.
The value and count lists must be the same length.
"""
try:
metric = self.cloudwatch_resource.Metric(namespace, name)
metric.put_data(
Namespace=namespace,
MetricData=[
{
"MetricName": name,
"Timestamp": timestamp,
"Values": data_set["values"],
"Counts": data_set["counts"],
"Unit": unit,
}
],
)
logger.info("Put data set for metric %s.%s.", namespace, name)
except ClientError:
logger.exception("Couldn't put data set for metric %s.%s.", namespace, name)
raise
def create_metric_alarm(
self,
metric_namespace,
metric_name,
alarm_name,
stat_type,
period,
eval_periods,
threshold,
comparison_op,
):
"""
Creates an alarm that watches a metric.
:param metric_namespace: The namespace of the metric.
:param metric_name: The name of the metric.
:param alarm_name: The name of the alarm.
:param stat_type: The type of statistic the alarm watches.
:param period: The period in which metric data are grouped to calculate
statistics.
:param eval_periods: The number of periods that the metric must be over the
alarm threshold before the alarm is set into an alarmed
state.
:param threshold: The threshold value to compare against the metric statistic.
:param comparison_op: The comparison operation used to compare the threshold
against the metric.
:return: The newly created alarm.
"""
try:
metric = self.cloudwatch_resource.Metric(metric_namespace, metric_name)
alarm = metric.put_alarm(
AlarmName=alarm_name,
Statistic=stat_type,
Period=period,
EvaluationPeriods=eval_periods,
Threshold=threshold,
ComparisonOperator=comparison_op,
)
logger.info(
"Added alarm %s to track metric %s.%s.",
alarm_name,
metric_namespace,
metric_name,
)
except ClientError:
logger.exception(
"Couldn't add alarm %s to metric %s.%s",
alarm_name,
metric_namespace,
metric_name,
)
raise
else:
return alarm
def put_metric_data(self, namespace, name, value, unit):
"""
Sends a single data value to CloudWatch for a metric. This metric is given
a timestamp of the current UTC time.
:param namespace: The namespace of the metric.
:param name: The name of the metric.
:param value: The value of the metric.
:param unit: The unit of the metric.
"""
try:
metric = self.cloudwatch_resource.Metric(namespace, name)
metric.put_data(
Namespace=namespace,
MetricData=[{"MetricName": name, "Value": value, "Unit": unit}],
)
logger.info("Put data for metric %s.%s", namespace, name)
except ClientError:
logger.exception("Couldn't put data for metric %s.%s", namespace, name)
raise
def get_metric_statistics(self, namespace, name, start, end, period, stat_types):
"""
Gets statistics for a metric within a specified time span. Metrics are grouped
into the specified period.
:param namespace: The namespace of the metric.
:param name: The name of the metric.
:param start: The UTC start time of the time span to retrieve.
:param end: The UTC end time of the time span to retrieve.
:param period: The period, in seconds, in which to group metrics. The period
must match the granularity of the metric, which depends on
the metric's age. For example, metrics that are older than
three hours have a one-minute granularity, so the period must
be at least 60 and must be a multiple of 60.
:param stat_types: The type of statistics to retrieve, such as average value
or maximum value.
:return: The retrieved statistics for the metric.
"""
try:
metric = self.cloudwatch_resource.Metric(namespace, name)
stats = metric.get_statistics(
StartTime=start, EndTime=end, Period=period, Statistics=stat_types
)
logger.info(
"Got %s statistics for %s.", len(stats["Datapoints"]), stats["Label"]
)
except ClientError:
logger.exception("Couldn't get statistics for %s.%s.", namespace, name)
raise
else:
return stats
def get_metric_alarms(self, metric_namespace, metric_name):
"""
Gets the alarms that are currently watching the specified metric.
:param metric_namespace: The namespace of the metric.
:param metric_name: The name of the metric.
:returns: An iterator that yields the alarms.
"""
metric = self.cloudwatch_resource.Metric(metric_namespace, metric_name)
alarm_iter = metric.alarms.all()
logger.info("Got alarms for metric %s.%s.", metric_namespace, metric_name)
return alarm_iter
def delete_metric_alarms(self, metric_namespace, metric_name):
"""
Deletes all of the alarms that are currently watching the specified metric.
:param metric_namespace: The namespace of the metric.
:param metric_name: The name of the metric.
"""
try:
metric = self.cloudwatch_resource.Metric(metric_namespace, metric_name)
metric.alarms.delete()
logger.info(
"Deleted alarms for metric %s.%s.", metric_namespace, metric_name
)
except ClientError:
logger.exception(
"Couldn't delete alarms for metric %s.%s.",
metric_namespace,
metric_name,
)
raise
```
Verwenden Sie die Wrapper-Klasse, um Daten in eine Metrik einzugeben, einen Alarm auszulösen, der die Metrik überwacht, und Daten aus dem Alarm abzurufen.
```
def usage_demo():
print("-" * 88)
print("Welcome to the Amazon CloudWatch metrics and alarms demo!")
print("-" * 88)
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
cw_wrapper = CloudWatchWrapper(boto3.resource("cloudwatch"))
minutes = 20
metric_namespace = "doc-example-metric"
metric_name = "page_views"
start = datetime.utcnow() - timedelta(minutes=minutes)
print(
f"Putting data into metric {metric_namespace}.{metric_name} spanning the "
f"last {minutes} minutes."
)
for offset in range(0, minutes):
stamp = start + timedelta(minutes=offset)
cw_wrapper.put_metric_data_set(
metric_namespace,
metric_name,
stamp,
"Count",
{
"values": [
random.randint(bound, bound * 2)
for bound in range(offset + 1, offset + 11)
],
"counts": [random.randint(1, offset + 1) for _ in range(10)],
},
)
alarm_name = "high_page_views"
period = 60
eval_periods = 2
print(f"Creating alarm {alarm_name} for metric {metric_name}.")
alarm = cw_wrapper.create_metric_alarm(
metric_namespace,
metric_name,
alarm_name,
"Maximum",
period,
eval_periods,
100,
"GreaterThanThreshold",
)
print(f"Alarm ARN is {alarm.alarm_arn}.")
print(f"Current alarm state is: {alarm.state_value}.")
print(
f"Sending data to trigger the alarm. This requires data over the threshold "
f"for {eval_periods} periods of {period} seconds each."
)
while alarm.state_value == "INSUFFICIENT_DATA":
print("Sending data for the metric.")
cw_wrapper.put_metric_data(
metric_namespace, metric_name, random.randint(100, 200), "Count"
)
alarm.load()
print(f"Current alarm state is: {alarm.state_value}.")
if alarm.state_value == "INSUFFICIENT_DATA":
print(f"Waiting for {period} seconds...")
time.sleep(period)
else:
print("Wait for a minute for eventual consistency of metric data.")
time.sleep(period)
if alarm.state_value == "OK":
alarm.load()
print(f"Current alarm state is: {alarm.state_value}.")
print(
f"Getting data for metric {metric_namespace}.{metric_name} during timespan "
f"of {start} to {datetime.utcnow()} (times are UTC)."
)
stats = cw_wrapper.get_metric_statistics(
metric_namespace,
metric_name,
start,
datetime.utcnow(),
60,
["Average", "Minimum", "Maximum"],
)
print(
f"Got {len(stats['Datapoints'])} data points for metric "
f"{metric_namespace}.{metric_name}."
)
pprint(sorted(stats["Datapoints"], key=lambda x: x["Timestamp"]))
print(f"Getting alarms for metric {metric_name}.")
alarms = cw_wrapper.get_metric_alarms(metric_namespace, metric_name)
for alarm in alarms:
print(f"Alarm {alarm.name} is currently in state {alarm.state_value}.")
print(f"Deleting alarms for metric {metric_name}.")
cw_wrapper.delete_metric_alarms(metric_namespace, metric_name)
print("Thanks for watching!")
print("-" * 88)
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *API-Referenz zum AWS SDK für Python (Boto3)*.
+ [DeleteAlarms](https://docs.aws.amazon.com/goto/boto3/monitoring-2010-08-01/DeleteAlarms)
+ [DescribeAlarmsForMetric](https://docs.aws.amazon.com/goto/boto3/monitoring-2010-08-01/DescribeAlarmsForMetric)
+ [DisableAlarmActions](https://docs.aws.amazon.com/goto/boto3/monitoring-2010-08-01/DisableAlarmActions)
+ [EnableAlarmActions](https://docs.aws.amazon.com/goto/boto3/monitoring-2010-08-01/EnableAlarmActions)
+ [GetMetricStatistics](https://docs.aws.amazon.com/goto/boto3/monitoring-2010-08-01/GetMetricStatistics)
+ [ListMetrics](https://docs.aws.amazon.com/goto/boto3/monitoring-2010-08-01/ListMetrics)
+ [PutMetricAlarm](https://docs.aws.amazon.com/goto/boto3/monitoring-2010-08-01/PutMetricAlarm)
+ [PutMetricData](https://docs.aws.amazon.com/goto/boto3/monitoring-2010-08-01/PutMetricData)
------
# Überwachen Sie die Leistung von Amazon DynamoDB mithilfe eines SDK AWS
Im folgenden Codebeispiel wird gezeigt, wie die Verwendung von DynamoDB durch eine Anwendung zur Leistungsüberwachung konfiguriert wird.
------
#### [ Java ]
**SDK für Java 2.x**
Im folgenden Codebeispiel wird gezeigt, wie eine Java-Anwendung zur Leistungsüberwachung von DynamoDB konfiguriert wird. Die Anwendung sendet Metrikdaten, CloudWatch an die Sie die Leistung überwachen können.
Den vollständigen Quellcode und Anweisungen zur Einrichtung und Ausführung finden Sie im vollständigen Beispiel unter [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/monitor_dynamodb).
**In diesem Beispiel verwendete Dienste**
+ CloudWatch
+ DynamoDB
------