# 使用 CloudWatch Metrics Insights 查询 CloudWatch 指标
<a name="query_with_cloudwatch-metrics-insights"></a>

CloudWatch Metrics Insights 是一个功能强大的高性能 SQL 查询引擎，您可以使用它来大规模查询指标。您可以实时识别 CloudWatch 所有指标的趋势和模式，并可访问长达两周的历史数据，开展全面的趋势分析。

您还可以对返回单个时间序列的任何 Metrics Insights 查询设置告警。这对于创建告警以监视基础设施或应用程序实例集的聚合指标特别有用。只需创建一次告警，它就会随着实例集添加或删除资源而动态调整。

 您可以使用 CloudWatch Metrics Insights 查询编辑器在控制台中执行 CloudWatch Metrics Insights 查询。您还可以通过运行 `GetMetricData` 或 `PutDashboard` 来使用 AWS CLI 或 AWS SDK 执行 CloudWatch Metrics Insights 查询。使用 CloudWatch Metrics Insights 查询编辑器运行的查询不收取任何费用。有关 CloudWatch 定价的信息，请参阅 [Amazon CloudWatch 定价](https://aws.amazon.com/cloudwatch/pricing/)。

 通过 CloudWatch Metris Insights 查询编辑器，您可以从各种预构建的示例查询中进行选择，也可以创建自己的查询。在创建查询时，您可以利用构建器视图浏览现有的指标和维度。或者，也可以利用编辑器视图手动编写查询。

借助 Metric Insights，您可以大规模运行查询。通过 **GROUP BY** 子句，您可以将指标实时分组为每个特定维度值的不同时间序列。Metrics Insights 查询包含**排序依据**功能，因此您可以使用 Metrics Insights 执行“前 N 个”类型的查询。例如，“前 N 个”类型的查询可以扫描账户中的数百万个指标，并返回 CPU 占用量最大的前 10 个实例。这有助于查明和修复应用程序中的延迟问题。若要为警报添加标签功能，需通过 CloudWatch 设置启用该功能。标签功能启用后，还可借助 AWS 资源标签对指标进行筛选和分组，从而能够按组织架构维度（如按应用程序、环境或团队）查询指标数据，实现指标与组织架构的精准匹配。

**Topics**
+ [在 CloudWatch Metrics Insights 中构建查询](cloudwatch-metrics-insights-buildquery.md)
+ [CloudWatch Metrics Insights 中的查询组件和语法](cloudwatch-metrics-insights-querylanguage.md)
+ [CloudWatch 中的 CloudWatch Metrics Insights 查询警报](cloudwatch-metrics-insights-alarms.md)
+ [将 Metrics Insights 查询与指标数学配合使用](cloudwatch-metrics-insights-math.md)
+ [使用自然语言生成与更新 CloudWatch Metrics Insights 查询](cloudwatch-metrics-insights-query-assist.md)
+ [SQL 推理](cloudwatch-metrics-insights-inference.md)
+ [Metrics Insights 配额](cloudwatch-metrics-insights-limits.md)
+ [Metrics Insights 示例查询](cloudwatch-metrics-insights-queryexamples.md)
+ [Metrics Insights 术语表](cloudwatch-metrics-insights-glossary.md)
+ [Metrics Insights 问题排查](cloudwatch-metrics-insights-troubleshooting.md)

# 在 CloudWatch Metrics Insights 中构建查询
<a name="cloudwatch-metrics-insights-buildquery"></a>

您可以使用 CloudWatch 控制台、AWS CLI 或者 AWS SDK 来运行 CloudWatch Metrics Insights 查询。在控制台中运行的查询免费。有关 CloudWatch 定价的信息，请参阅 [Amazon CloudWatch 定价](https://aws.amazon.com/cloudwatch/pricing/)。

借助 CloudWatch Metrics Insights，您可以分析长达两周的指标数据，与较短的保留期相比，可以实现更全面的历史分析和趋势识别。为了在查询较长的时间范围时获得最佳效果，建议采用更大的时间粒度（例如 5 分钟或 1 小时）来减少返回的数据点数。在分析整整两周的趋势时，请在 ORDER BY 子句中使用 AVG() 或 MAX() 之类的聚合函数来有效地识别模式。

有关使用 AWS SDK 执行 Metrics Insights 查询的更多信息，请参阅 [GetMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricData.html)。

要使用 CloudWatch 控制台运行查询，请执行以下步骤：

**使用 Metrics Insights 查询指标**

1. 通过 [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) 打开 CloudWatch 控制台。

1. 在导航窗格中，依次选择 **Metrics**（指标）、**All metrics**（所有指标）。

1. （可选）要运行预构建的示例查询，请选择 **Add query**（添加查询），然后选择要运行的查询。如果您对此查询满意，您可以跳过此过程的其余部分。或者，您可以选择 **Editor**（编辑器）来编辑示例查询，然后选择 **Run**（运行）以运行修改后的查询。

1. 要创建您自己的查询，请选择**多来源查询**。您可通过**构建器**视图（默认视图）获得向导式操作体验；若希望直接编写查询语法，可切换到**编辑器**视图。您可以随时在两个视图之间切换，并在两个视图中查看正在进行的工作。

   在**构建器**视图中，单击命名空间、指标名称、筛选条件、分组、排序及限制条件对应的输入框，即可浏览并选择可选值。您也可在输入框中输入目标值的任意部分，对构建器展示的候选列表进行筛选。筛选条件和分组的输入框中可引用资源标签。

   在**编辑器**视图中，您可使用 Metrics Insights 支持的 SQL 子集编写查询语句。编辑器会根据您已输入的字符提供自动补全建议，包括支持标签的指标对应的资源标签名称。

   CloudWatch Metrics Insights 支持按 AWS 资源标签查询指标。您可通过标签对指标数据进行筛选和分组，实现更具针对性的监控与分析。

   以下示例将演示如何在查询语句中结合标签使用。

   查看生产环境中 Amazon EC2 实例的 CPU 利用率：

   ```
   SELECT MAX(CPUUtilization) FROM SCHEMA("AWS/EC2") WHERE tag.env='prod'
   ```

   使用 GROUP BY 子句按环境维度对指标进行分组：

   ```
   SELECT MAX(CPUUtilization) FROM SCHEMA("AWS/EC2") GROUP BY tag.env
   ```

   在 GROUP BY 子句中指定标签名的用法：

   ```
   SELECT AVG(CPUUtilization) FROM "AWS/EC2" GROUP BY tag."aws:cloudformation:stack-name"
   ```

   将标签查询与现有指标维度相结合：

   ```
   SELECT MAX(CPUUtilization) FROM SCHEMA("AWS/EC2") WHERE tag.env='prod' AND InstanceId='i-1234567890abcdef0'
   ```

1. 如果对查询感到满意，请选择 **Run**（运行）。

1. （可选）编辑已绘制图表查询的另一种方法是选择 **Graphed metrics**（已绘制图表指标）选项卡，然后选择 **Details**（详细信息）列中查询公式旁边的编辑图标。

1. （可选）要从图表中删除查询，请选择 **Graphed metrics**（已绘制图表指标），然后选择显示查询一行右侧的 **X** 图标。

# CloudWatch Metrics Insights 中的查询组件和语法
<a name="cloudwatch-metrics-insights-querylanguage"></a>

CloudWatch Metrics Insights 语法如下。

```
SELECT FUNCTION(metricName)
FROM namespace | SCHEMA(...)
[ WHERE labelKey OPERATOR labelValue [AND ... ] ]
[ GROUP BY labelKey [ , ... ] ]
[ ORDER BY FUNCTION() [ DESC | ASC ] ]
[ LIMIT number ]
```

Metrics Insights 查询中可能的子句如下。关键字不区分大小写，但是指标名称、命名空间和维度等标识符需区分大小写。

**SELECT**  
必需。指定用于聚合每个时间段的观测值的函数（由提供的时段确定）。还可以指定要查询的指标的名称。  
**FUNCTION** 的有效值为 `AVG`、`COUNT`、`MAX`、`MIN` 和 `SUM`。  
+ `AVG` 计算查询匹配的观测值的平均值。
+ `COUNT` 返回查询匹配的观测值的计数。
+ `MAX` 返回查询匹配的观测值的最大值。
+ `MIN` 返回查询匹配的观测值的最小值。
+ `SUM` 计算查询匹配的观测值的总和。

**FROM**  
必需。指定指标源。您可以指定包含要查询的指标的指标命名空间，也可以指定 **SCHEMA** 表函数。指标命名空间的示例包括：`"AWS/EC2"`、`"AWS/Lambda"` 以及您为自定义指标创建的指标命名空间。  
包括 **/** 或任何其他不是字母、数字或下划线的字符在内的指标命名空间必须放在双引号中。有关更多信息，请参阅 [什么内容需要引号或转义字符？](#cloudwatch-metrics-insights-syntaxdetails)。  
**SCHEMA**  
一个可以在 **FROM** 子句中使用的可选表函数。使用 **SCHEMA** 将查询结果范围缩小到仅与维度列表完全匹配的指标或没有维度的指标。  
如果您使用 **SCHEMA** 子句，它必须包含至少一个参数，并且第一个参数必须是被查询的指标命名空间。如果您仅用此命名空间参数指定 **SCHEMA**，则结果范围只限于没有任何维度的指标。  
如果您使用其他参数指定 **SCHEMA**，命名空间参数之后的其他参数必须为*标注*键。标签键必须是维度名称。如果您指定了一个或多个标签键，则结果范围仅限于具有该确切维度集的指标。这些标签键的顺序无关紧要。  
例如：  
+ **SELECT AVG(CPUUtilization) FROM "AWS/EC2"** 匹配 `AWS/EC2` 命名空间中的所有 `CPUUtilization` 指标（无论它们的维度如何），并且会返回单个聚合时间序列。
+ **SELECT AVG(CPUUtilization) FROM SCHEMA("AWS/EC2")** 只匹配 `AWS/EC2` 命名空间中没有定义任何维度的 `CPUUtilization` 指标。
+ **SELECT AVG(CPUUtilization) FROM SCHEMA("AWS/EC2", InstanceId)** 只匹配向 CloudWatch 报告且只有一个维度（即 `CPUUtilization`）的 `InstanceId` 指标。
+ **SELECT SUM(RequestCount) FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone)** 只匹配从 `AWS/ApplicationELB` 向 CloudWatch 报告且只带有 `LoadBalancer` 和 `AvailabilityZone` 两个维度的 `RequestCount` 指标。

**WHERE**  
可选。使用一个或多个标签键的特定标签值，将结果筛选为仅与指定表达式匹配的指标。例如，**WHERE InstanceType = 'c3.4xlarge'** 将结果筛选为仅 `c3.4xlarge` 实例类型，**WHERE InstanceType \$1= 'c3.4xlarge'** 将结果筛选为除 `c3.4xlarge` 外的所有实例类型。  
在监控账户中运行查询时，可以利用 `WHERE AWS.AccountId` 将查询结果限制到指定账户。例如，`WHERE AWS.AccountId=444455556666` 仅查询账户 `444455556666` 的指标。要将查询限制为仅限监控账户本身中的指标，请使用 `WHERE AWS.AccountId=CURRENT_ACCOUNT_ID()`。  
标签值必须始终放在单引号中。  
**在 WHERE 子句中使用标签**  
可通过 `tag.keyName` 语法，按 AWS 资源标签筛选查询结果。标签筛选遵循与维度筛选相同的运算符规则。例如：  
+ WHERE `tag.env = 'prod'`：筛选出标签为 *env=prod* 的资源对应的指标
+ WHERE `tag.department != 'test'`：排除标签为 *department=test* 的资源对应的指标
标签筛选可与维度筛选组合使用：  
`WHERE tag.env = 'prod' AND InstanceType = 'm5.large'`  
**支持的运算符**  
**WHERE** 子句支持以下运算符：  
+ **=** 标签值必须与指定的字符串匹配。
+ **\$1=** 标签值不得与指定的字符串匹配。
+ **AND** 指定的两个条件都必须为真才能匹配。您可以使用多个 **AND** 关键字来指定两个或更多条件。

**GROUP BY**  
可选。将查询结果分组为多个时间序列，每个时间序列对应指定的一个或多个标签键的不同值。例如，使用 `GROUP BY InstanceId` 为每个 `InstanceId` 值返回不同的时间序列。使用 `GROUP BY ServiceName, Operation` 为 `ServiceName` 和 `Operation` 值的每个可能组合创建不同的时间序列。  
通过 **GROUP BY** 子句，默认情况下，将使用 **GROUP BY** 子句中指定的标签序列将结果按字母升序排列。要更改结果的顺序，请在查询中添加 **ORDER BY** 子句。  
在监控账户中运行查询时，您可以使用 `GROUP BY AWS.AccountId` 来按照结果的来源账户对结果进行分组。  
**在 GROUP BY 子句中使用标签**  
可通过 `tag.keyName` 语法，按 AWS 资源标签的值对查询结果进行分组。例如：  
+ *GROUP BY tag.environment*：按环境标签的不同取值生成独立的时间序列
+ *GROUP BY tag.team, InstanceType*：同时按标签和维度的取值进行分组
+ *GROUP BY tag.team, AWS.AccountId*：同时按标签和关联的源账户 ID 进行分组
如果某些匹配的指标不包含 **GROUP BY** 子句中指定的标签键，则会返回名为 `Other` 的空组。例如，如果指定 `GROUP BY ServiceName, Operation` 而且某些返回的指标不包括作为维度的 `ServiceName`，则这些指标将显示为将 `Other` 作为 `ServiceName` 的值。

**ORDER BY**  
可选。如果查询返回多个时间序列，则指定返回的时间序列的使用顺序。该顺序基于您在 **ORDER BY** 子句中指定的 **FUNCTION** 找到的值。**FUNCTION** 用于计算每个返回的时间序列中的单个标量值，该值用于确定顺序。  
还可以指定使用升序 **ASC** 或降序 **DESC**。如果您省略这一步，则默认为升序 **ASC**。  
例如，添加 `ORDER BY MAX() DESC` 子句将按时间范围内观察到的最大数据点以降序对结果进行排序：这意味着具有最高最大数据点的时间序列会首先返回。  
要在 **ORDER BY** 子句中使用的有效函数为 `AVG()`、`COUNT()`、`MAX()`、`MIN()` 和 `SUM()`。  
如果您将 **ORDER BY** 子句与 **LIMIT** 子句配合使用，则生成的查询为“前 N 个”查询。**ORDER BY** 对于可能返回大量指标的查询也很有用，因为每个查询返回的时间序列不超过 500 个。如果查询匹配超过 500 个时间序列，并且您使用 **ORDER BY** 子句并对时间序列进行排序，则排序中前 500 个时间序列是返回的时间序列。

**LIMIT**  
可选。将查询返回的时间序列数量限制为指定的值。您可以指定的最大值为 500，而不指定 **LIMIT** 的查询也可以返回不超过 500 个时间序列。  
将 **LIMITED** 子句与 **ORDER BY** 子句配合使用，将获得“前 N 个”查询。

## 什么内容需要引号或转义字符？
<a name="cloudwatch-metrics-insights-syntaxdetails"></a>

在查询中，标签值必须始终放在单引号中。例如，**SELECT MAX(CPUUtilization) FROM "AWS/EC2" WHERE AutoScalingGroupName = 'my-production-fleet'**。

包含字母、数字和下划线 (\$1) 以外的字符的指标命名空间、指标名称和标签键必须放在双引号中。例如，**SELECT MAX("My.Metric")**。

如果其中一个已包含双引号或单引号（如 `Bytes"Input"`），您必须用反斜杠转义每个引号，如 **SELECT AVG("Bytes\$1"Input\$1"")**。

如果指标命名空间、指标名称或标签键包含的词为 Metrics Insights 中的保留关键字，则这些词也必须放在双引号中。例如，如果您有名为 `LIMIT` 的指标，您可以使用 `SELECT AVG("LIMIT")`。将任何命名空间、指标名称或标签（即使不包含保留关键字）放在双引号中也有效。

有关保留关键字的完整列表，请参阅 [保留关键字](cloudwatch-metrics-insights-reserved-keywords.md)。

## 逐步构建丰富的查询
<a name="cloudwatch-metrics-insights-syntaxexample"></a>

本节说明了如何逐步构建一个使用所有可能子句的完整示例。

您可从以下查询开始，该查询聚合了使用 `LoadBalancer` 和 `AvailabilityZone` 两个维度收集的所有应用程序负载均衡器 `RequestCount` 指标。

```
SELECT SUM(RequestCount) 
FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone)
```

如果只想查看来自特定负载均衡器的指标，您可以添加 **WHERE** 子句，将返回的指标限制为 `LoadBalancer` 维度的值为 `app/load-balancer-1` 的指标。

```
SELECT SUM(RequestCount) 
FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone)
WHERE LoadBalancer = 'app/load-balancer-1'
```

前面的查询将此负载均衡器的所有可用区中的 `RequestCount` 指标聚合为一个时间序列。如果想看到每个可用区的不同时间序列，可以添加 **GROUP BY** 子句。

```
SELECT SUM(RequestCount) 
FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone)
WHERE LoadBalancer = 'app/load-balancer-1'
GROUP BY AvailabilityZone
```

接下来可对查询结果进行排序，优先展示数值最大的结果。以下 **ORDER BY** 子句按查询时间范围内每个时间序列报告的最大值以降序对时间序列进行排序：

```
SELECT SUM(RequestCount) 
FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone)
WHERE LoadBalancer = 'app/load-balancer-1'
GROUP BY AvailabilityZone
ORDER BY MAX() DESC
```

您也可通过标签对查询结果做进一步筛选。例如，若希望仅查看带有特定环境标签的负载均衡器对应的结果，可在 WHERE 子句中添加标签筛选条件：

```
SELECT SUM(RequestCount) FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone) WHERE LoadBalancer = 'app/load-balancer-1' AND tag.Environment = 'prod' GROUP BY AvailabilityZone ORDER BY MAX() DESC
```

您也可依据标签值对查询结果进行分组，替代维度分组（或在维度分组基础上叠加标签值分组）。例如，按应用程序标签分组：

```
SELECT SUM(RequestCount) FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone) WHERE tag.Environment = 'prod' GROUP BY tag.Application ORDER BY MAX() DESC
```

最后，如果我们主要对“前 N 个”类型的查询感兴趣，我们可以使用 **LIMIT** 子句。这最后一个例子将结果限制为仅带有五个最高 `MAX` 值的时间序列。

```
SELECT SUM(RequestCount) 
FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone)
WHERE LoadBalancer = 'app/load-balancer-1'
GROUP BY AvailabilityZone
ORDER BY MAX() DESC
LIMIT 5
```

## 跨账户查询示例
<a name="cloudwatch-metrics-insights-crossaccount"></a>

这些示例在 CloudWatch 跨账户可观测性中设置为监控账户的账户中运行时有效。

以下示例搜索源账户 123456789012 中的所有 Amazon EC2 实例并返回平均值。

```
SELECT AVG(CpuUtilization) 
FROM "AWS/EC2" 
WHERE AWS.AccountId ='123456789012'
```

以下示例查询所有关联源账户中 `AWS/EC2` 的 `CPUUtilization` 指标，并按账户 ID 和实例类型对结果进行分组。

```
SELECT AVG(CpuUtilization) 
FROM "AWS/EC2" 
GROUP BY AWS.AccountId, InstanceType
```

以下示例查询监控账户本身中的 `CPUUtilization`。

```
SELECT AVG(CpuUtilization) 
FROM "AWS/EC2" 
WHERE AWS.AccountId = CURRENT_ACCOUNT_ID()
```

# 保留关键字
<a name="cloudwatch-metrics-insights-reserved-keywords"></a>

以下是 CloudWatch Metrics Insights 中的保留关键字。如果查询中的命名空间、指标名称或标签键中包含这些词中的任何一个，则必须将其放在双引号中。保留关键字不区分大小写。

```
"ABORT" "ABORTSESSION" "ABS" "ABSOLUTE" "ACCESS" "ACCESSIBLE" "ACCESS_LOCK" "ACCOUNT" "ACOS" "ACOSH" "ACTION" "ADD" "ADD_MONTHS"
"ADMIN" "AFTER" "AGGREGATE" "ALIAS" "ALL" "ALLOCATE" "ALLOW" "ALTER" "ALTERAND" "AMP" "ANALYSE" "ANALYZE" "AND" "ANSIDATE" "ANY" "ARE" "ARRAY",
"ARRAY_AGG" "ARRAY_EXISTS" "ARRAY_MAX_CARDINALITY" "AS" "ASC" "ASENSITIVE" "ASIN" "ASINH" "ASSERTION" "ASSOCIATE" "ASUTIME" "ASYMMETRIC" "AT",
"ATAN" "ATAN2" "ATANH" "ATOMIC" "AUDIT" "AUTHORIZATION" "AUX" "AUXILIARY" "AVE" "AVERAGE" "AVG" "BACKUP" "BEFORE" "BEGIN" "BEGIN_FRAME" "BEGIN_PARTITION",
"BETWEEN" "BIGINT" "BINARY" "BIT" "BLOB" "BOOLEAN" "BOTH" "BREADTH" "BREAK" "BROWSE" "BT" "BUFFERPOOL" "BULK" "BUT" "BY" "BYTE" "BYTEINT" "BYTES" "CALL",
"CALLED" "CAPTURE" "CARDINALITY" "CASCADE" "CASCADED" "CASE" "CASESPECIFIC" "CASE_N" "CAST" "CATALOG" "CCSID" "CD" "CEIL" "CEILING" "CHANGE" "CHAR",
"CHAR2HEXINT" "CHARACTER" "CHARACTERS" "CHARACTER_LENGTH" "CHARS" "CHAR_LENGTH" "CHECK" "CHECKPOINT" "CLASS" "CLASSIFIER" "CLOB" "CLONE" "CLOSE" "CLUSTER",
"CLUSTERED" "CM" "COALESCE" "COLLATE" "COLLATION" "COLLECT" "COLLECTION" "COLLID" "COLUMN" "COLUMN_VALUE" "COMMENT" "COMMIT" "COMPLETION" "COMPRESS" "COMPUTE",
"CONCAT" "CONCURRENTLY" "CONDITION" "CONNECT" "CONNECTION" "CONSTRAINT" "CONSTRAINTS" "CONSTRUCTOR" "CONTAINS" "CONTAINSTABLE" "CONTENT" "CONTINUE" "CONVERT",
"CONVERT_TABLE_HEADER" "COPY" "CORR" "CORRESPONDING" "COS" "COSH" "COUNT" "COVAR_POP" "COVAR_SAMP" "CREATE" "CROSS" "CS" "CSUM" "CT" "CUBE" "CUME_DIST",
"CURRENT" "CURRENT_CATALOG" "CURRENT_DATE" "CURRENT_DEFAULT_TRANSFORM_GROUP" "CURRENT_LC_CTYPE" "CURRENT_PATH" "CURRENT_ROLE" "CURRENT_ROW" "CURRENT_SCHEMA",
"CURRENT_SERVER" "CURRENT_TIME" "CURRENT_TIMESTAMP" "CURRENT_TIMEZONE" "CURRENT_TRANSFORM_GROUP_FOR_TYPE" "CURRENT_USER" "CURRVAL" "CURSOR" "CV" "CYCLE" "DATA",
"DATABASE" "DATABASES" "DATABLOCKSIZE" "DATE" "DATEFORM" "DAY" "DAYS" "DAY_HOUR" "DAY_MICROSECOND" "DAY_MINUTE" "DAY_SECOND" "DBCC" "DBINFO" "DEALLOCATE" "DEC",
"DECFLOAT" "DECIMAL" "DECLARE" "DEFAULT" "DEFERRABLE" "DEFERRED" "DEFINE" "DEGREES" "DEL" "DELAYED" "DELETE" "DENSE_RANK" "DENY" "DEPTH" "DEREF" "DESC" "DESCRIBE",
"DESCRIPTOR" "DESTROY" "DESTRUCTOR" "DETERMINISTIC" "DIAGNOSTIC" "DIAGNOSTICS" "DICTIONARY" "DISABLE" "DISABLED" "DISALLOW" "DISCONNECT" "DISK" "DISTINCT",
"DISTINCTROW" "DISTRIBUTED" "DIV" "DO" "DOCUMENT" "DOMAIN" "DOUBLE" "DROP" "DSSIZE" "DUAL" "DUMP" "DYNAMIC" "EACH" "ECHO" "EDITPROC" "ELEMENT" "ELSE" "ELSEIF",
"EMPTY" "ENABLED" "ENCLOSED" "ENCODING" "ENCRYPTION" "END" "END-EXEC" "ENDING" "END_FRAME" "END_PARTITION" "EQ" "EQUALS" "ERASE" "ERRLVL" "ERROR" "ERRORFILES",
"ERRORTABLES" "ESCAPE" "ESCAPED" "ET" "EVERY" "EXCEPT" "EXCEPTION" "EXCLUSIVE" "EXEC" "EXECUTE" "EXISTS" "EXIT" "EXP" "EXPLAIN" "EXTERNAL" "EXTRACT" "FALLBACK
"FALSE" "FASTEXPORT" "FENCED" "FETCH" "FIELDPROC" "FILE" "FILLFACTOR" "FILTER" "FINAL" "FIRST" "FIRST_VALUE" "FLOAT" "FLOAT4" "FLOAT8" "FLOOR" 
"FOR" "FORCE" "FOREIGN" "FORMAT" "FOUND" "FRAME_ROW" "FREE" "FREESPACE" "FREETEXT" "FREETEXTTABLE" "FREEZE" "FROM" "FULL" "FULLTEXT" "FUNCTION" 
"FUSION" "GE" "GENERAL" "GENERATED" "GET" "GIVE" "GLOBAL" "GO" "GOTO" "GRANT" "GRAPHIC" "GROUP" "GROUPING" "GROUPS" "GT" "HANDLER" "HASH" 
"HASHAMP" "HASHBAKAMP" "HASHBUCKET" "HASHROW" "HAVING" "HELP" "HIGH_PRIORITY" "HOLD" "HOLDLOCK" "HOUR" "HOURS" "HOUR_MICROSECOND" "HOUR_MINUTE" 
"HOUR_SECOND" "IDENTIFIED" "IDENTITY" "IDENTITYCOL" "IDENTITY_INSERT" "IF" "IGNORE" "ILIKE" "IMMEDIATE" "IN" "INCLUSIVE" "INCONSISTENT" "INCREMENT" 
"INDEX" "INDICATOR" "INFILE" "INHERIT" "INITIAL" "INITIALIZE" "INITIALLY" "INITIATE" "INNER" "INOUT" "INPUT" "INS" "INSENSITIVE" "INSERT" "INSTEAD" 
"INT" "INT1" "INT2" "INT3" "INT4" "INT8" "INTEGER" "INTEGERDATE" "INTERSECT" "INTERSECTION" "INTERVAL" "INTO" "IO_AFTER_GTIDS" "IO_BEFORE_GTIDS" 
"IS" "ISNULL" "ISOBID" "ISOLATION" "ITERATE" "JAR" "JOIN" "JOURNAL" "JSON_ARRAY" "JSON_ARRAYAGG" "JSON_EXISTS" "JSON_OBJECT" "JSON_OBJECTAGG" 
"JSON_QUERY" "JSON_TABLE" "JSON_TABLE_PRIMITIVE" "JSON_VALUE" "KEEP" "KEY" "KEYS" "KILL" "KURTOSIS" "LABEL" "LAG" "LANGUAGE" "LARGE" "LAST" 
"LAST_VALUE" "LATERAL" "LC_CTYPE" "LE" "LEAD" "LEADING" "LEAVE" "LEFT" "LESS" "LEVEL" "LIKE" "LIKE_REGEX" "LIMIT" "LINEAR" "LINENO" "LINES" 
"LISTAGG" "LN" "LOAD" "LOADING" "LOCAL" "LOCALE" "LOCALTIME" "LOCALTIMESTAMP" "LOCATOR" "LOCATORS" "LOCK" "LOCKING" "LOCKMAX" "LOCKSIZE" "LOG" 
"LOG10" "LOGGING" "LOGON" "LONG" "LONGBLOB" "LONGTEXT" "LOOP" "LOWER" "LOW_PRIORITY" "LT" "MACRO" "MAINTAINED" "MAP" "MASTER_BIND" 
"MASTER_SSL_VERIFY_SERVER_CERT" "MATCH" "MATCHES" "MATCH_NUMBER" "MATCH_RECOGNIZE" "MATERIALIZED" "MAVG" "MAX" "MAXEXTENTS" "MAXIMUM" "MAXVALUE" 
"MCHARACTERS" "MDIFF" "MEDIUMBLOB" "MEDIUMINT" "MEDIUMTEXT" "MEMBER" "MERGE" "METHOD" "MICROSECOND" "MICROSECONDS" "MIDDLEINT" "MIN" "MINDEX" 
"MINIMUM" "MINUS" "MINUTE" "MINUTES" "MINUTE_MICROSECOND" "MINUTE_SECOND" "MLINREG" "MLOAD" "MLSLABEL" "MOD" "MODE" "MODIFIES" "MODIFY" 
"MODULE" "MONITOR" "MONRESOURCE" "MONSESSION" "MONTH" "MONTHS" "MSUBSTR" "MSUM" "MULTISET" "NAMED" "NAMES" "NATIONAL" "NATURAL" "NCHAR" "NCLOB" 
"NE" "NESTED_TABLE_ID" "NEW" "NEW_TABLE" "NEXT" "NEXTVAL" "NO" "NOAUDIT" "NOCHECK" "NOCOMPRESS" "NONCLUSTERED" "NONE" "NORMALIZE" "NOT" "NOTNULL" 
"NOWAIT" "NO_WRITE_TO_BINLOG" "NTH_VALUE" "NTILE" "NULL" "NULLIF" "NULLIFZERO" "NULLS" "NUMBER" "NUMERIC" "NUMPARTS" "OBID" "OBJECT" "OBJECTS" 
"OCCURRENCES_REGEX" "OCTET_LENGTH" "OF" "OFF" "OFFLINE" "OFFSET" "OFFSETS" "OLD" "OLD_TABLE" "OMIT" "ON" "ONE" "ONLINE" "ONLY" "OPEN" "OPENDATASOURCE" 
"OPENQUERY" "OPENROWSET" "OPENXML" "OPERATION" "OPTIMIZATION" "OPTIMIZE" "OPTIMIZER_COSTS" "OPTION" "OPTIONALLY" "OR" "ORDER" "ORDINALITY" "ORGANIZATION" 
"OUT" "OUTER" "OUTFILE" "OUTPUT" "OVER" "OVERLAPS" "OVERLAY" "OVERRIDE" "PACKAGE" "PAD" "PADDED" "PARAMETER" "PARAMETERS" "PART" "PARTIAL" "PARTITION" 
"PARTITIONED" "PARTITIONING" "PASSWORD" "PATH" "PATTERN" "PCTFREE" "PER" "PERCENT" "PERCENTILE" "PERCENTILE_CONT" "PERCENTILE_DISC" "PERCENT_RANK" "PERIOD" "PERM" 
"PERMANENT" "PIECESIZE" "PIVOT" "PLACING" "PLAN" "PORTION" "POSITION" "POSITION_REGEX" "POSTFIX" "POWER" "PRECEDES" "PRECISION" "PREFIX" "PREORDER" 
"PREPARE" "PRESERVE" "PREVVAL" "PRIMARY" "PRINT" "PRIOR" "PRIQTY" "PRIVATE" "PRIVILEGES" "PROC" "PROCEDURE" "PROFILE" "PROGRAM" "PROPORTIONAL" 
"PROTECTION" "PSID" "PTF" "PUBLIC" "PURGE" "QUALIFIED" "QUALIFY" "QUANTILE" "QUERY" "QUERYNO" "RADIANS" "RAISERROR" "RANDOM" "RANGE" "RANGE_N" "RANK" 
"RAW" "READ" "READS" "READTEXT" "READ_WRITE" "REAL" "RECONFIGURE" "RECURSIVE" "REF" "REFERENCES" "REFERENCING" "REFRESH" "REGEXP" "REGR_AVGX" "REGR_AVGY" 
"REGR_COUNT" "REGR_INTERCEPT" "REGR_R2" "REGR_SLOPE" "REGR_SXX" "REGR_SXY" "REGR_SYY" "RELATIVE" "RELEASE" "RENAME" "REPEAT" "REPLACE" "REPLICATION" 
"REPOVERRIDE" "REQUEST" "REQUIRE" "RESIGNAL" "RESOURCE" "RESTART" "RESTORE" "RESTRICT" "RESULT" "RESULT_SET_LOCATOR" "RESUME" "RET" "RETRIEVE" "RETURN" 
"RETURNING" "RETURNS" "REVALIDATE" "REVERT" "REVOKE" "RIGHT" "RIGHTS" "RLIKE" "ROLE" "ROLLBACK" "ROLLFORWARD" "ROLLUP" "ROUND_CEILING" "ROUND_DOWN" 
"ROUND_FLOOR" "ROUND_HALF_DOWN" "ROUND_HALF_EVEN" "ROUND_HALF_UP" "ROUND_UP" "ROUTINE" "ROW" "ROWCOUNT" "ROWGUIDCOL" "ROWID" "ROWNUM" "ROWS" "ROWSET" 
"ROW_NUMBER" "RULE" "RUN" "RUNNING" "SAMPLE" "SAMPLEID" "SAVE" "SAVEPOINT" "SCHEMA" "SCHEMAS" "SCOPE" "SCRATCHPAD" "SCROLL" "SEARCH" "SECOND" "SECONDS" 
"SECOND_MICROSECOND" "SECQTY" "SECTION" "SECURITY" "SECURITYAUDIT" "SEEK" "SEL" "SELECT" "SEMANTICKEYPHRASETABLE" "SEMANTICSIMILARITYDETAILSTABLE" 
"SEMANTICSIMILARITYTABLE" "SENSITIVE" "SEPARATOR" "SEQUENCE" "SESSION" "SESSION_USER" "SET" "SETRESRATE" "SETS" "SETSESSRATE" "SETUSER" "SHARE" "SHOW" 
"SHUTDOWN" "SIGNAL" "SIMILAR" "SIMPLE" "SIN" "SINH" "SIZE" "SKEW" "SKIP" "SMALLINT" "SOME" "SOUNDEX" "SOURCE" "SPACE" "SPATIAL" "SPECIFIC" "SPECIFICTYPE" 
"SPOOL" "SQL" "SQLEXCEPTION" "SQLSTATE" "SQLTEXT" "SQLWARNING" "SQL_BIG_RESULT" "SQL_CALC_FOUND_ROWS" "SQL_SMALL_RESULT" "SQRT" "SS" "SSL" "STANDARD" 
"START" "STARTING" "STARTUP" "STAT" "STATE" "STATEMENT" "STATIC" "STATISTICS" "STAY" "STDDEV_POP" "STDDEV_SAMP" "STEPINFO" "STOGROUP" "STORED" "STORES" 
"STRAIGHT_JOIN" "STRING_CS" "STRUCTURE" "STYLE" "SUBMULTISET" "SUBSCRIBER" "SUBSET" "SUBSTR" "SUBSTRING" "SUBSTRING_REGEX" "SUCCEEDS" "SUCCESSFUL" 
"SUM" "SUMMARY" "SUSPEND" "SYMMETRIC" "SYNONYM" "SYSDATE" "SYSTEM" "SYSTEM_TIME" "SYSTEM_USER" "SYSTIMESTAMP" "TABLE" "TABLESAMPLE" "TABLESPACE" "TAN" 
"TANH" "TBL_CS" "TEMPORARY" "TERMINATE" "TERMINATED" "TEXTSIZE" "THAN" "THEN" "THRESHOLD" "TIME" "TIMESTAMP" "TIMEZONE_HOUR" "TIMEZONE_MINUTE" "TINYBLOB" 
"TINYINT" "TINYTEXT" "TITLE" "TO" "TOP" "TRACE" "TRAILING" "TRAN" "TRANSACTION" "TRANSLATE" "TRANSLATE_CHK" "TRANSLATE_REGEX" "TRANSLATION" "TREAT" 
"TRIGGER" "TRIM" "TRIM_ARRAY" "TRUE" "TRUNCATE" "TRY_CONVERT" "TSEQUAL" "TYPE" "UC" "UESCAPE" "UID" "UNDEFINED" "UNDER" "UNDO" "UNION" "UNIQUE" 
"UNKNOWN" "UNLOCK" "UNNEST" "UNPIVOT" "UNSIGNED" "UNTIL" "UPD" "UPDATE" "UPDATETEXT" "UPPER" "UPPERCASE" "USAGE" "USE" "USER" "USING" "UTC_DATE" 
"UTC_TIME" "UTC_TIMESTAMP" "VALIDATE" "VALIDPROC" "VALUE" "VALUES" "VALUE_OF" "VARBINARY" "VARBYTE" "VARCHAR" "VARCHAR2" "VARCHARACTER" "VARGRAPHIC" 
"VARIABLE" "VARIADIC" "VARIANT" "VARYING" "VAR_POP" "VAR_SAMP" "VCAT" "VERBOSE" "VERSIONING" "VIEW" "VIRTUAL" "VOLATILE" "VOLUMES" "WAIT" "WAITFOR" 
"WHEN" "WHENEVER" "WHERE" "WHILE" "WIDTH_BUCKET" "WINDOW" "WITH" "WITHIN" "WITHIN_GROUP" "WITHOUT" "WLM" "WORK" "WRITE" "WRITETEXT" "XMLCAST" "XMLEXISTS" 
"XMLNAMESPACES" "XOR" "YEAR" "YEARS" "YEAR_MONTH" "ZEROFILL" "ZEROIFNULL" "ZONE"
```

# CloudWatch 中的 CloudWatch Metrics Insights 查询警报
<a name="cloudwatch-metrics-insights-alarms"></a>

您可以为 Metrics Insights 查询创建告警。这有助于您获得跟踪多个资源的告警，而无需稍后更新。该查询可捕获新资源和发生变化的资源。例如，您可以创建一个告警来监视实例集的 CPU 利用率，该告警会自动评估您在创建告警后启动的新实例。

在为 CloudWatch 跨账户可观测性设置的监控账户中，Metris Insights 警报可以监控源账户中的资源和该监控账户本身中的资源。有关如何将警报查询限制在特定账户，以及如何按账户 ID 对结果进行分组的更多信息，请参阅 [CloudWatch Metrics Insights 中的查询组件和语法](cloudwatch-metrics-insights-querylanguage.md) 中的 `WHERE` 和 `GROUP BY` 部分。

**在警报查询中使用标签**

您可以在 Metrics Insights 查询上创建警报，这些查询使用 AWS 资源标签对指标进行筛选和分组。要将标签与警报结合使用，请在 [https://console.aws.amazon.com/connect/](https://console.aws.amazon.com/connect/) 上选择**设置**。在 **CloudWatch 设置**页面的**针对遥测启用资源标签**下，选择**启用**。上下文感知型警报可随资源变化，自动监控特定应用程序、环境或团队的相关指标。

例如，您可创建警报，对所有带有特定应用程序标签的 Amazon EC2 实例的 CPU 利用率进行监控。

```
SELECT MAX(CPUUtilization) FROM "AWS/EC2" WHERE tag.Application = 'Orders' AND tag.Environment = 'Prod'
```

基于标签的警报会随匹配标签的资源新增或移除自动适配，实现与运维架构相契合的动态监控。

**Contents**
+ [创建 Metrics Insights CloudWatch 警报](cloudwatch-metrics-insights-alarm-create.md)

# 创建 Metrics Insights CloudWatch 警报
<a name="cloudwatch-metrics-insights-alarm-create"></a>

**使用控制台为 Metrics Insights 查询创建告警**

1. 通过 [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) 打开 CloudWatch 控制台。

1. 在导航窗格中，依次选择 **Metrics**（指标）、**All metrics**（所有指标）。

1. （可选）要运行预构建的示例查询，请选择 **Add query**（添加查询），然后选择要运行的查询。或者，您可以选择 **Editor**（编辑器）来编辑示例查询，然后选择 **Run**（运行）以运行修改后的查询。

1. 要创建您自己的查询，请选择**多来源查询**。您可以使用**构建器**视图、**编辑器**视图，也可以将二者结合起来使用。您可以随时在两个视图之间切换，并在两个视图中查看正在进行的工作。

   在 **Builder**（构建器）视图中，您可以浏览并选择指标命名空间、指标名称、筛选条件、分组和排序选项。对于其中每个选项，查询构建器都会为您提供您环境中的可选项列表，供您选择。

   在 **Editor**（编辑器）视图中，您可以开始编写查询。输入时，编辑器会根据您当前已输入的字符提供建议。

   例如，在为警报配置 Metrics Insights 查询语句时，您可通过标签对指标进行筛选和分组，实现更具针对性的监控。
   + 按标签筛选：通过 `WHERE tag.keyName = 'value'` 监控带有特定标签的资源

     ```
     SELECT MAX(CPUUtilization) FROM "AWS/EC2" WHERE tag.Environment = 'Prod'
     ```
   + 标签与维度结合：将标签筛选条件与现有指标维度结合使用

     ```
     SELECT AVG(Duration) FROM "AWS/Lambda" WHERE tag.Application = 'OrderService' AND FunctionName = 'process%'
     ```
**注意**  
使用标签时，仅当关联资源在警报评估时段内存在指定标签，该警报才会匹配对应指标。

1. 如果对查询感到满意，请选择 **Run**（运行）。

1. 选择**创建警报**。

1. 在**条件**下面，指定以下内容：

   1. 对于 **Whenever *metric* is（每当指标）**，指定指标是必须大于、小于还是等于阈值。在**于...** 下面，指定阈值。

   1. 选择**其他配置**。对于**触发警报的数据点数**，指定必须有多少个评估期（数据点）处于 `ALARM` 状态才能触发警报。如果此处的两个值匹配，则会创建一个告警；如果多个连续评估期违例，该告警将变为 `ALARM`（告警）状态。

      要创建“M（最大为 N）”告警，为第一个值指定的数字应小于为第二个值指定的数字。有关更多信息，请参阅 [告警评估](alarm-evaluation.md)。

   1. 对于**缺失数据处理**，选择在缺失某些数据点时的警报行为。有关更多信息，请参阅 [配置 CloudWatch 告警处理缺失数据的方式](alarms-and-missing-data.md)。

1. 选择**下一步**。

1. 在**通知**下面，选择一个在警报处于 `ALARM`、`OK` 或 `INSUFFICIENT_DATA` 状态时通知的 SNS 主题。

   要使告警为相同告警状态或不同告警状态发送多个通知，请选择**添加通知**。

   要让警报不发送通知，请选择**删除**。

1. 要让告警执行 Auto Scaling、EC2 或 Systems Manager 操作，请选择相应的按钮，然后选择告警状态和要执行的操作。告警只有在进入“ALARM（告警）”状态时才能执行 Systems Manager 操作。有关 Systems Manager 操作的更多信息，请参阅[将 CloudWatch 配置为通过告警创建 OpsItems ](https://docs.aws.amazon.com/systems-manager/latest/userguide/OpsCenter-create-OpsItems-from-CloudWatch-Alarms.html)和[事件创建](https://docs.aws.amazon.com/incident-manager/latest/userguide/incident-creation.html)。
**注意**  
要创建执行 SSM Incident Manager 操作的告警，您必须具有特定的权限。有关更多信息，请参阅 [AWS Systems Manager Incident Manager 的基于身份的策略示例](https://docs.aws.amazon.com/incident-manager/latest/userguide/security_iam_id-based-policy-examples.html)。

1. 在完成后，选择**下一步**。

1. 输入警报的名称和说明。名称只能包含 ASCII 字符。然后选择**下一步**。

1. 在 **Preview and create** 下面，确认具有所需的信息和条件，然后选择 **Create alarm**。

**通过 AWS CLI 基于 Metrics Insights 查询创建警报**

使用 `put-metric-alarm` 命令并在 `metrics` 参数中指定 Metrics Insights 查询。例如，以下命令将设置一个告警，如果任何实例的 CPU 利用率超过 50%，该告警将进入 ALARM 状态。

```
aws cloudwatch put-metric-alarm —alarm-name Prod-App-CPU-Alarm —evaluation-periods 1 —comparison-operator GreaterThanThreshold —metrics '[{"Id":"m1","Expression":"SELECT MAX(CPUUtilization) FROM \"AWS/EC2\" WHERE tag.Environment = '\''Prod'\'' AND tag.Application = '\''OrderService'\''", "Period":60}]' —threshold 80
```

# 将 Metrics Insights 查询与指标数学配合使用
<a name="cloudwatch-metrics-insights-math"></a>

您可以使用 Metrics Insights 查询作为指标数学函数的输入。有关指标数学的更多信息，请参阅 [将数学表达式与 CloudWatch 指标结合使用](using-metric-math.md)。

不包括 **GROUP BY** 子句的 Metrics Insights 查询将返回单个时间序列。因此，其返回的结果可以与以单个时间序列作为输入的任何指标数学函数一起使用。

包括 **GROUP BY** 子句的 Metrics Insights 查询将返回多个时间序列。因此，其返回的结果可以与以时间序列数组作为输入的任何指标数学函数一起使用。

例如，以下查询以时间序列数组的形式返回为区域中每个存储桶下载的总字节数：

```
SELECT SUM(BytesDownloaded) 
FROM SCHEMA("AWS/S3", BucketName, FilterId) 
WHERE FilterId = 'EntireBucket'
GROUP BY BucketName
```

在控制台或 [GetMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricData.html) 操作中的图表上，此查询的结果为 `q1`。此查询返回以字节为单位的结果，因此如果您想查看 MB 单位的结果，可以使用以下数学函数：

```
q1/1024/1024
```

# 使用自然语言生成与更新 CloudWatch Metrics Insights 查询
<a name="cloudwatch-metrics-insights-query-assist"></a>

 CloudWatch 支持自然语言查询功能，以帮助您生成和更新 [CloudWatch Metrics Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/query_with_cloudwatch-metrics-insights.html) 和 [CloudWatch Logs Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AnalyzingLogData.html) 查询。

 通过此功能，您可以用通俗易懂的英语询问或描述要查找的 CloudWatch 数据。自然语言功能可根据您输入的提示生成查询，并逐行说明查询的工作原理。您也可以更新查询以进一步调查数据。

 您可以根据环境输入各种提示，例如“Which Amazon Elastic Compute Cloud instance has the highest network out?”（哪个 Amazon Elastic Compute Cloud 实例的网络输出量最高？） 以及“Show me the top 10 Amazon DynamoDB Tables by consumed reads”（展示读取使用量前 10 的 Amazon DynamoDB 表）等。

**注意**  
自然语言查询功能通常在 10 个区域可用。对于某些区域，该功能会向美国的区域发起跨区域调用以处理查询提示。下表列出了支持的区域，并显示了每个区域处理其提示的位置。  


| 支持的区域 | 处理提示的区域 | 
| --- | --- | 
|  美国东部（弗吉尼亚州北部）  |  美国东部（弗吉尼亚州北部）  | 
|  美国东部（俄亥俄州）  |  美国东部（弗吉尼亚州北部）  | 
|  美国西部（俄勒冈州）  |  美国西部（俄勒冈州）  | 
|  亚太地区（香港）  |  美国西部（俄勒冈州）  | 
|  亚太地区（新加坡）  |  美国西部（俄勒冈州）  | 
|  亚太地区（悉尼）  |  美国西部（俄勒冈）  | 
|  亚太地区（东京）  |  亚太地区（东京）  | 
|  欧洲地区（法兰克福）  |  欧洲地区（法兰克福）  | 
|  欧洲地区（爱尔兰）  |  美国东部（弗吉尼亚州北部）  | 
|  欧洲地区（斯德哥尔摩）  |  美国东部（弗吉尼亚州北部）  | 

 要生成具有此功能的 CloudWatch Metrics Insights 查询，请在*构建器*或*编辑器*视图中打开 CloudWatch Metrics Insights 查询编辑器，然后选择**生成查询**。

**重要**  
 要使用自然语言查询功能，您必须使用 [CloudWatchFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/CloudWatchFullAccess.html)、[CloudWatchReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/CloudWatchReadOnlyAccess.html)、[CloudWatchFullAccessV2](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/CloudWatchFullAccessV2.html)、[AdministratorAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AdministratorAccess.html) 或 [ReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/ReadOnlyAccess.html) 策略。  
 您也可以将 `cloudwatch:GenerateQuery` 操作包含在新的或现有的客户托管策略或内联策略中。

## 示例查询
<a name="cloudwatch-metrics-insights-query-assist-examples"></a>

 本节中的示例描述了如何使用自然语言功能生成和更新查询。

**注意**  
 有关 CloudWatch Metrics Insights 查询编辑器和语法的更多信息，请参阅 [CloudWatch Metrics Insights 查询组件和语法](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-metrics-insights-querylanguage.html)。

### 示例：生成自然语言查询
<a name="cloudwatch-metrics-insights-query-assist-example-1"></a>

 要使用自然语言来生成查询，请输入提示并选择**生成新查询**。此示例显示了一个执行基本搜索的查询。

**提示**  
 在以下示例中，该提示指示的功能可搜索占用最多读取容量的前 10 个 DynamoDB 表格。

```
Show top 10 DynamoDB Tables by consumed reads
```

**Query**  
 以下是自然语言功能根据提示生成的查询示例。请注意在查询之前的注释中，提示是如何显示的。查询完成后，您可以阅读有关查询工作原理的说明。

```
# Show top 10 DynamoDB Tables by consumed reads
SELECT SUM("ConsumedReadCapacityUnits")
FROM "AWS/DynamoDB"
GROUP BY TableName
ORDER BY SUM() DESC
LIMIT 10
# This query selects the sum of consumed read capacity units for each DynamoDB table, groups the results by table name, orders the results from highest to lowest read capacity consumption, and limits the results to the top 10 tables.
```

**注意**  
 要关闭提示和有关查询工作原理的说明显示，请使用编辑器中的齿轮图标。

### 示例：更新自然语言查询
<a name="cloudwatch-metrics-insights-query-assist-example-2"></a>

 您可以通过编辑初始提示，然后选择**更新查询**，来更新查询。

**更新版提示**  
 以下示例显示了先前提示的更新版本。现在，该提示不再搜索占用读取容量最多的前 10 个 DynamoDB 表格，而是按返回的字节数对结果进行排序。

```
Sort by bytes returned instead
```

**更新版查询**  
 以下是更新版查询的示例：请注意在更新版查询之前的注释中，更新版提示是如何显示的。查询完成后，您可以阅读有关原始查询是如何更新的说明。

```
# Sort by bytes returned instead
SELECT SUM("ReturnedBytes")
FROM "AWS/DynamoDB"
GROUP BY TableName
ORDER BY SUM() DESC
LIMIT 10
# This query modifies the original query to select the sum of returned bytes instead of consumed read capacity units, and orders the results from highest to lowest sum of returned bytes, limiting the results to the top 10 tables.
```

## 选择不使用您的数据来改进服务
<a name="cloudwatch-metrics-insights-query-assist-service-data"></a>

 您为训练 AI 模型和生成相关查询而提供的自然语言提示数据仅用于提供和维护您的服务。这些数据可用于提高 CloudWatch Metrics Insights 的质量。您的信任、隐私和内容的安全性是我们最重视的问题。有关更多信息，请参阅 [AWS Service Terms](https://aws.amazon.com/service-terms/) 和 [AWS responsible AI policy](https://aws.amazon.com/machine-learning/responsible-ai/policy/)。

 通过创建 AI 服务选择退出策略，您可以选择不将您的内容用于开发自然语言查询或提高自然语言查询的质量。要选择退出对所有 CloudWatch AI 功能（包括查询生成功能）进行的数据收集，您必须为 CloudWatch 创建一个选择退出策略。有关更多信息，请参阅《AWS Organizations 用户指南》**中的 [AI 服务选择退出策略](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_ai-opt-out.html)。

# SQL 推理
<a name="cloudwatch-metrics-insights-inference"></a>

CloudWatch Metrics Insights 使用多种机制来推断给定 SQL 查询的意图。

**Topics**
+ [时间分段](#cloudwatch-metrics-insights-inference-timebucketing)
+ [字段投影](#cloudwatch-metrics-insights-inference-fieldsprojection)
+ [ORDER BY 全局聚合](#cloudwatch-metrics-insights-inference-OrderBy)

## 时间分段
<a name="cloudwatch-metrics-insights-inference-timebucketing"></a>

根据请求的时段，查询生成的时间序列数据点将累计到时间段中。要在标准 SQL 中聚合值，必须定义一个明确的 GROUP BY 子句，以便一起收集给定时段的所有观测值。由于这是查询时间序列数据的标准方式，CloudWatch Metrics Insights 可推断时间分段，而无需明确表达 **GROUP BY** 子句。

例如，当执行时间为 1 分钟的查询时，属于该分钟的所有观测值，直到下一分钟（排除）为止，都将累计到该时间段的开始时间。这使得 Metrics Insights SQL 语句更加简洁明了。

```
SELECT AVG(CPUUtilization)
FROM SCHEMA("AWS/EC2", InstanceId)
```

上一个查询返回单个时间序列（时间戳值对），表示所有 Amazon EC2 实例的平均 CPU 使用率。假设请求的时段为 1 分钟，则返回的每个数据点代表在特定 1 分钟间隔（包括开始时间，不包括结束时间）内测量的所有观测值的平均值。与特定数据点相关的时间戳是时间段的开始时间

## 字段投影
<a name="cloudwatch-metrics-insights-inference-fieldsprojection"></a>

Metrcis Insights 查询始终返回时间戳投影。您不需要在 **SELECT** 子句中指定时间戳列来获取每个相应数据点值的时间戳。有关如何计算时间戳的详细信息，请参阅 [时间分段](#cloudwatch-metrics-insights-inference-timebucketing)。

使用 **GROUP BY** 时，还可以在结果中推断和投影每个组名称，以便您可以对返回的时间序列进行分组。

```
SELECT AVG(CPUUtilization)
FROM SCHEMA("AWS/EC2", InstanceId)
GROUP BY InstanceId
```

上一个查询将返回每个 Amazon EC2 实例的时间序列。每个时间序列都在实例 ID 的值之后进行标注。

## ORDER BY 全局聚合
<a name="cloudwatch-metrics-insights-inference-OrderBy"></a>

使用 **ORDER BY** 时、**FUNCTION()** 推断要按哪个聚合函数排序（查询指标的数据点值）。聚合操作在查询的时间窗口中对每个单独时间序列的所有匹配数据点执行。

```
SELECT AVG(CPUUtilization)
FROM SCHEMA("AWS/EC2", InstanceId)
GROUP BY InstanceId
ORDER BY MAX()
LIMIT 10
```

上一个查询返回每个 Amazon EC2 实例的 CPU 使用率，并将结果集限制为 10 个条目。结果根据请求的时间窗口内各个时间序列的最大值进行排序。**ORDER BY** 子句在 **LIMIT** 之前应用，以便根据 10 个以上的时间序列计算排序。

# Metrics Insights 配额
<a name="cloudwatch-metrics-insights-limits"></a>

CloudWatch Metrics Insights 目前有以下配额：
+ 查询长达两周的数据，以便在指标、小组件和告警图表中进行可视化展示。您可以查询最近三小时的数据，以进行告警条件评估。
+ 单个查询可处理的指标不超过 10,000 个。这意味着，如果 **SELECT**、**FROM** 和 **WHERE** 子句匹配 10,000 个以上的指标，查询只处理找到的前 10,000 个指标。
+ 单个查询可返回的时间序列不超过 500 个。这意味着，如果查询返回 500 个以上的指标，则查询结果中并非所有指标都将返回。如果您使用的是 **ORDER BY** 子句，则将对正在处理的所有指标进行排序，并根据您的 **ORDER BY** 子句，具有前 500 个最高值或最低值的指标将返回。

  如果您不包括 **ORDER BY** 子句，则无法控制哪 500 个匹配的指标将返回。
+ 每个区域最多可以有 200 个 Metrics Insights 警报。
+ Metrics Insights 不支持高分辨率数据，即以小于一分钟的粒度报告的指标数据。如果您请求高分辨率数据，该请求不会失败，但输出会以一分钟的粒度聚合。
+ 每个 [GetMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricData.html) 操作只能有一个查询，但是您可以在控制面板中有多个小组件，每个小组件都包含一个查询。
+ 如果一个使用标签且包含 **GROUP BY** 或 **WHERE** 子句的查询匹配到标签更新次数超过 10 次的指标，则查询结果中将仅包含该指标最新的 10 个带标签版本。

# Metrics Insights 示例查询
<a name="cloudwatch-metrics-insights-queryexamples"></a>

本节包含有用的 CloudWatch Metrics Insights 查询的示例，您可以直接复制和使用，或在查询编辑器中复制并修改。控制台中已经提供一些示例，您可以通过选择 **Metrics**（指标）视图中的 **Add query**（添加查询）来访问它们。

## Application Load Balancer 示例
<a name="cloudwatch-metrics-insights-queryexamples-applicationloadbalancer"></a>

**所有负载均衡器的请求总数**

```
SELECT SUM(RequestCount) 
FROM SCHEMA("AWS/ApplicationELB", LoadBalancer)
```

**前 10 大最活跃的负载均衡器**

```
SELECT MAX(ActiveConnectionCount) 
FROM SCHEMA("AWS/ApplicationELB", LoadBalancer) 
GROUP BY LoadBalancer 
ORDER BY SUM() DESC 
LIMIT 10
```

## AWS API 使用示例
<a name="cloudwatch-metrics-insights-queryexamples-APIusage"></a>

**按账户中的调用次数划分，排名前 20 的 AWS API**

```
SELECT COUNT(CallCount) 
FROM SCHEMA("AWS/Usage", Class, Resource, Service, Type) 
WHERE Type = 'API' 
GROUP BY Service, Resource 
ORDER BY COUNT() DESC 
LIMIT 20
```

**按调用排序的 CloudWatch API**

```
SELECT COUNT(CallCount) 
FROM SCHEMA("AWS/Usage", Class, Resource, Service, Type) 
WHERE Type = 'API' AND Service = 'CloudWatch' 
GROUP BY Resource 
ORDER BY COUNT() DESC
```

## DynamoDB 示例
<a name="cloudwatch-metrics-insights-queryexamples-DynamoDB"></a>

**按消耗的读取数排序的前 10 个表**

```
SELECT SUM(ProvisionedWriteCapacityUnits)
FROM SCHEMA("AWS/DynamoDB", TableName) 
GROUP BY TableName
ORDER BY MAX() DESC LIMIT 10
```

**按返回的字节数排序的前 10 个表**

```
SELECT SUM(ReturnedBytes)
FROM SCHEMA("AWS/DynamoDB", TableName) 
GROUP BY TableName
ORDER BY MAX() DESC LIMIT 10
```

**按用户错误排序的前 10 个表**

```
SELECT SUM(UserErrors)
FROM SCHEMA("AWS/DynamoDB", TableName) 
GROUP BY TableName
ORDER BY MAX() DESC LIMIT 10
```

## Amazon Elastic Block Store 示例
<a name="cloudwatch-metrics-insights-queryexamples-EBS"></a>

**按写入字节数排序的前 10 个 Amazon EBS 卷**

```
SELECT SUM(VolumeWriteBytes) 
FROM SCHEMA("AWS/EBS", VolumeId) 
GROUP BY VolumeId 
ORDER BY SUM() DESC 
LIMIT 10
```

**Amazon EBS 卷的平均写入时间**

```
SELECT AVG(VolumeTotalWriteTime) 
FROM SCHEMA("AWS/EBS", VolumeId)
```

## Amazon EC2 示例
<a name="cloudwatch-metrics-insights-queryexamples-EC2"></a>

**按最高排序的 EC2 实例 CPU 使用率**

```
SELECT AVG(CPUUtilization) 
  FROM SCHEMA("AWS/EC2", InstanceId) 
  GROUP BY InstanceId 
  ORDER BY AVG() DESC
```

**整个机群的平均 CPU 使用率**

```
SELECT AVG(CPUUtilization) 
FROM SCHEMA("AWS/EC2", InstanceId)
```

**按最高 CPU 使用率排序的前 10 个实例**

```
SELECT MAX(CPUUtilization) 
FROM SCHEMA("AWS/EC2", InstanceId) 
GROUP BY InstanceId 
ORDER BY MAX() DESC 
LIMIT 10
```

**在这种情况下，CloudWatch 代理正在根据应用程序收集 `CPUUtilization` 指标。此查询筛选特定应用程序名称的此指标的平均值。**

```
SELECT AVG(CPUUtilization)
FROM "AWS/CWAgent"
WHERE ApplicationName = 'eCommerce'
```

## Amazon Elastic Container Service 示例
<a name="cloudwatch-metrics-insights-queryexamples-ECS"></a>

**所有 ECS 集群的平均 CPU 使用率**

```
SELECT AVG(CPUUtilization) 
FROM SCHEMA("AWS/ECS", ClusterName)
```

**按内存利用率排序的前 10 个集群**

```
SELECT AVG(MemoryUtilization) 
FROM SCHEMA("AWS/ECS", ClusterName) 
GROUP BY ClusterName 
ORDER BY AVG() DESC
LIMIT 10
```

**按 CPU 使用率排序的前 10 项服务**

```
SELECT AVG(CPUUtilization) 
FROM SCHEMA("AWS/ECS", ClusterName, ServiceName) 
GROUP BY ClusterName, ServiceName 
ORDER BY AVG() DESC 
LIMIT 10
```

**按运行任务排序的前 10 项服务 (Container Insights)**

```
SELECT AVG(RunningTaskCount) 
FROM SCHEMA("ECS/ContainerInsights", ClusterName, ServiceName) 
GROUP BY ClusterName, ServiceName 
ORDER BY AVG() DESC 
LIMIT 10
```

## Amazon Elastic Kubernetes Service Container Insights 示例
<a name="cloudwatch-metrics-insights-queryexamples-EKSCI"></a>

**所有 EKS 集群的平均 CPU 使用率**

```
SELECT AVG(pod_cpu_utilization) 
FROM SCHEMA("ContainerInsights", ClusterName)
```

**按节点 CPU 使用率排序的前 10 个集群**

```
SELECT AVG(node_cpu_utilization) 
FROM SCHEMA("ContainerInsights", ClusterName) 
GROUP BY ClusterName
ORDER BY AVG() DESC LIMIT 10
```

**按 pod 内存利用率排序的前 10 个集群**

```
SELECT AVG(pop_memory_utilization) 
FROM SCHEMA("ContainerInsights", ClusterName) 
GROUP BY ClusterName
ORDER BY AVG() DESC LIMIT 10
```

**按 CPU 使用率排序的前 10 个节点**

```
SELECT AVG(node_cpu_utilization) 
FROM SCHEMA("ContainerInsights", ClusterName, NodeName) 
GROUP BY ClusterName, NodeName 
ORDER BY AVG() DESC LIMIT 10
```

**按内存利用率排序的前 10 个 pod**

```
SELECT AVG(pod_memory_utilization) 
FROM SCHEMA("ContainerInsights", ClusterName, PodName) 
GROUP BY ClusterName, PodName 
ORDER BY AVG() DESC LIMIT 10
```

## EventBridge 示例
<a name="cloudwatch-metrics-insights-queryexamples-EventBridge"></a>

**按调用排序的前 10 条规则**

```
SELECT SUM(Invocations)
FROM SCHEMA("AWS/Events", RuleName) 
GROUP BY RuleName
ORDER BY MAX() DESC LIMIT 10
```

**按失败调用排序的前 10 条规则**

```
SELECT SUM(FailedInvocations)
FROM SCHEMA("AWS/Events", RuleName) 
GROUP BY RuleName
ORDER BY MAX() DESC LIMIT 10
```

**按匹配规则排序的前 10 条规则**

```
SELECT SUM(MatchedEvents)
FROM SCHEMA("AWS/Events", RuleName) 
GROUP BY RuleName
ORDER BY MAX() DESC LIMIT 10
```

## Kinesis 示例
<a name="cloudwatch-metrics-insights-queryexamples-Kinesis"></a>

**按写入字节数排序的前 10 个流**

```
SELECT SUM("PutRecords.Bytes") 
FROM SCHEMA("AWS/Kinesis", StreamName) 
GROUP BY StreamName
ORDER BY SUM() DESC LIMIT 10
```

**按流中最早的项目排序的前 10 个流**

```
SELECT MAX("GetRecords.IteratorAgeMilliseconds") 
FROM SCHEMA("AWS/Kinesis", StreamName) 
GROUP BY StreamName
ORDER BY MAX() DESC LIMIT 10
```

## Lambda 示例
<a name="cloudwatch-metrics-insights-queryexamples-Lambda"></a>

**按调用次数排序的 Lambda 函数**

```
SELECT SUM(Invocations) 
FROM SCHEMA("AWS/Lambda", FunctionName) 
GROUP BY FunctionName 
ORDER BY SUM() DESC
```

**按最长运行时排序的前 10 个 Lambda 函数**

```
SELECT AVG(Duration) 
FROM SCHEMA("AWS/Lambda", FunctionName) 
GROUP BY FunctionName 
ORDER BY MAX() DESC 
LIMIT 10
```

**按错误计数排序的前 10 个 Lambda 函数**

```
SELECT SUM(Errors) 
FROM SCHEMA("AWS/Lambda", FunctionName) 
GROUP BY FunctionName 
ORDER BY SUM() DESC 
LIMIT 10
```

## CloudWatch Logs 示例
<a name="cloudwatch-metrics-insights-queryexamples-CloudWatchLogs"></a>

**按传入事件排序的前 10 个日志组**

```
SELECT SUM(IncomingLogEvents)
FROM SCHEMA("AWS/Logs", LogGroupName) 
GROUP BY LogGroupName
ORDER BY SUM() DESC LIMIT 10
```

**按写入字节数排序的前 10 个日志组**

```
SELECT SUM(IncomingBytes)
FROM SCHEMA("AWS/Logs", LogGroupName) 
GROUP BY LogGroupName
ORDER BY SUM() DESC LIMIT 10
```

## Amazon RDS 示例
<a name="cloudwatch-metrics-insights-queryexamples-RDS"></a>

**按最高 CPU 使用率排序的前 10 个 Amazon RDS 实例**

```
SELECT MAX(CPUUtilization)
FROM SCHEMA("AWS/RDS", DBInstanceIdentifier) 
GROUP BY DBInstanceIdentifier
ORDER BY MAX() DESC 
LIMIT 10
```

**按写入数排序的前 10 个 Amazon RDS 集群**

```
SELECT SUM(WriteIOPS)
FROM SCHEMA("AWS/RDS", DBClusterIdentifier) 
GROUP BY DBClusterIdentifier
ORDER BY MAX() DESC 
LIMIT 10
```

## Amazon Simple Storage Service 示例
<a name="cloudwatch-metrics-insights-queryexamples-S3"></a>

**按存储桶排序的平均延迟**

```
SELECT AVG(TotalRequestLatency) 
FROM SCHEMA("AWS/S3", BucketName, FilterId) 
WHERE FilterId = 'EntireBucket' 
GROUP BY BucketName 
ORDER BY AVG() DESC
```

**按已下载字节数排序的前 10 个存储桶**

```
SELECT SUM(BytesDownloaded) 
FROM SCHEMA("AWS/S3", BucketName, FilterId) 
WHERE FilterId = 'EntireBucket'
GROUP BY BucketName 
ORDER BY SUM() DESC 
LIMIT 10
```

## Amazon Simple Notification Service 示例
<a name="cloudwatch-metrics-insights-queryexamples-SNS"></a>

**SNS 主题发布的消息总数**

```
SELECT SUM(NumberOfMessagesPublished) 
FROM SCHEMA("AWS/SNS", TopicName)
```

**按发布消息排序的前 10 个主题**

```
SELECT SUM(NumberOfMessagesPublished) 
FROM SCHEMA("AWS/SNS", TopicName) 
GROUP BY TopicName 
ORDER BY SUM() DESC 
LIMIT 10
```

**按消息传送失败排序的前 10 个主题**

```
SELECT SUM(NumberOfNotificationsFailed) 
FROM SCHEMA("AWS/SNS", TopicName)
GROUP BY TopicName 
ORDER BY SUM() DESC 
LIMIT 10
```

## Amazon SQS 示例
<a name="cloudwatch-metrics-insights-queryexamples-SQS"></a>

**按可见消息数量排序的前 10 个队列**

```
SELECT AVG(ApproximateNumberOfMessagesVisible)
FROM SCHEMA("AWS/SQS", QueueName) 
GROUP BY QueueName
ORDER BY AVG() DESC 
LIMIT 10
```

**前 10 个最活跃的队列**

```
SELECT SUM(NumberOfMessagesSent)
FROM SCHEMA("AWS/SQS", QueueName) 
GROUP BY QueueName
ORDER BY SUM() DESC 
LIMIT 10
```

**按最早消息的时间排序的前 10 个队列**

```
SELECT AVG(ApproximateAgeOfOldestMessage)
FROM SCHEMA("AWS/SQS", QueueName) 
GROUP BY QueueName
ORDER BY AVG() DESC 
LIMIT 10
```

# Metrics Insights 术语表
<a name="cloudwatch-metrics-insights-glossary"></a>

**标签**  
在 Metrics Insights 中，标签是一个键值对，用于确定查询范围以返回特定数据集，或者定义将查询结果分为单独时间序列的标准。标签键与 SQL 中的列名称类似。标签必须是 CloudWatch 指标维度。

**观测值**  
观测值是指在给定时间为给定指标记录的值。

# Metrics Insights 问题排查
<a name="cloudwatch-metrics-insights-troubleshooting"></a>

## 结果包括“其他”，但未将其作为维度
<a name="cloudwatch-metrics-insights-troubleshooting-other"></a>

这意味着查询包含 **GROUP BY** 子句，该子句指定查询返回的某些指标中未使用的标签键。在这种情况下，会返回名为 `Other` 的空组。不包含该标签键的指标可能是聚合指标，这些指标返回该标签键的所有值之间聚合的值。

 例如，假设我们有以下查询：

```
SELECT AVG(Faults) 
FROM MyCustomNamespace 
GROUP BY Operation, ServiceName
```

如果某些返回的指标不作为维度包括 `ServiceName`，则这些指标将显示为将 `Other` 作为 `ServiceName` 的值。

要防止在结果中看到“其他”，请在您的 **FROM** 子句中使用 **SCHEMA**，如以下示例所示：

```
SELECT AVG(Faults) 
FROM SCHEMA(MyCustomNamespace, Operation)
GROUP BY Operation, ServiceName
```

这将返回的结果限制为同时具有 `Operation` 和 `ServiceName` 维度的指标。

## 我的图表中最早的时间戳的指标值比其他时间戳的指标值低
<a name="cloudwatch-metrics-insights-troubleshooting-oldest"></a>

CloudWatch Metrics Insights 支持长达两周的历史数据。当您使用大于 1 分钟的时间段绘制图表时，可能会出现最早的数据点与预期值不同的情况。这是因为 CloudWatch Metrics Insights 查询仅返回两周保留期内的数据。在这种情况下，查询中最早的数据点仅会返回两周界限内测得的观察值，而不会返回该数据点时间段内的所有观察值。

## 使用基于标签的查询时，不同时间段的指标值不一致
<a name="cloudwatch-metrics-insights-troubleshooting-tag-mutations"></a>

在 CloudWatch Metrics Insights 查询中使用带有标签的 `WHERE` 或 `GROUP BY` 子句时，根据所选的时间段，可能会看到不同的指标值。例如，6 小时的时段可能显示峰值 20，而 1 小时的时段在同一时间窗口内仅显示峰值 2。

出现这种情况是因为标签时间戳以二级分辨率存储，而指标数据点则与时段边界（例如，每分钟或每小时的开始）对齐。为了确定哪些数据点与标签时间范围匹配，CloudWatch 通过减去一个时段来调整该范围的起始点。对于较长的时段，此调整会在标签时间戳和最早包含的数据点之间造成更大的间隔，这可能会导致范围起始点附近的数据点被排除在外。

以下示例说明了这会如何影响查询结果。一个指标有两个标签值：`env=beta`（从 00:00 至 01:30）和 `env=gamma`（从 01:30 至 03:00）。每个标签覆盖 90 分钟的数据，总和为 270。

![\[两张 CloudWatch 指标图表，将基于标签的查询结果与 1 分钟和 3 小时的时段进行了比较。\]](http://docs.aws.amazon.com/zh_cn/AmazonCloudWatch/latest/monitoring/images/metrics-insights-tag-alignment.png)



| **env=beta，时段为 1 分钟** | Statistic | 预期 | 返回值 | 区别 | 
| --- | --- | --- | --- | --- | 
| SUM | 270 | 271 | \$11 | 
| AVG | 3.0 | 3.0 | 0 | 
| MIN | 1 | 1 | 0 | 
| MAX | 5 | 5 | 0 | 
| SAMPLE\$1COUNT | 90 | 91 | \$11 | 


| **env=gamma，时段为 1 分钟** | Statistic | 预期 | 返回值 | 区别 | 
| --- | --- | --- | --- | --- | 
| SUM | 270 | 275 | 5\$1 | 
| AVG | 3.0 | 3.0 | 0 | 
| MIN | 1 | 1 | 0 | 
| MAX | 5 | 5 | 0 | 
| SAMPLE\$1COUNT | 90 | 91 | \$11 | 

对于 1 分钟的时段，对齐调整很小（1 分钟），因此每个标签只包含 1 个额外的数据点。对于 3 小时的时段，调整跨越了整个查询范围：


| **env=beta，时段为 3 小时** | Statistic | 预期 | 返回值 | 区别 | 
| --- | --- | --- | --- | --- | 
| SUM | 270 | 540 | \$1270 | 
| AVG | 3.0 | 3.0 | 0 | 
| MIN | 1 | 1 | 0 | 
| MAX | 5 | 5 | 0 | 
| SAMPLE\$1COUNT | 90 | 180 | \$190 | 


| **env=gamma，时段为 3 小时** | Statistic | 预期 | 返回值 | 区别 | 
| --- | --- | --- | --- | --- | 
| SUM | 270 | 540 | \$1270 | 
| AVG | 3.0 | 3.0 | 0 | 
| MIN | 1 | 1 | 0 | 
| MAX | 5 | 5 | 0 | 
| SAMPLE\$1COUNT | 90 | 180 | \$190 | 

对于 3 小时的时段，两个标签都会返回整个数据集（SUM=540，SAMPLE\$1COUNT=180），因为单个聚合数据点的时间戳在两个调整后的范围内。标签边界已被有效擦除。

要减少此行为的影响，请尝试以下方法：
+ **使用较短的聚合时段。**较短的时段（例如 1 分钟或 5 分钟）更贴近地匹配标签时间戳的二级分辨率，这样可以最大限度地减少对齐间隔，并且更有可能包含所有相关数据点。
+ **使用基于维度的筛选而不是标签。**如果使用案例允许，请按维度而不是标签进行筛选。基于维度的查询不受此行为的影响。例如，使用 `WHERE InstanceId = 'i-1234567890abcdef0'` 而不是 `WHERE tag."my-tag" = 'my-value'`。
+ **以一致的粒度进行查询。**比较不同时间窗口的指标数据时，请使用相同的时段，以避免因对齐调整导致的意外差异。