---
title: Amazon EBS
description: >-
  Amazon EBS provides persistent block storage volumes for use with Amazon EC2
  instances in the AWS Cloud.
breadcrumbs: Docs > Integrations > Amazon EBS
---

> For the complete documentation index, see [llms.txt](https://docs.datadoghq.com/llms.txt).

# Amazon EBS
Integration version1.1.0
{% callout %}
# Important note for users on the following Datadog sites: us2.ddog-gov.com

{% alert level="info" %}
To find out if this integration is available in your organization, see your [Datadog Integrations](https://app.datadoghq.com/integrations) page or ask your organization administrator.

To initiate an exception request to enable this integration for your organization, email [support@ddog-gov.com](mailto:support@ddog-gov.com).
{% /alert %}

{% /callout %}

## Overview{% #overview %}

Amazon EBS provides persistent block storage volumes for use with Amazon EC2 instances in the AWS Cloud.

Enable this integration to see in Datadog all your EBS metrics.

## Setup{% #setup %}

### Installation{% #installation %}

If you haven't already, set up the [Amazon Web Services integration](https://docs.datadoghq.com/integrations/amazon_web_services.md).

### Metric collection{% #metric-collection %}

1. In the [AWS integration page](https://app.datadoghq.com/integrations/amazon-web-services), ensure that `EBS` is enabled under the `Metric Collection` tab.
1. Install the [Datadog - Amazon EBS integration](https://app.datadoghq.com/integrations/amazon-ebs).

**Note**: This integration collects metrics for EBS volumes attached to a monitored EC2. To collect all EBS metrics, make sure that EC2 is checked in the [AWS integration page](https://app.datadoghq.com/integrations/amazon-web-services) and that the EC2 is not excluded from monitoring with the [limit resource collection](https://docs.datadoghq.com/account_management/billing/aws.md#aws-resource-exclusion) setting.

### Log collection{% #log-collection %}

#### Enable logging{% #enable-logging %}

Configure Amazon EBS to send logs either to a S3 bucket or to CloudWatch.

**Note**: If you log to a S3 bucket, make sure that `amazon_ebs` is set as *Target prefix*.

#### Send logs to Datadog{% #send-logs-to-datadog %}

1. If you haven't already, set up the [Datadog Forwarder Lambda function](https://docs.datadoghq.com/logs/guide/forwarder.md).

1. Once the Lambda function is installed, manually add a trigger on the S3 bucket or CloudWatch log group that contains your Amazon EBS logs in the AWS console:

   - [Add a manual trigger on the S3 bucket](https://docs.datadoghq.com/logs/guide/send-aws-services-logs-with-the-datadog-lambda-function.md#collecting-logs-from-s3-buckets)
   - [Add a manual trigger on the CloudWatch Log Group](https://docs.datadoghq.com/logs/guide/send-aws-services-logs-with-the-datadog-lambda-function.md#collecting-logs-from-cloudwatch-log-group)

## Data Collected{% #data-collected %}

### Metrics{% #metrics %}

|  |
|  |
| **aws.ebs.burst_balance**(gauge)                                 | Balance available in the burst bucket. This metric contains values for all volume types including io1.*Shown as percent*                                                                                                                                                                                                                                         |
| **aws.ebs.enable_copied_image_deprecation_completed**(count)  | The number of cross-Region AMI copies that were marked for deprecation by an EBS-backed AMI policy.                                                                                                                                                                                                                                                              |
| **aws.ebs.enable_copied_image_deprecation_failed**(count)     | The number of cross-Region AMI copies that could not be marked for deprecation by an EBS-backed AMI policy.                                                                                                                                                                                                                                                      |
| **aws.ebs.enable_image_deprecation_completed**(count)          | The number of AMIs that were marked for deprecation by an EBS-backed AMI policy.                                                                                                                                                                                                                                                                                 |
| **aws.ebs.enable_image_deprecation_failed**(count)             | The number of AMIs that could not be marked for deprecation by an EBS-backed AMI policy.                                                                                                                                                                                                                                                                         |
| **aws.ebs.fast_snapshot_restore_credits_balance**(gauge)      | The number of volume create credits available.                                                                                                                                                                                                                                                                                                                   |
| **aws.ebs.fast_snapshot_restore_credits_bucket_size**(gauge) | The maximum number of volume create credits that can be accumulated.                                                                                                                                                                                                                                                                                             |
| **aws.ebs.images_copied_region_completed**(count)              | The number of cross-Region AMI copies created by an EBS-backed AMI policy.                                                                                                                                                                                                                                                                                       |
| **aws.ebs.images_copied_region_deregister_completed**(count)  | The number of cross-Region AMI copies deregistered, as designated by the retention rule, by an EBS-backed AMI policy.                                                                                                                                                                                                                                            |
| **aws.ebs.images_copied_region_deregister_failed**(count)     | The number of cross-Region AMI copies that could not be deregistered, as designated by the retention rule, by an EBS-backed AMI policy.                                                                                                                                                                                                                          |
| **aws.ebs.images_copied_region_failed**(count)                 | The number of cross-Region AMI copies that could not be created by an EBS-backed AMI policy.                                                                                                                                                                                                                                                                     |
| **aws.ebs.images_copied_region_started**(count)                | The number of cross-Region copy actions initiated by an EBS-backed AMI policy.                                                                                                                                                                                                                                                                                   |
| **aws.ebs.images_create_completed**(count)                      | The number of AMIs created by an EBS-backed AMI policy.                                                                                                                                                                                                                                                                                                          |
| **aws.ebs.images_create_failed**(count)                         | The number of AMIs that could not be created by an EBS-backed AMI policy.                                                                                                                                                                                                                                                                                        |
| **aws.ebs.images_create_started**(count)                        | The number of CreateImage actions initiated by an EBS-backed AMI policy.                                                                                                                                                                                                                                                                                         |
| **aws.ebs.images_deregister_completed**(count)                  | The number of AMIs deregistered by an EBS-backed AMI policy.                                                                                                                                                                                                                                                                                                     |
| **aws.ebs.images_deregister_failed**(count)                     | The number of AMIs that could not be deregistered by an EBS-backed AMI policy.                                                                                                                                                                                                                                                                                   |
| **aws.ebs.post_script_completed**(count)                        | The number of instances for which a post script was successfully completed.                                                                                                                                                                                                                                                                                      |
| **aws.ebs.post_script_failed**(count)                           | The number of instances for which a post script failed to complete successfully.                                                                                                                                                                                                                                                                                 |
| **aws.ebs.post_script_started**(count)                          | The number of instances for which a post script was successfully initiated.                                                                                                                                                                                                                                                                                      |
| **aws.ebs.pre_script_completed**(count)                         | The number of instances for which a pre script was successfully completed.                                                                                                                                                                                                                                                                                       |
| **aws.ebs.pre_script_failed**(count)                            | The number of instances for which a pre script failed to complete successfully.                                                                                                                                                                                                                                                                                  |
| **aws.ebs.pre_script_started**(count)                           | The number of instances for which a pre script was successfully initiated.                                                                                                                                                                                                                                                                                       |
| **aws.ebs.resources_targeted**(count)                            | The number of resources targeted by the tags specified in a snapshot or EBS-backed AMI policy.*Shown as resource*                                                                                                                                                                                                                                                |
| **aws.ebs.snapshots_archive_deletion_completed**(count)        | The number of archived snapshots that were successfully deleted from the archive tier by a snapshot policy.                                                                                                                                                                                                                                                      |
| **aws.ebs.snapshots_archive_deletion_failed**(count)           | The number of archived snapshots that could not be deleted from the archive tier by a snapshot policy.                                                                                                                                                                                                                                                           |
| **aws.ebs.snapshots_archive_scheduled**(count)                  | The number of snapshots that were scheduled to be archived by a snapshot policy.                                                                                                                                                                                                                                                                                 |
| **aws.ebs.snapshots_copied_region_completed**(count)           | The number of cross-Region snapshot copies created by a snapshot policy.                                                                                                                                                                                                                                                                                         |
| **aws.ebs.snapshots_copied_region_delete_completed**(count)   | The number of cross-Region snapshot copies deleted, as designated by the retention rule, by a snapshot policy.                                                                                                                                                                                                                                                   |
| **aws.ebs.snapshots_copied_region_delete_failed**(count)      | The number of cross-Region snapshot copies that could not be deleted, as designated by the retention rule, by a snapshot policy.                                                                                                                                                                                                                                 |
| **aws.ebs.snapshots_copied_region_failed**(count)              | The number of cross-Region snapshot copies that could not be created by a snapshot policy.                                                                                                                                                                                                                                                                       |
| **aws.ebs.snapshots_copied_region_started**(count)             | The number of cross-Region snapshot copy actions initiated by a snapshot policy.                                                                                                                                                                                                                                                                                 |
| **aws.ebs.snapshots_create_completed**(count)                   | The number of snapshots created by a snapshot policy.                                                                                                                                                                                                                                                                                                            |
| **aws.ebs.snapshots_create_failed**(count)                      | The number of snapshots that could not be created by a snapshot policy.                                                                                                                                                                                                                                                                                          |
| **aws.ebs.snapshots_create_started**(count)                     | The number of snapshot create actions initiated by a snapshot policy.                                                                                                                                                                                                                                                                                            |
| **aws.ebs.snapshots_delete_completed**(count)                   | The number of snapshots deleted by a snapshot or EBS-backed AMI policy.                                                                                                                                                                                                                                                                                          |
| **aws.ebs.snapshots_delete_failed**(count)                      | The number of snapshots that could not be deleted by a snapshot or EBS-backed AMI policy.                                                                                                                                                                                                                                                                        |
| **aws.ebs.snapshots_shared_completed**(count)                   | The number of snapshots shared across accounts by a snapshot policy.                                                                                                                                                                                                                                                                                             |
| **aws.ebs.snapshots_shared_failed**(count)                      | The number of snapshots that could not be shared by a snapshot policy.                                                                                                                                                                                                                                                                                           |
| **aws.ebs.volume_avg_iops**(gauge)                              | The average read and write IOPS driven to the volume in a minute. Supported for all EBS volume types attached to Nitro instances.*Shown as operation*                                                                                                                                                                                                            |
| **aws.ebs.volume_avg_read_latency**(gauge)                     | The average time taken to complete read operations in a minute. Supported for all volume types attached to Nitro instances.*Shown as millisecond*                                                                                                                                                                                                                |
| **aws.ebs.volume_avg_read_latency.maximum**(gauge)             | Maximum time taken to complete read operations in a minute. Supported for all volume types attached to Nitro instances.*Shown as millisecond*                                                                                                                                                                                                                    |
| **aws.ebs.volume_avg_read_latency.minimum**(gauge)             | Minimum time taken to complete read operations in a minute. Supported for all volume types attached to Nitro instances.*Shown as millisecond*                                                                                                                                                                                                                    |
| **aws.ebs.volume_avg_throughput**(gauge)                        | The average read and write throughput driven to the volume in a minute, in KiB/s. Supported for all EBS volume types attached to Nitro instances.*Shown as kibibyte*                                                                                                                                                                                             |
| **aws.ebs.volume_avg_write_latency**(gauge)                    | The average time taken to complete write operations in a minute. Supported for all volume types attached to Nitro instances.*Shown as millisecond*                                                                                                                                                                                                               |
| **aws.ebs.volume_avg_write_latency.maximum**(gauge)            | Maximum time taken to complete write operations in a minute. Supported for all volume types attached to Nitro instances.*Shown as millisecond*                                                                                                                                                                                                                   |
| **aws.ebs.volume_avg_write_latency.minimum**(gauge)            | Minimum time taken to complete write operations in a minute. Supported for all volume types attached to Nitro instances.*Shown as millisecond*                                                                                                                                                                                                                   |
| **aws.ebs.volume_consumed_read_write_ops**(count)             | The total amount of read and write operations (normalized to 256K capacity units). Only for io1 volume types.                                                                                                                                                                                                                                                    |
| **aws.ebs.volume_consumed_read_write_ops.maximum**(count)     | The maximum amount of read and write operations (normalized to 256K capacity units). Only for io1 volume types.                                                                                                                                                                                                                                                  |
| **aws.ebs.volume_idle_time**(gauge)                             | The total number of seconds in a specified period of time when no read or write operations were submitted. This metric contains values for all volume types including io1.*Shown as second*                                                                                                                                                                      |
| **aws.ebs.volume_iopsexceeded_check**(gauge)                    | Reports whether an application consistently attempted to drive IOPS that exceeds the volume's provisioned IOPS performance within the last minute. This metric can be either 0 (provisioned IOPS not exceeded) or 1 (provisioned IOPS exceeded). Supported for all volume types except magnetic (standard), attached to Nitro instances.                         |
| **aws.ebs.volume_queue_length**(gauge)                          | The number of read and write operation requests waiting to be completed. This metric contains values for all volume types including io1.                                                                                                                                                                                                                         |
| **aws.ebs.volume_read_bytes**(gauge)                            | Average size of each read operation. This metric contains values for all volume types including io1.*Shown as byte*                                                                                                                                                                                                                                              |
| **aws.ebs.volume_read_bytes.sum**(gauge)                        | Total number of bytes read by read operations. This metric contains values for all volume types including io1.*Shown as byte*                                                                                                                                                                                                                                    |
| **aws.ebs.volume_read_ops**(count)                              | The total number of read operations. This metric contains values for all volume types including io1.*Shown as operation*                                                                                                                                                                                                                                         |
| **aws.ebs.volume_read_ops.maximum**(count)                      | The maximum number of read operations for a volume (only for volumes attached to Nitro-based instances).*Shown as operation*                                                                                                                                                                                                                                     |
| **aws.ebs.volume_throughput_exceeded_check**(gauge)            | Reports whether an application consistently attempted to drive throughput that exceeds the volume's provisioned throughput performance within the last minute. This metric can be either 0 (provisioned throughput not exceeded) or 1 (provisioned throughput exceeded). Supported for all volume types except magnetic (standard), attached to Nitro instances. |
| **aws.ebs.volume_throughput_percentage**(gauge)                 | The percentage of I/O operations per second (IOPS) delivered of the total IOPS provisioned for an Amazon EBS volume. Only for io1 volume types.*Shown as percent*                                                                                                                                                                                                |
| **aws.ebs.volume_total_read_time**(gauge)                      | The Average time spent by read operations. This metric contains values for all volume types including io1.*Shown as second*                                                                                                                                                                                                                                      |
| **aws.ebs.volume_total_read_time.sum**(gauge)                  | The total number of seconds spent for read operations. This metric contains values for all volume types including io1.*Shown as second*                                                                                                                                                                                                                          |
| **aws.ebs.volume_stalled_io_check**(gauge)                     | Reports whether a volume has passed or failed a stalled IO check in the last minute. This metric can be either 0 (passed) or 1 (failed)                                                                                                                                                                                                                          |
| **aws.ebs.volume_total_write_time**(gauge)                     | The average time spent by write operations. This metric contains values for all volume types including io1.*Shown as second*                                                                                                                                                                                                                                     |
| **aws.ebs.volume_total_write_time.sum**(gauge)                 | The total number of seconds spent for write operations. This metric contains values for all volume types including io1.*Shown as second*                                                                                                                                                                                                                         |
| **aws.ebs.volume_write_bytes**(gauge)                           | Average size of each write operation. This metric contains values for all volume types including io1.*Shown as byte*                                                                                                                                                                                                                                             |
| **aws.ebs.volume_write_bytes.sum**(gauge)                       | Total amount of bytes written by write operations. This metric contains values for all volume types including io1.*Shown as byte*                                                                                                                                                                                                                                |
| **aws.ebs.volume_write_ops**(count)                             | The total number of write operations. This metric contains values for all volume types including io1.*Shown as operation*                                                                                                                                                                                                                                        |
| **aws.ebs.volume_write_ops.maximum**(count)                     | The maximum number of write operations for a volume (only for volumes attached to Nitro-based instances).*Shown as operation*                                                                                                                                                                                                                                    |
| **aws.ebs.vss_backup_completed**(count)                         | The number of instances for which a VSS backup was successfully completed.                                                                                                                                                                                                                                                                                       |
| **aws.ebs.vss_backup_failed**(count)                            | The number of instances for which a VSS backup failed to complete successfully.                                                                                                                                                                                                                                                                                  |
| **aws.ebs.vss_backup_started**(count)                           | The number of instances for which a VSS backup was successfully initiated.                                                                                                                                                                                                                                                                                       |
| **aws.ebs.burst_balance.io1**(gauge)                             | Balance available in the burst bucket. Better granularity but only for io1 volumes.*Shown as percent*                                                                                                                                                                                                                                                            |
| **aws.ebs.snapshot_age**(gauge)                                  | Time since the most recent complete snapshot was created*Shown as second*                                                                                                                                                                                                                                                                                        |
| **aws.ebs.status.impaired**(gauge)                                | The number of EBS volumes with the impaired status.                                                                                                                                                                                                                                                                                                              |
| **aws.ebs.status.insufficient_data**(gauge)                      | The number of EBS volumes with the insufficient-data status.                                                                                                                                                                                                                                                                                                     |
| **aws.ebs.status.ok**(gauge)                                      | The number of EBS volumes with the ok status.                                                                                                                                                                                                                                                                                                                    |
| **aws.ebs.status.warning**(gauge)                                 | The number of EBS volumes with the warning status.                                                                                                                                                                                                                                                                                                               |
| **aws.ebs.volume_idle_time.io1**(gauge)                         | The total number of seconds in a specified period of time when no read or write operations were submitted. Better granularity but only for io1 volumes.*Shown as second*                                                                                                                                                                                         |
| **aws.ebs.volume_queue_length.io1**(gauge)                      | The number of read and write operation requests waiting to be completed. Better granularity but only for io1 volumes.                                                                                                                                                                                                                                            |
| **aws.ebs.volume_read_bytes.io1**(gauge)                        | Average size of each read operation. Better granularity but only for io1 volumes.*Shown as byte*                                                                                                                                                                                                                                                                 |
| **aws.ebs.volume_read_bytes.sum.io1**(gauge)                    | Total number of bytes read by read operations. Better granularity but only for io1 volumes.*Shown as byte*                                                                                                                                                                                                                                                       |
| **aws.ebs.volume_read_ops.io1**(count)                          | The total number of read operations. Better granularity but only for io1 volumes.*Shown as operation*                                                                                                                                                                                                                                                            |
| **aws.ebs.volume_total_read_time.io1**(gauge)                  | The Average time spent by read operations. Better granularity but only for io1 volumes.*Shown as second*                                                                                                                                                                                                                                                         |
| **aws.ebs.volume_total_read_time.sum.io1**(gauge)              | The total number of seconds spent for read operations. Better granularity but only for io1 volumes.*Shown as second*                                                                                                                                                                                                                                             |
| **aws.ebs.volume_total_write_time.io1**(gauge)                 | The average time spent by write operations. Better granularity but only for io1 volumes.*Shown as second*                                                                                                                                                                                                                                                        |
| **aws.ebs.volume_total_write_time.sum.io1**(gauge)             | The total number of seconds spent for write operations. Better granularity but only for io1 volumes.*Shown as second*                                                                                                                                                                                                                                            |
| **aws.ebs.volume_write_bytes.io1**(gauge)                       | Average size of each write operation. Better granularity but only for io1 volumes.*Shown as byte*                                                                                                                                                                                                                                                                |
| **aws.ebs.volume_write_bytes.sum.io1**(gauge)                   | Total amount of bytes written by write operations. Better granularity but only for io1 volumes.*Shown as byte*                                                                                                                                                                                                                                                   |
| **aws.ebs.volume_write_ops.io1**(count)                         | The total number of write operations. Better granularity but only for io1 volumes.*Shown as operation*                                                                                                                                                                                                                                                           |

Each of the metrics retrieved from AWS are assigned the same tags that appear in the AWS console, including but not limited to host name, security-groups, and more.

### Events{% #events %}

The Amazon EBS integration does not include any events.

### Service Checks{% #service-checks %}

The Amazon EBS integration does not include any service checks.

## Troubleshooting{% #troubleshooting %}

Need help? Contact [Datadog support](https://docs.datadoghq.com/help/).

## Further Reading{% #further-reading %}

Additional helpful documentation, links, and articles:

- [Key metrics for Amazon EBS monitoring](https://www.datadoghq.com/blog/amazon-ebs-monitoring)
- [Collecting Amazon EBS metrics](https://www.datadoghq.com/blog/collecting-amazon-ebs-metrics)
- [Monitoring Amazon EBS volumes with Datadog](https://www.datadoghq.com/blog/monitoring-amazon-ebs-volumes-with-datadog)
