CloudWatch Metrics and Dashboards

Welcome to the next step in your AWS developer journey! So far, you have learned how to keep your applications secure by managing credentials and protecting your APIs. Now, we will focus on another critical aspect: monitoring your applications.

Monitoring is essential for both security and reliability. It helps you answer questions like:

• Is my application working as expected?
• Are there any unusual patterns or errors?
• How is my application performing over time?

AWS CloudWatch is a service that helps you collect, view, and analyze data from your applications. In this lesson, you will learn how to send your own custom data (called metrics) to CloudWatch and create dashboards to visualize this information. By the end, you will be able to track important numbers from your application and see them in real time.

Before we dive in, let's quickly remind ourselves about boto3. In previous lessons, you used boto3 to interact with AWS services like Secrets Manager and Lambda. boto3 is the official AWS SDK for Python, and it allows you to connect to AWS services directly from your code.

For example, to use a service, you typically create a client like this:

import boto3

# Create a client for AWS CloudWatch
cw = boto3.client('cloudwatch')

This cw object lets you call CloudWatch functions from your Python code. You will use this same approach to send metrics and create dashboards in this lesson.

Before we start coding, let's visualize how the pieces fit together:

┌─────────────────────┐
│  Python Application │
│   (Your Code)       │
└──────────┬──────────┘
           │
           │ boto3.client('cloudwatch')
           │ put_metric_data()
           ↓
┌─────────────────────┐
│   AWS CloudWatch    │
│  (Stores Metrics)   │
└──────────┬──────────┘
           │
           │ Visualizes
           ↓
┌─────────────────────┐
│  CloudWatch         │
│  Dashboard          │
└─────────────────────┘

This diagram shows the complete flow:

1. Your Python application sends metrics to CloudWatch using boto3
2. CloudWatch receives and stores these metrics
3. A dashboard displays the metrics visually for monitoring

Important note about timing: When you send metrics to CloudWatch, they don't appear instantly. It can take several minutes (typically 2-5 minutes) for your metrics to show up in the CloudWatch console or on dashboards. This is normal behavior—CloudWatch processes and aggregates data in the background. So if you don't see your metrics right away, be patient and refresh the dashboard after a few minutes.

Now let's implement this flow step by step.

A metric is just a number that tells you something about your application. For example, you might want to track the value of each order placed in your app.

Let's see how to send a custom metric to CloudWatch step by step.

First, you need to import the libraries you will use. You will need boto3 for AWS and some standard libraries for working with time and random numbers.

import time
import random
import boto3

• time helps you add timestamps to your metrics.
• random is used here to generate example data.
• boto3 is for connecting to AWS CloudWatch.

Next, create a CloudWatch client using boto3:

cw = boto3.client('cloudwatch')

This line sets up the connection to CloudWatch.

Now, let's write a function that sends a single metric value to CloudWatch. We will call this metric OrderValue.

def put_metric_value(value):
    """Emit a single metric data point to CloudWatch"""
    cw.put_metric_data(
        Namespace="App/Metrics",
        MetricData=[{
            "MetricName": "OrderValue",
            "Dimensions": [{"Name":"Service","Value":"OrdersAPI"}],
            "Timestamp": time.time(),
            "Value": value
        }]
    )

Let's break down what's happening here:

• Namespace is a way to group related metrics. Here, we use "App/Metrics".
• MetricName is the name of the metric, in this case, "OrderValue".
• Dimensions are extra labels to help you filter or group your data. Here, we label the metric with "Service": "OrdersAPI".
• Timestamp records when the metric was sent.
• Value is the actual number you want to track.

Let's send a few example metrics to CloudWatch. We'll use random numbers to simulate order values.

for i in range(5):
    value = random.uniform(10, 200)
    put_metric_value(value)
    print(f"Emitted metric: OrderValue = {value:.2f}")
    time.sleep(1)

This code will:

• Generate a random order value between 10 and 200.
• Send it to CloudWatch using your function.
• Print out what was sent.
• Wait one second before sending the next value.

Example output:

Emitted metric: OrderValue = 153.27
Emitted metric: OrderValue = 45.12
Emitted metric: OrderValue = 189.03
Emitted metric: OrderValue = 77.56
Emitted metric: OrderValue = 120.44

Now, you have sent custom metrics to CloudWatch!

A dashboard in CloudWatch is a visual display of your metrics. It helps you see trends and spot problems quickly.

Let's see how to create a dashboard step by step.

You will need the json library to build the dashboard configuration.

import json

Now, let's write a function that creates a dashboard and adds a widget to show your OrderValue metric.

def create_dashboard():
    """Create CloudWatch dashboard to visualize metrics"""
    widget = {
        "type":"metric","x":0,"y":0,"width":12,"height":6,
        "properties":{
            "metrics":[["App/Metrics","OrderValue","Service","OrdersAPI"]],
            "stat":"Average","title":"Order Value",
            "region":"us-east-1",  # Add your AWS region here
            "annotations":{"horizontal":[]},
            "period":300
        }
    }
    cw.put_dashboard(
        DashboardName="App-Overview", 
        DashboardBody=json.dumps({"widgets":[widget]})
    )

Here's what's happening:

• We define a widget that tells CloudWatch what to display.
• The widget shows the average value of the OrderValue metric for the OrdersAPI service.
• The dashboard is named "App-Overview".
• The dashboard is created or updated using cw.put_dashboard.

Now, call the function to create the dashboard:

create_dashboard()
print("Dashboard 'App-Overview' created successfully!")

Example output:

Dashboard 'App-Overview' created successfully!

You can now go to the AWS CloudWatch console and see your dashboard with the OrderValue metric displayed.

In this lesson, you learned how to:

• Send custom metrics from your application to AWS CloudWatch using Python and boto3.
• Create a CloudWatch dashboard to visualize your metrics in real time.

These skills help you keep an eye on your application's health and performance, which is important for both security and reliability.

Next, you will get hands-on practice by emitting your own metrics and building dashboards in the CodeSignal environment. Remember, on CodeSignal, the required libraries are already installed, so you can focus on writing and running your code.

Great job making it this far! You are now ready to monitor your own AWS applications and gain valuable insights from your data.