# 综合监控（Canary）
您可以使用 Amazon CloudWatch Synthetics 创建*金丝雀*。金丝雀是按计划运行的可配置脚本，用于监控端点和 API。金丝雀遵循相同的路线并执行与客户相同的操作，这使您能够持续验证您的客户体验，即使您的应用程序中没有任何客户流量也可以。使用金丝雀，您可以早于客户先行发现问题。
金丝雀是指用 Node.js、Python 或 Java 编写的脚本，会在账户中创建以 Node.js、Python 或 Java 作为运行时的 Lambda 函数。金丝雀通过 HTTP 和 HTTPS 两种协议工作。金丝雀使用包含 CloudWatch Synthetics 库的 Lambda 层。该库提供适用于 NodeJS、Python 和 Java 的 CloudWatch Synthetics 实现。
使用 Node.js 和 Python 运行时的金丝雀，可通过 Playwright、Puppeteer 或 Selenium Webdriver 提供对无外设浏览器的程序化访问能力。支持多种浏览器，包括无外设 Google Chrome 和 Mozilla Firefox。有关 Playwright 的更多信息，请参阅 [Playwright](https://playwright.dev/)。有关 Puppeteer 的更多信息，请参阅 [Puppeteer](https://developer.chrome.com/docs/puppeteer/)。有关 Selenium 的更多信息，请参阅 [Selenium](https://www.selenium.dev/)。Selenium 上的金丝雀仅支持 Chrome 浏览器。使用 Java 的金丝雀旨在灵活地监控任意类型的服务或应用程序，不包含浏览器支持或框架。
金丝雀检查终端节点的可用性和延迟，并可以存储加载时间数据和 UI 屏幕截图。它们可以监控您的 REST API、URL 和网站内容，并且可以检查来自网络钓鱼、代码注入和跨站脚本的未经授权更改。
CloudWatch Synthetics 与 [Application Signals](CloudWatch-Application-Monitoring-Sections.md) 集成，可以发现和监控您的应用程序服务、客户端、Synthetics Canary 和服务依赖项。使用 Application Signals 查看您的服务列表或可视地图，根据您的服务级别目标（SLO）查看运行状况指标，并深入查看关联 X-Ray 跟踪以便更详细地进行问题排查。要在 Application Signals 中查看您的 Canary，[打开 X-Ray 活动跟踪](CloudWatch_Synthetics_Canaries_tracing.md)。金丝雀将显示在与服务相连的[应用程序图](ServiceMap.md)，以及所调用服务的[服务详细信息](ServiceDetail.md)页面上。
有关金丝雀的视频演示，请参阅以下内容:
+ [Amazon CloudWatch Synthetics 简介](https://www.youtube.com/watch?v=MItluIsvfTo)
+ [Amazon CloudWatch Synthetics 演示](https://www.youtube.com/watch?v=hF3NM9j-u7I)
+ [使用 Amazon CloudWatch Synthetics 创建金丝雀](https://www.youtube.com/watch?v=DSx65wW7lr0)
+ [使用 Amazon CloudWatch Synthetics 进行可视化监控](https://www.youtube.com/watch?v=_PCs-ucZz7E)
您可以运行一次金丝雀，也可以定期运行。金丝雀的运行频率可达每分钟一次。您可以使用 cron 和 rate 表达式来计划金丝雀。
有关在创建和运行金丝雀之前需要考虑的安全问题相关信息，请参阅 [Synthetics 金丝雀的安全注意事项](servicelens_canaries_security.md)。
预设情况下，金丝雀会在 `CloudWatchSynthetics` 命名空间中创建几个 CloudWatch 指标。这些指标使用 `CanaryName` 作为维度。使用函数库中 `executeStep()` 或 `executeHttpStep()` 函数的金丝雀还具有 `StepName` 维度。有关金丝雀函数库的更多信息，请参阅[可用于金丝雀脚本的库函数](CloudWatch_Synthetics_Canaries_Function_Library.md)。
CloudWatch Synthetics 与 X-Ray 跟踪地图集成良好，其将 CloudWatch 与 AWS X-Ray 结合使用，以提供服务的端到端视图，帮助您更有效地查明性能瓶颈并确定受影响的用户。使用 CloudWatch Synthetics 创建的 Canary 将显示在跟踪地图中。有关更多信息，请参阅 [X-Ray 跟踪地图](https://docs.aws.amazon.com/xray/latest/devguide/xray-console-servicemap.html)。
CloudWatch Synthetics 目前在所有商业 AWS 区域和 GovCloud 区域可用。
**注意**
在亚太地区（大阪）不支持 AWS PrivateLink。在亚太地区（雅加达），AWS PrivateLink 和 X-Ray 不受支持。
**Topics**
+ [CloudWatch 金丝雀的必需角色和权限](CloudWatch_Synthetics_Canaries_Roles.md)
+ [创建金丝雀](CloudWatch_Synthetics_Canaries_Create.md)
+ [组](CloudWatch_Synthetics_Groups.md)
+ [在本地测试 Canary](CloudWatch_Synthetics_Debug_Locally.md)
+ [排查失败金丝雀的问题](CloudWatch_Synthetics_Canaries_Troubleshoot.md)
+ [金丝雀脚本示例代码](CloudWatch_Synthetics_Canaries_Samples.md)
+ [金丝雀和 X-Ray 跟踪](CloudWatch_Synthetics_Canaries_tracing.md)
+ [在 VPC 上运行金丝雀](CloudWatch_Synthetics_Canaries_VPC.md)
+ [加密金丝雀构件](CloudWatch_Synthetics_artifact_encryption.md)
+ [查看金丝雀统计数据和详细信息](CloudWatch_Synthetics_Canaries_Details.md)
+ [金丝雀发布的 CloudWatch 指标](CloudWatch_Synthetics_Canaries_metrics.md)
+ [编辑或删除金丝雀脚本](synthetics_canaries_deletion.md)
+ [启动、停止、删除或更新多个金丝雀脚本的运行时](synthetics_canaries_multi-action.md)
+ [使用 Amazon EventBridge 监控金丝雀事件](monitoring-events-eventbridge.md)
+ [执行安全金丝雀更新](performing-safe-canary-upgrades.md)
# CloudWatch 金丝雀的必需角色和权限
创建和管理金丝雀的用户以及金丝雀本身都必须拥有某些权限。
# 管理 CloudWatch 金丝雀的用户的必需角色和权限
若要查看 Canary 详细信息和 Canary 运行的结果，您必须以附加了 `CloudWatchSyntheticsFullAccess` 或 ` CloudWatchSyntheticsReadOnlyAccess` 策略的用户身份登录。要在控制台中读取所有 Synthetics 数据，您还需要 `AmazonS3ReadOnlyAccess` 和 ` CloudWatchReadOnlyAccess` 策略。要查看金丝雀使用的源代码，您还需要 `AWSLambda_ReadOnlyAccess` 策略。
要创建 Canary ，您必须以具有 ` CloudWatchSyntheticsFullAccess` 策略或类似权限集的用户身份登录。要为金丝雀创建 IAM 角色，您还需要以下内联策略语句：
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iam:CreateRole",
"iam:CreatePolicy",
"iam:AttachRolePolicy"
],
"Resource": [
"arn:aws:iam::*:role/service-role/CloudWatchSyntheticsRole*",
"arn:aws:iam::*:policy/service-role/CloudWatchSyntheticsPolicy*"
]
}
]
}
```
------
**重要**
通过向用户授予 `iam:CreateRole`、`iam:CreatePolicy` 和 ` iam:AttachRolePolicy` 权限，用户将获得对 AWS 账户的完全管理访问权限。例如，具有这些权限的用户可以创建一个对所有资源具有完全权限的策略，并将该策略附加到任何角色。请谨慎地为相关人员授予这些权限。
有关附加策略和向用户授予权限的信息，请参阅[更改 IAM 用户的权限](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console)和[为用户或角色嵌入内联策略](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html#embed-inline-policy-console)。
# 金丝雀的必需角色和权限
每个金丝雀必须与附加某些权限的 IAM 角色相关联。当您使用 CloudWatch 控制台创建金丝雀时，您可以选择 CloudWatch Synthetics 为金丝雀创建 IAM 角色。如果您这样做，该角色将拥有所需的权限。
如果您要自己创建 IAM 角色，或者创建使用 AWS CLI 或 API 创建金丝雀时可以使用的 IAM 角色，角色必须包含本部分中列出的权限。
金丝雀的所有 IAM 角色必须包含以下信任策略语句。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
此外，金丝雀的 IAM 角色需要以下语句之一。
**不使用 AWS KMS 或者需要 Amazon VPC 访问的基本金丝雀**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::path/to/your/s3/bucket/canary/results/folder"
]
},
{
"Effect": "Allow",
"Action": [
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:::name/of/the/s3/bucket/that/contains/canary/results"
]
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:CreateLogGroup"
],
"Resource": [
"arn:aws:logs:us-east-1:123456789012:log-group:/aws/lambda/cwsyn-canary_name-*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:ListAllMyBuckets",
"xray:PutTraceSegments"
],
"Resource": [
"*"
]
},
{
"Effect": "Allow",
"Resource": "*",
"Action": "cloudwatch:PutMetricData",
"Condition": {
"StringEquals": {
"cloudwatch:namespace": "CloudWatchSynthetics"
}
}
}
]
}
```
------
**使用 AWS KMS 加密金丝雀构件但不需要 Amazon VPC 访问的金丝雀**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::path/to/your/S3/bucket/canary/results/folder"
]
},
{
"Effect": "Allow",
"Action": [
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:::name/of/the/S3/bucket/that/contains/canary/results"
]
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:CreateLogGroup"
],
"Resource": [
"arn:aws:logs:us-east-1:123456789012:log-group:/aws/lambda/cwsyn-canary_name-*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:ListAllMyBuckets",
"xray:PutTraceSegments"
],
"Resource": [
"*"
]
},
{
"Effect": "Allow",
"Resource": "*",
"Action": "cloudwatch:PutMetricData",
"Condition": {
"StringEquals": {
"cloudwatch:namespace": "CloudWatchSynthetics"
}
}
},
{
"Effect": "Allow",
"Action": [
"kms:Decrypt",
"kms:GenerateDataKey"
],
"Resource": "arn:aws:kms:us-east-1:111122223333:key/KMS_key_id",
"Condition": {
"StringEquals": {
"kms:ViaService": [
"s3.us-east-1.amazonaws.com"
]
}
}
}
]
}
```
------
**不使用 AWS KMS 但需要 Amazon VPC 访问的金丝雀**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::path/to/your/S3/bucket/canary/results/folder"
]
},
{
"Effect": "Allow",
"Action": [
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:::name/of/the/S3/bucket/that/contains/canary/results"
]
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:CreateLogGroup"
],
"Resource": [
"arn:aws:logs:us-east-1:123456789012:log-group:/aws/lambda/cwsyn-canary_name-*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:ListAllMyBuckets",
"xray:PutTraceSegments"
],
"Resource": [
"*"
]
},
{
"Effect": "Allow",
"Resource": "*",
"Action": "cloudwatch:PutMetricData",
"Condition": {
"StringEquals": {
"cloudwatch:namespace": "CloudWatchSynthetics"
}
}
},
{
"Effect": "Allow",
"Action": [
"ec2:CreateNetworkInterface",
"ec2:DescribeNetworkInterfaces",
"ec2:DeleteNetworkInterface"
],
"Resource": [
"*"
]
}
]
}
```
------
**使用 AWS KMS 加密金丝雀构件并且也需要 Amazon VPC 访问的金丝雀**
如果您更新非 VPC 金丝雀以开始使用 VPC，则为了包含以下策略中列出的网络接口权限，需要更新金丝雀的角色。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::path/to/your/S3/bucket/canary/results/folder"
]
},
{
"Effect": "Allow",
"Action": [
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:::name/of/the/S3/bucket/that/contains/canary/results"
]
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:CreateLogGroup"
],
"Resource": [
"arn:aws:logs:us-east-1:123456789012:log-group:/aws/lambda/cwsyn-canary_name-*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:ListAllMyBuckets",
"xray:PutTraceSegments"
],
"Resource": [
"*"
]
},
{
"Effect": "Allow",
"Resource": "*",
"Action": "cloudwatch:PutMetricData",
"Condition": {
"StringEquals": {
"cloudwatch:namespace": "CloudWatchSynthetics"
}
}
},
{
"Effect": "Allow",
"Action": [
"ec2:CreateNetworkInterface",
"ec2:DescribeNetworkInterfaces",
"ec2:DeleteNetworkInterface"
],
"Resource": [
"*"
]
},
{
"Effect": "Allow",
"Action": [
"kms:Decrypt",
"kms:GenerateDataKey"
],
"Resource": "arn:aws:kms:us-east-1:111122223333:key/KMS_key_id",
"Condition": {
"StringEquals": {
"kms:ViaService": [
"s3.us-east-1.amazonaws.com"
]
}
}
}
]
}
```
------
## 用于 CloudWatch Synthetics 的 AWS 托管式策略
要向用户、组和角色添加权限，与自己编写策略相比，使用 AWS 托管式策略更简单。创建仅为团队提供所需权限的 IAM 客户管理型策略需要时间和专业知识。要快速入门，您可以使用我们的 AWS 托管式策略。这些策略涵盖常见使用案例，可在您的 AWS 账户中使用。有关 AWS 托管式策略的更多信息，请参阅 IAM 用户指南中的 [AWS 托管式策略](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) AWS 托管式策略。
AWS 服务负责维护和更新 AWS 托管式策略。您无法更改 AWS 托管式策略中的权限。服务会偶尔更改 AWS 托管式策略中的权限。此类更新会影响附加策略的所有身份（用户、组和角色）。
### CloudWatch Synthetics 对 AWS 托管式策略的更新
查看有关 CloudWatch Synthetics 的 AWS 托管式策略更新的详细信息（从该服务开始跟踪这些更改开始）。有关此页面更改的自动提示，请订阅 CloudWatch 文档历史记录页面上的 RSS 源。
| 更改 | 描述 | 日期 |
| --- | --- | --- |
| 删除了 **CloudWatchSyntheticsFullAccess** 中的冗余操作 | CloudWatch Synthetics 删除了 **CloudWatchSyntheticsFullAccess** 策略中的 `s3:PutBucketEncryption` 和 ` lambda:GetLayerVersionByArn` 操作，因为这些操作相较于策略中的其他权限是多余的。删除的操作不提供任何权限，策略授予的权限也未发生任何净更改。 | 2021 年 3 月 12 日 |
| CloudWatch Synthetics 开始跟踪变更 | CloudWatch Synthetics 开始跟踪其 AWS 托管式策略的更改。 | 2021 年 3 月 10 日 |
**CloudWatchSyntheticsFullAccess**
以下是 `CloudWatchSyntheticsFullAccess` 策略的内容：
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": [
"synthetics:*"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"s3:CreateBucket",
"s3:PutEncryptionConfiguration"
],
"Resource": [
"arn:aws:s3:::cw-syn-results-*"
]
},
{
"Effect": "Allow",
"Action": [
"iam:ListRoles",
"s3:ListAllMyBuckets",
"xray:GetTraceSummaries",
"xray:BatchGetTraces",
"apigateway:GET"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetBucketLocation"
],
"Resource": "arn:aws:s3:::*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:ListBucket"
],
"Resource": "arn:aws:s3:::cw-syn-*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObjectVersion"
],
"Resource": "arn:aws:s3:::aws-synthetics-library-*"
},
{
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::*:role/service-role/CloudWatchSyntheticsRole*"
],
"Condition": {
"StringEquals": {
"iam:PassedToService": [
"lambda.amazonaws.com",
"synthetics.amazonaws.com"
]
}
}
},
{
"Effect": "Allow",
"Action": [
"iam:GetRole",
"iam:ListAttachedRolePolicies"
],
"Resource": [
"arn:aws:iam::*:role/service-role/CloudWatchSyntheticsRole*"
]
},
{
"Effect": "Allow",
"Action": [
"cloudwatch:GetMetricData",
"cloudwatch:GetMetricStatistics"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"cloudwatch:PutMetricAlarm",
"cloudwatch:DeleteAlarms"
],
"Resource": [
"arn:aws:cloudwatch:*:*:alarm:Synthetics-*"
]
},
{
"Effect": "Allow",
"Action": [
"cloudwatch:DescribeAlarms"
],
"Resource": [
"arn:aws:cloudwatch:*:*:alarm:*"
]
},
{
"Effect": "Allow",
"Action": [
"logs:GetLogRecord",
"logs:DescribeLogStreams",
"logs:StartQuery",
"logs:GetLogEvents",
"logs:FilterLogEvents",
"logs:GetLogGroupFields"
],
"Resource": [
"arn:aws:logs:*:*:log-group:/aws/lambda/cwsyn-*"
],
"Condition": {
"StringEquals": {
"aws:ResourceAccount": "${aws:PrincipalAccount}"
}
}
},
{
"Effect": "Allow",
"Action": [
"lambda:CreateFunction",
"lambda:AddPermission",
"lambda:PublishVersion",
"lambda:UpdateFunctionCode",
"lambda:UpdateFunctionConfiguration",
"lambda:GetFunctionConfiguration",
"lambda:GetFunction",
"lambda:DeleteFunction",
"lambda:ListTags",
"lambda:TagResource",
"lambda:UntagResource"
],
"Resource": [
"arn:aws:lambda:*:*:function:cwsyn-*"
]
},
{
"Effect": "Allow",
"Action": [
"lambda:GetLayerVersion",
"lambda:PublishLayerVersion",
"lambda:DeleteLayerVersion"
],
"Resource": [
"arn:aws:lambda:*:*:layer:cwsyn-*",
"arn:aws:lambda:*:*:layer:Synthetics:*",
"arn:aws:lambda:*:*:layer:Synthetics_Selenium:*",
"arn:aws:lambda:*:*:layer:AWS-CW-Synthetics*:*"
]
},
{
"Effect": "Allow",
"Action": [
"ec2:DescribeVpcs",
"ec2:DescribeSubnets",
"ec2:DescribeSecurityGroups"
],
"Resource": [
"*"
]
},
{
"Effect": "Allow",
"Action": [
"sns:ListTopics"
],
"Resource": [
"*"
]
},
{
"Effect": "Allow",
"Action": [
"sns:CreateTopic",
"sns:Subscribe",
"sns:ListSubscriptionsByTopic"
],
"Resource": [
"arn:*:sns:*:*:Synthetics-*"
]
},
{
"Effect": "Allow",
"Action": [
"kms:ListAliases"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"kms:DescribeKey"
],
"Resource": "arn:aws:kms:*:*:key/*"
},
{
"Effect": "Allow",
"Action": [
"kms:Decrypt"
],
"Resource": "arn:aws:kms:*:*:key/*",
"Condition": {
"StringLike": {
"kms:ViaService": [
"s3.*.amazonaws.com"
]
}
}
}
]
}
```
------
**CloudWatchSyntheticsReadOnlyAccess**
以下是 `CloudWatchSyntheticsReadOnlyAccess` 策略的内容：
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"synthetics:Describe*",
"synthetics:Get*",
"synthetics:List*"
],
"Resource": "*"
}
]
}
```
------
# 限制用户查看特定的金丝雀
您可以限制用户查看金丝雀相关信息，使他们只能看到您指定金丝雀的信息。为此，请将 IAM 策略与类似以下内容的 ` Condition` 声明配合使用，并将此策略附加到用户或 IAM 角色。
以下示例限制了用户只能查看 ` name-of-allowed-canary-1` 和 `name-of-allowed-canary-2` 相关信息。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "synthetics:DescribeCanaries",
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"synthetics:Names": [
"name-of-allowed-canary-1",
"name-of-allowed-canary-2"
]
}
}
}
]
}
```
------
CloudWatch Synthetics 支持在 `synthetics:Names` 数组中最多列出五个项目。
您也可以创建策略，在允许的金丝雀名称中使用 \$1** 作为通配符，如以下示例所示：
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "synthetics:DescribeCanaries",
"Resource": "*",
"Condition": {
"ForAnyValue:StringLike": {
"synthetics:Names": [
"my-team-canary-*"
]
}
}
}
]
}
```
------
使用所附的这些策略之一登录的任何用户都不能使用 CloudWatch 控制台查看任何金丝雀信息。他们只能使用 [DescribeCanaries](https://docs.aws.amazon.com/AmazonSynthetics/latest/APIReference/API_DescribeCanaries.html) API 或 [describe-canaries](https://docs.aws.amazon.com/cli/latest/reference/synthetics/describe-canaries.html) AWS CLI 命令，查看策略授权的金丝雀信息。
# 创建金丝雀
**重要**
确保使用 Synthetics 金丝雀来仅监控您拥有所有权或权限的终端节点和 API。根据金丝雀运行频率设置，这些端点可能会面临流量增加的情况。
当您使用 CloudWatch 控制台创建金丝雀时，您可以使用 CloudWatch 提供的蓝图创建您的金丝雀，也可以编写您自己的脚本。有关更多信息，请参阅 [使用金丝雀蓝图](CloudWatch_Synthetics_Canaries_Blueprints.md)。
如果使用的是您自己的金丝雀脚本，您还可以使用 CloudFormation 创建金丝雀。有关更多信息，请参阅《AWS CloudFormation 用户指南》**中的 [AWS::Synthetics::Canary](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-synthetics-canary.html)。
如果您正在编写自己的脚本，则可以使用 CloudWatch Synthetics 已内置在库中的多个函数。有关更多信息，请参阅 [Synthetics 运行时版本](CloudWatch_Synthetics_Canaries_Library.md)。
**注意**
当您创建金丝雀时，所创建的其中一个层是前面加上 ` Synthetics` 的 Synthetics 层。该层归 Synthetics 服务账户所有，且包含运行时系统代码。
**创建金丝雀**
1. 通过 [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) 打开 CloudWatch 控制台。
1. 在导航窗格中，选择 **Application Signals**、**Synthetics 金丝雀**。
1. 选择 **Create Canary (创建金丝雀)**。
1. 选择下列选项之一：
+ 要将某个蓝图脚本作为金丝雀的基础，请选择 **Use a blueprint (使用蓝图)**，然后选择要创建的金丝雀的类型。有关每种类型的蓝图执行的操作的更多信息，请参阅[使用金丝雀蓝图](CloudWatch_Synthetics_Canaries_Blueprints.md)。
+ 要上传您自己的 node.js 脚本以创建自定义金丝雀，请选择 **Upload a script (上传脚本)**。
然后，您可以将脚本拖入 **Script (脚本)** 区域，或者选择 **Browse files (浏览文件)**，在文件系统中浏览找到该脚本。
+ 要从 S3 存储桶导入脚本，请选择 **Import from S3 (从 S3 导入)**。然后，在 **Source location (源位置)** 下，输入金丝雀的完整路径或选择 **Browse S3 (浏览 S3)**。
您必须对您使用的 S3 存储桶具有 `s3:GetObject` 和 `s3:GetObjectVersion` 权限。存储桶必须位于您在其中创建金丝雀的同一 AWS 区域内。
1. 在 **Name (名称)** 下，输入金丝雀的名称。此名称将用于许多页面，因此，我们建议您为该金丝雀提供一个描述性名称，以将它与其他金丝雀区分开来。
1. 在 **Application or endpoint URL (应用程序或终端节点 URL)** 下，输入您希望金丝雀测试的 URL。此 URL 必须包含协议（例如 https://）。
如果您希望金丝雀测试 VPC 上的终端节点，还必须在此过程随后的步骤中输入有关 VPC 的信息。
1. 如果您将自己的脚本用于金丝雀，请在 **Lambda handler (Lambda 处理程序)** 下，输入您希望金丝雀开始的入口点。有关 Lambda 处理程序格式的信息，请参阅 [Synthetics 运行时版本](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Synthetics_Canaries_Library.html)。
1. 在**脚本编辑器**的**运行时版本**下，选择要执行金丝雀的 Synthetics 运行时版本。有关 Synthetics 运行时版本的信息，请参阅 [Synthetics 运行时版本](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Synthetics_Canaries_Library.html)。
在**浏览器配置**下，您可以启用浏览器来测试金丝雀。必须至少选择一个浏览器。
1. 如果在脚本中使用环境变量，请选择 **Environment variables（环境变量）**，然后为脚本中定义的每个环境变量指定值。有关更多信息，请参阅 [环境变量](CloudWatch_Synthetics_Canaries_WritingCanary_Nodejs_Pup.md#CloudWatch_Synthetics_Environment_Variables)。
1. 在 **Schedule（计划）**下，选择是运行此金丝雀一次、使用 rate 表达式连续运行，还是使用 cron 表达式对其进行计划。
+ 当您使用 CloudWatch 控制台创建连续运行的金丝雀时，您可以在每分钟一次到每小时一次之间的范围内选择一个运行速率。
+ 有关为金丝雀调度编写 cron 表达式的更多信息，请参阅 [使用 cron 安排金丝雀运行](CloudWatch_Synthetics_Canaries_cron.md)。
1. （可选）要为金丝雀设置超时值，请选择 **Additional configuration**（其它配置），然后指定该超时值。此值不要短于 15 秒钟，以预留 Lambda 冷启动以及启动金丝雀工具的时间。
1. 在 **Data retention (数据保留)** 下，指定保留有关失败和成功的金丝雀运行的信息的时间。范围为 1 - 455 天。
此设置会影响 [GetCanaryRuns](https://docs.aws.amazon.com/AmazonSynthetics/latest/APIReference/API_GetCanaryRuns.html) 操作返回的信息范围以及 Synthetics 控制台中显示的信息范围。
它不会影响 Amazon S3 存储桶中存储的数据，也不会影响 Canary 发布的日志或指标。
无论金丝雀的数据留存期长短，控制台中显示的信息范围都有一定限制。在 Synthetics 控制台主视图中，相对和绝对时间范围限制为七天。在特定金丝雀的 Synthetics 控制台视图中，相对时间范围限制为七天，绝对时间范围限制为 30 天。
1. 在**数据存储**下，选择要用于存储来自金丝雀运行的数据的 Amazon S3 存储桶。存储桶名称不能包含句点 (.)。如果将此选项保留空白，将使用或创建默认 Amazon S3 存储桶。
1. （可选）默认情况下，金丝雀将自己的构件存储在 Amazon S3 上，并使用 AWS 托管式 AWS KMS 密钥将构件静态加密。您可以通过选择 **Data Storage**（数据存储）部分的 **Additional configuration**（其他配置）来使用不同的加密选项。然后，您可以选择用于加密的密钥类型。有关更多信息，请参阅 [加密金丝雀构件](CloudWatch_Synthetics_artifact_encryption.md)。
1. 在 **Access permissions（访问权限）**下，选择是创建 IAM 角色来运行金丝雀，还是使用现有角色。
如果您使用 CloudWatch Synthetics 创建角色，则其会自动包含所有必要的权限。如果您要自己创建角色，请参阅 [金丝雀的必需角色和权限](CloudWatch_Synthetics_Canaries_CanaryPermissions.md) 获取有关必要权限的信息。
如果您在创建金丝雀时使用 CloudWatch 控制台为金丝雀创建角色，则无法将该角色重新用于其他金丝雀，因为这些角色仅特定于一个金丝雀。如果您已手动创建了适用于多个金丝雀的角色，则可以使用现有角色。
若要使用现有角色，您必须具有 `iam:PassRole` 权限，以将角色传递到 Synthetics 和 Lambda。您还必须拥有 `iam:GetRole` 权限。
1. （可选）在 **Alarms（告警）**下，选择是否要为此金丝雀创建默认 CloudWatch 告警。如果选择创建告警，则会按照以下命名约定创建告警：`Synthetics-Alarm-canaryName -index `
`index` 是一个数字，代表为此金丝雀创建的各个不同的告警。第一个告警的索引为 1，第二个告警的索引为 2，依此类推。
1. （可选）要让此金丝雀测试 VPC 上的终端节点，请选择 **VPC settings (VPC 设置)**，并执行以下操作：
1. 选择托管终端节点的 VPC。
1. 选择 VPC 上的一个或多个子网。您必须选择私有子网，因为在执行过程中无法为 Lambda 实例分配 IP 地址时，无法将 Lambda 实例配置为在公有子网中运行。有关更多信息，请参阅[配置 Lambda 函数以访问 VPC 中的资源](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc.html)。
1. 在 VPC 上选择一个或多个安全组。
1. 要允许此金丝雀的出站 IPv6 流量，请选择**允许双堆栈子网的 IPv6 流量**。这样能让金丝雀通过 IPv6 监测仅限 IPv6 和启用了双堆栈的端点。
您可以通过授予金丝雀互联网访问权限并适当配置 VPC 子网来监测 VPC 外部的端点。有关更多信息，请参阅 [在 VPC 上运行金丝雀](CloudWatch_Synthetics_Canaries_VPC.md)。
如果端点位于 VPC 上，则必须启用您的金丝雀才能向 CloudWatch 和 Amazon S3 发送信息。有关更多信息，请参阅 [在 VPC 上运行金丝雀](CloudWatch_Synthetics_Canaries_VPC.md)。
1. （可选）在 **Tags (标签)** 下，添加一个或多个键/值对作为此金丝雀的标签。标签可帮助您识别和组织 AWS 资源并跟踪 AWS 成本。有关更多信息，请参阅 [标记 Amazon CloudWatch 资源](CloudWatch-Tagging.md)。
如果您希望应用于金丝雀的标签也应用于金丝雀使用的 Lambda 函数，请在**标签复制**下选择 **Lambda 函数**。如果您选择此选项，CloudWatch Synthetics 将使金丝雀上的标签和 Lambda 函数保持同步：
+ Synthetics 会将您在此处指定的相同标签同时应用于您的金丝雀和 Lambda 函数。
+ 如果您稍后更新金丝雀的标签并保持选中此选项，Synthetics 会修改 Lambda 函数上的标签以与金丝雀保持同步。
1. （可选）在 **Active tracing（活动跟踪）**下，选择是否启用此金丝雀的活动 X-Ray 跟踪。主动跟踪仅适用于 Puppeteer 和 Java 运行时。有关更多信息，请参阅 [金丝雀和 X-Ray 跟踪](CloudWatch_Synthetics_Canaries_tracing.md)。
## 为金丝雀创建的资源
创建金丝雀时，将创建以下资源：
+ 一个名为 `CloudWatchSyntheticsRole-canary-name -uuid` 的 IAM 角色（如果您使用 CloudWatch 控制台创建金丝雀并指定为金丝雀创建新角色）
+ 一个名为 `CloudWatchSyntheticsPolicy- canary-name-uuid` 的 IAM 策略。
+ 一个名为 `cw-syn-results-accountID -region` 的 S3 存储桶。
+ 名为 `Synthetics-Alarm-MyCanaryName` 的警报（如果您为要为金丝雀创建警报）。
+ Lambda 函数和层（如果您使用蓝图创建金丝雀）。这些资源具有前缀 `cwsyn-MyCanaryName`。
+ 名为 `/aws/lambda/cwsyn-MyCanaryName -randomId` 的 CloudWatch Logs 日志组。
# 使用金丝雀蓝图
本节提供有关每种金丝雀蓝图的详细信息以及每种蓝图最适合的任务。为以下金丝雀类型提供了蓝图：
**Topics**
+ [检测信号监控](#CloudWatch_Synthetics_Canaries_Blueprints_Heartbeat)
+ [API 金丝雀](#CloudWatch_Synthetics_Canaries_Blueprints_API)
+ [失效链接检查器](#CloudWatch_Synthetics_Canaries_Blueprints_Broken_Links)
+ [可视监控蓝图](#CloudWatch_Synthetics_Canaries_Blueprints_VisualTesting)
+ [金丝雀记录器](#CloudWatch_Synthetics_Canaries_Blueprints_Recorder)
+ [GUI 工作流生成器](#CloudWatch_Synthetics_Canaries_Blueprints_GUI_Workflow)
+ [多重检查蓝图](#CloudWatch_Synthetics_Canaries_Blueprints_Multichecks_Blueprint)
+ [创建多重检查蓝图金丝雀](CloudWatch_Synthetics_Canaries_MultiCheck_Blueprint.md)
当您使用蓝图创建金丝雀时，在填写 CloudWatch 控制台中的字段时，页面的 **Script editor（脚本编辑器）**区域会将您正在创建的金丝雀显示为 Node.js 脚本。您还可以在此区域编辑金丝雀以进一步定制。
## 检测信号监控
检测信号脚本加载指定的 URL，并存储页面的屏幕截图和 HTTP 归档文件（HAR 文件）。它们还存储已访问 URL 的日志。
您可以使用 HAR 文件查看有关网页性能的详细数据。您可以分析 Web 请求列表并捕获性能问题，例如某个项的加载时间。
如果您的金丝雀使用 `syn-nodejs-puppeteer-3.1` 或更高版本的运行时，您可以使用检测信号监控蓝图，以监控多个 URL 并查看状态、持续时间、关联的屏幕截图和金丝雀运行报告的步骤摘要中各个 URL 的故障原因。
## API 金丝雀
API 金丝雀可以测试 REST API 的基本读写函数。REST 指*表述性状态转移*，是开发人员在创建 API 时需要遵循的一组规则。其中一条规则规定，指向特定 URL 的链接应返回一段数据。
金丝雀可与任何 API 结合使用并测试所有类型的功能。每个金丝雀都可以做出多个 API 调用。
在使用 `syn-nodejs-2.2` 或更高版本运行时的金丝雀中，API 金丝雀蓝图支持将 API 作为 HTTP 步骤进行监控的多步骤金丝雀。您可以在单个金丝雀中测试多个 API。每个步骤都是一个单独的请求，可以访问不同的 URL、使用不同的标头以及对是否捕获标题和响应正文使用不同的规则。通过不捕获标头和响应正文，可以防止敏感数据被记录下来。
API 金丝雀中的每个请求均包含以下信息：
+ *终端节点*，即您请求的 URL。
+ *方法*，它是发送到服务器的请求类型。REST API 支持 GET（读取）、POST（写入）、PUT（更新）、PATCH（更新）和 DELETE（删除）操作。
+ *标头*，用于向客户端和服务器提供信息。它们用于身份验证和提供有关正文内容的信息。有关有效标头的列表，请参阅 [HTTP 标头](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers)。
+ *数据*（或*正文*），其中包含要发送到服务器的信息。这仅用于 POST、PUT、PATCH 或 DELETE 请求。
**注意**
Playwright 运行时不支持 API Canary 蓝图。
API 金丝雀蓝图支持 GET 和 POST 方法。使用此蓝图时，您必须指定标头。例如，您可以指定 **Authorization** 作为**键**，并指定必要的授权数据作为该键的**值**。
如果您在测试 POST 请求，还可以在**数据**字段中指定要发布的内容。
**与 API Gateway 的集成**
API 蓝图与 Amazon API Gateway 集成。因此，您能够从与该金丝雀所在的同一个 AWS 账户和区域选择一个 API Gateway API 和阶段，或上载 API Gateway 中的 Swagger 模板以进行跨账户和跨区域 API 监控。然后，您可以在控制台中选择其余详细信息来创建金丝雀，而不是从 Scratch 输入这些详细信息。有关 API Gateway 的更多信息，请参阅[什么是 Amazon API Gateway？](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html)。
**使用私有 API**
您可以在 Amazon API Gateway 中创建使用私有 API 的金丝雀。有关更多信息，请参阅 [在 Amazon API Gateway 中创建私有 API?](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-apis.html)
## 失效链接检查器
无效链接检查器通过使用 `document.getElementsByTagName('a')` 收集您正在测试的 URL 内的所有链接。它仅测试您指定数量的链接，而且 URL 本身计为第一个链接。例如，如果要检查包含五个链接的页面上的所有链接，则必须指定金丝雀跟踪六个链接。
使用 `syn-nodejs-2.0-beta` 或更高版本运行时创建的无效链接检查器金丝雀支持以下额外功能：
+ 提供包含所检查链接、状态代码、故障原因（如有）以及源页面和目标页面屏幕截图的报告。
+ 查看金丝雀结果时，您可以筛选以仅查看无效链接，然后根据故障原因修复链接。
+ 此版本会捕获每个链接的带注释源页面屏幕截图，并突出显示链接所在的锚点。不会对隐藏组件添加注释。
+ 您可以将此版本配置为捕获源页面和目标页面的屏幕截图、仅捕获源页面或仅捕获目标页面的屏幕截图。
+ 此版本修复了早期版本中的一个问题，在早期版本中，即使从第一页抓取了更多链接，金丝雀脚本也会在第一个无效链接后停止。
**注意**
Playwright 运行时不支持无效链接检查器蓝图。
要使用 `syn-1.0` 来更新现有 Canary 以使用新的运行时，则必须删除并重新创建 Canary。这些功能并不会随着将现有金丝雀更新到新运行时而变得可用。
无效链接检查器金丝雀可检测以下类型的链接错误：
+ 404 未找到页面
+ 主机名无效
+ 错误的 URL。例如，URL 缺少括号、包含多余的斜线，或者协议错误。
+ 无效的 HTTP 响应代码。
+ 主机服务器返回没有内容和没有响应代码的空响应。
+ HTTP 请求在金丝雀运行期间持续超时。
+ 主机持续丢弃连接，因为它配置错误或太忙。
## 可视监控蓝图
可视化监控蓝图包含用以比较在金丝雀运行期间捕获的屏幕截图与在基准金丝雀运行期间捕获的屏幕截图的代码。如果两个屏幕截图之间的差异超过阈值百分比，则金丝雀将失败。运行 **syn-puppeteer-node-3.2** 和更高版本的金丝雀支持可视化监控。运行 Python 和 Selenium 或使用 Playwright 运行时的 Canary 中目前不支持可视化监控。
可视化监控蓝图在默认蓝图金丝雀脚本中包含以下代码行，这些代码可实现可视化监控。
```
syntheticsConfiguration.withVisualCompareWithBaseRun(true);
```
将此行添加到脚本后，金丝雀首次成功运行时，它会使用在该运行期间捕获的屏幕截图作为比较基准。在金丝雀的该首次运行之后，您可以使用 CloudWatch 控制台编辑金丝雀以执行以下任一操作：
+ 将金丝雀的下一次运行设置为新基准。
+ 在当前基准屏幕截图上绘制边界，以指定在可视化比较过程中要忽略的屏幕截图区域。
+ 删除屏幕截图，使其不用于可视化监控。
有关使用 CloudWatch 控制台编辑金丝雀的更多信息，请参阅 [编辑或删除金丝雀脚本](synthetics_canaries_deletion.md)。
您还可以通过使用 ` nextrun` 或 `lastrun` 参数或在 [UpdateCanary](https://docs.aws.amazon.com/AmazonSynthetics/latest/APIReference/API_UpdateCanary.html) API 中指定金丝雀运行 ID 来更改用作基准的金丝雀运行。
使用可视化监控蓝图时，您可以输入要在其中捕获屏幕截图的 URL，并将差值阈值指定为百分比。在基准运行之后，只要在金丝雀的未来运行中检测到大于该阈值的可视化差异，便会触发金丝雀故障。在基准运行之后，您还可以编辑金丝雀，以在可视化监控过程中要忽略的基准屏幕截图上“绘制”边界。
可视化监控功能由 ImageMagick 开源软件工具包提供支持。有关更多信息，请参阅 [ImageMagick](https://imagemagick.org/index.php)。
## 金丝雀记录器
使用金丝雀记录器蓝图，您可以使用 CloudWatch Synthetics Recorder 记录您的点击并在网站上键入操作，并自动生成可用于创建按相同步骤操作的金丝雀的 Node.js 脚本。CloudWatch Synthetics Recorder 是 Amazon 推出的 Google Chrome 扩展程序。使用 Playwright 运行时的 Canary 不支持 Canary 记录器。
**开发团队**：CloudWatch Synthetics Recorder 基于[无头记录器](https://github.com/checkly/headless-recorder)。
有关更多信息，请参阅 [使用面向 Google Chrome 的 CloudWatch Synthetics Recorder](CloudWatch_Synthetics_Canaries_Recorder.md)。
## GUI 工作流生成器
GUI 工作流生成器蓝图验证是否可以在您的网页上执行操作。例如，如果您有一个带有登录表单的网页，则金丝雀可以填充用户和密码字段并提交表单，以验证网页是否正常工作。
当您使用蓝图创建此类型的金丝雀时，可以指定希望金丝雀在网页上执行的操作。您可以使用的操作如下：
+ **单击** – 选择您要指定的元素，然后模拟用户单击或选择该元素的行为。
若要在 Node.js 脚本中指定该元素，请使用 `[id=]` 或 ` a[class=]`。
若要在 Python 脚本中指定该元素，请使用 `xpath //*[@id=]` 或 ` //*[@class=]`。
+ **验证选择器** – 验证网页上存在指定的元素。此测试对于验证之前的操作是否导致使用正确的元素填充页面非常有用。
若要在 Node.js 脚本中指定待验证的元素，请使用 `[id=]` 或 ` a[class=]`。
若要在 Python 脚本中指定待验证的元素，请使用 `xpath //*[@id=]` 或 `//*[class=]`。
+ **验证文本** – 验证指定的字符串是否包含在目标元素中。此测试对于验证之前的操作是否导致显示正确的文本非常有用。
若要在 Node.js 脚本中指定元素，请使用诸如 ` div[@id=]//h1` 之类的格式，因为此操作使用 Puppeteer 中的 `waitForXPath` 函数。
若要在 Python 脚本中指定元素，请使用 xpath 格式（例如 ` //*[@id=] ` 或 //\$1[@class=]），因为此操作使用 Selenium 中的 `implicitly_wait` 函数。
+ **输入文本** – 在目标元素中写入指定的文本。
若要在 Node.js 脚本中指定待验证的元素，请使用 `[id=]` 或 ` a[class=]`。
若要在 Python 脚本中指定待验证的元素，请使用 `xpath //*[@id=]` 或 `//*[@class=]`。
+ **单击并导航** – 在选择指定的元素之后，等待整个页面加载。当您需要重新加载页面时，这非常有用。
若要在 Node.js 脚本中指定该元素，请使用 `[id=]` 或 ` a[class=]`。
若要在 Python 脚本中指定该元素，请使用 `xpath //*[@id=]` 或 ` //*[@class=]`。
例如，以下蓝图使用 Node.js。其会单击指定 URL 上的 **firstButton**，验证预期的选择器是否出现了预期文本，将名称 `Test_Customer` 输入到 **Name**（名称）字段中，单击 **Login**（登录）按钮，然后通过检查下一页上的 **Welcome**（欢迎）文本来验证登录是否成功。
![\[控制台中的创建金丝雀页面，其中填充了 GUI 工作流蓝图的字段。\]](http://docs.aws.amazon.com/zh_cn/AmazonCloudWatch/latest/monitoring/images/canary_create_gui_workflow.PNG)
使用以下运行时的 GUI 工作流金丝雀还提供每次金丝雀运行所执行的步骤的摘要。您可以使用与每个步骤关联的屏幕截图和错误消息来查找故障的根本原因。
+ `syn-nodejs-2.0` 或更高版本
+ `syn-python-selenium-1.0` 或更高版本
## 多重检查蓝图
多重检查蓝图简化了金丝雀的创建过程。它通过简单的 JSON 配置提供了开箱即用的功能，用于执行 HTTP、DNS、SSL 和 TCP 检查，从而降低了成本。最多可以配置 10 项检查。将每项检查配置为按顺序运行的数字步骤，以便清晰理解金丝雀执行流程。
多重检查蓝图支持：
+ 基本 HTTP 请求、TCP 请求；验证 DNS 记录、监控 SSL 证书
+ 与 Secrets Manager 集成的 HTTP 身份验证方法，例如 Basic、API Key、OAuth 和 Sigv4
+ 针对每项检查的断言
有关更多信息，请参阅 [创建金丝雀](CloudWatch_Synthetics_Canaries_Create.md)。
# 创建多重检查蓝图金丝雀
Amazon CloudWatch Synthetics 多重检查蓝图通过提供简单的 JSON 配置，帮助您创建 Synthetics 金丝雀。您可以以基于步骤的顺序方式捆绑最多 10 种不同类型的 HTTP/DNS/SSL/TCP 检查，以此节省成本。每项检查都包含针对检查结果提供基本验证的断言。
多重检查金丝雀专为简单使用案例而设计，这些使用案例仅需基本检查，无需使用无头浏览器。有关更复杂的使用案例，请查看 Amazon CloudWatch Synthetics 提供的其他金丝雀类型。
**Topics**
+ [先决条件](#CloudWatch_Synthetics_MultiCheck_Prerequisites)
+ [限制](#CloudWatch_Synthetics_MultiCheck_Limitations)
+ [打包结构、JSON 架构和配置设置](#CloudWatch_Synthetics_MultiCheck_Packaging)
+ [在 AWS 管理控制台中创建多重检查金丝雀](#CloudWatch_Synthetics_MultiCheck_Console)
+ [使用 AWS Synthetics API 创建多重检查金丝雀](#CloudWatch_Synthetics_MultiCheck_API)
+ [在 CloudFormation 中创建多重检查金丝雀](#CloudWatch_Synthetics_MultiCheck_CloudFormation)
+ [身份验证配置](#CloudWatch_Synthetics_MultiCheck_Authentication)
+ [问题排查](#CloudWatch_Synthetics_MultiCheck_Troubleshooting)
## 先决条件
+ 必须使用 syn-nodejs-3.0\$1 才能创建多重检查金丝雀
+ 使用身份验证和 Secrets Manager 配置时，必须确保金丝雀的 [ExecutionRoleArn](https://docs.aws.amazon.com/AmazonSynthetics/latest/APIReference/API_CreateCanary.html) 有权访问这些密钥
+ 为 Sigv4 使用身份验证时，必须确保金丝雀的 [ExecutionRoleArn](https://docs.aws.amazon.com/AmazonSynthetics/latest/APIReference/API_CreateCanary.html) 有权访问相关角色
## 限制
+ HTTP 响应大小不能超过 1 MB
+ 最多定义 10 个变量。
+ 使用 JSON RFC 时，Checks JSON 可能提供重复字段，但仅会使用最后一个顺序字段
+ 在 AWS 管理控制台中，多重检查金丝雀将默认显示多重检查步骤指标，以便识别每项检查的可用性。删除检查后，此图表可能仍会在可用性图表中显示这些检查，直到指标停止活动至少 3 小时
## 打包结构、JSON 架构和配置设置
必须将用于金丝雀的 JSON Checks 配置命名为 ` blueprint-config.json`。配置必须遵循[架构](https://github.com/aws-samples/synthetics-canary-local-debugging-sample/tree/main)并按照[为 Node.js 多重检查蓝图编写 JSON 配置](CloudWatch_Synthetics_WritingCanary_Multichecks.md)中的说明进行操作。
将 `blueprint-config.json` 压缩为 ZIP 文件，并在以下任一创建工作流中提供。如果存在 `synthetics.json` 配置，它也会被压缩到同一 ZIP 文件中。以下是名为 `multi-checks.zip` 的 zip 文件示例。
```
multi-checks.zip
├── blueprint-config.json
└── synthetics.json
```
## 在 AWS 管理控制台中创建多重检查金丝雀
1. 打开 Amazon CloudWatch Synthetics 控制台。
1. 选择 **Create Canary (创建金丝雀)**。
1. 在**使用蓝图**下，选择**多重检查**。
在**配置检查**下，您将看到两个选项卡：**检查**和**金丝雀配置**。
1. 选择运行时版本 **syn-nodejs-3.0** 或更高版本。
1. 按照[为 Node.js 多重检查蓝图编写 JSON 配置](CloudWatch_Synthetics_WritingCanary_Multichecks.md)下的步骤描述要执行的检查。或者，控制台会提供默认 JSON 配置，您可以在此基础上进行构建。
1. 选择 **Create Canary (创建金丝雀)**。
## 使用 AWS Synthetics API 创建多重检查金丝雀
使用 `CreateCanary` API，并在 `Code` 参数中提供字段/值 `BlueprintTypes="multi-checks"` 而不是 ` Handler`。如果同时指定了 `BlueprintTypes` 和 `Handler`，则会显示 `ValidationException`。提供的运行时版本必须为 `syn-nodejs-3.0` 或更高版本。
```
aws synthetics create-canary \
--name my-multi-check-canary \
--code ZipFile="ZIP_BLOB",BlueprintTypes="multi-checks" \
--runtime-version syn-nodejs-3.0 \
...
// Or if you wanted to use S3 to provide your code.
aws synthetics create-canary \
--name my-multi-check-canary \
--code S3Bucket="my-code-bucket",S3Key="my-zip-code-key",BlueprintTypes="multi-checks" \
...
```
## 在 CloudFormation 中创建多重检查金丝雀
在多重检查金丝雀的 CloudFormation 模板中，在 `Code` 参数内，提供字段/值 `BlueprintTypes="multi-checks"` 而不是 ` Handler`。如果同时指定了 `BlueprintTypes` 和 `Handler`，则会显示 `ValidationException`。提供的运行时版本必须为 `syn-nodejs-3.0 or later`。
示例模板：
```
SyntheticsCanary:
Type: 'AWS::Synthetics::Canary'
Properties:
Name: MyCanary
RuntimeVersion: syn-nodejs-3.0
Schedule: {Expression: 'rate(5 minutes)', DurationInSeconds: 3600}
...
Code:
S3Bucket: "my-code-bucket"
S3Key: "my-zip-code-key"
BlueprintTypes: ["multi-checks"]
...
```
## 身份验证配置
当金丝雀向经过身份验证的端点发出 HTTP 请求时，您可以将蓝图金丝雀的步骤配置为使用四种身份验证类型之一：基本身份验证、API 密钥、OAuth 客户端凭证和 Sigv4。您无需自己设置请求头，只需在蓝图定义中指定身份验证类型，Synthetics 就会按照指定的身份验证类型，使用提供的身份验证信息填充 HTTP 请求的各个部分。
您可以在蓝图步骤的“身份验证”部分中指定身份验证类型。您可以指定要使用的身份验证方案、所选身份验证方案所需的属性，然后 Synthetics 将使用提供的信息为 HTTP 请求构造身份验证标头。
由于以纯文本形式存储机密（例如密码或 API 密钥）存在安全隐患，因此 Synthetics 支持与 AWS Secrets Manager 集成。如果希望在 Synthetics 蓝图金丝雀中对 HTTP 请求进行身份验证，可以引用存储身份验证信息的密钥，Synthetics 就会检索密钥并将其缓存在金丝雀中。这种方法可以向 Synthetics 提供密钥，同时确保密钥安全存储，无需在蓝图配置中以纯文本形式指定它们。
有关 AWS Secrets Manager 的更多信息，请参阅[什么是 AWS Secrets Manager？](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html)
### 基本身份验证
Synthetics 实施 RFC 7617 中定义的基本 HTTP 身份验证方案。具体流程如下：
+ 蓝图配置中提供了用户名和密码对。
+ user-pass 通过连接用户名、冒号（“:”）字符以及密码进行创建。
+ user-pass 采用 UTF-8 编码，然后转换为 base64 编码字符串。
+ 这个 base64 编码的 user-pass 包含在“Authorization”标头中，格式如下：Authorization: Basic \$1base64-encoded-user-pass\$1
例如，如果用户代理希望发送用户 ID“Aladdin”和密码“open sesame”，则会使用以下标头字段：Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==
示例配置：
```
"Authentication": {
"type": "BASIC",
"username": MY_USERNAME, // Required
"password": MY_PASSWORD // Required
}
```
### API 密钥身份验证
您可以提供 API 密钥来验证 HTTP 请求。使用 API 密钥身份验证时，您提供的 API 密钥将放入“x-api-key”HTTP 标头中。如果您有自定义资源在其他标头中查找 API 密钥标头，则可以选择指定其他标头名称，让 Synthetics 将 API 密钥放入其中。
示例配置：
```
"Authentication": {
"type": "API_KEY",
"apiKey": S0A1M2P3L4E5, // Required
"header": X-Specific-Header // Optional, defaults to "X-API-Key"
}
```
### SigV4 身份验证
AWS SigV4（签名版本 4）是将身份验证信息添加到 AWS API 请求的 AWS 签名协议。要发出 SigV4 身份验证的请求，需要指定要向其发出请求的区域和服务，并标识您希望金丝雀在发出此 SigV4 请求时代入的 IAM 角色的 ARN（AWS 资源名称）。Synthetics 将代入 roleArn 中提供的 IAM 角色，并使用该角色对 AWS API 请求进行身份验证。
示例配置：
```
"Authentication": {
"type": "SIGV4",
"region": us-west-2, // Required
"service": s3, // Required
"roleArn": arn:AWS:iam:12345678912:role/SampleRole // Required
}
```
#### SigV4 注意事项
要使 Synthetics 代入您在 Sigv4 身份验证部分中提供的角色，必须将附加到该角色的信任策略配置为允许金丝雀代入所提供的 roleArn。需要您信任的 AWS 主体是金丝雀通过 AWS STS 代入的角色。它采用 ` aws:sts::{account_running_the_canary}:assumed-role//` arn: 格式。
例如，如果您在账户 0123456789012 中运行了名为 test-canary 的金丝雀，且其所代入的角色名为 canary-assume-role，则信任策略需要包含以下语句，这样金丝雀才能正确代入用于 SigV4 身份验证的 roleArn：
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:AWS:sts::123456789012:assumed-role/test-canary/"
},
"Action": "sts:AssumeRole"
}
```
### OAuth 客户端凭证
Synthetics 实现了 RFC 6479 第 4.4 节中定义的 OAuth 客户端凭证授权类型。如果您想向使用 OAuth 令牌端点所颁发的持有者令牌进行身份验证的端点发出 HTTP 请求，Synthetics 可以代表您请求并管理该持有者令牌。如果使用 OAuth 方案，Synthetics 会执行以下步骤：
+ 采用基本身份验证方案，通过 clientId 和 clientSecret 对发往 tokenUrl（颁发持有者令牌的端点）的请求进行身份验证
+ 如果提供了可选的 scope、audience 和 resource 参数，它们将包含在令牌请求中
+ 使用 tokenUrl 返回的访问令牌对 HTTP 请求进行身份验证
+ 安全地存储从 tokenUrl 返回的刷新令牌，用于未来的令牌请求
示例配置：
```
"Authentication": {
"type": "OAUTH_CLIENT_CREDENTIALS",
"tokenUrl": ..., // Required
"clientId": ..., // Required
"clientSecret": ..., // Required
"scope": ..., // Optional
"audience": ..., // Optional
"resource": ..., // Optional
}
```
#### OAuth 注意事项
当返回 401 或 407 响应时，Synthetics 会刷新 OAuth 令牌。
### AWS Secrets Manager 集成
为避免以纯文本形式存储密钥值（例如密码或 API 密钥），Synthetics 提供了与 AWS Secrets Manager 的集成。您可以在蓝图配置中引用整个密钥值，格式为 ` ${aws_SECRET:}`，也可以引用特定密钥 ` ${aws_SECRET::}`。
例如，如果密钥名为 login/basic-auth-credentials，则使用以下 JSON 结构存储用户名和密码：
```
{
"username": "Aladdin",
"password": "open sesame"
}
```
您可以按如下方式在蓝图配置中引用用户名和密码，Synthetics 会检索密钥值并使用其键对请求进行身份验证：
```
"Authentication": {
"type": "BASIC",
"username": ${AWS_SECRET:login/basic-auth-credentials:username},
"password": ${AWS_SECRET:login/basic-auth-credentials:password}
}
```
为使 Synthetics 能够检索指定的密钥，金丝雀代入的角色 ARN 需要具有 secretsManager:GetSecretValue 权限。如果密钥加密方式使用客户自主管理型密钥，而非 AWS 托管密钥 AWS/secretsmanager，您还需要该密钥的 kms:Decrypt 权限。
示例权限：
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "secretsmanager:GetSecretValue",
"Resource": "arn:AWS:secretsmanager:us-east-1:123456789012:secret:secretName-AbCdEf"
},
{
"Effect": "Allow",
"Action": "kms:Decrypt",
"Resource": "arn:AWS:kms:us-east-1:123456789012:key/key-id"
}
]
}
```
## 问题排查
### 常见问题排查
多重检查蓝图的底层代码是用 Typescript 编写的。有关常见故障，请参阅金丝雀问题排查页面：[排查失败金丝雀的问题](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Synthetics_Canaries_Troubleshoot.html)。
### JSON 检查配置语法错误
当出现任何与金丝雀 JSON 检查配置相关的语法错误时，AWS 管理控制台会在您尝试创建金丝雀时提供失败原因。如果您使用 API 或 CloudFormation 创建金丝雀，则首次执行金丝雀时会失败。建议对多重检查金丝雀使用安全的金丝雀更新工作流。有关更多信息，请参阅[执行安全金丝雀更新](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/performing-safe-canary-upgrades.html)。
### 网络或超时故障
对于任何与超时、网络连接故障（例如 ENOTFOUND、ECONNRESET）相关的间歇性或持续性故障，请考虑启用 ` DEBUG` 日志，以便后续运行提供有关检查失败原因的更多详细信息。为此，请提供环境变量 CW\$1SYNTHETICS\$1LOG\$1LEVEL: "DEBUG"。
如果仍然存在无法调试的故障，可以考虑联系 AWS Support，或者检查 CloudWatch Synthetics 提供的其他任何金丝雀类型是否更符合使用案例。
# 使用面向 Google Chrome 的 CloudWatch Synthetics Recorder
Amazon 推出 CloudWatch Synthetics Recorder，以帮助您更轻松地创建金丝雀。此记录器是一个 Google Chrome 扩展程序。
此记录器记录您在网站上的单击和键入操作，并自动生成可用于创建按相同步骤操作的金丝雀的 Node.js 脚本。
开始记录后，CloudWatch Synthetics Recorder 会在浏览器中检测您的操作并将其转换为脚本。您可以根据需要暂停和恢复记录。当您停止记录时，记录器会将您的操作生成 Node.js 脚本，您可以使用 **Copy to Clipboard（复制到剪贴板）**按钮轻松复制这些脚本。之后，您可以使用此脚本在 CloudWatch Synthetics 中创建金丝雀。
**开发团队**：CloudWatch Synthetics Recorder 基于[无头记录器](https://github.com/checkly/headless-recorder)。
## 安装面向 Google Chrome 的 CloudWatch Synthetics Recorder 扩展程序
若要使用 CloudWatch Synthetics Recorder，您可以先创建一个金丝雀，然后选择 **Canary Recorder**（金丝雀记录器）蓝图。如果您在尚未下载记录器时执行此操作，则 CloudWatch Synthetics 控制台会提供下载该记录器的链接。
您也可以按照以下步骤直接下载并安装该记录器。
**安装 CloudWatch Synthetics Recorder**
1. 使用 Google Chrome，访问此网站：[https://chrome.google.com/webstore/detail/cloudwatch-synthetics-rec/bhdnlmmgiplmbcdmkkdfplenecpegfno](https://chrome.google.com/webstore/detail/cloudwatch-synthetics-rec/bhdnlmmgiplmbcdmkkdfplenecpegfno)
1. 选择 **Add to Chrome（添加到 Chrome）**，然后选择 **Add extension（添加扩展程序）**。
## 使用面向 Google Chrome 的 CloudWatch Synthetics Recorder
若要使用 CloudWatch Synthetics Recorder 帮助您创建金丝雀，您可以在 CloudWatch 控制台中选择 **Create canary**（创建金丝雀），然后依次选择 **Use a blueprint**（使用蓝图）、**Canary Recorder**（金丝雀记录器）。有关更多信息，请参阅 [创建金丝雀](CloudWatch_Synthetics_Canaries_Create.md)。
您也可以使用记录器记录步骤，而不必立即使用它们创建金丝雀。
**使用 CloudWatch Synthetics Recorder 记录您在网站上的行为**
1. 导航到要监控的页面。
1. 选择 Chrome 扩展程序图标，然后选择 **CloudWatch Synthetics Recorder**。
1. 选择 **Start Recording（开始记录）**。
1. 执行您希望记录的步骤。要暂停记录，请选择**暂停**。
1. 完成记录工作流后，选择 **Stop recording（停止记录）**。
1. 选择 **Copy to clipboard（复制到剪贴板）**以将生成的脚本复制到剪贴板。或者，如果要重新开始，请选择 **New recording（新建记录）**。
1. 若要使用复制的脚本创建金丝雀，您可以将复制的脚本粘贴到记录器蓝图内联编辑器中，或者将其保存到 Amazon S3 存储桶中，然后从该存储桶中导入。
1. 如果您不立即创建金丝雀，则可以将记录的脚本保存到文件中。
## CloudWatch Synthetics Recorder 的已知局限性
面向 Google Chrome 的 CloudWatch Synthetics Recorder 目前具有以下局限性。
+ 不具有 ID 的 HTML 元素将使用 CSS 选择器。如果网页结构稍后发生变化，这可能会破坏金丝雀。我们计划在未来版本的记录器中针对此问题提供一些配置选项（例如使用 data-id）。
+ 记录器不支持双击或复制/粘贴等操作，也不支持 CMD\$10 等组合键。
+ 若要验证页面上是否存在某元素或文本，用户必须在脚本后生成添加断言。记录器不支持在不对某元素执行任何操作的情况下验证该元素。这与金丝雀工作流生成器中的“验证文本”或“验证元素”选项类似。我们计划在未来版本的记录器中添加一些断言支持。
+ 记录器会记录启动记录的选项卡中的所有操作。其不会记录弹出窗口（例如，允许位置跟踪的弹出窗口）或从弹出窗口到不同页面的导航。
# Synthetics 运行时版本
创建或更新金丝雀时，您可以为金丝雀选择 Synthetics 运行时版本。Synthetics 运行时是调用脚本处理程序的 Synthetics 代码，以及捆绑依赖关系的 Lambda 层的组合。
CloudWatch Synthetics 当前支持使用 Node.js、Python 或 Java 语言的运行时，所支持的框架有 Puppeteer、Playwright 和 Selenium。
我们建议您始终为金丝雀使用最新的运行时版本，以便能够使用最新的功能和对 Synthetics 库进行的更新。
**请注意**：每当运行金丝雀来启用新版本的 Synthetics 运行时之时，金丝雀使用的所有 Synthetics 库函数也会自动移动到该 Synthetics 运行时所支持的同一个 NodeJS 版本。
**Topics**
+ [使用 Java 的运行时版本](CloudWatch_Synthetics_Library_Java.md)
+ [使用 Node.js 和 Playwright 的运行时版本](CloudWatch_Synthetics_Library_nodejs_playwright.md)
+ [使用 Node.js 和 Puppeteer 的运行时版本](CloudWatch_Synthetics_Library_nodejs_puppeteer.md)
+ [使用 Python 和 Selenium Webdriver 的运行时版本](CloudWatch_Synthetics_Library_python_selenium.md)
+ [使用 Node.js 的运行时版本](CloudWatch_Synthetics_Library_Nodejs.md)
+ [运行时版本支持策略](CloudWatch_Synthetics_Runtime_Support_Policy.md)
+ [运行时版本更新](CloudWatch_Synthetics_Runtime_Version_Update.md)
# 使用 Java 的运行时版本
下文包含有关 CloudWatch Synthetics Java 运行时版本的信息。该运行时不包含任何浏览器或框架。
这些运行时版本的命名约定为 `syn-language -majorversion.minorversion`。
## syn-java-1.0
**主要依赖项**：
+ AWS Lambda 运行时 Java 21
**功能**
+ *CloudWatch Logs 集成* – 您可以通过 CloudWatch Synthetics 控制台查询和筛选日志。每条日志消息都包含唯一 ` canaryRunId`，因此可以轻松搜索特定 Canary 运行的日志。
+ *指标* – 您可以通过 CloudWatch 指标监控金丝雀运行成功率和持续时间。您还可以配置警报，在金丝雀检测到问题时发出警报。
+ *金丝雀构件* – 每次金丝雀运行都会上传一份与该次运行和运行步骤相对应的详细报告。这些报告可通过 Amazon S3 访问。
+ *支持追踪功能* – 您可以通过 X-Ray 为金丝雀发出的所有请求生成追踪数据。每次金丝雀运行都与一个追踪 ID 相关联。
# 使用 Node.js 和 Playwright 的运行时版本
以下各节包含有关用于 Node.js 和 Playwright 的 CloudWatch Synthetics 运行时版本的信息。Playwright 是用于浏览器测试的开源自动化库。有关 Playwright 的更多信息，请参阅 [https://playwright.dev/](https://playwright.dev)
这些运行时版本的命名约定为 `syn-language -framework-majorversion. minorversion`。
## syn-nodejs-playwright-6.0
**重要**
Synthetics `syn-nodejs-playwright-5.1` 及更高版本中，Synthetics 运行时将使用新的命名空间。请迁移金丝雀脚本以使用新的命名空间。在未来的版本中，旧命名空间将被弃用。
@amzn/synthetics-playwright → @aws/synthetics-playwright
**主要依赖项**：
+ AWS Lambda 运行时 Node.js 22.x
+ Playwright 版本 1.58.2
+ Playwright/test 版本 1.58.2
+ Chromium 145.0.7632.77 版
+ Firefox 版本 146.0.1
**syn-nodejs-playwright-6.0 中的变化**
+ 应用了安全补丁，并更新了 Playwright 和浏览器版本。
有关更多信息，请参阅下列内容：
+ [Playwright 更改日志](https://playwright.dev/docs/release-notes)
+ [Playwright API 参考](https://playwright.dev/docs/api/class-playwright)
## 先前的 Node.js 和 Playwright 运行时版本
下列 Node.js 和 Playwright 的早期运行时版本仍受支持。
### syn-nodejs-playwright-5.1
**主要依赖项**：
+ AWS Lambda 运行时 Node.js 22.x
+ Playwright 版本 1.57.0
+ Playwright/test 版本 1.57.0
+ Chromium 143.0.7499.169 版
+ Firefox 版本 142.0.1
**syn-nodejs-playwright-5.1 中的变化**
+ Synthetics 运行时命名空间迁移。
+ 类型定义在 [npm 注册表](https://www.npmjs.com/package/@aws/synthetics-playwright)中可用。请确保类型定义包的版本与您的金丝雀的运行时版本相匹配。
有关更多信息，请参阅下列内容：
+ [Playwright 更改日志](https://playwright.dev/docs/release-notes)
+ [Playwright API 参考](https://playwright.dev/docs/api/class-playwright)
### syn-nodejs-playwright-5.0
**主要依赖项**：
+ AWS Lambda 运行时 Node.js 22.x
+ Playwright 版本 1.57.0
+ Playwright/test 版本 1.57.0
+ Chromium 143.0.7499.4 版
+ Firefox 版本 142.0.1
**syn-nodejs-playwright-5.0 中的变化**
+ 应用了安全补丁，并更新了 Playwright 和浏览器版本。
有关更多信息，请参阅下列内容：
+ [Playwright 更改日志](https://playwright.dev/docs/release-notes)
+ [Playwright API 参考](https://playwright.dev/docs/api/class-playwright)
### syn-nodejs-playwright-4.0
**主要依赖项**：
+ AWS Lambda 运行时 Node.js 22.x
+ Playwright 版本 1.55.0
+ Playwright/test 版本 1.55.0
+ Chromium 140.0.7339.16 版
+ Firefox 版本 141.0
**syn-nodejs-playwright-4.0 中的变化**
+ 应用了安全补丁，并更新了 Playwright 和浏览器版本。
有关更多信息，请参阅下列内容：
+ [Playwright 更改日志](https://playwright.dev/docs/release-notes)
+ [Playwright API 参考](https://playwright.dev/docs/api/class-playwright)
### syn-nodejs-playwright-3.0
**主要依赖项**：
+ AWS Lambda 运行时 Node.js 20.x
+ Playwright 版本 1.53.0
+ Playwright/test 版本 1.53.0
+ Chromium 版本 138.0.7204.168
**syn-nodejs-playwright-3.0 中的变化**
+ 多浏览器支持：现可在 Firefox 或 Chrome 中运行 nodejs puppeteer 金丝雀
+ 可视化监控支持
有关更多信息，请参阅下列内容：
+ [Playwright 更改日志](https://playwright.dev/docs/release-notes)
+ [Playwright API 参考](https://playwright.dev/docs/api/class-playwright)
### syn-nodejs-playwright-2.0
**主要依赖项**：
+ AWS Lambda 运行时 Node.js 20.x
+ Playwright 版本 1.49.1
+ Playwright/test 版本 1.49.1
+ Chromium 版本 131.0.6778.264
**syn-nodejs-playwright-2.0 中的变化**：
+ 修复了 HAR 文件中给定请求的总持续时间和计时总和之间不一致的问题。
+ 支持对金丝雀进行试运行，允许临时执行或执行安全的金丝雀更新。
有关更多信息，请参阅下列内容：
+ [Playwright 更改日志](https://playwright.dev/docs/release-notes)
+ [Playwright API 参考](https://playwright.dev/docs/api/class-playwright)
### syn-nodejs-playwright-1.0
**主要依赖项**：
+ AWS Lambda 运行时 Node.js 20.x
+ Playwright 版本 1.44.1
+ Playwright/test 版本 1.44.1
+ Chromium 版本 126.0.6478.126
**功能：**
+ **PlayWright 支持** – 您可以使用 Playwright 自动化框架编写 Canary 脚本。您可以将现有的 Playwright 脚本作为 Canary 运行，并通过 AWS 监控功能对其进行增强。
+ **CloudWatch Logs 集成** – 您可以通过 CloudWatch Synthetics 控制台查询和筛选日志。每条日志消息都包含唯一 `canaryRunId`，因此可以轻松搜索特定 Canary 运行的日志。
+ **指标和 Canary 构件** – 您可以通过 CloudWatch 指标监控 Canary 运行通过率，并配置警报进而在 Canary 检测到问题时提醒您。
+ **屏幕截图和步骤关联** – 您可以使用原生 Playwright 功能捕获屏幕截图，以便在每次运行时可视化 Canary 脚本的各个阶段。屏幕截图会自动与 Canary 步骤相关联，并上传到 Amazon S3 存储桶。
+ **多个选项卡** – 您可以创建打开多个浏览器选项卡的 Canary，并从每个选项卡访问屏幕截图。您可以在 Synthetics 中创建多选项卡和多步骤用户工作流程。
# 使用 Node.js 和 Puppeteer 的运行时版本
使用 Node.js 和 Puppeteer 的第一个运行时版本被命名为 `syn-1.0`。后续运行时版本采用命名约定 `syn-language -majorversion.minorversion`。从 `syn-nodejs-puppeteer-3.0` 开始，命名约定为 `syn- language-framework-majorversion .minorversion`
额外添加的 `-beta` 后缀用以显示运行时版本当前为测试预览版。
具有相同主版本号的运行时版本将始终向后兼容。
金丝雀中的 Lambda 代码已配置为具有最多 1 GB 内存。在配置的超时值之后，该超时将适用于每个运行的金丝雀。如果未为金丝雀指定超时值，则 CloudWatch 会根据金丝雀的频率来选择超时值。如要配置超时值，请使此值不要短于 15 秒钟，以预留 Lambda 冷启动以及启动金丝雀工具的时间。
## syn-nodejs-puppeteer-15.0
`syn-nodejs-puppeteer-15.0` 是 Node.js 和 Puppeteer 最新的 Synthetics 运行时系统。
**重要**
Synthetics `syn-nodejs-puppeteer-13.1` 及更高版本中，Synthetics 运行时将使用新的命名空间。请迁移金丝雀脚本以使用新的命名空间。在未来的版本中，旧命名空间将被弃用。
Synthetics → @aws/synthetics-puppeteer
SyntheticsLink → @aws/synthetics-link
SyntheticsLogger → @aws/synthetics-logger
SyntheticsLogHelper → @aws/synthetics-log-helper
BrokenLinkCheckerReport → @aws/synthetics-broken-link-checker-report
**重要**
Synthetics 运行时 `syn-nodejs-puppeteer-11.0` 及更高版本仅支持以下步骤级配置覆盖：
`screenshotOnStepStart`
`screenshotOnStepSuccess`
`screenshotOnStepFailure`
`stepSuccessMetric`
`stepDurationMetric`
`continueOnStepFailure/continueOnHttpStepFailure`
`stepsReport`
有关更多信息，请参阅下列内容：
+ [Puppeteer 更改日志](https://pptr.dev/CHANGELOG#24375-2026-02-19)
+ [Puppeteer API 参考](https://github.com/puppeteer/puppeteer/blob/puppeteer-v24.37.5/docs/api/index.md)
**主要依赖项**：
+ Lambda 运行时系统 Node.js 22.x
+ Puppeteer-core 版本 24.37.5
+ Chromium 145.0.7632.77 版
+ Firefox 版本 147.0.4
**syn-nodejs-puppeteer-15.0 中的变化**
+ 应用了安全补丁，并更新了 Puppeteer 和浏览器版本。
+ 修复了 continueOnHttpStepFailure 未得到尊重的错误，该错误导致尽管出现了 HTTP 步骤失败，但金丝雀运行仍被错误地标记为成功。
## 先前的 Node.js 和 Puppeteer 运行时版本
下列 Node.js 和 Puppeteer 的早期运行时版本仍受支持。
### syn-nodejs-puppeteer-14.0
有关更多信息，请参阅下列内容：
+ [Puppeteer 更改日志](https://pptr.dev/CHANGELOG#24340-2025-12-19)
+ [Puppeteer API 参考](https://github.com/puppeteer/puppeteer/blob/puppeteer-v24.34.0/docs/api/index.md)
**主要依赖项**：
+ Lambda 运行时系统 Node.js 22.x
+ Puppeteer-core 版本 24.34.0
+ Chromium 143.0.7499.169 版
+ Firefox 版本 146.x
**syn-nodejs-puppeteer-14.0 中的变化**
+ 应用了安全补丁，并更新了 Puppeteer 和浏览器版本。
### syn-nodejs-puppeteer-13.1
`syn-nodejs-puppeteer-13.1` 是 Node.js 和 Puppeteer 最新的 Synthetics 运行时系统。
有关更多信息，请参阅下列内容：
+ [Puppeteer 更改日志](https://pptr.dev/CHANGELOG#24250-2025-10-15)
+ [Puppeteer API 参考](https://github.com/puppeteer/puppeteer/blob/puppeteer-v24.2.0/docs/api/index.md)
**主要依赖项**：
+ Lambda 运行时系统 Node.js 22.x
+ Puppeteer-core 版本 24.25.0
+ Chromium 142.0.7444.175 版
+ Firefox 版本 145.x
**syn-nodejs-puppeteer-13.1 中的变化**
+ Synthetics 运行时命名空间迁移。
+ 类型定义在 npm 注册表中可用。请确保类型定义包的版本与您的金丝雀的运行时版本相匹配。
+ [@aws/synthetics-puppeteer](https://www.npmjs.com/package/@aws/synthetics-puppeteer)
+ [@aws/synthetics-link](https://www.npmjs.com/package/@aws/synthetics-link)
+ [@aws/synthetics-broken-link-checker-report](https://www.npmjs.com/package/@aws/synthetics-broken-link-checker-report)
+ [@aws/synthetics-log-helper](https://www.npmjs.com/package/@aws/synthetics-log-helper)
+ [@aws/synthetics-logger](https://www.npmjs.com/package/@aws/synthetics-logger)
### syn-nodejs-puppeteer-13.0
有关更多信息，请参阅下列内容：
+ [Puppeteer 更改日志](https://pptr.dev/CHANGELOG#24250-2025-10-15)
+ [Puppeteer API 参考](https://github.com/puppeteer/puppeteer/blob/puppeteer-v24.2.0/docs/api/index.md)
**主要依赖项**：
+ Lambda 运行时系统 Node.js 22.x
+ Puppeteer-core 版本 24.25.0
+ Chromium 142.0.7444.175 版
+ Firefox 版本 145.x
**syn-nodejs-puppeteer-13.0 中的变化**
+ 应用了安全补丁，并更新了 Puppeteer 和浏览器版本。
+ 错误修复：修复了由并发映射访问导致的间歇性运行时扩展崩溃问题
### syn-nodejs-puppeteer-12.0
有关更多信息，请参阅下列内容：
+ [Puppeteer 更改日志](https://pptr.dev/CHANGELOG#24221-2025-09-23)
+ [Puppeteer API 参考](https://github.com/puppeteer/puppeteer/blob/puppeteer-v24.22.1/docs/api/index.md)
**主要依赖项**：
+ Lambda 运行时系统 Node.js 22.x
+ Puppeteer-core 版本 24.22.1
+ Chromium 140.0.7339.185 版
+ Firefox 版本 143.0.1
**syn-nodejs-puppeteer-12.0 中的变化**
+ 应用了安全补丁，并更新了 Puppeteer 和浏览器版本。
+ 修复了受限标头编辑的错误：修复了在某些情况下，executeHttpStep() 中受限标头未正确编辑的问题。现在其行为与 Puppeteer 10.0 版本保持一致。
+ 修复了 includeResponseBody 配置错误的问题：修复了在某些情况下，HAR 文件生成可能错误应用 includeResponseBody 配置设置的问题。现在，HAR 可确保在配置设置时正确排除响应正文。
+ 修复了请求捕获生命周期的问题：修复了在某些情况下，HTTP 请求捕获器可能导致请求持续聚合的问题。现在，每次执行步骤后，记录都会正确终止。
### syn-nodejs-puppeteer-11.0
有关更多信息，请参阅下列内容：
+ [Puppeteer 更改日志](https://pptr.dev/CHANGELOG)
+ [Puppeteer API 参考](https://github.com/puppeteer/puppeteer/blob/puppeteer-v24.2.0/docs/api/index.md)
**主要依赖项**：
+ Lambda 运行时系统 Node.js 20.x
+ Puppeteer-core 版本 24.15.0
+ Chromium 版本 138.0.7204.168
**syn-nodejs-puppeteer-11.0 中的变化**
+ 多浏览器支持：现可在 Firefox 或 Chrome 中运行 Node.js Puppeteer 金丝雀
+ 简化打包：无需使用 Node.js/node\$1modules 目录结构即可直接在根目录下打包脚本
+ 屏幕截图集成：使用原生 Puppeteer 函数捕获屏幕截图，可视化展示金丝雀脚本的各执行阶段。Synthetics 会自动将屏幕截图与金丝雀检测步骤关联，并上传至 Amazon S3
+ 增强型日志查询：通过 CloudWatch Insights 控制台查询和筛选日志。每条日志消息都包含一个独特的 `canaryRunId` 以便于搜索
+ 配置文件支持：使用 synthetics.json 文件定义和更新 Synthetics 设置。这种配置与脚本逻辑的分离方式提高了可维护性和可复用性
+ 多选项卡支持：创建可打开多个浏览器选项卡的金丝雀，并从每个选项卡访问屏幕截图。在 Synthetics 中创建多选项卡和多步骤用户工作流程
+ 安全修复
+ 可视化监控错误修复
+ 增加了对具有可配置日志级别的结构化 JSON 日志的支持：日志现在以 JSON 格式发出，以便在 CloudWatch 中更轻松地进行解析和查询。日志级别（例如 DEBUG、INFO、TRACE）可通过环境变量进行配置，允许用户根据自己的需求控制详细程度
+ 对 ES 语法的支持
### syn-nodejs-puppeteer-10.0
有关更多信息，请参阅下列内容：
+ [Puppeteer 更改日志](https://pptr.dev/CHANGELOG)
+ [Puppeteer API 参考](https://github.com/puppeteer/puppeteer/blob/puppeteer-v24.2.0/docs/api/index.md)
**主要依赖项**：
+ Lambda 运行时系统 Node.js 20.x
+ Puppeteer-core 版本 24.2.0
+ Chromium 版本 131.0.6778.264
**syn-nodejs-puppeteer-10.0 中的变化**：
+ 修复了关闭浏览器耗时过长的问题。
+ 支持对金丝雀进行试运行，允许临时执行或执行安全的金丝雀更新。
### syn-nodejs-puppeteer-9.1
**主要依赖项**：
+ Lambda 运行时系统 Node.js 20.x
+ Puppeteer-core 版本 22.12.1
+ Chromium 版本 126.0.6478.126
**syn-nodejs-puppeteer-9.1 中的变化**：修复了与 HAR 文件中的日期范围和待处理请求相关的错误。
### syn-nodejs-puppeteer-9.0
**主要依赖项**：
+ Lambda 运行时系统 Node.js 20.x
+ Puppeteer-core 版本 22.12.1
+ Chromium 版本 126.0.6478.126
**syn-nodejs-puppeteer-9.0 中的变化**：修复了启用视觉监控功能的错误。
### syn-nodejs-puppeteer-8.0
**警告**
由于存在错误，`syn-nodejs-puppeteer-8.0` 运行时不支持在金丝雀系统中进行可视化监控。升级到 [syn-nodejs-puppeteer-9.0](#CloudWatch_Synthetics_runtimeversion-nodejs-puppeteer-9.0) 以修复可视化监视的错误。
**重要**
Lambda Node.js 18 和更高版本运行时系统使用适用于 JavaScript V3 的 AWS SDK。如果需要从较早的运行时迁移金丝雀，请遵循 GitHub 上的 [aws-sdk-js-v3 Migration Workshop](https://github.com/aws-samples/aws-sdk-js-v3-workshop)。有关 AWS SDK for JavaScript 版本 3 的更多信息，请参阅[此博客文章](https://aws.amazon.com/blogs/developer/modular-aws-sdk-for-javascript-is-now-generally-available/)。
**主要依赖项**：
+ Lambda 运行时系统 Node.js 20.x
+ Puppeteer-core 22.10.0 版
+ Chromium 125.0.6422.112 版
**syn-nodejs-puppeteer-8.0 中的更新**：
+ **支持双重身份验证**
+ 修复了与某些服务客户端在 Node.js SDK V3 响应中丢失数据相关的**错误**。
## 已弃用的 Node.js 和 Puppeteer 运行时版本
下列 Node.js 和 Puppeteer 运行时系统已弃用。有关运行时弃用日期的信息，请参阅 [CloudWatch Synthetics 运行时弃用日期](CloudWatch_Synthetics_Runtime_Support_Policy.md#runtime_deprecation_dates)。
### syn-nodejs-puppeteer-7.0
**主要依赖项**：
+ Lambda 运行时系统 Node.js 18.x
+ Puppeteer-core 21.9.0 版
+ Chromium 121.0.6167.139 版
**代码大小**：
您可以将大小为 80MB 的代码和依赖项打包到此运行时中。
**syn-nodejs-puppeteer-7.0 中的更新**：
+ **更新了 Puppeteer 和 Chromium 中捆绑库的版本**：Puppeteer 和 Chromium 依赖项已更新到新版本。
**重要**
从 Puppeteer 19.7.0 迁移到 Puppeteer 21.9.0 引入了有关测试和筛选条件的重大更改。有关更多信息，请参阅 [puppeteer：v20.0.0](https://github.com/puppeteer/puppeteer/releases/tag/puppeteer-v20.0.0) 和 [puppeteer-core：v21.0.0](https://github.com/puppeteer/puppeteer/releases/tag/puppeteer-core-v21.0.0) 中的**重大更改**部分。
**推荐升级到 AWS SDK v3**
Lambda nodejs18.x 运行时不支持 AWS SDK v2。强烈建议您迁移到 AWS SDK v3。
### syn-nodejs-puppeteer-6.2
**主要依赖项**：
+ Lambda 运行时系统 Node.js 18.x
+ Puppeteer-core 19.7.0 版
+ Chromium 111.0.5563.146 版
**syn-nodejs-puppeteer-6.2 中的变化**：
+ **更新了 Chromium 中捆绑库的版本**
+ **临时存储监控** — 此运行时系统会在客户账户中添加临时存储监控。
+ **错误修复**
### syn-nodejs-puppeteer-6.1
**主要依赖项**：
+ Lambda 运行时系统 Node.js 18.x
+ Puppeteer-core 19.7.0 版
+ Chromium 111.0.5563.146 版
**syn-nodejs-puppeteer-6.1 中的更新**：
+ **稳定性提高**：新增自动重试逻辑，用于处理间歇性 Puppeteer 启动错误。
+ **依赖项升级**：升级部分第三方依赖项包。
+ **没有 Amazon S3 权限的 Canary**：通过错误修复使没有任何 Amazon S3 权限的 Canary 仍可运行。这些没有 Amazon S3 权限的 Canary 将无法将屏幕截图或其他构件上传到 Amazon S3。有关 Canary 权限的更多信息，请参阅 [金丝雀的必需角色和权限](CloudWatch_Synthetics_Canaries_CanaryPermissions.md)。
**重要**
重要提示：在未来的运行时系统版本中，随附的适用于 JavaScript v2 的 AWS SDK 依赖项将被移除，并更新为使用适用于 JavaScript v3 的 AWS SDK。发生这种情况时，您可以更新金丝雀代码引用，也可以继续引用和使用随附的适用于 JavaScript v2 的 AWS SDK 依赖项，方法是将其作为依赖项添加到源代码 zip 文件中。
### syn-nodejs-puppeteer-6.0
**主要依赖项**：
+ Lambda 运行时系统 Node.js 18.x
+ Puppeteer-core 19.7.0 版
+ Chromium 111.0.5563.146 版
**syn-nodejs-puppeteer-6.0 中的更新**：
+ **依赖项升级** – Node.js 依赖项已升级到 18.x。
+ **拦截模式支持** – Synthetics 金丝雀运行时系统库中添加了 Puppeteer 合作拦截模式支持。
+ **跟踪行为更改** – 将默认跟踪行为更改为了仅跟踪 fetch 和 xhr 请求，而不跟踪资源请求。您可以通过配置 `traceResourceRequests` 选项来启用对资源请求的跟踪。
+ **持续时间指标已完善** – ` Duration` 指标现在不包括金丝雀用于上传构件、捕获屏幕截图和生成 CloudWatch 指标的操作时间。`Duration` 指标值会报告给 CloudWatch，您也可以在 Synthetics 控制台中进行查看。
+ **错误修复** – 清理 Chromium 在金丝雀运行期间崩溃时生成的核心转储。
**重要**
重要提示：在未来的运行时系统版本中，随附的适用于 JavaScript v2 的 AWS SDK 依赖项将被移除，并更新为使用适用于 JavaScript v3 的 AWS SDK。发生这种情况时，您可以更新金丝雀代码引用，也可以继续引用和使用随附的适用于 JavaScript v2 的 AWS SDK 依赖项，方法是将其作为依赖项添加到源代码 zip 文件中。
### syn-nodejs-puppeteer-5.2
**主要依赖项**：
+ Lambda 运行时系统 Node.js 16.x
+ Puppeteer-core 19.7.0 版
+ Chromium 111.0.5563.146 版
**syn-nodejs-puppeteer-5.2 中的更新**：
+ **更新了 Chromium 中捆绑库的版本**
+ **错误修复**
### syn-nodejs-puppeteer-5.1
**主要依赖项**：
+ Lambda 运行时系统 Node.js 16.x
+ Puppeteer-core 19.7.0 版
+ Chromium 111.0.5563.146 版
**syn-nodejs-puppeteer-5.1 中的错误修复**：
+ **错误修复**：此运行时系统修复了 ` syn-nodejs-puppeteer-5.0` 中的一个错误，其中由金丝雀创建的 HAR 文件缺少请求标头。
### syn-nodejs-puppeteer-5.0
**主要依赖项**：
+ Lambda 运行时系统 Node.js 16.x
+ Puppeteer-core 19.7.0 版
+ Chromium 111.0.5563.146 版
**syn-nodejs-puppeteer-5.0 中的更新**：
+ **依赖关系升级** — Puppeteer-Core 版本已更新至 19.7.0。Chromium 版本已升级至 111.0.5563.146。
**重要**
新的 Puppeteer-Core 版本并不完全向后兼容之前版本的 Puppeteer。此版本中的某些更改可能会导致使用已弃用的 Puppeteer 函数的现有金丝雀失败。有关更多信息，请参阅 [Puppeteer 变更日志](https://github.com/puppeteer/puppeteer/releases?q=breaking&expanded=true)中 Puppeteer-core 19.7.0 至 6.0 版变更日志中的重大更改。
### syn-nodejs-puppeteer-4.0
**主要依赖项**：
+ Lambda 运行时系统 Node.js 16.x
+ Puppeteer-core 5.5.0 版
+ Chromium 92.0.4512 版
**syn-nodejs-puppeteer-4.0 中的更新**：
+ **依赖项升级** – Node.js 依赖项已更新到 16.x。
### syn-nodejs-puppeteer-3.9
**重要**
此运行时系统版本已于 2024 年 1 月 8 日弃用。有关更多信息，请参阅 [运行时版本支持策略](CloudWatch_Synthetics_Runtime_Support_Policy.md)。
**主要依赖项**：
+ Lambda 运行时 Node.js 14.x
+ Puppeteer-core 5.5.0 版
+ Chromium 92.0.4512 版
**syn-nodejs-puppeteer-3.9 中的更新**：
+ **依赖项升级** – 升级一些第三方依赖项包。
### syn-nodejs-puppeteer-3.8
**重要**
此运行时系统版本已于 2024 年 1 月 8 日弃用。有关更多信息，请参阅 [运行时版本支持策略](CloudWatch_Synthetics_Runtime_Support_Policy.md)。
**主要依赖项**：
+ Lambda 运行时 Node.js 14.x
+ Puppeteer-core 5.5.0 版
+ Chromium 92.0.4512 版
**syn-nodejs-puppeteer-3.8 中的更新**：
+ **配置文件清理** – 现在，每次金丝雀脚本运行后，都会清理 Chromium 配置文件。
**syn-nodejs-puppeteer-3.8 中的错误修复**：
+ **错误修复** – 以前，在没有屏幕截图的情况下运行后，可视化监控金丝雀脚本有时会停止正常工作。此问题现已修复。
### syn-nodejs-puppeteer-3.7
**重要**
此运行时系统版本已于 2024 年 1 月 8 日弃用。有关更多信息，请参阅 [运行时版本支持策略](CloudWatch_Synthetics_Runtime_Support_Policy.md)。
**主要依赖项**：
+ Lambda 运行时 Node.js 14.x
+ Puppeteer-core 5.5.0 版
+ Chromium 92.0.4512 版
**syn-nodejs-puppeteer-3.7 中的更新**：
+ **日志记录增强功能** — 即使 Amazon S3 超时或崩溃，金丝雀也会将日志上传到 Amazon S3。
+ **Lambda 层大小已减小** — 用于金丝雀的 Lambda 层的大小减小了 34%。
**syn-nodejs-puppeteer-3.7 中的错误修复**：
+ **错误修复** — 日语、简体中文和繁体中文字体将正确呈现。
### syn-nodejs-puppeteer-3.6
**重要**
此运行时系统版本已于 2024 年 1 月 8 日弃用。有关更多信息，请参阅 [运行时版本支持策略](CloudWatch_Synthetics_Runtime_Support_Policy.md)。
**主要依赖项**：
+ Lambda 运行时 Node.js 14.x
+ Puppeteer-core 5.5.0 版
+ Chromium 92.0.4512 版
**syn-nodejs-puppeteer-3.6 中的更新**：
+ **更精确的时间戳** — 金丝雀运行的开始时间和停止时间现在精确到毫秒。
### syn-nodejs-puppeteer-3.5
**重要**
此运行时系统版本已于 2024 年 1 月 8 日弃用。有关更多信息，请参阅 [运行时版本支持策略](CloudWatch_Synthetics_Runtime_Support_Policy.md)。
**主要依赖项**：
+ Lambda 运行时 Node.js 14.x
+ Puppeteer-core 5.5.0 版
+ Chromium 92.0.4512 版
**syn-nodejs-puppeteer-3.5 中的更新**：
+ **更新的项目依赖项**— 此运行时中唯一的新功能是更新的项目依赖项。
### syn-nodejs-puppeteer-3.4
**重要**
此运行时版本于 2022 年 11 月 13 日弃用。有关更多信息，请参阅 [运行时版本支持策略](CloudWatch_Synthetics_Runtime_Support_Policy.md)。
**主要依赖项**：
+ Lambda 运行时 Node.js 12.x
+ Puppeteer-core 5.5.0 版
+ Chromium 88.0.4298.0 版
**syn-nodejs-puppeteer-3.4 中的更新**：
+ **自定义处理程序函数**— 您现在可以对金丝雀脚本使用自定义处理程序函数。之前的运行时要求脚本入口点包括 `.handler`。
您还可以将金丝雀脚本放在任何文件夹中，并将文件夹名称作为处理程序的一部分进行传递。例如，`MyFolder/MyScriptFile.functionname` 可以用作入口点。
+ **扩展的 HAR 文件信息**— 您现在可以在金丝雀生成的 HAR 文件中看到恶意、待处理和未完成的请求。
### syn-nodejs-puppeteer-3.3
**重要**
此运行时版本于 2022 年 11 月 13 日弃用。有关更多信息，请参阅 [运行时版本支持策略](CloudWatch_Synthetics_Runtime_Support_Policy.md)。
**主要依赖项**：
+ Lambda 运行时 Node.js 12.x
+ Puppeteer-core 5.5.0 版
+ Chromium 88.0.4298.0 版
**syn-nodejs-puppeteer-3.3 中的更新**：
+ **用于构件加密的更多选项** – 对于使用此运行时或更高版本运行时（而不是使用 AWS 托管式密钥）来加密金丝雀存储在 Amazon S3 中的构件的金丝雀，您可以选择使用 AWS KMS 客户托管式密钥或 Amazon S3 托管式密钥。有关更多信息，请参阅 [加密金丝雀构件](CloudWatch_Synthetics_artifact_encryption.md)。
### syn-nodejs-puppeteer-3.2
**重要**
此运行时版本于 2022 年 11 月 13 日弃用。有关更多信息，请参阅 [运行时版本支持策略](CloudWatch_Synthetics_Runtime_Support_Policy.md)。
**主要依赖项**：
+ Lambda 运行时 Node.js 12.x
+ Puppeteer-core 5.5.0 版
+ Chromium 88.0.4298.0 版
**syn-nodejs-puppeteer-3.2 中的更新**：
+ **使用屏幕截图进行可视化监控** – 使用此运行时或更高版本运行时的金丝雀可以将运行期间捕获的屏幕截图与相同屏幕截图的基准版本进行比较。如果屏幕截图与指定百分比阈值之间的差异较大，则金丝雀将失败。有关更多信息，请参阅 [可视化监控](CloudWatch_Synthetics_Canaries_Library_Nodejs.md#CloudWatch_Synthetics_Library_SyntheticsLogger_VisualTesting) 或 [可视监控蓝图](CloudWatch_Synthetics_Canaries_Blueprints.md#CloudWatch_Synthetics_Canaries_Blueprints_VisualTesting)。
+ **与敏感数据相关的新函数**：您可以阻止敏感数据出现在金丝雀日志和报告中。有关更多信息，请参阅 [SyntheticsLogHelper 类](CloudWatch_Synthetics_Canaries_Library_Nodejs.md#CloudWatch_Synthetics_Library_SyntheticsLogHelper)。
+ **已弃用的函数**：` RequestResponseLogHelper` 类已弃用，以支持其他新配置选项。有关更多信息，请参阅 [RequestResponseLogHelper 类](CloudWatch_Synthetics_Canaries_Library_Nodejs.md#CloudWatch_Synthetics_Library_RequestResponseLogHelper)。
### syn-nodejs-puppeteer-3.1
**重要**
此运行时版本于 2022 年 11 月 13 日弃用。有关更多信息，请参阅 [运行时版本支持策略](CloudWatch_Synthetics_Runtime_Support_Policy.md)。
**主要依赖项**：
+ Lambda 运行时 Node.js 12.x
+ Puppeteer-core 5.5.0 版
+ Chromium 88.0.4298.0 版
**syn-nodejs-puppeteer-3.1 中的更新**：
+ **CloudWatch 指标配置功能** – 使用此运行时，您可以禁用不需要的指标。否则，金丝雀会发布每次金丝雀运行的各种 CloudWatch 指标。
+ **屏幕截图链接** – 您可以在金丝雀步骤完成后将屏幕截图链接到该步骤。为此，您可以使用 **takeScreenshot** 方法捕获屏幕截图，并使用要与屏幕截图关联的步骤的名称。例如，您可能想要执行某个步骤，添加等待时间，然后捕获屏幕截图。
+ **检测信号监控器蓝图可以监控多个 URL** – 您可以使用 CloudWatch 控制台中的检测信号监控蓝图来监控多个 URL，并在金丝雀运行报告的步骤摘要中查看每个 URL 的状态、持续时间、关联的屏幕截图和故障原因。
### syn-nodejs-puppeteer-3.0
**重要**
此运行时版本于 2022 年 11 月 13 日弃用。有关更多信息，请参阅 [运行时版本支持策略](CloudWatch_Synthetics_Runtime_Support_Policy.md)。
**主要依赖项**：
+ Lambda 运行时 Node.js 12.x
+ Puppeteer-core 5.5.0 版
+ Chromium 88.0.4298.0 版
**syn-nodejs-puppeteer-3.0 中的更新**：
+ **升级的依赖项** – 此版本使用 Puppeteer 5.5.0 版、Node.js 12.x 和 Chromium 88.0.4298.0。
+ **跨区域存储桶访问** – 您现在可以指定另一个区域中的 S3 存储桶作为金丝雀存储其日志文件、屏幕截图和 HAR 文件的存储桶。
+ **可用的新函数** – 此版本添加了库函数来检索金丝雀名称和 Synthetics 运行时版本。
有关更多信息，请参阅 [Synthetics 类](CloudWatch_Synthetics_Canaries_Library_Nodejs.md#CloudWatch_Synthetics_Library_Synthetics_Class_all)。
### syn-nodejs-2.2
本节包含有关 `syn-nodejs-2.2` 运行时版本的信息。
**重要**
此运行时版本已于 2021 年 5 月 28 日弃用。有关更多信息，请参阅 [运行时版本支持策略](CloudWatch_Synthetics_Runtime_Support_Policy.md)。
**主要依赖项**：
+ Lambda 运行时 Node.js 10.x
+ Puppeteer-core 3.3.0 版
+ Chromium 83.0.4103.0 版
**syn-nodejs-2.2 中的变化**：
+ **作为 HTTP 步骤监控您的金丝雀** – 您现在可以在一个金丝雀中测试多个 API。每个 API 都作为单独的 HTTP 步骤进行测试，CloudWatch Synthetics 会使用步骤指标和 CloudWatch Synthetics 步骤报告监控每个步骤的状态。CloudWatch Synthetics 会为每个 HTTP 步骤创建 ` SuccessPercent` 和 `Duration` 指标。
此功能由 **executeHttpStep(stepName, requestOptions, callback, stepConfig)** 函数实现。有关更多信息，请参阅 [executeHttpStep(stepName, requestOptions, [callback], [stepConfig])](CloudWatch_Synthetics_Canaries_Library_Nodejs.md#CloudWatch_Synthetics_Library_executeHttpStep)。
API 金丝雀蓝图已更新为使用此新功能。
+ **HTTP 请求报告** – 您现在可以查看详细的 HTTP 请求报告，这些报告捕获的是请求/响应标头、响应正文、状态代码、错误和性能计时、TCP 连接时间、TLS 握手时间、第一字节时间和内容传输时间等详细信息。所有使用后台 HTTP/HTTPS 模块的 HTTP 请求都在此处捕获。预设情况下不会捕获标头和响应正文，但可以通过设置配置选项来启用捕获标头和响应正文。
+ **全局和步骤级配置** – 您可以在全局级别设置 CloudWatch Synthetics 配置，这些配置应用于金丝雀的所有步骤。您还可以通过传递配置键/值对来启用或禁用某些选项，在步骤级别覆盖这些配置。
有关更多信息，请参阅 [SyntheticsConfiguration 类](CloudWatch_Synthetics_Canaries_Library_Nodejs.md#CloudWatch_Synthetics_Library_SyntheticsConfiguration)。
+ **继续执行步骤故障配置** – 您可以选择在步骤故障时继续执行金丝雀。对于 ` executeHttpStep` 函数，预设情况下，此选项处于启用状态。您可以在全局级别设置此选项一次，或者针对每个步骤做出不同的设置。
### syn-nodejs-2.1
**重要**
此运行时版本已于 2021 年 5 月 28 日弃用。有关更多信息，请参阅 [运行时版本支持策略](CloudWatch_Synthetics_Runtime_Support_Policy.md)。
**主要依赖项**：
+ Lambda 运行时 Node.js 10.x
+ Puppeteer-core 3.3.0 版
+ Chromium 83.0.4103.0 版
**syn-nodejs-2.1 中的更新**：
+ **可配置的屏幕截图行为** – 提供关闭 UI 金丝雀捕获屏幕截图的功能。在使用以前版本运行时的金丝雀中，UI 金丝雀始终在每个步骤前后捕获屏幕截图。在 `syn-nodejs-2.1` 中，可配置此行为。关闭屏幕截图可以降低您的 Amazon S3 存储成本，并有助于您遵守 HIPAA 法规。有关更多信息，请参阅 [SyntheticsConfiguration 类](CloudWatch_Synthetics_Canaries_Library_Nodejs.md#CloudWatch_Synthetics_Library_SyntheticsConfiguration)。
+ **自定义 Google Chrome 启动参数**：现在，您可以配置当金丝雀启动 Google Chrome 浏览器窗口时使用的参数。有关更多信息，请参阅 [launch(options)](CloudWatch_Synthetics_Canaries_Library_Nodejs.md#CloudWatch_Synthetics_Library_LaunchOptions)。
与更早版本的金丝雀运行时相比，使用 syn-nodejs-2.0 或更高版本时，金丝雀持续时间可能会略有增加。
### syn-nodejs-2.0
**重要**
此运行时版本已于 2021 年 5 月 28 日弃用。有关更多信息，请参阅 [运行时版本支持策略](CloudWatch_Synthetics_Runtime_Support_Policy.md)。
**主要依赖项**：
+ Lambda 运行时 Node.js 10.x
+ Puppeteer-core 3.3.0 版
+ Chromium 83.0.4103.0 版
**syn-nodejs-2.0 中的更新**：
+ **升级的依赖项** – 此运行时版本使用 Puppeteer-core 3.3.0 版和 Chromium 83.0.4103.0 版
+ **支持 X-Ray 活动跟踪。**金丝雀启用跟踪后，将针对由使用浏览器、AWS SDK 或 HTTP 或 HTTPS 模块的金丝雀发出的所有调用发送 X-Ray 跟踪。启用了跟踪的 Canary 会显示在 X-Ray 跟踪地图中，即使它们没有向启用了跟踪的其他服务或应用程序发送请求。有关更多信息，请参阅 [金丝雀和 X-Ray 跟踪](CloudWatch_Synthetics_Canaries_tracing.md)。
+ **Synthetics 报告** – CloudWatch Synthetics 会针对每次金丝雀运行创建一个名为 ` SyntheticsReport-PASSED.json` 或 ` SyntheticsReport-FAILED.json` 的报告，其中记录了开始时间、结束时间、状态和故障等数据。报告中还记录金丝雀脚本的每个步骤的 PASSED/FAILED 状态，以及每个步骤捕获的失败和屏幕截图。
+ **无效链接检查器报告** – 此运行时中包含的新版本无效链接检查器会创建一个报告，其中包括已检查的链接、状态代码、故障原因（如有）以及源页面和目标页面屏幕截图。
+ **新 CloudWatch 指标** – Synthetics 在 `CloudWatchSynthetics` 命名空间中发布名为 `2xx`、`4xx`、`5xx` 和 `RequestFailed` 的指标。这些指标会显示金丝雀运行中 200 秒、400 秒、500 秒和请求故障的数量。在此运行时版本中，这些指标仅针对 UI 金丝雀报告，而不针对 API 金丝雀报告。从 ` syn-nodejs-puppeteeer-2.2` 运行时版本开始，也针对 API 金丝雀报告这些指标。
+ **可排序的 HAR 文件** – 您现在可以按状态代码、请求大小和持续时间对 HAR 文件进行排序。
+ **指标时间戳** – 现在基于 Lambda 调用时间而非金丝雀运行结束时间报告 CloudWatch 指标。
**syn-nodejs-2.0 中的错误修复**：
+ 修复了不报告金丝雀构件上载错误的问题。此类错误现在显示为执行错误。
+ 修复了将重定向请求 (3xx) 误记为错误的问题。
+ 修复了从 0 开始编号屏幕截图的问题。现在应从 1 开始编号。
+ 修复了中文和日文字体屏幕截图乱码的问题。
与更早版本的金丝雀运行时相比，使用 syn-nodejs-2.0 或更高版本时，金丝雀持续时间可能会略有增加。
### syn-nodejs-2.0-beta
**重要**
此运行时版本已于 2021 年 2 月 8 日弃用。有关更多信息，请参阅 [运行时版本支持策略](CloudWatch_Synthetics_Runtime_Support_Policy.md)。
**主要依赖项**：
+ Lambda 运行时 Node.js 10.x
+ Puppeteer-core 3.3.0 版
+ Chromium 83.0.4103.0 版
**syn-nodejs-2.0-beta 中的变化**：
+ **升级的依赖项** – 此运行时版本使用 Puppeteer-core 3.3.0 版和 Chromium 83.0.4103.0 版
+ **Synthetics 报告** – CloudWatch Synthetics 会针对每次金丝雀运行创建一个名为 ` SyntheticsReport-PASSED.json` 或 ` SyntheticsReport-FAILED.json` 的报告，其中记录了开始时间、结束时间、状态和故障等数据。报告中还记录金丝雀脚本的每个步骤的 PASSED/FAILED 状态，以及每个步骤捕获的失败和屏幕截图。
+ **无效链接检查器报告** – 此运行时中包含的新版本无效链接检查器会创建一个报告，其中包括已检查的链接、状态代码、故障原因（如有）以及源页面和目标页面屏幕截图。
+ **新 CloudWatch 指标** – Synthetics 在 `CloudWatchSynthetics` 命名空间中发布名为 `2xx`、`4xx`、`5xx` 和 `RequestFailed` 的指标。这些指标会显示金丝雀运行中 200 秒、400 秒、500 秒和请求故障的数量。仅针对 UI 金丝雀报告而不针对 API 金丝雀报告这些指标。
+ **可排序的 HAR 文件** – 您现在可以按状态代码、请求大小和持续时间对 HAR 文件进行排序。
+ **指标时间戳** – 现在基于 Lambda 调用时间而非金丝雀运行结束时间报告 CloudWatch 指标。
**syn-nodejs-2.0-beta 中的错误修复**：
+ 修复了不报告金丝雀构件上载错误的问题。此类错误现在显示为执行错误。
+ 修复了将重定向请求 (3xx) 误记为错误的问题。
+ 修复了从 0 开始编号屏幕截图的问题。现在应从 1 开始编号。
+ 修复了中文和日文字体屏幕截图乱码的问题。
### syn-1.0
第一个 Synthetics 运行时版本是 `syn-1.0`。
**主要依赖项**：
+ Lambda 运行时 Node.js 10.x
+ Puppeteer-core 1.14.0 版
+ 与 Puppeteer-core 1.14.0 匹配的 Chromium 版本
# 使用 Python 和 Selenium Webdriver 的运行时版本
以下各节包含有关用于 Python 和 Selenium Webdriver 的 CloudWatch Synthetics 运行时版本的信息。Selenium 是一种开源浏览器自动化工具。有关 Selenium 的更多信息，请参阅 [www.selenium.dev/](https://www.selenium.dev)
关于 Synthetics 运行时在 Selenium 框架中支持的功能和方法，请参阅[仅适用于 UI Canary 的 Python 和 Selenium 库类和函数](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Synthetics_Canaries_Library_Python.html#CloudWatch_Synthetics_Library_Python_UIcanaries)以及 [Selenium API 参考](https://www.selenium.dev/selenium/docs/api/py/api.html)。
这些运行时版本的命名约定为 `syn-language -framework-majorversion. minorversion`。
## syn-python-selenium-10.0
版本 10.0 是适用于 Python 和 Selenium 的最新 CloudWatch Synthetics 运行时。
**主要依赖项**：
+ Python 3.11
+ Selenium 4.32.0
+ Chromium 145.0.7632.77 版
**syn-python-selenium-10.0 中的更改**
+ 应用了安全补丁，并更新了浏览器版本。
有关更多信息，请参阅下列内容：
+ [Selenium 更改日志](https://www.selenium.dev/blog/2025/selenium-4-32-released)
+ [Selenium 文档](https://www.selenium.dev/selenium/docs/api/py/api.html)
## 先前的 Python 和 Selenium 运行时版本
下列 Python 和 Selenium 的早期运行时版本仍受支持。
### syn-python-selenium-9.0
**主要依赖项**：
+ Python 3.11
+ Selenium 4.32.0
+ Chromium 143.0.7499.169 版
**syn-python-selenium-9.0 中的更改**
+ 应用了安全补丁，并更新了浏览器版本。
有关更多信息，请参阅下列内容：
+ [Selenium 更改日志](https://www.selenium.dev/blog/2025/selenium-4-32-released)
+ [Selenium 文档](https://www.selenium.dev/selenium/docs/api/py/api.html)
### syn-python-selenium-8.0
版本 8.0 是适用于 Python 和 Selenium 的最新 CloudWatch Synthetics 运行时。
**主要依赖项**：
+ Python 3.11
+ Selenium 4.32.0
+ Chromium 142.0.7444.175 版
**syn-python-selenium-8.0 中的更改**
+ 应用了安全补丁，并更新了 Selenium 和浏览器版本。
+ 修改了失败的 HAR 网络请求日志级别，从 ERROR 改为 INFO。
有关更多信息，请参阅下列内容：
+ [Selenium 更改日志](https://www.selenium.dev/blog/2025/selenium-4-32-released)
+ [Selenium 文档](https://www.selenium.dev/selenium/docs/api/py/api.html)
### syn-python-selenium-7.0
**主要依赖项**：
+ Python 3.11
+ Selenium 4.32.0
+ Chromium 版本 138.0.7204.168
**syn-python-selenium-7.0 中的更改**
+ 应用了安全补丁，并更新了 Selenium 和浏览器版本。
有关更多信息，请参阅下列内容：
+ [Selenium 更改日志](https://www.selenium.dev/blog/2025/selenium-4-32-released)
+ [Selenium 文档](https://www.selenium.dev/selenium/docs/api/py/api.html)
### syn-python-selenium-6.0
**主要依赖项**：
+ Python 3.11
+ Selenium 4.21.0
+ Chromium 版本 131.0.6778.264
**syn-python-selenium-6.0 中的变化**：
+ 从 Python 3.9 升级到 Python 3.11。
有关更多信息，请参阅下列内容：
+ [Selenium 更改日志](https://www.selenium.dev/blog/2024/selenium-4-21-released/)
+ [Selenium 文档](https://www.selenium.dev/selenium/docs/api/py/api.html)
### syn-python-selenium-5.1
**主要依赖项**：
+ Python 3.9
+ Selenium 4.21.0
+ Chromium 版本 131.0.6778.264
**syn-python-selenium-5.1 中的变化**：
+ 对指标上报功能进行了细微更新。
+ 支持对金丝雀进行试运行，允许临时执行或执行安全的金丝雀更新。
### syn-python-selenium-5.0
**主要依赖项**：
+ Python 3.9
+ Selenium 4.21.0
+ Chromium 版本 131.0.6778.264
**syn-python-selenium-5.0 中的变化**：
+ 如果浏览器无法启动，则会自动重试。
### syn-python-selenium-4.1
**主要依赖项**：
+ Python 3.9
+ Selenium 4.15.1
+ Chromium 版本 126.0.6478.126
**syn-python-selenium-4.1 中的变化**：
+ **修复安全漏洞**：此运行时包含用于解决 [CVE-2024-39689](https://nvd.nist.gov/vuln/detail/CVE-2024-39689) 漏洞的更新。
### syn-python-selenium-4.0
**主要依赖项**：
+ Python 3.9
+ Selenium 4.15.1
+ Chromium 版本 126.0.6478.126
**syn-python-selenium-4.0 中的变化**：
+ **修复了** HAR 解析器日志记录中的错误。
## 已弃用的 Python 和 Selenium 运行时版本
下列 Python 和 Selenium 的早期运行时版本已弃用。有关运行时弃用日期的信息，请参阅 [CloudWatch Synthetics 运行时弃用日期](CloudWatch_Synthetics_Runtime_Support_Policy.md#runtime_deprecation_dates)。
### syn-python-selenium-3.0
**主要依赖项**：
+ Python 3.8
+ Selenium 4.15.1
+ Chromium 121.0.6167.139 版
**syn-python-selenium-3.0 中的变化**：
+ **更新了 Chromium 中捆绑库的版本**：Chromium 依赖项已更新到新版本。
### syn-python-selenium-2.1
**主要依赖项**：
+ Python 3.8
+ Selenium 4.15.1
+ Chromium 111.0.5563.146 版
**syn-python-selenium-2.1 中的变化**：
+ **更新了 Chromium 中捆绑库的版本**：Chromium 和 Selenium 依赖项已更新到新版本。
### syn-python-selenium-2.0
**主要依赖项**：
+ Python 3.8
+ Selenium 4.10.0
+ Chromium 111.0.5563.146 版
**syn-python-selenium-2.0 中的变化**：
+ **更新了依赖项** — Chromium 和 Selenium 依赖项已更新到新版本。
**syn-python-selenium-2.0 中的错误修复**：
+ **添加了时间戳** — 已将时间戳添加到金丝雀日志。
+ **会话重用** — 修复了一个错误，因此金丝雀现在无法重用以前金丝雀运行的会话。
### syn-python-selenium-1.3
**主要依赖项**：
+ Python 3.8
+ Selenium 3.141.0
+ Chromium 92.0.4512.0 版
**syn-python-selenium-1.3 中的变化**：
+ **更精确的时间戳** — 金丝雀运行的开始时间和停止时间现在精确到毫秒。
### syn-python-selenium-1.2
**主要依赖项**：
+ Python 3.8
+ Selenium 3.141.0
+ Chromium 92.0.4512.0 版
+ **更新的项目依赖项**— 此运行时中唯一的新功能是更新的项目依赖项。
### syn-python-selenium-1.1
**主要依赖项**：
+ Python 3.8
+ Selenium 3.141.0
+ Chromium 83.0.4103.0 版
**功能：**
+ **自定义处理程序函数**— 您现在可以对金丝雀脚本使用自定义处理程序函数。之前的运行时要求脚本入口点包括 `.handler`。
您还可以将金丝雀脚本放在任何文件夹中，并将文件夹名称作为处理程序的一部分进行传递。例如，`MyFolder/MyScriptFile.functionname` 可以用作入口点。
+ **用于添加指标和步骤失败配置的配置选项**— 这些选项已在适用于 Node.js 金丝雀的运行时中提供。有关更多信息，请参阅 [SyntheticsConfiguration 类](CloudWatch_Synthetics_Canaries_Library_Python.md#CloudWatch_Synthetics_Library_SyntheticsConfiguration_Python)。
+ **Chrome 中的自定义参数**— 您现在可以用无痕模式打开浏览器或用代理服务器配置进行传递。有关更多信息，请参阅 [Chrome()](CloudWatch_Synthetics_Canaries_Library_Python.md#CloudWatch_Synthetics_Library_Python_Chrome)。
+ **跨区域构件存储桶**— 金丝雀可以将其构件存储在不同区域的 Simple Storage Service (Amazon S3) 存储桶中。
+ **错误修复，包括修复 `index.py` 问题**— 对于之前的运行时，名为 ` index.py` 的金丝雀文件导致异常，因为其与库文件的名称冲突。此问题现已修复。
### syn-python-selenium-1.0
**主要依赖项**：
+ Python 3.8
+ Selenium 3.141.0
+ Chromium 83.0.4103.0 版
**功能：**
+ **Selenium 支持** – 您可以使用 Selenium 测试框架编写金丝雀脚本。您可以将其他地方的 Selenium 脚本添加到 CloudWatch Synthetics 中，只需做出最少的更改，它们即可用于 AWS 服务。
# 使用 Node.js 的运行时版本
以下部分包含有关 CloudWatch Synthetics Node.js 运行时版本的信息。该运行时不包含任何浏览器或框架。
这些运行时版本的命名约定为 `syn-language -majorversion.minorversion`。
## syn-nodejs-4.1
**重要**
Synthetics `syn-nodejs-3.1` 及更高版本中，Synthetics 运行时将使用新的命名空间。请迁移金丝雀脚本以使用新的命名空间。在未来的版本中，旧命名空间将被弃用。
@amzn/synthetics-core → @aws/synthetics-core
**主要依赖项**：
+ AWS Lambda 运行时 Node.js 22.x
**syn-nodejs-4.1 中的变化**
+ 升级到 `fast-xml-parser` 5.5.7 以解决下列 CVE 问题：
+ CVE-2026-25128
+ CVE-2026-25896
+ CVE-2026-26278
+ CVE-2026-27942
+ CVE-2026-33036
## 先前的 Node.js 运行时版本
下列 Node.js 的早期运行时版本仍受支持。
### syn-nodejs-4.0
**主要依赖项**：
+ AWS Lambda 运行时 Node.js 22.x
**syn-nodejs-4.0 中的变化**
+ 应用了安全补丁。
### syn-nodejs-3.1
**重要**
Synthetics `syn-nodejs-3.1` 及更高版本中，Synthetics 运行时将使用新的命名空间。请迁移金丝雀脚本以使用新的命名空间。在未来的版本中，旧命名空间将被弃用。
@amzn/synthetics-core → @aws/synthetics-core
**主要依赖项**：
+ AWS Lambda 运行时 Node.js 20.x
**syn-nodejs-3.1 中的变化**
+ Synthetics 运行时命名空间迁移。
+ 类型定义在 [npm 注册表](https://www.npmjs.com/package/@aws/synthetics-core)中可用。请确保类型定义包的版本与您的金丝雀的运行时版本相匹配。
### syn-nodejs-3.0
**主要依赖项**：
+ AWS Lambda 运行时 Node.js 20.x
**syn-nodejs-3.0 中的变化**
+ 对多重检查蓝图的支持。
# 运行时版本支持策略
Synthetics 运行时版本受维护和安全更新的约束。如果不再支持运行时版本的任何组件，则该 Synthetics 运行时版本将被弃用。
您无法使用已弃用的运行时版本创建金丝雀。使用已弃用运行时的金丝雀将继续运行。您可以停止、启动和删除这些金丝雀。您可以通过将金丝雀更新为使用受支持的运行时版本，来更新使用已弃用运行时版本的现有金丝雀。
如果您有使用计划将在未来 60 天内弃用的运行时的金丝雀，则 CloudWatch Synthetics 会通过电子邮件通知您。我们建议您将金丝雀迁移到受支持的运行时版本，以享受最新版本中包含的新功能、安全性和性能增强的益处。
## CloudWatch Synthetics 运行时弃用日期
下表中列出了每个已弃用的 CloudWatch Synthetics 运行时的弃用日期。
| 运行时版本 | 弃用日期 |
| --- | --- |
| `syn-python-selenium-5.1` | 2026 年 2 月 3 日 |
| `syn-python-selenium-5.0` | 2026 年 2 月 3 日 |
| `syn-python-selenium-4.1` | 2026 年 2 月 3 日 |
| `syn-python-selenium-4.0` | 2026 年 2 月 3 日 |
| `syn-nodejs-puppeteer-7.0` | 2026 年 1 月 22 日 |
| `syn-nodejs-puppeteer-6.2` | 2026 年 1 月 22 日 |
| `syn-nodejs-puppeteer-5.2` | 2026 年 1 月 22 日 |
| `syn-python-selenium-3.0` | 2026 年 1 月 22 日 |
| `syn-python-selenium-2.1` | 2026 年 1 月 22 日 |
| `syn-nodejs-puppeteer-6.1` | 2024 年 3 月 8 日 |
| `syn-nodejs-puppeteer-6.0` | 2024 年 3 月 8 日 |
| `syn-nodejs-puppeteer-5.1` | 2024 年 3 月 8 日 |
| `syn-nodejs-puppeteer-5.0` | 2024 年 3 月 8 日 |
| `syn-nodejs-puppeteer-4.0` | 2024 年 3 月 8 日 |
| `syn-nodejs-puppeteer-3.9` | 2024 年 1 月 8 日 |
| `syn-nodejs-puppeteer-3.8` | 2024 年 1 月 8 日 |
| `syn-python-selenium-2.0` | 2024 年 3 月 8 日 |
| `syn-python-selenium-1.3` | 2024 年 3 月 8 日 |
| `syn-python-selenium-1.2` | 2024 年 3 月 8 日 |
| `syn-python-selenium-1.1` | 2024 年 3 月 8 日 |
| `syn-python-selenium-1.0` | 2024 年 3 月 8 日 |
| `syn-nodejs-puppeteer-3.7` | 2024 年 1 月 8 日 |
| `syn-nodejs-puppeteer-3.6` | 2024 年 1 月 8 日 |
| `syn-nodejs-puppeteer-3.5` | 2024 年 1 月 8 日 |
| `syn-nodejs-puppeteer-3.4` | 2022 年 11 月 13 日 |
| `syn-nodejs-puppeteer-3.3` | 2022 年 11 月 13 日 |
| `syn-nodejs-puppeteer-3.2` | 2022 年 11 月 13 日 |
| `syn-nodejs-puppeteer-3.1` | 2022 年 11 月 13 日 |
| `syn-nodejs-puppeteer-3.0` | 2022 年 11 月 13 日 |
| `syn-nodejs-2.2` | 2021 年 5 月 28 日 |
| `syn-nodejs-2.1` | 2021 年 5 月 28 日 |
| `syn-nodejs-2.0` | 2021 年 5 月 28 日 |
| `syn-nodejs-2.0-beta` | 2021 年 2 月 8 日 |
| `syn-1.0` | 2021 年 5 月 28 日 |
# 运行时版本更新
您可以使用 CloudWatch 控制台、AWS CloudFormation、AWS CLI 或 AWS SDK 更新金丝雀的运行时版本。当使用 CloudWatch 控制台更新时，您可以一次最多更新五个金丝雀，方法是在金丝雀列表页面中选中它们，然后选择**操作**、**更新运行时**。
在提交运行时更新之前，您可以先测试更新来验证其有效性。更新运行时版本时，请在 CloudWatch 控制台中选择**开始试运行**或**验证并稍后保存**选项，对原始金丝雀及其配置变更进行试运行测试。试运行会更新并执行金丝雀，验证运行时更新对金丝雀是否安全。在使用新的运行时版本验证金丝雀能正常工作后，您便可以更新金丝雀的运行时版本。有关更多信息，请参阅 [执行安全金丝雀更新](performing-safe-canary-upgrades.md)。
您也可以先使用 CloudWatch 控制台克隆金丝雀，然后更新其运行时版本，以此验证更新是否安全。这会再创建一个金丝雀，其是原始金丝雀的克隆。在使用新的运行时版本验证了金丝雀后，您便可以更新原始金丝雀的运行时版本并删除克隆金丝雀。
您还可以使用升级脚本更新多个金丝雀。有关更多信息，请参阅 [金丝雀运行时升级脚本](#CloudWatch_Synthetics_Canaries_upgrade_script)。
如果升级金丝雀失败，请参阅 [排查失败金丝雀的问题](CloudWatch_Synthetics_Canaries_Troubleshoot.md)。
## 金丝雀运行时升级脚本
若要将金丝雀脚本升级到支持的运行时版本，请使用以下脚本。
```
const AWS = require('aws-sdk');
// You need to configure your AWS credentials and Region.
// https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-region.html
const synthetics = new AWS.Synthetics();
const DEFAULT_OPTIONS = {
/**
* The number of canaries to upgrade during a single run of this script.
*/
count: 10,
/**
* No canaries are upgraded unless force is specified.
*/
force: false
};
/**
* The number of milliseconds to sleep between GetCanary calls when
* verifying that an update succeeded.
*/
const SLEEP_TIME = 5000;
(async () => {
try {
const options = getOptions();
const versions = await getRuntimeVersions();
const canaries = await getAllCanaries();
const upgrades = canaries
.filter(canary => !versions.isLatestVersion(canary.RuntimeVersion))
.map(canary => {
return {
Name: canary.Name,
FromVersion: canary.RuntimeVersion,
ToVersion: versions.getLatestVersion(canary.RuntimeVersion)
};
});
if (options.force) {
const promises = [];
for (const upgrade of upgrades.slice(0, options.count)) {
const promise = upgradeCanary(upgrade);
promises.push(promise);
// Sleep for 100 milliseconds to avoid throttling.
await usleep(100);
}
const succeeded = [];
const failed = [];
for (let i = 0; i < upgrades.slice(0, options.count).length; i++) {
const upgrade = upgrades[i];
const promise = promises[i];
try {
await promise;
console.log(`The update of ${upgrade.Name} succeeded.`);
succeeded.push(upgrade.Name);
} catch (e) {
console.log(`The update of ${upgrade.Name} failed with error: ${e}`);
failed.push({
Name: upgrade.Name,
Reason: e
});
}
}
if (succeeded.length) {
console.group('The following canaries were upgraded successfully.');
for (const name of succeeded) {
console.log(name);
}
console.groupEnd()
} else {
console.log('No canaries were upgraded successfully.');
}
if (failed.length) {
console.group('The following canaries were not upgraded successfully.');
for (const failure of failed) {
console.log('\x1b[31m', `${failure.Name}: ${failure.Reason}`, '\x1b[0m');
}
console.groupEnd();
}
} else {
console.log('Run with --force [--count ] to perform the first upgrades shown. The default value of is 10.')
console.table(upgrades);
}
} catch (e) {
console.error(e);
}
})();
function getOptions() {
const force = getFlag('--force', DEFAULT_OPTIONS.force);
const count = getOption('--count', DEFAULT_OPTIONS.count);
return { force, count };
function getFlag(key, defaultValue) {
return process.argv.includes(key) || defaultValue;
}
function getOption(key, defaultValue) {
const index = process.argv.indexOf(key);
if (index < 0) {
return defaultValue;
}
const value = process.argv[index + 1];
if (typeof value === 'undefined' || value.startsWith('-')) {
throw `The ${key} option requires a value.`;
}
return value;
}
}
function getAllCanaries() {
return new Promise((resolve, reject) => {
const canaries = [];
synthetics.describeCanaries().eachPage((err, data) => {
if (err) {
reject(err);
} else {
if (data === null) {
resolve(canaries);
} else {
canaries.push(...data.Canaries);
}
}
});
});
}
function getRuntimeVersions() {
return new Promise((resolve, reject) => {
const jsVersions = [];
const pythonVersions = [];
synthetics.describeRuntimeVersions().eachPage((err, data) => {
if (err) {
reject(err);
} else {
if (data === null) {
jsVersions.sort((a, b) => a.ReleaseDate - b.ReleaseDate);
pythonVersions.sort((a, b) => a.ReleaseDate - b.ReleaseDate);
resolve({
isLatestVersion(version) {
const latest = this.getLatestVersion(version);
return latest === version;
},
getLatestVersion(version) {
if (jsVersions.some(v => v.VersionName === version)) {
return jsVersions[jsVersions.length - 1].VersionName;
} else if (pythonVersions.some(v => v.VersionName === version)) {
return pythonVersions[pythonVersions.length - 1].VersionName;
} else {
throw Error(`Unknown version ${version}`);
}
}
});
} else {
for (const version of data.RuntimeVersions) {
if (version.VersionName === 'syn-1.0') {
jsVersions.push(version);
} else if (version.VersionName.startsWith('syn-nodejs-2.')) {
jsVersions.push(version);
} else if (version.VersionName.startsWith('syn-nodejs-puppeteer-')) {
jsVersions.push(version);
} else if (version.VersionName.startsWith('syn-python-selenium-')) {
pythonVersions.push(version);
} else {
throw Error(`Unknown version ${version.VersionName}`);
}
}
}
}
});
});
}
async function upgradeCanary(upgrade) {
console.log(`Upgrading canary ${upgrade.Name} from ${upgrade.FromVersion} to ${upgrade.ToVersion}`);
await synthetics.updateCanary({ Name: upgrade.Name, RuntimeVersion: upgrade.ToVersion }).promise();
while (true) {
await usleep(SLEEP_TIME);
console.log(`Getting the state of canary ${upgrade.Name}`);
const response = await synthetics.getCanary({ Name: upgrade.Name }).promise();
const state = response.Canary.Status.State;
console.log(`The state of canary ${upgrade.Name} is ${state}`);
if (state === 'ERROR' || response.Canary.Status.StateReason) {
throw response.Canary.Status.StateReason;
}
if (state !== 'UPDATING') {
return;
}
}
}
function usleep(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
```
# 编写金丝雀脚本
以下部分介绍了如何编写 Canary 脚本，以及如何将 Canary 与其他 AWS 服务及外部依赖项和库集成。
**Topics**
+ [使用 Java 运行时编写金丝雀脚本](Synthetics_WritingCanary_Java.md)
+ [使用 Playwright 运行时编写 Node.js Canary 脚本](Synthetics_WritingCanary_Nodejs_Playwright.md)
+ [使用 Puppeteer 运行时编写 Node.js Canary 脚本](CloudWatch_Synthetics_Canaries_WritingCanary_Nodejs_Pup.md)
+ [编写 Python 金丝雀脚本](CloudWatch_Synthetics_Canaries_WritingCanary_Python.md)
+ [为 Node.js 多重检查蓝图编写 JSON 配置](CloudWatch_Synthetics_WritingCanary_Multichecks.md)
# 使用 Java 运行时编写金丝雀脚本
**Topics**
+ [金丝雀的 Java 项目结构](#Synthetics_canary_Java_package)
+ [为金丝雀打包项目](#Synthetics_canary_Java_package_canary)
+ [处理程序名称](#Synthetics_canary_Java_handler)
+ [CloudWatch Synthetics 配置](#Synthetics_canary_Java_config)
+ [CloudWatch Synthetics 环境变量](#Synthetics_canary_Java_variables)
## 金丝雀的 Java 项目结构
若要使用 Java 创建金丝雀，您需要编写和编译代码，并将编译后的构件部署到 Synthetics。您可以通过多种方式初始化 Java Lambda 项目。例如，您可以在 IntelliJ IDEA 或 Visual Studio Code 等首选 IDE 中使用标准的 Java 项目设置。或者，您也可以手动创建所需的文件结构。
Synthetics Java 项目包含以下常规结构：
```
/project-root
└ src
└ main
└ java
└ canarypackage // name of package
| └ ExampleCanary.java // Canary code file
| └ other_supporting_classes
- resources
└ synthetics.json // Synthetics configuration file
└ build.gradle OR pom.xml
```
您可以使用 Maven 或 Gradle 来构建项目和管理依赖项。
在上面的结构中，`ExampleCanary` 类是金丝雀的入口点或处理程序。
**Java 金丝雀类示例**
此示例是让金丝雀向存储在 *TESTING\$1URL* Lambda 环境变量中的 URL 发出 GET 请求。该金丝雀不使用 Synthetics 运行时提供的任何方法。
```
package canarypackage;
import java.net.HttpURLConnection;
import java.net.URL;
// Handler value: canary.ExampleCanary::canaryCode
public class ExampleCanary {
public void canaryCode() throws Exception{
URL url = new URL(System.getenv("TESTING_URL"));
HttpURLConnection con=(HttpURLConnection)url.openConnection();
con.setRequestMethod("GET");
con.setConnectTimeout(5000);
con.setReadTimeout(5000);
int status=con.getResponseCode();
if(status!=200){
throw new Exception("Failed to load " + url + ", status code: " + status);
}
}
}
```
强烈建议使用 Synthetics 提供的库函数 `executeStep` 对该金丝雀进行模块化处理。该金丝雀会对从 URL1 和 URL2 环境变量获取的两个单独的 URL 进行 `get` 调用。
**注意**
要使用 `executeStep` 功能，金丝雀的处理程序方法应采用类型为 Synthetics 的参数，如下所示。
```
package canarypackage;
import com.amazonaws.synthetics.Synthetics;
import java.net.HttpURLConnection;
import java.net.URL;
// Handler value: canary.ExampleCanary::canaryCode
public class ExampleCanary {
public void canaryCode(Synthetics synthetics) throws Exception {
createStep("Step1", synthetics, System.getenv("URL1"));
createStep("Step2", synthetics, System.getenv("URL2"));
return;
}
private void createStep(String stepName, Synthetics synthetics, String url) throws Exception{
synthetics.executeStep(stepName,()->{
URL obj=new URL(url);
HttpURLConnection con=(HttpURLConnection)obj.openConnection();
con.setRequestMethod("GET");
con.setConnectTimeout(5000);
con.setReadTimeout(5000);
int status=con.getResponseCode();
if(status!=200){
throw new Exception("Failed to load" + url + "status code:" + status);
}
return null;
}).get();
}
}
```
## 为金丝雀打包项目
Synthetics 接受以 *zip* 格式打包的 Java 金丝雀代码。zip 文件包含金丝雀代码的类文件、任何第三方依赖项的 jar 和 Synthetics 配置文件。
Synthetics Java zip 包含以下常规结构。
```
example-canary
└ lib
| └ //third party dependency jars
└ java-canary.jar
└ synthetics.json
```
要根据上面的项目结构构建此 zip，您可以使用 gradle (build.gradle) 或 maven (pom.xml)。见下列。
有关 Synthetics 库的编译时依赖项或接口的信息，请参阅 [aws-aws-cloudwatch-synthetics-sdk-java](https://github.com/aws/aws-cloudwatch-synthetics-sdk-java/tree/main) 下的自述文件。
```
plugins {
id 'java'
}
repositories {
mavenCentral()
}
dependencies {
// Third party dependencies
// example: implementation 'software.amazon.awssdk:s3:2.31.9'
// Declares dependency on Synthetics interfaces for compiling only
// Refer https://github.com/aws/aws-cloudwatch-synthetics-sdk-java for building from source.
compileOnly 'software.amazon.synthetics:aws-cloudwatch-synthetics-sdk-java:1.0.0'}
test {
useJUnitPlatform()
}
// Build the zip to be used as Canary code.
task buildZip(type: Zip) {
archiveFileName.set("example-canary.zip")
destinationDirectory.set(file("$buildDir"))
from processResources
into('lib') {
from configurations.runtimeClasspath
from(tasks.named("jar"))
}
from "src/main/java/resources/synthetics.json"
doLast {
println "Artifact written to: ${archiveFile.get().asFile.absolutePath}"
}
}
java {
toolchain {
languageVersion = JavaLanguageVersion.of(21)
}
}
tasks.named("build") {
dependsOn "buildZip"
}
```
## 处理程序名称
处理程序名称是金丝雀的入口点。对于 Java 运行时，处理程序采用以下格式。
```
<>::<>
// for above code: canarypackage.ExampleCanary::canaryCode
```
## CloudWatch Synthetics 配置
您可以通过提供一个名为 `synthetics.json` 的可选 JSON 配置文件来配置 Synthetics Java 运行时的行为。此文件应打包到 zip 包的根目录中。尽管配置文件是可选的，但如果您未提供配置文件或缺少配置密钥，CloudWatch 将采用默认值。
以下是支持的配置值及其默认值。
```
{
"step": {
"stepSuccessMetric": true,
"stepDurationMetric": true,
"continueOnStepFailure": false,
"stepsReport": true
},
"logging": {
"logRequest": false,
"logResponse": false
},
"httpMetrics": {
"metric_2xx": true,
"metric_4xx": true,
"metric_5xx": true,
"aggregated2xxMetric": true,
"aggregated4xxMetric": true,
"aggregated5xxMetric": true
},
"canaryMetrics": {
"failedCanaryMetric": true,
"aggregatedFailedCanaryMetric": true
}
}
```
**步骤配置**
+ *continueOnStepFailure* – 确定是否即使步骤失败，脚本仍应继续。默认值为 false。
+ *stepSuccessMetric* – 确定是否发出步骤的 ` SuccessPercent` 指标。对于金丝雀运行，如果步骤成功，步骤的 `SuccessPercent` 指标为 *100*；如果步骤失败，则为 *0*。默认值为 *true*。
+ *stepDurationMetric* – 确定是否发出步骤的 *Duration* 指标。*Duration* 指标以步骤运行的持续时间（以毫秒为单位）发出。默认值为 *true*。
**日志记录配置**
适用于 CloudWatch Synthetics 生成的日志。控制请求和响应日志的详细程度。
+ *logRequest* – 指定是否将每个请求都记录在金丝雀日志中。默认值为 false。
+ *logResponse* – 指定是否将每个响应都记录在金丝雀日志中。默认值为 false。
**HTTP 指标配置**
与 CloudWatch Synthetics 针对此 Canary 发出的具有不同 HTTP 状态代码的网络请求数量相关的指标的配置。
+ *metric\$12xx* – 指定是否发出此金丝雀的 *2xx* 指标（含 CanaryName 维度）。默认值为 *true*。
+ *metric\$14xx* – 指定是否发出此金丝雀的 *4xx* 指标（含 CanaryName 维度）。默认值为 *true*。
+ *metric\$15xx* – 指定是否发出此金丝雀的 *5xx* 指标（含 CanaryName 维度）。默认值为 *true*。
+ *aggregated2xxMetric* – 指定是否发出此金丝雀的 *2xx* 指标（不含 CanaryName 维度）。默认值为 *true*。
+ *aggregated4xxMetric* – 指定是否发出此金丝雀的 *4xx* 指标（不含 CanaryName 维度）。默认值为 *true*。
+ *aggregated5xxMetric* – 指定是否发出此金丝雀的 *5xx* 指标（不含 CanaryName 维度）。默认值为 *true*。
**Canary 指标配置**
对 CloudWatch Synthetics 发出的其他指标的配置。
+ *failedCanaryMetric* – 网络访问分析器指定是否发出此金丝雀的 *Failed* 指标（含 CanaryName 维度）。默认值为 *true*。
+ *aggatedFailedCanaryMetric* – 指定是否发出此金丝雀的 *Failed* 指标（不含 CanaryName 维度）。默认值为 *true*。
## CloudWatch Synthetics 环境变量
您可以使用环境变量配置日志记录级别和格式。
**日志格式**
CloudWatch Synthetics Java 运行时会为每一次金丝雀运行创建 CloudWatch 日志。日志以 JSON 格式编写，便于查询。您还可以选择将日志格式更改为 *TEXT*。
+ *环境变量名称* – CW\$1SYNTHETICS\$1LOG\$1FORMAT
+ *支持的值* – JSON、TEXT
+ *默认值* – JSON
**日志级别**
+ *环境变量名称* – CW\$1SYNTHETICS\$1LOG\$1LEVEL
+ *支持的值* – TRACE、DEBUG、INFO、WARN、ERROR、FATAL
+ *默认值* – INFO
除了以上环境变量外，Java 运行时还会为函数添加一个默认环境变量 `AWS_LAMBDA-EXEC_WRAPPER`，并将其值设置为 `/opt/synthetics-otel-instrument`。此环境变量会修改函数用于遥测的启动行为。如果此环境变量已存在，则确保将其设置为所需值。
# 使用 Playwright 运行时编写 Node.js Canary 脚本
**Topics**
+ [将 Node.js Canary 文件打包用于 Playwright 运行时](#Synthetics_canary_Nodejs_Playwright_package)
+ [更改现有 Playwright 脚本以将其用作 CloudWatch Synthetics Canary](#CloudWatch_Synthetics_canary_edit_Playwright_script)
+ [CloudWatch Synthetics 配置](#Synthetics_canary_configure_Playwright_script)
## 将 Node.js Canary 文件打包用于 Playwright 运行时
Canary 脚本包含一个 `.js`（CommonJS 语法）或 `.mjs`（ES 语法）文件，其中包含您的 Synthetics 处理程序代码，以及代码所依赖的任何其他包和模块。以 ES（ECMAScript）格式创建的脚本应使用 .mjs 作为扩展名，或者包含一个设置了 "type": "module" 字段的 package.json 文件。与 Node.js Puppeteer 等其他运行时不同，您无需将脚本保存在特定的文件夹结构中。您可以直接打包脚本。使用您的首选 `zip` 实用工具创建一个 `.zip` 文件，并将处理程序文件置于根目录中。如果您的 Canary 脚本依赖未包含在 Synthetics 运行时中的其他包或模块，您可以将这些依赖项添加到 `.zip` 文件中。为此，您可以通过运行 `npm install` 命令将函数所需的库安装到 `node_modules` 目录中。以下示例 CLI 命令将创建名为 `my_deployment_package.zip` 的 `.zip` 文件，其中包含 `index.js` 或 `index.mjs` 文件（Synthetics 处理程序）及其依赖项。在示例中，您要使用 `npm` 程序包管理器来安装依赖项。
```
~/my_function
├── index.mjs
├── synthetics.json
├── myhelper-util.mjs
└── node_modules
├── mydependency
```
在根目录下创建一个包含您的项目文件夹内容的 `.zip` 文件。使用 `r`（递归）选项，如以下示例所示，确保 `zip` 压缩子文件夹。
```
zip -r my_deployment_package.zip .
```
添加 Synthetics 配置文件来配置 CloudWatch Synthetics 的行为。您可以创建 `synthetics.json` 文件并将其保存在与入口点或处理程序文件相同的路径下。
或者，您也可以将入口点文件存储在您选择的文件夹结构中。但是，请确保在您的处理程序名称中指定了文件夹路径。
**处理程序名称**
请务必将您的金丝雀脚本入口点（处理程序）设置为 ` myCanaryFilename.functionName`，以匹配脚本入口点的文件名。您也可以选择将 Canary 存储在单独的文件夹中，例如 ` myFolder/my_canary_filename.mjs`。如果将其存储在单独的文件夹中，请在脚本入口点中指定该路径，例如 ` myFolder/my_canary_filename.functionName`。
## 更改现有 Playwright 脚本以将其用作 CloudWatch Synthetics Canary
您可以编辑 Node.js 和 Playwright 的现有脚本以用作 Canary。有关 Playwright 的更多信息，请参阅 [Playwright 库](https://playwright.dev/docs/api/class-playwright)文档。
您可以使用保存在文件 ` exampleCanary.mjs` 中的以下 Playwright 脚本。
```
import { chromium } from 'playwright';
import { expect } from '@playwright/test';
const browser = await chromium.launch();
const page = await browser.newPage();
await page.goto('https://example.com', {timeout: 30000});
await page.screenshot({path: 'example-home.png'});
const title = await page.title();
expect(title).toEqual("Example Domain");
await browser.close();
```
执行以下步骤转换脚本：
1. 创建和导出 `handler` 函数。处理程序是脚本的入口点函数。您可以为处理程序函数选择任何名称，但脚本中使用的函数应与 Canary 处理程序中的函数相同。如果您的脚本名称为 `exampleCanary.mjs`，处理程序函数名称为 `myhandler`，则您的 Canary 处理程序命名为 `exampleCanary.myhandler`。在以下示例中，处理程序函数的名称为 `handler`。
```
exports.handler = async () => {
// Your script here
};
```
1. 将 `Synthetics Playwright module` 作为依赖项导入。
```
import { synthetics } from '@aws/synthetics-playwright';
```
1. 使用 Synthetics `Launch` 函数启动浏览器。
```
const browser = await synthetics.launch();
```
1. 使用 Synthetics `newPage` 函数创建新的 Playwright 页面。
```
const page = await synthetics.newPage();
```
您的脚本现已准备好作为 Synthetics Canary 运行。以下是更新的脚本：
**更新了 ES6 格式的脚本**
脚本文件以 `.mjs` 扩展名保存。
```
import { synthetics } from '@aws/synthetics-playwright';
import { expect } from '@playwright/test';
export const handler = async (event, context) => {
try {
// Launch a browser
const browser = await synthetics.launch();
// Create a new page
const page = await synthetics.newPage(browser);
// Navigate to a website
await page.goto('https://www.example.com', {timeout: 30000});
// Take screenshot
await page.screenshot({ path: '/tmp/example.png' });
// Verify the page title
const title = await page.title();
expect(title).toEqual("Example Domain");
} finally {
// Ensure browser is closed
await synthetics.close();
}
};
```
**更新的 CommonJS 格式的脚本**
脚本文件以 `.js` 扩展名保存。
```
const { synthetics } = require('@aws/synthetics-playwright');
const { expect } = require('@playwright/test');
exports.handler = async (event) => {
try {
const browser = await synthetics.launch();
const page = await synthetics.newPage(browser);
await page.goto('https://www.example.com', {timeout: 30000});
await page.screenshot({ path: '/tmp/example.png' });
const title = await page.title();
expect(title).toEqual("Example Domain");
} finally {
await synthetics.close();
}
};
```
## CloudWatch Synthetics 配置
您可以通过提供一个名为 `synthetics.json` 的可选 JSON 配置文件来配置 Synthetics Playwright 运行时的行为。此文件应与处理程序文件打包在相同的位置。尽管配置文件是可选的，但如果您未提供配置文件或缺少配置密钥，CloudWatch 将采用默认值。
**打包您的配置文件**
以下是支持的配置值及其默认值。
```
{
"step": {
"screenshotOnStepStart": false,
"screenshotOnStepSuccess": false,
"screenshotOnStepFailure": false,
"stepSuccessMetric": true,
"stepDurationMetric": true,
"continueOnStepFailure": true,
"stepsReport": true
},
"report": {
"includeRequestHeaders": true,
"includeResponseHeaders": true,
"includeUrlPassword": false,
"includeRequestBody": true,
"includeResponseBody": true,
"restrictedHeaders": ['x-amz-security-token', 'Authorization'], // Value of these headers is redacted from logs and reports
"restrictedUrlParameters": ['Session', 'SigninToken'] // Values of these url parameters are redacted from logs and reports
},
"logging": {
"logRequest": false,
"logResponse": false,
"logResponseBody": false,
"logRequestBody": false,
"logRequestHeaders": false,
"logResponseHeaders": false
},
"httpMetrics": {
"metric_2xx": true,
"metric_4xx": true,
"metric_5xx": true,
"failedRequestsMetric": true,
"aggregatedFailedRequestsMetric": true,
"aggregated2xxMetric": true,
"aggregated4xxMetric": true,
"aggregated5xxMetric": true
},
"canaryMetrics": {
"failedCanaryMetric": true,
"aggregatedFailedCanaryMetric": true
},
"userAgent": "",
"har": true
}
```
**步骤配置**
+ `screenshotOnStepStart` – 确定 Synthetics 是否应在步骤开始之前捕获屏幕截图。默认值为 `true`。
+ `screenshotOnStepSuccess` – 确定 Synthetics 是否应在步骤成功后捕获屏幕截图。默认值为 `true`。
+ `screenshotOnStepFailure` – 确定 Synthetics 是否应在步骤失败后捕获屏幕截图。默认值为 `true`。
+ `continueOnStepFailure` – 确定是否即使步骤失败，脚本仍应继续。默认值为 `false`。
+ `stepSuccessMetric` – 确定是否发出步骤的 ` SuccessPercent` 指标。对于 Canary 运行，如果步骤成功，步骤的 `SuccessPercent` 指标为 `100`，如果步骤失败，则为 `0`。默认值为 `true`。
+ `stepDurationMetric` – 确定是否发出步骤的 `Duration` 指标。`Duration` 指标以步骤运行的持续时间（以毫秒为单位）发出。默认值为 `true`。
**报告配置**
包括 CloudWatch Synthetics 生成的所有报告，例如 HAR 文件和 Synthetics 步骤报告。敏感数据编辑字段 `restrictedHeaders` 和 `restrictedUrlParameters` 也适用于 Synthetics 生成的日志。
+ `includeRequestHeaders` – 是否在报告中包含请求标头。默认值为 `false`。
+ `includeResponseHeaders` – 是否在报告中包含响应标头。默认值为 `false`。
+ `includeUrlPassword` – 是否包含 URL 中显示的密码。默认情况下，URL 中显示的密码会在日志和报告中进行编辑，以防泄露敏感数据。默认为 `false`。
+ `includeRequestBody` – 是否在报告中包含请求正文。默认值为 `false`。
+ `includeResponseBody` – 是否在报告中包含响应正文。默认值为 `false`。
+ `restrictedHeaders` – 要忽略的标头值列表（如果包含标头）。这对请求标头和响应标头均适用。例如，您可以通过将 `includeRequestHeaders` 传递为 true 并将 `restrictedHeaders` 传递为 `['Authorization']` 来隐藏您的凭证。
+ `restrictedUrlParameters` – 要编辑的 URL 路径或查询参数的列表。这适用于出现在日志、报告和错误中的 URL。此参数区分大小写。您可以传递星号 (`*`) 作为值来编辑所有 URL 路径和查询参数值。默认值为空数组。
+ `har` – 确定是否应生成 HTTP 存档（HAR）。默认值为 `true`。
下面是报告配置文件的示例：
```
"includeRequestHeaders": true,
"includeResponseHeaders": true,
"includeUrlPassword": false,
"includeRequestBody": true,
"includeResponseBody": true,
"restrictedHeaders": ['x-amz-security-token', 'Authorization'], // Value of these headers is redacted from logs and reports
"restrictedUrlParameters": ['Session', 'SigninToken'] // Values of these URL parameters are redacted from logs and reports
```
**日志记录配置**
适用于 CloudWatch Synthetics 生成的日志。控制请求和响应日志的详细程度。
+ `logRequest` – 是否将每个请求都记录在 Canary 日志中。对于 UI 金丝雀，这会记录浏览器发送的每个请求。默认值为 ` false`。
+ `logResponse` – 是否将每个响应都记录在 Canary 日志中。对于 UI 金丝雀，这会记录浏览器收到的每个响应。默认值为 ` false`。
+ `logRequestBody` – 是否随请求一起将请求正文记录在 Canary 日志中。仅当 `logRequest` 为 true 时，此配置才适用。默认值为 `false`。
+ `logResponseBody` – 是否随请求一起将响应正文记录在 Canary 日志中。仅当 `logResponse` 为 true 时，此配置才适用。默认值为 `false`。
+ `logRequestHeaders` – 是否随请求一起将请求标头记录在 Canary 日志中。仅当 ` logRequest` 为 true 时，此配置才适用。默认值为 `false`。
+ `logResponseHeaders` – 是否随响应一起将响应标头记录在 Canary 日志中。仅当 ` logResponse` 为 true 时，此配置才适用。默认值为 `false`。
**HTTP 指标配置**
与 CloudWatch Synthetics 针对此 Canary 发出的具有不同 HTTP 状态代码的网络请求数量相关的指标的配置。
+ `metric_2xx` – 是否发出此 Canary 的 `2xx` 指标（带 `CanaryName` 维度）。默认值为 ` true`。
+ `metric_4xx` – 是否发出此 Canary 的 `4xx` 指标（带 `CanaryName` 维度）。默认值为 ` true`。
+ `metric_5xx` – 是否发出此 Canary 的 `5xx` 指标（带 `CanaryName` 维度）。默认值为 ` true`。
+ `failedRequestsMetric` – 是否发出此 Canary 的 ` failedRequests` 指标（带 `CanaryName` 维度）。默认值为 `true`。
+ `aggregatedFailedRequestsMetric` – 是否发出此 Canary 的 ` failedRequests` 指标（不带 `CanaryName` 维度）。默认值为 `true`。
+ `aggregated2xxMetric` – 是否发出此 Canary 的 `2xx` 指标（不带 `CanaryName` 维度）。默认值为 `true`。
+ `aggregated4xxMetric` – 是否发出此 Canary 的 `4xx` 指标（不带 `CanaryName` 维度）。默认值为 `true`。
+ `aggregated5xxMetric` – 是否发出此 Canary 的 `5xx` 指标（不带 `CanaryName` 维度）。默认值为 `true`。
**Canary 指标配置**
对 CloudWatch Synthetics 发出的其他指标的配置。
+ `failedCanaryMetric` – 是否发出此 Canary 的 `Failed` 指标（带 `CanaryName` 维度）。默认值为 ` true`。
+ `aggregatedFailedCanaryMetric` – 是否发出此 Canary 的 ` Failed` 指标（不带 `CanaryName` 维度）。默认值为 `true`。
**其他配置**
+ `userAgent` – 要附加到用户代理的字符串。用户代理是一个包含在请求标头中的字符串，用于识别您在使用无外设浏览器时访问的网站的浏览器。CloudWatch Synthetics 会自动添加 `CloudWatchSynthetics/canary-arn to the user agent`。指定的配置将附加到生成的用户代理。要附加的默认用户代理值是空字符串 (`""`)。
### CloudWatch Synthetics 环境变量
使用环境变量配置日志记录级别和格式。
**日志格式**
CloudWatch Synthetics Playwright 运行时会为每一次 Canary 运行创建 CloudWatch 日志。日志以 JSON 格式编写，便于查询。您还可以将日志格式更改为 `TEXT`。
+ `Environment variable name` – CW\$1SYNTHETICS\$1LOG\$1FORMAT
+ `Supported values` – JSON、TEXT
+ `Default` – JSON
**日志级别**
尽管启用 `Debug` 模式会增加详细程度，但对于故障排除很有用。
+ `Environment variable name` – CW\$1SYNTHETICS\$1LOG\$1LEVEL
+ `Supported values` – TRACE、DEBUG、INFO、WARN、ERROR、FATAL
+ `Default` – INFO
# 使用 Puppeteer 运行时编写 Node.js Canary 脚本
**Topics**
+ [从 Scratch 创建 CloudWatch Synthetics 金丝雀](#CloudWatch_Synthetics_Canaries_write_from_scratch)
+ [将 Node.js 金丝雀文件打包](#CloudWatch_Synthetics_Canaries_package)
+ [更改现有 Puppeteer 脚本以将其用作 Synthetics 金丝雀](#CloudWatch_Synthetics_Canaries_modify_puppeteer_script)
+ [环境变量](#CloudWatch_Synthetics_Environment_Variables)
+ [将您的金丝雀与其他 AWS 服务集成](#CloudWatch_Synthetics_Canaries_AWS_integrate)
+ [强制金丝雀使用静态 IP 地址](#CloudWatch_Synthetics_Canaries_staticIP)
## 从 Scratch 创建 CloudWatch Synthetics 金丝雀
这里是一个极简 Synthetics 金丝雀脚本示例。此脚本将成功通过一次运行，并返回一个字符串。要查看失败的金丝雀示例，请将 `let fail = false;` 更改为 `let fail = true;`。
您必须为金丝雀脚本定义入口点函数。要查看如何将文件上传到指定作为 Canary 的 `ArtifactS3Location` 的 Amazon S3 位置，请在 `/tmp` 文件夹下创建这些文件。所有 Canary 构件都应存储在 `/tmp` 中，因为这是唯一可写入的目录。请务必将脚本创建的所有屏幕截图或其他文件的屏幕截图路径设置为 `/tmp`。Synthetics 会自动将 ` /tmp` 中的文件上传到 S3 存储桶。
```
/tmp/
```
脚本运行后，将“通过/失败”状态和持续时间指标发布到 CloudWatch，并将 `/tmp` 下的文件上传到 S3 存储桶。
```
const basicCustomEntryPoint = async function () {
// Insert your code here
// Perform multi-step pass/fail check
// Log decisions made and results to /tmp
// Be sure to wait for all your code paths to complete
// before returning control back to Synthetics.
// In that way, your canary will not finish and report success
// before your code has finished executing
// Throw to fail, return to succeed
let fail = false;
if (fail) {
throw "Failed basicCanary check.";
}
return "Successfully completed basicCanary checks.";
};
exports.handler = async () => {
return await basicCustomEntryPoint();
};
```
接下来，我们将扩展脚本以使用 Synthetics 日志记录并使用 AWS SDK 进行调用。出于演示目的，此脚本将创建 Amazon DynamoDB 客户端并调用 DynamoDB listTables API。它会记录对请求的响应，并根据请求是否成功来记录通过还是失败。
```
const log = require('@aws/synthetics-logger');
const AWS = require('aws-sdk');
// Require any dependencies that your script needs
// Bundle additional files and dependencies into a .zip file with folder structure
// nodejs/node_modules/additional files and folders
const basicCustomEntryPoint = async function () {
log.info("Starting DynamoDB:listTables canary.");
let dynamodb = new AWS.DynamoDB();
var params = {};
let request = await dynamodb.listTables(params);
try {
let response = await request.promise();
log.info("listTables response: " + JSON.stringify(response));
} catch (err) {
log.error("listTables error: " + JSON.stringify(err), err.stack);
throw err;
}
return "Successfully completed DynamoDB:listTables canary.";
};
exports.handler = async () => {
return await basicCustomEntryPoint();
};
```
## 将 Node.js 金丝雀文件打包
**对于 syn-nodejs-puppeteer-11.0 及以上版本**
较新版本仍然支持较旧的打包结构（适用于 syn-nodejs-puppeteer-10.0 及以下版本）。
使用以下某个选项创建脚本：
+ .js 文件（CommonJS 语法）
+ .mjs 文件（ES 模块语法）
对于 ES 模块，请使用以下某个选项：
+ .js 文件（CommonJS 语法）
+ .mjs 文件（ES 模块语法）
软件包结构定义如下：
+ 根级别处理程序文件（index.js/index.mjs）
+ 可选配置文件（synthetics.json）
+ node\$1modules 中的其他依赖项（如果需要）
打包结构示例：
```
my_function/
├── index.mjs
├── synthetics.json
├── helper-utils.mjs
└── node_modules/
└── dependencies
```
要进行打包，请按照以下步骤操作：
1. 安装依赖项（如有）。
```
npm install
```
1. 创建一个 .zip 包。
```
zip -r my_deployment_package.zip
```
**对于 syn-nodejs-puppeteer-11.0 及以下版本**
在使用 Amazon S3 时需要以下结构：
```
nodejs/
└── node_modules/
└── myCanaryFilename.js
```
**要在 syn-nodejs-puppeteer-3.4\$1 中添加可选的子文件夹支持：**
```
nodejs/
└── node_modules/
└── myFolder/
└── myCanaryFilename.js
```
**注意**
配置中的处理程序路径必须与文件位置匹配。
**处理程序名称**
请务必将您的金丝雀脚本入口点（处理程序）设置为 ` myCanaryFilename.functionName`，以匹配脚本入口点的文件名。如果您使用 `syn-nodejs-puppeteer-3.4` 之前版本的运行时，则 `functionName` 必须是 `handler`。如果您使用 ` syn-nodejs-puppeteer-3.4` 或之后版本，您可以选择任何函数名称作为处理程序。如果您使用 `syn-nodejs-puppeteer-3.4` 或之后版本，您也可以选择将金丝雀存储在单独的文件夹中，例如 ` nodejs/node_modules/myFolder/my_canary_filename`。如果将其存储在单独的文件夹中，请在脚本入口点中指定该路径，例如 ` myFolder/my_canary_filename.functionName`。
## 更改现有 Puppeteer 脚本以将其用作 Synthetics 金丝雀
本节介绍如何对 Puppeteer 脚本进行修改，以将其作为 Synthetics 金丝雀脚本运行。有关 Puppeteer 的更多信息，请参阅 [Puppeteer API v1.14.0](https://github.com/puppeteer/puppeteer/blob/v1.14.0/docs/api.md)。
我们从这个示例 Puppeteer 开始：
```
const puppeteer = require('puppeteer');
(async () => {
const browser = await puppeteer.launch();
const page = await browser.newPage();
await page.goto('https://example.com');
await page.screenshot({path: 'example.png'});
await browser.close();
})();
```
转换步骤如下：
+ 创建和导出 `handler` 函数。处理程序是脚本的入口点函数。如果您使用 ` syn-nodejs-puppeteer-3.4` 之前版本的运行时，处理程序函数必须命名为 `handler`。如果您使用 `syn-nodejs-puppeteer-3.4` 或之后版本，函数可以有任何名称，但必须与脚本中使用的名称相同。此外，如果您使用 `syn-nodejs-puppeteer-3.4` 或之后版本，您可以将脚本存储在任何文件夹下，并将该文件夹指定为处理程序名称的一部分。
```
const basicPuppeteerExample = async function () {};
exports.handler = async () => {
return await basicPuppeteerExample();
};
```
+ 使用 `Synthetics` 依赖项。
```
var synthetics = require('@aws/synthetics-puppeteer');
```
+ 使用 `Synthetics.getPage` 函数获取 Puppeteer `Page` 对象。
```
const page = await synthetics.getPage();
```
Synthetics.getPage 函数返回的页面对象指示需要记录 **page.on** `request`、`response` 和 ` requestfailed` 事件。Synthetics 还为页面上的请求和响应设置 HAR 文件生成，并将金丝雀 ARN 添加到页面上的传出请求的 user-agent 标头。
该脚本现已准备好作为 Synthetics 金丝雀运行。更新的脚本如下：
```
var synthetics = require('@aws/synthetics-puppeteer'); // Synthetics dependency
const basicPuppeteerExample = async function () {
const page = await synthetics.getPage(); // Get instrumented page from Synthetics
await page.goto('https://example.com');
await page.screenshot({path: '/tmp/example.png'}); // Write screenshot to /tmp folder
};
exports.handler = async () => { // Exported handler function
return await basicPuppeteerExample();
};
```
## 环境变量
您可以在创建金丝雀时使用环境变量。这样，您就能够编写单个金丝雀脚本，然后将该脚本与不同的值相结合，快速创建具有类似任务的多个金丝雀。
例如，假定您的企业具有用于不同软件开发阶段的 `prod`、` dev` 和 `pre-release` 端点，而您需要创建金丝雀来测试其中每个端点。您可以编写一个测试软件的金丝雀脚本，然后在分别创建三个金丝雀时为端点环境变量指定不同的值。之后，在创建金丝雀时，您可以指定要用于环境变量的脚本和值。
环境变量的名称可以包含字母、数字和下划线字符，必须以字母开头，并且至少为两个字符。环境变量的总大小不能超过 4 KB。不能将任何 Lambda 预留环境变量指定为环境变量的名称。有关预留环境变量的更多信息，请参阅[运行时环境变量](https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html#configuration-envvars-runtime)。
**重要**
使用 AWS 自有 AWS KMS 密钥对环境变量密钥和值进行静态加密。但是，并未在客户端对环境变量进行加密。请勿在其中存储敏感信息。
下面的示例脚本使用两个环境变量。此脚本用于检查网页是否可用的金丝雀。该金丝雀使用环境变量来参数化所检查的 URL 和所使用的 CloudWatch Synthetics 日志级别。
以下函数将 `LogLevel` 设置为 ` LOG_LEVEL` 环境变量的值。
```
synthetics.setLogLevel(process.env.LOG_LEVEL);
```
此函数将 `URL` 设置为 `URL` 环境变量的值。
```
const URL = process.env.URL;
```
以下是完整的脚本。当您使用此脚本创建金丝雀时，您可以指定 `LOG_LEVEL` 和 `URL` 环境变量的值。
```
var synthetics = require('@aws/synthetics-puppeteer');
const log = require('@aws/synthetics-logger');
const pageLoadEnvironmentVariable = async function () {
// Setting the log level (0-3)
synthetics.setLogLevel(process.env.LOG_LEVEL);
// INSERT URL here
const URL = process.env.URL;
let page = await synthetics.getPage();
//You can customize the wait condition here. For instance,
//using 'networkidle2' may be less restrictive.
const response = await page.goto(URL, {waitUntil: 'domcontentloaded', timeout: 30000});
if (!response) {
throw "Failed to load page!";
}
//Wait for page to render.
//Increase or decrease wait time based on endpoint being monitored.
await page.waitFor(15000);
await synthetics.takeScreenshot('loaded', 'loaded');
let pageTitle = await page.title();
log.info('Page title: ' + pageTitle);
log.debug('Environment variable:' + process.env.URL);
//If the response status code is not a 2xx success code
if (response.status() < 200 || response.status() > 299) {
throw "Failed to load page!";
}
};
exports.handler = async () => {
return await pageLoadEnvironmentVariable();
};
```
### 将环境变量传递到脚本
要在控制台中创建金丝雀时将环境变量传递给脚本，请在控制台上的 **Environment variables（环境变量）**部分指定环境变量的密钥和值。有关更多信息，请参阅 [创建金丝雀](CloudWatch_Synthetics_Canaries_Create.md)。
要通过 API 或 AWS CLI 传递环境变量，请使用 `RunConfig` 部分中的 ` EnvironmentVariables` 参数。以下为 AWS CLI 命令示例，该命令创建一个使用两个环境变量（具有 `Environment` 和 `Region` 密钥）的金丝雀。
```
aws synthetics create-canary --cli-input-json '{
"Name":"nameofCanary",
"ExecutionRoleArn":"roleArn",
"ArtifactS3Location":"s3://amzn-s3-demo-bucket-123456789012-us-west-2",
"Schedule":{
"Expression":"rate(0 minute)",
"DurationInSeconds":604800
},
"Code":{
"S3Bucket": "canarycreation",
"S3Key": "cwsyn-mycanaryheartbeat-12345678-d1bd-1234-abcd-123456789012-12345678-6a1f-47c3-b291-123456789012.zip",
"Handler":"pageLoadBlueprint.handler"
},
"RunConfig": {
"TimeoutInSeconds":60,
"EnvironmentVariables": {
"Environment":"Production",
"Region": "us-west-1"
}
},
"SuccessRetentionPeriodInDays":13,
"FailureRetentionPeriodInDays":13,
"RuntimeVersion":"syn-nodejs-2.0"
}'
```
## 将您的金丝雀与其他 AWS 服务集成
所有金丝雀都可以使用 AWS SDK 库。在编写金丝雀时，您可以使用此库将金丝雀与其他 AWS 服务集成。
为此，您需要将以下代码添加到您的金丝雀中。对于这些例子，AWS Secrets Manager 用作与金丝雀集成的服务。
+ 导入 AWS SDK。
```
const AWS = require('aws-sdk');
```
+ 为要集成的 AWS 服务创建客户端。
```
const secretsManager = new AWS.SecretsManager();
```
+ 使用客户端对该服务进行 API 调用。
```
var params = {
SecretId: secretName
};
return await secretsManager.getSecretValue(params).promise();
```
下面的金丝雀脚本代码段更详细地演示了与 Secrets Manager 集成的示例。
```
var synthetics = require('@aws/synthetics-puppeteer');
const log = require('@aws/synthetics-logger');
const AWS = require('aws-sdk');
const secretsManager = new AWS.SecretsManager();
const getSecrets = async (secretName) => {
var params = {
SecretId: secretName
};
return await secretsManager.getSecretValue(params).promise();
}
const secretsExample = async function () {
let URL = "";
let page = await synthetics.getPage();
log.info(`Navigating to URL: ${URL}`);
const response = await page.goto(URL, {waitUntil: 'domcontentloaded', timeout: 30000});
// Fetch secrets
let secrets = await getSecrets("secretname")
/**
* Use secrets to login.
*
* Assuming secrets are stored in a JSON format like:
* {
* "username": "",
* "password": ""
* }
**/
let secretsObj = JSON.parse(secrets.SecretString);
await synthetics.executeStep('login', async function () {
await page.type(">USERNAME-INPUT-SELECTOR<", secretsObj.username);
await page.type(">PASSWORD-INPUT-SELECTOR<", secretsObj.password);
await Promise.all([
page.waitForNavigation({ timeout: 30000 }),
await page.click(">SUBMIT-BUTTON-SELECTOR<")
]);
});
// Verify login was successful
await synthetics.executeStep('verify', async function () {
await page.waitForXPath(">SELECTOR<", { timeout: 30000 });
});
};
exports.handler = async () => {
return await secretsExample();
};
```
## 强制金丝雀使用静态 IP 地址
您可以设置金丝雀，使其使用静态 IP 地址。
**强制金丝雀使用静态 IP 地址**
1. 创建新的 VPC。有关更多信息，请参阅[在您的 VPC 中使用 DNS](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html)。
1. 创建新的互联网网关。有关更多信息，请参阅[在您的 VPC 中添加互联网网关](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Internet_Gateway.html#working-with-igw)。
1. 在新的 VPC 内创建公有子网。
1. 向 VPC 添加新的路由表。
1. 在新路由表中添加一条从 `0.0.0.0/0` 到互联网网关的路由。
1. 将新的路由表与公有子网关联。
1. 创建弹性 IP 地址。有关更多信息，请参阅[弹性 IP 地址](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html)。
1. 创建一个新的 NAT 网关，并将其分配给公有子网和弹性 IP 地址。
1. 在 VPC 中创建私有子网。
1. 向 VPC 默认路由表中添加一条从 `0.0.0.0/0` 到 NAT 网关的路由
1. 创建金丝雀。
# 编写 Python 金丝雀脚本
此脚本将成功通过一次运行，并返回一个字符串。要查看失败的金丝雀示例，请将 fail = False 更改为 fail = True
```
def basic_custom_script():
# Insert your code here
# Perform multi-step pass/fail check
# Log decisions made and results to /tmp
# Be sure to wait for all your code paths to complete
# before returning control back to Synthetics.
# In that way, your canary will not finish and report success
# before your code has finished executing
fail = False
if fail:
raise Exception("Failed basicCanary check.")
return "Successfully completed basicCanary checks."
def handler(event, context):
return basic_custom_script()
```
## 将 Python 金丝雀文件打包
如果您有多个 .py 文件或脚本具有依赖项，则您可以将它们捆绑到单个 ZIP 格式文件中。如果您使用 `syn-python-selenium-1.1` 运行时，此 ZIP 格式文件必须将主金丝雀 .py 文件包含在 `python` 文件夹中，例如 `python/my_canary_filename.py`。如果您使用 ` syn-python-selenium-1.1` 或之后版本，您可以选择使用其他文件夹，例如 `python/myFolder/my_canary_filename.py`。
此 ZIP 格式文件应包含所有必要的文件夹和文件，但其他文件不需要位于 `python` 文件夹中。
请务必将您的金丝雀脚本入口点设置为 ` my_canary_filename.functionName`，以匹配脚本入口点的文件名和函数名称。如果您使用 `syn-python-selenium-1.0` 运行时，则 `functionName` 必须是 `handler`。如果您使用 ` syn-python-selenium-1.1` 或之后版本，该处理程序名称限制不适用，您也可以选择将金丝雀存储在单独的文件夹中，例如 ` python/myFolder/my_canary_filename.py`。如果将其存储在单独的文件夹中，请在脚本入口点中指定该路径，例如 ` myFolder/my_canary_filename.functionName`。
## 更改现有 Puppeteer 脚本以使用 Synthetics 金丝雀
您可以快速修改用于 Python 和 Selenium 的现有脚本以用作金丝雀。有关 Selenium 的更多信息，请参阅 [www.selenium.dev/](https://www.selenium.dev/)。
在本示例中，将从以下 Selenium 脚本开始：
```
from selenium import webdriver
def basic_selenium_script():
browser = webdriver.Chrome()
browser.get('https://example.com')
browser.save_screenshot('loaded.png')
basic_selenium_script()
```
转换步骤如下。
**转换 Selenium 脚本以用作金丝雀**
1. 更改 `import` 语句以使用 ` aws_synthetics` 模块中的 Selenium：
```
from aws_synthetics.selenium import synthetics_webdriver as webdriver
```
`aws_synthetics` 模块中的 Selenium 确保金丝雀可以发出指标和日志、生成 HAR 文件及使用其他 CloudWatch Synthetics 功能。
1. 创建一个处理程序函数并调用您的 Selenium 方法。处理程序是脚本的入口点函数。
如果您使用 `syn-python-selenium-1.0`，处理程序函数必须命名为 `handler`。如果您使用 `syn-python-selenium-1.1` 或之后版本，函数可以有任何名称，但必须与脚本中使用的名称相同。此外，如果您使用 `syn-python-selenium-1.1` 或之后版本，您可以将脚本存储在任何文件夹下，并将该文件夹指定为处理程序名称的一部分。
```
def handler(event, context):
basic_selenium_script()
```
脚本现已更新为 CloudWatch Synthetics 金丝雀。更新的脚本如下：
`webdriver` 是 [SyntheticsWebDriver](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Synthetics_Canaries_Library_Python.html#CloudWatch_Synthetics_Library_Python_SyntheticsWebDriver) 类的实例，而由 `webdriver.Chrome()` 返回的浏览器则是 [SyntheticsBrowser](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Synthetics_Canaries_Library_Python.html#CloudWatch_Synthetics_Library_Python_SyntheticsBrowser) 类的实例。
```
from aws_synthetics.selenium import synthetics_webdriver as webdriver
def basic_selenium_script():
browser = webdriver.Chrome()
browser.get('https://example.com')
browser.save_screenshot('loaded.png')
def handler(event, context):
basic_selenium_script()
```
## 更改现有的 Puppeteer Synthetics 脚本以验证非标准证书
Synthetics Canary 的一个重要用例是让您监测自己的端点。如果您想监测尚未准备好接收外部流量的端点，这种监测有时可能意味着您尚未拥有由可信的第三方证书颁发机构签署的正确证书。
对于这种情况，有如下两种可能的解决方案：
+ 要对客户端证书进行身份验证，请参阅 [How to validate authentication using Amazon CloudWatch Synthetics – Part 2](https://aws.amazon.com/blogs/mt/how-to-validate-authentication-using-amazon-cloudwatch-synthetics-part-2/)。
+ 要对自签名证书进行身份验证，请参阅 [ How to validate authentication with self-signed certificates in Amazon CloudWatch Synthetics](https://aws.amazon.com/blogs/mt/how-to-validate-authentication-with-self-signed-certificates-in-amazon-cloudwatch-synthetics/)
使用 CloudWatch Synthetics Canary 时，您的选择并不局限于以上两种。您可以通过扩展 Canary 代码来扩展这些功能并添加业务逻辑。
**注意**
在 Python 运行时上运行的 Synthetics Canary 本身就启用了 ` --ignore-certificate-errors` 标志，因此这些 Canary 在访问具有非标准证书配置的网站时，不应出现任何问题。
# 为 Node.js 多重检查蓝图编写 JSON 配置
借助 Node.js 多重检查蓝图，您可以创建可在单次金丝雀运行中执行多项验证检查的金丝雀。当您想要测试多个端点、验证应用程序的不同方面，或按顺序执行一系列相关检查时，此蓝图非常有用。
**Topics**
+ [根配置结构](#root-configuration-structure)
+ [全局设置](#global-settings)
+ [变量和数据管理](#variables-data-management)
+ [步骤定义](#step-definitions)
+ [检查类型](#check-types)
+ [身份验证方法](#authentication-methods)
+ [断言与验证](#assertions-validation)
+ [数据提取](#data-extraction)
## 根配置结构
根配置定义了高级 API 蓝图金丝雀的整体结构。
**架构属性**
| 属性 | Type | 必需 | 说明 |
| --- | --- | --- | --- |
| globalSettings | 对象 | 否 | 应用于所有步骤的默认配置 |
| variables | 对象 | 否 | 跨步骤（最多 10 个）可重复使用的值 |
| steps | 对象 | 是 | 监控步骤集合（1-10 个步骤） |
**示例**
```
{
"globalSettings": {
"stepTimeout": 30000,
"userAgent": "CloudWatch-Synthetics-Advanced/1.0"
},
"variables": {
"baseUrl": "https://api.example.com",
"apiVersion": "v1"
},
"steps": {
"1": {
"stepName": "healthCheck",
"checkerType": "HTTP",
"url": "${baseUrl}/health",
"httpMethod": "GET"
}
}
}
```
**验证规则**
+ 必须包含至少一个步骤
+ 最多允许 10 个步骤
+ 除 `globalSettings`、` variables` 和 `steps` 外，不允许使用其他属性
## 全局设置
全局设置提供了应用于所有步骤的默认配置，除非在步骤级别被覆盖。
**属性**
**全局设置属性**
| 属性 | Type | 默认 | Range | 说明 |
| --- | --- | --- | --- | --- |
| stepTimeout | 整数 | 30000 | 5000-300000 | 所有步骤的默认超时（毫秒） |
**示例**
```
{
"globalSettings": {
"stepTimeout": 60000,
}
}
```
## 变量和数据管理
通过变量，您可以定义可重复使用的值，并在整个配置中使用 `${variableName}` 语法来引用它们。
**变量属性**
| 属性 | Type | 说明 |
| --- | --- | --- |
| 变量名称 | 字符串 | 必须匹配模式 ^[a-zA-Z][a-zA-Z0-9\$1]\$1\$1 |
| 变量值 | 字符串 | 任意字符串值 |
**限制**
+ 每个配置最多 10 个变量
+ 变量名称必须以字母开头
+ 变量名称只能包含字母、数字和下划线
+ 架构中未指定最大长度
**示例**
```
{
"variables": {
"baseUrl": "https://api.example.com",
"apiKey": "${AWS_SECRET:my-api-key}",
"timeout": "30000",
"userEmail": "test@example.com"
}
}
```
**配置使用**
```
{
"steps": {
"1": {
"url": "${baseUrl}/users",
"timeout": "${timeout}",
"headers": {
"Authorization": "Bearer ${apiKey}"
}
}
}
}
```
## 步骤定义
步骤定义了单独的监控操作。每个步骤从 1 到 10 编号，包含特定类型的检查。
*常用步骤属性*
| 属性 | Type | 必需 | 描述 |
| --- | --- | --- | --- |
| stepName | 字符串 | 是 | 步骤的唯一标识符 |
| checkerType | 字符串 | 是 | 检查类型：HTTP、DNS、SSL、 TCP |
| extractors | array | 否 | 数据提取配置 |
*步骤名称验证*
+ 模式：^[a-zA-Z][a-zA-Z0-9\$1-]\$1\$1
+ 最大长度：64 个字符
+ 必须以字母开头
*步骤编号*
+ 步骤以字符串键的形式编号：“1”、“2”、...、“10”
+ 模式：^([1-9]\$110)\$1
+ 至少需要 1 个步骤
+ 最多允许 10 个步骤
*示例*
```
{
"steps": {
"1": {
"stepName": "loginAPI",
"checkerType": "HTTP",
"url": "https://api.example.com/login",
"httpMethod": "POST"
},
"2": {
"stepName": "dnsCheck",
"checkerType": "DNS",
"domain": "example.com"
}
}
}
```
## 检查类型
### HTTP 检查
通过全面的请求和响应验证来监控 Web 端点和 API。
**必需属性**
| 属性 | Type | 说明 |
| --- | --- | --- |
| url | 字符串 | 目标 URL（必须是有效的 URI 格式） |
| httpMethod | 字符串 | HTTP 方法：GET、POST、PUT、 PATCH、DELETE、HEAD、OPTIONS |
**可选属性**
| 属性 | Type | 默认 | Range | 说明 |
| --- | --- | --- | --- | --- |
| timeout | 整数 | 30000 | 5000-300000 | 请求超时（毫秒） |
| waitTime | 整数 | 0 | 0-60 | 请求前的延迟（秒） |
| headers | object | - | - | 自定义 HTTP 标头 |
| body | 字符串 | - | - | 用于 POST/PUT 操作的请求正文 |
| authentication | object | - | - | 身份验证配置 |
| assertions | array | - | - | 响应验证规则 |
**示例**
```
{
"stepName": "createUser",
"checkerType": "HTTP",
"url": "https://api.example.com/users",
"httpMethod": "POST",
"timeout": 15000,
"headers": {
"Content-Type": "application/json",
"X-API-Version": "v1"
},
"body": "{\"name\":\"John Doe\",\"email\":\"john@example.com\"}",
"authentication": {
"type": "API_KEY",
"apiKey": "${AWS_SECRET:api-credentials}",
"headerName": "X-API-Key"
},
"assertions": [
{
"type": "STATUS_CODE",
"operator": "EQUALS",
"value": 201
}
]
}
```
### DNS 检查
验证 DNS 解析并记录信息。
**必需属性**
| 属性 | Type | 说明 |
| --- | --- | --- |
| domain | 字符串 | 要查询的域名（主机名格式） |
**可选属性**
| 属性 | Type | 默认值 | 说明 |
| --- | --- | --- | --- |
| recordType | 字符串 | “A” | DNS 记录类型：A、CNAME、MX、 TXT、NS |
| nameserver | 字符串 | - | 要查询的特定 DNS 服务器 |
| timeout | 整数 | 30000 | 查询超时（5000-300000 毫秒） |
| port | 整数 | 53 | DNS 服务器端口（1-65535） |
| protocol | 字符串 | “UDP” | 协议：UDP 或 TCP |
| assertions | array | - | DNS 响应验证规则 |
**示例**
```
{
"stepName": "dnsResolution",
"checkerType": "DNS",
"domain": "example.com",
"recordType": "A",
"nameserver": "8.8.8.8",
"timeout": 10000,
"assertions": [
{
"type": "RECORD_VALUE",
"operator": "CONTAINS",
"value": "192.168"
}
]
}
```
### SSL 检查
监控 SSL 证书的运行状况和配置。
**必需属性**
| 属性 | Type | 说明 |
| --- | --- | --- |
| hostname | 字符串 | 目标主机名（主机名格式） |
**可选属性**
| 属性 | Type | 默认值 | 描述 |
| --- | --- | --- | --- |
| port | 整数 | 443 | SSL 端口（1-65535） |
| timeout | 整数 | 30000 | 连接超时（5000-300000 毫秒） |
| sni | 布尔值 | TRUE | 服务器名称指示 |
| verifyHostname | 布尔值 | TRUE | 主机名验证 |
| allowSelfSigned | 布尔值 | FALSE | 接受自签名证书 |
| assertions | array | - | 证书验证规则 |
**示例**
```
{
"stepName": "sslCertCheck",
"checkerType": "SSL",
"hostname": "secure.example.com",
"port": 443,
"sni": true,
"verifyHostname": true,
"assertions": [
{
"type": "CERTIFICATE_EXPIRY",
"operator": "GREATER_THAN",
"value": 30,
"unit": "DAYS"
}
]
}
```
### TCP 检查
测试 TCP 端口连接性和响应验证。
**必需属性**
| 属性 | Type | 说明 |
| --- | --- | --- |
| hostname | 字符串 | 目标主机名（主机名格式） |
| port | 整数 | 目标端口（1-65535） |
**可选属性**
| 属性 | Type | 默认值 | 描述 |
| --- | --- | --- | --- |
| timeout | 整数 | 30000 | 总超时（5000-300000 毫秒） |
| connectionTimeout | 整数 | 3000 | 连接超时（5000-300000 毫秒） |
| readTimeout | 整数 | 2000 | 数据读取超时（5000-300000 毫秒） |
| sendData | 字符串 | - | 连接后要发送的数据 |
| expectedResponse | 字符串 | - | 预期响应数据 |
| encoding | 字符串 | “UTF-8” | 数据编码：UTF-8、ASCII、HEX |
| assertions | array | - | 连接和响应验证 |
**示例**
```
{
"stepName": "databaseConnection",
"checkerType": "TCP",
"hostname": "db.example.com",
"port": 3306,
"connectionTimeout": 5000,
"sendData": "SELECT 1",
"expectedResponse": "1",
"assertions": [
{
"type": "CONNECTION_SUCCESSFUL",
"value": true
}
]
}
```
## 身份验证方法
**不使用身份验证**
```
{
"type": "NONE"
}
```
**基本身份验证**
| 属性 | Type | 必需 | 描述 |
| --- | --- | --- | --- |
| type | 字符串 | 是 | 必须是 "BASIC" |
| username | 字符串 | 是 | 用于身份验证的用户名 |
| password | 字符串 | 是 | 用于身份验证的密码 |
**示例**
```
{
"type": "BASIC",
"username": "admin",
"password": "${AWS_SECRET:basic-auth:password}"
}
```
**API 密钥身份验证**
| 属性 | Type | 必需 | 默认值 | 说明 |
| --- | --- | --- | --- | --- |
| type | 字符串 | 是 | - | 必须是 "API\$1KEY" |
| apiKey | 字符串 | 是 | - | API 密钥值 |
| headerName | 字符串 | 否 | “X-API-Key” | API 密钥的标头名称 |
**示例**
```
{
"type": "API_KEY",
"apiKey": "${AWS_SECRET:api-credentials}",
"headerName": "Authorization"
}
```
**OAuth 客户端凭证**
| 属性 | Type | 必需 | 默认值 | 说明 |
| --- | --- | --- | --- | --- |
| type | 字符串 | 是 | - | 必须是 "OAUTH\$1CLIENT\$1CREDENTIALS" |
| tokenUrl | 字符串 | 是 | - | OAuth 令牌端点 URL |
| clientId | 字符串 | 是 | - | OAuth 客户端 ID |
| clientSecret | 字符串 | 是 | - | OAuth 客户端密钥 |
| scope | 字符串 | 否 | - | OAuth 范围 |
| audience | 字符串 | 否 | - | OAuth 受众 |
| resource | 字符串 | 否 | - | OAuth 资源 |
| tokenApiAuth | array | 否 | - | 令牌 API 身份验证方法：BASIC\$1AUTH\$1HEADER、REQUEST\$1BODY |
| tokenCacheTtl | 整数 | 否 | 3600 | 令牌缓存 TTL（至少 60 秒） |
**示例**
```
{
"type": "OAUTH_CLIENT_CREDENTIALS",
"tokenUrl": "https://auth.example.com/oauth/token",
"clientId": "${AWS_SECRET:oauth-creds:client_id}",
"clientSecret": "${AWS_SECRET:oauth-creds:client_secret}",
"scope": "read write",
"tokenCacheTtl": 7200
}
```
**AWS 签名（版本 4）**
| 属性 | Type | 必需 | 描述 |
| --- | --- | --- | --- |
| type | 字符串 | 是 | 必须是 "SIGV4" |
| service | 字符串 | 是 | AWS 服务的名称（例如“execute-api”） |
| region | 字符串 | 是 | AWS 区域 |
| roleArn | 字符串 | 是 | 用于签名的 IAM 角色 ARN |
**示例**
```
{
"type": "SIGV4",
"service": "execute-api",
"region": "us-east-1",
"roleArn": "arn:aws:iam::123456789012:role/SyntheticsRole"
}
```
## 断言与验证
### HTTP 断言
**状态代码断言**
| 属性 | Type | 必需 | 描述 |
| --- | --- | --- | --- |
| type | 字符串 | 是 | 必须是 "STATUS\$1CODE" |
| operator | 字符串 | 是 | EQUALS, NOT\$1EQUALS, GREATER\$1THAN, LESS\$1THAN, IN\$1RANGE |
| value | 整数 | 有条件 | HTTP 状态代码（100-599） |
| rangeMin | 整数 | 有条件 | 最小范围值（适用于 IN\$1RANGE） |
| rangeMax | 整数 | 有条件 | 最大范围值（适用于 IN\$1RANGE） |
```
{
"type": "STATUS_CODE",
"operator": "EQUALS",
"value": 200
}
```
**响应时间断言**
| 属性 | Type | 必需 | 默认值 | 说明 |
| --- | --- | --- | --- | --- |
| type | 字符串 | 是 | - | 必须是 "RESPONSE\$1TIME" |
| operator | 字符串 | 是 | - | LESS\$1THAN, GREATER\$1THAN, EQUALS |
| value | 数字 | 是 | - | 时间值（最小 0） |
| unit | 字符串 | 否 | “MILLISECONDS” | 必须是 "MILLISECONDS" |
```
{
"type": "RESPONSE_TIME",
"operator": "LESS_THAN",
"value": 500,
"unit": "MILLISECONDS"
}
```
**标头断言**
| 属性 | Type | 必需 | 描述 |
| --- | --- | --- | --- |
| type | 字符串 | 是 | 必须是 "HEADER" |
| headerName | 字符串 | 是 | 要验证的标头名称 |
| operator | 字符串 | 是 | EQUALS, NOT\$1EQUALS, CONTAINS, NOT\$1CONTAINS, REGEX\$1MATCH, EXIST |
| value | 字符串/布尔值 | 有条件 | 预期值（EXIST 运算符为布尔值） |
```
{
"type": "HEADER",
"headerName": "Content-Type",
"operator": "CONTAINS",
"value": "application/json"
}
```
**正文断言**
| 属性 | Type | 必需 | 默认值 | 说明 |
| --- | --- | --- | --- | --- |
| type | 字符串 | 是 | - | 必须是 "BODY" |
| target | 字符串 | 否 | “JSON” | JSON 或 TEXT |
| path | 字符串 | 有条件 | - | JSONPath（对于 JSON 目标是必需的） |
| operator | 字符串 | 是 | - | CONTAINS, NOT\$1CONTAINS, EQUALS, NOT\$1EQUALS, EXISTS |
| value | 字符串/布尔值 | 是 | - | 预期值（EXISTS 运算符为布尔值） |
```
{
"type": "BODY",
"target": "JSON",
"path": "$.users[0].name",
"operator": "EQUALS",
"value": "John Doe"
}
```
### DNS 断言
**记录价值断言**
| 属性 | Type | 必需 | Range | 说明 |
| --- | --- | --- | --- | --- |
| type | 字符串 | 是 | - | 必须是 "RECORD\$1VALUE" |
| operator | 字符串 | 是 | - | EQUALS, NOT\$1EQUALS, CONTAINS, NOT\$1CONTAINS, REGEX\$1MATCH |
| value | 字符串 | 是 | - | 预期记录值 |
**记录计数断言**
| 属性 | Type | 必需 | Range | 说明 |
| --- | --- | --- | --- | --- |
| type | 字符串 | 是 | - | 必须是 "RECORD\$1COUNT" |
| operator | 字符串 | 是 | - | EQUALS, GREATER\$1THAN, LESS\$1THAN |
| value | 整数 | 是 | ≥ 0 | 预期计数（最小 0） |
**授权断言**
| 属性 | Type | 必需 | Range | 说明 |
| --- | --- | --- | --- | --- |
| type | 字符串 | 是 | - | 必须是 "AUTHORITATIVE" |
| value | 布尔值 | 是 | - | 预期授权状态 |
**TTL 断言**
| 属性 | Type | 必需 | Range | 说明 |
| --- | --- | --- | --- | --- |
| type | 字符串 | 是 | - | 必须是 "TTL" |
| operator | 字符串 | 是 | - | EQUALS, GREATER\$1THAN, LESS\$1THAN |
| value | 整数 | 是 | ≥ 0 | 预期 TTL（最小 0） |
### SSL 断言
**证书到期断言**
| 属性 | Type | 必需 | 默认值 | 说明 |
| --- | --- | --- | --- | --- |
| type | 字符串 | 是 | - | 必须是 "CERTIFICATE\$1EXPIRY" |
| operator | 字符串 | 是 | - | GREATER\$1THAN, LESS\$1THAN |
| value | 整数 | 是 | - | 时间值（最小 0） |
| unit | 字符串 | 否 | “DAYS” | DAYS, HOURS |
**证书主题断言**
| 属性 | Type | 必需 | 默认值 | 说明 |
| --- | --- | --- | --- | --- |
| type | 字符串 | 是 | - | 必须是 "CERTIFICATE\$1SUBJECT" |
| field | 字符串 | 是 | - | 主题字段：CN、O、OU、C、ST、L |
| operator | 字符串 | 是 | - | CONTAINS, EQUALS, REGEX\$1MATCH |
| value | 字符串 | 是 | - | 预期字段值 |
**证书颁发者断言**
| 属性 | Type | 必需 | 默认值 | 说明 |
| --- | --- | --- | --- | --- |
| type | 字符串 | 是 | - | 必须是 "CERTIFICATE\$1ISSUER" |
| field | 字符串 | 是 | - | 颁发者字段：CN、O |
| operator | 字符串 | 是 | - | CONTAINS, EQUALS |
| value | 字符串 | 是 | - | 预期字段值 |
### TCP 断言
**连接成功断言**
| 属性 | Type | 必需 | 默认值 | 说明 |
| --- | --- | --- | --- | --- |
| type | 字符串 | 是 | - | 必须是 "CONNECTION\$1SUCCESSFUL" |
| value | 布尔值 | 是 | - | 预期连接状态 |
**响应数据断言**
| 属性 | Type | 必需 | 默认值 | 说明 |
| --- | --- | --- | --- | --- |
| type | 字符串 | 是 | - | 必须是 "RESPONSE\$1DATA" |
| operator | 字符串 | 是 | - | CONTAINS, EQUALS, NOT\$1CONTAINS, REGEX\$1MATCH, STARTS\$1WITH, ENDS\$1WITH |
| value | 字符串 | 是 | - | 预期响应数据 |
| encoding | 字符串 | 否 | “UTF-8” | UTF-8, ASCII, HEX |
## 数据提取
借助提取器，您可以从响应中捕获数据，用于后续步骤或报告目的。
**提取属性**
| 属性 | Type | 必需 | 默认值 | 说明 |
| --- | --- | --- | --- | --- |
| name | 字符串 | 是 | - | 提取数据的变量名称 |
| type | 字符串 | 是 | - | 提取类型：BODY |
| path | 字符串 | 否 | - | 用于正文提取的 JSONPath |
| regex | 字符串 | 否 | - | 正则表达式模式 |
| regexGroup | 整数 | 否 | 0 | 正则表达式捕获组（最小 0） |
**提取名称验证**
+ 模式：`^[a-zA-Z][a-zA-Z0-9_]*$`
+ 必须以字母开头
+ 可包含字母、数字和下划线
**限制**：替换不适用于架构中具有特定 ENUM 值的字段
**提取类型**
```
{
"name": "userId",
"type": "BODY",
"path": "$.user.id"
}
```
```
{
"stepName": "loginAndExtract",
"checkerType": "HTTP",
"url": "https://api.example.com/login",
"httpMethod": "POST",
"body": "{\"username\":\"test\",\"password\":\"pass\"}",
"extractors": [
{
"name": "textVariable",
"type": "BODY",
"path": "$.myvalue"
}
]
},
{
"stepName": "substituteVariable",
"checkerType": "HTTP",
"url": "https://api.example.com/get/${textVariable}",
"httpMethod": "GET",
"assertions": [
{
"type": "BODY",
"target": "JSON",
"path": "$.users[0].name",
"operator": "EQUALS",
"value": "${textVariable}"
}
]
}
```
# 可用于金丝雀脚本的库函数
CloudWatch Synthetics 中包含多个您在编写用作金丝雀的 Node.js 脚本时可以调用的内置类和函数。
某些类和函数适用于 UI 和 API 金丝雀。其他函数仅适用于 UI 金丝雀。UI 金丝雀是使用 `getPage()` 函数，并使用 Puppeteer 作为 Web 驱动程序进行导航和与网页交互的金丝雀。
**注意**
每当您升级金丝雀以使用新版本的 Synthetics 运行时时，您的金丝雀使用的所有 Synthetics 库函数也会自动升级到 Synthetics 运行时支持的相同 NodeJS 版本。
**Topics**
+ [适用于 Node.js 金丝雀的库函数](Library_function_Nodejs.md)
+ [可用于 Java 金丝雀的库函数](CloudWatch_Synthetics_Canaries_Java.md)
+ [可用于使用 Playwright 的 Node.js Canary 脚本的库函数](CloudWatch_Synthetics_Canaries_Nodejs_Playwright.md)
+ [可用于使用 Puppeteer 的 Node.js Canary 脚本的库函数](CloudWatch_Synthetics_Canaries_Library_Nodejs.md)
+ [可用于使用 Selenium 的 Python 金丝雀脚本的库函数](CloudWatch_Synthetics_Canaries_Library_Python.md)
# 适用于 Node.js 金丝雀的库函数
本节将介绍使用 Node.js 运行时可用于金丝雀脚本的库函数。
**Topics**
+ [addExecutionError(errorMessage, ex);](#Library_function_Nodejs_addExecutionError_Nodecanary)
+ [getCanaryName();](#Library_function_Nodejs_getCanaryName)
+ [getCanaryArn();](#Library_function_Nodejs_Nodecanary)
+ [getCanaryUserAgentString();](#Library_function_Nodejs_getCanaryUserAgentString_Nodecanary)
+ [getRuntimeVersion();](#Library_function_Nodejs_getRuntimeVersion_Nodecanary)
+ [getLogLevel();](#Library_function_Nodejs_getLogLevel_Nodecanary)
+ [setLogLevel();](#Library_function_Nodejs_setLogLevel_Nodecanary)
+ [executeStep(stepName, functionToExecute, [stepConfig])](#Library_function_Nodejs_executestep_Nodecanary)
+ [executeHttpStep(stepName, requestOptions, [callback], [stepConfig])](#Library_function_Nodejs_executeHttpStep)
## addExecutionError(errorMessage, ex);
`errorMessage` 描述错误，`ex` 指遇到的异常
您可以使用 `addExecutionError` 来设置金丝雀的执行错误。它会在不中断脚本执行的情况下导致金丝雀失败。它也不会影响 `successPercent` 指标。
只有当错误对于指示金丝雀脚本成功或故障并不重要时，才应将错误作为执行错误进行跟踪。
以下是使用 `addExecutionError` 的示例。您将会监控端点的可用性，并在页面加载完成后捕获屏幕截图。由于捕获屏幕截图故障并不会决定端点的可用性，因此您可以捕获在截图时遇到的任何错误，并将它们添加为执行错误。可用性指标仍会指示端点已启动并正在运行，但金丝雀状态会被标记为失败。以下示例代码块将会捕获此类错误并将其添加为执行错误。
```
try {await synthetics.executeStep(stepName, callbackFunc);} catch(ex) {synthetics.addExecutionError('Unable to take screenshot ', ex);}
```
## getCanaryName();
返回金丝雀的名称。
## getCanaryArn();
返回金丝雀的 ARN。
## getCanaryUserAgentString();
返回金丝雀的自定义用户代理。
## getRuntimeVersion();
此函数在运行时版本 `syn-nodejs-3.0` 和更高版本中可用。其返回金丝雀的 Synthetics 运行时版本。例如，返回值可能为 `syn-nodejs-3.0`。
## getLogLevel();
检索 Synthetics 库的当前日志级别。可能的值包括：
+ `0` – 调试
+ `1` – 信息
+ `2` – 警告
+ `3` – 错误
示例：
```
let logLevel = synthetics.getLogLevel();
```
## setLogLevel();
设置 Synthetics 库的日志级别。可能的值包括：
+ `0` – 调试
+ `1` – 信息
+ `2` – 警告
+ `3` – 错误
示例：
```
synthetics.setLogLevel(0);
```
## executeStep(stepName, functionToExecute, [stepConfig])
执行提供的步骤，并使用开始/通过/失败日志记录，以及通过/失败和持续时间指标对其进行包装。
`executeStep` 函数还执行以下操作：
+ 记录步骤开始
+ 启动计时器
+ 执行提供的函数
+ 如果函数正常返回，则计为通过。如果函数引发异常，则计为失败
+ 结束计时器
+ 记录步骤是通过还是失败
+ 发出 `stepName SuccessPercent` 指标，100 表示通过，0 表示失败
+ 发出 `stepName Duration metric` 指标，其值基于步骤开始和结束时间
+ 返回 functionToExecute 返回的内容，或重新抛出 ` functionToExecute` 抛出的异常
+ 将步骤执行摘要添加到金丝雀的报告中
**示例**
```
await synthetics.executeStep(stepName, async function () {
return new Promise((resolve, reject) => {
const req = https.request(url, (res) => {
console.log(`Status: ${res.statusCode}`);
if (res.statusCode >= 400) {
reject(new Error(`Request failed with status ${res.statusCode} for ${url}`));
} else {
resolve();
}
});
req.on('error', (err) => {
reject(new Error(`Request failed for ${url}: ${err.message}`));
});
req.end();
});
});
```
## executeHttpStep(stepName, requestOptions, [callback], [stepConfig])
作为步骤执行提供的 HTTP 请求，并发布 `SuccessPercent`（通过/失败）和 `Duration` 指标。
**executeHttpStep** 在后台使用 HTTP 或 HTTPS 本机函数，具体取决于请求中指定的协议。
此函数还将步骤执行摘要添加到金丝雀的报告中。摘要中包括有关每个 HTTP 请求的详细信息，如下所示：
+ 开始时间
+ 结束时间
+ 状态 (PASSED/FAILED)
+ 故障原因（如失败）
+ HTTP 调用详细信息，如请求/响应标头、请求/响应体、状态代码、状态消息和性能计时。
**Topics**
+ [参数](#Library_function_Nodejs_executeHttpStep_parameters_Nodecanary)
+ [executeHttpStep 的使用示例](#Library_function_Nodejs_executeHttpStep_examples_Nodecanary)
### 参数
**stepName(*String*)**
指定步骤的名称。此名称也用于发布此步骤的 CloudWatch 指标。
**requestOptions(*Object or String*)**
此参数的值可以是 URL、URL 字符串或对象。如果为对象，则必须是用以发出 HTTP 请求的一组可配置选项。其支持 Node.js 文档中 [http.request(options[, callback])](https://nodejs.org/api/http.html#http_http_request_options_callback) 中的所有选项。
除了这些 Node.js 选项之外，**requestOptions** 支持附加参数 `body`。您可以使用 `body` 参数将数据作为请求体传递。
**callback(*response*)**
（可选）此函数是与 HTTP 响应一起调用的用户函数。响应的类型为 [Class: http.IncomingMessage](https://nodejs.org/api/http.html#http_class_http_incomingmessage)。
**stepConfig(*object*)**
（可选）使用此参数，可以用此步骤的不同配置覆盖全局 synthetics 配置。
### executeHttpStep 的使用示例
以下一系列示例相互依存，以说明此选项的各种用途。
第一个示例展示配置请求参数。您可以将 URL 作为 **requestOptions** 传递：
```
let requestOptions = 'https://www.amazon.com';
```
或者，您也可以传递一组选项：
```
let requestOptions = {
'hostname': 'myproductsEndpoint.com',
'method': 'GET',
'path': '/test/product/validProductName',
'port': 443,
'protocol': 'https:'
};
```
在下一个示例中，创建一个接受响应的回调函数。预设情况下，如果您未指定 **callback**，CloudWatch Synthetics 会验证状态是否介于 200 和 299 之间（含）。
```
// Handle validation for positive scenario
const callback = async function(res) {
return new Promise((resolve, reject) => {
if (res.statusCode < 200 || res.statusCode > 299) {
throw res.statusCode + ' ' + res.statusMessage;
}
let responseBody = '';
res.on('data', (d) => {
responseBody += d;
});
res.on('end', () => {
// Add validation on 'responseBody' here if required. For ex, your status code is 200 but data might be empty
resolve();
});
});
};
```
下一个示例展示为此步骤创建覆盖全局 CloudWatch Synthetics 配置的配置。在本示例中，步骤配置允许报告中包含请求标头、响应标头、请求体（发布数据）和响应体，并限制了“X-Amz-Security-Token”和“Authorization”标头值。预设情况下，出于安全原因，报告中不包括这些值。如果您选择将它们包含在报告中，则这些数据仅存储在 S3 存储桶中。
```
// By default headers, post data, and response body are not included in the report for security reasons.
// Change the configuration at global level or add as step configuration for individual steps
let stepConfig = {
includeRequestHeaders: true,
includeResponseHeaders: true,
restrictedHeaders: ['X-Amz-Security-Token', 'Authorization'], // Restricted header values do not appear in report generated.
includeRequestBody: true,
includeResponseBody: true
};
```
最后一个例子展示将请求传递给 **executeHttpStep** 并对步骤命名。
```
await synthetics.executeHttpStep('Verify GET products API', requestOptions, callback, stepConfig);
```
在这组示例中，CloudWatch Synthetics 将每个步骤的详细信息添加在报告中，并使用 **stepName** 生成每个步骤的指标。
您将看到 `Verify GET products API` 步骤的 `successPercent` 和 `duration` 指标。您可以通过监控 API 调用步骤的指标来监控 API 性能。
有关使用这些函数的完整脚本示例，请参阅 [多步骤 API 金丝雀](CloudWatch_Synthetics_Canaries_Samples.md#CloudWatch_Synthetics_Canaries_Samples_APIsteps)。
# 可用于 Java 金丝雀的库函数
`executeStep` 函数用于对金丝雀代码进行模块化处理并分步执行。在 CloudWatch Synthetics 中，Synthetics 步骤是一种将您的 Canary 脚本分解为一系列明确定义的操作的方法，允许您分别监控应用程序旅程的不同部分。对于每个步骤，CloudWatch Synthetics 执行以下操作：
+ 每次金丝雀运行都会创建一份报告，包括步骤执行详细信息的摘要，例如步骤的持续时间、*通过*或*失败*状态等。当您在 CloudWatch Synthetics 控制台中选择运行时，您可以在**步骤**选项卡上查看每个步骤的执行详细信息。
+ 每个步骤都会发出 *SuccessPercent* 和 *Duration* CloudWatch 指标，让用户能够监测每个步骤的可用性和延迟情况。
**用法**
```
synthetics.executeStep(stepName,()->{
try {
//step code to be executed
return null;
} catch (Exception e) {
throw e;
}
}).get();
```
**参数**
+ *StepName*，字符串（必填）– Synthetics 步骤的描述性名称
+ *要执行的函数*，Callable（必填）– 表示要执行的任务
+ *stepOptions*，`com.amazonaws.synthetics.StepOptions (optional)`– 可用于配置步骤执行的 StepOptions 对象。
*stepConfiguration*，` com.amazonaws.synthetics.StepConfiguration`（作为 stepOptions 的一部分时为必填）
**返回值**
返回的值为 *CompletableFuture*。
**注意**
Synthetics 仅支持顺序步骤。务必按示例所示调用 `.get()` 方法，确保在执行后续步骤前当前步骤已完成。
# 可用于使用 Playwright 的 Node.js Canary 脚本的库函数
本节介绍使用 Node.js Playwright 运行时可用于 Canary 脚本的库函数。
**Topics**
+ [启动](#Synthetics_Library_Nodejs_Playwright_functions)
+ [newPage](#Synthetics_Library_Nodejs_Playwright_function_newPage)
+ [关闭](#Synthetics_Library_Nodejs_Playwright_function_close)
+ [getDefaultLaunchOptions](#Synthetics_Library_Nodejs_Playwright_function_getDefaultLaunchOptions)
+ [executeStep](#Synthetics_Library_Nodejs_Playwright_function_executeStep)
## 启动
该函数使用 Playwright 启动函数启动 Chromium 浏览器，并返回浏览器对象。该函数使用适用于无外设浏览器的默认选项来解压缩浏览器二进制文件并启动 Chromium 浏览器。有关 `launch` 函数的更多信息，请参阅 Playwright 文档中的 [https://playwright.dev/docs/api/class-browsertype#browser-type-launch](https://playwright.dev/docs/api/class-browsertype#browser-type-launch)。
**用法**
```
const browser = await synthetics.launch();
```
**参数**
`options` [选项](https://playwright.dev/docs/api/class-browsertype#browser-type-launch)（可选）是浏览器的一组可配置的选项。
**返回值**
Promise ``，其中 [Browser](https://playwright.dev/docs/api/class-browser) 是一个 Playwright 浏览器实例。
如果再次调用该函数，则先前打开的浏览器将在启动新浏览器之前关闭。您可以覆盖 CloudWatch Synthetics 使用的启动参数，并在启动浏览器时传递其他参数。例如，以下代码段以默认参数和默认可执行文件路径启动浏览器，但视区为 800 x 600 像素。有关更多信息，请参阅 Playwright 文档中的 [Playwright launch options](https://playwright.dev/docs/api/class-browsertype#browser-type-launch)。
```
const browser = await synthetics.launch({
defaultViewport: {
"deviceScaleFactor": 1,
"width": 800,
"height": 600
}});
```
您还可以添加或覆盖默认传递给浏览器的 Chromium 标志。例如，您可以通过向 CloudWatch Synthetics 启动参数中的参数添加一个 `--disable-web-security` 标志来禁用 Web 安全：
```
// This function adds the --disable-web-security flag to the launch parameters
const defaultOptions = await synthetics.getDefaultLaunchOptions();
const launchArgs = [...defaultOptions.args, '--disable-web-security'];
const browser = await synthetics.launch({
args: launchArgs
});
```
## newPage
`newPage()` 函数创建并返回一个新的 Playwright 页面。Synthetics 会自动设置 Chrome DevTools 协议（CDP）连接，为生成 HTTP 存档（HAR）启用网络捕获。
**用法**
通过以下任一方式使用 `newPage()`：
**1。在新的浏览器上下文中创建新页面：**
```
const page = await synthetics.newPage(browser);
```
**2. 在指定的浏览器上下文中创建新页面：**
```
// Create a new browser context
const browserContext = await browser.newContext();
// Create a new page in the specified browser context
const page = await synthetics.newPage(browserContext)
```
**参数**
接受 Playwright [Browser](https://playwright.dev/docs/api/class-browser) 实例或 Playwright [BrowserContext](https://playwright.dev/docs/api/class-browsercontext) 实例。
**返回值**
Promise ，其中 Page 是 Playwright [Page](https://playwright.dev/docs/api/class-page) 实例。
## 关闭
关闭当前打开的浏览器。
**用法**
```
await synthetics.close();
```
建议在脚本的 `finally` 块中关闭浏览器。
**参数**
无
**返回值**
返回 Synthetics 启动函数在启动浏览器时使用的 Promise。
## getDefaultLaunchOptions
`getDefaultLaunchOptions()` 函数返回 CloudWatch Synthetics 使用的浏览器启动选项。
**用法**
```
const defaultOptions = await synthetics.getDefaultLaunchOptions();
```
**参数**
无
**返回值**
返回 Synthetics `launch` 函数用于启动浏览器的 Playwright [启动选项](https://playwright.dev/docs/api/class-browsertype#browser-type-launch)。
## executeStep
`executeStep` 函数用于执行 Synthetics 脚本中的一个步骤。在 CloudWatch Synthetics 中，Synthetics 步骤是一种将您的 Canary 脚本分解为一系列明确定义的操作的方法，允许您分别监控应用程序旅程的不同部分。对于每个步骤，CloudWatch Synthetics 执行以下操作：
+ 在步骤开始之前和步骤完成之后自动捕获屏幕截图。您还可以在步骤中捕获屏幕截图。屏幕截图是默认捕获的，但可以使用 Synthetics 配置将其关闭。
+ 每次 Canary 运行都会创建一份报告，包括步骤执行详细信息的摘要，例如步骤的持续时间、`pass` 或 `fail` 状态、源和目标页面 URL、关联的屏幕截图等。当您在 CloudWatch Synthetics 控制台中选择运行时，您可以在**步骤**选项卡上查看每个步骤的执行详细信息。
+ 并且会为每个步骤发出 `SuccessPercent` 和 `Duration` CloudWatch 指标，使用户能够监控每个步骤的可用性和延迟。
**用法**
```
await synthetics.executeStep("mystepname", async function () {
await page.goto(url, { waitUntil: 'load', timeout: 30000 });
}
```
**注意**
步骤应按顺序运行。一定要对 promise 使用 `await`。
**参数**
+ `stepName` 字符串（必填）（布尔值）– Synthetics 步骤的名称。
+ `functionToExecute` 异步函数（必填）– 您希望 Synthetics 运行的函数。此函数应包含该步骤的逻辑。
+ `stepConfig` 对象（可选）– 步骤配置覆盖此函数的全局 Synthetics 配置。
+ `continueOnStepFailure` 布尔值（可选）– 在此步骤失败后是否继续运行 Canary 脚本。
+ `screenshotOnStepStart` 布尔值（可选）– 在此步骤开始是否时捕获屏幕截图。
+ `screenshotOnStepSuccess` 布尔值（可选）– 在此步骤成功时是否捕获屏幕截图。
+ `screenshotOnStepFailure` 布尔值（可选）– 在此步骤失败后是否捕获屏幕截图。
+ `page` – Playwright 页面对象（可选）
Playwright 页面对象。Synthetics 使用此页面对象来捕获屏幕截图和 URL。默认情况下，Synthetics 使用调用 `synthetics.newPage()` 函数时创建的 Playwright 页面来捕获屏幕截图和 URL 等页面详细信息。
**返回值**
返回 Promise，该参数使用 ` functionToExecute` 函数返回的值进行解析。有关示例脚本，请参阅本指南中的 [金丝雀脚本示例代码](CloudWatch_Synthetics_Canaries_Samples.md)。
# 可用于使用 Puppeteer 的 Node.js Canary 脚本的库函数
本节描述了可用于 Node.js Canary 脚本的库函数。
**Topics**
+ [适用于所有金丝雀的 Node.js 库类和函数](#CloudWatch_Synthetics_Library_allcanaries)
+ [仅适用于 UI 金丝雀的 Node.js 库类和函数](#CloudWatch_Synthetics_Library_UIcanaries)
+ [仅适用于 API 金丝雀的 Node.js 库类和函数](#CloudWatch_Synthetics_Library_APIcanaries)
## 适用于所有金丝雀的 Node.js 库类和函数
以下用于 Node.js 的 CloudWatch Synthetics 库函数适用于所有金丝雀。
**Topics**
+ [Synthetics 类](#CloudWatch_Synthetics_Library_Synthetics_Class_all)
+ [SyntheticsConfiguration 类](#CloudWatch_Synthetics_Library_SyntheticsConfiguration)
+ [Synthetics Logger](#CloudWatch_Synthetics_Library_SyntheticsLogger)
+ [SyntheticsLogHelper 类](#CloudWatch_Synthetics_Library_SyntheticsLogHelper)
### Synthetics 类
以下适用于所有金丝雀的函数都属于 Synthetics 类。
**Topics**
+ [addExecutionError(errorMessage, ex);](#CloudWatch_Synthetics_Library_addExecutionError)
+ [getCanaryName();](#CloudWatch_Synthetics_Library_getCanaryName)
+ [getCanaryArn();](#CloudWatch_Synthetics_Library_getCanaryARN)
+ [getCanaryUserAgentString();](#CloudWatch_Synthetics_Library_getCanaryUserAgentString)
+ [getRuntimeVersion();](#CloudWatch_Synthetics_Library_getRuntimeVersion)
+ [getLogLevel();](#CloudWatch_Synthetics_Library_getLogLevel)
+ [setLogLevel();](#CloudWatch_Synthetics_Library_setLogLevel)
#### addExecutionError(errorMessage, ex);
`errorMessage` 描述错误，`ex` 指遇到的异常
您可以使用 `addExecutionError` 来设置金丝雀的执行错误。它会在不中断脚本执行的情况下导致金丝雀失败。它也不会影响 `successPercent` 指标。
只有当错误对于指示金丝雀脚本成功或故障并不重要时，才应将错误作为执行错误进行跟踪。
以下是使用 `addExecutionError` 的示例。您将会监控端点的可用性，并在页面加载完成后捕获屏幕截图。由于捕获屏幕截图故障并不会决定端点的可用性，因此您可以捕获在截图时遇到的任何错误，并将它们添加为执行错误。可用性指标仍会指示端点已启动并正在运行，但金丝雀状态会被标记为失败。以下示例代码块将会捕获此类错误并将其添加为执行错误。
```
try {
await synthetics.takeScreenshot(stepName, "loaded");
} catch(ex) {
synthetics.addExecutionError('Unable to take screenshot ', ex);
}
```
#### getCanaryName();
返回金丝雀的名称。
#### getCanaryArn();
返回金丝雀的 ARN。
#### getCanaryUserAgentString();
返回金丝雀的自定义用户代理。
#### getRuntimeVersion();
此函数在 `syn-nodejs-puppeteer-3.0` 和更高版本的运行时中可用。其返回金丝雀的 Synthetics 运行时版本。例如，返回值可能为 `syn-nodejs-puppeteer-3.0`。
#### getLogLevel();
检索 Synthetics 库的当前日志级别。可能的值包括：
+ `0` – 调试
+ `1` – 信息
+ `2` – 警告
+ `3` – 错误
示例：
```
let logLevel = synthetics.getLogLevel();
```
#### setLogLevel();
设置 Synthetics 库的日志级别。可能的值包括：
+ `0` – 调试
+ `1` – 信息
+ `2` – 警告
+ `3` – 错误
示例：
```
synthetics.setLogLevel(0);
```
### SyntheticsConfiguration 类
此类仅在 `syn-nodejs-2.1` 或更高版本的运行时中可用。
您可以使用 `SyntheticsConfiguration` 类来配置 Synthetics 库函数的行为。例如，您可以使用此类将 `executeStep()` 函数配置为不捕获屏幕截图。
您可以在全局级别设置 CloudWatch Synthetics 配置，这些配置会应用于金丝雀的所有步骤。您还可以通过传递配置键和值对，在步骤级别覆盖这些配置。
您可以在步骤级别传入选项。有关示例，请参阅 [async executeStep(stepName, functionToExecute, [stepConfig]);](#CloudWatch_Synthetics_Library_executeStep) 和 [executeHttpStep(stepName, requestOptions, [callback], [stepConfig])](#CloudWatch_Synthetics_Library_executeHttpStep)。
**Topics**
+ [setConfig(options)](#CloudWatch_Synthetics_Library_setConfig)
+ [可视化监控](#CloudWatch_Synthetics_Library_SyntheticsLogger_VisualTesting)
#### setConfig(options)
` options ` 是一个对象，它是一组适用于您的金丝雀的可配置选项。以下各节将介绍 ` options ` 中的可能字段。
##### 所有金丝雀的 setConfig(options)
对于使用 `syn-nodejs-puppeteer-3.2` 或更新版本的金丝雀，**setConfig** 的 **(options)** 可包含以下参数：
+ `includeRequestHeaders`（布尔值）– 是否在报告中包含请求标头。默认值为 `false`。
+ `includeResponseHeaders`（布尔值）– 是否在报告中包含响应标头。默认值为 `false`。
+ `restrictedHeaders`（数组）– 要忽略的标头值列表（如果包含标头）。这对请求标头和响应标头均适用。例如，您可以将 **includeRequestHeaders** 传递为 `true` 并将 **restrictedHeaders** 传递为 `['Authorization']`，来隐藏凭证。
+ `includeRequestBody`（布尔值）– 是否在报告中包含请求体。默认值为 `false`。
+ `includeResponseBody`（布尔值）– 是否在报告中包含响应体。默认值为 `false`。
**重要**
如果您启用了 `includeResponseBody` 或 ` logResponseBody`，则某些 API（例如 aws-sdk v3 客户端）的响应中不会返回该数据对象。这是因为 Node.js 和所用响应对象类型的限制。
**CloudWatch 指标的相关 setConfig(options)**
对于使用 `syn-nodejs-puppeteer-3.1` 或更新版本的金丝雀，**setConfig** 的 **(options)** 可包含以下布尔参数，这些参数决定将由金丝雀发布的指标。其中每个选项的默认值均为 `true`。以 `aggregated` 开头的选项决定是否不带 ` CanaryName` 维度发出指标。您可以使用该等指标查看所有金丝雀的聚合结果。其他选项决定是否带 `CanaryName` 维度发出指标。您可以使用该等指标查看每个金丝雀的结果。
有关金丝雀发出的 CloudWatch 指标的列表，请参阅 [金丝雀发布的 CloudWatch 指标](CloudWatch_Synthetics_Canaries_metrics.md)。
+ `failedCanaryMetric`（布尔值）– 是否发出此金丝雀的 ` Failed` 指标（带 `CanaryName` 维度）。默认值为 `true`。
+ `failedRequestsMetric`（布尔值）– 是否发出此金丝雀的 `Failed requests` 指标（带 `CanaryName` 维度）。默认值为 `true`。
+ `_2xxMetric`（布尔值）– 是否发出此金丝雀的 `2xx` 指标（带 `CanaryName` 维度）。默认值为 `true`。
+ `_4xxMetric`（布尔值）– 是否发出此金丝雀的 `4xx` 指标（带 `CanaryName` 维度）。默认值为 `true`。
+ `_5xxMetric`（布尔值）– 是否发出此金丝雀的 `5xx` 指标（带 `CanaryName` 维度）。默认值为 `true`。
+ `stepDurationMetric`（布尔值）– 是否发出此金丝雀的 `Step duration` 指标（带 `CanaryName` `StepName` 维度）。默认值为 `true`。
+ `stepSuccessMetric`（布尔值）– 是否发出此金丝雀的 `Step success` 指标（带 `CanaryName` `StepName` 维度）。默认值为 `true`。
+ `aggregatedFailedCanaryMetric`（布尔值）– 是否发出此金丝雀的 `Failed` 指标（不带 `CanaryName` 维度）。默认值为 `true`。
+ `aggregatedFailedRequestsMetric`（布尔值）– 是否发出此金丝雀的 `Failed Requests` 指标（不带 `CanaryName` 维度）。默认值为 `true`。
+ `aggregated2xxMetric`（布尔值）– 是否发出此金丝雀的 ` 2xx` 指标（不带 `CanaryName` 维度）。默认值为 `true`。
+ `aggregated4xxMetric`（布尔值）– 是否发出此金丝雀的 ` 4xx` 指标（不带 `CanaryName` 维度）。默认值为 `true`。
+ `aggregated5xxMetric`（布尔值）– 是否发出此金丝雀的 ` 5xx` 指标（不带 `CanaryName` 维度）。默认值为 `true`。
+ `visualMonitoringSuccessPercentMetric`（布尔值）– 是否发出此金丝雀的 `visualMonitoringSuccessPercent` 指标。默认值为 `true`。
+ `visualMonitoringTotalComparisonsMetric`（布尔值）– 是否发出此金丝雀的 `visualMonitoringTotalComparisons` 指标。默认值为 `false`。
+ `includeUrlPassword`（布尔值）– 是否包含 URL 中显示的密码。预设情况下，URL 中显示的密码会在日志和报告中进行编辑，以防泄露敏感数据。默认值为 `false`。
+ `restrictedUrlParameters`（数组）– 要编辑的 URL 路径或查询参数的列表。这适用于出现在日志、报告和错误中的 URL。此参数区分大小写。您可以传递星号 (\$1) 作为值来编辑所有 URL 路径和查询参数值。默认值为空数组。
+ `logRequest`（布尔值）– 是否将每个请求都记录在金丝雀日志中。对于 UI 金丝雀，这会记录浏览器发送的每个请求。默认值为 `true`。
+ `logResponse`（布尔值）– 是否将每个响应都记录在金丝雀日志中。对于 UI 金丝雀，这会记录浏览器收到的每个响应。默认值为 `true`。
+ `logRequestBody`（布尔值）– 是否随请求一起将请求体记录在金丝雀日志中。仅当 `logRequest` 为 `true` 时，此配置才适用。默认为 `false`。
+ `logResponseBody`（布尔值）– 是否随响应一起将响应体记录在金丝雀日志中。仅当 `logResponse` 为 `true` 时，此配置才适用。默认值为 ` false`。
**重要**
如果您启用了 `includeResponseBody` 或 ` logResponseBody`，则某些 API（例如 aws-sdk v3 客户端）的响应中不会返回该数据对象。这是因为 Node.js 和所用响应对象类型的限制。
+ `logRequestHeaders`（布尔值）– 是否随请求一起将请求标头记录在金丝雀日志中。仅当 `logRequest` 为 `true` 时，此配置才适用。默认值为 ` false`。
请注意，`includeRequestHeaders` 会在构件中启用标头。
+ `logResponseHeaders`（布尔值）– 是否随响应一起将响应标头记录在金丝雀日志中。仅当 `logResponse` 为 `true` 时，此配置才适用。默认值为 ` false`。
请注意，`includeResponseHeaders` 会在构件中启用标头。
**注意**
始终会发出每个金丝雀的 `Duration` 和 `SuccessPercent` 指标，这两个指标都会带有和不带 `CanaryName` 指标。
##### 用于启用或禁用指标的方法
**disableAggregatedRequestMetrics()**
禁用金丝雀发出以不带 `CanaryName` 维度形式发出的所有请求指标。
**disableRequestMetrics()**
禁用所有请求指标，包括每个金丝雀的指标和跨所有金丝雀聚合的指标。
**disableStepMetrics()**
禁用所有步骤指标，包括步骤成功指标和步骤持续时间指标。
**enableAggregatedRequestMetrics()**
启用金丝雀发出以不带 ` CanaryName` 维度形式发出的所有请求指标。
**enableRequestMetrics()**
启用所有请求指标，包括每个金丝雀的指标和跨所有金丝雀聚合的指标。
**enableStepMetrics()**
启用所有步骤指标，包括步骤成功指标和步骤持续时间指标。
**get2xxMetric()**
返回金丝雀是否发出带 ` CanaryName` 维度的 `2xx` 指标。
**get4xxMetric()**
返回金丝雀是否发出带 ` CanaryName` 维度的 `4xx` 指标。
**get5xxMetric()**
返回金丝雀是否发出带 ` CanaryName` 维度的 `5xx` 指标。
**getAggregated2xxMetric()**
返回金丝雀是否发出不带维度的 `2xx` 指标。
**getAggregated4xxMetric()**
返回金丝雀是否发出不带维度的 `4xx` 指标。
**getAggregatedFailedCanaryMetric()**
返回金丝雀是否发出不带维度的 `Failed` 指标。
**getAggregatedFailedRequestsMetric()**
返回金丝雀是否发出不带维度的 `Failed requests` 指标。
**getAggregated5xxMetric()**
返回金丝雀是否发出不带维度的 `5xx` 指标。
**getFailedCanaryMetric()**
返回金丝雀是否发出带 ` CanaryName` 维度的 `Failed` 指标。
**getFailedRequestsMetric()**
返回金丝雀是否发出带 `CanaryName` 维度的 `Failed requests` 指标。
**getStepDurationMetric()**
返回金丝雀是否发出带有此金丝雀的 ` CanaryName` 维度的 `Duration` 指标。
**getStepSuccessMetric()**
返回金丝雀是否发出带有此金丝雀的 ` CanaryName` 维度的 `StepSuccess` 指标。
**with2xxMetric(\$12xxMetric)**
接受一个布尔参数，该参数指定是否为此金丝雀发出带 `CanaryName` 维度的 `2xx` 指标。
**with4xxMetric(\$14xxMetric)**
接受一个布尔参数，该参数指定是否为此金丝雀发出带 `CanaryName` 维度的 `4xx` 指标。
**with5xxMetric(\$15xxMetric)**
接受一个布尔参数，该参数指定是否为此金丝雀发出带 `CanaryName` 维度的 `5xx` 指标。
**withAggregated2xxMetric(aggregated2xxMetric)**
接受一个布尔参数，该参数指定是否为此金丝雀发出不带维度的 `2xx` 指标。
**withAggregated4xxMetric(aggregated4xxMetric)**
接受一个布尔参数，该参数指定是否为此金丝雀发出不带维度的 `4xx` 指标。
**withAggregated5xxMetric(aggregated5xxMetric)**
接受一个布尔参数，该参数指定是否为此金丝雀发出不带维度的 `5xx` 指标。
**withAggregatedFailedCanaryMetric(aggregatedFailedCanaryMetric)**
接受一个布尔参数，该参数指定是否为此金丝雀发出不带维度的 `Failed` 指标。
**withAggregatedFailedRequestsMetric(aggregatedFailedRequestsMetric)**
接受一个布尔参数，该参数指定是否为此金丝雀发出不带维度的 `Failed requests` 指标。
**withFailedCanaryMetric(failedCanaryMetric)**
接受一个布尔参数，该参数指定是否为此金丝雀发出带 `CanaryName` 维度的 `Failed` 指标。
**withFailedRequestsMetric(failedRequestsMetric)**
接受一个布尔参数，该参数指定是否为此金丝雀发出带 `CanaryName` 维度的 `Failed requests` 指标。
**withStepDurationMetric(stepDurationMetric)**
接受一个布尔参数，该参数指定是否为此金丝雀发出带 `CanaryName` 维度的 `Duration` 指标。
**withStepSuccessMetric(stepSuccessMetric)**
接受一个布尔参数，该参数指定是否为此金丝雀发出带 `CanaryName` 维度的 ` StepSuccess` 指标。
##### 启用或禁用其他功能的方法
**withHarFile()**
接受一个布尔参数，该参数指定是否为此金丝雀创建 HAR 文件。
**withStepsReport()**
接受一个布尔参数，该参数指定是否报告此金丝雀的步骤执行摘要。
**withIncludeUrlPassword()**
接受一个布尔参数，该参数指定是否在日志和报告中包含 URL 中出现的密码。
**withRestrictedUrlParameters()**
接受要编辑的 URL 路径或查询参数的数组。这适用于出现在日志、报告和错误中的 URL。您可以传递星号 (\$1) 作为值来编辑所有 URL 路径和查询参数值
**withLogRequest()**
接受一个布尔参数，该参数指定是否将每个请求记录在金丝雀的日志中。
**withLogResponse()**
接受一个布尔参数，该参数指定是否将每个响应记录在金丝雀的日志中。
**withLogRequestBody()**
接受一个布尔参数，该参数指定是否将每个请求体记录在金丝雀的日志中。
**withLogResponseBody()**
接受一个布尔参数，该参数指定是否将每个响应体记录在金丝雀的日志中。
**withLogRequestHeaders()**
接受一个布尔参数，该参数指定是否将每个请求标头记录在金丝雀的日志中。
**withLogResponseHeaders()**
接受一个布尔参数，该参数指定是否将每个响应标头记录在金丝雀日志中。
**getHarFile()**
返回金丝雀是否创建 HAR 文件。
**getStepsReport()**
返回金丝雀是否报告步骤执行摘要。
**getIncludeUrlPassword()**
返回金丝雀是否在日志和报告中包含 URL 中出现的密码。
**getRestrictedUrlParameters()**
返回金丝雀是否编辑 URL 路径或查询参数。
**getLogRequest()**
返回金丝雀是否将每个请求记录在金丝雀的日志中。
**getLogResponse()**
返回金丝雀是否将每个响应记录在金丝雀的日志中。
**getLogRequestBody()**
返回金丝雀是否将每个请求体记录在金丝雀的日志中。
**getLogResponseBody()**
返回金丝雀是否将每个响应体记录在金丝雀的日志中。
**getLogRequestHeaders()**
返回金丝雀是否将每个请求标头记录在金丝雀的日志中。
**getLogResponseHeaders()**
返回金丝雀是否将每个响应标头记录在金丝雀的日志中。
**所有金丝雀的函数**
+ `withIncludeRequestHeaders`(includeRequestHeaders)
+ `withIncludeResponseHeaders`（包括响应标题）
+ `withRestrictedHeaders`(restrictedHeaders)
+ `withIncludeRequestBody`(includeRequestBody)
+ `withIncludeResponseBody`(includeResponseBody)
+ `enableReportingOptions`() – 启用所有报告选项-- **includeRequestHeaders**、**includeResponseHeaders**、**includeRequestBody** 和 **includeResponseBody**。
+ `disableReportingOptions`() – 禁用所有报告选项-- **includeRequestHeaders**、**includeResponseHeaders**、**includeRequestBody** 和 **includeResponseBody**。
##### 用于 UI 金丝雀的 setConfig(options)
对于 UI 金丝雀，**setConfig** 可包含以下布尔参数：
+ `continueOnStepFailure`（布尔值）– 是否在步骤失败（指 **executeStep** 函数）后继续运行金丝雀脚本。如果任何步骤失败，金丝雀运行仍将被标记为失败。默认值为 `false`。
+ `harFile`（布尔值）– 是否创建 HAR 文件。默认值为 `True`。
+ `screenshotOnStepStart`（布尔值）– 是否在开始步骤之前捕获屏幕截图。
+ `screenshotOnStepSuccess`（布尔值）– 是否在成功完成步骤后捕获屏幕截图。
+ `screenshotOnStepFailure`（布尔值）– 是否在步骤失败后捕获屏幕截图。
##### 启用或禁用屏幕截图的方法
**disableStepScreenshots()**
禁用所有屏幕截图选项（screenshotOnStepStart、screenshotOnStepSuccess 和 screenshotOnStepFailure）。
**enableStepScreenshots()**
启用所有屏幕截图选项（screenshotOnStepStart、screenshotOnStepSuccess 和 screenshotOnStepFailure）。预设情况下，这些方法均未启用。
**getScreenshotOnStepFailure()**
返回金丝雀是否在步骤失败后捕获屏幕截图。
**getScreenshotOnStepStart()**
返回金丝雀是否在开始步骤之前捕获屏幕截图。
**getScreenshotOnStepSuccess()**
返回金丝雀是否在成功完成步骤后捕获屏幕截图。
**withScreenshotOnStepStart(screenshotOnStepStart)**
接受一个布尔参数，该参数指示是否在开始步骤之前捕获屏幕截图。
**withScreenshotOnStepSuccess(screenshotOnStepSuccess)**
接受一个布尔参数，该参数指示是否在成功完成步骤后捕获屏幕截图。
**withScreenshotOnStepFailure(screenshotOnStepFailure)**
接受一个布尔参数，该参数指示是否在步骤失败后捕获屏幕截图。
**在 UI 金丝雀中的使用情况**
首先，导入 Synthetics 依赖关系并获取配置。
```
// Import Synthetics dependency
const synthetics = require('@aws/synthetics-puppeteer');
// Get Synthetics configuration
const synConfig = synthetics.getConfiguration();
```
然后，通过使用以下选项之一调用 setConfig 方法来设置每个选项的配置。
```
// Set configuration values
synConfig.setConfig({
screenshotOnStepStart: true,
screenshotOnStepSuccess: false,
screenshotOnStepFailure: false
});
```
Or
```
synConfig.withScreenshotOnStepStart(false).withScreenshotOnStepSuccess(true).withScreenshotOnStepFailure(true)
```
要禁用所有屏幕截图，请使用 `disableStepScreenshots()` 函数，如本示例所示。
```
synConfig.disableStepScreenshots();
```
您可以在代码中的任何位置启用和禁用屏幕截图。例如，若要仅禁用一个步骤的屏幕截图，请在运行该步骤之前禁用屏幕截图，然后在该步骤后启用它们。
##### 用于 API 金丝雀的 setConfig(options)
对于 API 金丝雀，**setConfig** 可包含以下布尔参数：
+ `continueOnHttpStepFailure`（布尔值）- 是否在 HTTP 步骤（指 **executeHttpStep** 函数）失败后继续运行金丝雀脚本。如果任何步骤失败，金丝雀运行仍将被标记为失败。默认值为 `true`。
#### 可视化监控
可视化监控将在金丝雀运行期间捕获的屏幕截图与在基准金丝雀运行期间捕获的屏幕截图进行比较。如果两个屏幕截图之间的差异超出阈值百分比，则金丝雀失败，您可以在金丝雀运行报告中看到以高亮颜色突出显示的差异区域。运行 **syn-puppeteer-node-3.2** 和更高版本的金丝雀支持可视化监控。运行 Python 和 Selenium 的金丝雀中目前不支持可视化监控。
若要启用可视化监控，请将以下代码行添加到金丝雀脚本中。有关更多详细信息，请参阅[SyntheticsConfiguration 类](#CloudWatch_Synthetics_Library_SyntheticsConfiguration)。
```
syntheticsConfiguration.withVisualCompareWithBaseRun(true);
```
将此行添加到脚本后，金丝雀首次成功运行时，它会使用在该运行期间捕获的屏幕截图作为比较基准。在金丝雀的该首次运行之后，您可以使用 CloudWatch 控制台编辑金丝雀以执行以下任一操作：
+ 将金丝雀的下一次运行设置为新基准。
+ 在当前基准屏幕截图上绘制边界，以指定在可视化比较过程中要忽略的屏幕截图区域。
+ 删除屏幕截图，使其不用于可视化监控。
有关使用 CloudWatch 控制台编辑金丝雀的更多信息，请参阅 [编辑或删除金丝雀脚本](synthetics_canaries_deletion.md)。
**可视化监控的其他选项**
**syntheticsConfiguration.withVisualVarianceThresholdPercentage(desiredPercentage)**
设置可视化对比中屏幕截图差异的可接受百分比。
**syntheticsConfiguration.withVisualVarianceHighlightHexColor("\$1fafa00")**
设置在查看使用可视化监控的金丝雀运行报告时指明差异区域的突出显示颜色。
**syntheticsConfiguration.withFailCanaryRunOnVisualVariance(failCanary)**
设置当存在超过阈值的可视化差异时金丝雀是否失败。默认为金丝雀失败。
### Synthetics Logger
SyntheticsLogger 将日志写入控制台和同一日志级别的本地日志文件。仅当日志级别与所调用的日志函数所需的日志记录级别相同或比其级别低时，此日志文件才会写入到这两个位置。
本地日志文件中的日志记录语句前面加上“DEBUG:”、“INFO:”等，以便与所调用的函数的日志级别相匹配。
如果您希望在与 Synthetics 金丝雀日志记录相同的日志级别运行 Synthetics 库，可以使用 SyntheticsLogger。
如果要创建上载到 S3 结果位置的日志文件，不需要使用 SyntheticsLogger。您可以在 ` /tmp` 文件夹中创建不同的日志文件。在 `/tmp` 文件夹下创建的任何文件都会作为构件上传到 S3 中的结果位置。
要使用 Synthetics 库日志记录程序，请执行以下操作：
```
const log = require('@aws/synthetics-logger');
```
有用的函数定义：
**log.debug(*message*, *ex* );**
参数：*message* 是要记录的消息。*ex* 是要记录的异常（如果有）。
示例：
```
log.debug("Starting step - login.");
```
**log.error(*message*, *ex* );**
参数：*message* 是要记录的消息。*ex* 是要记录的异常（如果有）。
示例：
```
try {
await login();
catch (ex) {
log.error("Error encountered in step - login.", ex);
}
```
**log.info(*message*, *ex* );**
参数：*message* 是要记录的消息。*ex* 是要记录的异常（如果有）。
示例：
```
log.info("Successfully completed step - login.");
```
**log.log(*message*, *ex* );**
这是 `log.info` 的一个别名。
参数：*message* 是要记录的消息。*ex* 是要记录的异常（如果有）。
示例：
```
log.log("Successfully completed step - login.");
```
**log.warn(*message*, *ex* );**
参数：*message* 是要记录的消息。*ex* 是要记录的异常（如果有）。
示例：
```
log.warn("Exception encountered trying to publish CloudWatch Metric.", ex);
```
### SyntheticsLogHelper 类
`SyntheticsLogHelper` 类在 ` syn-nodejs-puppeteer-3.2` 和更高版本的运行时中可用。其已在 CloudWatch Synthetics 库中初始化，并配置了 Synthetics 配置。您可以将它作为依赖项添加到脚本中。此类使您能够清理 URL、标头和错误消息，以编辑敏感信息。
**注意**
根据 Synthetics 配置设置 `restrictedUrlParameters`，Synthetics 会对其记录的所有 URL 和错误消息进行清理，然后再将它们纳入日志、报告、HAR 文件和金丝雀运行错误中。仅当您在脚本中记录 URL 或错误时，才必须使用 ` getSanitizedUrl` 或 `getSanitizedErrorMessage`。除了脚本引发的金丝雀错误之外，Synthetics 不会存储任何金丝雀构件。金丝雀运行构件存储在您的客户账户中。有关更多信息，请参阅 [Synthetics 金丝雀的安全注意事项](servicelens_canaries_security.md)。
**Topics**
+ [getSanitizedUrl(url, stepConfig = null)](#CloudWatch_Synthetics_Library_getSanitizedUrl)
+ [getSanitizedErrorMessage](#CloudWatch_Synthetics_Library_getSanitizedErrorMessage)
+ [getSanitizedHeaders(headers, stepConfig=null)](#CloudWatch_Synthetics_Library_getSanitizedHeaders)
#### getSanitizedUrl(url, stepConfig = null)
此函数在 `syn-nodejs-puppeteer-3.2` 和更高版本中可用。它根据配置返回经过清理的 url 字符串。您可以通过设置 `restrictedUrlParameters` 属性选择编辑敏感 URL 参数（如密码和 access\$1token）。预设情况下，会编辑 URL 中的密码。如果需要，您可以通过将 `includeUrlPassword` 设置为 true 来启用 URL 密码。
如果传入的 URL 不是有效 URL，此函数会引发一个错误。
**参数 **
+ *url* 是一个字符串，也是要清理的 URL。
+ *StepConfig*（可选）覆盖此函数的全局 Synthetics 配置。如果 `stepConfig` 未传入，则使用全局配置清理 URL。
**示例 **
此示例使用以下示例 URL：` https://example.com/learn/home?access_token=12345&token_type=Bearer&expires_in=1200`。在此示例中，`access_token` 包含不应记录下来的敏感信息。请注意，Synthetics 服务不会存储任何金丝雀运行构件。日志、屏幕截图和报告等构件都存储在您客户账户的 Amazon S3 存储桶中。
第一步，设置 Synthetics 配置。
```
// Import Synthetics dependency
const synthetics = require('@aws/synthetics-puppeteer');
// Import Synthetics logger for logging url
const log = require('@aws/synthetics-logger');
// Get Synthetics configuration
const synConfig = synthetics.getConfiguration();
// Set restricted parameters
synConfig.setConfig({
restrictedUrlParameters: ['access_token'];
});
// Import SyntheticsLogHelper dependency
const syntheticsLogHelper = require('@aws/synthetics-log-helper');
const sanitizedUrl = syntheticsLogHelper.getSanitizedUrl('URL');
const urlConfig = {
restrictedUrlParameters = ['*']
};
const sanitizedUrl = syntheticsLogHelper.getSanitizedUrl('URL', urlConfig);
logger.info('My example url is: ' + sanitizedUrl);
```
接下来，清理并记录 URL
```
// Import SyntheticsLogHelper dependency
const syntheticsLogHelper = require('@aws/synthetics-log-helper');
const sanitizedUrl = syntheticsLogHelper.getSanitizedUrl('https://example.com/learn/home?access_token=12345&token_type=Bearer&expires_in=1200');
```
这一步会将以下内容记录在您的金丝雀日志中。
```
My example url is: https://example.com/learn/home?access_token=REDACTED&token_type=Bearer&expires_in=1200
```
您可以通过传入包含 Synthetics 配置选项的可选参数来覆盖 URL 的 Synthetics 配置，如以下示例所示。
```
const urlConfig = {
restrictedUrlParameters = ['*']
};
const sanitizedUrl = syntheticsLogHelper.getSanitizedUrl('https://example.com/learn/home?access_token=12345&token_type=Bearer&expires_in=1200', urlConfig);
logger.info('My example url is: ' + sanitizedUrl);
```
上面的示例编辑了所有查询参数，并记录如下：
```
My example url is: https://example.com/learn/home?access_token=REDACTED&token_type=REDACTED&expires_in=REDACTED
```
#### getSanitizedErrorMessage
此函数在 `syn-nodejs-puppeteer-3.2` 和更高版本中可用。它根据 Synthetics 配置对所存在的任何 URL 进行清理，返回已清理的错误字符串。您可以选择在调用此函数时通过传递一个可选的 `stepConfig` 参数来覆盖全局 Synthetics 配置。
**参数 **
+ *error* 是要清理的错误。它可以是 Error 对象或字符串。
+ *StepConfig*（可选）覆盖此函数的全局 Synthetics 配置。如果 `stepConfig` 未传入，则使用全局配置清理 URL。
**示例 **
此示例使用以下内容：` Failed to load url: https://example.com/learn/home?access_token=12345&token_type=Bearer&expires_in=1200`
第一步，设置 Synthetics 配置。
```
// Import Synthetics dependency
const synthetics = require('@aws/synthetics-puppeteer');
// Import Synthetics logger for logging url
const log = require('@aws/synthetics-logger');
// Get Synthetics configuration
const synConfig = synthetics.getConfiguration();
// Set restricted parameters
synConfig.setConfig({
restrictedUrlParameters: ['access_token'];
});
```
接下来，清理并记录错误消息
```
// Import SyntheticsLogHelper dependency
const syntheticsLogHelper = require('@aws/synthetics-log-helper');
try {
// Your code which can throw an error containing url which your script logs
} catch (error) {
const sanitizedErrorMessage = syntheticsLogHelper.getSanitizedErrorMessage(errorMessage);
logger.info(sanitizedErrorMessage);
}
```
这一步会将以下内容记录在您的金丝雀日志中。
```
Failed to load url: https://example.com/learn/home?access_token=REDACTED&token_type=Bearer&expires_in=1200
```
#### getSanitizedHeaders(headers, stepConfig=null)
此函数在 `syn-nodejs-puppeteer-3.2` 和更高版本中可用。它根据 ` syntheticsConfiguration` 的 `restrictedHeaders` 属性返回经清理的标头。`restrictedHeaders` 属性中指定的标头是在日志、HAR 文件和报告中编辑的。
**参数 **
+ *headers* 是一个包含要清理的标题的对象。
+ *StepConfig*（可选）覆盖此函数的全局 Synthetics 配置。如果 `stepConfig` 未传入，则使用全局配置来清理标头。
## 仅适用于 UI 金丝雀的 Node.js 库类和函数
以下用于 Node.js 的 CloudWatch Synthetics 库函数仅适用于 UI 金丝雀。
**Topics**
+ [Synthetics 类](#CloudWatch_Synthetics_Library_Synthetics_Class)
+ [BrokenLinkCheckerReport 类](#CloudWatch_Synthetics_Library_BrokenLinkCheckerReport)
+ [SyntheticsLink 类](#CloudWatch_Synthetics_Library_SyntheticsLink)
### Synthetics 类
以下函数位于 Synthetics 类中。
**Topics**
+ [async addUserAgent(page, userAgentString);](#CloudWatch_Synthetics_Library_addUserAgent)
+ [async executeStep(stepName, functionToExecute, [stepConfig]);](#CloudWatch_Synthetics_Library_executeStep)
+ [getDefaultLaunchOptions();](#CloudWatch_Synthetics_Library_getDefaultLaunchOptions)
+ [getPage();](#CloudWatch_Synthetics_Library_getPage)
+ [getRequestResponseLogHelper();](#CloudWatch_Synthetics_Library_getRequestResponseLogHelper)
+ [launch(options)](#CloudWatch_Synthetics_Library_LaunchOptions)
+ [RequestResponseLogHelper 类](#CloudWatch_Synthetics_Library_RequestResponseLogHelper)
+ [setRequestResponseLogHelper();](#CloudWatch_Synthetics_Library_setRequestResponseLogHelper)
+ [async takeScreenshot(name, suffix);](#CloudWatch_Synthetics_Library_takeScreenshot)
#### async addUserAgent(page, userAgentString);
此函数可将 *userAgentString* 附加到指定页面的 User-Agent 标头。
示例：
```
await synthetics.addUserAgent(page, "MyApp-1.0");
```
结果是页面的 User-Agent 标头被设置为 ` browsers-user-agent-header-valueMyApp-1.0`
#### async executeStep(stepName, functionToExecute, [stepConfig]);
执行提供的步骤，并使用开始/通过/失败日志记录、开始/通过/失败屏幕截图，以及通过/失败和持续时间指标对其进行包装。
**注意**
如果您使用的是 `syn-nodejs-2.1` 或更高版本的运行时，您可以配置是否以及何时捕获屏幕截图。有关更多信息，请参阅 [SyntheticsConfiguration 类](#CloudWatch_Synthetics_Library_SyntheticsConfiguration)。
`executeStep` 函数还执行以下操作：
+ 记录步骤开始。
+ 获取名为 `-starting` 的屏幕截图。
+ 启动计时器。
+ 执行提供的函数。
+ 如果函数正常返回，则计为通过。如果函数引发异常，则计为失败。
+ 结束计时器。
+ 记录步骤是通过还是失败
+ 获取名为 `-succeeded` 或 ` -failed` 的屏幕截图。
+ 发出 `stepName` `SuccessPercent` 指标，100 表示通过，0 表示失败。
+ 发出 `stepName` `Duration` 指标，指标的值基于步骤开始和结束时间。
+ 最后，返回 `functionToExecute` 返回的内容或重新抛出 `functionToExecute` 抛出的内容。
如果金丝雀使用 `syn-nodejs-2.0` 或更高版本的运行时，则此函数还将步骤执行摘要添加到金丝雀的报告中。摘要包括有关每个步骤的详细信息，例如开始时间、结束时间、状态 (PASSED/FAILED)、故障原因（如失败）以及在每个步骤执行过程中捕获的屏幕截图。
示例：
```
await synthetics.executeStep('navigateToUrl', async function (timeoutInMillis = 30000) {
await page.goto(url, {waitUntil: ['load', 'networkidle0'], timeout: timeoutInMillis});});
```
响应：
返回 `functionToExecute` 返回的内容。
**syn-nodejs-2.2 的更新**
从 `syn-nodejs-2.2` 开始，您可以选择传递步骤配置来在步骤级别覆盖 CloudWatch Synthetics 配置。有关可以传递给 `executeStep` 的选项列表，请参阅 [SyntheticsConfiguration 类](#CloudWatch_Synthetics_Library_SyntheticsConfiguration)。
在以下示例中，用 `true` 覆盖 ` continueOnStepFailure` 的默认 `false` 配置，并指定捕获屏幕截图的时间。
```
var stepConfig = {
'continueOnStepFailure': true,
'screenshotOnStepStart': false,
'screenshotOnStepSuccess': true,
'screenshotOnStepFailure': false
}
await executeStep('Navigate to amazon', async function (timeoutInMillis = 30000) {
await page.goto(url, {waitUntil: ['load', 'networkidle0'], timeout: timeoutInMillis});
}, stepConfig);
```
#### getDefaultLaunchOptions();
`getDefaultLaunchOptions()` 函数返回 CloudWatch Synthetics 使用的浏览器启动选项。有关更多信息，请参阅 [启动选项类型](https://pptr.dev/browsers-api/browsers.launchoptions/)
```
// This function returns default launch options used by Synthetics.
const defaultOptions = await synthetics.getDefaultLaunchOptions();
```
#### getPage();
返回当前打开的页面作为 Puppeteer 对象。有关更多信息，请参阅 [Puppeteer API v1.14.0](https://github.com/puppeteer/puppeteer/blob/v1.14.0/docs/api.md)。
示例：
```
let page = await synthetics.getPage();
```
响应：
在当前浏览器会话中打开的页面（Puppeteer 对象）。
#### getRequestResponseLogHelper();
**重要**
在使用 `syn-nodejs-puppeteer-3.2` 或更高版本运行时的金丝雀中，此函数将与 `RequestResponseLogHelper` 类一起弃用。对此函数的任何使用都会导致在金丝雀日志中出现警告。将在未来的运行时版本中删除此函数。如果您正在使用此函数，请改为使用 [RequestResponseLogHelper 类](#CloudWatch_Synthetics_Library_RequestResponseLogHelper)。
将此函数用作生成器模式，用于调整请求和响应日志记录标记。
示例：
```
synthetics.setRequestResponseLogHelper(getRequestResponseLogHelper().withLogRequestHeaders(false));;
```
响应：
```
{RequestResponseLogHelper}
```
#### launch(options)
此函数的选项仅在 `syn-nodejs-2.1` 版本或更高版本的运行时中可用。
此函数仅用于 UI 金丝雀。它的作用是关闭现有浏览器并启动一个新的浏览器。
**注意**
在开始运行脚本之前，CloudWatch Synthetics 始终启动浏览器。除非您想使用自定义选项启动新浏览器，否则不需要调用 launch()。
(options) 是在浏览器上设置的一组可配置的选项。有关更多信息，请参阅 [LaunchOptions 类型](https://pptr.dev/browsers-api/browsers.launchoptions/)。
如果您在不设置选项的情况下调用此函数，Synthetics 会以默认参数、`executablePath` 和 `defaultViewport` 启动浏览器。CloudWatch Synthetics 中的默认视区是 1920 x 1080。
您可以覆盖 CloudWatch Synthetics 使用的启动参数，并在启动浏览器时传递其他参数。例如，以下代码段以默认参数和默认可执行文件路径启动浏览器，但视区为 800 x 600。
```
await synthetics.launch({
defaultViewport: {
"deviceScaleFactor": 1,
"width": 800,
"height": 600
}});
```
以下示例代码向 CloudWatch Synthetics 启动参数中添加了一个新的 `ignoreHTTPSErrors` 参数。
```
await synthetics.launch({
ignoreHTTPSErrors: true
});
```
您可以通过向 CloudWatch Synthetics 启动参数中的参数添加一个 `--disable-web-security` 标志来禁用 Web 安全：
```
// This function adds the --disable-web-security flag to the launch parameters
const defaultOptions = await synthetics.getDefaultLaunchOptions();
const launchArgs = [...defaultOptions.args, '--disable-web-security'];
await synthetics.launch({
args: launchArgs
});
```
#### RequestResponseLogHelper 类
**重要**
在使用 `syn-nodejs-puppeteer-3.2` 或更高版本运行时的金丝雀中，此类将被弃用。对此类的任何使用都会导致在金丝雀日志中出现警告。将在未来的运行时版本中删除此函数。如果您正在使用此函数，请改为使用 [RequestResponseLogHelper 类](#CloudWatch_Synthetics_Library_RequestResponseLogHelper)。
处理精细配置，以及创建请求和响应负载的字符串表示。
```
class RequestResponseLogHelper {
constructor () {
this.request = {url: true, resourceType: false, method: false, headers: false, postData: false};
this.response = {status: true, statusText: true, url: true, remoteAddress: false, headers: false};
}
withLogRequestUrl(logRequestUrl);
withLogRequestResourceType(logRequestResourceType);
withLogRequestMethod(logRequestMethod);
withLogRequestHeaders(logRequestHeaders);
withLogRequestPostData(logRequestPostData);
withLogResponseStatus(logResponseStatus);
withLogResponseStatusText(logResponseStatusText);
withLogResponseUrl(logResponseUrl);
withLogResponseRemoteAddress(logResponseRemoteAddress);
withLogResponseHeaders(logResponseHeaders);
```
示例：
```
synthetics.setRequestResponseLogHelper(getRequestResponseLogHelper()
.withLogRequestPostData(true)
.withLogRequestHeaders(true)
.withLogResponseHeaders(true));
```
响应：
```
{RequestResponseLogHelper}
```
#### setRequestResponseLogHelper();
**重要**
在使用 `syn-nodejs-puppeteer-3.2` 或更高版本运行时的金丝雀中，此函数将与 `RequestResponseLogHelper` 类一起弃用。对此函数的任何使用都会导致在金丝雀日志中出现警告。将在未来的运行时版本中删除此函数。如果您正在使用此函数，请改为使用 [RequestResponseLogHelper 类](#CloudWatch_Synthetics_Library_RequestResponseLogHelper)。
将此函数用作成生器模式，用于设置请求和响应日志记录标记。
示例：
```
synthetics.setRequestResponseLogHelper().withLogRequestHeaders(true).withLogResponseHeaders(true);
```
响应：
```
{RequestResponseLogHelper}
```
#### async takeScreenshot(name, suffix);
捕获当前页面的屏幕截图 (.PNG) 并命名和添加后缀（可选）。
示例：
```
await synthetics.takeScreenshot("navigateToUrl", "loaded")
```
在此示例中，捕获了名为 ` 01-navigateToUrl-loaded.png` 的屏幕截图并将其上载到金丝雀的 S3 存储桶。
您可以传递 ` stepName` 作为第一个参数，捕获特定金丝雀步骤的屏幕截图。屏幕截图会链接到报告中的金丝雀步骤，以帮助您在调试时跟踪每个步骤。
CloudWatch Synthetics 金丝雀会在开始步骤之前（`executeStep` 函数）和步骤完成后自动捕获屏幕截图（除非您将金丝雀配置为禁用屏幕截图）。您可以通过将步骤名称传入 `takeScreenshot` 函数来捕获多个屏幕截图。
在以下示例中，捕获屏幕截图并将 `signupForm` 作为 `stepName` 的值。屏幕截图将被命名为 ` 02-signupForm-address`，并链接到金丝雀报告中名为 ` signupForm` 的步骤。
```
await synthetics.takeScreenshot('signupForm', 'address')
```
### BrokenLinkCheckerReport 类
此类提供了添加 Synthetics 链接的方法。仅在使用 `syn-nodejs-2.0-beta` 或更高版本运行时的金丝雀上支持此类。
若要使用 `BrokenLinkCheckerReport`，脚本中需包括以下行：
```
const BrokenLinkCheckerReport = require('@aws/synthetics-broken-link-checker-report');
const brokenLinkCheckerReport = new BrokenLinkCheckerReport();
```
有用的函数定义：
**addLink(*syntheticsLink*, isBroken)**
` syntheticsLink ` 是一个 ` SyntheticsLink` 对象，表示链接。此函数根据状态代码添加链接。预设情况下，如果状态代码不可用或状态代码为 400 或以上，则其会将链接视为无效。您可以通过传入可选参数 `isBrokenLink`（带有值 `true` 或 `false`）来覆盖此默认行为。
此函数无返回值。
**getLinks()**
此函数返回一组 `SyntheticsLink` 对象，这些对象包含在无效链接检查器报告。
**getTotalBrokenLinks()**
此函数返回一个表示无效链接总数的数字。
**getTotalLinksChecked()**
此函数返回一个表示包含在报告中的链接总数的数字。
**如何使用 BrokenLinkCheckerReport**
以下金丝雀脚本代码段展示了导航到链接并将其添加到无效链接检查器报告的示例。
1. 导入 `SyntheticsLink`、`BrokenLinkCheckerReport` 和 ` Synthetics`。
```
const BrokenLinkCheckerReport = require('@aws/synthetics-broken-link-checker-report');
const SyntheticsLink = require('@aws/synthetics-link');
// Synthetics dependency
const synthetics = require('@aws/synthetics-puppeteer');
```
1. 若要向报告添加链接，请创建 ` BrokenLinkCheckerReport` 实例。
```
let brokenLinkCheckerReport = new BrokenLinkCheckerReport();
```
1. 导航到 URL 并将其添加到无效链接检查器报告中。
```
let url = "https://amazon.com";
let syntheticsLink = new SyntheticsLink(url);
// Navigate to the url.
let page = await synthetics.getPage();
// Create a new instance of Synthetics Link
let link = new SyntheticsLink(url)
try {
const response = await page.goto(url, {waitUntil: 'domcontentloaded', timeout: 30000});
} catch (ex) {
// Add failure reason if navigation fails.
link.withFailureReason(ex);
}
if (response) {
// Capture screenshot of destination page
let screenshotResult = await synthetics.takeScreenshot('amazon-home', 'loaded');
// Add screenshot result to synthetics link
link.addScreenshotResult(screenshotResult);
// Add status code and status description to the link
link.withStatusCode(response.status()).withStatusText(response.statusText())
}
// Add link to broken link checker report.
brokenLinkCheckerReport.addLink(link);
```
1. 将报告添加到 Synthetics。这样，金丝雀每次运行都会在 S3 存储桶中创建一个名为 ` BrokenLinkCheckerReport.json` 的 JSON 文件。您可以在控制台中查看金丝雀每次运行的链接报告以及屏幕截图、日志和 HAR 文件。
```
await synthetics.addReport(brokenLinkCheckerReport);
```
### SyntheticsLink 类
此类提供了包装信息的方法。仅在使用 `syn-nodejs-2.0-beta` 或更高版本运行时的金丝雀上支持此类。
若要使用 `SyntheticsLink`，脚本中需包括以下行：
```
const SyntheticsLink = require('@aws/synthetics-link');
const syntheticsLink = new SyntheticsLink("https://www.amazon.com");
```
此函数返回 `syntheticsLinkObject`
有用的函数定义：
**withUrl(*url*)**
` url ` 是一个 URL 字符串。此函数返回 `syntheticsLinkObject`
**withText(*text*)**
` text ` 是一个表示锚文本的字符串。此函数返回 `syntheticsLinkObject`。它会添加与链接相对应的锚文本。
**withParentUrl(*parentUrl*)**
` parentUrl ` 是一个表示父（源页面）URL 的字符串。此函数返回 `syntheticsLink Object`
**withStatusCode(*statusCode*)**
` statusCode ` 是一个表示状态代码的字符串。此函数返回 `syntheticsLinkObject`
**withFailureReason(*failureReason*)**
` failureReason ` 是一个表示故障原因的字符串。此函数返回 `syntheticsLink Object`
**addScreenshotResult(*screenshotResult*)**
` screenshotResult ` 是一个对象。它是 Synthetics 函数 `takeScreenshot` 返回的 `ScreenshotResult` 的实例。此对象包括以下属性：
+ `fileName` – 表示 ` screenshotFileName` 的字符串
+ `pageUrl`（可选）
+ `error`（可选）
## 仅适用于 API 金丝雀的 Node.js 库类和函数
以下用于 Node.js 的 CloudWatch Synthetics 库函数仅适用于 API 金丝雀。
**Topics**
+ [executeHttpStep(stepName, requestOptions, [callback], [stepConfig])](#CloudWatch_Synthetics_Library_executeHttpStep)
### executeHttpStep(stepName, requestOptions, [callback], [stepConfig])
作为步骤执行提供的 HTTP 请求，并发布 `SuccessPercent`（通过/失败）和 `Duration` 指标。
**executeHttpStep** 在后台使用 HTTP 或 HTTPS 本机函数，具体取决于请求中指定的协议。
此函数还将步骤执行摘要添加到金丝雀的报告中。摘要中包括有关每个 HTTP 请求的详细信息，如下所示：
+ 开始时间
+ 结束时间
+ 状态 (PASSED/FAILED)
+ 故障原因（如失败）
+ HTTP 调用详细信息，如请求/响应标头、请求/响应体、状态代码、状态消息和性能计时。
**Topics**
+ [参数](#CloudWatch_Synthetics_Library_executeHttpStep_parameters)
+ [executeHttpStep 的使用示例](#CloudWatch_Synthetics_Library_executeHttpStep_examples)
#### 参数
**stepName(*String*)**
指定步骤的名称。此名称也用于发布此步骤的 CloudWatch 指标。
**requestOptions(*Object or String*)**
此参数的值可以是 URL、URL 字符串或对象。如果为对象，则必须是用以发出 HTTP 请求的一组可配置选项。其支持 Node.js 文档中 [http.request(options[, callback])](https://nodejs.org/api/http.html#http_http_request_options_callback) 中的所有选项。
除了这些 Node.js 选项之外，**requestOptions** 支持附加参数 `body`。您可以使用 `body` 参数将数据作为请求体传递。
**callback(*response*)**
（可选）此函数是与 HTTP 响应一起调用的用户函数。响应的类型为 [Class: http.IncomingMessage](https://nodejs.org/api/http.html#http_class_http_incomingmessage)。
**stepConfig(*object*)**
（可选）使用此参数，可以用此步骤的不同配置覆盖全局 synthetics 配置。
#### executeHttpStep 的使用示例
以下一系列示例相互依存，以说明此选项的各种用途。
第一个示例展示配置请求参数。您可以将 URL 作为 **requestOptions** 传递：
```
let requestOptions = 'https://www.amazon.com';
```
或者，您也可以传递一组选项：
```
let requestOptions = {
'hostname': 'myproductsEndpoint.com',
'method': 'GET',
'path': '/test/product/validProductName',
'port': 443,
'protocol': 'https:'
};
```
在下一个示例中，创建一个接受响应的回调函数。预设情况下，如果您未指定 **callback**，CloudWatch Synthetics 会验证状态是否介于 200 和 299 之间（含）。
```
// Handle validation for positive scenario
const callback = async function(res) {
return new Promise((resolve, reject) => {
if (res.statusCode < 200 || res.statusCode > 299) {
throw res.statusCode + ' ' + res.statusMessage;
}
let responseBody = '';
res.on('data', (d) => {
responseBody += d;
});
res.on('end', () => {
// Add validation on 'responseBody' here if required. For ex, your status code is 200 but data might be empty
resolve();
});
});
};
```
下一个示例展示为此步骤创建覆盖全局 CloudWatch Synthetics 配置的配置。在本示例中，步骤配置允许报告中包含请求标头、响应标头、请求体（发布数据）和响应体，并限制了“X-Amz-Security-Token”和“Authorization”标头值。预设情况下，出于安全原因，报告中不包括这些值。如果您选择将它们包含在报告中，则这些数据仅存储在 S3 存储桶中。
```
// By default headers, post data, and response body are not included in the report for security reasons.
// Change the configuration at global level or add as step configuration for individual steps
let stepConfig = {
includeRequestHeaders: true,
includeResponseHeaders: true,
restrictedHeaders: ['X-Amz-Security-Token', 'Authorization'], // Restricted header values do not appear in report generated.
includeRequestBody: true,
includeResponseBody: true
};
```
最后一个例子展示将请求传递给 **executeHttpStep** 并对步骤命名。
```
await synthetics.executeHttpStep('Verify GET products API', requestOptions, callback, stepConfig);
```
在这组示例中，CloudWatch Synthetics 将每个步骤的详细信息添加在报告中，并使用 **stepName** 生成每个步骤的指标。
您将看到 `Verify GET products API` 步骤的 `successPercent` 和 `duration` 指标。您可以通过监控 API 调用步骤的指标来监控 API 性能。
有关使用这些函数的完整脚本示例，请参阅 [多步骤 API 金丝雀](CloudWatch_Synthetics_Canaries_Samples.md#CloudWatch_Synthetics_Canaries_Samples_APIsteps)。
# 可用于使用 Selenium 的 Python 金丝雀脚本的库函数
本节列出了可用于 Python 金丝雀脚本的 Selenium 库函数。
**Topics**
+ [适用于所有金丝雀的 Python 和 Selenium 库类和函数](#CloudWatch_Synthetics_Library_allcanaries_Python)
+ [仅适用于 UI 金丝雀的 Python 和 Selenium 库类和函数](#CloudWatch_Synthetics_Library_Python_UIcanaries)
## 适用于所有金丝雀的 Python 和 Selenium 库类和函数
以下用于 Python 的 CloudWatch Synthetics 库函数适用于所有金丝雀。
**Topics**
+ [SyntheticsConfiguration 类](#CloudWatch_Synthetics_Library_SyntheticsConfiguration_Python)
+ [SyntheticsLogger 类](#CloudWatch_Synthetics_Library_SyntheticsLogger_Python)
### SyntheticsConfiguration 类
您可以使用 SyntheticsConfiguration 类来配置 Synthetics 库函数的行为。例如，您可以使用此类将 ` executeStep()` 函数配置为不捕获屏幕截图。
您可以在全局级别设置 CloudWatch Synthetics 配置。
函数定义：
#### set\$1config(options)
```
from aws_synthetics.common import synthetics_configuration
```
` options ` 是一个对象，它是一组适用于您的金丝雀的可配置选项。以下各节将介绍 ` options ` 中的可能字段。
+ `screenshot_on_step_start`（布尔值）– 是否在开始步骤之前捕获屏幕截图。
+ `screenshot_on_step_success`（布尔值）– 是否在成功完成步骤后捕获屏幕截图。
+ `screenshot_on_step_failure`（布尔值）– 是否在步骤失败后捕获屏幕截图。
**with\$1screenshot\$1on\$1step\$1start(screenshot\$1on\$1step\$1start)**
接受一个布尔参数，该参数指示是否在开始步骤之前捕获屏幕截图。
**with\$1screenshot\$1on\$1step\$1success(screenshot\$1on\$1step\$1success)**
接受一个布尔参数，该参数指示是否在成功完成步骤后捕获屏幕截图。
**with\$1screenshot\$1on\$1step\$1failure(screenshot\$1on\$1step\$1failure)**
接受一个布尔参数，该参数指示是否在步骤失败后捕获屏幕截图。
**get\$1screenshot\$1on\$1step\$1start()**
返回是否在开始步骤之前捕获屏幕截图。
**get\$1screenshot\$1on\$1step\$1success()**
返回是否在成功完成步骤后捕获屏幕截图。
**get\$1screenshot\$1on\$1step\$1failure()**
返回是否在步骤失败后捕获屏幕截图。
**disable\$1step\$1screenshots()**
禁用所有屏幕截图选项（get\$1screenshot\$1on\$1step\$1start、get\$1screenshot\$1on\$1step\$1success 和 get\$1screenshot\$1on\$1step\$1failure）。
**enable\$1step\$1screenshots()**
启用所有屏幕截图选项（get\$1screenshot\$1on\$1step\$1start、get\$1screenshot\$1on\$1step\$1success 和 get\$1screenshot\$1on\$1step\$1failure)。预设情况下，这些方法均未启用。
**CloudWatch 指标的相关 setConfig(options)**
对于使用 `syn-python-selenium-1.1` 或更新版本的金丝雀，**setConfig** 的 **(options)** 可包含以下布尔参数，这些参数决定将由金丝雀发布的指标。其中每个选项的默认值均为 `true`。以 ` aggregated` 开头的选项决定是否不带 ` CanaryName` 维度发出指标。您可以使用该等指标查看所有金丝雀的聚合结果。其他选项决定是否带 `CanaryName` 维度发出指标。您可以使用该等指标查看每个金丝雀的结果。
有关金丝雀发出的 CloudWatch 指标的列表，请参阅 [金丝雀发布的 CloudWatch 指标](CloudWatch_Synthetics_Canaries_metrics.md)。
+ `failed_canary_metric`（布尔值）– 是否发出此金丝雀的 ` Failed` 指标（带 `CanaryName` 维度）。默认值为 `true`。
+ `failed_requests_metric`（布尔值）– 是否发出此金丝雀的 `Failed requests` 指标（带 `CanaryName` 维度）。默认值为 `true`。
+ `2xx_metric`（布尔值）– 是否发出此金丝雀的 `2xx` 指标（带 `CanaryName` 维度）。默认值为 `true`。
+ `4xx_metric`（布尔值）– 是否发出此金丝雀的 `4xx` 指标（带 `CanaryName` 维度）。默认值为 `true`。
+ `5xx_metric`（布尔值）– 是否发出此金丝雀的 `5xx` 指标（带 `CanaryName` 维度）。默认值为 `true`。
+ `step_duration_metric`（布尔值）– 是否发出此金丝雀的 `Step duration` 指标（带 `CanaryName` `StepName` 维度）。默认值为 `true`。
+ `step_success_metric`（布尔值）– 是否发出此金丝雀的 `Step success` 指标（带 `CanaryName` `StepName` 维度）。默认值为 `true`。
+ `aggregated_failed_canary_metric`（布尔值）– 是否发出此金丝雀的 `Failed` 指标（不带 `CanaryName` 维度）。默认值为 `true`。
+ `aggregated_failed_requests_metric`（布尔值）– 是否发出此金丝雀的 `Failed Requests` 指标（不带 `CanaryName` 维度）。默认值为 `true`。
+ `aggregated_2xx_metric`（布尔值）– 是否发出此金丝雀的 ` 2xx` 指标（不带 `CanaryName` 维度）。默认值为 `true`。
+ `aggregated_4xx_metric`（布尔值）– 是否发出此金丝雀的 ` 4xx` 指标（不带 `CanaryName` 维度）。默认值为 `true`。
+ `aggregated_5xx_metric`（布尔值）– 是否发出此金丝雀的 ` 5xx` 指标（不带 `CanaryName` 维度）。默认值为 `true`。
**with\$12xx\$1metric(2xx\$1metric)**
接受一个布尔参数，该参数指定是否为此金丝雀发出带 `CanaryName` 维度的 `2xx` 指标。
**with\$14xx\$1metric(4xx\$1metric)**
接受一个布尔参数，该参数指定是否为此金丝雀发出带 `CanaryName` 维度的 `4xx` 指标。
**with\$15xx\$1metric(5xx\$1metric)**
接受一个布尔参数，该参数指定是否为此金丝雀发出带 `CanaryName` 维度的 `5xx` 指标。
**withAggregated2xxMetric(aggregated2xxMetric)**
接受一个布尔参数，该参数指定是否为此金丝雀发出不带维度的 `2xx` 指标。
**withAggregated4xxMetric(aggregated4xxMetric)**
接受一个布尔参数，该参数指定是否为此金丝雀发出不带维度的 `4xx` 指标。
**with\$1aggregated\$15xx\$1metric(aggregated\$15xx\$1metric)**
接受一个布尔参数，该参数指定是否为此金丝雀发出不带维度的 `5xx` 指标。
**with\$1aggregated\$1failed\$1canary\$1metric(aggregated\$1failed\$1canary\$1metric)**
接受一个布尔参数，该参数指定是否为此金丝雀发出不带维度的 `Failed` 指标。
**with\$1aggregated\$1failed\$1requests\$1metric(aggregated\$1failed\$1requests\$1metric)**
接受一个布尔参数，该参数指定是否为此金丝雀发出不带维度的 `Failed requests` 指标。
**with\$1failed\$1canary\$1metric(failed\$1canary\$1metric)**
接受一个布尔参数，该参数指定是否为此金丝雀发出带 `CanaryName` 维度的 `Failed` 指标。
**with\$1failed\$1requests\$1metric(failed\$1requests\$1metric)**
接受一个布尔参数，该参数指定是否为此金丝雀发出带 `CanaryName` 维度的 `Failed requests` 指标。
**with\$1step\$1duration\$1metric(step\$1duration\$1metric)**
接受一个布尔参数，该参数指定是否为此金丝雀发出带 `CanaryName` 维度的 `Duration` 指标。
**with\$1step\$1success\$1metric(step\$1success\$1metric)**
接受一个布尔参数，该参数指定是否为此金丝雀发出带 `CanaryName` 维度的 `StepSuccess` 指标。
##### 用于启用或禁用指标的方法
**disable\$1aggregated\$1request\$1metrics()**
禁用金丝雀发出以不带 ` CanaryName` 维度形式发出的所有请求指标。
**disable\$1request\$1metrics()**
禁用所有请求指标，包括每个金丝雀的指标和跨所有金丝雀聚合的指标。
**disable\$1step\$1metrics()**
禁用所有步骤指标，包括步骤成功指标和步骤持续时间指标。
**enable\$1aggregated\$1request\$1metrics()**
启用金丝雀发出以不带 ` CanaryName` 维度形式发出的所有请求指标。
**enable\$1request\$1metrics()**
启用所有请求指标，包括每个金丝雀的指标和跨所有金丝雀聚合的指标。
**enable\$1step\$1metrics()**
启用所有步骤指标，包括步骤成功指标和步骤持续时间指标。
**在 UI 金丝雀中的使用情况**
首先，导入 Synthetics 依赖关系并获取配置。然后，通过使用以下选项之一调用 setConfig 方法来设置每个选项的配置。
```
from aws_synthetics.common import synthetics_configuration
synthetics_configuration.set_config(
{
"screenshot_on_step_start": False,
"screenshot_on_step_success": False,
"screenshot_on_step_failure": True
}
)
or
```
Or
```
synthetics_configuration.with_screenshot_on_step_start(False).with_screenshot_on_step_success(False).with_screenshot_on_step_failure(True)
```
若要禁用所有屏幕截图，请使用 disableStepScreenshots() 函数，如本示例所示。
```
synthetics_configuration.disable_step_screenshots()
```
您可以在代码中的任何位置启用和禁用屏幕截图。例如，若要仅禁用一个步骤的屏幕截图，请在运行该步骤之前禁用屏幕截图，然后在该步骤后启用它们。
##### 用于 UI 金丝雀的 set\$1config(options)
从 `syn-python-selenium-1.1` 开始，对于 UI 金丝雀，` set_config` 可包含以下布尔参数:
+ `continue_on_step_failure`（布尔值）– 是否在步骤失败（指 **executeStep** 函数）后继续运行金丝雀脚本。如果任何步骤失败，金丝雀运行仍将被标记为失败。默认值为 `false`。
### SyntheticsLogger 类
`synthetics_logger` 将日志写入控制台和同一日志级别的本地日志文件。仅当日志级别与所调用的日志函数所需的日志记录级别相同或比其级别低时，此日志文件才会写入到这两个位置。
本地日志文件中的日志记录语句前面加上“DEBUG:”、“INFO:”等，以便与所调用的函数的日志级别相匹配。
如果要创建上载到 Amazon S3 结果位置的日志文件，不需要使用 `synthetics_logger`。您可以在 `/tmp` 文件夹中创建不同的日志文件。在 `/tmp` 文件夹下创建的任何文件都会作为构件上载到 S3 存储桶中的结果位置。
若要使用 `synthetics_logger`：
```
from aws_synthetics.common import synthetics_logger
```
****有用的函数定义：
获取日志级别：
```
log_level = synthetics_logger.get_level()
```
设置日志级别：
```
synthetics_logger.set_level()
```
使用指定级别记录消息。该级别可以是 `DEBUG`、` INFO`、`WARN`，或 `ERROR`，如以下语法示例所示：
```
synthetics_logger.debug(message, *args, **kwargs)
```
```
synthetics_logger.info(message, *args, **kwargs)
```
```
synthetics_logger.log(message, *args, **kwargs)
```
```
synthetics_logger.warning(message, *args, **kwargs)
```
```
synthetics_logger.error(message, *args, **kwargs)
```
有关调试参数的信息，请参阅标准 Python 文档中的 [logging.debug](https://docs.python.org/3/library/logging.html#logging.debug)
在这些日志记录函数中，`message` 为消息格式的字符串。`args` 为合并到使用字符串格式运算符的 `msg` 中的参数。
`kwargs` 中有三个关键字参数：
+ `exc_info` – 如果未评估为 false，则会将异常信息添加到日志记录消息中。
+ `stack_info` – 默认值为 false。如果为 true，则会将堆栈信息添加到日志记录消息中，包括实际的日志记录调用。
+ `extra` – 第三个可选关键字参数，您可以使用该参数将用于填充 `LogRecord`（为具有用户定义属性的日志记录事件而创建）的 `__dict__` 传入字典。
示例：
使用 `DEBUG` 级别记录消息：
```
synthetics_logger.debug('Starting step - login.')
```
使用 `INFO` 级别记录消息。`logger.log` 是 `logger.info` 的同义词：
```
synthetics_logger.info('Successfully completed step - login.')
```
或者
```
synthetics_logger.log('Successfully completed step - login.')
```
使用 `WARN` 级别记录消息：
```
synthetics_logger.warning('Warning encountered trying to publish %s', 'CloudWatch Metric')
```
使用 `ERROR` 级别记录消息：
```
synthetics_logger.error('Error encountered trying to publish %s', 'CloudWatch Metric')
```
记录异常：
```
synthetics_logger.exception(message, *args, **kwargs)
```
使用 `ERROR` 级别记录消息。异常信息将会添加到日志记录消息中。您应该只从异常处理程序调用此函数。
有关异常参数的信息，请参阅标准 Python 文档中的 [logging.exception](https://docs.python.org/3/library/logging.html#logging.exception)
`message` 为消息格式的字符串。`args` 为合并到使用字符串格式运算符的 `msg` 中的参数。
`kwargs` 中有三个关键字参数：
+ `exc_info` – 如果未评估为 false，则会将异常信息添加到日志记录消息中。
+ `stack_info` – 默认值为 false。如果为 true，则会将堆栈信息添加到日志记录消息中，包括实际的日志记录调用。
+ `extra` – 第三个可选关键字参数，您可以使用该参数将用于填充 `LogRecord`（为具有用户定义属性的日志记录事件而创建）的 `__dict__` 传入字典。
示例：
```
synthetics_logger.exception('Error encountered trying to publish %s', 'CloudWatch Metric')
```
## 仅适用于 UI 金丝雀的 Python 和 Selenium 库类和函数
以下用于 Python 的 CloudWatch Synthetics Selenium 库函数仅适用于 UI 金丝雀。
**Topics**
+ [SyntheticsBrowser 类](#CloudWatch_Synthetics_Library_Python_SyntheticsBrowser)
+ [SyntheticsWebDriver 类](#CloudWatch_Synthetics_Library_Python_SyntheticsWebDriver)
### SyntheticsBrowser 类
**注意**
Chrome 是唯一支持 `SyntheticsBrowser` 的浏览器。
当您通过调用 `synthetics_webdriver.Chrome()` 创建浏览器实例时，返回的浏览器实例类型为 `SyntheticsBrowser`。` SyntheticsBrowser` 类继承自 WebDriver 类，并提供对 [WebDriver](https://www.selenium.dev/documentation/webdriver/) 公开的所有方法的访问权限。它控制 ChromeDriver，并使 Canary 脚本能够驱动浏览器，从而允许 Selenium WebDriver 使用 Synthetics。
**注意**
Synthetics 重写了 WebDriver 的 [quit](https://www.selenium.dev/selenium/docs/api/py/selenium_webdriver_firefox/selenium.webdriver.firefox.webdriver.html) 方法，使其不执行任何操作。您无需担心关闭浏览器的问题，因为 Synthetics 会为您处理此事。
除了标准的 Selenium 方法之外，它还提供了以下方法。
**Topics**
+ [set\$1viewport\$1size(width, height)](#CloudWatch_Synthetics_Library_set_viewport_size)
+ [save\$1screenshot(filename, suffix)](#CloudWatch_Synthetics_Library_save_screenshot)
#### set\$1viewport\$1size(width, height)
设置浏览器的视区。示例：
```
browser.set_viewport_size(1920, 1080)
```
#### save\$1screenshot(filename, suffix)
将屏幕截图保存到 `/tmp` 目录。屏幕截图将上载到 S3 存储桶中的金丝雀构件文件夹。
*filename* 是屏幕截图的文件名，*suffix* 是用于命名屏幕截图的可选字符串。
示例：
```
browser.save_screenshot('loaded.png', 'page1')
```
### SyntheticsWebDriver 类
要使用此类，请在脚本中使用以下内容：
```
from aws_synthetics.selenium import synthetics_webdriver
```
**Topics**
+ [add\$1execution\$1error(errorMessage, ex);](#CloudWatch_Synthetics_Library_Python_addExecutionError)
+ [add\$1user\$1agent(user\$1agent\$1str)](#CloudWatch_Synthetics_Library_add_user_agent)
+ [execute\$1step(step\$1name, function\$1to\$1execute)](#CloudWatch_Synthetics_Library_Python_execute_step)
+ [get\$1http\$1response(url)](#CloudWatch_Synthetics_Library_Python_get_http_response)
+ [Chrome()](#CloudWatch_Synthetics_Library_Python_Chrome)
#### add\$1execution\$1error(errorMessage, ex);
`errorMessage` 描述错误，`ex` 指遇到的异常
您可以使用 `add_execution_error` 来设置金丝雀的执行错误。它会在不中断脚本执行的情况下导致金丝雀失败。它也不会影响 `successPercent` 指标。
只有当错误对于指示金丝雀脚本成功或故障并不重要时，才应将错误作为执行错误进行跟踪。
以下是使用 `add_execution_error` 的示例。您将会监控端点的可用性，并在页面加载完成后捕获屏幕截图。由于捕获屏幕截图故障并不会决定端点的可用性，因此您可以捕获在截图时遇到的任何错误，并将它们添加为执行错误。可用性指标仍会指示端点已启动并正在运行，但金丝雀状态会被标记为失败。以下示例代码块将会捕获此类错误并将其添加为执行错误。
```
try:
browser.save_screenshot("loaded.png")
except Exception as ex:
self.add_execution_error("Unable to take screenshot", ex)
```
#### add\$1user\$1agent(user\$1agent\$1str)
将 `user_agent_str` 的值附加到浏览器的用户代理标头。您必须在创建浏览器实例之前分配 `user_agent_str`。
示例：
```
await synthetics_webdriver.add_user_agent('MyApp-1.0')
```
`add_user_agent` 应在 `async` 函数内使用。
#### execute\$1step(step\$1name, function\$1to\$1execute)
处理一个函数。它还执行以下操作：
+ 记录步骤开始。
+ 获取名为 `-starting` 的屏幕截图。
+ 启动计时器。
+ 执行提供的函数。
+ 如果函数正常返回，则计为通过。如果函数引发异常，则计为失败。
+ 结束计时器。
+ 记录步骤是通过还是失败
+ 获取名为 `-succeeded` 或 ` -failed` 的屏幕截图。
+ 发出 `stepName` `SuccessPercent` 指标，100 表示通过，0 表示失败。
+ 发出 `stepName` `Duration` 指标，指标的值基于步骤开始和结束时间。
+ 最后，返回 `functionToExecute` 返回的内容或重新抛出 `functionToExecute` 抛出的内容。
示例：
```
from selenium.webdriver.common.by import By
def custom_actions():
#verify contains
browser.find_element(By.XPATH, "//*[@id=\"id_1\"][contains(text(),'login')]")
#click a button
browser.find_element(By.XPATH, '//*[@id="submit"]/a').click()
await synthetics_webdriver.execute_step("verify_click", custom_actions)
```
#### get\$1http\$1response(url)
对提供的 URL 发出 HTTP 请求并返回 HTTP 请求的响应代码。如果 HTTP 请求期间发生异常，则返回值为“error”的字符串。
示例：
```
response_code = syn_webdriver.get_http_response(url)
if not response_code or response_code == "error" or response_code < 200 or response_code > 299:
raise Exception("Failed to load page!")
```
#### Chrome()
启动 Chromium 浏览器的实例并返回创建的浏览器实例。
示例：
```
browser = synthetics_webdriver.Chrome()
browser.get("https://example.com/)
```
要以隐身模式启动浏览器，请遵循以下说明:
```
add_argument('——incognito')
```
要添加代理设置，请遵循以下说明:
```
add_argument('--proxy-server=%s' % PROXY)
```
示例：
```
from selenium.webdriver.chrome.options import Options
chrome_options = Options()
chrome_options.add_argument("——incognito")
browser = syn_webdriver.Chrome(chrome_options=chrome_options)
```
# 使用 cron 安排金丝雀运行
当您安排金丝雀时，使用 cron 表达式可以让您灵活地安排计划。Cron 表达式包含五或六个按下表所列顺序排列的字段。这些字段采用空格分隔。语法根据您创建金丝雀使用的是 CloudWatch 控制台还是 AWS CLI 或 AWS SDK 而有所不同。若您使用控制台，则只能指定前五个字段。若使用 AWS CLI 或 AWS SDK，则可以指定所有六个字段，而且必须为 `Year` 字段指定 `*`。
| **字段** | **允许的值** | **允许的特殊字符** |
| --- | --- | --- |
| Minutes | 0-59 | , - \$1 / |
| Hours | 0-23 | , - \$1 / |
| Day-of-month | 1-31 | , - \$1 ? / L W |
| Month | 1-12 或 JAN-DEC | , - \$1 / |
| Day-of-week | 1-7 或 SUN-SAT | , - \$1 ? L \$1 |
| Year | \$1 | |
**特殊字符**
+ **,**（逗号）在字段的表达式中包含多个值。例如，在“Month（月份）”字段中，JAN、FEB 和 MAR 将包含 January、February 和 March。
+ **-**（破折号）特殊字符用于指定范围。在“日”字段中，1-15 将包含指定月份的 1 - 15 日。
+ **\$1**（星号）特殊字符包含该字段中的所有值。在“Hours（小时）”字段中，**\$1** 包括每个小时。您不能在同一个表达式的“日期”和“星期几”字段中同时使用 **\$1**。如果您在一个中使用它，则必须在另一个中使用 **?** 。
+ **/**（正斜杠）用于指定增量。在“Minutes（分钟）”字段中，您可以输入 1/10 以指定从一个小时的第一分钟开始的每个第十分钟（例如，第 11 分钟、第 21 分钟和第 31 分钟，依此类推）。
+ **?**（问号）用于指定一个或另一个。在“日期”字段中，您可以输入 **7**，如果您不介意第 7 日是星期几，则可以在“星期几”字段中输入 **?**。
+ “Day-of-month”或“Day-of-week”字段中的 **L** 通配符用于指定月或周的最后一天。
+ “Day-of-month”字段中的 **W** 通配符用于指定工作日。在“Day-of-month”字段中，**3W** 用于指定最靠近当月的第三周的日。
+ “Day-of-week”字段中的 **\$1** 通配符用于指定一个月内所指定星期几的特定实例。例如，3\$12 指该月的第二个星期二。3 指的是星期二，因为它是每周的第三天，2 是指该月内该类型的第二天。
**限制**
+ 您无法在同一 Cron 表达式中为日期和星期几字段同时指定值。如果您在其中一个字段中指定值或 `*`（星号），则必须在另一个字段中使用 **?**（问号）。
+ 不支持产生的速率快于一分钟的 Cron 表达式。
+ 您不能将金丝雀设置为等待一年以上才能运行，因此 `Year` 字段中只能指定为 `*`。
**示例**
创建金丝雀时，您可以参考以下示例 cron 字符串。以下示例展示了使用 AWS CLI 或 AWS SDK 创建或更新金丝雀的正确语法。如果您使用的是 CloudWatch 控制台，请省略每个示例末尾的 `*`。
| Expression | 含义 |
| --- | --- |
| `0 10 * * ? *` | 每天上午的 10:00（UTC）运行 |
| `15 12 * * ? *` | 每天在下午 12:15（UTC）运行 |
| `0 18 ? * MON-FRI *` | 每星期一到星期五的下午 6:00（UTC）运行 |
| `0 8 1 * ? *` | 每月第 1 天上午 8:00 (UTC) 运行 |
| `0/10 * ? * MON-SAT *` | 每周星期一到星期六每 10 分钟运行一次 |
| `0/5 8-17 ? * MON-FRI *` | 星期一到星期五的上午 8:00 和下午 5:55 (UTC) 之间，每 5 分钟运行一次 |
# 配置金丝雀进行自动重试
创建或更新金丝雀时，可将金丝雀配置为在计划的运行数失败时自动尝试其他运行。这有助于区分真正的故障和临时故障，从而提供更可靠的结果。此功能非常适合构建更具弹性的监控系统，同时减少误报和手动干预。
**创建自动重试金丝雀**
1. 通过 [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) 打开 CloudWatch 控制台。
1. 在导航窗格中，选择 **Application Signals**、**Synthetics 金丝雀**。
1. 选择 **Create Canary (创建金丝雀)**。
1. 在**其他配置**的**自动重试**下，选择所需的最大重试次数。
**更新金丝雀的最大重试次数**
1. 通过 [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) 打开 CloudWatch 控制台。
1. 在导航窗格中，选择 **Application Signals**、**Synthetics 金丝雀**。
1. 您可以执行以下操作之一：
+ 选择金丝雀，再依次选择**操作**、**启用自动重试**，然后调整最大重试次数。
+ 选择金丝雀，再依次选择**操作**、**编辑**。在**编辑详细信息**页面的**其他配置**部分，找到**自动重试**，然后调整重试配置。
**限制**
以下是配置自动重试的限制。
+ 仅支持运行时版本 `syn-nodejs-puppeteer-10.0 ` 或更新版本、` syn-nodejs-playwright-2.0` 或更新版本、`syn-python-selenium-5.1` 或更新版本或 `syn-nodejs-3.0` 或更新版本。
+ 长时间运行的金丝雀在十分钟后超时只能重试一次。其余金丝雀最多可以支持两次重试
# 在 CloudWatch Synthetics 金丝雀中使用依赖项
本节将介绍如何在 CloudWatch Synthetics 金丝雀中使用 `Dependencies`。通过 `Dependencies` 字段可为金丝雀指定依赖项，从而添加金丝雀脚本可以使用的其他库或自定义代码。
## 概述
CloudWatch Synthetics 金丝雀支持将 Lambda 层指定为依赖项。此功能有助实现以下目标：
+ 跨多个金丝雀共享公共代码
+ 独立管理依赖项与金丝雀脚本
+ 将依赖项移至 Lambda 层来精简金丝雀脚本体积
## 支持的 API
以下 API 支持 `Dependencies` 字段：
+ [CreateCanary](https://docs.aws.amazon.com/AmazonSynthetics/latest/APIReference/API_CreateCanary.html)
+ [UpdateCanary](https://docs.aws.amazon.com/AmazonSynthetics/latest/APIReference/API_UpdateCanary.html)
+ [StartCanaryDryRun](https://docs.aws.amazon.com/AmazonSynthetics/latest/APIReference/API_StartCanaryDryRun.html)
## 语法
`Dependencies` 字段是请求语法中代码结构的一部分：
```
"Code": {
"Handler": "string",
"S3Bucket": "string",
"S3Key": "string",
"S3Version": "string",
"ZipFile": blob,
"Dependencies": [
{
"Type": "LambdaLayer",
"Reference": "string"
}
]
}
```
## 使用依赖项
以下是在不同场景中使用 `Dependencies` 字段的一些示例和说明。
### 创建带依赖项的金丝雀
创建金丝雀时，可将 Lambda 层指定为依赖项：
```
{
"Name": "my-canary",
"Code": {
"Handler": "pageLoadBlueprint.handler",
"S3Bucket": "my-bucket",
"S3Key": "my-canary-script.zip",
"Dependencies": [
{
"Type": "LambdaLayer",
"Reference": "arn:aws:lambda:us-west-2:123456789012:layer:my-custom-layer:1"
}
]
},
"ArtifactS3Location": "s3://my-bucket/artifacts/",
"ExecutionRoleArn": "arn:aws:iam::123456789012:role/my-canary-role",
"Schedule": {
"Expression": "rate(5 minutes)"
},
"RuntimeVersion": "syn-nodejs-puppeteer-3.9"
}
```
### 更新金丝雀的依赖项
使用 UpdateCanary API 可更新金丝雀的依赖项：
```
{
"Name": "my-canary",
"Code": {
"Dependencies": [
{
"Type": "LambdaLayer",
"Reference": "arn:aws:lambda:us-west-2:123456789012:layer:my-updated-layer:2"
}
]
}
}
```
### 删除依赖项
要从金丝雀中删除依赖项，只需将 Dependencies 字段指定为空数组：
```
{
"Name": "my-canary",
"Code": {
"Dependencies": []
}
}
```
### 使用 StartCanaryDryRun 测试依赖项
在更新金丝雀的新依赖项前，可使用 StartCanaryDryRun API 进行测试：
```
{
"Name": "my-canary",
"Code": {
"Dependencies": [
{
"Type": "LambdaLayer",
"Reference": "arn:aws:lambda:us-west-2:123456789012:layer:my-test-layer:3"
}
]
}
}
```
## 限制和注意事项
+ 只能指定一个 Lambda 层作为依赖项
+ 创建带依赖项的金丝雀时，所用角色除[必要角色和权限](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Synthetics_Canaries_Roles.html)外，还应具有能访问依赖项层的 ` lambda:GetLayerVersion` 权限
## 创建兼容的 Lambda 层
有关创建和打包 Lambda 层的具体方法，请参阅[使用层管理 Lambda 依赖项](https://docs.aws.amazon.com/lambda/latest/dg/chapter-layers.html)；要了解基于金丝雀打包结构的检查机制，请参阅[编写金丝雀脚本](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Synthetics_Canaries_WritingCanary.html)。
# 组
创建*组*可以将金丝雀相互关联，包括跨区域的金丝雀。使用组可以帮助您管理和自动化金丝雀，您还可以查看组中所有金丝雀的聚合运行结果和统计数据。
组是全局资源。创建组时，将在支持组的所有 AWS 区域中复制该组，您可以将其中任何一个区域的金丝雀添加到该组，并在这些区域中查看该组。虽然组 ARN 格式反映了其创建位置的区域名称，但组不受限于任何区域。这意味着您可以将来自多个区域的金丝雀放在同一组中，然后使用该组在单个视图中查看和管理所有这些金丝雀。
除默认禁用的区域外，所有区域都支持组。有关这些区域的更多信息，请参阅[启用区域](https://docs.aws.amazon.com/general/latest/gr/rande-manage.html#rande-manage-enable)。
每组最多可以容纳 10 个金丝雀。您的账户中最多可以有 20 个组。任何一个金丝雀最多可以成为 10 个组的成员。
**创建组**
1. 通过 [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) 打开 CloudWatch 控制台。
1. 在导航窗格中，选择 **Application Signals**、**Synthetics 金丝雀**。
1. 选择**创建组**。
1. 在 **Group Name**（组名称）下，输入组的名称。
1. 选择要与此组关联的金丝雀。要选择金丝雀，请在 **Exact canary name**（准确输入金丝雀名称）中键入其完整名称，然后选择 **Search**（搜索）。然后选中金丝雀名称旁边的复选框。如果不同区域有多个同名金丝雀，请务必选择所需的金丝雀。
您可以重复此步骤，将最多 10 个金丝雀与该组关联。
1. （可选）在 **Tags**（标签）下，添加一个或多个键/值对作为此组的标签。标签可帮助您识别和组织 AWS 资源并跟踪 AWS 成本。有关更多信息，请参阅 [标记 Amazon CloudWatch 资源](CloudWatch-Tagging.md)。
1. 选择**创建组**。
# 在本地测试 Canary
本节介绍如何直接在 Microsoft Visual Studio 代码编辑器或 JetBrains IDE 代码编辑器中修改、测试和调试 CloudWatch Synthetics Canary。本地调试环境使用无服务器应用程序模型（SAM）容器来模拟 Lambda 函数，从而模拟 Synthetics Canary 的行为。
**注意**
执行依赖于可视化监控的本地调试 Canary 是不切实际的。可视化监控依赖于在初始运行期间捕获基本屏幕截图，然后将这些屏幕截图与后续运行的屏幕截图进行比较。在本地开发环境中，运行不会被存储或跟踪，并且每次迭代都是独立的运行。由于缺少 Canary 运行历史记录，因此调试依赖可视化监控的 Canary 变得不切实际。
**先决条件**
1. 选择或创建 Amazon S3 存储桶，以用于存储本地 Canary 测试运行的构件，例如 HAR 文件和屏幕截图。这要求您预调配 IAM。如果您跳过设置 Amazon S3 存储桶，您仍然可以在本地测试您的 Canary，但是您将看到一条关于丢失存储桶的错误消息，并且您将无法访问 Canary 构件。
如果您使用 Amazon S3 存储桶，我们建议您将存储桶生命周期设置为在几天后删除对象，以节省成本。有关更多信息，请参阅[管理存储生命周期](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html)。
1. 为您的 AWS 账户设置默认 AWS 配置文件。有关更多信息，请参阅[配置和凭证文件设置](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html)。
1. 将调试环境的默认 AWS 区域设置为您的首选区域，例如 ` us-west-2`。
1. 安装 AWS SAM CLI。有关更多信息，请参阅[安装 AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html)。
1. 安装 Visual Studio Code Editor 或 JetBrains IDE。有关更多信息，请参阅 [https://code.visualstudio.com/](https://code.visualstudio.com/) 或 [https://www.jetbrains.com/ides/](https://www.jetbrains.com/ides/)。
1. 安装 Docker 以使用 AWS SAM CLI。请务必启动 docker 进程守护程序。有关更多信息，请参阅[安装 Docker 以用于 AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-docker.html)。
或者，您可以安装其他容器管理软件，例如 Rancher，只要它使用 Docker 运行时即可。
1. 为您的首选编辑器安装 AWS 工具包扩展。有关更多信息，请参阅[安装 AWS Toolkit for Visual Studio Code](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/setup-toolkit.html) 或[安装 AWS Toolkit for JetBrains](https://docs.aws.amazon.com/toolkit-for-jetbrains/latest/userguide/setup-toolkit.html)。
**Topics**
+ [设置测试和调试环境](#CloudWatch_Synthetics_Debug_Environment)
+ [使用 Visual Studio Code IDE](#CloudWatch_Synthetics_Debug_VS)
+ [使用 JetBrains IDE](#CloudWatch_Synthetics_Debug_JetBrains)
+ [使用 SAM CLI 在本地运行 Canary](#CloudWatch_Synthetics_Run_Locally)
+ [将您的本地测试环境集成到现有的 Canary 包中](#CloudWatch_Synthetics_Debug_Integrate)
+ [更改 CloudWatch Synthetics 运行时](#CloudWatch_Synthetics_Debug_DifferentRuntime)
+ [常见错误](#CloudWatch_Synthetics_Debug_Errors)
## 设置测试和调试环境
首先，通过输入以下命令克隆 AWS 提供的 Github 存储库。该存储库包含 Node.js Canary 和 Python Canary 的代码示例。
```
git clone https://github.com/aws-samples/synthetics-canary-local-debugging-sample.git
```
然后根据您的 Canary 的语言执行以下操作之一。
**对于 Node.js Canary**
1. 通过输入以下命令转到 Node.js Canary 源目录。
```
cd synthetics-canary-local-debugging-sample/nodejs-canary/src
```
1. 运行以下命令，以安装 Canary 依赖项。
```
npm install
```
**对于 Python Canary**
1. 通过输入以下命令转到 Python Canary 源目录。
```
cd synthetics-canary-local-debugging-sample/python-canary/src
```
1. 运行以下命令，以安装 Canary 依赖项。
```
pip3 install -r requirements.txt -t .
```
## 使用 Visual Studio Code IDE
Visual Studio 启动配置文件位于 ` .vscode/launch.json`。它包含允许 Visual Studio 代码发现模板文件的配置。它定义了一个 Lambda 有效负载，其中包含成功调用 Canary 所需的参数。以下是 Node.js Canary 的启动配置：
```
{
...
...
"lambda": {
"payload": {
"json": {
// Canary name. Provide any name you like.
"canaryName": "LocalSyntheticsCanary",
// Canary artifact location
"artifactS3Location": {
"s3Bucket": "cw-syn-results-123456789012-us-west-2",
"s3Key": "local-run-artifacts",
},
// Your canary handler name
"customerCanaryHandlerName": "heartbeat-canary.handler"
}
},
// Environment variables to pass to the canary code
"environmentVariables": {}
}
}
]
}
```
您也可以选择在有效负载 JSON 中提供以下字段：
+ `s3EncryptionMode` 有效值：`SSE_S3` \$1 `SSE_KMS`
+ `s3KmsKeyArn` 有效值：*KMS 密钥 ARN*
+ `activeTracing` 有效值：`true` \$1 `false`
+ `canaryRunId` 有效值：*UUID* 如果启用了主动跟踪，则需要此参数。
要在 Visual Studio 中调试 Canary，请在要暂停执行的 Canary 代码中添加断点。要添加断点，请选择编辑器边距，然后在编辑器中进入**运行和调试**模式。点击播放按钮运行 Canary。当 Canary 运行时，将在调试控制台中跟踪日志，从而为您提供有关 Canary 行为的实时见解。如果您添加了断点，则 Canary 执行将在每个断点处暂停，从而使您可以逐步浏览代码并检查变量值、实例方法、对象属性和函数调用堆栈。
除了存储在 Amazon S3 存储桶中的构件和每次本地运行生成的 CloudWatch 指标外，在本地运行和调试 Canary 不会产生任何费用。
![\[Visual Studio Code interface showing JavaScript code for a heartbeat canary function.\]](http://docs.aws.amazon.com/zh_cn/AmazonCloudWatch/latest/monitoring/images/DebugCanaryVS.png)
## 使用 JetBrains IDE
安装 AWS Toolkit for JetBrains 扩展程序后，如果您正在调试 Node.js Canary，请确保启用 Node.js 插件和 JavaScript 调试器运行。然后，按照以下步骤执行操作。
**使用 JetBrains IDE 调试 Canary**
1. 在 JetBrains IDE 的左侧导航窗格中，选择 **Lambda**，然后选择本地配置模板。
1. 为运行配置输入名称，例如 **LocalSyntheticsCanary**
1. 选择**来自模板**，在模板字段中选择文件浏览器，然后从 **nodejs** 目录或 **python** 目录中在项目中选择 **template.yml** 文件。
1. 在**输入**部分，输入 Canary 的有效负载，如以下屏幕所示。
```
{
"canaryName": "LocalSyntheticsCanary",
"artifactS3Location": {
"s3Bucket": "cw-syn-results-123456789012-us-west-2",
"s3Key": "local-run-artifacts"
},
"customerCanaryHandlerName": "heartbeat-canary.handler"
}
```
您也可以在有效负载 JSON 中设置其他环境变量，如 [使用 Visual Studio Code IDE](#CloudWatch_Synthetics_Debug_VS) 中所列。
![\[Run/Debug Configurations interface for AWS Lambda with LocalSyntheticsCanary settings.\]](http://docs.aws.amazon.com/zh_cn/AmazonCloudWatch/latest/monitoring/images/DebugCanaryIntellij.png)
## 使用 SAM CLI 在本地运行 Canary
使用以下过程之一，使用无服务器应用程序模型（SAM）CLI 在本地运行 Canary。请务必在 `event.json` 中为 `s3Bucket` 指定您自己的 Amazon S3 存储桶名称
**要使用 SAM CLI 运行 Node.js Canary**
1. 通过输入以下命令转到源目录。
```
cd synthetics-canary-local-debugging-sample/nodejs-canary
```
1. 输入以下命令。
```
sam build
sam local invoke -e ../event.json
```
**要使用 SAM CLI 运行 Python Canary**
1. 通过输入以下命令转到源目录。
```
cd synthetics-canary-local-debugging-sample/python-canary
```
1. 输入以下命令。
```
sam build
sam local invoke -e ../event.json
```
## 将您的本地测试环境集成到现有的 Canary 包中
您可以通过复制三个文件将本地 Canary 调试集成到现有的 Canary 包中：
+ 将 `template.yml` 文件复制到您的 Canary 包根目录中。请务必修改 `CodeUri` 的路径以指向您的 Canary 代码所在的目录。
+ 如果您使用的是 Node.js Canary，请将 `cw-synthetics.js` 文件复制到您的 Canary 源目录。如果您使用的是 Python Canary，请将 ` cw-synthetics.py` 复制到您的 Canary 源目录。
+ 复制启动配置文件。`vscode/launch.json` 进入包根目录。确保将其放在 `.vscode` 目录中；如果目录尚不存在，请创建目录。
## 更改 CloudWatch Synthetics 运行时
在调试的过程中，您可能需要尝试使用不同的 CloudWatch Synthetics 运行时来运行 Canary，而不是最新的运行时。为此，请从下表之一中找到要使用的运行时。务必为正确的区域选择运行时。然后，将该运行时的 ARN 粘贴到 ` template.yml` 文件中的相应位置，然后运行 Canary。
### Node.js 和 Puppeteer 运行时
#### syn-nodejs-puppeteer-15.0 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-nodejs-puppeteer-15.0` 版本 CloudWatch Synthetics 运行时的适用 ARN。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonCloudWatch/latest/monitoring/CloudWatch_Synthetics_Debug_Locally.html)
#### syn-nodejs-puppeteer-14.0 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-nodejs-puppeteer-14.0` 版本 CloudWatch Synthetics 运行时的适用 ARN。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonCloudWatch/latest/monitoring/CloudWatch_Synthetics_Debug_Locally.html)
#### syn-nodejs-puppeteer-13.1 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-nodejs-puppeteer-13.1` 版本 CloudWatch Synthetics 运行时的适用 ARN。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonCloudWatch/latest/monitoring/CloudWatch_Synthetics_Debug_Locally.html)
#### syn-nodejs-puppeteer-13.0 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-nodejs-puppeteer-13.0` 版本 CloudWatch Synthetics 运行时的适用 ARN。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonCloudWatch/latest/monitoring/CloudWatch_Synthetics_Debug_Locally.html)
#### syn-nodejs-puppeteer-12.0 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-nodejs-puppeteer-12.0` 版本 CloudWatch Synthetics 运行时的适用 ARN。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonCloudWatch/latest/monitoring/CloudWatch_Synthetics_Debug_Locally.html)
#### syn-nodejs-puppeteer-11.0 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-nodejs-puppeteer-11.0` 版本 CloudWatch Synthetics 运行时的适用 ARN。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonCloudWatch/latest/monitoring/CloudWatch_Synthetics_Debug_Locally.html)
#### syn-nodejs-puppeteer-10.0 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-nodejs-puppeteer-10.0` 版本 CloudWatch Synthetics 运行时的适用 ARN。
| 区域 | ARN |
| --- | --- |
| 美国东部（弗吉尼亚州北部） | `arn:aws:lambda:us-east-1:378653112637:layer:Synthetics:58` |
| 美国东部（俄亥俄州） | `arn:aws:lambda:us-east-2:772927465453:layer:Synthetics:61` |
| 美国西部（北加利福尼亚） | `arn:aws:lambda:us-west-1:332033056316:layer:Synthetics:59` |
| 美国西部（俄勒冈州） | `arn:aws:lambda:us-west-2:760325925879:layer:Synthetics:61` |
| 非洲（开普敦） | `arn:aws:lambda:af-south-1:461844272066:layer:Synthetics:59` |
| 亚太地区（香港） | `arn:aws:lambda:ap-east-1:129828061636:layer:Synthetics:59` |
| 亚太地区（海得拉巴） | `arn:aws:lambda:ap-south-2:280298676434:layer:Synthetics:34` |
| 亚太地区（雅加达） | `arn:aws:lambda:ap-southeast-3:246953257743:layer:Synthetics:41` |
| 亚太地区（马来西亚） | `arn:aws:lambda:ap-southeast-5:035872523913:layer:Synthetics:15` |
| 亚太地区（墨尔本） | `arn:aws:lambda:ap-southeast-4:200724813040:layer:Synthetics:32` |
| 亚太地区（孟买） | `arn:aws:lambda:ap-south-1:724929286329:layer:Synthetics:59` |
| 亚太地区（新西兰） | `arn:aws:lambda:ap-southeast-6:779414629109:layer:Synthetics:18` |
| 亚太地区（大阪） | `arn:aws:lambda:ap-northeast-3:608016332111:layer:Synthetics:45` |
| 亚太地区（首尔） | `arn:aws:lambda:ap-northeast-2:989515803484:layer:Synthetics:62` |
| 亚太地区（新加坡） | `arn:aws:lambda:ap-southeast-1:068035103298:layer:Synthetics:63` |
| 亚太地区（悉尼） | `arn:aws:lambda:ap-southeast-2:584677157514:layer:Synthetics:58` |
| 亚太地区（台北） | `arn:aws:lambda:ap-east-2:471112897378:layer:Synthetics:24` |
| 亚太地区（泰国） | `arn:aws:lambda:ap-southeast-7:851725245975:layer:Synthetics:6` |
| 亚太地区（东京） | `arn:aws:lambda:ap-northeast-1:172291836251:layer:Synthetics:59` |
| 加拿大（中部） | `arn:aws:lambda:ca-central-1:236629016841:layer:Synthetics:59` |
| 加拿大西部（卡尔加里） | `arn:aws:lambda:ca-west-1:944448206667:layer:Synthetics:90` |
| 中国（北京） | `arn:aws-cn:lambda:cn-north-1:422629156088:layer:Synthetics:58` |
| 中国（宁夏）； | `arn:aws-cn:lambda:cn-northwest-1:474974519687:layer:Synthetics:59` |
| 欧洲地区（法兰克福） | `arn:aws:lambda:eu-central-1:122305336817:layer:Synthetics:59` |
| 欧洲地区（爱尔兰） | `arn:aws:lambda:eu-west-1:563204233543:layer:Synthetics:60` |
| 欧洲地区（伦敦） | `arn:aws:lambda:eu-west-2:565831452869:layer:Synthetics:58` |
| 欧洲地区（米兰） | `arn:aws:lambda:eu-south-1:525618516618:layer:Synthetics:60` |
| 欧洲地区（巴黎） | `arn:aws:lambda:eu-west-3:469466506258:layer:Synthetics:59` |
| 欧洲（西班牙） | `arn:aws:lambda:eu-south-2:029793053121:layer:Synthetics:34` |
| 欧洲地区（斯德哥尔摩） | `arn:aws:lambda:eu-north-1:162938142733:layer:Synthetics:59` |
| 欧洲（苏黎世） | `arn:aws:lambda:eu-central-2:224218992030:layer:Synthetics:33` |
| 以色列（特拉维夫） | `arn:aws:lambda:il-central-1:313249807427:layer:Synthetics:31` |
| 墨西哥（中部） | `arn:aws:lambda:mx-central-1:654654265476:layer:Synthetics:7` |
| 中东（巴林） | `arn:aws:lambda:me-south-1:823195537320:layer:Synthetics:58` |
| 中东（阿联酋）： | `arn:aws:lambda:me-central-1:239544149032:layer:Synthetics:34` |
| 南美洲（圣保罗） | `arn:aws:lambda:sa-east-1:783765544751:layer:Synthetics:60` |
| AWS GovCloud（美国东部） | `arn:aws-us-gov:lambda:us-gov-east-1:946759330430:layer:Synthetics:54` |
| AWS GovCloud（美国西部） | `arn:aws-us-gov:lambda:us-gov-west-1:946807836238:layer:Synthetics:55` |
#### syn-nodejs-puppeteer-9.1 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-nodejs-puppeteer-9.1` 版本 CloudWatch Synthetics 运行时的适用 ARN。
| 区域 | ARN |
| --- | --- |
| 美国东部（弗吉尼亚州北部） | `arn:aws:lambda:us-east-1:378653112637:layer:Synthetics:53` |
| 美国东部（俄亥俄州） | `arn:aws:lambda:us-east-2:772927465453:layer:Synthetics:56` |
| 美国西部（北加利福尼亚） | `arn:aws:lambda:us-west-1:332033056316:layer:Synthetics:54` |
| 美国西部（俄勒冈州） | `arn:aws:lambda:us-west-2:760325925879:layer:Synthetics:56` |
| 非洲（开普敦） | `arn:aws:lambda:af-south-1:461844272066:layer:Synthetics:54` |
| 亚太地区（香港） | `arn:aws:lambda:ap-east-1:129828061636:layer:Synthetics:54` |
| 亚太地区（海得拉巴） | `arn:aws:lambda:ap-south-2:280298676434:layer:Synthetics:29` |
| 亚太地区（雅加达） | `arn:aws:lambda:ap-southeast-3:246953257743:layer:Synthetics:36` |
| 亚太地区（马来西亚） | `arn:aws:lambda:ap-southeast-5:035872523913:layer:Synthetics:10` |
| 亚太地区（墨尔本） | `arn:aws:lambda:ap-southeast-4:200724813040:layer:Synthetics:27` |
| 亚太地区（孟买） | `arn:aws:lambda:ap-south-1:724929286329:layer:Synthetics:54` |
| 亚太地区（新西兰） | `arn:aws:lambda:ap-southeast-6:779414629109:layer:Synthetics:17` |
| 亚太地区（大阪） | `arn:aws:lambda:ap-northeast-3:608016332111:layer:Synthetics:40` |
| 亚太地区（首尔） | `arn:aws:lambda:ap-northeast-2:989515803484:layer:Synthetics:57` |
| 亚太地区（新加坡） | `arn:aws:lambda:ap-southeast-1:068035103298:layer:Synthetics:58` |
| 亚太地区（悉尼） | `arn:aws:lambda:ap-southeast-2:584677157514:layer:Synthetics:53` |
| 亚太地区（台北） | `arn:aws:lambda:ap-east-2:471112897378:layer:Synthetics:25` |
| 亚太地区（泰国） | `arn:aws:lambda:ap-southeast-7:851725245975:layer:Synthetics:1` |
| 亚太地区（东京） | `arn:aws:lambda:ap-northeast-1:172291836251:layer:Synthetics:54` |
| 加拿大（中部） | `arn:aws:lambda:ca-central-1:236629016841:layer:Synthetics:54` |
| 加拿大西部（卡尔加里） | `arn:aws:lambda:ca-west-1:944448206667:layer:Synthetics:85` |
| 中国（北京） | `arn:aws-cn:lambda:cn-north-1:422629156088:layer:Synthetics:54` |
| 中国（宁夏）； | `arn:aws-cn:lambda:cn-northwest-1:474974519687:layer:Synthetics:55` |
| 欧洲地区（法兰克福） | `arn:aws:lambda:eu-central-1:122305336817:layer:Synthetics:54` |
| 欧洲地区（爱尔兰） | `arn:aws:lambda:eu-west-1:563204233543:layer:Synthetics:55` |
| 欧洲地区（伦敦） | `arn:aws:lambda:eu-west-2:565831452869:layer:Synthetics:53` |
| 欧洲地区（米兰） | `arn:aws:lambda:eu-south-1:525618516618:layer:Synthetics:55` |
| 欧洲地区（巴黎） | `arn:aws:lambda:eu-west-3:469466506258:layer:Synthetics:54` |
| 欧洲（西班牙） | `arn:aws:lambda:eu-south-2:029793053121:layer:Synthetics:29` |
| 欧洲地区（斯德哥尔摩） | `arn:aws:lambda:eu-north-1:162938142733:layer:Synthetics:54` |
| 欧洲（苏黎世） | `arn:aws:lambda:eu-central-2:224218992030:layer:Synthetics:28` |
| 以色列（特拉维夫） | `arn:aws:lambda:il-central-1:313249807427:layer:Synthetics:26` |
| 墨西哥（中部） | `arn:aws:lambda:mx-central-1:654654265476:layer:Synthetics:3` |
| 中东（巴林） | `arn:aws:lambda:me-south-1:823195537320:layer:Synthetics:53` |
| 中东（阿联酋）： | `arn:aws:lambda:me-central-1:239544149032:layer:Synthetics:29` |
| 南美洲（圣保罗） | `arn:aws:lambda:sa-east-1:783765544751:layer:Synthetics:55` |
| AWS GovCloud（美国东部） | `arn:aws-us-gov:lambda:us-gov-east-1:946759330430:layer:Synthetics:50` |
| AWS GovCloud（美国西部） | `arn:aws-us-gov:lambda:us-gov-west-1:946807836238:layer:Synthetics:51` |
#### syn-nodejs-puppeteer-9.0 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-nodejs-puppeteer-9.0` 版本 CloudWatch Synthetics 运行时的适用 ARN。
| 区域 | ARN |
| --- | --- |
| 美国东部（弗吉尼亚州北部） | `arn:aws:lambda:us-east-1:378653112637:layer:Synthetics:51` |
| 美国东部（俄亥俄州） | `arn:aws:lambda:us-east-2:772927465453:layer:Synthetics:54` |
| 美国西部（北加利福尼亚） | `arn:aws:lambda:us-west-1:332033056316:layer:Synthetics:52` |
| 美国西部（俄勒冈州） | `arn:aws:lambda:us-west-2:760325925879:layer:Synthetics:54` |
| 非洲（开普敦） | `arn:aws:lambda:af-south-1:461844272066:layer:Synthetics:52` |
| 亚太地区（香港） | `arn:aws:lambda:ap-east-1:129828061636:layer:Synthetics:52` |
| 亚太地区（海得拉巴） | `arn:aws:lambda:ap-south-2:280298676434:layer:Synthetics:27` |
| 亚太地区（雅加达） | `arn:aws:lambda:ap-southeast-3:246953257743:layer:Synthetics:34` |
| 亚太地区（马来西亚） | `arn:aws:lambda:ap-southeast-5:035872523913:layer:Synthetics:8` |
| 亚太地区（墨尔本） | `arn:aws:lambda:ap-southeast-4:200724813040:layer:Synthetics:25` |
| 亚太地区（孟买） | `arn:aws:lambda:ap-south-1:724929286329:layer:Synthetics:52` |
| 亚太地区（新西兰） | `arn:aws:lambda:ap-southeast-6:779414629109:layer:Synthetics:16` |
| 亚太地区（大阪） | `arn:aws:lambda:ap-northeast-3:608016332111:layer:Synthetics:38` |
| 亚太地区（首尔） | `arn:aws:lambda:ap-northeast-2:989515803484:layer:Synthetics:55` |
| 亚太地区（新加坡） | `arn:aws:lambda:ap-southeast-1:068035103298:layer:Synthetics:56` |
| 亚太地区（悉尼） | `arn:aws:lambda:ap-southeast-2:584677157514:layer:Synthetics:51` |
| 亚太地区（台北） | `arn:aws:lambda:ap-east-2:471112897378:layer:Synthetics:26` |
| 亚太地区（东京） | `arn:aws:lambda:ap-northeast-1:172291836251:layer:Synthetics:52` |
| 加拿大（中部） | `arn:aws:lambda:ca-central-1:236629016841:layer:Synthetics:52` |
| 加拿大西部（卡尔加里） | `arn:aws:lambda:ca-west-1:944448206667:layer:Synthetics:83` |
| 中国（北京） | `arn:aws-cn:lambda:cn-north-1:422629156088:layer:Synthetics:52` |
| 中国（宁夏）； | `arn:aws-cn:lambda:cn-northwest-1:474974519687:layer:Synthetics:53` |
| 欧洲地区（法兰克福） | `arn:aws:lambda:eu-central-1:122305336817:layer:Synthetics:52` |
| 欧洲地区（爱尔兰） | `arn:aws:lambda:eu-west-1:563204233543:layer:Synthetics:53` |
| 欧洲地区（伦敦） | `arn:aws:lambda:eu-west-2:565831452869:layer:Synthetics:51` |
| 欧洲地区（米兰） | `arn:aws:lambda:eu-south-1:525618516618:layer:Synthetics:53` |
| 欧洲地区（巴黎） | `arn:aws:lambda:eu-west-3:469466506258:layer:Synthetics:52` |
| 欧洲（西班牙） | `arn:aws:lambda:eu-south-2:029793053121:layer:Synthetics:27` |
| 欧洲地区（斯德哥尔摩） | `arn:aws:lambda:eu-north-1:162938142733:layer:Synthetics:52` |
| 欧洲（苏黎世） | `arn:aws:lambda:eu-central-2:224218992030:layer:Synthetics:26` |
| 以色列（特拉维夫） | `arn:aws:lambda:il-central-1:313249807427:layer:Synthetics:24` |
| 中东（巴林） | `arn:aws:lambda:me-south-1:823195537320:layer:Synthetics:51` |
| 中东（阿联酋）： | `arn:aws:lambda:me-central-1:239544149032:layer:Synthetics:27` |
| 南美洲（圣保罗） | `arn:aws:lambda:sa-east-1:783765544751:layer:Synthetics:53` |
| AWS GovCloud（美国东部） | `arn:aws-us-gov:lambda:us-gov-east-1:946759330430:layer:Synthetics:48` |
| AWS GovCloud（美国西部） | `arn:aws-us-gov:lambda:us-gov-west-1:946807836238:layer:Synthetics:49` |
#### syn-nodejs-puppeteer-8.0 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-nodejs-puppeteer-8.0` 版本 CloudWatch Synthetics 运行时的适用 ARN。
| 区域 | ARN |
| --- | --- |
| 美国东部（弗吉尼亚州北部） | `arn:aws:lambda:us-east-1:378653112637:layer:Synthetics:48` |
| 美国东部（俄亥俄州） | `arn:aws:lambda:us-east-2:772927465453:layer:Synthetics:50` |
| 美国西部（北加利福尼亚） | `arn:aws:lambda:us-west-1:332033056316:layer:Synthetics:48` |
| 美国西部（俄勒冈州） | `arn:aws:lambda:us-west-2:760325925879:layer:Synthetics:51` |
| 非洲（开普敦） | `arn:aws:lambda:af-south-1:461844272066:layer:Synthetics:48` |
| 亚太地区（香港） | `arn:aws:lambda:ap-east-1:129828061636:layer:Synthetics:49` |
| 亚太地区（海得拉巴） | `arn:aws:lambda:ap-south-2:280298676434:layer:Synthetics:24` |
| 亚太地区（雅加达） | `arn:aws:lambda:ap-southeast-3:246953257743:layer:Synthetics:30` |
| 亚太地区（墨尔本） | `arn:aws:lambda:ap-southeast-4:200724813040:layer:Synthetics:22` |
| 亚太地区（孟买） | `arn:aws:lambda:ap-south-1:724929286329:layer:Synthetics:48` |
| 亚太地区（新西兰） | `arn:aws:lambda:ap-southeast-6:779414629109:layer:Synthetics:15` |
| 亚太地区（大阪） | `arn:aws:lambda:ap-northeast-3:608016332111:layer:Synthetics:34` |
| 亚太地区（首尔） | `arn:aws:lambda:ap-northeast-2:989515803484:layer:Synthetics:51` |
| 亚太地区（新加坡） | `arn:aws:lambda:ap-southeast-1:068035103298:layer:Synthetics:53` |
| 亚太地区（悉尼） | `arn:aws:lambda:ap-southeast-2:584677157514:layer:Synthetics:48` |
| 亚太地区（台北） | `arn:aws:lambda:ap-east-2:471112897378:layer:Synthetics:23` |
| 亚太地区（东京） | `arn:aws:lambda:ap-northeast-1:172291836251:layer:Synthetics:48` |
| 加拿大（中部） | `arn:aws:lambda:ca-central-1:236629016841:layer:Synthetics:48` |
| 加拿大西部（卡尔加里） | `arn:aws:lambda:ca-west-1:944448206667:layer:Synthetics:80` |
| 中国（北京） | `arn:aws-cn:lambda:cn-north-1:422629156088:layer:Synthetics:49` |
| 中国（宁夏）； | `arn:aws-cn:lambda:cn-northwest-1:474974519687:layer:Synthetics:50` |
| 欧洲地区（法兰克福） | `arn:aws:lambda:eu-central-1:122305336817:layer:Synthetics:48` |
| 欧洲地区（爱尔兰） | `arn:aws:lambda:eu-west-1:563204233543:layer:Synthetics:50` |
| 欧洲地区（伦敦） | `arn:aws:lambda:eu-west-2:565831452869:layer:Synthetics:48` |
| 欧洲地区（米兰） | `arn:aws:lambda:eu-south-1:525618516618:layer:Synthetics:49` |
| 欧洲地区（巴黎） | `arn:aws:lambda:eu-west-3:469466506258:layer:Synthetics:48` |
| 欧洲（西班牙） | `arn:aws:lambda:eu-south-2:029793053121:layer:Synthetics:24` |
| 欧洲地区（斯德哥尔摩） | `arn:aws:lambda:eu-north-1:162938142733:layer:Synthetics:48` |
| 欧洲（苏黎世） | `arn:aws:lambda:eu-central-2:224218992030:layer:Synthetics:23` |
| 以色列（特拉维夫） | `arn:aws:lambda:il-central-1:313249807427:layer:Synthetics:21` |
| 中东（巴林） | `arn:aws:lambda:me-south-1:823195537320:layer:Synthetics:48` |
| 中东（阿联酋）： | `arn:aws:lambda:me-central-1:239544149032:layer:Synthetics:23` |
| 南美洲（圣保罗） | `arn:aws:lambda:sa-east-1:783765544751:layer:Synthetics:49` |
| AWS GovCloud（美国东部） | `arn:aws-us-gov:lambda:us-gov-east-1:946759330430:layer:Synthetics:45` |
| AWS GovCloud（美国西部） | `arn:aws-us-gov:lambda:us-gov-west-1:946807836238:layer:Synthetics:46` |
#### syn-nodejs-puppeteer-7.0 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-nodejs-puppeteer-7.0` 版本 CloudWatch Synthetics 运行时的适用 ARN。
| 区域 | ARN |
| --- | --- |
| 美国东部（弗吉尼亚州北部） | `arn:aws:lambda:us-east-1:378653112637:layer:Synthetics:44` |
| 美国东部（俄亥俄州） | `arn:aws:lambda:us-east-2:772927465453:layer:Synthetics:46` |
| 美国西部（北加利福尼亚） | `arn:aws:lambda:us-west-1:332033056316:layer:Synthetics:44` |
| 美国西部（俄勒冈州） | `arn:aws:lambda:us-west-2:760325925879:layer:Synthetics:47` |
| 非洲（开普敦） | `arn:aws:lambda:af-south-1:461844272066:layer:Synthetics:44` |
| 亚太地区（香港） | `arn:aws:lambda:ap-east-1:129828061636:layer:Synthetics:45` |
| 亚太地区（海得拉巴） | `arn:aws:lambda:ap-south-2:280298676434:layer:Synthetics:20` |
| 亚太地区（雅加达） | `arn:aws:lambda:ap-southeast-3:246953257743:layer:Synthetics:26` |
| 亚太地区（马来西亚） | `arn:aws:lambda:ap-southeast-5:035872523913:layer:Synthetics:7` |
| 亚太地区（墨尔本） | `arn:aws:lambda:ap-southeast-4:200724813040:layer:Synthetics:18` |
| 亚太地区（孟买） | `arn:aws:lambda:ap-south-1:724929286329:layer:Synthetics:44` |
| 亚太地区（大阪） | `arn:aws:lambda:ap-northeast-3:608016332111:layer:Synthetics:30` |
| 亚太地区（首尔） | `arn:aws:lambda:ap-northeast-2:989515803484:layer:Synthetics:46` |
| 亚太地区（新加坡） | `arn:aws:lambda:ap-southeast-1:068035103298:layer:Synthetics:49` |
| 亚太地区（悉尼） | `arn:aws:lambda:ap-southeast-2:584677157514:layer:Synthetics:44` |
| 亚太地区（泰国） | `arn:aws:lambda:ap-southeast-7:851725245975:layer:Synthetics:3` |
| 亚太地区（东京） | `arn:aws:lambda:ap-northeast-1:172291836251:layer:Synthetics:44` |
| 加拿大（中部） | `arn:aws:lambda:ca-central-1:236629016841:layer:Synthetics:44` |
| 加拿大西部（卡尔加里） | `arn:aws:lambda:ca-west-1:944448206667:layer:Synthetics:76` |
| 中国（北京） | `arn:aws-cn:lambda:cn-north-1:422629156088:layer:Synthetics:45` |
| 中国（宁夏）； | `arn:aws-cn:lambda:cn-northwest-1:474974519687:layer:Synthetics:46` |
| 欧洲地区（法兰克福） | `arn:aws:lambda:eu-central-1:122305336817:layer:Synthetics:44` |
| 欧洲地区（爱尔兰） | `arn:aws:lambda:eu-west-1:563204233543:layer:Synthetics:46` |
| 欧洲地区（伦敦） | `arn:aws:lambda:eu-west-2:565831452869:layer:Synthetics:44` |
| 欧洲地区（米兰） | `arn:aws:lambda:eu-south-1:525618516618:layer:Synthetics:45` |
| 欧洲地区（巴黎） | `arn:aws:lambda:eu-west-3:469466506258:layer:Synthetics:44` |
| 欧洲（西班牙） | `arn:aws:lambda:eu-south-2:029793053121:layer:Synthetics:20` |
| 欧洲地区（斯德哥尔摩） | `arn:aws:lambda:eu-north-1:162938142733:layer:Synthetics:44` |
| 欧洲（苏黎世） | `arn:aws:lambda:eu-central-2:224218992030:layer:Synthetics:19` |
| 以色列（特拉维夫） | `arn:aws:lambda:il-central-1:313249807427:layer:Synthetics:17` |
| 墨西哥（中部） | `arn:aws:lambda:mx-central-1:654654265476:layer:Synthetics:4` |
| 中东（巴林） | `arn:aws:lambda:me-south-1:823195537320:layer:Synthetics:44` |
| 中东（阿联酋）： | `arn:aws:lambda:me-central-1:239544149032:layer:Synthetics:19` |
| 南美洲（圣保罗） | `arn:aws:lambda:sa-east-1:783765544751:layer:Synthetics:45` |
| AWS GovCloud（美国东部） | `arn:aws-us-gov:lambda:us-gov-east-1:946759330430:layer:Synthetics:41` |
| AWS GovCloud（美国西部） | `arn:aws-us-gov:lambda:us-gov-west-1:946807836238:layer:Synthetics:42` |
#### syn-nodejs-puppeteer-6.2 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-nodejs-puppeteer-6.2` 版本 CloudWatch Synthetics 运行时的适用 ARN。
| 区域 | ARN |
| --- | --- |
| 美国东部（弗吉尼亚州北部） | `arn:aws:lambda:us-east-1:378653112637:layer:Synthetics:41` |
| 美国东部（俄亥俄州） | `arn:aws:lambda:us-east-2:772927465453:layer:Synthetics:43` |
| 美国西部（北加利福尼亚） | `arn:aws:lambda:us-west-1:332033056316:layer:Synthetics:41` |
| 美国西部（俄勒冈州） | `arn:aws:lambda:us-west-2:760325925879:layer:Synthetics:44` |
| 非洲（开普敦） | `arn:aws:lambda:af-south-1:461844272066:layer:Synthetics:41` |
| 亚太地区（香港） | `arn:aws:lambda:ap-east-1:129828061636:layer:Synthetics:42` |
| 亚太地区（海得拉巴） | `arn:aws:lambda:ap-south-2:280298676434:layer:Synthetics:17` |
| 亚太地区（雅加达） | `arn:aws:lambda:ap-southeast-3:246953257743:layer:Synthetics:23` |
| 亚太地区（墨尔本） | `arn:aws:lambda:ap-southeast-4:200724813040:layer:Synthetics:15` |
| 亚太地区（孟买） | `arn:aws:lambda:ap-south-1:724929286329:layer:Synthetics:41` |
| 亚太地区（大阪） | `arn:aws:lambda:ap-northeast-3:608016332111:layer:Synthetics:27` |
| 亚太地区（首尔） | `arn:aws:lambda:ap-northeast-2:989515803484:layer:Synthetics:42` |
| 亚太地区（新加坡） | `arn:aws:lambda:ap-southeast-1:068035103298:layer:Synthetics:46` |
| 亚太地区（悉尼） | `arn:aws:lambda:ap-southeast-2:584677157514:layer:Synthetics:41` |
| 亚太地区（东京） | `arn:aws:lambda:ap-northeast-1:172291836251:layer:Synthetics:41` |
| 加拿大（中部） | `arn:aws:lambda:ca-central-1:236629016841:layer:Synthetics:41` |
| 加拿大西部（卡尔加里） | `arn:aws:lambda:ca-west-1:944448206667:layer:Synthetics:73` |
| 中国（北京） | `arn:aws-cn:lambda:cn-north-1:422629156088:layer:Synthetics:42` |
| 中国（宁夏）； | `arn:aws-cn:lambda:cn-northwest-1:474974519687:layer:Synthetics:43` |
| 欧洲地区（法兰克福） | `arn:aws:lambda:eu-central-1:122305336817:layer:Synthetics:41` |
| 欧洲地区（爱尔兰） | `arn:aws:lambda:eu-west-1:563204233543:layer:Synthetics:43` |
| 欧洲地区（伦敦） | `arn:aws:lambda:eu-west-2:565831452869:layer:Synthetics:41` |
| 欧洲地区（米兰） | `arn:aws:lambda:eu-south-1:525618516618:layer:Synthetics:42` |
| 欧洲地区（巴黎） | `arn:aws:lambda:eu-west-3:469466506258:layer:Synthetics:41` |
| 欧洲（西班牙） | `arn:aws:lambda:eu-south-2:029793053121:layer:Synthetics:17` |
| 欧洲地区（斯德哥尔摩） | `arn:aws:lambda:eu-north-1:162938142733:layer:Synthetics:41` |
| 欧洲（苏黎世） | `arn:aws:lambda:eu-central-2:224218992030:layer:Synthetics:16` |
| 以色列（特拉维夫） | `arn:aws:lambda:il-central-1:313249807427:layer:Synthetics:14` |
| 中东（巴林） | `arn:aws:lambda:me-south-1:823195537320:layer:Synthetics:41` |
| 中东（阿联酋）： | `arn:aws:lambda:me-central-1:239544149032:layer:Synthetics:16` |
| 南美洲（圣保罗） | `arn:aws:lambda:sa-east-1:783765544751:layer:Synthetics:42` |
| AWS GovCloud（美国东部） | `arn:aws-us-gov:lambda:us-gov-east-1:946759330430:layer:Synthetics:39` |
| AWS GovCloud（美国西部） | `arn:aws-us-gov:lambda:us-gov-west-1:946807836238:layer:Synthetics:39` |
#### syn-nodejs-puppeteer-5.2 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-nodejs-puppeteer-5.2` 版本 CloudWatch Synthetics 运行时的适用 ARN。
| 区域 | ARN |
| --- | --- |
| 美国东部（弗吉尼亚州北部） | `arn:aws:lambda:us-east-1:378653112637:layer:Synthetics:42` |
| 美国东部（俄亥俄州） | `arn:aws:lambda:us-east-2:772927465453:layer:Synthetics:44` |
| 美国西部（北加利福尼亚） | `arn:aws:lambda:us-west-1:332033056316:layer:Synthetics:42` |
| 美国西部（俄勒冈州） | `arn:aws:lambda:us-west-2:760325925879:layer:Synthetics:45` |
| 非洲（开普敦） | `arn:aws:lambda:af-south-1:461844272066:layer:Synthetics:42` |
| 亚太地区（香港） | `arn:aws:lambda:ap-east-1:129828061636:layer:Synthetics:43` |
| 亚太地区（海得拉巴） | `arn:aws:lambda:ap-south-2:280298676434:layer:Synthetics:18` |
| 亚太地区（雅加达） | `arn:aws:lambda:ap-southeast-3:246953257743:layer:Synthetics:24` |
| 亚太地区（墨尔本） | `arn:aws:lambda:ap-southeast-4:200724813040:layer:Synthetics:16` |
| 亚太地区（孟买） | `arn:aws:lambda:ap-south-1:724929286329:layer:Synthetics:42` |
| 亚太地区（大阪） | `arn:aws:lambda:ap-northeast-3:608016332111:layer:Synthetics:28` |
| 亚太地区（首尔） | `arn:aws:lambda:ap-northeast-2:989515803484:layer:Synthetics:44` |
| 亚太地区（新加坡） | `arn:aws:lambda:ap-southeast-1:068035103298:layer:Synthetics:47` |
| 亚太地区（悉尼） | `arn:aws:lambda:ap-southeast-2:584677157514:layer:Synthetics:42` |
| 亚太地区（东京） | `arn:aws:lambda:ap-northeast-1:172291836251:layer:Synthetics:42` |
| 加拿大（中部） | `arn:aws:lambda:ca-central-1:236629016841:layer:Synthetics:42` |
| 加拿大西部（卡尔加里） | `arn:aws:lambda:ca-west-1:944448206667:layer:Synthetics:74` |
| 中国（北京） | `arn:aws-cn:lambda:cn-north-1:422629156088:layer:Synthetics:43` |
| 中国（宁夏）； | `arn:aws-cn:lambda:cn-northwest-1:474974519687:layer:Synthetics:44` |
| 欧洲地区（法兰克福） | `arn:aws:lambda:eu-central-1:122305336817:layer:Synthetics:42` |
| 欧洲地区（爱尔兰） | `arn:aws:lambda:eu-west-1:563204233543:layer:Synthetics:44` |
| 欧洲地区（伦敦） | `arn:aws:lambda:eu-west-2:565831452869:layer:Synthetics:42` |
| 欧洲地区（米兰） | `arn:aws:lambda:eu-south-1:525618516618:layer:Synthetics:43` |
| 欧洲地区（巴黎） | `arn:aws:lambda:eu-west-3:469466506258:layer:Synthetics:42` |
| 欧洲（西班牙） | `arn:aws:lambda:eu-south-2:029793053121:layer:Synthetics:18` |
| 欧洲地区（斯德哥尔摩） | `arn:aws:lambda:eu-north-1:162938142733:layer:Synthetics:42` |
| 欧洲（苏黎世） | `arn:aws:lambda:eu-central-2:224218992030:layer:Synthetics:17` |
| 以色列（特拉维夫） | `arn:aws:lambda:il-central-1:313249807427:layer:Synthetics:15` |
| 中东（巴林） | `arn:aws:lambda:me-south-1:823195537320:layer:Synthetics:42` |
| 中东（阿联酋）： | `arn:aws:lambda:me-central-1:239544149032:layer:Synthetics:17` |
| 南美洲（圣保罗） | `arn:aws:lambda:sa-east-1:783765544751:layer:Synthetics:43` |
| AWS GovCloud（美国东部） | `arn:aws-us-gov:lambda:us-gov-east-1:946759330430:layer:Synthetics:40` |
| AWS GovCloud（美国西部） | `arn:aws-us-gov:lambda:us-gov-west-1:946807836238:layer:Synthetics:40` |
### Node.js 和 Playwright 运行时
#### syn-nodejs-playwright-6.0 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-nodejs-playwright-6.0` 版本 CloudWatch Synthetics 运行时的适用 ARN。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonCloudWatch/latest/monitoring/CloudWatch_Synthetics_Debug_Locally.html)
#### syn-nodejs-playwright-5.1 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-nodejs-playwright-5.1` 版本 CloudWatch Synthetics 运行时的适用 ARN。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonCloudWatch/latest/monitoring/CloudWatch_Synthetics_Debug_Locally.html)
#### syn-nodejs-playwright-5.0 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-nodejs-playwright-5.0` 版本 CloudWatch Synthetics 运行时的适用 ARN。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonCloudWatch/latest/monitoring/CloudWatch_Synthetics_Debug_Locally.html)
#### syn-nodejs-playwright-4.0 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-nodejs-playwright-4.0` 版本 CloudWatch Synthetics 运行时的适用 ARN。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonCloudWatch/latest/monitoring/CloudWatch_Synthetics_Debug_Locally.html)
#### syn-nodejs-playwright-3.0 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-nodejs-playwright-3.0` 版本 CloudWatch Synthetics 运行时的适用 ARN。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonCloudWatch/latest/monitoring/CloudWatch_Synthetics_Debug_Locally.html)
#### syn-nodejs-playwright-2.0 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-nodejs-playwright-2.0` 版本 CloudWatch Synthetics 运行时的适用 ARN。
| 区域 | ARN |
| --- | --- |
| 美国东部（弗吉尼亚州北部） | ` arn:aws:lambda:us-east-1:378653112637:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 美国东部（俄亥俄州） | ` arn:aws:lambda:us-east-2:772927465453:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 美国西部（北加利福尼亚） | ` arn:aws:lambda:us-west-1:332033056316:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 美国西部（俄勒冈州） | ` arn:aws:lambda:us-west-2:760325925879:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 非洲（开普敦） | ` arn:aws:lambda:af-south-1:461844272066:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 亚太地区（香港） | ` arn:aws:lambda:ap-east-1:129828061636:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 亚太地区（海得拉巴） | ` arn:aws:lambda:ap-south-2:280298676434:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 亚太地区（雅加达） | ` arn:aws:lambda:ap-southeast-3:246953257743:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 亚太地区（马来西亚） | ` arn:aws:lambda:ap-southeast-5:035872523913:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 亚太地区（墨尔本） | ` arn:aws:lambda:ap-southeast-4:200724813040:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 亚太地区（孟买） | ` arn:aws:lambda:ap-south-1:724929286329:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 亚太地区（新西兰） | ` arn:aws:lambda:ap-southeast-6:779414629109:layer:AWS-CW-SyntheticsNodeJsPlaywright:7` |
| 亚太地区（大阪） | ` arn:aws:lambda:ap-northeast-3:608016332111:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 亚太地区（首尔） | ` arn:aws:lambda:ap-northeast-2:989515803484:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 亚太地区（新加坡） | ` arn:aws:lambda:ap-southeast-1:068035103298:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 亚太地区（悉尼） | ` arn:aws:lambda:ap-southeast-2:584677157514:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 亚太地区（台北） | ` arn:aws:lambda:ap-east-2:471112897378:layer:AWS-CW-SyntheticsNodeJsPlaywright:9` |
| 亚太地区（泰国） | ` arn:aws:lambda:ap-southeast-7:851725245975:layer:AWS-CW-SyntheticsNodeJsPlaywright:3` |
| 亚太地区（东京） | ` arn:aws:lambda:ap-northeast-1:172291836251:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 加拿大（中部） | ` arn:aws:lambda:ca-central-1:236629016841:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 加拿大西部（卡尔加里） | ` arn:aws:lambda:ca-west-1:944448206667:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 中国（北京） | ` arn:aws-cn:lambda:cn-north-1:422629156088:layer:AWS-CW-SyntheticsNodeJsPlaywright:3` |
| 中国（宁夏）； | ` arn:aws-cn:lambda:cn-northwest-1:474974519687:layer:AWS-CW-SyntheticsNodeJsPlaywright:3` |
| 欧洲地区（法兰克福） | ` arn:aws:lambda:eu-central-1:122305336817:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 欧洲地区（爱尔兰） | ` arn:aws:lambda:eu-west-1:563204233543:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 欧洲地区（伦敦） | ` arn:aws:lambda:eu-west-2:565831452869:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 欧洲地区（米兰） | ` arn:aws:lambda:eu-south-1:525618516618:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 欧洲地区（巴黎） | ` arn:aws:lambda:eu-west-3:469466506258:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 欧洲（西班牙） | ` arn:aws:lambda:eu-south-2:029793053121:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 欧洲地区（斯德哥尔摩） | ` arn:aws:lambda:eu-north-1:162938142733:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 欧洲（苏黎世） | ` arn:aws:lambda:eu-central-2:224218992030:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 以色列（特拉维夫） | ` arn:aws:lambda:il-central-1:313249807427:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 墨西哥（中部） | ` arn:aws:lambda:mx-central-1:654654265476:layer:AWS-CW-SyntheticsNodeJsPlaywright:5` |
| 中东（巴林） | ` arn:aws:lambda:me-south-1:823195537320:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 中东（阿联酋）： | ` arn:aws:lambda:me-central-1:239544149032:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| 南美洲（圣保罗） | ` arn:aws:lambda:sa-east-1:783765544751:layer:AWS-CW-SyntheticsNodeJsPlaywright:4` |
| AWS GovCloud（美国东部） | ` arn:aws-us-gov:lambda:us-gov-east-1:946759330430:layer:AWS-CW-SyntheticsNodeJsPlaywright:3` |
| AWS GovCloud（美国西部） | ` arn:aws-us-gov:lambda:us-gov-west-1:946807836238:layer:AWS-CW-SyntheticsNodeJsPlaywright:3` |
#### syn-nodejs-playwright-1.0 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-nodejs-playwright-1.0` 版本 CloudWatch Synthetics 运行时的适用 ARN。
| 区域 | ARN |
| --- | --- |
| 美国东部（弗吉尼亚州北部） | ` arn:aws:lambda:us-east-1:378653112637:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 美国东部（俄亥俄州） | ` arn:aws:lambda:us-east-2:772927465453:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 美国西部（北加利福尼亚） | ` arn:aws:lambda:us-west-1:332033056316:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 美国西部（俄勒冈州） | ` arn:aws:lambda:us-west-2:760325925879:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 非洲（开普敦） | ` arn:aws:lambda:af-south-1:461844272066:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 亚太地区（香港） | ` arn:aws:lambda:ap-east-1:129828061636:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 亚太地区（海得拉巴） | ` arn:aws:lambda:ap-south-2:280298676434:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 亚太地区（雅加达） | ` arn:aws:lambda:ap-southeast-3:246953257743:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 亚太地区（马来西亚） | ` arn:aws:lambda:ap-southeast-5:035872523913:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 亚太地区（墨尔本） | ` arn:aws:lambda:ap-southeast-4:200724813040:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 亚太地区（孟买） | ` arn:aws:lambda:ap-south-1:724929286329:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 亚太地区（新西兰） | ` arn:aws:lambda:ap-southeast-6:779414629109:layer:AWS-CW-SyntheticsNodeJsPlaywright:8` |
| 亚太地区（大阪） | ` arn:aws:lambda:ap-northeast-3:608016332111:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 亚太地区（首尔） | ` arn:aws:lambda:ap-northeast-2:989515803484:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 亚太地区（新加坡） | ` arn:aws:lambda:ap-southeast-1:068035103298:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 亚太地区（悉尼） | ` arn:aws:lambda:ap-southeast-2:584677157514:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 亚太地区（台北） | ` arn:aws:lambda:ap-east-2:471112897378:layer:AWS-CW-SyntheticsNodeJsPlaywright:10` |
| 亚太地区（泰国） | ` arn:aws:lambda:ap-southeast-7:851725245975:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 亚太地区（东京） | ` arn:aws:lambda:ap-northeast-1:172291836251:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 加拿大（中部） | ` arn:aws:lambda:ca-central-1:236629016841:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 加拿大西部（卡尔加里） | ` arn:aws:lambda:ca-west-1:944448206667:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 中国（北京） | ` arn:aws-cn:lambda:cn-north-1:422629156088:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 中国（宁夏）； | ` arn:aws-cn:lambda:cn-northwest-1:474974519687:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 欧洲地区（法兰克福） | ` arn:aws:lambda:eu-central-1:122305336817:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 欧洲地区（爱尔兰） | ` arn:aws:lambda:eu-west-1:563204233543:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 欧洲地区（伦敦） | ` arn:aws:lambda:eu-west-2:565831452869:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 欧洲地区（米兰） | ` arn:aws:lambda:eu-south-1:525618516618:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 欧洲地区（巴黎） | ` arn:aws:lambda:eu-west-3:469466506258:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 欧洲（西班牙） | ` arn:aws:lambda:eu-south-2:029793053121:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 欧洲地区（斯德哥尔摩） | ` arn:aws:lambda:eu-north-1:162938142733:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 欧洲（苏黎世） | ` arn:aws:lambda:eu-central-2:224218992030:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 以色列（特拉维夫） | ` arn:aws:lambda:il-central-1:313249807427:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 墨西哥（中部） | ` arn:aws:lambda:mx-central-1:654654265476:layer:AWS-CW-SyntheticsNodeJsPlaywright:3` |
| 中东（巴林） | ` arn:aws:lambda:me-south-1:823195537320:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 中东（阿联酋）： | ` arn:aws:lambda:me-central-1:239544149032:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| 南美洲（圣保罗） | ` arn:aws:lambda:sa-east-1:783765544751:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| AWS GovCloud（美国东部） | ` arn:aws-us-gov:lambda:us-gov-east-1:946759330430:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
| AWS GovCloud（美国西部） | ` arn:aws-us-gov:lambda:us-gov-west-1:946807836238:layer:AWS-CW-SyntheticsNodeJsPlaywright:1` |
### Node.js 运行时
#### syn-nodejs-4.1 的 ARN
下表列出了要在各个 AWS 区域中用于 `syn-nodejs-4.1` 版本 CloudWatch Synthetics 运行时的适用 ARN。
| 区域 | ARN |
| --- | --- |
| 美国东部（弗吉尼亚州北部） | `arn:aws:lambda:us-east-1:378653112637:layer:AWS-CW-SyntheticsNodeJs:12` |
| 美国东部（俄亥俄州） | `arn:aws:lambda:us-east-2:772927465453:layer:AWS-CW-SyntheticsNodeJs:12` |
| 美国西部（北加利福尼亚） | `arn:aws:lambda:us-west-1:332033056316:layer:AWS-CW-SyntheticsNodeJs:12` |
| 美国西部（俄勒冈州） | `arn:aws:lambda:us-west-2:760325925879:layer:AWS-CW-SyntheticsNodeJs:12` |
| 非洲（开普敦） | ` arn:aws:lambda:af-south-1:461844272066:layer:AWS-CW-SyntheticsNodeJs:12` |
| 亚太地区（香港） | `arn:aws:lambda:ap-east-1:129828061636:layer:AWS-CW-SyntheticsNodeJs:12` |
| 亚太地区（海得拉巴） | ` arn:aws:lambda:ap-south-2:280298676434:layer:AWS-CW-SyntheticsNodeJs:12` |
| 亚太地区（雅加达） | ` arn:aws:lambda:ap-southeast-3:246953257743:layer:AWS-CW-SyntheticsNodeJs:12` |
| 亚太地区（马来西亚） | ` arn:aws:lambda:ap-southeast-5:035872523913:layer:AWS-CW-SyntheticsNodeJs:12` |
| 亚太地区（墨尔本） | ` arn:aws:lambda:ap-southeast-4:200724813040:layer:AWS-CW-SyntheticsNodeJs:12` |
| 亚太地区（孟买） | ` arn:aws:lambda:ap-south-1:724929286329:layer:AWS-CW-SyntheticsNodeJs:12` |
| 亚太地区（新西兰） | ` arn:aws:lambda:ap-southeast-6:779414629109:layer:AWS-CW-SyntheticsNodeJs:12` |
| 亚太地区（大阪） | ` arn:aws:lambda:ap-northeast-3:608016332111:layer:AWS-CW-SyntheticsNodeJs:12` |
| 亚太地区（首尔） | ` arn:aws:lambda:ap-northeast-2:989515803484:layer:AWS-CW-SyntheticsNodeJs:12` |
| 亚太地区（新加坡） | ` arn:aws:lambda:ap-southeast-1:068035103298:layer:AWS-CW-SyntheticsNodeJs:12` |
| 亚太地区（悉尼） | ` arn:aws:lambda:ap-southeast-2:584677157514:layer:AWS-CW-SyntheticsNodeJs:12` |
| 亚太地区（台北） | `arn:aws:lambda:ap-east-2:471112897378:layer:AWS-CW-SyntheticsNodeJs:12` |
| 亚太地区（泰国） | ` arn:aws:lambda:ap-southeast-7:851725245975:layer:AWS-CW-SyntheticsNodeJs:12` |
| 亚太地区（东京） | ` arn:aws:lambda:ap-northeast-1:172291836251:layer:AWS-CW-SyntheticsNodeJs:12` |
| 加拿大（中部） | ` arn:aws:lambda:ca-central-1:236629016841:layer:AWS-CW-SyntheticsNodeJs:12` |
| 加拿大西部（卡尔加里） | `arn:aws:lambda:ca-west-1:944448206667:layer:AWS-CW-SyntheticsNodeJs:12` |
| 中国（北京） | ` arn:aws-cn:lambda:cn-north-1:422629156088:layer:AWS-CW-SyntheticsNodeJs:12` |
| 中国（宁夏） | ` arn:aws-cn:lambda:cn-northwest-1:474974519687:layer:AWS-CW-SyntheticsNodeJs:12` |
| 欧洲地区（法兰克福） | ` arn:aws:lambda:eu-central-1:122305336817:layer:AWS-CW-SyntheticsNodeJs:12` |
| 欧洲地区（爱尔兰） | `arn:aws:lambda:eu-west-1:563204233543:layer:AWS-CW-SyntheticsNodeJs:12` |
| 欧洲地区（伦敦） | `arn:aws:lambda:eu-west-2:565831452869:layer:AWS-CW-SyntheticsNodeJs:12` |
| 欧洲地区（米兰） | ` arn:aws:lambda:eu-south-1:525618516618:layer:AWS-CW-SyntheticsNodeJs:12` |
| 欧洲地区（巴黎） | `arn:aws:lambda:eu-west-3:469466506258:layer:AWS-CW-SyntheticsNodeJs:12` |
| 欧洲（西班牙） | ` arn:aws:lambda:eu-south-2:029793053121:layer:AWS-CW-SyntheticsNodeJs:12` |
| 欧洲地区（斯德哥尔摩） | ` arn:aws:lambda:eu-north-1:162938142733:layer:AWS-CW-SyntheticsNodeJs:12` |
| 欧洲（苏黎世） | ` arn:aws:lambda:eu-central-2:224218992030:layer:AWS-CW-SyntheticsNodeJs:12` |
| 以色列（特拉维夫） | ` arn:aws:lambda:il-central-1:313249807427:layer:AWS-CW-SyntheticsNodeJs:12` |
| 墨西哥（中部） | ` arn:aws:lambda:mx-central-1:654654265476:layer:AWS-CW-SyntheticsNodeJs:12` |
| 南美洲（圣保罗） | `arn:aws:lambda:sa-east-1:783765544751:layer:AWS-CW-SyntheticsNodeJs:12` |
| AWS GovCloud（美国东部） | ` arn:aws-us-gov:lambda:us-gov-east-1:946759330430:layer:AWS-CW-SyntheticsNodeJs:12` |
| AWS GovCloud（美国西部） | ` arn:aws-us-gov:lambda:us-gov-west-1:946807836238:layer:AWS-CW-SyntheticsNodeJs:12` |
#### syn-nodejs-4.0 的 ARN
下表列出了要在各个 AWS 区域中用于 `syn-nodejs-4.0` 版本 CloudWatch Synthetics 运行时的适用 ARN。
| 区域 | ARN |
| --- | --- |
| 美国东部（弗吉尼亚州北部） | `arn:aws:lambda:us-east-1:378653112637:layer:AWS-CW-SyntheticsNodeJs:11` |
| 美国东部（俄亥俄州） | `arn:aws:lambda:us-east-2:772927465453:layer:AWS-CW-SyntheticsNodeJs:11` |
| 美国西部（北加利福尼亚） | `arn:aws:lambda:us-west-1:332033056316:layer:AWS-CW-SyntheticsNodeJs:11` |
| 美国西部（俄勒冈州） | `arn:aws:lambda:us-west-2:760325925879:layer:AWS-CW-SyntheticsNodeJs:11` |
| 非洲（开普敦） | ` arn:aws:lambda:af-south-1:461844272066:layer:AWS-CW-SyntheticsNodeJs:11` |
| 亚太地区（香港） | `arn:aws:lambda:ap-east-1:129828061636:layer:AWS-CW-SyntheticsNodeJs:11` |
| 亚太地区（海得拉巴） | ` arn:aws:lambda:ap-south-2:280298676434:layer:AWS-CW-SyntheticsNodeJs:11` |
| 亚太地区（雅加达） | ` arn:aws:lambda:ap-southeast-3:246953257743:layer:AWS-CW-SyntheticsNodeJs:11` |
| 亚太地区（马来西亚） | ` arn:aws:lambda:ap-southeast-5:035872523913:layer:AWS-CW-SyntheticsNodeJs:11` |
| 亚太地区（墨尔本） | ` arn:aws:lambda:ap-southeast-4:200724813040:layer:AWS-CW-SyntheticsNodeJs:11` |
| 亚太地区（孟买） | ` arn:aws:lambda:ap-south-1:724929286329:layer:AWS-CW-SyntheticsNodeJs:11` |
| 亚太地区（新西兰） | ` arn:aws:lambda:ap-southeast-6:779414629109:layer:AWS-CW-SyntheticsNodeJs:11` |
| 亚太地区（大阪） | ` arn:aws:lambda:ap-northeast-3:608016332111:layer:AWS-CW-SyntheticsNodeJs:11` |
| 亚太地区（首尔） | ` arn:aws:lambda:ap-northeast-2:989515803484:layer:AWS-CW-SyntheticsNodeJs:11` |
| 亚太地区（新加坡） | ` arn:aws:lambda:ap-southeast-1:068035103298:layer:AWS-CW-SyntheticsNodeJs:11` |
| 亚太地区（悉尼） | ` arn:aws:lambda:ap-southeast-2:584677157514:layer:AWS-CW-SyntheticsNodeJs:11` |
| 亚太地区（台北） | `arn:aws:lambda:ap-east-2:471112897378:layer:AWS-CW-SyntheticsNodeJs:11` |
| 亚太地区（泰国） | ` arn:aws:lambda:ap-southeast-7:851725245975:layer:AWS-CW-SyntheticsNodeJs:11` |
| 亚太地区（东京） | ` arn:aws:lambda:ap-northeast-1:172291836251:layer:AWS-CW-SyntheticsNodeJs:11` |
| 加拿大（中部） | ` arn:aws:lambda:ca-central-1:236629016841:layer:AWS-CW-SyntheticsNodeJs:11` |
| 加拿大西部（卡尔加里） | `arn:aws:lambda:ca-west-1:944448206667:layer:AWS-CW-SyntheticsNodeJs:11` |
| 中国（北京） | ` arn:aws-cn:lambda:cn-north-1:422629156088:layer:AWS-CW-SyntheticsNodeJs:11` |
| 中国（宁夏） | ` arn:aws-cn:lambda:cn-northwest-1:474974519687:layer:AWS-CW-SyntheticsNodeJs:11` |
| 欧洲地区（法兰克福） | ` arn:aws:lambda:eu-central-1:122305336817:layer:AWS-CW-SyntheticsNodeJs:11` |
| 欧洲地区（爱尔兰） | `arn:aws:lambda:eu-west-1:563204233543:layer:AWS-CW-SyntheticsNodeJs:11` |
| 欧洲地区（伦敦） | `arn:aws:lambda:eu-west-2:565831452869:layer:AWS-CW-SyntheticsNodeJs:11` |
| 欧洲地区（米兰） | ` arn:aws:lambda:eu-south-1:525618516618:layer:AWS-CW-SyntheticsNodeJs:11` |
| 欧洲地区（巴黎） | `arn:aws:lambda:eu-west-3:469466506258:layer:AWS-CW-SyntheticsNodeJs:11` |
| 欧洲（西班牙） | ` arn:aws:lambda:eu-south-2:029793053121:layer:AWS-CW-SyntheticsNodeJs:11` |
| 欧洲地区（斯德哥尔摩） | ` arn:aws:lambda:eu-north-1:162938142733:layer:AWS-CW-SyntheticsNodeJs:11` |
| 欧洲（苏黎世） | ` arn:aws:lambda:eu-central-2:224218992030:layer:AWS-CW-SyntheticsNodeJs:11` |
| 以色列（特拉维夫） | ` arn:aws:lambda:il-central-1:313249807427:layer:AWS-CW-SyntheticsNodeJs:11` |
| 墨西哥（中部） | ` arn:aws:lambda:mx-central-1:654654265476:layer:AWS-CW-SyntheticsNodeJs:11` |
| 南美洲（圣保罗） | `arn:aws:lambda:sa-east-1:783765544751:layer:AWS-CW-SyntheticsNodeJs:11` |
| AWS GovCloud（美国东部） | ` arn:aws-us-gov:lambda:us-gov-east-1:946759330430:layer:AWS-CW-SyntheticsNodeJs:11` |
| AWS GovCloud（美国西部） | ` arn:aws-us-gov:lambda:us-gov-west-1:946807836238:layer:AWS-CW-SyntheticsNodeJs:11` |
#### syn-nodejs-3.1 的 ARN
下表列出了要在各个 AWS 区域中用于 `syn-nodejs-3.1` 版本 CloudWatch Synthetics 运行时的适用 ARN。
| 区域 | ARN |
| --- | --- |
| 美国东部（弗吉尼亚州北部） | `arn:aws:lambda:us-east-1:378653112637:layer:AWS-CW-SyntheticsNodeJs:9` |
| 美国东部（俄亥俄州） | `arn:aws:lambda:us-east-2:772927465453:layer:AWS-CW-SyntheticsNodeJs:9` |
| 美国西部（北加利福尼亚） | `arn:aws:lambda:us-west-1:332033056316:layer:AWS-CW-SyntheticsNodeJs:9` |
| 美国西部（俄勒冈州） | `arn:aws:lambda:us-west-2:760325925879:layer:AWS-CW-SyntheticsNodeJs:9` |
| 非洲（开普敦） | `arn:aws:lambda:af-south-1:461844272066:layer:AWS-CW-SyntheticsNodeJs:9` |
| 亚太地区（香港） | `arn:aws:lambda:ap-east-1:129828061636:layer:AWS-CW-SyntheticsNodeJs:9` |
| 亚太地区（海得拉巴） | `arn:aws:lambda:ap-south-2:280298676434:layer:AWS-CW-SyntheticsNodeJs:9` |
| 亚太地区（雅加达） | ` arn:aws:lambda:ap-southeast-3:246953257743:layer:AWS-CW-SyntheticsNodeJs:9` |
| 亚太地区（马来西亚） | ` arn:aws:lambda:ap-southeast-5:035872523913:layer:AWS-CW-SyntheticsNodeJs:9` |
| 亚太地区（墨尔本） | ` arn:aws:lambda:ap-southeast-4:200724813040:layer:AWS-CW-SyntheticsNodeJs:9` |
| 亚太地区（孟买） | `arn:aws:lambda:ap-south-1:724929286329:layer:AWS-CW-SyntheticsNodeJs:9` |
| 亚太地区（新西兰） | ` arn:aws:lambda:ap-southeast-6:779414629109:layer:AWS-CW-SyntheticsNodeJs:9` |
| 亚太地区（大阪） | ` arn:aws:lambda:ap-northeast-3:608016332111:layer:AWS-CW-SyntheticsNodeJs:9` |
| 亚太地区（首尔） | ` arn:aws:lambda:ap-northeast-2:989515803484:layer:AWS-CW-SyntheticsNodeJs:9` |
| 亚太地区（新加坡） | ` arn:aws:lambda:ap-southeast-1:068035103298:layer:AWS-CW-SyntheticsNodeJs:9` |
| 亚太地区（悉尼） | ` arn:aws:lambda:ap-southeast-2:584677157514:layer:AWS-CW-SyntheticsNodeJs:9` |
| 亚太地区（台北） | `arn:aws:lambda:ap-east-2:471112897378:layer:AWS-CW-SyntheticsNodeJs:9` |
| 亚太地区（泰国） | ` arn:aws:lambda:ap-southeast-7:851725245975:layer:AWS-CW-SyntheticsNodeJs:9` |
| 亚太地区（东京） | ` arn:aws:lambda:ap-northeast-1:172291836251:layer:AWS-CW-SyntheticsNodeJs:9` |
| 加拿大（中部） | ` arn:aws:lambda:ca-central-1:236629016841:layer:AWS-CW-SyntheticsNodeJs:9` |
| 加拿大西部（卡尔加里） | `arn:aws:lambda:ca-west-1:944448206667:layer:AWS-CW-SyntheticsNodeJs:9` |
| 中国（北京） | ` arn:aws-cn:lambda:cn-north-1:422629156088:layer:AWS-CW-SyntheticsNodeJs:9` |
| 中国（宁夏） | ` arn:aws-cn:lambda:cn-northwest-1:474974519687:layer:AWS-CW-SyntheticsNodeJs:9` |
| 欧洲地区（法兰克福） | ` arn:aws:lambda:eu-central-1:122305336817:layer:AWS-CW-SyntheticsNodeJs:9` |
| 欧洲地区（爱尔兰） | `arn:aws:lambda:eu-west-1:563204233543:layer:AWS-CW-SyntheticsNodeJs:9` |
| 欧洲地区（伦敦） | `arn:aws:lambda:eu-west-2:565831452869:layer:AWS-CW-SyntheticsNodeJs:9` |
| 欧洲地区（米兰） | `arn:aws:lambda:eu-south-1:525618516618:layer:AWS-CW-SyntheticsNodeJs:9` |
| 欧洲地区（巴黎） | `arn:aws:lambda:eu-west-3:469466506258:layer:AWS-CW-SyntheticsNodeJs:9` |
| 欧洲（西班牙） | `arn:aws:lambda:eu-south-2:029793053121:layer:AWS-CW-SyntheticsNodeJs:9` |
| 欧洲地区（斯德哥尔摩） | `arn:aws:lambda:eu-north-1:162938142733:layer:AWS-CW-SyntheticsNodeJs:9` |
| 欧洲（苏黎世） | ` arn:aws:lambda:eu-central-2:224218992030:layer:AWS-CW-SyntheticsNodeJs:9` |
| 以色列（特拉维夫） | ` arn:aws:lambda:il-central-1:313249807427:layer:AWS-CW-SyntheticsNodeJs:9` |
| 墨西哥（中部） | ` arn:aws:lambda:mx-central-1:654654265476:layer:AWS-CW-SyntheticsNodeJs:9` |
| 中东（巴林） | `arn:aws:lambda:me-south-1:823195537320:layer:AWS-CW-SyntheticsNodeJs:9` |
| 中东（阿联酋）： | ` arn:aws:lambda:me-central-1:239544149032:layer:AWS-CW-SyntheticsNodeJs:9` |
| 南美洲（圣保罗） | `arn:aws:lambda:sa-east-1:783765544751:layer:AWS-CW-SyntheticsNodeJs:9` |
| AWS GovCloud（美国东部） | ` arn:aws-us-gov:lambda:us-gov-east-1:946759330430:layer:AWS-CW-SyntheticsNodeJs:9` |
| AWS GovCloud（美国西部） | ` arn:aws-us-gov:lambda:us-gov-west-1:946807836238:layer:AWS-CW-SyntheticsNodeJs:9` |
#### syn-nodejs-3.0 的 ARN
下表列出了要在各个 AWS 区域中用于 `syn-nodejs-3.0` 版本 CloudWatch Synthetics 运行时的适用 ARN。
| 区域 | ARN |
| --- | --- |
| 美国东部（弗吉尼亚州北部） | `arn:aws:lambda:us-east-1:378653112637:layer:AWS-CW-SyntheticsNodeJs:1` |
| 美国东部（俄亥俄州） | `arn:aws:lambda:us-east-2:772927465453:layer:AWS-CW-SyntheticsNodeJs:1` |
| 美国西部（北加利福尼亚） | `arn:aws:lambda:us-west-1:332033056316:layer:AWS-CW-SyntheticsNodeJs:1` |
| 美国西部（俄勒冈州） | `arn:aws:lambda:us-west-2:760325925879:layer:AWS-CW-SyntheticsNodeJs:1` |
| 非洲（开普敦） | `arn:aws:lambda:af-south-1:461844272066:layer:AWS-CW-SyntheticsNodeJs:1` |
| 亚太地区（香港） | `arn:aws:lambda:ap-east-1:129828061636:layer:AWS-CW-SyntheticsNodeJs:1` |
| 亚太地区（海得拉巴） | `arn:aws:lambda:ap-south-2:280298676434:layer:AWS-CW-SyntheticsNodeJs:1` |
| 亚太地区（雅加达） | ` arn:aws:lambda:ap-southeast-3:246953257743:layer:AWS-CW-SyntheticsNodeJs:1` |
| 亚太地区（马来西亚） | ` arn:aws:lambda:ap-southeast-5:035872523913:layer:AWS-CW-SyntheticsNodeJs:1` |
| 亚太地区（墨尔本） | ` arn:aws:lambda:ap-southeast-4:200724813040:layer:AWS-CW-SyntheticsNodeJs:1` |
| 亚太地区（孟买） | `arn:aws:lambda:ap-south-1:724929286329:layer:AWS-CW-SyntheticsNodeJs:1` |
| 亚太地区（新西兰） | ` arn:aws:lambda:ap-southeast-6:779414629109:layer:AWS-CW-SyntheticsNodeJs:1` |
| 亚太地区（大阪） | ` arn:aws:lambda:ap-northeast-3:608016332111:layer:AWS-CW-SyntheticsNodeJs:1` |
| 亚太地区（首尔） | ` arn:aws:lambda:ap-northeast-2:989515803484:layer:AWS-CW-SyntheticsNodeJs:1` |
| 亚太地区（新加坡） | ` arn:aws:lambda:ap-southeast-1:068035103298:layer:AWS-CW-SyntheticsNodeJs:1` |
| 亚太地区（悉尼） | ` arn:aws:lambda:ap-southeast-2:584677157514:layer:AWS-CW-SyntheticsNodeJs:1` |
| 亚太地区（台北） | `arn:aws:lambda:ap-east-2:471112897378:layer:AWS-CW-SyntheticsNodeJs:1` |
| 亚太地区（泰国） | ` arn:aws:lambda:ap-southeast-7:851725245975:layer:AWS-CW-SyntheticsNodeJs:1` |
| 亚太地区（东京） | ` arn:aws:lambda:ap-northeast-1:172291836251:layer:AWS-CW-SyntheticsNodeJs:1` |
| 加拿大（中部） | ` arn:aws:lambda:ca-central-1:236629016841:layer:AWS-CW-SyntheticsNodeJs:1` |
| 加拿大西部（卡尔加里） | `arn:aws:lambda:ca-west-1:944448206667:layer:AWS-CW-SyntheticsNodeJs:1` |
| 中国（北京） | ` arn:aws-cn:lambda:cn-north-1:422629156088:layer:AWS-CW-SyntheticsNodeJs:1` |
| 中国（宁夏） | ` arn:aws-cn:lambda:cn-northwest-1:474974519687:layer:AWS-CW-SyntheticsNodeJs:1` |
| 欧洲地区（法兰克福） | ` arn:aws:lambda:eu-central-1:122305336817:layer:AWS-CW-SyntheticsNodeJs:1` |
| 欧洲地区（爱尔兰） | `arn:aws:lambda:eu-west-1:563204233543:layer:AWS-CW-SyntheticsNodeJs:1` |
| 欧洲地区（伦敦） | `arn:aws:lambda:eu-west-2:565831452869:layer:AWS-CW-SyntheticsNodeJs:1` |
| 欧洲地区（米兰） | `arn:aws:lambda:eu-south-1:525618516618:layer:AWS-CW-SyntheticsNodeJs:1` |
| 欧洲地区（巴黎） | `arn:aws:lambda:eu-west-3:469466506258:layer:AWS-CW-SyntheticsNodeJs:1` |
| 欧洲（西班牙） | `arn:aws:lambda:eu-south-2:029793053121:layer:AWS-CW-SyntheticsNodeJs:1` |
| 欧洲地区（斯德哥尔摩） | `arn:aws:lambda:eu-north-1:162938142733:layer:AWS-CW-SyntheticsNodeJs:1` |
| 欧洲（苏黎世） | ` arn:aws:lambda:eu-central-2:224218992030:layer:AWS-CW-SyntheticsNodeJs:1` |
| 以色列（特拉维夫） | ` arn:aws:lambda:il-central-1:313249807427:layer:AWS-CW-SyntheticsNodeJs:1` |
| 墨西哥（中部） | ` arn:aws:lambda:mx-central-1:654654265476:layer:AWS-CW-SyntheticsNodeJs:1` |
| 中东（巴林） | `arn:aws:lambda:me-south-1:823195537320:layer:AWS-CW-SyntheticsNodeJs:1` |
| 中东（阿联酋）： | ` arn:aws:lambda:me-central-1:239544149032:layer:AWS-CW-SyntheticsNodeJs:1` |
| 南美洲（圣保罗） | `arn:aws:lambda:sa-east-1:783765544751:layer:AWS-CW-SyntheticsNodeJs:1` |
| AWS GovCloud（美国东部） | ` arn:aws-us-gov:lambda:us-gov-east-1:946759330430:layer:AWS-CW-SyntheticsNodeJs:1` |
| AWS GovCloud（美国西部） | ` arn:aws-us-gov:lambda:us-gov-west-1:946807836238:layer:AWS-CW-SyntheticsNodeJs:1` |
### Python 和 Selenium 运行时
#### syn-python-selenium-10.0 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-python-selenium-10.0` 版本 CloudWatch Synthetics 运行时的适用 ARN。
| 区域 | ARN |
| --- | --- |
| 美国东部（弗吉尼亚州北部） | `arn:aws:lambda:us-east-1:378653112637:layer:Synthetics_Selenium:62` |
| 美国东部（俄亥俄州） | `arn:aws:lambda:us-east-2:772927465453:layer:Synthetics_Selenium:65` |
| 美国西部（北加利福尼亚） | `arn:aws:lambda:us-west-1:332033056316:layer:Synthetics_Selenium:63` |
| 美国西部（俄勒冈州） | `arn:aws:lambda:us-west-2:760325925879:layer:Synthetics_Selenium:64` |
| 非洲（开普敦） | `arn:aws:lambda:af-south-1:461844272066:layer:Synthetics_Selenium:63` |
| 亚太地区（香港） | `arn:aws:lambda:ap-east-1:129828061636:layer:Synthetics_Selenium:62` |
| 亚太地区（海得拉巴） | `arn:aws:lambda:ap-south-2:280298676434:layer:Synthetics_Selenium:50` |
| 亚太地区（雅加达） | ` arn:aws:lambda:ap-southeast-3:246953257743:layer:Synthetics_Selenium:57` |
| 亚太地区（马来西亚） | ` arn:aws:lambda:ap-southeast-5:035872523913:layer:Synthetics_Selenium:32` |
| 亚太地区（墨尔本） | ` arn:aws:lambda:ap-southeast-4:200724813040:layer:Synthetics_Selenium:48` |
| 亚太地区（孟买） | `arn:aws:lambda:ap-south-1:724929286329:layer:Synthetics_Selenium:63` |
| 亚太地区（新西兰） | ` arn:aws:lambda:ap-southeast-6:779414629109:layer:Synthetics_Selenium:38` |
| 亚太地区（大阪） | ` arn:aws:lambda:ap-northeast-3:608016332111:layer:Synthetics_Selenium:61` |
| 亚太地区（首尔） | ` arn:aws:lambda:ap-northeast-2:989515803484:layer:Synthetics_Selenium:66` |
| 亚太地区（新加坡） | ` arn:aws:lambda:ap-southeast-1:068035103298:layer:Synthetics_Selenium:67` |
| 亚太地区（悉尼） | ` arn:aws:lambda:ap-southeast-2:584677157514:layer:Synthetics_Selenium:62` |
| 亚太地区（台北） | `arn:aws:lambda:ap-east-2:471112897378:layer:Synthetics_Selenium:25` |
| 亚太地区（泰国） | ` arn:aws:lambda:ap-southeast-7:851725245975:layer:Synthetics_Selenium:23` |
| 亚太地区（东京） | ` arn:aws:lambda:ap-northeast-1:172291836251:layer:Synthetics_Selenium:63` |
| 加拿大（中部） | `arn:aws:lambda:ca-central-1:236629016841:layer:Synthetics_Selenium:63` |
| 加拿大西部（卡尔加里） | `arn:aws:lambda:ca-west-1:944448206667:layer:Synthetics_Selenium:106` |
| 中国（北京） | `arn:aws-cn:lambda:cn-north-1:422629156088:layer:Synthetics_Selenium:61` |
| 中国（宁夏） | ` arn:aws-cn:lambda:cn-northwest-1:474974519687:layer:Synthetics_Selenium:61` |
| 欧洲地区（法兰克福） | `arn:aws:lambda:eu-central-1:122305336817:layer:Synthetics_Selenium:63` |
| 欧洲地区（爱尔兰） | `arn:aws:lambda:eu-west-1:563204233543:layer:Synthetics_Selenium:64` |
| 欧洲地区（伦敦） | `arn:aws:lambda:eu-west-2:565831452869:layer:Synthetics_Selenium:62` |
| 欧洲地区（米兰） | `arn:aws:lambda:eu-south-1:525618516618:layer:Synthetics_Selenium:64` |
| 欧洲地区（巴黎） | `arn:aws:lambda:eu-west-3:469466506258:layer:Synthetics_Selenium:63` |
| 欧洲（西班牙） | `arn:aws:lambda:eu-south-2:029793053121:layer:Synthetics_Selenium:50` |
| 欧洲地区（斯德哥尔摩） | `arn:aws:lambda:eu-north-1:162938142733:layer:Synthetics_Selenium:63` |
| 欧洲（苏黎世） | `arn:aws:lambda:eu-central-2:224218992030:layer:Synthetics_Selenium:49` |
| 以色列（特拉维夫） | `arn:aws:lambda:il-central-1:313249807427:layer:Synthetics_Selenium:47` |
| 墨西哥（中部） | `arn:aws:lambda:mx-central-1:654654265476:layer:Synthetics_Selenium:24` |
| 南美洲（圣保罗） | `arn:aws:lambda:sa-east-1:783765544751:layer:Synthetics_Selenium:64` |
| AWS GovCloud（美国东部） | ` arn:aws-us-gov:lambda:us-gov-east-1:946759330430:layer:Synthetics_Selenium:59` |
| AWS GovCloud（美国西部） | ` arn:aws-us-gov:lambda:us-gov-west-1:946807836238:layer:Synthetics_Selenium:60` |
#### syn-python-selenium-9.0 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-python-selenium-9.0` 版本 CloudWatch Synthetics 运行时的适用 ARN。
| 区域 | ARN |
| --- | --- |
| 美国东部（弗吉尼亚州北部） | `arn:aws:lambda:us-east-1:378653112637:layer:Synthetics_Selenium:61` |
| 美国东部（俄亥俄州） | `arn:aws:lambda:us-east-2:772927465453:layer:Synthetics_Selenium:64` |
| 美国西部（北加利福尼亚） | `arn:aws:lambda:us-west-1:332033056316:layer:Synthetics_Selenium:62` |
| 美国西部（俄勒冈州） | `arn:aws:lambda:us-west-2:760325925879:layer:Synthetics_Selenium:63` |
| 非洲（开普敦） | `arn:aws:lambda:af-south-1:461844272066:layer:Synthetics_Selenium:62` |
| 亚太地区（香港） | `arn:aws:lambda:ap-east-1:129828061636:layer:Synthetics_Selenium:61` |
| 亚太地区（海得拉巴） | `arn:aws:lambda:ap-south-2:280298676434:layer:Synthetics_Selenium:49` |
| 亚太地区（雅加达） | ` arn:aws:lambda:ap-southeast-3:246953257743:layer:Synthetics_Selenium:56` |
| 亚太地区（马来西亚） | ` arn:aws:lambda:ap-southeast-5:035872523913:layer:Synthetics_Selenium:31` |
| 亚太地区（墨尔本） | ` arn:aws:lambda:ap-southeast-4:200724813040:layer:Synthetics_Selenium:47` |
| 亚太地区（孟买） | `arn:aws:lambda:ap-south-1:724929286329:layer:Synthetics_Selenium:62` |
| 亚太地区（新西兰） | ` arn:aws:lambda:ap-southeast-6:779414629109:layer:Synthetics_Selenium:37` |
| 亚太地区（大阪） | ` arn:aws:lambda:ap-northeast-3:608016332111:layer:Synthetics_Selenium:60` |
| 亚太地区（首尔） | ` arn:aws:lambda:ap-northeast-2:989515803484:layer:Synthetics_Selenium:65` |
| 亚太地区（新加坡） | ` arn:aws:lambda:ap-southeast-1:068035103298:layer:Synthetics_Selenium:66` |
| 亚太地区（悉尼） | ` arn:aws:lambda:ap-southeast-2:584677157514:layer:Synthetics_Selenium:61` |
| 亚太地区（台北） | `arn:aws:lambda:ap-east-2:471112897378:layer:Synthetics_Selenium:24` |
| 亚太地区（泰国） | ` arn:aws:lambda:ap-southeast-7:851725245975:layer:Synthetics_Selenium:22` |
| 亚太地区（东京） | ` arn:aws:lambda:ap-northeast-1:172291836251:layer:Synthetics_Selenium:62` |
| 加拿大（中部） | `arn:aws:lambda:ca-central-1:236629016841:layer:Synthetics_Selenium:62` |
| 加拿大西部（卡尔加里） | `arn:aws:lambda:ca-west-1:944448206667:layer:Synthetics_Selenium:105` |
| 中国（北京） | `arn:aws-cn:lambda:cn-north-1:422629156088:layer:Synthetics_Selenium:60` |
| 中国（宁夏） | ` arn:aws-cn:lambda:cn-northwest-1:474974519687:layer:Synthetics_Selenium:60` |
| 欧洲地区（法兰克福） | `arn:aws:lambda:eu-central-1:122305336817:layer:Synthetics_Selenium:62` |
| 欧洲地区（爱尔兰） | `arn:aws:lambda:eu-west-1:563204233543:layer:Synthetics_Selenium:63` |
| 欧洲地区（伦敦） | `arn:aws:lambda:eu-west-2:565831452869:layer:Synthetics_Selenium:61` |
| 欧洲地区（米兰） | `arn:aws:lambda:eu-south-1:525618516618:layer:Synthetics_Selenium:63` |
| 欧洲地区（巴黎） | `arn:aws:lambda:eu-west-3:469466506258:layer:Synthetics_Selenium:62` |
| 欧洲（西班牙） | `arn:aws:lambda:eu-south-2:029793053121:layer:Synthetics_Selenium:49` |
| 欧洲地区（斯德哥尔摩） | `arn:aws:lambda:eu-north-1:162938142733:layer:Synthetics_Selenium:62` |
| 欧洲（苏黎世） | `arn:aws:lambda:eu-central-2:224218992030:layer:Synthetics_Selenium:48` |
| 以色列（特拉维夫） | `arn:aws:lambda:il-central-1:313249807427:layer:Synthetics_Selenium:46` |
| 墨西哥（中部） | `arn:aws:lambda:mx-central-1:654654265476:layer:Synthetics_Selenium:23` |
| 中东（巴林） | `arn:aws:lambda:me-south-1:823195537320:layer:Synthetics_Selenium:61` |
| 中东（阿联酋）： | `arn:aws:lambda:me-central-1:239544149032:layer:Synthetics_Selenium:49` |
| 南美洲（圣保罗） | `arn:aws:lambda:sa-east-1:783765544751:layer:Synthetics_Selenium:63` |
| AWS GovCloud（美国东部） | ` arn:aws-us-gov:lambda:us-gov-east-1:946759330430:layer:Synthetics_Selenium:58` |
| AWS GovCloud（美国西部） | ` arn:aws-us-gov:lambda:us-gov-west-1:946807836238:layer:Synthetics_Selenium:59` |
#### syn-python-selenium-8.0 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-python-selenium-8.0` 版本 CloudWatch Synthetics 运行时的适用 ARN。
| 区域 | ARN |
| --- | --- |
| 美国东部（弗吉尼亚州北部） | `arn:aws:lambda:us-east-1:378653112637:layer:Synthetics_Selenium:57` |
| 美国东部（俄亥俄州） | `arn:aws:lambda:us-east-2:772927465453:layer:Synthetics_Selenium:60` |
| 美国西部（北加利福尼亚） | `arn:aws:lambda:us-west-1:332033056316:layer:Synthetics_Selenium:58` |
| 美国西部（俄勒冈州） | `arn:aws:lambda:us-west-2:760325925879:layer:Synthetics_Selenium:59` |
| 非洲（开普敦） | `arn:aws:lambda:af-south-1:461844272066:layer:Synthetics_Selenium:58` |
| 亚太地区（香港） | `arn:aws:lambda:ap-east-1:129828061636:layer:Synthetics_Selenium:57` |
| 亚太地区（海得拉巴） | `arn:aws:lambda:ap-south-2:280298676434:layer:Synthetics_Selenium:45` |
| 亚太地区（雅加达） | ` arn:aws:lambda:ap-southeast-3:246953257743:layer:Synthetics_Selenium:52` |
| 亚太地区（马来西亚） | ` arn:aws:lambda:ap-southeast-5:035872523913:layer:Synthetics_Selenium:27` |
| 亚太地区（墨尔本） | ` arn:aws:lambda:ap-southeast-4:200724813040:layer:Synthetics_Selenium:43` |
| 亚太地区（孟买） | `arn:aws:lambda:ap-south-1:724929286329:layer:Synthetics_Selenium:58` |
| 亚太地区（新西兰） | ` arn:aws:lambda:ap-southeast-6:779414629109:layer:Synthetics_Selenium:33` |
| 亚太地区（大阪） | ` arn:aws:lambda:ap-northeast-3:608016332111:layer:Synthetics_Selenium:56` |
| 亚太地区（首尔） | ` arn:aws:lambda:ap-northeast-2:989515803484:layer:Synthetics_Selenium:61` |
| 亚太地区（新加坡） | ` arn:aws:lambda:ap-southeast-1:068035103298:layer:Synthetics_Selenium:62` |
| 亚太地区（悉尼） | ` arn:aws:lambda:ap-southeast-2:584677157514:layer:Synthetics_Selenium:57` |
| 亚太地区（台北） | `arn:aws:lambda:ap-east-2:471112897378:layer:Synthetics_Selenium:20` |
| 亚太地区（泰国） | ` arn:aws:lambda:ap-southeast-7:851725245975:layer:Synthetics_Selenium:18` |
| 亚太地区（东京） | ` arn:aws:lambda:ap-northeast-1:172291836251:layer:Synthetics_Selenium:58` |
| 加拿大（中部） | `arn:aws:lambda:ca-central-1:236629016841:layer:Synthetics_Selenium:58` |
| 加拿大西部（卡尔加里） | `arn:aws:lambda:ca-west-1:944448206667:layer:Synthetics_Selenium:101` |
| 中国（北京） | `arn:aws-cn:lambda:cn-north-1:422629156088:layer:Synthetics_Selenium:56` |
| 中国（宁夏） | ` arn:aws-cn:lambda:cn-northwest-1:474974519687:layer:Synthetics_Selenium:56` |
| 欧洲地区（法兰克福） | `arn:aws:lambda:eu-central-1:122305336817:layer:Synthetics_Selenium:58` |
| 欧洲地区（爱尔兰） | `arn:aws:lambda:eu-west-1:563204233543:layer:Synthetics_Selenium:59` |
| 欧洲地区（伦敦） | `arn:aws:lambda:eu-west-2:565831452869:layer:Synthetics_Selenium:57` |
| 欧洲地区（米兰） | `arn:aws:lambda:eu-south-1:525618516618:layer:Synthetics_Selenium:59` |
| 欧洲地区（巴黎） | `arn:aws:lambda:eu-west-3:469466506258:layer:Synthetics_Selenium:58` |
| 欧洲（西班牙） | `arn:aws:lambda:eu-south-2:029793053121:layer:Synthetics_Selenium:45` |
| 欧洲地区（斯德哥尔摩） | `arn:aws:lambda:eu-north-1:162938142733:layer:Synthetics_Selenium:58` |
| 欧洲（苏黎世） | `arn:aws:lambda:eu-central-2:224218992030:layer:Synthetics_Selenium:44` |
| 以色列（特拉维夫） | `arn:aws:lambda:il-central-1:313249807427:layer:Synthetics_Selenium:42` |
| 墨西哥（中部） | `arn:aws:lambda:mx-central-1:654654265476:layer:Synthetics_Selenium:19` |
| 中东（巴林） | `arn:aws:lambda:me-south-1:823195537320:layer:Synthetics_Selenium:57` |
| 中东（阿联酋）： | `arn:aws:lambda:me-central-1:239544149032:layer:Synthetics_Selenium:45` |
| 南美洲（圣保罗） | `arn:aws:lambda:sa-east-1:783765544751:layer:Synthetics_Selenium:59` |
| AWS GovCloud（美国东部） | ` arn:aws-us-gov:lambda:us-gov-east-1:946759330430:layer:Synthetics_Selenium:54` |
| AWS GovCloud（美国西部） | ` arn:aws-us-gov:lambda:us-gov-west-1:946807836238:layer:Synthetics_Selenium:55` |
#### syn-python-selenium-7.0 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-python-selenium-7.0` 版本 CloudWatch Synthetics 运行时的适用 ARN。
| 区域 | ARN |
| --- | --- |
| 美国东部（弗吉尼亚州北部） | `arn:aws:lambda:us-east-1:378653112637:layer:Synthetics_Selenium:49` |
| 美国东部（俄亥俄州） | `arn:aws:lambda:us-east-2:772927465453:layer:Synthetics_Selenium:52` |
| 美国西部（北加利福尼亚） | `arn:aws:lambda:us-west-1:332033056316:layer:Synthetics_Selenium:50` |
| 美国西部（俄勒冈州） | `arn:aws:lambda:us-west-2:760325925879:layer:Synthetics_Selenium:51` |
| 非洲（开普敦） | `arn:aws:lambda:af-south-1:461844272066:layer:Synthetics_Selenium:50` |
| 亚太地区（香港） | `arn:aws:lambda:ap-east-1:129828061636:layer:Synthetics_Selenium:49` |
| 亚太地区（海得拉巴） | `arn:aws:lambda:ap-south-2:280298676434:layer:Synthetics_Selenium:37` |
| 亚太地区（雅加达） | ` arn:aws:lambda:ap-southeast-3:246953257743:layer:Synthetics_Selenium:44` |
| 亚太地区（马来西亚） | ` arn:aws:lambda:ap-southeast-5:035872523913:layer:Synthetics_Selenium:19` |
| 亚太地区（墨尔本） | ` arn:aws:lambda:ap-southeast-4:200724813040:layer:Synthetics_Selenium:35` |
| 亚太地区（孟买） | `arn:aws:lambda:ap-south-1:724929286329:layer:Synthetics_Selenium:50` |
| 亚太地区（新西兰） | ` arn:aws:lambda:ap-southeast-6:779414629109:layer:Synthetics_Selenium:25` |
| 亚太地区（大阪） | ` arn:aws:lambda:ap-northeast-3:608016332111:layer:Synthetics_Selenium:48` |
| 亚太地区（首尔） | ` arn:aws:lambda:ap-northeast-2:989515803484:layer:Synthetics_Selenium:53` |
| 亚太地区（新加坡） | ` arn:aws:lambda:ap-southeast-1:068035103298:layer:Synthetics_Selenium:54` |
| 亚太地区（悉尼） | ` arn:aws:lambda:ap-southeast-2:584677157514:layer:Synthetics_Selenium:49` |
| 亚太地区（台北） | `arn:aws:lambda:ap-east-2:471112897378:layer:Synthetics_Selenium:12` |
| 亚太地区（泰国） | ` arn:aws:lambda:ap-southeast-7:851725245975:layer:Synthetics_Selenium:10` |
| 亚太地区（东京） | ` arn:aws:lambda:ap-northeast-1:172291836251:layer:Synthetics_Selenium:50` |
| 加拿大（中部） | `arn:aws:lambda:ca-central-1:236629016841:layer:Synthetics_Selenium:50` |
| 加拿大西部（卡尔加里） | `arn:aws:lambda:ca-west-1:944448206667:layer:Synthetics_Selenium:93` |
| 中国（北京） | `arn:aws-cn:lambda:cn-north-1:422629156088:layer:Synthetics_Selenium:48` |
| 中国（宁夏） | ` arn:aws-cn:lambda:cn-northwest-1:474974519687:layer:Synthetics_Selenium:48` |
| 欧洲地区（法兰克福） | `arn:aws:lambda:eu-central-1:122305336817:layer:Synthetics_Selenium:50` |
| 欧洲地区（爱尔兰） | `arn:aws:lambda:eu-west-1:563204233543:layer:Synthetics_Selenium:51` |
| 欧洲地区（伦敦） | `arn:aws:lambda:eu-west-2:565831452869:layer:Synthetics_Selenium:49` |
| 欧洲地区（米兰） | `arn:aws:lambda:eu-south-1:525618516618:layer:Synthetics_Selenium:51` |
| 欧洲地区（巴黎） | `arn:aws:lambda:eu-west-3:469466506258:layer:Synthetics_Selenium:50` |
| 欧洲（西班牙） | `arn:aws:lambda:eu-south-2:029793053121:layer:Synthetics_Selenium:37` |
| 欧洲地区（斯德哥尔摩） | `arn:aws:lambda:eu-north-1:162938142733:layer:Synthetics_Selenium:50` |
| 欧洲（苏黎世） | `arn:aws:lambda:eu-central-2:224218992030:layer:Synthetics_Selenium:36` |
| 以色列（特拉维夫） | `arn:aws:lambda:il-central-1:313249807427:layer:Synthetics_Selenium:34` |
| 墨西哥（中部） | `arn:aws:lambda:mx-central-1:654654265476:layer:Synthetics_Selenium:11` |
| 中东（巴林） | `arn:aws:lambda:me-south-1:823195537320:layer:Synthetics_Selenium:49` |
| 中东（阿联酋）： | `arn:aws:lambda:me-central-1:239544149032:layer:Synthetics_Selenium:37` |
| 南美洲（圣保罗） | `arn:aws:lambda:sa-east-1:783765544751:layer:Synthetics_Selenium:51` |
| AWS GovCloud（美国东部） | ` arn:aws-us-gov:lambda:us-gov-east-1:946759330430:layer:Synthetics_Selenium:46` |
| AWS GovCloud（美国西部） | ` arn:aws-us-gov:lambda:us-gov-west-1:946807836238:layer:Synthetics_Selenium:47` |
#### syn-python-selenium-6.0 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-python-selenium-6.0` 版本 CloudWatch Synthetics 运行时的适用 ARN。
| 区域 | ARN |
| --- | --- |
| 美国东部（弗吉尼亚州北部） | `arn:aws:lambda:us-east-1:378653112637:layer:Synthetics_Selenium:47` |
| 美国东部（俄亥俄州） | `arn:aws:lambda:us-east-2:772927465453:layer:Synthetics_Selenium:50` |
| 美国西部（北加利福尼亚） | `arn:aws:lambda:us-west-1:332033056316:layer:Synthetics_Selenium:48` |
| 美国西部（俄勒冈州） | `arn:aws:lambda:us-west-2:760325925879:layer:Synthetics_Selenium:49` |
| 非洲（开普敦） | `arn:aws:lambda:af-south-1:461844272066:layer:Synthetics_Selenium:48` |
| 亚太地区（香港） | `arn:aws:lambda:ap-east-1:129828061636:layer:Synthetics_Selenium:47` |
| 亚太地区（海得拉巴） | `arn:aws:lambda:ap-south-2:280298676434:layer:Synthetics_Selenium:35` |
| 亚太地区（雅加达） | ` arn:aws:lambda:ap-southeast-3:246953257743:layer:Synthetics_Selenium:42` |
| 亚太地区（马来西亚） | ` arn:aws:lambda:ap-southeast-5:035872523913:layer:Synthetics_Selenium:17` |
| 亚太地区（墨尔本） | ` arn:aws:lambda:ap-southeast-4:200724813040:layer:Synthetics_Selenium:33` |
| 亚太地区（孟买） | `arn:aws:lambda:ap-south-1:724929286329:layer:Synthetics_Selenium:48` |
| 亚太地区（新西兰） | ` arn:aws:lambda:ap-southeast-6:779414629109:layer:Synthetics_Selenium:25` |
| 亚太地区（大阪） | ` arn:aws:lambda:ap-northeast-3:608016332111:layer:Synthetics_Selenium:46` |
| 亚太地区（首尔） | ` arn:aws:lambda:ap-northeast-2:989515803484:layer:Synthetics_Selenium:51` |
| 亚太地区（新加坡） | ` arn:aws:lambda:ap-southeast-1:068035103298:layer:Synthetics_Selenium:52` |
| 亚太地区（悉尼） | ` arn:aws:lambda:ap-southeast-2:584677157514:layer:Synthetics_Selenium:47` |
| 亚太地区（台北） | `arn:aws:lambda:ap-east-2:471112897378:layer:Synthetics_Selenium:10` |
| 亚太地区（泰国） | `arn:aws:lambda:ap-southeast-7:851725245975:layer:Synthetics_Selenium:8` |
| 亚太地区（东京） | ` arn:aws:lambda:ap-northeast-1:172291836251:layer:Synthetics_Selenium:48` |
| 加拿大（中部） | `arn:aws:lambda:ca-central-1:236629016841:layer:Synthetics_Selenium:48` |
| 加拿大西部（卡尔加里） | `arn:aws:lambda:ca-west-1:944448206667:layer:Synthetics_Selenium:91` |
| 中国（北京） | `arn:aws-cn:lambda:cn-north-1:422629156088:layer:Synthetics_Selenium:46` |
| 中国（宁夏） | ` arn:aws-cn:lambda:cn-northwest-1:474974519687:layer:Synthetics_Selenium:46` |
| 欧洲地区（法兰克福） | `arn:aws:lambda:eu-central-1:122305336817:layer:Synthetics_Selenium:48` |
| 欧洲地区（爱尔兰） | `arn:aws:lambda:eu-west-1:563204233543:layer:Synthetics_Selenium:49` |
| 欧洲地区（伦敦） | `arn:aws:lambda:eu-west-2:565831452869:layer:Synthetics_Selenium:47` |
| 欧洲地区（米兰） | `arn:aws:lambda:eu-south-1:525618516618:layer:Synthetics_Selenium:49` |
| 欧洲地区（巴黎） | `arn:aws:lambda:eu-west-3:469466506258:layer:Synthetics_Selenium:48` |
| 欧洲（西班牙） | `arn:aws:lambda:eu-south-2:029793053121:layer:Synthetics_Selenium:35` |
| 欧洲地区（斯德哥尔摩） | `arn:aws:lambda:eu-north-1:162938142733:layer:Synthetics_Selenium:48` |
| 欧洲（苏黎世） | `arn:aws:lambda:eu-central-2:224218992030:layer:Synthetics_Selenium:34` |
| 以色列（特拉维夫） | `arn:aws:lambda:il-central-1:313249807427:layer:Synthetics_Selenium:32` |
| 墨西哥（中部） | `arn:aws:lambda:mx-central-1:654654265476:layer:Synthetics_Selenium:9` |
| 中东（巴林） | `arn:aws:lambda:me-south-1:823195537320:layer:Synthetics_Selenium:47` |
| 中东（阿联酋）： | `arn:aws:lambda:me-central-1:239544149032:layer:Synthetics_Selenium:35` |
| 南美洲（圣保罗） | `arn:aws:lambda:sa-east-1:783765544751:layer:Synthetics_Selenium:49` |
| AWS GovCloud（美国东部） | ` arn:aws-us-gov:lambda:us-gov-east-1:946759330430:layer:Synthetics_Selenium:44` |
| AWS GovCloud（美国西部） | ` arn:aws-us-gov:lambda:us-gov-west-1:946807836238:layer:Synthetics_Selenium:45` |
#### syn-python-selenium-5.1 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-python-selenium-5.1` 版本 CloudWatch Synthetics 运行时的适用 ARN。
| 区域 | ARN |
| --- | --- |
| 美国东部（弗吉尼亚州北部） | `arn:aws:lambda:us-east-1:378653112637:layer:Synthetics_Selenium:45` |
| 美国东部（俄亥俄州） | `arn:aws:lambda:us-east-2:772927465453:layer:Synthetics_Selenium:48` |
| 美国西部（北加利福尼亚） | `arn:aws:lambda:us-west-1:332033056316:layer:Synthetics_Selenium:46` |
| 美国西部（俄勒冈州） | `arn:aws:lambda:us-west-2:760325925879:layer:Synthetics_Selenium:47` |
| 非洲（开普敦） | `arn:aws:lambda:af-south-1:461844272066:layer:Synthetics_Selenium:46` |
| 亚太地区（香港） | `arn:aws:lambda:ap-east-1:129828061636:layer:Synthetics_Selenium:45` |
| 亚太地区（海得拉巴） | `arn:aws:lambda:ap-south-2:280298676434:layer:Synthetics_Selenium:33` |
| 亚太地区（雅加达） | ` arn:aws:lambda:ap-southeast-3:246953257743:layer:Synthetics_Selenium:40` |
| 亚太地区（马来西亚） | ` arn:aws:lambda:ap-southeast-5:035872523913:layer:Synthetics_Selenium:15` |
| 亚太地区（墨尔本） | ` arn:aws:lambda:ap-southeast-4:200724813040:layer:Synthetics_Selenium:31` |
| 亚太地区（孟买） | `arn:aws:lambda:ap-south-1:724929286329:layer:Synthetics_Selenium:46` |
| 亚太地区（新西兰） | ` arn:aws:lambda:ap-southeast-6:779414629109:layer:Synthetics_Selenium:24` |
| 亚太地区（大阪） | ` arn:aws:lambda:ap-northeast-3:608016332111:layer:Synthetics_Selenium:44` |
| 亚太地区（首尔） | ` arn:aws:lambda:ap-northeast-2:989515803484:layer:Synthetics_Selenium:49` |
| 亚太地区（新加坡） | ` arn:aws:lambda:ap-southeast-1:068035103298:layer:Synthetics_Selenium:50` |
| 亚太地区（悉尼） | ` arn:aws:lambda:ap-southeast-2:584677157514:layer:Synthetics_Selenium:45` |
| 亚太地区（台北） | `arn:aws:lambda:ap-east-2:471112897378:layer:Synthetics_Selenium:8` |
| 亚太地区（泰国） | `arn:aws:lambda:ap-southeast-7:851725245975:layer:Synthetics_Selenium:6` |
| 亚太地区（东京） | ` arn:aws:lambda:ap-northeast-1:172291836251:layer:Synthetics_Selenium:46` |
| 加拿大（中部） | `arn:aws:lambda:ca-central-1:236629016841:layer:Synthetics_Selenium:44` |
| 加拿大西部（卡尔加里） | `arn:aws:lambda:ca-west-1:944448206667:layer:Synthetics_Selenium:89` |
| 中国（北京） | `arn:aws-cn:lambda:cn-north-1:422629156088:layer:Synthetics_Selenium:44` |
| 中国（宁夏）； | ` arn:aws-cn:lambda:cn-northwest-1:474974519687:layer:Synthetics_Selenium:44` |
| 欧洲地区（法兰克福） | `arn:aws:lambda:eu-central-1:122305336817:layer:Synthetics_Selenium:46` |
| 欧洲地区（爱尔兰） | `arn:aws:lambda:eu-west-1:563204233543:layer:Synthetics_Selenium:47` |
| 欧洲地区（伦敦） | `arn:aws:lambda:eu-west-2:565831452869:layer:Synthetics_Selenium:45` |
| 欧洲地区（米兰） | `arn:aws:lambda:eu-south-1:525618516618:layer:Synthetics_Selenium:47` |
| 欧洲地区（巴黎） | `arn:aws:lambda:eu-west-3:469466506258:layer:Synthetics_Selenium:46` |
| 欧洲（西班牙） | `arn:aws:lambda:eu-south-2:029793053121:layer:Synthetics_Selenium:33` |
| 欧洲地区（斯德哥尔摩） | `arn:aws:lambda:eu-north-1:162938142733:layer:Synthetics_Selenium:46` |
| 欧洲（苏黎世） | `arn:aws:lambda:eu-central-2:224218992030:layer:Synthetics_Selenium:32` |
| 以色列（特拉维夫） | `arn:aws:lambda:il-central-1:313249807427:layer:Synthetics_Selenium:30` |
| 墨西哥（中部） | `arn:aws:lambda:mx-central-1:654654265476:layer:Synthetics_Selenium:7` |
| 中东（巴林） | `arn:aws:lambda:me-south-1:823195537320:layer:Synthetics_Selenium:45` |
| 中东（阿联酋）： | `arn:aws:lambda:me-central-1:239544149032:layer:Synthetics_Selenium:33` |
| 南美洲（圣保罗） | `arn:aws:lambda:sa-east-1:783765544751:layer:Synthetics_Selenium:47` |
| AWS GovCloud（美国东部） | ` arn:aws-us-gov:lambda:us-gov-east-1:946759330430:layer:Synthetics_Selenium:42` |
| AWS GovCloud（美国西部） | ` arn:aws-us-gov:lambda:us-gov-west-1:946807836238:layer:Synthetics_Selenium:43` |
#### syn-python-selenium-5.0 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-python-selenium-5.0` 版本 CloudWatch Synthetics 运行时的适用 ARN。
| 区域 | ARN |
| --- | --- |
| 美国东部（弗吉尼亚州北部） | `arn:aws:lambda:us-east-1:378653112637:layer:Synthetics_Selenium:43` |
| 美国东部（俄亥俄州） | `arn:aws:lambda:us-east-2:772927465453:layer:Synthetics_Selenium:46` |
| 美国西部（北加利福尼亚） | `arn:aws:lambda:us-west-1:332033056316:layer:Synthetics_Selenium:44` |
| 美国西部（俄勒冈州） | `arn:aws:lambda:us-west-2:760325925879:layer:Synthetics_Selenium:45` |
| 非洲（开普敦） | `arn:aws:lambda:af-south-1:461844272066:layer:Synthetics_Selenium:44` |
| 亚太地区（香港） | `arn:aws:lambda:ap-east-1:129828061636:layer:Synthetics_Selenium:43` |
| 亚太地区（海得拉巴） | `arn:aws:lambda:ap-south-2:280298676434:layer:Synthetics_Selenium:31` |
| 亚太地区（雅加达） | ` arn:aws:lambda:ap-southeast-3:246953257743:layer:Synthetics_Selenium:38` |
| 亚太地区（马来西亚） | ` arn:aws:lambda:ap-southeast-5:035872523913:layer:Synthetics_Selenium:13` |
| 亚太地区（墨尔本） | ` arn:aws:lambda:ap-southeast-4:200724813040:layer:Synthetics_Selenium:29` |
| 亚太地区（孟买） | `arn:aws:lambda:ap-south-1:724929286329:layer:Synthetics_Selenium:44` |
| 亚太地区（新西兰） | ` arn:aws:lambda:ap-southeast-6:779414629109:layer:Synthetics_Selenium:23` |
| 亚太地区（大阪） | ` arn:aws:lambda:ap-northeast-3:608016332111:layer:Synthetics_Selenium:42` |
| 亚太地区（首尔） | ` arn:aws:lambda:ap-northeast-2:989515803484:layer:Synthetics_Selenium:47` |
| 亚太地区（新加坡） | ` arn:aws:lambda:ap-southeast-1:068035103298:layer:Synthetics_Selenium:48` |
| 亚太地区（悉尼） | ` arn:aws:lambda:ap-southeast-2:584677157514:layer:Synthetics_Selenium:43` |
| 亚太地区（台北） | `arn:aws:lambda:ap-east-2:471112897378:layer:Synthetics_Selenium:3` |
| 亚太地区（泰国） | `arn:aws:lambda:ap-southeast-7:851725245975:layer:Synthetics_Selenium:4` |
| 亚太地区（东京） | ` arn:aws:lambda:ap-northeast-1:172291836251:layer:Synthetics_Selenium:44` |
| 加拿大（中部） | `arn:aws:lambda:ca-central-1:236629016841:layer:Synthetics_Selenium:44` |
| 加拿大西部（卡尔加里） | `arn:aws:lambda:ca-west-1:944448206667:layer:Synthetics_Selenium:87` |
| 中国（北京） | `arn:aws-cn:lambda:cn-north-1:422629156088:layer:Synthetics_Selenium:43` |
| 中国（宁夏）； | ` arn:aws-cn:lambda:cn-northwest-1:474974519687:layer:Synthetics_Selenium:43` |
| 欧洲地区（法兰克福） | `arn:aws:lambda:eu-central-1:122305336817:layer:Synthetics_Selenium:44` |
| 欧洲地区（爱尔兰） | `arn:aws:lambda:eu-west-1:563204233543:layer:Synthetics_Selenium:45` |
| 欧洲地区（伦敦） | `arn:aws:lambda:eu-west-2:565831452869:layer:Synthetics_Selenium:43` |
| 欧洲地区（米兰） | `arn:aws:lambda:eu-south-1:525618516618:layer:Synthetics_Selenium:45` |
| 欧洲地区（巴黎） | `arn:aws:lambda:eu-west-3:469466506258:layer:Synthetics_Selenium:44` |
| 欧洲（西班牙） | `arn:aws:lambda:eu-south-2:029793053121:layer:Synthetics_Selenium:31` |
| 欧洲地区（斯德哥尔摩） | `arn:aws:lambda:eu-north-1:162938142733:layer:Synthetics_Selenium:44` |
| 欧洲（苏黎世） | `arn:aws:lambda:eu-central-2:224218992030:layer:Synthetics_Selenium:30` |
| 以色列（特拉维夫） | `arn:aws:lambda:il-central-1:313249807427:layer:Synthetics_Selenium:28` |
| 墨西哥（中部） | `arn:aws:lambda:mx-central-1:654654265476:layer:Synthetics_Selenium:5` |
| 中东（巴林） | `arn:aws:lambda:me-south-1:823195537320:layer:Synthetics_Selenium:43` |
| 中东（阿联酋）： | `arn:aws:lambda:me-central-1:239544149032:layer:Synthetics_Selenium:31` |
| 南美洲（圣保罗） | `arn:aws:lambda:sa-east-1:783765544751:layer:Synthetics_Selenium:45` |
| AWS GovCloud（美国东部） | ` arn:aws-us-gov:lambda:us-gov-east-1:946759330430:layer:Synthetics_Selenium:41` |
| AWS GovCloud（美国西部） | ` arn:aws-us-gov:lambda:us-gov-west-1:946807836238:layer:Synthetics_Selenium:42` |
#### syn-python-selenium-4.1 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-python-selenium-4.1` 版本 CloudWatch Synthetics 运行时的适用 ARN。
| 区域 | ARN |
| --- | --- |
| 美国东部（弗吉尼亚州北部） | `arn:aws:lambda:us-east-1:378653112637:layer:Synthetics_Selenium:40` |
| 美国东部（俄亥俄州） | `arn:aws:lambda:us-east-2:772927465453:layer:Synthetics_Selenium:43` |
| 美国西部（北加利福尼亚） | `arn:aws:lambda:us-west-1:332033056316:layer:Synthetics_Selenium:41` |
| 美国西部（俄勒冈州） | `arn:aws:lambda:us-west-2:760325925879:layer:Synthetics_Selenium:42` |
| 非洲（开普敦） | `arn:aws:lambda:af-south-1:461844272066:layer:Synthetics_Selenium:41` |
| 亚太地区（香港） | `arn:aws:lambda:ap-east-1:129828061636:layer:Synthetics_Selenium:40` |
| 亚太地区（海得拉巴） | `arn:aws:lambda:ap-south-2:280298676434:layer:Synthetics_Selenium:28` |
| 亚太地区（雅加达） | ` arn:aws:lambda:ap-southeast-3:246953257743:layer:Synthetics_Selenium:35` |
| 亚太地区（马来西亚） | ` arn:aws:lambda:ap-southeast-5:035872523913:layer:Synthetics_Selenium:10` |
| 亚太地区（墨尔本） | ` arn:aws:lambda:ap-southeast-4:200724813040:layer:Synthetics_Selenium:26` |
| 亚太地区（孟买） | `arn:aws:lambda:ap-south-1:724929286329:layer:Synthetics_Selenium:41` |
| 亚太地区（新西兰） | ` arn:aws:lambda:ap-southeast-6:779414629109:layer:Synthetics_Selenium:22` |
| 亚太地区（大阪） | ` arn:aws:lambda:ap-northeast-3:608016332111:layer:Synthetics_Selenium:39` |
| 亚太地区（首尔） | ` arn:aws:lambda:ap-northeast-2:989515803484:layer:Synthetics_Selenium:44` |
| 亚太地区（新加坡） | ` arn:aws:lambda:ap-southeast-1:068035103298:layer:Synthetics_Selenium:45` |
| 亚太地区（悉尼） | ` arn:aws:lambda:ap-southeast-2:584677157514:layer:Synthetics_Selenium:40` |
| 亚太地区（台北） | `arn:aws:lambda:ap-east-2:471112897378:layer:Synthetics_Selenium:4` |
| 亚太地区（泰国） | `arn:aws:lambda:ap-southeast-7:851725245975:layer:Synthetics_Selenium:1` |
| 亚太地区（东京） | ` arn:aws:lambda:ap-northeast-1:172291836251:layer:Synthetics_Selenium:41` |
| 加拿大（中部） | `arn:aws:lambda:ca-central-1:236629016841:layer:Synthetics_Selenium:41` |
| 加拿大西部（卡尔加里） | `arn:aws:lambda:ca-west-1:944448206667:layer:Synthetics_Selenium:84` |
| 中国（北京） | `arn:aws-cn:lambda:cn-north-1:422629156088:layer:Synthetics_Selenium:40` |
| 中国（宁夏）； | ` arn:aws-cn:lambda:cn-northwest-1:474974519687:layer:Synthetics_Selenium:40` |
| 欧洲地区（法兰克福） | `arn:aws:lambda:eu-central-1:122305336817:layer:Synthetics_Selenium:41` |
| 欧洲地区（爱尔兰） | `arn:aws:lambda:eu-west-1:563204233543:layer:Synthetics_Selenium:42` |
| 欧洲地区（伦敦） | `arn:aws:lambda:eu-west-2:565831452869:layer:Synthetics_Selenium:40` |
| 欧洲地区（米兰） | `arn:aws:lambda:eu-south-1:525618516618:layer:Synthetics_Selenium:42` |
| 欧洲地区（巴黎） | `arn:aws:lambda:eu-west-3:469466506258:layer:Synthetics_Selenium:41` |
| 欧洲（西班牙） | `arn:aws:lambda:eu-south-2:029793053121:layer:Synthetics_Selenium:28` |
| 欧洲地区（斯德哥尔摩） | `arn:aws:lambda:eu-north-1:162938142733:layer:Synthetics_Selenium:41` |
| 欧洲（苏黎世） | `arn:aws:lambda:eu-central-2:224218992030:layer:Synthetics_Selenium:27` |
| 以色列（特拉维夫） | `arn:aws:lambda:il-central-1:313249807427:layer:Synthetics_Selenium:25` |
| 墨西哥（中部） | `arn:aws:lambda:mx-central-1:654654265476:layer:Synthetics_Selenium:3` |
| 中东（巴林） | `arn:aws:lambda:me-south-1:823195537320:layer:Synthetics_Selenium:40` |
| 中东（阿联酋）： | `arn:aws:lambda:me-central-1:239544149032:layer:Synthetics_Selenium:28` |
| 南美洲（圣保罗） | `arn:aws:lambda:sa-east-1:783765544751:layer:Synthetics_Selenium:42` |
| AWS GovCloud（美国东部） | ` arn:aws-us-gov:lambda:us-gov-east-1:946759330430:layer:Synthetics_Selenium:38` |
| AWS GovCloud（美国西部） | ` arn:aws-us-gov:lambda:us-gov-west-1:946807836238:layer:Synthetics_Selenium:39` |
#### syn-python-selenium-4.0 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-python-selenium-4.0` 版本 CloudWatch Synthetics 运行时的适用 ARN。
| 区域 | ARN |
| --- | --- |
| 美国东部（弗吉尼亚州北部） | `arn:aws:lambda:us-east-1:378653112637:layer:Synthetics_Selenium:38` |
| 美国东部（俄亥俄州） | `arn:aws:lambda:us-east-2:772927465453:layer:Synthetics_Selenium:41` |
| 美国西部（北加利福尼亚） | `arn:aws:lambda:us-west-1:332033056316:layer:Synthetics_Selenium:39` |
| 美国西部（俄勒冈州） | `arn:aws:lambda:us-west-2:760325925879:layer:Synthetics_Selenium:40` |
| 非洲（开普敦） | `arn:aws:lambda:af-south-1:461844272066:layer:Synthetics_Selenium:39` |
| 亚太地区（香港） | `arn:aws:lambda:ap-east-1:129828061636:layer:Synthetics_Selenium:38` |
| 亚太地区（海得拉巴） | `arn:aws:lambda:ap-south-2:280298676434:layer:Synthetics_Selenium:26` |
| 亚太地区（雅加达） | ` arn:aws:lambda:ap-southeast-3:246953257743:layer:Synthetics_Selenium:33` |
| 亚太地区（马来西亚） | `arn:aws:lambda:ap-southeast-5:035872523913:layer:Synthetics_Selenium:8` |
| 亚太地区（墨尔本） | ` arn:aws:lambda:ap-southeast-4:200724813040:layer:Synthetics_Selenium:24` |
| 亚太地区（孟买） | `arn:aws:lambda:ap-south-1:724929286329:layer:Synthetics_Selenium:39` |
| 亚太地区（新西兰） | ` arn:aws:lambda:ap-southeast-6:779414629109:layer:Synthetics_Selenium:21` |
| 亚太地区（大阪） | ` arn:aws:lambda:ap-northeast-3:608016332111:layer:Synthetics_Selenium:37` |
| 亚太地区（首尔） | ` arn:aws:lambda:ap-northeast-2:989515803484:layer:Synthetics_Selenium:42` |
| 亚太地区（新加坡） | ` arn:aws:lambda:ap-southeast-1:068035103298:layer:Synthetics_Selenium:43` |
| 亚太地区（悉尼） | ` arn:aws:lambda:ap-southeast-2:584677157514:layer:Synthetics_Selenium:38` |
| 亚太地区（台北） | `arn:aws:lambda:ap-east-2:471112897378:layer:Synthetics_Selenium:5` |
| 亚太地区（东京） | ` arn:aws:lambda:ap-northeast-1:172291836251:layer:Synthetics_Selenium:39` |
| 加拿大（中部） | `arn:aws:lambda:ca-central-1:236629016841:layer:Synthetics_Selenium:39` |
| 加拿大西部（卡尔加里） | `arn:aws:lambda:ca-west-1:944448206667:layer:Synthetics_Selenium:82` |
| 中国（北京） | `arn:aws-cn:lambda:cn-north-1:422629156088:layer:Synthetics_Selenium:38` |
| 中国（宁夏）； | ` arn:aws-cn:lambda:cn-northwest-1:474974519687:layer:Synthetics_Selenium:38` |
| 欧洲地区（法兰克福） | `arn:aws:lambda:eu-central-1:122305336817:layer:Synthetics_Selenium:39` |
| 欧洲地区（爱尔兰） | `arn:aws:lambda:eu-west-1:563204233543:layer:Synthetics_Selenium:40` |
| 欧洲地区（伦敦） | `arn:aws:lambda:eu-west-2:565831452869:layer:Synthetics_Selenium:38` |
| 欧洲地区（米兰） | `arn:aws:lambda:eu-south-1:525618516618:layer:Synthetics_Selenium:40` |
| 欧洲地区（巴黎） | `arn:aws:lambda:eu-west-3:469466506258:layer:Synthetics_Selenium:39` |
| 欧洲（西班牙） | `arn:aws:lambda:eu-south-2:029793053121:layer:Synthetics_Selenium:26` |
| 欧洲地区（斯德哥尔摩） | `arn:aws:lambda:eu-north-1:162938142733:layer:Synthetics_Selenium:39` |
| 欧洲（苏黎世） | `arn:aws:lambda:eu-central-2:224218992030:layer:Synthetics_Selenium:25` |
| 以色列（特拉维夫） | `arn:aws:lambda:il-central-1:313249807427:layer:Synthetics_Selenium:23` |
| 中东（巴林） | `arn:aws:lambda:me-south-1:823195537320:layer:Synthetics_Selenium:38` |
| 中东（阿联酋）： | `arn:aws:lambda:me-central-1:239544149032:layer:Synthetics_Selenium:26` |
| 南美洲（圣保罗） | `arn:aws:lambda:sa-east-1:783765544751:layer:Synthetics_Selenium:40` |
| AWS GovCloud（美国东部） | ` arn:aws-us-gov:lambda:us-gov-east-1:946759330430:layer:Synthetics_Selenium:36` |
| AWS GovCloud（美国西部） | ` arn:aws-us-gov:lambda:us-gov-west-1:946807836238:layer:Synthetics_Selenium:37` |
#### syn-python-selenium-3.0 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-python-selenium-3.0` 版本 CloudWatch Synthetics 运行时的适用 ARN。
| 区域 | ARN |
| --- | --- |
| 美国东部（弗吉尼亚州北部） | `arn:aws:lambda:us-east-1:378653112637:layer:Synthetics_Selenium:32` |
| 美国东部（俄亥俄州） | `arn:aws:lambda:us-east-2:772927465453:layer:Synthetics_Selenium:34` |
| 美国西部（北加利福尼亚） | `arn:aws:lambda:us-west-1:332033056316:layer:Synthetics_Selenium:32` |
| 美国西部（俄勒冈州） | `arn:aws:lambda:us-west-2:760325925879:layer:Synthetics_Selenium:34` |
| 非洲（开普敦） | `arn:aws:lambda:af-south-1:461844272066:layer:Synthetics_Selenium:32` |
| 亚太地区（香港） | `arn:aws:lambda:ap-east-1:129828061636:layer:Synthetics_Selenium:32` |
| 亚太地区（海得拉巴） | `arn:aws:lambda:ap-south-2:280298676434:layer:Synthetics_Selenium:20` |
| 亚太地区（雅加达） | ` arn:aws:lambda:ap-southeast-3:246953257743:layer:Synthetics_Selenium:26` |
| 亚太地区（马来西亚） | `arn:aws:lambda:ap-southeast-5:035872523913:layer:Synthetics_Selenium:7` |
| 亚太地区（墨尔本） | ` arn:aws:lambda:ap-southeast-4:200724813040:layer:Synthetics_Selenium:18` |
| 亚太地区（孟买） | `arn:aws:lambda:ap-south-1:724929286329:layer:Synthetics_Selenium:32` |
| 亚太地区（大阪） | ` arn:aws:lambda:ap-northeast-3:608016332111:layer:Synthetics_Selenium:30` |
| 亚太地区（首尔） | ` arn:aws:lambda:ap-northeast-2:989515803484:layer:Synthetics_Selenium:34` |
| 亚太地区（新加坡） | ` arn:aws:lambda:ap-southeast-1:068035103298:layer:Synthetics_Selenium:37` |
| 亚太地区（悉尼） | ` arn:aws:lambda:ap-southeast-2:584677157514:layer:Synthetics_Selenium:32` |
| 亚太地区（泰国） | `arn:aws:lambda:ap-southeast-7:851725245975:layer:Synthetics_Selenium:3` |
| 亚太地区（东京） | ` arn:aws:lambda:ap-northeast-1:172291836251:layer:Synthetics_Selenium:32` |
| 加拿大（中部） | `arn:aws:lambda:ca-central-1:236629016841:layer:Synthetics_Selenium:32` |
| 加拿大西部（卡尔加里） | `arn:aws:lambda:ca-west-1:944448206667:layer:Synthetics_Selenium:76` |
| 中国（北京） | `arn:aws-cn:lambda:cn-north-1:422629156088:layer:Synthetics_Selenium:32` |
| 中国（宁夏）； | ` arn:aws-cn:lambda:cn-northwest-1:474974519687:layer:Synthetics_Selenium:32` |
| 欧洲地区（法兰克福） | `arn:aws:lambda:eu-central-1:122305336817:layer:Synthetics_Selenium:32` |
| 欧洲地区（爱尔兰） | `arn:aws:lambda:eu-west-1:563204233543:layer:Synthetics_Selenium:34` |
| 欧洲地区（伦敦） | `arn:aws:lambda:eu-west-2:565831452869:layer:Synthetics_Selenium:32` |
| 欧洲地区（米兰） | `arn:aws:lambda:eu-south-1:525618516618:layer:Synthetics_Selenium:33` |
| 欧洲地区（巴黎） | `arn:aws:lambda:eu-west-3:469466506258:layer:Synthetics_Selenium:32` |
| 欧洲（西班牙） | `arn:aws:lambda:eu-south-2:029793053121:layer:Synthetics_Selenium:20` |
| 欧洲地区（斯德哥尔摩） | `arn:aws:lambda:eu-north-1:162938142733:layer:Synthetics_Selenium:32` |
| 欧洲（苏黎世） | `arn:aws:lambda:eu-central-2:224218992030:layer:Synthetics_Selenium:19` |
| 以色列（特拉维夫） | `arn:aws:lambda:il-central-1:313249807427:layer:Synthetics_Selenium:17` |
| 墨西哥（中部） | `arn:aws:lambda:mx-central-1:654654265476:layer:Synthetics_Selenium:4` |
| 中东（巴林） | `arn:aws:lambda:me-south-1:823195537320:layer:Synthetics_Selenium:32` |
| 中东（阿联酋）： | `arn:aws:lambda:me-central-1:239544149032:layer:Synthetics_Selenium:19` |
| 南美洲（圣保罗） | `arn:aws:lambda:sa-east-1:783765544751:layer:Synthetics_Selenium:33` |
| AWS GovCloud（美国东部） | ` arn:aws-us-gov:lambda:us-gov-east-1:946759330430:layer:Synthetics_Selenium:30` |
| AWS GovCloud（美国西部） | ` arn:aws-us-gov:lambda:us-gov-west-1:946807836238:layer:Synthetics_Selenium:31` |
#### syn-python-selenium-2.1 的 ARN
下表列出了要在各个 AWS 区域中用于 ` syn-python-selenium-2.1` 版本 CloudWatch Synthetics 运行时的适用 ARN。
| 区域 | ARN |
| --- | --- |
| 美国东部（弗吉尼亚州北部） | `arn:aws:lambda:us-east-1:378653112637:layer:Synthetics:29` |
| 美国东部（俄亥俄州） | `arn:aws:lambda:us-east-2:772927465453:layer:Synthetics:31` |
| 美国西部（北加利福尼亚） | `arn:aws:lambda:us-west-1:332033056316:layer:Synthetics:29` |
| 美国西部（俄勒冈州） | `arn:aws:lambda:us-west-2:760325925879:layer:Synthetics:31` |
| 非洲（开普敦） | `arn:aws:lambda:af-south-1:461844272066:layer:Synthetics:29` |
| 亚太地区（香港） | `arn:aws:lambda:ap-east-1:129828061636:layer:Synthetics:29` |
| 亚太地区（海得拉巴） | `arn:aws:lambda:ap-south-2:280298676434:layer:Synthetics:17` |
| 亚太地区（雅加达） | `arn:aws:lambda:ap-southeast-3:246953257743:layer:Synthetics:23` |
| 亚太地区（墨尔本） | `arn:aws:lambda:ap-southeast-4:200724813040:layer:Synthetics:15` |
| 亚太地区（孟买） | `arn:aws:lambda:ap-south-1:724929286329:layer:Synthetics:29` |
| 亚太地区（大阪） | `arn:aws:lambda:ap-northeast-3:608016332111:layer:Synthetics:27` |
| 亚太地区（首尔） | `arn:aws:lambda:ap-northeast-2:989515803484:layer:Synthetics:30` |
| 亚太地区（新加坡） | `arn:aws:lambda:ap-southeast-1:068035103298:layer:Synthetics:34` |
| 亚太地区（悉尼） | `arn:aws:lambda:ap-southeast-2:584677157514:layer:Synthetics:29` |
| 亚太地区（东京） | `arn:aws:lambda:ap-northeast-1:172291836251:layer:Synthetics:29` |
| 加拿大（中部） | `arn:aws:lambda:ca-central-1:236629016841:layer:Synthetics:29` |
| 加拿大西部（卡尔加里） | `arn:aws:lambda:ca-west-1:944448206667:layer:Synthetics:73` |
| 中国（北京） | `arn:aws-cn:lambda:cn-north-1:422629156088:layer:Synthetics:29` |
| 中国（宁夏）； | `arn:aws-cn:lambda:cn-northwest-1:474974519687:layer:Synthetics:29` |
| 欧洲地区（法兰克福） | `arn:aws:lambda:eu-central-1:122305336817:layer:Synthetics:29` |
| 欧洲地区（爱尔兰） | `arn:aws:lambda:eu-west-1:563204233543:layer:Synthetics:31` |
| 欧洲地区（伦敦） | `arn:aws:lambda:eu-west-2:565831452869:layer:Synthetics:29` |
| 欧洲地区（米兰） | `arn:aws:lambda:eu-south-1:525618516618:layer:Synthetics:30` |
| 欧洲地区（巴黎） | `arn:aws:lambda:eu-west-3:469466506258:layer:Synthetics:29` |
| 欧洲（西班牙） | `arn:aws:lambda:eu-south-2:029793053121:layer:Synthetics:17` |
| 欧洲地区（斯德哥尔摩） | `arn:aws:lambda:eu-north-1:162938142733:layer:Synthetics:29` |
| 欧洲（苏黎世） | `arn:aws:lambda:eu-central-2:224218992030:layer:Synthetics:16` |
| 以色列（特拉维夫） | `arn:aws:lambda:il-central-1:313249807427:layer:Synthetics:14` |
| 中东（巴林） | `arn:aws:lambda:me-south-1:823195537320:layer:Synthetics:29` |
| 中东（阿联酋）： | `arn:aws:lambda:me-central-1:239544149032:layer:Synthetics:16` |
| 南美洲（圣保罗） | `arn:aws:lambda:sa-east-1:783765544751:layer:Synthetics:30` |
| AWS GovCloud（美国东部） | `arn:aws-us-gov:lambda:us-gov-east-1:946759330430:layer:Synthetics:29` |
| AWS GovCloud（美国西部） | `arn:aws-us-gov:lambda:us-gov-west-1:946807836238:layer:Synthetics:29` |
## 常见错误
**错误：在本地运行 AWS SAM 项目需要 Docker。您是否已安装并正在运行它？**
请务必在计算机上启动 Docker。
**SAM 本地调用失败：调用 GetLayerVersion 操作时发生错误（ExpiredTokenException）：请求中包含的安全令牌已过期**
确保已设置 AWS 默认配置文件。
**更常见的错误**
有关 SAM 常见错误的更多信息，请参阅 [AWS SAM CLI 故障排除](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-troubleshooting.html)。
# 排查失败金丝雀的问题
如果您的金丝雀失败，请检查以下内容以排查问题。
**一般故障排除**
+ 使用金丝雀详细信息页面查找更多信息。在 CloudWatch 控制台中，选择导航窗格中的**金丝雀**，然后选择金丝雀的名称以打开金丝雀详细信息页面。在**可用性**选项卡上，选中 **SuccessPercent** 指标以查看问题是经常性问题还是间歇性问题。
仍在 **Availability（可用性）**选项卡上时，选择失败的数据点以查看该失败运行的屏幕截图、日志和步骤报告（如可用）。
如果步骤报告可用（因为步骤是脚本的一部分），请检查以查明失败的步骤，并查看相关屏幕截图以查看客户看到的问题。
您还可以检查 HAR 文件以了解是否有一个或多个请求失败。您可以使用日志对失败的请求和错误进行深入分析。最后，您可以将这些构件与成功金丝雀运行中的构件进行比较，以查明问题。
预设情况下，CloudWatch Synthetics 会捕获 UI 金丝雀中每个步骤的屏幕截图。但您的脚本可能会配置为禁用屏幕截图。在调试期间，您可能希望再次启用屏幕截图。同样，对于 API 金丝雀，您可能希望在调试过程中查看 HTTP 请求和响应标头和响应体。有关如何将此数据包括在报告中，请参阅 [executeHttpStep(stepName, requestOptions, [callback], [stepConfig])](CloudWatch_Synthetics_Canaries_Library_Nodejs.md#CloudWatch_Synthetics_Library_executeHttpStep)。
+ 如果您最近对应用程序做出了部署，请执行回滚操作，然后稍后进行调试。
+ 手动连接到端点，看看是否会重现相同问题。
**Topics**
+ [金丝雀在 Lambda 环境更新后发生故障](#Troubleshoot_upgradeLambda)
+ [我的金丝雀被 AWS WAF 阻止了](#Canary_Blocked_WAF)
+ [等待元素出现](#CloudWatch_Synthetics_Canaries_Troubleshoot_waiting)
+ [节点不可见或不是用于 page.click() 的 HTMLElement](#CloudWatch_Synthetics_Canaries_Troubleshoot_notvisible)
+ [无法将构件上载到 S3，“异常：无法获取 S3 存储桶位置：访问被拒绝”](#CloudWatch_Synthetics_Canaries_Troubleshoot_noupload)
+ [“错误：协议错误 (Runtime.callFunctionOn)：目标已关闭。”](#CloudWatch_Synthetics_Canaries_Troubleshoot_protocolError)
+ [“金丝雀失败。错误：无数据点 – 金丝雀显示超时”错误](#CloudWatch_Synthetics_Canaries_Troubleshoot_nodatapoint)
+ [尝试访问内部端点](#CloudWatch_Synthetics_Canaries_Troubleshoot_internalendpoint)
+ [金丝雀运行时版本升级和降级问题](#CloudWatch_Synthetics_Canaries_Troubleshoot_upgradeissues)
+ [跨域请求共享 (CORS) 问题](#CloudWatch_Synthetics_Canaries_CORS)
+ [金丝雀争用情况问题](#CloudWatch_Synthetics_Canaries_RaceCondition)
+ [排查 VPC 上金丝雀的问题](#CloudWatch_Synthetics_Canaries_VPC_troubleshoot)
+ [对自动重试金丝雀进行问题排查](#CloudWatch_Synthetics_Canaries_autoretry)
## 金丝雀在 Lambda 环境更新后发生故障
CloudWatch Synthetics 金丝雀在您的账户中作为 Lambda 函数实施。这些 Lambda 函数需要定期更新 Lambda 运行时系统，其中包括安全更新、错误修复和其他改进。Lambda 致力于提供与现有函数向后兼容的运行时系统更新。但是，与软件修补一样，在极少数情况下，运行时更新会对现有函数产生负面影响。如果您认为自己的金丝雀受到 Lambda 运行时系统更新的影响，则可以使用 Lambda 运行时系统管理手动模式（在支持的区域中）来临时回滚 Lambda 运行时系统版本。这样，可以使金丝雀函数保持正常运行并最大限度地减少中断，从而在返回到最新的运行时系统版本之前有时间解决不兼容问题。
如果您的金丝雀在 Lambda 运行时系统更新后出现故障，最好的解决方案是升级到最新的 Synthetics 运行时系统之一。有关最新运行时系统的更多信息，请参阅 [Synthetics 运行时版本](CloudWatch_Synthetics_Canaries_Library.md)。
作为替代解决方案，在提供 Lambda 运行时系统管理控件的区域中，您可以使用手动模式进行运行时系统管理控制，将金丝雀恢复到较旧的 Lambda 托管运行时系统。您可以按照以下各部分中的以下步骤使用 AWS CLI 或通过 Lambda 控制台设置手动模式。
**警告**
当您将运行时系统设置更改为手动模式时，您的 Lambda 函数在恢复到自动模式之前不会收到自动安全更新。在此期间，您的 Lambda 函数可能容易受到安全漏洞的影响。
**先决条件**
+ 安装 [jq](https://jqlang.github.io/jq/)
+ 安装最新版本的 AWS CLI。有关更多信息，请参阅 [AWS CLI 安装和更新说明](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html#getting-started-install-instructions)。
### 步骤 1：获取 Lambda 函数 ARN
运行以下命令，以从响应中检索 `EngineArn` 字段。此 `EngineArn` 是与金丝雀关联的 Lambda 函数的 ARN。您将在以下步骤中使用此 ARN。
```
aws synthetics get-canary --name my-canary | jq '.Canary.EngineArn'
```
`EngingArn` 的示例输出：
```
"arn:aws:lambda:us-west-2:123456789012:function:cwsyn-my-canary-dc5015c2-db17-4cb5-afb1-EXAMPLE991:8"
```
### 步骤 2：获取最后一个良好的 Lambda 运行时系统版本 ARN
为了帮助了解您的金丝雀是否受到 Lambda 运行时系统更新的影响，请检查日志中 Lambda 运行时系统版本 ARN 更改的日期和时间是否与您看到金丝雀受到影响的日期和时间一致。如果两者不匹配，则可能不是 Lambda 运行时系统更新导致您的问题。
如果您的金丝雀受到 Lambda 运行时系统更新的影响，则必须识别之前正在使用的有效 Lambda 运行时系统版本的 ARN。按照[识别运行时系统版本更改](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-update.html#runtime-management-identify.html)中的说明查找先前的运行时系统的 ARN。记录运行时系统版本 ARN，然后继续执行步骤 3，以设置运行时系统管理配置。
如果您的金丝雀尚未受到 Lambda 环境更新的影响，则可以查找您当前正在使用的 Lambda 运行时系统版本的 ARN。运行以下命令，以从响应中检索 Lambda 函数的 `RuntimeVersionArn`。
```
aws lambda get-function-configuration \
--function-name "arn:aws:lambda:us-west-2:123456789012:function:cwsyn-my-canary-dc5015c2-db17-4cb5-afb1-EXAMPLE991:8" | jq '.RuntimeVersionConfig.RuntimeVersionArn'
```
`RuntimeVersionArn` 的示例输出：
```
"arn:aws:lambda:us-west-2::runtime:EXAMPLE647b82f490a45d7ddd96b557b916a30128d9dcab5f4972911ec0f"
```
### 步骤 3：更新 Lambda 运行时系统管理配置
您可以使用 AWS CLI 或 Lambda 控制台来更新运行时系统管理配置。
**要设置 Lambda 运行时系统管理配置手动模式，请使用 AWS CLI**
输入以下命令，以将 Lambda 函数的运行时系统管理更改为手动模式。请务必使用您在步骤 1 中找到的值，将 *function-name* 和 *qualifier* 分别替换为 Lambda 函数 ARN 和 Lambda 函数版本号。另外，将 *runtime-version-arn* 替换为您在步骤 2 中找到的版本 ARN。
```
aws lambda put-runtime-management-config \
--function-name "arn:aws:lambda:us-west-2:123456789012:function:cwsyn-my-canary-dc5015c2-db17-4cb5-afb1-EXAMPLE991" \
--qualifier 8 \
--update-runtime-on "Manual" \
--runtime-version-arn "arn:aws:lambda:us-west-2::runtime:a993d90ea43647b82f490a45d7ddd96b557b916a30128d9dcab5f4972911ec0f"
```
**要使用 Lambda 控制台将金丝雀更改为手动模式**
1. 通过 [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/) 打开 AWS Lambda 控制台。
1. 选择**版本**选项卡，选择与您的 ARN 对应的版本号链接，然后选择**代码**选项卡。
1. 向下滚动到**运行时系统设置**，展开**运行时系统管理配置**，然后复制**运行时系统版本 ARN**。
![\[显示屏幕的运行时设置部分，并显示运行时版本 ARN 在此部分中的显示位置。\]](http://docs.aws.amazon.com/zh_cn/AmazonCloudWatch/latest/monitoring/images/SyntheticsManual1.png)
1. 选择**编辑运行时管理配置**，选择**手动**，将之前复制的运行时版本 ARN 粘贴到**运行时版本 ARN** 字段中。然后选择**保存**。
![\[显示运行时管理配置屏幕，并显示要将之前复制的运行时版本 ARN 粘贴到其中的位置。\]](http://docs.aws.amazon.com/zh_cn/AmazonCloudWatch/latest/monitoring/images/SyntheticsManual2.png)
## 我的金丝雀被 AWS WAF 阻止了
要允许金丝雀流量通过 AWS WAF，请创建一个 AWS WAF 字符串匹配条件，该条件允许您指定的自定义字符串。有关更多信息，请参阅 AWS WAF 文档中的[使用字符串匹配条件](https://docs.aws.amazon.com/waf/latest/developerguide/classic-web-acl-string-conditions.html)。
强烈建议您使用自己的自定义用户代理字符串，而不是使用默认值。这可以更好地控制 AWS WAF 筛选并提高安全性。
要设置自定义用户代理字符串，请执行以下操作：
+ 对于 Playwright 运行时，您可以使用 Synthetics 配置文件附加 AWS WAF 批准的自定义用户代理字符串。有关更多信息，请参阅 [CloudWatch Synthetics 配置](Synthetics_WritingCanary_Nodejs_Playwright.md#Synthetics_canary_configure_Playwright_script)。
+ 对于 Puppeteer 或 Selenium 运行时，您可以使用支持的库函数添加自定义用户代理字符串。有关 Puppeteer 运行时，请参阅 [async addUserAgent(page, userAgentString);](CloudWatch_Synthetics_Canaries_Library_Nodejs.md#CloudWatch_Synthetics_Library_addUserAgent)。有关 Selenium 运行时，请参阅 [add\$1user\$1agent(user\$1agent\$1str)](CloudWatch_Synthetics_Canaries_Library_Python.md#CloudWatch_Synthetics_Library_add_user_agent)。
## 等待元素出现
分析日志和屏幕截图后，如果您发现脚本正在等待某个元素出现在屏幕上并超时，请检查相关的屏幕截图以查看该元素是否出现在页面上。验证 `xpath` 以确保该元素的准确性。
对于与 Puppeteer 相关的问题，请参阅 [Puppeteer 的 GitHub 页面](https://github.com/puppeteer/puppeteer/issues)或 Internet 论坛。
## 节点不可见或不是用于 page.click() 的 HTMLElement
如果节点不可见或不是用于 `page.click()` 的 `HTMLElement`，请首先验证您正在用于单击元素的 `xpath`。另外，如果您的元素位于屏幕底部，请调整视区。预设情况下，CloudWatch Synthetics 采用的视区为 1920 \$1 1080。您可以在启动浏览器时或使用 Puppeteer 函数 `page.setViewport` 另行设置视区。
## 无法将构件上载到 S3，“异常：无法获取 S3 存储桶位置：访问被拒绝”
如果您的金丝雀因 Amazon S3 错误而失败，CloudWatch Synthetics 无法上传屏幕截图、日志或因权限问题为金丝雀创建的报告。请检查以下事项：
+ 检查金丝雀的 IAM 角色是否具有 `s3:ListAllMyBuckets` 权限、对正确的 Amazon S3 存储桶的 `s3:GetBucketLocation` 权限，以及对金丝雀存储其构件的存储桶的 `s3:PutObject` 权限。如果金丝雀执行可视化监控，该角色还需要存储桶的 ` s3:GetObject` 权限。如果 Canary 部署在具有 VPC 端点的 VPC 中，则 Amazon VPC S3 网关端点策略也需要相同权限。
+ 如果金丝雀使用 AWS KMS 客户托管式密钥而不是标准 AWS 托管式密钥（默认）来加密，金丝雀的 IAM 角色可能没有使用该密钥加密或解密的权限。有关更多信息，请参阅 [加密金丝雀构件](CloudWatch_Synthetics_artifact_encryption.md)。
+ 您的存储桶策略可能不允许金丝雀使用的加密机制。例如，如果您的存储桶策略要求使用特定的加密机制或 KMS 密钥，则必须为金丝雀选择相同的加密模式。
如果金丝雀执行可视化监控，请参阅 [使用可视化监控时更新构件位置和加密](CloudWatch_Synthetics_artifact_encryption.md#CloudWatch_Synthetics_artifact_encryption_visual) 了解更多信息。
## “错误：协议错误 (Runtime.callFunctionOn)：目标已关闭。”
如果在页面或浏览器关闭后还有一些网络请求，则会出现此错误。您可能忘记了等待异步操作。执行脚本后，CloudWatch Synthetics 会关闭浏览器。关闭浏览器后执行任何异步操作可能会导致 `target closed error` 错误。
## “金丝雀失败。错误：无数据点 – 金丝雀显示超时”错误
此错误指金丝雀运行超过了超时时间。金丝雀执行在 CloudWatch Synthetics 发布成功率 CloudWatch 指标或更新构件（如 HAR 文件、日志和屏幕截图）前已经停止。如果超时时间太低，您可以将其提高。
预设情况下，金丝雀的超时值等于其频率。您可以手动将超时值调整为小于或等于金丝雀频率。如果金丝雀频率较低，则必须增加频率以提高超时时间。在使用 CloudWatch Synthetics 控制台创建或更新金丝雀时，您可以在 **Schedule（计划）**下调整频率和超时值。
请确保金丝雀超时值不要短于 15 秒钟，以预留 Lambda 冷启动以及启动金丝雀工具的时间。
发生此错误时，无法在 CloudWatch Synthetics 控制台中查看金丝雀构件。您可以使用 CloudWatch Logs 查看金丝雀的日志。
**使用 CloudWatch Logs 查看金丝雀的日志**
1. 通过 [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) 打开 CloudWatch 控制台。
1. 在左侧导航窗格中，选择 **Log groups（日志组）**。
1. 在筛选器框中键入金丝雀名称来查找日志组。金丝雀的日志组名称为 **/aws/lambda/cwsyn-*canaryName*-randomId**。
## 尝试访问内部端点
如果希望您的金丝雀访问内部网络上的端点，我们建议您将 CloudWatch Synthetics 设置为使用 VPC。有关更多信息，请参阅 [在 VPC 上运行金丝雀](CloudWatch_Synthetics_Canaries_VPC.md)。
## 金丝雀运行时版本升级和降级问题
如果您最近将金丝雀的运行时版本从 `syn-1.0` 升级到更高版本，则可能是跨域请求共享 (CORS) 问题。有关更多信息，请参阅 [跨域请求共享 (CORS) 问题](#CloudWatch_Synthetics_Canaries_CORS)。
如果您最近将金丝雀运行时版本降级到较旧版本，请检查以确保您正在使用的 CloudWatch Synthetics 函数在您降级到的旧运行时版本中可用。例如，`executeHttpStep` 函数可用于 `syn-nodejs-2.2` 或更高版本的运行时。要检查函数的可用性，请参阅 [编写金丝雀脚本](CloudWatch_Synthetics_Canaries_WritingCanary.md)。
**注意**
当您计划升级或降级金丝雀的运行时系统版本时，我们建议您首先克隆金丝雀并更新克隆金丝雀中的运行时系统版本。在验证了使用新运行时版本的克隆金丝雀正常运行后，您可以更新原始金丝雀的运行时版本并删除克隆金丝雀。
## 跨域请求共享 (CORS) 问题
在 UI 金丝雀中，如果某些网络请求失败并显示 `403` 或 ` net::ERR_FAILED` 错误，请检查金丝雀是否启用了活动跟踪，并使用 Puppeteer 函数 `page.setExtraHTTPHeaders` 添加标头。若是如此，则网络请求失败可能是由跨域请求共享 (CORS) 限制所致。您可以通过禁用活动跟踪或删除额外的 HTTP 标头来确认是否属于这种情况。
**为什么会发生这种情况？**
在使用活动跟踪时，会向所有传出请求添加额外的标头以跟踪调用。通过使用 Puppeteer 的 `page.setExtraHTTPHeaders` 来添加跟踪标头或添加额外标头的方式来修改请求标头，会导致对 XMLHttpRequest (XHR) 请求进行 CORS 检查。
如果您不想禁用活动跟踪或删除额外标头，则可以更新 Web 应用程序以允许跨域访问，也可以在脚本中启动 Chrome 浏览器时使用 `disable-web-security` 标志来禁用 Web 安全。
您可以覆盖 CloudWatch Synthetics 所用的启动参数，并通过使用 CloudWatch Synthetics 启动函数传递其他 ` disable-web-security` 标记参数。有关更多信息，请参阅 [可用于使用 Puppeteer 的 Node.js Canary 脚本的库函数](CloudWatch_Synthetics_Canaries_Library_Nodejs.md)。
**注意**
如果您使用的是 `syn-nodejs-2.1` 或更高运行时版本，则可以覆盖 CloudWatch Synthetics 所用的启动参数。
## 金丝雀争用情况问题
为了在使用 CloudWatch Synthetics 时获得最佳体验，请确保为金丝雀编写的代码具有幂等性。否则，在极少数情况下，当金丝雀在不同的运行中与相同资源交互时，Canary 运行可能会遇到争用情况。
## 排查 VPC 上金丝雀的问题
如果您在创建或更新使用 VPC 的金丝雀后遇到问题，以下其中一部分可能会帮助您解决问题。
### 新的金丝雀处于错误状态或无法更新金丝雀
如果您创建要在 VPC 上运行的金丝雀，并且它立即进入错误状态，或者您无法更新金丝雀以在 VPC 上运行，则金丝雀的角色可能没有正确的权限。要在 VPC 上运行，金丝雀必须具有权限 ` ec2:CreateNetworkInterface`、`ec2:DescribeNetworkInterfaces` 和 ` ec2:DeleteNetworkInterface`。这些权限包含在 ` AWSLambdaVPCAccessExecutionRole` 托管策略中。有关更多信息，请参阅[执行角色和用户权限](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc.html#vpc-permissions)。
如果在创建金丝雀时发生此问题，必须删除此金丝雀，然后创建一个新的金丝雀。如果您使用 CloudWatch 控制台创建新金丝雀，请在 **Access Permissions（访问权限）**下选择 **Create a new role（创建新角色）**。此时将创建一个新角色，该角色包含运行金丝雀所需的全部权限。
如果在更新金丝雀时发生此问题，可以再次更新金丝雀并提供具有必要权限的新角色。
### “未返回测试结果”错误
如果金丝雀显示“未返回测试结果”错误，以下问题之一可能是导致这个问题的原因：
+ 如果您的 VPC 不具有 Internet 访问权限，则必须使用 VPC 终端节点授予金丝雀对 CloudWatch 和 Amazon S3 的访问权限。您必须在 VPC 中启用 **DNS 解析**和 **DNS 主机名**选项，才能正确解析这些终端节点地址。有关更多信息，请参阅 [将 DNS 与 VPC 配合使用](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html) 以及 [将 CloudWatch 和 CloudWatch Synthetics 与接口 VPC 端点配合使用](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-and-interface-VPC.html)。
+ 金丝雀必须在 VPC 内的私有子网中运行。要检查是否存在此问题，请在 VPC 控制台中打开**子网**页面。检查您在配置金丝雀时选择的子网。如果它们具有通往互联网网关 (**igw-**) 的路径，则不是私有子网。
要帮助您解决这些问题，请参阅金丝雀日志。
**要查看来自金丝雀的日志事件，请执行以下操作：**
1. 通过 [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) 打开 CloudWatch 控制台。
1. 在导航窗格中，选择 **Log groups（日志组）**。
1. 选择金丝雀日志组的名称。日志组名称以 ` /aws/lambda/cwsyn-canary-name` 开头。
## 对自动重试金丝雀进行问题排查
要了解金丝雀失败的原因或分析特定的失败尝试，请按照以下问题排查步骤进行操作。
1. 通过 [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) 打开 CloudWatch 控制台。
1. 在导航窗格中，选择 **Application Signals**、**Synthetics 金丝雀**。
1. 选择**金丝雀**。
1. 在**可用性**选项卡下，您可以通过以下任一方式检查运行详细信息：
+ 在金丝雀运行图表上选择特定点
+ 在**问题**下选择一条记录。请注意，重试尝试会经过标记并与其计划运行共享时间戳
您可以在**步骤**、**屏幕截图**、**日志**、**HAR 文件**或**跟踪**（如果启用了主动跟踪）下查看其他信息。
1. 在**金丝雀构件和 Amazon S3 位置**下，您可以访问构件并通过可用链接导航到 Amazon S3 文件夹或存储桶。
1. **金丝雀运行**图表使用不同颜色的点来表示不同的状态：
+ 蓝色点 – 表示计划运行成功，一致值为 100%
+ 红色点 – 显示失败的计划运行和所有重试，标记为 0%
+ 橙色点 – 显示 0% 或 100%。0% 表示在上一次尝试失败后正在进行重试，100% 表示重试后成功了
# 金丝雀脚本示例代码
本节包含对 CloudWatch Synthetics 金丝雀脚本的一些可能的函数进行说明的代码示例。
## Node.js 和 Playwright 的示例
### Playwright Canary 有多个步骤
以下脚本是包含多个步骤的 Node.js Playwright Canary 的示例。
```
import { synthetics } from '@aws/synthetics-playwright';
export async function handler(event, context) {
try {
console.log('Running Synthetics Playwright canary');
const browser = await synthetics.launch();
const browserContext = await browser.newContext();
const page = await synthetics.getPage(browserContext);
// Add steps
// Step 1
await synthetics.executeStep("home-page", async () => {
console.log("Verify home page loads")
await page.goto('https://www.amazon.com', {waitUntil: "load"});
await new Promise(r => setTimeout(r, 5000));
});
// Step 2
await synthetics.executeStep("search", async () => {
console.log("Searching for a product")
const searchInput = page.getByPlaceholder("Search Amazon").first();
await searchInput.click()
await searchInput.fill('Amazon echo');
const btn = page.getByRole('button', { name: 'Go' }).first()
await btn.click({ timeout: 15000 })
console.log("Clicked search button")
});
// Step 3
await synthetics.executeStep("search-results", async () => {
console.log("Verifying search results")
const resultsHeading = page.getByText("Results", {exact: true}).first()
await resultsHeading.highlight();
await new Promise(r => setTimeout(r, 5000));
});
} finally {
// Close all browser contexts and browser
await synthetics.close();
}
}
```
### Playwright Canary 设置 Cookie
以下脚本是 Node.js Playwright Canary 设置三个 Cookie 的示例。
```
import { synthetics } from '@aws/synthetics-playwright';
export const handler = async (event, context) => {
try {
let url = "http://smile.amazon.com/";
const browser = await synthetics.launch();
const page = await synthetics.getPage(browser);
const cookies = [{
'name': 'cookie1',
'value': 'val1',
'url': url
},
{
'name': 'cookie2',
'value': 'val2',
'url': url
},
{
'name': 'cookie3',
'value': 'val3',
'url': url
}
];
await page.context().addCookies(cookies);
await page.goto(url, {waitUntil: 'load', timeout: 30000});
await page.screenshot({ path: '/tmp/smile.png' });
} finally {
await synthetics.close();
}
};
```
## Node.js 和 Puppeteer 示例
### 设置 Cookie
网站依赖 Cookie 来提供自定义功能或跟踪用户。通过在 CloudWatch Synthetics 脚本中设置 Cookie，您可以模拟此自定义行为并对其进行验证。
例如，某个网站可能会对再次访问该网站的用户显示**登录**链接，而不是**注册**链接。
```
var synthetics = require('@aws/synthetics-puppeteer');
const log = require('@aws/synthetics-logger');
const pageLoadBlueprint = async function () {
let url = "http://smile.amazon.com/";
let page = await synthetics.getPage();
// Set cookies. I found that name, value, and either url or domain are required fields.
const cookies = [{
'name': 'cookie1',
'value': 'val1',
'url': url
},{
'name': 'cookie2',
'value': 'val2',
'url': url
},{
'name': 'cookie3',
'value': 'val3',
'url': url
}];
await page.setCookie(...cookies);
// Navigate to the url
await synthetics.executeStep('pageLoaded_home', async function (timeoutInMillis = 30000) {
var response = await page.goto(url, {waitUntil: ['load', 'networkidle0'], timeout: timeoutInMillis});
// Log cookies for this page and this url
const cookiesSet = await page.cookies(url);
log.info("Cookies for url: " + url + " are set to: " + JSON.stringify(cookiesSet));
});
};
exports.handler = async () => {
return await pageLoadBlueprint();
};
```
### 设备仿真
您可以编写模拟各种设备的脚本，以便粗略估计页面在这些设备上的外观和行为。
以下示例模拟的是 iPhone 6 设备。有关仿真的更多信息，请参阅 Puppeteer 文档中的 [page.emulate(options)](https://pptr.dev/#?product=Puppeteer&version=v5.3.1&show=api-pageemulateoptions)。
```
var synthetics = require('@aws/synthetics-puppeteer');
const log = require('@aws/synthetics-logger');
const puppeteer = require('puppeteer-core');
const pageLoadBlueprint = async function () {
const iPhone = puppeteer.devices['iPhone 6'];
// INSERT URL here
const URL = "https://amazon.com";
let page = await synthetics.getPage();
await page.emulate(iPhone);
//You can customize the wait condition here. For instance,
//using 'networkidle2' may be less restrictive.
const response = await page.goto(URL, {waitUntil: 'domcontentloaded', timeout: 30000});
if (!response) {
throw "Failed to load page!";
}
await page.waitFor(15000);
await synthetics.takeScreenshot('loaded', 'loaded');
//If the response status code is not a 2xx success code
if (response.status() < 200 || response.status() > 299) {
throw "Failed to load page!";
}
};
exports.handler = async () => {
return await pageLoadBlueprint();
};
```
### 多步骤 API 金丝雀
此示例代码演示了一个具有两个 HTTP 步骤的 API 金丝雀：对正面和负面测试用例测试同一个 API。传递步骤配置以启用请求/响应标头报告。此外，其会隐藏 Authorization（授权）标头和 X-Amz-Security-Token，因为它们二者包含用户凭证。
当此脚本用作金丝雀时，您可以查看有关每个步骤和相关 HTTP 请求的详细信息，例如步骤通过/失败、持续时间和性能指标（如 DNS 查找时间和第一字节时间）。也可以查看金丝雀运行的 2xx、4xx 和 5xx 的数量。
```
var synthetics = require('@aws/synthetics-puppeteer');
const log = require('@aws/synthetics-logger');
const apiCanaryBlueprint = async function () {
// Handle validation for positive scenario
const validatePositiveCase = async function(res) {
return new Promise((resolve, reject) => {
if (res.statusCode < 200 || res.statusCode > 299) {
throw res.statusCode + ' ' + res.statusMessage;
}
let responseBody = '';
res.on('data', (d) => {
responseBody += d;
});
res.on('end', () => {
// Add validation on 'responseBody' here if required. For ex, your status code is 200 but data might be empty
resolve();
});
});
};
// Handle validation for negative scenario
const validateNegativeCase = async function(res) {
return new Promise((resolve, reject) => {
if (res.statusCode < 400) {
throw res.statusCode + ' ' + res.statusMessage;
}
resolve();
});
};
let requestOptionsStep1 = {
'hostname': 'myproductsEndpoint.com',
'method': 'GET',
'path': '/test/product/validProductName',
'port': 443,
'protocol': 'https:'
};
let headers = {};
headers['User-Agent'] = [synthetics.getCanaryUserAgentString(), headers['User-Agent']].join(' ');
requestOptionsStep1['headers'] = headers;
// By default headers, post data and response body are not included in the report for security reasons.
// Change the configuration at global level or add as step configuration for individual steps
let stepConfig = {
includeRequestHeaders: true,
includeResponseHeaders: true,
restrictedHeaders: ['X-Amz-Security-Token', 'Authorization'], // Restricted header values do not appear in report generated.
includeRequestBody: true,
includeResponseBody: true
};
await synthetics.executeHttpStep('Verify GET products API with valid name', requestOptionsStep1, validatePositiveCase, stepConfig);
let requestOptionsStep2 = {
'hostname': 'myproductsEndpoint.com',
'method': 'GET',
'path': '/test/canary/InvalidName(',
'port': 443,
'protocol': 'https:'
};
headers = {};
headers['User-Agent'] = [synthetics.getCanaryUserAgentString(), headers['User-Agent']].join(' ');
requestOptionsStep2['headers'] = headers;
// By default headers, post data and response body are not included in the report for security reasons.
// Change the configuration at global level or add as step configuration for individual steps
stepConfig = {
includeRequestHeaders: true,
includeResponseHeaders: true,
restrictedHeaders: ['X-Amz-Security-Token', 'Authorization'], // Restricted header values do not appear in report generated.
includeRequestBody: true,
includeResponseBody: true
};
await synthetics.executeHttpStep('Verify GET products API with invalid name', requestOptionsStep2, validateNegativeCase, stepConfig);
};
exports.handler = async () => {
return await apiCanaryBlueprint();
};
```
## Python 和 Selenium 示例
以下示例 Selenium 代码是一个金丝雀，当未加载目标元素时，此金丝雀会失败并显示自定义错误消息。
```
from aws_synthetics.selenium import synthetics_webdriver as webdriver
from aws_synthetics.common import synthetics_logger as logger
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By
def custom_selenium_script():
# create a browser instance
browser = webdriver.Chrome()
browser.get('https://www.example.com/')
logger.info('navigated to home page')
# set cookie
browser.add_cookie({'name': 'foo', 'value': 'bar'})
browser.get('https://www.example.com/')
# save screenshot
browser.save_screenshot('signed.png')
# expected status of an element
button_condition = EC.element_to_be_clickable((By.CSS_SELECTOR, '.submit-button'))
# add custom error message on failure
WebDriverWait(browser, 5).until(button_condition, message='Submit button failed to load').click()
logger.info('Submit button loaded successfully')
# browser will be quit automatically at the end of canary run,
# quit action is not necessary in the canary script
browser.quit()
# entry point for the canary
def handler(event, context):
return custom_selenium_script()
```
# 金丝雀和 X-Ray 跟踪
您可以选择对使用 ` syn-nodejs-2.0` 或更高版本运行时的金丝雀启用活动 AWS X-Ray 跟踪。启用跟踪后，将针对由使用浏览器、AWS SDK 或 HTTP 或 HTTPS 模块的金丝雀发出的所有调用发送 X-Ray 跟踪。启用了跟踪功能的 Canary 会显示在 [X-Ray 跟踪地图](https://docs.aws.amazon.com/xray/latest/devguide/xray-console-servicemap.html)上，在您为应用程序启用此功能后显示在 [Application Signals](CloudWatch-Application-Monitoring-Sections.md) 中。
**注意**
亚太地区（雅加达）尚不支持在金丝雀上激活 X-Ray 追踪。
使用 Firefox 浏览器的金丝雀不支持 X-Ray 跟踪。
当 Canary 出现在 X-Ray 跟踪地图上时，其会显示为新的客户端节点类型。您可以将鼠标悬停在某个金丝雀节点上以查看有关延迟、请求和故障的数据。您也可以选择该金丝雀节点以在页面底部查看更多数据。在页面的此区域，您可以选择 **View in Synthetics（在 Synthetics 中查看）**以跳转到 CloudWatch Synthetics 控制台，了解有关金丝雀的更多详细信息，或选择 **View Traces（查看跟踪）**来查看有关此金丝雀运行的跟踪的更多详细信息。
启用了跟踪的金丝雀的详细信息页面上还有一个 **Tracing（跟踪）**选项卡，其中包含有关金丝雀运行的跟踪和分段的详细信息。
启用跟踪会将金丝雀的运行时增加 2.5% 至 7%。
启用了跟踪的金丝雀必须使用具有以下权限的角色。如果您在创建金丝雀时使用控制台创建角色，则会为其授予这些权限。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Sid230934",
"Effect": "Allow",
"Action": [
"xray:PutTraceSegments"
],
"Resource": "*"
}
]
}
```
------
金丝雀产生的跟踪会产生费用。有关 X-Ray 定价的更多信息，请参阅 [AWS X-Ray 定价](https://aws.amazon.com/xray/pricing/)。
# 在 VPC 上运行金丝雀
您可以在 VPC 上的终端节点上，以及在内部公有终端节点上运行金丝雀。要在 VPC 上运行金丝雀，您必须在 VPC 上同时启用 **DNS 解析**和 **DNS 主机名**选项。有关更多信息，请参阅[在您的 VPC 中使用 DNS](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html)。
当您在 VPC 终端节点上运行金丝雀时，必须提供一种将其指标发送到 CloudWatch 并将其构件发送到 Amazon S3 的方法。如果 VPC 已启用 Internet 访问，则您无需再执行任何操作。金丝雀将在您的 VPC 中执行，但可以访问 Internet 以上传其指标和构件。
如果 VPC 尚未启用互联网访问功能，您有两个选项：
+ 启用 IPv4 互联网访问，以允许金丝雀向 CloudWatch 和 Amazon S3 发送指标。有关更多信息，请参阅以下部分 [为 VPC 上的金丝雀提供互联网访问权限](#CloudWatch_Synthetics_VPC_Internet)。
+ 如果您希望将 VPC 保持私有状态，可以将金丝雀配置为通过私有 VPC 终端节点将其数据发送到 CloudWatch 和 Amazon S3。如果您尚未这样做，则必须为 CloudWatch (com.amazonaws.*region*.monitoring) 创建 VPC 端点，并为 Amazon S3 创建网关端点。有关更多信息，请参阅 [将 CloudWatch、CloudWatch Synthetics 和 CloudWatch 网络监控与接口 VPC 端点结合使用](cloudwatch-and-interface-VPC.md) 和[适用于 Amazon S3 的 Amazon VPC 终端节点](https://docs.aws.amazon.com/glue/latest/dg/vpc-endpoints-s3.html)。
## 为 VPC 上的金丝雀提供互联网访问权限
请按照以下步骤为您的 VPC 金丝雀提供互联网访问权限，或者为您的 VPC 金丝雀分配静态 IP 地址
**为 VPC 上的金丝雀提供互联网访问（IPv4）**
1. 在 VPC 上的公有子网中创建 NAT 网关。有关说明，请参阅[创建 NAT 网关](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-creating)。
1. 在启动金丝雀的私有子网中的路由表中添加新路由。指定以下内容：
+ 对于 **Destination**（目标），输入 **0.0.0.0/0**。
+ 对于**目标**，选择 **NAT 网关**，然后选择您创建的 NAT 网关的 ID。
+ 选择 **Save routes（保存路由）**。
有关在路由表中添加路由的更多信息，请参阅[在路由表中添加和删除路由](https://docs.aws.amazon.com/vpc/latest/userguide/WorkWithRouteTables.html#AddRemoveRoutes)。
**为 VPC 上的金丝雀提供互联网访问（IPv6）**
1. 将 VPC 配置为具有双栈子网。您必须向 VPC 添加仅出口互联网网关，更新路由表以允许流向互联网网关的流量，并允许来自关联安全组的出站访问。有关更多信息，请参阅[为 VPC 添加 IPv6 支持](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-migrate-ipv6-add.html)。
1. 使用 `CreateCanary` 或 `UpdateCanary` API 设置金丝雀 VPC 配置中的 `Ipv6AllowedForDualstack `。有关更多信息，请参阅 [VpcConfigInput](https://docs.aws.amazon.com/AmazonSynthetics/latest/APIReference/API_VpcConfigInput.html)。
要启用来自金丝雀的出站 IPv6 流量，必须为双堆栈启用附加到金丝雀的 VPC 子网。
**注意**
确保通往 NAT 网关的路由处于**活动**状态。如果 NAT 网关被删除，而您尚未更新路由，则它们将处于黑洞状态。有关更多信息，请参阅[使用 NAT 网关](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-working-with)。
# 加密金丝雀构件
CloudWatch Synthetics 将屏幕截图、HAR 文件和报告等金丝雀构件存储在 Amazon S3 存储桶中。默认情况下，这些构件使用 AWS 托管式密钥加密。有关更多信息，请参阅[客户密钥和 AWS 密钥](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-mgmt.html)。
您可以选择使用其他加密选项。CloudWatch Synthetics 支持以下选项：
+ **SSE-S3** – 使用 Amazon S3 托管式密钥进行服务器端加密 (SSE)。
+ **SSE-KMS** – 使用 AWS KMS 客户托管式的密钥进行服务器端加密 (SSE)。
如果您想通过 AWS 托管式密钥使用默认加密选项，则不需要任何额外权限。
要使用 SSE-S3 加密，则需要将 **SSE\$1S3** 指定为创建或更新金丝雀时的加密模式。使用此加密模式不需要任何额外权限。有关更多信息，请参阅[使用服务器端加密与 Amazon S3 托管式加密密钥 (SSE-S3) 保护数据](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingServerSideEncryption.html)。
要使用 AWS KMS 客户托管式密钥，则需要将 **SSE-KMS** 指定为创建或更新金丝雀时的加密模式，并提供密钥的 Amazon Resource Name (ARN)。您还可以使用跨账户 KMS 密钥。
要使用客户托管式密钥，需要以下设置：
+ 您的金丝雀的 IAM 角色必须具有使用密钥加密构件的权限。如果您使用可视化监控，还必须授予其解密构件的权限。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowKMSKeyUsage",
"Effect": "Allow",
"Action": [
"kms:GenerateDataKey",
"kms:Decrypt"
],
"Resource": "arn:aws:kms:us-east-1:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab"
}
]
}
```
------
+ 您可以将 IAM 角色添加到密钥策略中，而不是向 IAM 角色添加权限。如果您对多个金丝雀使用相同的角色，您应该考虑这种方法。
```
{
"Sid": "Enable IAM User Permissions",
"Effect": "Allow",
"Principal": {
"AWS": "Your synthetics IAM role ARN"
},
"Action": [
"kms:GenerateDataKey",
"kms:Decrypt"
],
"Resource": "*"
}
```
+ 如果您使用的是跨账户 KMS 密钥，请参阅[是否允许其他账户中的用户使用 KMS 密钥](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-modifying-external-accounts.html)。
**使用客户托管式密钥时查看加密的金丝雀构件**
要查看金丝雀构件，请更新客户托管式密钥以向查看构件的用户提供 AWS KMS 解密权限。或者，向正在查看构件的用户或 IAM 角色添加解密权限。
默认 AWS KMS 策略让账户中的 IAM 策略能够允许访问 KMS 密钥。如果您使用的是跨账户 KMS 密钥，请参阅[为什么跨账户用户在尝试访问由自定义 AWS KMS 密钥加密的 Amazon S3 对象时会出现“拒绝访问”的错误？](https://aws.amazon.com/premiumsupport/knowledge-center/cross-account-access-denied-error-s3/)
有关因 KMS 密钥而被拒绝访问的故障排除的更多信息，请参阅[密钥访问故障排除](https://docs.aws.amazon.com/kms/latest/developerguide/policy-evaluation.html)。
## 使用可视化监控时更新构件位置和加密
为执行可视化监控，CloudWatch Synthetics 会将您的屏幕截图与在基准运行中获得的基准屏幕截图进行比较。如果您更新构件位置或加密选项，必须执行以下操作之一：
+ 确保您的 IAM 角色对之前的 Amazon S3 位置和新的 Amazon S3 位置都具有足够的权限，以获取构件。同时，确保它对以前的和新的加密方法及 KMS 密钥都具有权限。
+ 通过选择下一个金丝雀运行作为新基准来创建新基准。如果您使用此选项，则只需确保您的 IAM 角色对构件的新位置和加密选项具有足够的权限。
我们建议第二个选项，即选择下一次运行作为新基准。这避免了对之前用于金丝雀的构件位置或加密选项的依赖。
例如，假设您的金丝雀使用构件位置 A 和 KMS 密钥 K 来上传构件。如果您将金丝雀更新为构件位置 B 和 KMS 密钥 L，则可以确保您的 IAM 角色具有对两个构件位置（A 和 B）以及两个 KMS 密钥（K 和 L）的权限。或者，您可以选择下一次运行作为新基准，并确保您的金丝雀 IAM 角色具有对构件位置 B 和 KMS 密钥 L 的权限。
# 查看金丝雀统计数据和详细信息
您可以查看有关金丝雀的详细信息，并查看有关其运行的统计数据。
要能够查看有关金丝雀运行结果的所有详细信息，您必须登录具有足够权限的账户。有关更多信息，请参阅 [CloudWatch 金丝雀的必需角色和权限](CloudWatch_Synthetics_Canaries_Roles.md)。
**查看金丝雀统计数据和详细信息**
1. 通过 [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) 打开 CloudWatch 控制台。
1. 在导航窗格中，选择 **Application Signals**、**Synthetics 金丝雀**。
在有关您已创建的金丝雀的详细信息中：
+ **Status (状态)** 直观地显示了已通过其最新运行的金丝雀的数目。
+ **Groups**（组）显示了您创建的组，并显示其中有多少组存在故障或警报的金丝雀。
+ **Slowest performers**（最慢执行者）显示了金丝雀执行最慢的组和区域。这一数据是在选定的时间跨度内、将组或区域内所有金丝雀的平均持续时间相加，并除以组或区域中的金丝雀数量计算得出的。如果选择最慢组的指标，则会筛选该表，仅显示最慢组及其金丝雀。该表按平均持续时间排序。
+ 在页面底部附近有一张显示了所有金丝雀的表格。您可以使用筛选栏来筛选表格，以按特定的金丝雀名称、上次运行结果、成功百分比、警报、运行率、金丝雀状态、运行时和唯一标签显示金丝雀。
对于警报列，仅显示符合金丝雀警报命名标准的警报。该标准为 `Synthetics-Alarm-canaryName -index`。您在 CloudWatch 控制台的 **Synthetics** 部分中创建的金丝雀警报会自动使用此命名惯例。如果金丝雀告警是在 CloudWatch 控制台的 **Alarms（告警）**部分或通过使用 AWS CloudFormation 创建的，并且您未使用此命名约定，则告警会工作但不会出现在此列表中。
1. 要查看单个金丝雀的更多详细信息，请在**金丝雀**表中选择该金丝雀的名称。
在有关金丝雀的详细信息中：
+ **Availability（可用性）**选项卡显示了有关此金丝雀的最近运行的信息。
在 **Canary runs (金丝雀运行)** 下，您可以选择其中一条线，查看有关运行的详细信息。
在图表下，您可以选择**步骤**、**屏幕截图**、**日志**或 **HAR 文件**来查看这些类型的详细信息。如果金丝雀启用了主动跟踪，您还可选择**跟踪**以查看来自金丝雀运行的跟踪信息。
金丝雀运行的日志存储在 S3 存储桶和 CloudWatch Logs 中。
屏幕截图显示客户查看您的网页的情况。您可以使用 HAR 文件（HTTP 归档文件）查看有关网页性能的详细数据。您可以分析 Web 请求列表并捕获性能问题，例如某个项的加载时间。日志文件显示金丝雀运行与网页之间的交互记录，可用于确定错误的详细信息。
如果金丝雀使用的是 `syn-nodejs-2.0-beta` 或更高版本的运行时，则您可以按状态代码、请求大小或持续时间对 HAR 文件进行排序。
**Steps**（步骤）选项卡显示了金丝雀的步骤列表、每个步骤的状态、故障原因、步骤执行后的 URL、屏幕截图和步骤执行持续时间。对于具有 HTTP 步骤的 API 金丝雀，如果您使用的是 `syn-nodejs-2.2` 或更高版本的运行时，您可以查看步骤和相应的 HTTP 请求。
选择 **HTTP Requests（HTTP 请求）**选项卡查看金丝雀发出的每个 HTTP 请求的日志。您可以查看请求/响应标头、响应体、状态代码、错误和性能计时（总持续时间、TCP 连接时间、TLS 握手时间、第一字节时间和内容传输时间）。所有使用后台 HTTP/HTTPS 模块的 HTTP 请求都在此处捕获。
预设情况下，在 API 金丝雀中，出于安全原因，请求标头、响应标头、请求体和响应体不包含在报告中。如果您选择将它们包含在报告中，则这些数据仅存储在 S3 存储桶中。有关如何将此数据包括在报告中，请参阅 [executeHttpStep(stepName, requestOptions, [callback], [stepConfig])](CloudWatch_Synthetics_Canaries_Library_Nodejs.md#CloudWatch_Synthetics_Library_executeHttpStep)。
支持文本、HTML 和 JSON 类型的响应体内容。支持文本/HTML、文本/纯文本、应用程序/JSON 和应用程序/x-amz-json-1.0 等内容类型。不支持经压缩的响应。
+ **Monitoring（监控）**选项卡显示了由此金丝雀发布的 CloudWatch 指标的图表。有关这些指标的更多信息，请参阅 [金丝雀发布的 CloudWatch 指标](CloudWatch_Synthetics_Canaries_metrics.md)。
在金丝雀发布的 CloudWatch 图表下方，是与金丝雀的 Lambda 代码相关的 Lambda 指标图表。
+ **Configuration（配置）**选项卡显示了有关金丝雀的配置和计划信息。
+ **Groups**（组）选项卡显示了与此金丝雀关联的组（如果有）。
+ **Tags（标签）**选项卡显示了与金丝雀关联的标签。
# 金丝雀发布的 CloudWatch 指标
金丝雀会将以下指标发布到 `CloudWatchSynthetics` 命名空间中的 CloudWatch。有关查看 CloudWatch 指标的更多信息，请参阅[查看可用的指标](viewing_metrics_with_cloudwatch.md)。
**注意**
对于多浏览器金丝雀，浏览器维度指标默认处于启用状态，提供跨 Chrome、Firefox 及其他浏览器的性能可视化洞察。要禁用浏览器指标，请将 `browserDimension` 设置为 `false`。
对于单浏览器金丝雀，浏览器维度指标默认处于禁用状态，避免数据冗余。要查看按浏览器细分的指标，请将 `browserDimension` 设置为 ` true`。
| 指标 | 说明 |
| --- | --- |
| `2xx` | 金丝雀执行的返回“OK”响应且响应代码介于 200 到 299 之间的网络请求数。 针对使用 ` syn-nodejs-2.0` 或更高版本运行时的 UI 金丝雀和使用 `syn-nodejs-2.2` 或更高版本运行时的 API 金丝雀报告此指标。 有效维度：CanaryName、浏览器 有效统计数据：Sum 单位：计数 |
| `4xx` | 金丝雀执行的返回“Error”响应且响应代码介于 400 到 499 之间的网络请求数。 针对使用 ` syn-nodejs-2.0` 或更高版本运行时的 UI 金丝雀和使用 `syn-nodejs-2.2` 或更高版本运行时的 API 金丝雀报告此指标。 有效维度：CanaryName、浏览器 有效统计数据：Sum 单位：计数 |
| `5xx` | 金丝雀执行的返回“Fault”响应且响应代码介于 500 到 599 之间的网络请求数。 针对使用 ` syn-nodejs-2.0` 或更高版本运行时的 UI 金丝雀和使用 `syn-nodejs-2.2` 或更高版本运行时的 API 金丝雀报告此指标。 有效维度：CanaryName、浏览器 有效统计数据：Sum 单位：计数 |
| `Duration` | 金丝雀运行时长，以毫秒为单位。 有效维度：CanaryName、浏览器 有效统计数据：平均值 单位：毫秒 |
| `DurationDryRun` | DryRun 执行的持续时间。 有效维度：CanaryName、浏览器 有效统计数据：平均值 单位：毫秒 |
| `EphemeralStorageUsagePercent` | 已使用的临时存储占配置的临时存储总量的最大百分比。此指标每隔 10 秒收集一次。 |
| `Failed` | 执行失败的金丝雀运行数。这些失败与金丝雀本身有关。 有效维度：CanaryName、浏览器 有效统计数据：Sum 单位：计数 |
| `Failed requests` | 金丝雀在目标网站上执行但失败且无响应的 HTTP 请求数。 有效维度：CanaryName、浏览器 有效统计数据：Sum 单位：计数 |
| `RetryCount` | 金丝雀重试的次数。仅当存在重试时才会显示此指标。 有效维度：CanaryName、浏览器 有效统计数据：Sum 单位：计数 |
| `SuccessPercent` | 此金丝雀成功运行且未发现任何故障的运行数百分比。 有效维度：CanaryName、浏览器 有效统计数据：平均值 单位：百分比 |
| `SuccessPercentDryRun` | DryRun 执行的成功百分比。 有效维度：CanaryName、浏览器 有效统计数据：平均值 单位：百分比 |
| `SuccessPercentWithRetries` | 此金丝雀在所有尝试后成功运行的百分比。 有效维度：CanaryName、浏览器 有效统计数据：平均值 单位：百分比 |
| `VisualMonitoringSuccessPercent` | 在金丝雀运行期间成功匹配基准屏幕截图的可视化比较数百分比。 有效维度：CanaryName、浏览器 有效统计数据：平均值 单位：百分比 |
| `VisualMonitoringTotalComparisons` | 在金丝雀运行期间发生的可视化比较总数。 有效维度：CanaryName、浏览器 单位：计数 |
**注意**
使用 Synthetics 库中 `executeStep()` 或 `executeHttpStep()` 方法的金丝雀还会发布 `SuccessPercent` 和 ` Duration` 指标，指标包含每个步骤的 `CanaryName` 和 `StepName` 维度。
# 编辑或删除金丝雀脚本
您可以编辑或删除现有金丝雀。
**编辑金丝雀**
在编辑金丝雀时，即使您并未更改其计划，该计划也会在您编辑金丝雀时相应地重置。例如，如果您的金丝雀每小时运行，而您编辑了该金丝雀，则该金丝雀会在编辑完成后立即运行，然后每一小时运行一次。
**编辑或更新金丝雀**
1. 通过 [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) 打开 CloudWatch 控制台。
1. 在导航窗格中，选择 **Application Signals**、**Synthetics 金丝雀**。
1. 选择金丝雀名称旁边的按钮，然后选择**操作**、**编辑**。
1. （可选）如果此金丝雀执行屏幕截图可视化监控，并且您希望将金丝雀的下一次运行设置为基准，请选择 **Set next run as new baseline（将下一次运行设置为新基准）**。
1. （可选）如果此金丝雀执行屏幕截图可视化监控，并且您希望从可视化监控中删除某个屏幕截图，或者您希望在可视化比较期间指定要忽略部分屏幕截图，请在 **Visual Monitoring（可视化监控）**下选择 **Edit Baseline（编辑基准）**。
此时会显示屏幕截图，您可以执行下列操作之一：
+ 若要删除用于可视化监控的屏幕截图，请选择 **Remove screenshot from visual test baseline（从可视化测试基准中删除屏幕截图）**。
+ 若要指定要在可视化对比过程中忽略的屏幕截图部分，请单击并拖动以绘制屏幕中要忽略的区域。针对要在对比中忽略的所有区域执行完成此操作后，选择 **Save（保存）**。
1. 在**脚本编辑器**的**运行时版本**下，选择要执行金丝雀的 Synthetics 运行时版本。有关 Synthetics 运行时版本的信息，请参阅 [Synthetics 运行时版本](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Synthetics_Canaries_Library.html)。
在**浏览器配置**下，您可以启用浏览器来测试金丝雀。必须至少选择一个浏览器。
1. 对金丝雀做出任何其他更改，然后选择 **Save（保存）**。
**删除金丝雀**
当您删除金丝雀时，可以选择是否同时删除该金丝雀使用和创建的其他资源。如果删除 Canary 时 Canary 的 `ProvisionedResourceCleanup` 字段设置为 ` AUTOMATIC` 或 `DeleteLambda` 指定为 `true`，则 CloudWatch Synthetics 将自动删除 Canary 使用的 Lambda 函数和层。
当您删除金丝雀时，还应删除以下内容：
+ 此金丝雀使用的 Lambda 函数和层。其前缀为 `cwsyn- MyCanaryName`。
+ 为此金丝雀创建的 CloudWatch 告警。这些告警的名称都以 ` Synthetics-Alarm-MyCanaryName` 开头。有关删除警报的更多信息，请参阅[编辑或删除 CloudWatch 警报](Edit-CloudWatch-Alarm.md)。
+ Amazon S3 对象和存储桶，例如金丝雀的结果位置和构件位置。
+ 为金丝雀创建的 IAM 角色。它们的名称为 ` role/service-role/CloudWatchSyntheticsRole-MyCanaryName`。
+ CloudWatch Logs 中为金丝雀创建的日志组。这些日志组具有以下名称：`/aws/lambda/cwsyn-MyCanaryName-randomId`。
在删除金丝雀之前，您可能需要查看金丝雀详细信息并记下此信息。这样，您就可以在删除金丝雀后删除正确的资源。
**删除金丝雀**
1. 通过 [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) 打开 CloudWatch 控制台。
1. 在导航窗格中，选择 **Application Signals**、**Synthetics 金丝雀**。
1. 如果金丝雀当前处于 `RUNNING` 状态，则您必须停止它。仅可删除处于 `STOPPED`、`READY(NOT_STARTED)` 或 `ERROR` 状态的金丝雀。
要停止金丝雀，请选择金丝雀名称旁边的按钮，然后选择**操作**、**停止**。
1. 选择金丝雀名称旁边的按钮，然后选择**操作**、**删除**。
1. 选择是否同时删除为该金丝雀创建和供其使用的其他资源。Lambda 函数和层将与该 Canary 一起删除，但您也可以选择删除该 Canary 的 IAM 角色和 IAM 策略。
在框中输入 **Delete**，然后选择 **Delete（删除）**。
1. 删除为金丝雀所用和为其创建的其他资源，如本节前面所列内容。
# 启动、停止、删除或更新多个金丝雀脚本的运行时
您可以通过一个操作停止、启动、删除或更新多达五个金丝雀脚本的运行时。如果您更新金丝雀脚本的运行时，它会更新为适用于金丝雀脚本所用语言和框架的最新运行时。
如果您选择了多个金丝雀脚本，并且只有其中一部分处于对所选操作有效的状态，则该操作仅在该操作有效的金丝雀脚本上执行。例如，如果您选择了一些当前正在运行的金丝雀脚本和一些未运行的金丝雀脚本，然后选择启动金丝雀脚本，则尚未运行的金丝雀脚本将会启动，而已经运行的金丝雀脚本不会受到影响。
如果您选择的所有金丝雀脚本都不适用于某项操作，则该操作在菜单中不可用。
1. 通过 [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) 打开 CloudWatch 控制台。
1. 在导航窗格中，选择 **Application Signals**、**Synthetics 金丝雀**。
1. 选中要停止、启动或删除的金丝雀脚本旁边的复选框。
1. 选择**操作**，然后依次选择**启动**、**停止**、**删除**、**开始试运行**或**更新运行时**。
此外，选择**更新运行时**之时，可以选择在提交更改之前先试运行运行时更新。
# 使用 Amazon EventBridge 监控金丝雀事件
在金丝雀更改状态或完成运行时，Amazon EventBridge 事件规则可以通知您。EventBridge 提供近乎实时的系统事件流，这些系统事件描述的是 AWS 资源发生的变化。CloudWatch Synthetics *尽最大努力*将这些事件发送到 EventBridge。尽最大努力发送事件是指 CloudWatch Synthetics 会尝试将所有事件发送到 EventBridge，但在某些极少数情况下，可能无法发送事件。EventBridge 至少会处理所接收的所有事件一次。此外，事件侦听器可能无法按事件的发生顺序接收事件。
**注意**
Amazon EventBridge 是一种事件总线服务，您可以用其轻松地将应用程序与来自各种来源的数据相连接。有关更多信息，请参阅 *Amazon EventBridge 用户指南*中的[什么是 Amazon EventBridge？](https://docs.aws.amazon.com/eventbridge/latest/userguide/what-is-amazon-eventbridge.html)。
CloudWatch Synthetics 会在金丝雀改变状态或完成运行时发出事件。您可以创建一个包含事件模式的 EventBridge 规则，以匹配从 CloudWatch Synthetics 发送的所有事件类型，或者仅匹配特定事件类型。当金丝雀触发规则时，EventBridge 会调用规则中定义的目标操作。这样，您就可以发送通知、捕获事件信息以及采取纠正操作，以响应金丝雀的状态更改或完成运行。例如，您可以为以下使用案例创建规则：
+ 在金丝雀运行失败时执行调查
+ 在金丝雀变为 `ERROR` 状态时执行调查
+ 跟踪金丝雀的生命周期
+ 作为工作流程的一部分监控金丝雀运行成功或故障
## CloudWatch Synthetics 发送的事件示例
本节列出了 CloudWatch Synthetics 发送的事件示例。有关事件格式的更多信息，请参阅 [EventBridge 中的事件和事件模式](https://docs.aws.amazon.com/eventbridge/latest/userguide/eventbridge-and-event-patterns.html)。
**金丝雀状况更改**
在此事件类型中，`current-state` 和 `previous-state` 的值可以是：
`CREATING` \$1 `READY` \$1 `STARTING` \$1 `RUNNING` \$1 `UPDATING` \$1 `STOPPING` \$1 `STOPPED` \$1 `ERROR`
```
{
"version": "0",
"id": "8a99ca10-1e97-2302-2d64-316c5dedfd61",
"detail-type": "Synthetics Canary Status Change",
"source": "aws.synthetics",
"account": "123456789012",
"time": "2021-02-09T22:19:43Z",
"region": "us-east-1",
"resources": [],
"detail": {
"account-id": "123456789012",
"canary-id": "EXAMPLE-dc5a-4f5f-96d1-989b75a94226",
"canary-name": "events-bb-1",
"current-state": "STOPPED",
"previous-state": "UPDATING",
"source-location": "NULL",
"updated-on": 1612909161.767,
"changed-config": {
"executionArn": {
"previous-value": "arn:aws:lambda:us-east-1:123456789012:function:cwsyn-events-bb-1-af3e3a05-dc5a-4f5f-96d1-989EXAMPLE:1",
"current-value": "arn:aws:lambda:us-east-1:123456789012:function:cwsyn-events-bb-1-af3e3a05-dc5a-4f5f-96d1-989EXAMPLE:2"
},
"vpcId": {
"current-value": "NULL"
},
"testCodeLayerVersionArn": {
"previous-value": "arn:aws:lambda:us-east-1:123456789012:layer:cwsyn-events-bb-1-af3e3a05-dc5a-4f5f-96d1-989EXAMPLE:1",
"current-value": "arn:aws:lambda:us-east-1:123456789012:layer:cwsyn-events-bb-1-af3e3a05-dc5a-4f5f-96d1-989EXAMPLE:2"
}
},
"message": "Canary status has changed"
}
}
```
**已完成的成功金丝雀运行**
```
{
"version": "0",
"id": "989EXAMPLE-f4a5-57a7-1a8f-d9cc768a1375",
"detail-type": "Synthetics Canary TestRun Successful",
"source": "aws.synthetics",
"account": "123456789012",
"time": "2021-02-09T22:24:01Z",
"region": "us-east-1",
"resources": [],
"detail": {
"account-id": "123456789012",
"canary-id": "989EXAMPLE-dc5a-4f5f-96d1-989b75a94226",
"canary-name": "events-bb-1",
"canary-run-id": "c6c39152-8f4a-471c-9810-989EXAMPLE",
"artifact-location": "cw-syn-results-123456789012-us-east-1/canary/us-east-1/events-bb-1-ec3-28ddbe266797/2021/02/09/22/23-41-200",
"test-run-status": "PASSED",
"state-reason": "null",
"canary-run-timeline": {
"started": 1612909421,
"completed": 1612909441
},
"message": "Test run result is generated successfully"
}
}
```
**已完成的失败金丝雀运行**
```
{
"version": "0",
"id": "2644b18f-3e67-5ebf-cdfd-bf9f91392f41",
"detail-type": "Synthetics Canary TestRun Failure",
"source": "aws.synthetics",
"account": "123456789012",
"time": "2021-02-09T22:24:27Z",
"region": "us-east-1",
"resources": [],
"detail": {
"account-id": "123456789012",
"canary-id": "af3e3a05-dc5a-4f5f-96d1-9989EXAMPLE",
"canary-name": "events-bb-1",
"canary-run-id": "0df3823e-7e33-4da1-8194-b04e4d4a2bf6",
"artifact-location": "cw-syn-results-123456789012-us-east-1/canary/us-east-1/events-bb-1-ec3-989EXAMPLE/2021/02/09/22/24-21-275",
"test-run-status": "FAILED",
"state-reason": "\"Error: net::ERR_NAME_NOT_RESOLVED \""
"canary-run-timeline": {
"started": 1612909461,
"completed": 1612909467
},
"message": "Test run result is generated successfully"
}
}
```
可能是事件重复或者顺序颠倒。要确定事件的顺序，请使用 `time` 属性。
## 创建 EventBridge 规则的先决条件
在为 CloudWatch Synthetics 创建 EventBridge 规则之前，您应执行以下操作：
+ 熟悉 EventBridge 中的事件、规则和目标。
+ 创建和配置由 EventBridge 规则调用的目标。规则可以调用许多类型的目标，包括：
+ Amazon SNS 主题
+ AWS Lambda 函数
+ Kinesis Streams
+ Amazon SQS 队列
有关更多信息，请参阅 *Amazon EventBridge 用户指南*中的[什么是 Amazon EventBridge？](https://docs.aws.amazon.com/eventbridge/latest/userguide/what-is-amazon-eventbridge.html)和 [Amazon EventBridge 入门](https://docs.aws.amazon.com/eventbridge/latest/userguide/eventbridge-getting-set-up.html)。
## 创建 EventBridge 规则 (CLI)
以下示例中的步骤将创建一条 EventBridge 规则，该规则会在 `us-east-1` 中名为 `my-canary-name` 的金丝雀完成一次运行或更改状态时发布 Amazon SNS 主题。
1. 创建 规则。
```
aws events put-rule \
--name TestRule \
--region us-east-1 \
--event-pattern "{\"source\": [\"aws.synthetics\"], \"detail\": {\"canary-name\": [\"my-canary-name\"]}}"
```
模式中省略的属性都将会被忽略。
1. 将主题添加为规则目标。
+ 将 *topic-arn* 替换为 Amazon SNS 主题的 Amazon Resource Name (ARN)。
```
aws events put-targets \
--rule TestRule \
--targets "Id"="1","Arn"="topic-arn"
```
**注意**
要允许 Amazon EventBridge 调用您的目标主题，您必须将基于资源的策略添加到您的主题中。有关更多信息，请参阅 *Amazon EventBridge 用户指南*中的 [Amazon SNS 权限](https://docs.aws.amazon.com/eventbridge/latest/userguide/resource-based-policies-eventbridge.html#sns-permissions)。
有关更多信息，请参阅 *Amazon EventBridge 用户指南*中的 [EventBridge 中的事件和事件模式](https://docs.aws.amazon.com/eventbridge/latest/userguide/eventbridge-and-event-patterns.html)。
# 执行安全金丝雀更新
CloudWatch Synthetics 安全金丝雀更新功能允许在应用更改之前，在先对现有金丝雀的更新进行测试。此功能可帮助验证金丝雀与新运行时和其他配置更改（例如代码或内存更改）的兼容性。这将有助于最大限度地减少错误更新造成的潜在监控中断。
通过对运行时版本更新、配置更改和代码脚本修改使用金丝雀安全更新，您可以降低风险、保持不间断的监控、在提交和更新之前验证更改并减少停机时间。
**Topics**
+ [先决条件](#performing-safe-canary-upgrades-prereq)
+ [最佳实践](#performing-safe-canary-upgrades-best-practices)
+ [使用试运行测试金丝雀](#performing-safe-canary-upgrades-getting-started)
+ [限制](#performing-safe-canary-upgrades-limitations)
## 先决条件
确保已满足先决条件。
+ 具有 CloudWatch Synthetics 权限的 AWS 账户
+ 支持的运行时版本上已有金丝雀（有关兼容的运行时，请参阅[限制](#performing-safe-canary-upgrades-limitations)）
+ 执行试运行时包括兼容的运行时（有关兼容的运行时，请参阅[限制](#performing-safe-canary-upgrades-limitations)）
## 最佳实践
下面是在执行金丝雀时可遵循的一些最佳实践。
+ 执行试运行以验证运行时更新
+ 在对金丝雀进行生产环境更新之前执行试运行
+ 试运行后查看金丝雀日志和构件
+ 使用试运行来验证依赖项和库兼容性
## 使用试运行测试金丝雀
您可使用以下选项测试金丝雀更新：
**使用 AWS 管理控制台的“编辑”工作流程**
1. 前往 CloudWatch Synthetics 控制台。
1. 选择要更新的金丝雀。
1. 从**操作**下拉列表中选择**编辑**。
使用要测试的更改来更新金丝雀。例如，更改运行时版本或编辑脚本代码。
1. 在**金丝雀脚本**下选择**开始试运行**，立即测试并查看结果；或在页面底部选择**验证并稍后保存**，开始测试并稍后在**金丝雀详细信息**页面中查看结果。
1. 试运行成功后选择**提交**，完成金丝雀更新的提交。
**使用 AWS 管理控制台批量更新金丝雀**
1. 前往 CloudWatch Synthetics 控制台。
1. 选择 **Synthetics** 列表页面。
1. 最多可选择五个要为其更新运行时的金丝雀。
1. 从**操作**下拉列表中选择**更新运行时**。
1. 选择**为新的运行时开始试运行**开始试运行，并在更新之前测试更改。
1. 在 **Synthetics** 列表页面上，您将在金丝雀的**运行时**版本旁边看到一个文本，其中显示了试运行的进度（仅在涉及运行时更新的试运行中才会显示此文本）。
试运行成功后，即可看到**启动更新**文本。
1. 选择**启动更新**，完成提交运行时更新的提交。
1. 如果试运行失败，则会看到**更新试运行失败**文本。选择文本，即可查看金丝雀详细信息页面的调试链接。
**使用 AWS CLI 或 SDK**
API 开始对提供的金丝雀名称 `MyCanary` 进行试运行，并将运行时版本更新为 `syn-nodejs-puppeteer-10.0`。
```
aws synthetics start-canary-dry-run \
--name MyCanary \
--runtime-version syn-nodejs-puppeteer-10.0
// Or if you wanted to update other configurations:
aws synthetics start-canary-dry-run \
--name MyCanary \
--execution-role-arn arn:aws:iam::123456789012:role/NewRole
```
API 将返回 `DryRunConfigOutput` 内的 `DryRunId`。
通过提供的 `DryRunId` 调用 `GetCanary`，获取金丝雀的试运行配置以及包含列为 `LastDryRunExecutionStatus` 的试运行状态的附加字段 `DryRunConfig`。
```
aws synthetics get-canary \
--name MyCanary \
--dry-run-id XXXX-XXXX-XXXX-XXXX
```
有关更多详细信息，请将 `GetCanaryRuns` 与提供的 `DryRunId` 一起使用来检索运行和其他信息。
```
aws synthetics get-canary-runs \
--name MyCanary \
--dry-run-id XXXX-XXXX-XXXX-XXXX
```
成功试运行后，即可将 `UpdateCanary` 与提供的 ` DryRunId` 一起使用来提交更改。
```
aws synthetics update-canary \
--name MyCanary \
--dry-run-id XXXX-XXXX-XXXX-XXXX
```
如果因任何原因失败（GetCanaryRuns 返回的结果会包含详细信息），`GetCanaryRuns` 的返回结果会有一个包含要调试的日志的构件位置。如果没有日志，则无法创建试运行。您可以使用 ` GetCanary` 进行验证。
```
aws synthetics get-canary \
--name MyCanary \
--dry-run-id XXXX-XXXX-XXXX-XXXX
```
*State*、*StateReason* 和 *StateReasonCode* 会显示试运行的状态。
**使用 CloudFormation**
在 Synthetics 金丝雀模板中，提供接受布尔值 `true` 或 `false` 的字段 `DryRunAndUpdate`。
当值为 `true` 时，每次更新都会执行试运行来验证更改，然后自动更新金丝雀。如果试运行失败，金丝雀不会更新，而且部署和 CloudFormation 部署会因有效原因失败。要调试此问题，请使用 [AWS Synthetics 控制台](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Synthetics_Canaries_Troubleshoot.html)；如果使用 API 调试，请使用 `GetCanaryRuns` API 获取 `ArtifactS3Location`，然后下载 `*-log.txt` 文件，查看金丝雀日志执行中是否存在错误。验证后，修改 CloudFormation 模板并重试部署或使用上述 API 进行验证。
当值为 `false` 时，Synthetics 不会执行试运行来验证更改，而是直接提交您的更新。
有关对失败金丝雀进行问题排查的信息，请参阅[排查失败金丝雀的问题](CloudWatch_Synthetics_Canaries_Troubleshoot.md)。
示例模板：
```
SyntheticsCanary:
Type: 'AWS::Synthetics::Canary'
Properties:
Name: MyCanary
RuntimeVersion: syn-nodejs-puppeteer-10.0
Schedule: {Expression: 'rate(5 minutes)', DurationInSeconds: 3600}
...
DryRunAndUpdate: true
```
## 限制
+ 支持运行时版本 syn-nodejs-puppeteer-10.0\$1、syn-nodejs-playwright-2.0\$1、syn-python-selenium-5.1\$1 和 syn-nodejs-3.0\$1
+ 每个金丝雀每次只能执行一次试运行
+ 如果试运行失败，则无法更新金丝雀
+ 试运行无法测试任何**计划**字段的更改
**注意**
如果启动具有 Playwright 金丝雀代码更改的试运行，并且想要在不提供相关 `DryRunId` 的情况下更新金丝雀，必须明确指定代码参数。