跳转到内容
本站为社区维护的非官方中文翻译,与 Cloudflare, Inc. 无关联。本站不提供账户登录,请勿在任何非官方站点输入您的 Cloudflare 账户信息。官方文档:developers.cloudflare.com

Amazon AWS Transit Gateway

最后更新 查看 MarkdownAgent 设置

本指南提供将 Amazon Web Services (AWS) Transit Gateway 通过冗余的基于路由的 IPsec 隧道和边界网关协议 (BGP) 连接到 Cloudflare WAN 的分步说明。主要拓扑使用:

  • 一个 Cloudflare anycast IP
  • 一个 AWS 客户网关
  • 一个包含两条 IPsec 隧道的 AWS Site-to-Site VPN 连接
  • AWS Transit Gateway 与 Cloudflare WAN 之间的两个 BGP 会话

Cloudflare 会为每个 Cloudflare WAN 账户分配一个 IPv4 anycast IP,额外的 anycast IP 可通过您的账户团队获取。由于 anycast IP 由全球 Cloudflare 数据中心提供,隧道不绑定到单个 Cloudflare 服务器或数据中心。本指南基线使用一个 anycast IP,并支持已拥有第二个 anycast IP 的客户。有关更多信息,请参阅 Anycast 和 配置隧道端点。

AWS Transit Gateway 使用等价多路径 (ECMP) 在等价 BGP 路径之间分配流量。BGP 动态交换路由,并在会话失败时撤销路径。此设计避免了 AWS 静态路由 Site-to-Site VPN 连接的主/备限制。

AWS 要求每条隧道使用 /30 隧道内部网络,并且第 1 阶段最长生存时间为 28800 秒。因此本指南使用 /30 隧道寻址和 28800 秒的第 1 阶段生存时间。

架构

总体设计使用以下资源:

  • 一个启用了 VPN ECMP 支持的 AWS Transit Gateway
  • 一张用于工作负载 VPC 以及面向 Cloudflare WAN 的 AWS VPN 附件的专用 Transit Gateway 路由表
  • 一个或多个已连接到 Transit Gateway 的工作负载 VPC
  • 每个已配置的 Cloudflare anycast IP 对应一个 AWS 客户网关
  • 每个客户网关对应一个动态路由 AWS Site-to-Site VPN 连接
  • 每个 VPN 连接包含两条 AWS 托管的 IPsec 隧道以及两条对应的 Cloudflare WAN IPsec 隧道
  • AWS Transit Gateway 与 Cloudflare WAN 之间每条隧道一个 BGP 会话

Terraform 概念验证会创建:

  • 一个恰好包含一个公有工作负载子网的工作负载 VPC
  • 两个位于不同可用区的 Transit Gateway 附件子网
  • 一个用于从公有工作负载子网直接出口的 Internet Gateway
  • 仅将 vpn_routed_prefixes 目的地发送到 Transit Gateway 的选择性路由

它不会创建:

  • 虚拟机或测试主机
  • 独立弹性网络接口 (ENI);AWS 会在连接子网中为 Transit Gateway VPC 连接创建 ENI
  • 安全组
  • 弹性 IP 地址
  • NAT 服务

工作负载子网在启动时会分配公网 IPv4 地址。其路由表仅将 vpn_routed_prefixes 中配置的更具体目的地发送到 Transit Gateway 和 Site-to-Site VPN;其余 IPv4 出口流量沿 0.0.0.0/0 路由前往 Internet Gateway。

Terraform proof of concept: AWS workload VPC 192.168.0.0/16

Public workload subnet 192.168.125.0/24
  Workload route table
    +-- vpn_routed_prefixes (more-specific) --> AWS Transit Gateway ASN 65020
    |                                             |
    |                                VPN connection 1
    |                                        |
    |                                   +----+----+
    |                                   |         |
    |                                Tunnel 1  Tunnel 2
    |                                   |         |
    |                             Cloudflare WAN ASN 13335
    |                                  162.159.135.1
    |
    +-- 0.0.0.0/0 (remaining IPv4) --> Internet Gateway --> Internet

TGW attachment subnets: 192.168.124.0/28 and 192.168.124.16/28

AWS Site-to-Site VPN 连接终止于一个 AWS 客户网关。由于 AWS 客户网关只有一个公网 IP 地址,两条隧道使用相同的 Cloudflare anycast IP。

测试环境

字段 值
云提供商 Amazon Web Services
服务 AWS Transit Gateway 和 AWS Site-to-Site VPN
AWS 区域 美国东部(俄亥俄),us-east-2
路由模式 使用 BGP 的动态路由
AWS Transit Gateway ASN 65020
Cloudflare ASN 13335
anycast IP 数量 两个
VPN 连接数量 两个
IPsec 隧道数量 四条
Terraform AWS provider hashicorp/aws 6.67.0
Terraform Cloudflare provider cloudflare/cloudflare 5.27.0
测试日期 2026 年 10 月

测试环境使用了:

  • 两个租用的 anycast IP
  • 四条 IPsec 隧道
  • 四个 BGP 会话

AWS 在每条已配置隧道上导入了预期的 Cloudflare WAN 路由,Cloudflare 学习到了完整的 AWS VPC 前缀。

本指南中的基线部署使用一个 anycast IP、一个 VPN 连接和两条隧道。它使用与测试环境中第一个 VPN 连接相同的设置。基线并未单独部署;其 Terraform plan 由随附的 terraform test 套件覆盖,该套件使用模拟提供商。

IKE/IPsec 和 BGP 设置

字段 值
流量选择条件 基于路由的 VPN
路由 BGP
隧道转发 主/主,配合 ECMP
IKE 版本 IKEv2
身份验证 预共享密钥
第 1 阶段加密 AES-256-CBC
第 1 阶段完整性 SHA-256
第 1 阶段 DH 组 Group 20
第 1 阶段生存时间 28,800 秒
第 2 阶段加密 AES-256-CBC
第 2 阶段完整性 SHA-256
第 2 阶段 PFS 组 Group 20
第 2 阶段生存时间 3,600 秒
AWS 重放窗口 2,048 个数据包
Cloudflare 重放保护 已启用
NAT 穿越 (NAT-T) 自动
失效对等体检测操作 Restart
隧道启动操作 Start
AWS Transit Gateway ASN 65020
CF Account ASN 13335(默认)
BGP 身份验证 无

AWS Site-to-Site VPN 不支持禁用抗重放保护。请在每条对应的 Cloudflare WAN 隧道上启用重放保护,并使用 AWS 最大重放窗口 2048。重放保护可能会将隧道流量固定到一台 Cloudflare 服务器以保持数据包顺序,从而降低部分 anycast 性能和弹性优势。

预共享密钥要求

配置满足以下 AWS 要求的预共享密钥:

  • 包含 8 到 64 个字符
  • 仅包含字母、数字、句点 (.) 和下划线 (_)
  • 不以 0 开头

在匹配的 AWS 和 Cloudflare WAN 隧道对象上配置相同的 PSK。在 Cloudflare 中,选择 Use my own pre-shared key(使用我自己的预共享密钥) 并输入 AWS 隧道上配置的 PSK。

有关更多信息,请参阅 AWS 文档中的 VpnTunnelOptionsSpecification ↗。

对于 AWS 控制台工作流,可以为每条隧道配置唯一 PSK,或在所有隧道上重用相同 PSK。Terraform 工作流要求每条隧道使用唯一 PSK。

配置设置

Cloudflare WAN 接受每条隧道使用 /31 或 /30 接口地址,并建议使用 /31。有关更多信息,请参阅 配置隧道端点。

AWS Site-to-Site VPN 要求每条隧道使用唯一的 /30 内部隧道网络,因此本指南使用 /30。AWS 将 /30 中第一个可用 IP 地址分配给其隧道侧。因此,请在 Cloudflare WAN 侧配置第二个可用 IP 地址。Cloudflare 支持从 169.254.240.0/20 中选择 AWS 内部隧道网络。

AWS 和 Cloudflare WAN 还要求不同的输入格式:

  • AWS 接受 /30 网络地址作为 Inside IPv4 CIDR(内部 IPv4 CIDR)
  • Cloudflare WAN 要求将其可用主机地址与 /30 前缀长度一起作为 IPv4 interface address(IPv4 接口地址)

不要将 /30 网络地址输入为 Cloudflare 接口地址。在此示例中,AWS 使用 169.254.240.45,Cloudflare WAN 使用 169.254.240.46。基线使用以下两个 /30 网络。

属性 隧道 01/02 隧道 02/02
Cloudflare 隧道名称 AWS_TUN_01 AWS_TUN_02
AWS VPN 连接 VPN 1 VPN 1
AWS 公网 IPv4 地址 <AWS_OUTSIDE_IP_01> <AWS_OUTSIDE_IP_02>
Cloudflare anycast IP 162.159.135.1 162.159.135.1
AWS 内部 IPv4 CIDR 输入 169.254.240.44/30 169.254.240.48/30
AWS 内部 IP 169.254.240.45 169.254.240.49
Cloudflare 接口地址 169.254.240.46/30 169.254.240.50/30
BGP 发起方 AWS AWS
AWS ASN 65020 65020
CF Account ASN 13335 13335
预共享密钥 <TUNNEL_01_PSK> <TUNNEL_02_PSK>

示例 AWS VPC 前缀为 192.168.0.0/16。请将其以及所有尖括号占位符替换为您环境中的值。AWS 为每个 VPN 连接生成两个公网 IPv4 地址。这些值在 AWS 创建连接之前不可用。

假设

本指南假设以下条件:

  • 您的 Cloudflare WAN 账户已启用 Unified Routing 和 BGP over IPsec
  • Cloudflare WAN 账户可以使用 162.159.135.1,并且在使用两个 anycast IP 时也可以使用 172.64.135.1
  • 对于 AWS 控制台路径,已存在 AWS Transit Gateway,且工作负载 VPC 已在至少两个可用区中连接;Terraform 路径会创建这些资源
  • 本示例中的 AWS VPC 前缀为 192.168.0.0/16
  • AWS VPC 前缀与从 Cloudflare WAN 学习到的前缀不重叠
  • 安全组、网络访问控制列表、主机防火墙和 Cloudflare WAN 网络防火墙策略允许所需的应用和测试流量
  • 您可以创建和修改 AWS 客户网关、Site-to-Site VPN 连接、Transit Gateway 路由表、VPC 路由表和 Cloudflare WAN 资源
  • 隧道接口和路由前缀使用 IPv4
  • AWS Transit Gateway ASN 65020 未被另一个 Cloudflare WAN 连接站点使用(AWS 必须学习该站点的路由);否则 BGP 环路防护可能会拒绝这些路由

配置工作流程

  1. 将 AWS Transit Gateway 配置为 ASN 65020 并启用 VPN ECMP。
  2. 创建专用的 Transit Gateway 路由表。
  3. 为 Cloudflare anycast IP 创建一个 AWS 客户网关。
  4. 创建一个使用动态路由的 AWS Site-to-Site VPN 连接。
  5. 使用 Modify VPN tunnel options(修改 VPN 隧道选项) 为每条隧道配置 IKE 版本以及第 1 阶段和第 2 阶段设置。
  6. 创建两条匹配的 Cloudflare WAN IPsec 隧道。
  7. 在每条 Cloudflare 隧道上启用 BGP。
  8. 将 VPC 和 VPN 连接传播到 Transit Gateway 路由表。
  9. 添加指向 Cloudflare WAN 的 VPC 路由。
  10. 验证每条已配置的隧道、BGP 会话和端到端流量。

选择部署方法

除非您有手动配置现有资源的特定要求,否则请使用 Terraform 工作流。在应用之前,请审查针对您的账户和网络生成的 plan。不要对同一部署同时完成两种工作流。

收集 Cloudflare WAN 信息

在创建 AWS 资源之前,收集并验证 Cloudflare 信息。AWS 客户网关使用 Cloudflare anycast IP 作为其公网 IP 地址,因此稍后更改 anycast IP 需要替换对应的 AWS 客户网关和 VPN 连接。

有关 Cloudflare anycast IP 和隧道寻址的更多信息,请参阅 配置隧道端点。

  1. 登录 Cloudflare 仪表板。
  2. 前往 Address Space(地址空间) > Leased IPs(租用的 IP)。
  3. 确认账户拥有基线 IPv4 anycast IP 162.159.135.1。
  4. 前往 Networking(网络) > Routes(路由) > WAN configuration(WAN 配置)。
  5. 确认账户已启用 Unified Routing 以及 IPsec 上的 BGP。
  6. 记录 CF Account ASN。默认值为 13335。
  7. 清点 Unified Routing 数据平面中 AWS 应学习的合格路由。
  8. 检查现有隧道名称和接口地址。

在继续之前记录以下值:

项目 参考值
Cloudflare anycast IP 1 162.159.135.1
Cloudflare anycast IP 2 172.64.135.1
CF Account ASN 13335(默认)
AWS Transit Gateway ASN 65020
AWS VPC 前缀 192.168.0.0/16
预期从 Cloudflare WAN 接收的 RFC 1918 前缀 <EXPECTED_RFC1918_PREFIX_LIST>

默认情况下,Cloudflare WAN 会路由 RFC 1918 地址空间。可路由的公网地址空间可以按前缀逐个启用。如需启用公网前缀,请联系 Cloudflare。

检查现有隧道名称和接口地址

如果新隧道的名称或接口地址与同一 Cloudflare 账户中的另一条隧道匹配,Cloudflare 会拒绝该隧道。AWS Site-to-Site VPN 连接会在 Cloudflare 隧道之前创建,因此冲突只有在 AWS 资源已存在后才会显现。在选择隧道名称和内部 /30 CIDR 之前,请列出已在使用的名称和接口地址。

在 Cloudflare 仪表板中,前往 Connectors(连接器) 页面并查看 IPsec/GRE tunnels(IPsec/GRE 隧道) 选项卡。或者,使用可读取 Cloudflare WAN 配置的 API token 运行以下命令:

curl -s -H "Authorization: Bearer $CLOUDFLARE_API_TOKEN" "https://api.cloudflare.com/client/v4/accounts/<CLOUDFLARE_ACCOUNT_ID>/magic/ipsec_tunnels" | jq -r '.result.ipsec_tunnels[] | "\(.interface_address)\t\(.name)"' | sort
curl -s -H "Authorization: Bearer $CLOUDFLARE_API_TOKEN" "https://api.cloudflare.com/client/v4/accounts/<CLOUDFLARE_ACCOUNT_ID>/magic/gre_tunnels" | jq -r '.result.gre_tunnels[] | "\(.interface_address)\t\(.name)"' | sort

选择未出现在输出中的隧道名称。对于每条隧道,在 169.254.240.0/20 内选择一个不包含任何已列出接口地址的内部 /30 CIDR。本指南中的参考值(169.254.240.44/30 到 169.254.240.56/30)仅为示例;如果已被占用(例如被此配置的另一次部署占用),请替换它们。

配置 AWS Transit Gateway

验证 Transit Gateway 选项

  1. 登录 AWS Management Console 并打开 VPC。
  2. 前往 Transit gateways > Transit gateways。
  3. 选择工作负载 VPC 使用的 Transit Gateway。
  4. 确认以下设置:
Transit Gateway 选项 值
Amazon side ASN 65020
VPN ECMP support Enabled
DNS support Enabled

本指南使用 65020 作为示例私有 ASN。请选择其他 Cloudflare WAN 连接站点未使用的 ASN,并避免使用 AWS 默认值 64512。有关更多信息,请参阅 AS 路径环路防御。

仅当 Transit Gateway 没有 VPN、Direct Connect 网关、Connect、VPN Concentrator 或 Client VPN 连接时,AWS 才允许更改 Amazon 侧 ASN。要更改它,请运行以下命令:

aws ec2 modify-transit-gateway --transit-gateway-id <AWS_TGW_ID> --options AmazonSideAsn=65020

如果 Transit Gateway 已具有其中一种连接,请保留其当前 ASN,在本指南中替换该 ASN,并在 Cloudflare 中将相同值配置为 Customer device ASN(客户设备 ASN)。确认没有其他 Cloudflare WAN 连接站点使用该 ASN。

验证工作负载 VPC 附件

  1. 前往 Transit gateways > Transit gateway attachments。
  2. 确认工作负载 VPC 具有到 Transit Gateway 的可用 VPC 连接。
  3. 确认连接子网至少存在于两个可用区中。

创建专用 Transit Gateway 路由表

与 AWS VPN 连接关联的路由表决定 AWS 通过该 Site-to-Site VPN 连接通告哪些路由。使用专用路由表,以免将不相关的 VPC、Site-to-Site VPN 和 Direct Connect 路由导出到 Cloudflare WAN。

  1. 前往 Transit gateways > Transit gateway route tables。
  2. 选择 Create transit gateway route table。
  3. 在 Transit gateway ID 中,选择 <AWS_TGW_ID>。
  4. 添加描述性 Name 标签,例如 cloudflare-wan-routing。
  5. 选择 Create transit gateway route table。
  6. 将其 ID 记录为 <AWS_TGW_ROUTE_TABLE_ID>。

创建 AWS 客户网关

  1. 前往 Virtual private network (VPN) > Customer gateways。

  2. 选择 Create customer gateway。

  3. 配置以下值:

    AWS 字段 值
    Name tag cloudflare-wan-anycast-01
    BGP ASN CF Account ASN(默认为 13335)
    IP address 162.159.135.1
    Certificate ARN 留空
    Device cloudflare-wan-anycast-01
  4. 选择 Create customer gateway。

  5. 将生成的客户网关 ID 记录为 <AWS_CUSTOMER_GATEWAY_01_ID>。

创建 AWS Site-to-Site VPN 连接

  1. 前往 Virtual private network (VPN) > Site-to-Site VPN connections。

  2. 选择 Create VPN connection。

  3. 配置以下值:

    AWS 字段 值
    Name tag cloudflare-wan-bgp-01
    Target gateway type Transit gateway
    Transit gateway <AWS_TGW_ID>
    Customer gateway Existing
    Customer gateway ID <AWS_CUSTOMER_GATEWAY_01_ID>
    Routing options Dynamic (requires BGP)
    Local IPv4 network CIDR 0.0.0.0/0
    Remote IPv4 network CIDR 0.0.0.0/0
    Tunnel inside IP version IPv4

    本地和远程网络 CIDR 字段是 IKE 流量选择器。基于路由的转发由 Transit Gateway 路由表和 BGP 控制,而不是由这些宽泛的选择器控制。

  4. 选择 Create VPN connection。

  5. 等待连接状态变为 Available(可用)。

  6. 将 VPN 连接 ID 记录为 <AWS_VPN_CONNECTION_01_ID>。

记录 AWS 资源 ID

保留将生成的 AWS 资源映射到其 Cloudflare 角色的部署记录:

资源 记录值
Transit Gateway <AWS_TGW_ID>
专用 Transit Gateway 路由表 <AWS_TGW_ROUTE_TABLE_ID>
工作负载 VPC 连接 <AWS_VPC_ATTACHMENT_ID>
162.159.135.1 的客户网关 <AWS_CUSTOMER_GATEWAY_01_ID>
162.159.135.1 的 VPN 连接 <AWS_VPN_CONNECTION_01_ID>

根据组织标准,使用描述性名称、环境、所有者和变更管理引用来标记每个 AWS 资源。

配置 AWS VPN 隧道

AWS 为每个 VPN 连接分配两个公网 IPv4 地址。请配置两条隧道;不要将第二条隧道保留为默认设置。

配置隧道 01

  1. 选择 <AWS_VPN_CONNECTION_01_ID>。
  2. 打开 Tunnel details(隧道详细信息) 并将第一个 Public IPv4 address(公网 IPv4 地址) 记录为 <AWS_OUTSIDE_IP_01>。
  3. 选择 Actions > Modify VPN tunnel options。
  4. 为 VPN tunnel outside IP address(VPN 隧道外部 IP 地址) 选择 <AWS_OUTSIDE_IP_01>。
  5. 配置以下选项。移除其他算法选项,以免 AWS 协商意外提议。
AWS 选项 值
Inside IPv4 CIDR 169.254.240.44/30
Pre-shared key 输入满足 AWS 要求的 PSK,并将其记录为 <TUNNEL_01_PSK>
Phase 1 encryption algorithms AES256
Phase 2 encryption algorithms AES256
Phase 1 integrity algorithms SHA2-256
Phase 2 integrity algorithms SHA2-256
Phase 1 DH group numbers 20
Phase 2 DH group numbers 20
IKE versions ikev2
Replay window size 2048
DPD timeout action Restart
Startup action Start

将第 1 阶段生存时间保持为 28800 秒,将第 2 阶段生存时间保持为 3600 秒,然后选择 Save changes(保存更改)。

AWS 仅在 IKEv2 下支持 Start 启动操作。Cloudflare 仅响应 IKE,从不发起 IKE,因此 AWS 必须发起每条隧道。

配置隧道 02

对第二个公网 IPv4 地址和隧道特定值重复上述过程:

隧道 VPN 连接 内部 IPv4 CIDR 预共享密钥
02 <AWS_VPN_CONNECTION_01_ID> 169.254.240.48/30 <TUNNEL_02_PSK>

将公网 IPv4 地址记录为 <AWS_OUTSIDE_IP_02>。在两条隧道上使用相同的 IKE、IPsec、DPD、重放窗口、生存时间和启动设置。为每条隧道配置符合 预共享密钥要求 的 PSK。隧道可以共享 PSK。

创建 Cloudflare WAN IPsec 隧道

AWS 为每条 VPN 隧道分配一个公网 IPv4 地址,并自动将该地址用作 IKE ID。AWS 不允许更改 IKE ID。Cloudflare WAN 将此 AWS 地址称为 Customer endpoint(客户端点)。虽然 Customer endpoint 在 Cloudflare WAN IPsec 隧道配置中通常是可选的,但此集成为必填项,以便与 AWS 出示的 IKE ID 匹配。

请先创建 AWS VPN 连接以获取其两个公网 IPv4 地址。由于每个 AWS VPN 连接包含两条隧道,基线需要两条对应的 Cloudflare WAN IPsec 隧道。

有关常规 Cloudflare WAN 隧道配置指导和字段定义,请参阅 配置隧道端点。

  1. 在 Cloudflare 仪表板中,转到 Connectors(连接器) 页面。
  2. 在 IPsec/GRE tunnels(IPsec/GRE 隧道) 选项卡中,选择 Create a tunnel(创建隧道)。
  3. 在 Add tunnels(添加隧道) 页面上,选择 IPsec tunnel(IPsec 隧道)。
  4. 使用以下值创建两条隧道:
属性 AWS_TUN_01 AWS_TUN_02
IPv4 interface address(IPv4 接口地址) 169.254.240.46/30 169.254.240.50/30
Customer endpoint(客户端点) <AWS_OUTSIDE_IP_01> <AWS_OUTSIDE_IP_02>
Cloudflare anycast IP 162.159.135.1 162.159.135.1
Pre-shared key(预共享密钥) <TUNNEL_01_PSK> <TUNNEL_02_PSK>
Tunnel health checks(隧道健康检查) Enabled(已启用) Enabled(已启用)
Health check rate(健康检查频率) Medium(中) Medium(中)
Health check type(健康检查类型) Request(请求) Request(请求)
Health check direction(健康检查方向) Bidirectional(双向) Bidirectional(双向)
Health check target(健康检查目标) Default(默认,不显示) Default(默认,不显示)
Replay protection(重放保护) Enabled(已启用) Enabled(已启用)
Automatic return routing(自动回程路由) Disabled(已禁用) Disabled(已禁用)

隧道名称和接口地址在 Cloudflare 账户内必须唯一。如果另一条隧道已使用其中一个名称或接口地址,请为匹配的 AWS 隧道选择不同的名称或不同的内部 /30 CIDR。

将每个 <AWS_OUTSIDE_IP_XX> 占位符替换为匹配 AWS 隧道显示的地址。按 VPN 连接和内部 IPv4 CIDR 匹配隧道,而不是通过比较或排序生成的公网 IP 地址。

为每条隧道选择 Use my own pre-shared key(使用我自己的预共享密钥),并输入匹配 AWS 隧道上配置的 PSK。此集成使用 IP 地址 IKE 身份;请勿使用 Cloudflare 生成的 FQDN 身份工作流。Cloudflare 通过 Customer endpoint(客户端点) 将 IP 地址 IKE 身份匹配到隧道,因此每条 Cloudflare 隧道必须使用唯一的 Customer endpoint 值。

验证隧道与 VPN 的配对

在保存每条隧道之前,将这些隧道特定值作为一组进行验证:

  • AWS VPN 连接 ID
  • 用作 Cloudflare Customer endpoint(客户端点) 的 AWS Public IPv4 address(公网 IPv4 地址)
  • 内部 /30 CIDR 和 Cloudflare 接口地址
  • AWS 客户网关使用的 Cloudflare anycast IP
  • 匹配的预共享密钥

验证健康检查设置

Cloudflare 健康检查独立于 IKE、IPsec 和 BGP 状态测试可达性。为每条隧道精确配置以下值:

健康检查字段 值
Rate(频率) Medium(中)
Type(类型) Request(请求)
Direction(方向) Bidirectional(双向)
Target(目标) Default(默认)

仅当 Health check direction(健康检查方向) 为 Unidirectional(单向) 时,仪表板才会显示 Health check target(健康检查目标)。选择 Bidirectional(双向) 时,该字段会隐藏并应用默认目标,因此无需操作。请勿通过 API 或 Terraform 设置自定义目标。

默认目标是隧道 /30 中的另一个可用地址,即 AWS 内部地址。例如,对于 Cloudflare 接口地址 169.254.240.46/30,Cloudflare 会将健康检查发送到 169.254.240.45。健康的 IPsec 安全关联本身并不能证明健康检查或 BGP 会话正在工作。

有关更多信息,请参阅 隧道健康检查。

在 Cloudflare WAN 中配置 BGP

BGP over IPsec 需要 Unified Routing。AWS 发起每个 BGP 会话;Cloudflare 不发起 BGP 对等。

记录 CF Account ASN

  1. 前往 Networking(网络) > Routes(路由)。
  2. 选择 WAN configuration(WAN 配置)。
  3. 记录 CF Account ASN。

CF Account ASN 默认为 13335,可更改为 64512 到 65534 范围内的私有 ASN。它应用于 Cloudflare 账户中的每个 BGP 会话,并且必须与 AWS Transit Gateway ASN 不同。本指南使用 13335 作为参考值。如果您的账户使用不同的 CF Account ASN,请在本指南显示 13335 的所有位置使用该值,包括每个 AWS 客户网关的 BGP ASN。

有关更多信息,请参阅 配置路由。

在每条隧道上启用 BGP

对于 AWS_TUN_01 和 AWS_TUN_02:

  1. 在 Cloudflare 仪表板中,转到 Connectors(连接器) 页面。
  2. 在 IPsec/GRE tunnels(IPsec/GRE 隧道) 中找到该隧道。
  3. 选择隧道旁的三点菜单,然后选择 Configure BGP(配置 BGP)。
  4. 对于 Customer device ASN(客户设备 ASN),输入 65020。
  5. 将 MD5 key(MD5 密钥) 留空。AWS Site-to-Site VPN 不提供匹配的 BGP MD5 配置选项。
  6. 将 Additional advertised prefix list(额外通告前缀列表) 留空,除非 AWS 必须接收 Unified Routing 数据平面中尚不符合条件的额外路由。
  7. 选择 Save(保存)。

将 Additional advertised prefix list(额外通告前缀列表) 留空并不会将通告限制为零路由。Cloudflare 仍会从 Unified Routing 数据平面通告符合条件的路由。在启用 BGP 之前清点这些路由,并按照 阻止不需要的前缀 所述阻止 AWS 不得使用的任何前缀。在本指南全程使用的分流出口设计中,AWS 不得学习 0.0.0.0/0;仅在 前缀控制 所述的可选 Cloudflare Gateway 出口设计中通告该前缀。

Cloudflare 通过隧道与 AWS 内部 IP 建立对等。AWS 与对应的 Cloudflare 接口地址建立对等。生成的会话如下:

隧道 AWS BGP 地址 Cloudflare BGP 地址
AWS_TUN_01 169.254.240.45 169.254.240.46
AWS_TUN_02 169.254.240.49 169.254.240.50

不要为 192.168.0.0/16 创建 Cloudflare WAN 静态路由。Cloudflare 通过 BGP 从 AWS 学习 VPC 前缀。

了解路由交换

两个路由方向使用不同的来源:

方向 路由来源 控制点
AWS 到 Cloudflare 与每个 VPN 连接关联的 Transit Gateway 路由表中的路由 专用路由表和连接传播
Cloudflare 到 AWS Unified Routing 数据平面中的符合条件路由以及隧道特定的额外通告前缀 Cloudflare 路由清单和 Additional advertised prefix list(额外通告前缀列表)

AWS 在每个已建立的 BGP 会话上通告已传播的 VPC 前缀。因此 Cloudflare 可以保留等价路径,并仅撤销受失败会话影响的路径。默认情况下,AWS 会从 Cloudflare WAN 学习 RFC 1918 前缀,以及为账户显式启用的任何可公开路由前缀。当 BGP 属性等价时,AWS 可以安装等价路径。

配置 AWS Transit Gateway 路由

该示例传播并导出完整的 192.168.0.0/16 VPC CIDR。它还将通过 VPN 连接学习到的所有前缀传播到专用 Transit Gateway 路由表。

关联附件

  1. 前往 Transit gateways > Transit gateway route tables。
  2. 选择 <AWS_TGW_ROUTE_TABLE_ID>。
  3. 打开 Associations(关联)。
  4. 确认工作负载 VPC 连接和每个已配置的 VPN 连接都与此路由表关联。
  5. 如果连接未关联,请选择 Create association(创建关联),选择该连接,并创建关联。
  6. 确认没有不相关的连接与此路由表关联。

一个连接只能与一个 Transit Gateway 路由表关联。移动现有工作负载连接可能会更改其转发行为;在更改关联之前,请确保专用表包含工作负载所需的每条路由。

启用 VPC 路由传播

  1. 打开 <AWS_TGW_ROUTE_TABLE_ID> 的 Propagations(传播)。
  2. 选择 Create propagation。
  3. 选择工作负载 VPC 连接并创建传播。
  4. 确认 192.168.0.0/16 显示为已传播路由。

AWS 通过每个已建立的 BGP 会话将已传播的 VPC CIDR 通告给 Cloudflare。

启用 VPN 路由传播

  1. 打开 <AWS_TGW_ROUTE_TABLE_ID> 的 Propagations(传播)。
  2. 选择 Create propagation。
  3. 选择 VPN 连接并创建传播。

已传播路由是 AWS 通过 BGP 从 Cloudflare 学习到的前缀。当同一前缀以等价 BGP 属性通过多条隧道到达时,Transit Gateway 可以安装等价路径并使用 ECMP。

配置工作负载子网路由

对于与工作负载子网关联的每个 VPC 路由表:

  1. 前往 Virtual private cloud > Route tables。
  2. 选择工作负载子网路由表。
  3. 选择 Routes > Edit routes。
  4. 对于应经过 Cloudflare WAN 的每个已批准目的地前缀,添加以 <AWS_TGW_ID> 为目标的路由。
  5. 保持任何现有 0.0.0.0/0 路由不变。
  6. 保存更改。

这会生成与 Terraform 参考部署相同的分流出口设计:已批准前缀使用 Transit Gateway,现有默认路由继续通过 Internet Gateway 或 NAT 网关承载 Internet 流量。AWS 最长前缀匹配会选择比默认路由更具体的路由。仅添加 Cloudflare 通告的已批准清单中的前缀;不要添加与 VPC CIDR 重叠的路由。

检查安全控制

确认以下控制允许预期流量:

  • 工作负载安全组
  • 子网网络访问控制列表
  • 主机防火墙
  • Cloudflare WAN 网络防火墙策略

AWS 管理 Site-to-Site VPN 隧道的 UDP 500、UDP 4500 和 ESP 连接。这些协议不需要工作负载安全组中的规则。

BGP 设计注意事项

本节仅介绍将 AWS Transit Gateway 与 Cloudflare WAN 结合时特有的 BGP 行为。

BGP 定时器与收敛

AWS 为每条隧道设置 BGP 保持时间,且无法更改。Cloudflare 通告 240 秒并使用较小值,因此应用 AWS 值。Cloudflare 要求保持时间至少为 30 秒。Terraform 在 cloudflare_tunnel_mapping 输出中将 AWS 值报告为 aws_bgp_holdtime。

会话中断后,Cloudflare 会在几分钟内传播路由撤销。在 Edge Resiliency Mode(边缘弹性模式)中,只要隧道健康检查通过,Cloudflare 数据中心就会继续按上次已知路由转发,因此健康隧道上的 BGP 故障可能不会立即撤销该路径。

有关更多信息,请参阅 BGP 路由分发和收敛、BGP 计时器和设置 以及 Edge Resiliency Mode。

AS 路径环路防御

Cloudflare 保留 Cloudflare WAN 站点之间的原始 AS 路径,而 AWS Transit Gateway 没有 allowas-in 选项。AWS 会静默拒绝来自使用 Transit Gateway ASN 的任何其他 Cloudflare WAN 站点的路由。为每个站点提供唯一 ASN,并且不要使用 AWS 默认值:Transit Gateway 和虚拟专用网关为 64512,客户网关为 65000。

前缀控制

Cloudflare 通告 Unified Routing 数据平面中的每条符合条件的路由,以及 Additional advertised prefix list(额外通告前缀列表) 中的任何条目。将该列表留空并不会限制 Cloudflare 通告的内容。AWS 从每个 VPN 连接最多接受 1,000 条路由,最多通告 5,000 条;这两个配额均不可调整。

仅当工作负载路由表也将 0.0.0.0/0 发送到 Transit Gateway 时,向 AWS 通告 0.0.0.0/0 才会通过 Cloudflare Gateway 发送 Internet 流量。Terraform 参考部署不使用此设计。

阻止不需要的前缀

要阻止 AWS 使用某个前缀,请将其从 Cloudflare 通告中移除(Networking(网络) > Routes(路由) 下的静态路由,或 Additional advertised prefix list(额外通告前缀列表) 条目),或在 <AWS_TGW_ROUTE_TABLE_ID> 中为精确 CIDR 添加黑洞静态路由。Transit Gateway 静态路由优先于同一 CIDR 的 VPN 传播路由,但不优先于更具体的路由。Cloudflare 通过 BGP 从其他站点学习到的路由只能在源站点撤销或在 AWS 中阻止。在采用 Cloudflare Gateway 出口之前,请移除任何 0.0.0.0/0 黑洞路由。

有关更多信息,请参阅 AWS 文档中的 Route evaluation order ↗。

MSS 和 MTU

有关 Cloudflare WAN 指导,请参阅 最大传输单元和最大分段大小。

IPsec 封装会减小可用数据包大小。Cloudflare 建议 IPsec 隧道的最大 TCP MSS 钳制为 1360 字节。该值低于 AWS 为 AES-CBC 与 SHA-256 以及 NAT-T 列出的 1382 字节 MSS,因此与本指南中的密码套件兼容。AWS Site-to-Site VPN 不提供按 VPN 的 MSS 钳制控制,因此必要时请在流量路径中的设备或工作负载上应用钳制。

AWS Site-to-Site VPN 不支持路径 MTU 发现。请使用受控数据包大小和 Don't Fragment (DF) 测试来验证大型 TCP 流。在受支持的情况下,请在加密前分片数据包或应用 MSS 钳制,而不是依赖路径 MTU 发现。

验证

验证 AWS 隧道和 BGP 状态

对于每个 VPN 连接:

  1. 在 AWS VPC 控制台中,转到 Site-to-Site VPN connections。
  2. 选择 VPN 连接。
  3. 打开 Tunnel details(隧道详细信息)。
  4. 确认两条隧道均显示 UP。
  5. 确认已接受路由计数与预期的 Cloudflare WAN 前缀清单匹配。

UP 隧道确认 IKE 和 IPsec 状态,而不是 BGP 有限状态机状态。请在 Cloudflare BGP 状态视图中确认每个会话为 Established(已建立)。正的已接受路由计数确认路由交换,但已建立的会话可以合理地具有零条已接受路由。

您还可以使用 AWS CLI 验证已配置的隧道:

aws ec2 describe-vpn-connections --vpn-connection-ids <AWS_VPN_CONNECTION_01_ID> --query 'VpnConnections[].{VpnId:VpnConnectionId,Tunnels:VgwTelemetry[].{OutsideIP:OutsideIpAddress,Status:Status,ImportedRoutes:AcceptedRouteCount,Message:StatusMessage}}' --output table --no-cli-pager

预期结果:

  • 每条已配置隧道报告 UP
  • 当正在通告路由时,AcceptedRouteCount 与预期的 Cloudflare WAN 前缀匹配且大于零

该命令报告隧道遥测和已接受路由计数;它不公开显式 BGP 会话状态。使用 Cloudflare BGP 状态视图验证每个已配置会话当前已建立。

验证 Transit Gateway 路由

  1. 前往 Transit gateways > Transit gateway route tables。
  2. 选择 <AWS_TGW_ROUTE_TABLE_ID> 并打开 Routes(路由)。
  3. 确认 192.168.0.0/16 是指向工作负载 VPC 连接的活动传播路由。
  4. 确认预期的 RFC 1918 前缀以及任何显式启用的公网前缀作为通过 VPN 连接传播的路由出现。
  5. 当预期使用 ECMP 时,确认等价的 Cloudflare WAN 路由具有多条等价路径。

枚举确切的活动 Transit Gateway 路由,并将每个 CIDR 和连接与已批准的前缀清单进行比较:

aws ec2 search-transit-gateway-routes --transit-gateway-route-table-id <AWS_TGW_ROUTE_TABLE_ID> --filters Name=state,Values=active --max-results 1000 --query '{AdditionalRoutesAvailable:AdditionalRoutesAvailable,Routes:Routes[].{CIDR:DestinationCidrBlock,Type:Type,State:State,Attachments:TransitGatewayAttachments[].TransitGatewayAttachmentId}}' --output json --no-cli-pager

如果 AdditionalRoutesAvailable 为 true,则结果不完整。对每个已批准前缀运行更窄的搜索,并调查已批准清单未覆盖的任何路由。

验证 Cloudflare 隧道和路由状态

  1. 在 Cloudflare 仪表板中,转到 Networking(网络) > Insights(洞察) > Network health(网络运行状况) > IPsec/GRE tunnels and interconnects(IPsec/GRE 隧道和互连)。
  2. 确认每条已配置隧道均正常。
  3. 检查每条隧道的 BGP 状态,并确认每个已配置会话为 Established(已建立)。
  4. 前往 Networking(网络) > Routes(路由)。
  5. 确认通过 AWS BGP 会话学习到 192.168.0.0/16。
  6. 检查可用路由路径,并确认预期隧道贡献路径。
  7. 确认完整的 AWS VPC 前缀存在,并且未通告不相关的 AWS 前缀。

测试端到端连接

  1. 在可用的情况下启动数据包捕获或流日志查询。
  2. 从 192.168.125.0/24 中获准的 AWS 工作负载 ping 或连接到从 Cloudflare WAN 学习到的前缀中的主机。
  3. 从 Cloudflare WAN 连接的网络向 AWS 工作负载测试反向方向。
  4. 确认应用流量未被意外转换。
  5. 在维护窗口期间,禁用一条隧道并确认其 BGP 路径被撤销,同时流量继续通过另一条隧道。允许每侧最多使用协商的 BGP 保持时间来声明会话中断,再加上最多几分钟供 Cloudflare 传播撤销。请参阅 BGP 计时器和收敛。

同时确认每个已批准目的地前缀(Terraform 中的 vpn_routed_prefixes)使用 Transit Gateway,并且不匹配的 IPv4 目的地仍使用现有 Internet Gateway 或 NAT 网关默认路由。AWS 最长前缀匹配使已配置的 VPN 路由优先于 0.0.0.0/0。测试直接 Internet 出口需要具有公网 IPv4 地址的工作负载或 NAT 网关路径;Terraform 概念验证不会创建工作负载或 NAT 服务。

故障排除

所有隧道都关闭

  • 确认每个 AWS 客户网关 IP 与其配置的 Cloudflare anycast IP 匹配
  • 确认 Startup action(启动操作) 为 Start;Cloudflare 仅响应 IKE,从不发起 IKE
  • 验证已启用的提议为 IKEv2、AES-256-CBC、SHA-256 和 DH group 20
  • 确认每个预共享密钥与对应的 AWS 公网 IPv4 地址和 Cloudflare WAN 隧道匹配
  • 查看 Cloudflare 隧道健康事件

一条隧道关闭

  • 确认 Cloudflare Customer endpoint(客户端点) 包含为该特定 VPN 隧道生成的 AWS Public IPv4 address(公网 IPv4 地址)
  • 验证内部 /30、AWS 公网 IPv4 地址和预共享密钥不是从另一条隧道复制的
  • 确认每个内部 CIDR 唯一且位于 169.254.240.0/20 内
  • 确认 Cloudflare 中已启用重放保护,且 AWS 重放窗口为 2048
  • 确认 DPD timeout action(DPD 超时操作) 为 Restart

IPsec 已建立但 BGP 关闭

  • 确认 AWS 客户网关 BGP ASN 与 CF Account ASN 匹配
  • 确认对应 Cloudflare WAN 隧道上的 Customer device ASN(客户设备 ASN) 为 65020
  • 确认每条 Cloudflare WAN 隧道都已启用 BGP
  • 确认 Cloudflare 接口地址与 AWS /30 中的第二个可用地址匹配
  • 确认 Cloudflare 中未配置 BGP MD5 密钥
  • 确认 AWS 向 Cloudflare 接口地址发起 TCP 端口 179

按如下方式解释报告的 BGP 状态:

状态 含义 主要检查
Established 会话正在交换路由 验证已接收和已通告的前缀清单
Active 对等体正在重试连接 检查对等体地址、ASN 和 TCP 端口 179 可达性
Connect TCP 连接正在进行 检查隧道可达性和 Cloudflare 接口地址
Idle 会话未尝试连接 确认已启用 BGP 且 AWS 配置为发起连接

BGP 已建立但缺少路由

  • 确认每个已配置的 VPN 连接在预期的 Transit Gateway 路由表中启用了传播
  • 确认工作负载 VPC 连接已与该表关联并传播到该表
  • 确认 192.168.0.0/16 作为传播到 VPC 连接的 Transit Gateway 路由存在
  • 检查 BGP 环路防护是否拒绝包含 ASN 65020 的路由
  • 确认预期的 Cloudflare WAN 路由在 Unified Routing 数据平面中符合条件
  • 检查是否存在更改转发结果的路由过滤器或更具体的路由

路由存在但流量不通

  • 双向检查工作负载子网路由表、Transit Gateway 路由表和 Cloudflare WAN 路由表
  • 确认安全组、网络访问控制列表、主机防火墙和 Cloudflare WAN 网络防火墙策略允许该流量
  • 检查重叠或更具体的路由
  • 如果已启用,请查看 VPC Flow Logs 和 Transit Gateway Flow Logs
  • 确认源和目的地前缀未被意外转换

在全部三层转发层跟踪该路由:

  1. 工作负载子网路由表必须将目的地前缀发送到 Transit Gateway。
  2. 专用 Transit Gateway 路由表必须通过 VPN 连接发送目的地。
  3. Cloudflare WAN 必须具有从 AWS BGP 会话学习到的 192.168.0.0/16 回程路由。

如果仅一个方向有效,请在流日志中比较源和目的地前缀,并确认回程路由存在,而不是假设 IPsec 隧道是原因。

隧道健康状况降级但 IPsec 已建立

  • 确认健康检查频率为 Medium(中)、类型为 Request(请求)、方向为 Bidirectional(双向)
  • 确认未设置自定义健康检查目标;目标应为同一 /30 中的 AWS 内部地址
  • 验证 Cloudflare 接口和 AWS 内部地址属于同一 /30
  • 确认对应的 AWS 隧道使用预期的内部 CIDR
  • 检查网络策略是否阻止发往 AWS 隧道内部地址的 ICMP

流量使用的隧道少于预期

  • 确认 Transit Gateway 上已启用 VPN ECMP 支持
  • 确认每条已配置的 IPsec 隧道和 BGP 会话均已启动
  • 确认每条隧道以等价 BGP 属性通告相同前缀
  • 确认每个已配置的 VPN 连接已关联并传播到专用路由表
  • 请记住 ECMP 分发的是流而不是单个数据包;少量测试流可能不会使用每条隧道

AWS 或 Cloudflare 中出现意外前缀

  • 审核专用 Transit Gateway 路由表中的每条路由和传播
  • 确认工作负载 VPC 连接和每个已配置的 VPN 连接均已传播
  • 确认没有不相关的连接传播到专用表
  • 查看 Unified Routing 数据平面中的符合条件路由清单以及每条隧道的 Additional advertised prefix list(额外通告前缀列表)
  • 在源处移除意外路由,而不是依赖更不具体的路由来覆盖它

小数据包正常但应用程序失败

  • 不要依赖路径 MTU 发现,AWS Site-to-Site VPN 不支持该功能
  • 使用受控数据包大小和 DF 位测试来识别有效路径 MTU
  • 在架构允许的情况下应用不超过 1360 字节的 TCP MSS 钳制
  • 检查 ICMP fragmentation-needed 消息是否被过滤

设计说明

  • 每个 AWS Site-to-Site VPN 连接在不同的 AWS 可用区中提供两条隧道
  • AWS 不支持创建单隧道 Site-to-Site VPN 连接;两条隧道使用相同的客户网关,因此使用相同的 Cloudflare anycast IP
  • 基线 VPN 连接通过一个 Cloudflare anycast IP 提供两条路径;第二个 anycast IP 会添加第二个 VPN 连接和另外两条路径
  • AWS 要求 /30 内部隧道网络,因此此集成无法使用 Cloudflare 为其他设备推荐的 /31 接口地址
  • 启用 VPN ECMP 支持时,AWS Transit Gateway 可以在等价 BGP 路径上使用 ECMP
  • Cloudflare 会自动撤销从失败 BGP 会话学习到的路由,同时等价路径仍可通过健康会话使用
  • 标准 AWS Site-to-Site VPN 隧道支持 AWS 公布的每隧道带宽限制;Transit Gateway 还在符合条件的区域支持 Large Bandwidth Tunnels,但在使用该选项之前请验证 Cloudflare 互操作性和商业要求
  • 修改 AWS VPN 隧道选项可能会中断该隧道数分钟
  • 为每条隧道配置 8-64 个字符的 PSK,仅包含字母、数字、句点和下划线;PSK 不能以 0 开头,控制台配置的隧道可以使用唯一 PSK 或在所有隧道上重用一个 PSK,而 Terraform 工作流要求每条隧道使用唯一 PSK

摘要

主拓扑通过以下项连接 AWS Transit Gateway:

  • 一个 Cloudflare anycast IP
  • 一个 AWS 客户网关
  • 一个 AWS Site-to-Site VPN 连接
  • 两条 IPsec 隧道和两个 BGP 会话

对于每个已配置的 anycast IP,Terraform 工作流需要:

  • 恰好两个唯一的 /30 隧道 CIDR
  • 恰好两个兼容 AWS 的预共享密钥

配置记录

在实施和交接期间使用此表。不要在文档中记录预共享密钥值。

占位符 说明
<AWS_TGW_ID> Transit Gateway ID
<AWS_TGW_ROUTE_TABLE_ID> 与工作负载和 VPN 连接关联的专用路由表
<AWS_VPC_ATTACHMENT_ID> 工作负载 VPC 连接 ID
<AWS_CUSTOMER_GATEWAY_01_ID> 代表 162.159.135.1 的客户网关
<AWS_VPN_CONNECTION_01_ID> 使用 162.159.135.1 的 VPN 连接
<AWS_OUTSIDE_IP_01> VPN 1、隧道 1 的 AWS 公网 IPv4 地址
<AWS_OUTSIDE_IP_02> VPN 1、隧道 2 的 AWS 公网 IPv4 地址
<TUNNEL_01_PSK> 和 <TUNNEL_02_PSK> 隧道 01 和 02 的预共享密钥
<EXPECTED_RFC1918_PREFIX_LIST> AWS 预期从 Cloudflare WAN 学习的 RFC 1918 前缀

完成的记录应使运维人员能够将 AWS 隧道告警、Cloudflare 隧道健康事件、BGP 会话和路由表路径关联起来,而无需猜测哪些资源属于一起。

Terraform 参考部署

自包含的 Terraform 配置会创建一个最简概念验证,其中包含:

  • 一个工作负载 VPC
  • 一个公网工作负载子网
  • 两个位于不同可用区的 Transit Gateway 连接子网
  • 一个 Internet Gateway
  • 一个带分流出口路由的工作负载路由表
  • 一个 Transit Gateway 和一个专用 Transit Gateway 路由表
  • 一个 VPC 连接
  • 每个已配置 anycast IP 一个客户网关和一个 Site-to-Site VPN 连接
  • 每个 VPN 连接两条 AWS IPsec/BGP 隧道
  • 每个 VPN 连接两条启用 BGP 的匹配 Cloudflare WAN 隧道
  • 所需的 Transit Gateway 路由表关联和传播

该配置不会创建:

  • 虚拟机或测试主机
  • 独立弹性网络接口 (ENI);AWS 会在连接子网中为 Transit Gateway VPC 连接创建 ENI
  • 安全组
  • 弹性 IP 地址
  • NAT 网关或其他 NAT 服务
  • Cloudflare 路由
  • Cloudflare 网络防火墙策略

AWS 为每个 VPN 连接分配两个公网 IPv4 地址,用作 Cloudflare Customer endpoint(客户端点) 值。

该部署将完整 VPC CIDR 传播到 Transit Gateway 路由表以通告给 Cloudflare,并将从 Cloudflare 学习到的所有路由传播到该表。在 VPC 工作负载路由表中,每个已配置的 vpn_routed_prefixes 目的地是指向 Transit Gateway 和 Site-to-Site VPN 的更具体路由,而 0.0.0.0/0 将所有剩余 IPv4 出口直接通过 Internet Gateway 发送。当两者都匹配时,AWS 最长前缀匹配会选择已配置的 VPN 路由而不是 Internet 默认路由。

工作负载子网在启动时启用公网 IPv4 分配,但此配置不会创建用于接收地址的工作负载。直接 Internet Gateway 出口要求工作负载 ENI 上具有公网 IPv4 地址以及适当的安全控制;Internet Gateway 不为仅私网主机提供 NAT。

参考部署布局

资源 参考值
AWS Region us-east-2
VPC CIDR 192.168.0.0/16
公网工作负载子网 192.168.125.0/24
Transit Gateway 连接子网 A 192.168.124.0/28
Transit Gateway 连接子网 B 192.168.124.16/28
VPN 路由前缀示例 172.16.0.0/16
剩余 IPv4 出口 Internet Gateway
AWS Transit Gateway ASN 65020
CF Account ASN 13335(默认)
Cloudflare anycast IP 1 162.159.135.1

基线参考布局使用一个 anycast IP。

Terraform 前提条件

安装 Terraform 1.11.0 或更高版本。随附测试使用 override_during,这需要 Terraform 1.11.0。为目标账户配置 AWS 凭证。使用以下命令发现活动 AWS 账户 ID:

aws sts get-caller-identity --query Account --output text

将返回值设置为 expected_account_id。Terraform AWS 提供商在创建资源之前会根据此值验证活动账户。

创建一个限定于目标账户且具有 Magic WAN Write 或 Magic Transit Write 权限的 Cloudflare API 令牌。将该令牌作为 CLOUDFLARE_API_TOKEN 提供给 Terraform 进程:

macOS 或 Linux:

export CLOUDFLARE_API_TOKEN="<API_TOKEN>"

PowerShell:

$env:CLOUDFLARE_API_TOKEN = "<API_TOKEN>"

从设置令牌的同一环境运行 terraform plan 和 terraform apply。在 Cloudflare 仪表板中,选择目标账户并从账户概览复制其 Account ID;不要依赖固定导航路径,因为仪表板可能会更改。将此 32 字符值在 terraform.tfvars 中设置为 cloudflare_account_id。将 cloudflare_asn 设置为账户的 CF Account ASN,记录在 Networking(网络) > Routes(路由) > WAN configuration(WAN 配置) 下。Terraform 接受 13335 或与 aws_transit_gateway_asn 不同的、从 64512 到 65534 的私有 ASN。Terraform 不会更改 CF Account ASN,因为 Cloudflare provider v5.27 不会将账户范围的 BGP 设置公开为资源。

确认 cloudflare_anycast_ips 中的每个值都出现在由 cloudflare_account_id 标识的账户的 Address Space(地址空间) > Leased IPs(租用 IP) 下。这些值是公网 Cloudflare anycast IP,而不是 Cloudflare WAN 路由前缀或链路本地隧道接口地址。

创建一个空的 Terraform 目录,并添加本指南完整列表中的以下文件:

文件 用途
versions.tf 配置 Terraform、AWS 和 Cloudflare 提供商以及账户防护
variables.tf 声明并验证所有部署输入
main.tf 创建 AWS 网络、IGW、选择性路由、Transit Gateway 和 VPN
cloudflare.tf 创建 Cloudflare WAN 隧道、健康检查和 BGP 会话
outputs.tf 返回资源 ID、出口路由、隧道映射和状态
terraform.tfvars.example 提供一个 anycast IP 的参考输入值
terraform.tfvars.two-anycast-ips.example 提供两个 anycast IP 的参考输入值
tests/reference.tftest.hcl 使用模拟提供商测试参考不变量和无效输入

不要从列表创建 .terraform.lock.hcl。terraform init 会根据提供商约束生成该文件,您应提交生成的文件以保留为部署审查过的提供商选择。.gitignore 和 README.md 是可选的仓库支持文件,执行此配置或其测试并不需要它们,因此未包含。

配置 Terraform 变量

创建以下文件后,将 terraform.tfvars.example 复制为 terraform.tfvars。替换两个账户 ID 和两个 PSK 占位符。

Terraform 根据 cloudflare_anycast_ips 中的条目数推导部署规模。一个 anycast IP 创建一个客户网关、一个 Site-to-Site VPN 连接和两条 Cloudflare WAN 隧道。两个 anycast IP 创建各两个 AWS 资源和四条 Cloudflare WAN 隧道。验证会拒绝零个或超过两个 anycast IP、重复的 anycast IP,以及每个 anycast IP 不是两个隧道 CIDR 或 PSK 的数量。

Cloudflare 隧道名称默认为 <deployment_name>-tun-01、-02 等。要选择名称,请按隧道顺序将 cloudflare_tunnel_names 设置为每个 anycast IP 两个唯一名称。名称可以包含字母、数字、连字符和下划线,并且在 Cloudflare 账户内必须唯一。

为每个 anycast IP 精确配置两个隧道 CIDR 和两个 PSK。每个 PSK 必须唯一。审查每个 CIDR、anycast IP、ASN、vpn_routed_prefixes 目的地和额外通告前缀。VPN 路由列表接受比 0.0.0.0/0 更具体且不与 VPC CIDR 重叠的唯一规范 IPv4 前缀;仅将其用于应经过 Cloudflare WAN 的目的地。

anycast IP 列表顺序定义 Terraform 资源标识。保持第一个 anycast IP 不变。追加第二个 anycast IP 以扩展,或仅移除最后一个 anycast IP 以缩减。重新排序 anycast IP 或替换第一个 anycast IP 可能会替换每个客户网关和 VPN 路径,从而导致中断。请在维护窗口中审查这些更改。

resource_ids 输出返回以 "01" 和可选 "02" 为键的 vpn_connection_ids 和 vpn_attachment_ids 映射。

每个客户网关使用设备名称 <deployment_name>-cgw-NN,因此 AWS 会创建不同的客户网关,而不是返回具有相同 IP 地址和 ASN 的现有网关。更改 deployment_name 会替换每个客户网关并短暂中断每个 VPN 连接。请在维护窗口中审查这些更改。

aws_transit_gateway_asn 默认为 65020。AWS 不允许更改具有 VPN 连接的 Transit Gateway 的 ASN,因此请在首次 apply 之前设置 aws_transit_gateway_asn,之后不要更改。

空的 cloudflare_additional_advertised_prefixes 列表不会抑制 Cloudflare 路由表中已符合 BGP 通告条件的路由。仅添加 Cloudflare 必须在这些路由之外通告的前缀。

完整 Terraform 配置

versions.tf

创建 versions.tf 以约束 Terraform 和提供商版本、配置提供商身份验证、保护 AWS 账户并应用默认标签。

terraform {
  # terraform test uses override_during, which requires Terraform 1.11.0 or later.
  required_version = ">= 1.11.0"

  # Keep provider behavior within the minor versions tested by this guide.
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 6.67.0"
    }

    cloudflare = {
      source  = "cloudflare/cloudflare"
      version = "~> 5.27.0"
    }
  }
}

# Authentication comes from CLOUDFLARE_API_TOKEN rather than a Terraform variable,
# which keeps the API token out of configuration and variable files.
provider "cloudflare" {}

provider "aws" {
  region = var.aws_region
  # Refuse to operate if the active credentials point at the wrong AWS account.
  allowed_account_ids = [var.expected_account_id]

  default_tags {
    tags = {
      Deployment = var.deployment_name
      ManagedBy  = "Terraform"
    }
  }
}

variables.tf

创建 variables.tf 以声明部署输入,并拒绝无效的账户 ID、CIDR、anycast IP、ASN 和预共享密钥。

variable "aws_region" {
  description = "AWS Region for the reference deployment."
  type        = string
  default     = "us-east-2"
}

variable "expected_account_id" {
  description = "Twelve-digit AWS account ID allowed to receive the deployment."
  type        = string

  validation {
    condition     = can(regex("^[0-9]{12}$", var.expected_account_id))
    error_message = "expected_account_id must be a 12-digit AWS account ID."
  }
}

variable "cloudflare_account_id" {
  description = "Cloudflare account ID that owns the Cloudflare WAN configuration."
  type        = string

  validation {
    condition     = can(regex("^[0-9a-fA-F]{32}$", var.cloudflare_account_id))
    error_message = "cloudflare_account_id must be a 32-character hexadecimal Cloudflare account ID."
  }
}

variable "deployment_name" {
  description = "Name used to tag the reference deployment."
  type        = string
  default     = "cloudflare-wan-reference"

  validation {
    condition     = can(regex("^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$", var.deployment_name))
    error_message = "deployment_name may contain only letters, numbers, periods, underscores, and hyphens."
  }
}

variable "vpc_cidr" {
  description = "IPv4 CIDR for the workload VPC."
  type        = string
  default     = "192.168.0.0/16"

  validation {
    # Require the canonical network address so containment checks are unambiguous.
    condition = try(
      can(regex("^([0-9]{1,3}\\.){3}[0-9]{1,3}/[0-9]{1,2}$", var.vpc_cidr)) &&
      cidrhost(var.vpc_cidr, 0) == split("/", var.vpc_cidr)[0] &&
      tonumber(split("/", var.vpc_cidr)[1]) >= 16 &&
      tonumber(split("/", var.vpc_cidr)[1]) <= 28,
      false
    )
    error_message = "vpc_cidr must be an IPv4 network with an AWS-supported /16 through /28 prefix."
  }
}

variable "workload_subnet_cidr" {
  description = "Public subnet for workloads that use split Internet and Cloudflare WAN connectivity."
  type        = string
  default     = "192.168.125.0/24"

  validation {
    condition = try(
      can(regex("^([0-9]{1,3}\\.){3}[0-9]{1,3}/[0-9]{1,2}$", var.workload_subnet_cidr)) &&
      cidrhost(var.workload_subnet_cidr, 0) == split("/", var.workload_subnet_cidr)[0] &&
      tonumber(split("/", var.workload_subnet_cidr)[1]) >= 16 &&
      tonumber(split("/", var.workload_subnet_cidr)[1]) <= 28,
      false
    )
    error_message = "workload_subnet_cidr must be an IPv4 network with an AWS-supported /16 through /28 prefix."
  }
}

variable "vpn_routed_prefixes" {
  description = "IPv4 destination prefixes routed through the Transit Gateway and Site-to-Site VPNs instead of the Internet Gateway."
  type        = list(string)
  default     = []

  validation {
    # The default route belongs to the Internet Gateway; only more-specific
    # canonical networks can be selected for the VPN path.
    condition = length(distinct(var.vpn_routed_prefixes)) == length(var.vpn_routed_prefixes) && alltrue([
      for cidr in var.vpn_routed_prefixes : try(
        can(regex("^([0-9]{1,3}\\.){3}[0-9]{1,3}/[0-9]{1,2}$", cidr)) &&
        cidrhost(cidr, 0) == split("/", cidr)[0] &&
        tonumber(split("/", cidr)[1]) >= 1 &&
        tonumber(split("/", cidr)[1]) <= 32,
        false
      )
    ])
    error_message = "vpn_routed_prefixes must contain unique canonical IPv4 network CIDRs more specific than 0.0.0.0/0."
  }

  validation {
    # Overlapping local and remote address space cannot be routed unambiguously.
    condition = alltrue([
      for cidr in var.vpn_routed_prefixes : try(
        cidrhost("${cidrhost(cidr, 0)}/${split("/", var.vpc_cidr)[1]}", 0) != cidrhost(var.vpc_cidr, 0) &&
        cidrhost("${cidrhost(var.vpc_cidr, 0)}/${split("/", cidr)[1]}", 0) != cidrhost(cidr, 0),
        false
      )
    ])
    error_message = "vpn_routed_prefixes must not overlap vpc_cidr."
  }
}

variable "tgw_subnet_a_cidr" {
  description = "Transit Gateway attachment subnet in the first Availability Zone."
  type        = string
  default     = "192.168.124.0/28"

  validation {
    condition = try(
      can(regex("^([0-9]{1,3}\\.){3}[0-9]{1,3}/[0-9]{1,2}$", var.tgw_subnet_a_cidr)) &&
      cidrhost(var.tgw_subnet_a_cidr, 0) == split("/", var.tgw_subnet_a_cidr)[0] &&
      tonumber(split("/", var.tgw_subnet_a_cidr)[1]) >= 16 &&
      tonumber(split("/", var.tgw_subnet_a_cidr)[1]) <= 28,
      false
    )
    error_message = "tgw_subnet_a_cidr must be an IPv4 network with an AWS-supported /16 through /28 prefix."
  }
}

variable "tgw_subnet_b_cidr" {
  description = "Transit Gateway attachment subnet in the second Availability Zone."
  type        = string
  default     = "192.168.124.16/28"

  validation {
    condition = try(
      can(regex("^([0-9]{1,3}\\.){3}[0-9]{1,3}/[0-9]{1,2}$", var.tgw_subnet_b_cidr)) &&
      cidrhost(var.tgw_subnet_b_cidr, 0) == split("/", var.tgw_subnet_b_cidr)[0] &&
      tonumber(split("/", var.tgw_subnet_b_cidr)[1]) >= 16 &&
      tonumber(split("/", var.tgw_subnet_b_cidr)[1]) <= 28,
      false
    )
    error_message = "tgw_subnet_b_cidr must be an IPv4 network with an AWS-supported /16 through /28 prefix."
  }
}

variable "tunnel_inside_cidrs" {
  description = "Two unique AWS VPN tunnel /30 networks per Cloudflare anycast IP, ordered by VPN connection and tunnel."
  type        = list(string)
  default = [
    "169.254.240.44/30",
    "169.254.240.48/30",
  ]

  validation {
    # Every AWS VPN connection contains exactly two tunnels.
    condition = length(var.tunnel_inside_cidrs) == length(var.cloudflare_anycast_ips) * 2 && length(distinct(var.tunnel_inside_cidrs)) == length(var.tunnel_inside_cidrs) && alltrue([
      for cidr in var.tunnel_inside_cidrs : try(
        split("/", cidr)[1] == "30" &&
        cidrhost(cidr, 0) == split("/", cidr)[0] &&
        cidrhost("${cidrhost(cidr, 0)}/20", 0) == "169.254.240.0" &&
        cidrhost("${cidrhost(cidr, -1)}/20", 0) == "169.254.240.0",
        false
      )
    ])
    error_message = "tunnel_inside_cidrs must contain two unique /30 network addresses within 169.254.240.0/20 for each Cloudflare anycast IP."
  }
}

variable "vpn_preshared_keys" {
  description = "Two AWS-compatible pre-shared keys per Cloudflare anycast IP, in tunnel order."
  type        = list(string)
  # Sensitive suppresses CLI display, but the keys are still stored in state.
  sensitive = true

  validation {
    # List order matches tunnel_inside_cidrs and the generated tunnel numbering.
    # Key format matches the AWS Site-to-Site VPN PreSharedKey constraints.
    condition = length(var.vpn_preshared_keys) == length(var.cloudflare_anycast_ips) * 2 && alltrue([
      for key in var.vpn_preshared_keys : can(regex("^[A-Za-z1-9._][A-Za-z0-9._]{7,63}$", key))
    ])
    error_message = "vpn_preshared_keys must contain two keys per Cloudflare anycast IP; each key must contain 8-64 letters, numbers, periods, or underscores and cannot begin with 0."
  }

  validation {
    # The AWS provider identifies tunnel1_address by matching the tunnel 1 PSK.
    # Identical PSKs disable that match and can swap the AWS public IPv4
    # addresses assigned to the Cloudflare WAN tunnels.
    condition     = length(distinct(var.vpn_preshared_keys)) == length(var.vpn_preshared_keys)
    error_message = "vpn_preshared_keys must be unique for every tunnel."
  }
}

variable "cloudflare_anycast_ips" {
  description = "One or two Cloudflare anycast IPs leased to cloudflare_account_id."
  type        = list(string)
  default     = ["162.159.135.1"]

  validation {
    # Each anycast IP backs one AWS VPN connection containing two tunnels.
    condition = length(var.cloudflare_anycast_ips) >= 1 && length(var.cloudflare_anycast_ips) <= 2 && length(distinct(var.cloudflare_anycast_ips)) == length(var.cloudflare_anycast_ips) && alltrue([
      for address in var.cloudflare_anycast_ips : try(
        can(regex("^([0-9]{1,3}\\.){3}[0-9]{1,3}$", address)) &&
        cidrhost("${address}/32", 0) == address,
        false
      )
    ])
    error_message = "cloudflare_anycast_ips must contain one or two distinct IPv4 addresses."
  }
}

variable "aws_transit_gateway_asn" {
  description = "Private ASN used by the AWS Transit Gateway."
  type        = number
  default     = 65020

  validation {
    condition     = floor(var.aws_transit_gateway_asn) == var.aws_transit_gateway_asn && ((var.aws_transit_gateway_asn >= 64512 && var.aws_transit_gateway_asn <= 65534) || (var.aws_transit_gateway_asn >= 4200000000 && var.aws_transit_gateway_asn <= 4294967294))
    error_message = "aws_transit_gateway_asn must be an AWS-supported private ASN."
  }
}

variable "cloudflare_asn" {
  description = "CF Account ASN configured in Cloudflare WAN and used by every AWS customer gateway."
  type        = number
  default     = 13335

  validation {
    # Cloudflare defaults to 13335 and permits a private 2-byte ASN instead.
    condition     = floor(var.cloudflare_asn) == var.cloudflare_asn && (var.cloudflare_asn == 13335 || (var.cloudflare_asn >= 64512 && var.cloudflare_asn <= 65534))
    error_message = "cloudflare_asn must match the CF Account ASN: 13335 or a private ASN from 64512 through 65534."
  }

  validation {
    # The CF Account ASN must differ from the customer device ASN on each tunnel.
    condition     = var.cloudflare_asn != var.aws_transit_gateway_asn
    error_message = "cloudflare_asn must differ from aws_transit_gateway_asn."
  }
}

variable "cloudflare_additional_advertised_prefixes" {
  description = "Additional prefixes for Cloudflare to advertise to AWS on every BGP session. Eligible Cloudflare WAN routes are advertised without listing them here."
  type        = list(string)
  default     = []

  validation {
    condition = length(distinct(var.cloudflare_additional_advertised_prefixes)) == length(var.cloudflare_additional_advertised_prefixes) && alltrue([
      for cidr in var.cloudflare_additional_advertised_prefixes : try(
        can(regex("^([0-9]{1,3}\\.){3}[0-9]{1,3}/[0-9]{1,2}$", cidr)) &&
        cidrhost(cidr, 0) == split("/", cidr)[0],
        false
      )
    ])
    error_message = "cloudflare_additional_advertised_prefixes must contain unique IPv4 network CIDRs."
  }
}

variable "cloudflare_tunnel_names" {
  description = "Optional Cloudflare WAN tunnel names in tunnel order, two per Cloudflare anycast IP. Leave empty to use <deployment_name>-tun-01, -02, and so on."
  type        = list(string)
  default     = []

  validation {
    # Cloudflare rejects a tunnel whose name matches any other tunnel in the account.
    condition = length(var.cloudflare_tunnel_names) == 0 || (
      length(var.cloudflare_tunnel_names) == length(var.cloudflare_anycast_ips) * 2 &&
      length(distinct(var.cloudflare_tunnel_names)) == length(var.cloudflare_tunnel_names) &&
      alltrue([for name in var.cloudflare_tunnel_names : can(regex("^[A-Za-z0-9_-]+$", name))])
    )
    error_message = "cloudflare_tunnel_names must be empty or contain two unique names per Cloudflare anycast IP, using only letters, numbers, hyphens, and underscores."
  }
}

main.tf

创建 main.tf 以构建 AWS VPC、公网工作负载子网、Internet Gateway、分流出口路由、Transit Gateway,以及每个已配置 anycast IP 的一个客户网关和 VPN 连接。每个 VPN 连接包含两条有序隧道。

data "aws_availability_zones" "available" {
  state = "available"
}

locals {
  # Resources require two AZs; try() keeps expression evaluation safe until the
  # VPC precondition can return a clear error in a single-AZ Region.
  availability_zone_a = data.aws_availability_zones.available.names[0]
  availability_zone_b = try(data.aws_availability_zones.available.names[1], data.aws_availability_zones.available.names[0])
  subnet_cidrs        = [var.workload_subnet_cidr, var.tgw_subnet_a_cidr, var.tgw_subnet_b_cidr]
  subnet_pairs        = [[0, 1], [0, 2], [1, 2]]

  # Each anycast IP creates one AWS customer gateway and one two-tunnel VPN.
  customer_gateways = {
    for index, anycast_ip in var.cloudflare_anycast_ips : format("%02d", index + 1) => {
      cloudflare_anycast_ip = anycast_ip
      tunnel1_index         = index * 2
      tunnel2_index         = index * 2 + 1
    }
  }
}

resource "aws_vpc" "workload" {
  cidr_block           = var.vpc_cidr
  instance_tenancy     = "default"
  enable_dns_support   = true
  enable_dns_hostnames = false

  tags = {
    Name = "${var.deployment_name}-vpc"
  }

  lifecycle {
    precondition {
      condition     = length(data.aws_availability_zones.available.names) >= 2
      error_message = "The selected AWS Region must have at least two available Availability Zones."
    }

    precondition {
      # Check both ends of each subnet against the VPC to prevent partial overlap.
      condition = alltrue([
        for cidr in local.subnet_cidrs : try(
          cidrhost(cidr, 0) == split("/", cidr)[0] &&
          tonumber(split("/", cidr)[1]) >= tonumber(split("/", var.vpc_cidr)[1]) &&
          cidrhost("${cidrhost(cidr, 0)}/${split("/", var.vpc_cidr)[1]}", 0) == cidrhost(var.vpc_cidr, 0) &&
          cidrhost("${cidrhost(cidr, -1)}/${split("/", var.vpc_cidr)[1]}", 0) == cidrhost(var.vpc_cidr, 0),
          false
        )
      ])
      error_message = "Each subnet CIDR must be a valid network contained within vpc_cidr."
    }

    precondition {
      # Evaluate every pair so no workload or attachment subnet can overlap.
      condition = try(alltrue([
        for pair in local.subnet_pairs :
        cidrhost("${cidrhost(local.subnet_cidrs[pair[1]], 0)}/${split("/", local.subnet_cidrs[pair[0]])[1]}", 0) != cidrhost(local.subnet_cidrs[pair[0]], 0) &&
        cidrhost("${cidrhost(local.subnet_cidrs[pair[0]], 0)}/${split("/", local.subnet_cidrs[pair[1]])[1]}", 0) != cidrhost(local.subnet_cidrs[pair[1]], 0)
      ]), false)
      error_message = "The workload and Transit Gateway subnet CIDRs must not overlap."
    }
  }
}

resource "aws_subnet" "workload" {
  vpc_id                  = aws_vpc.workload.id
  cidr_block              = var.workload_subnet_cidr
  availability_zone       = local.availability_zone_a
  map_public_ip_on_launch = true

  tags = {
    Name = "${var.deployment_name}-workload"
  }
}

# The workload subnet uses direct Internet Gateway egress for destinations that
# do not match a more-specific VPN route. Workloads still need a public IPv4
# address and security controls; this reference deployment does not create workloads.
resource "aws_internet_gateway" "workload" {
  vpc_id = aws_vpc.workload.id

  tags = {
    Name = "${var.deployment_name}-igw"
  }
}

resource "aws_subnet" "tgw_a" {
  vpc_id            = aws_vpc.workload.id
  cidr_block        = var.tgw_subnet_a_cidr
  availability_zone = local.availability_zone_a

  tags = {
    Name = "${var.deployment_name}-tgw-${local.availability_zone_a}"
  }
}

resource "aws_subnet" "tgw_b" {
  vpc_id            = aws_vpc.workload.id
  cidr_block        = var.tgw_subnet_b_cidr
  availability_zone = local.availability_zone_b

  tags = {
    Name = "${var.deployment_name}-tgw-${local.availability_zone_b}"
  }
}

resource "aws_route_table" "workload" {
  vpc_id = aws_vpc.workload.id

  tags = {
    Name = "${var.deployment_name}-workload-rt"
  }
}

resource "aws_route_table_association" "workload" {
  subnet_id      = aws_subnet.workload.id
  route_table_id = aws_route_table.workload.id
}

resource "aws_ec2_transit_gateway" "cloudflare" {
  amazon_side_asn                = var.aws_transit_gateway_asn
  auto_accept_shared_attachments = "disable"
  # Explicit associations and propagations below avoid implicit routing changes.
  default_route_table_association    = "disable"
  default_route_table_propagation    = "disable"
  dns_support                        = "enable"
  multicast_support                  = "disable"
  security_group_referencing_support = "disable"
  vpn_ecmp_support                   = "enable"

  tags = {
    Name = "${var.deployment_name}-tgw"
  }
}

resource "aws_ec2_transit_gateway_route_table" "cloudflare" {
  transit_gateway_id = aws_ec2_transit_gateway.cloudflare.id

  tags = {
    Name = "${var.deployment_name}-tgw-rt"
  }
}

resource "aws_ec2_transit_gateway_vpc_attachment" "workload" {
  subnet_ids                                      = [aws_subnet.tgw_a.id, aws_subnet.tgw_b.id]
  transit_gateway_id                              = aws_ec2_transit_gateway.cloudflare.id
  vpc_id                                          = aws_vpc.workload.id
  appliance_mode_support                          = "disable"
  dns_support                                     = "enable"
  ipv6_support                                    = "disable"
  security_group_referencing_support              = "disable"
  transit_gateway_default_route_table_association = false
  transit_gateway_default_route_table_propagation = false

  tags = {
    Name = "${var.deployment_name}-vpc-attachment"
  }
}

resource "aws_ec2_transit_gateway_route_table_association" "workload" {
  transit_gateway_attachment_id  = aws_ec2_transit_gateway_vpc_attachment.workload.id
  transit_gateway_route_table_id = aws_ec2_transit_gateway_route_table.cloudflare.id
}

resource "aws_ec2_transit_gateway_route_table_propagation" "workload" {
  transit_gateway_attachment_id  = aws_ec2_transit_gateway_vpc_attachment.workload.id
  transit_gateway_route_table_id = aws_ec2_transit_gateway_route_table.cloudflare.id
}

# Route only approved destination prefixes through the Transit Gateway. AWS
# longest-prefix matching gives these routes precedence over the Internet default.
resource "aws_route" "cloudflare" {
  for_each = toset(var.vpn_routed_prefixes)

  route_table_id         = aws_route_table.workload.id
  destination_cidr_block = each.value
  transit_gateway_id     = aws_ec2_transit_gateway.cloudflare.id

  depends_on = [aws_ec2_transit_gateway_vpc_attachment.workload]
}

# All destinations not selected above use direct Internet Gateway egress.
resource "aws_route" "internet" {
  route_table_id         = aws_route_table.workload.id
  destination_cidr_block = "0.0.0.0/0"
  gateway_id             = aws_internet_gateway.workload.id
}

resource "aws_customer_gateway" "cloudflare" {
  for_each = local.customer_gateways

  bgp_asn    = var.cloudflare_asn
  ip_address = each.value.cloudflare_anycast_ip
  type       = "ipsec.1"
  # AWS returns an existing customer gateway for an identical type, IP address,
  # and ASN unless the device name differs, so this name keeps the gateway unique.
  device_name = "${var.deployment_name}-cgw-${each.key}"

  tags = {
    Name = "${var.deployment_name}-cgw-${each.key}"
  }

  lifecycle {
    # AWS cannot delete an in-use customer gateway, so establish its replacement first.
    create_before_destroy = true
  }
}

resource "aws_vpn_connection" "cloudflare" {
  for_each = local.customer_gateways

  customer_gateway_id   = aws_customer_gateway.cloudflare[each.key].id
  transit_gateway_id    = aws_ec2_transit_gateway.cloudflare.id
  type                  = "ipsec.1"
  static_routes_only    = false
  preshared_key_storage = "Standard"

  local_ipv4_network_cidr  = "0.0.0.0/0"
  remote_ipv4_network_cidr = "0.0.0.0/0"
  outside_ip_address_type  = "PublicIpv4"
  tunnel_bandwidth         = "standard"
  tunnel_inside_ip_version = "ipv4"

  # Each VPN consumes the two tunnel inputs assigned to its anycast IP.
  tunnel1_inside_cidr                  = var.tunnel_inside_cidrs[each.value.tunnel1_index]
  tunnel1_preshared_key                = var.vpn_preshared_keys[each.value.tunnel1_index]
  tunnel1_replay_window_size           = 2048
  tunnel1_dpd_timeout_action           = "restart"
  tunnel1_phase1_encryption_algorithms = ["AES256"]
  tunnel1_phase2_encryption_algorithms = ["AES256"]
  tunnel1_phase1_integrity_algorithms  = ["SHA2-256"]
  tunnel1_phase2_integrity_algorithms  = ["SHA2-256"]
  tunnel1_phase1_dh_group_numbers      = [20]
  tunnel1_phase2_dh_group_numbers      = [20]
  tunnel1_phase1_lifetime_seconds      = 28800
  tunnel1_phase2_lifetime_seconds      = 3600
  tunnel1_ike_versions                 = ["ikev2"]
  tunnel1_startup_action               = "start"

  tunnel2_inside_cidr                  = var.tunnel_inside_cidrs[each.value.tunnel2_index]
  tunnel2_preshared_key                = var.vpn_preshared_keys[each.value.tunnel2_index]
  tunnel2_replay_window_size           = 2048
  tunnel2_dpd_timeout_action           = "restart"
  tunnel2_phase1_encryption_algorithms = ["AES256"]
  tunnel2_phase2_encryption_algorithms = ["AES256"]
  tunnel2_phase1_integrity_algorithms  = ["SHA2-256"]
  tunnel2_phase2_integrity_algorithms  = ["SHA2-256"]
  tunnel2_phase1_dh_group_numbers      = [20]
  tunnel2_phase2_dh_group_numbers      = [20]
  tunnel2_phase1_lifetime_seconds      = 28800
  tunnel2_phase2_lifetime_seconds      = 3600
  tunnel2_ike_versions                 = ["ikev2"]
  tunnel2_startup_action               = "start"

  tags = {
    Name = "${var.deployment_name}-vpn-${each.key}"
  }
}

resource "aws_ec2_transit_gateway_route_table_association" "vpn" {
  for_each = aws_vpn_connection.cloudflare

  transit_gateway_attachment_id  = each.value.transit_gateway_attachment_id
  transit_gateway_route_table_id = aws_ec2_transit_gateway_route_table.cloudflare.id
}

resource "aws_ec2_transit_gateway_route_table_propagation" "vpn" {
  for_each = aws_vpn_connection.cloudflare

  transit_gateway_attachment_id  = each.value.transit_gateway_attachment_id
  transit_gateway_route_table_id = aws_ec2_transit_gateway_route_table.cloudflare.id
}

cloudflare.tf

创建 cloudflare.tf 以将 AWS 隧道映射到 Cloudflare WAN、选择 Cloudflare 主机地址,并为每个已配置 anycast IP 启用健康检查和 BGP。

locals {
  # Cloudflare tunnel names must be unique within the account. Use the supplied names, or
  # prefix generated names with deployment_name. Periods are replaced because tunnel names
  # avoid special characters.
  cloudflare_tunnel_name_prefix = replace(var.deployment_name, ".", "-")

  # Expand each anycast IP and AWS VPN connection into two Cloudflare WAN tunnel objects. Tunnel keys
  # remain globally ordered as 01-02 for anycast IP 1 and 03-04 for anycast IP 2.
  cloudflare_tunnels = merge([
    for vpn_key, vpn in local.customer_gateways : {
      (format("%02d", vpn.tunnel1_index + 1)) = {
        name                  = length(var.cloudflare_tunnel_names) > 0 ? var.cloudflare_tunnel_names[vpn.tunnel1_index] : "${local.cloudflare_tunnel_name_prefix}-tun-${format("%02d", vpn.tunnel1_index + 1)}"
        vpn_connection_key    = vpn_key
        cloudflare_anycast_ip = vpn.cloudflare_anycast_ip
        customer_endpoint     = aws_vpn_connection.cloudflare[vpn_key].tunnel1_address
        aws_bgp_holdtime      = aws_vpn_connection.cloudflare[vpn_key].tunnel1_bgp_holdtime
        inside_cidr           = var.tunnel_inside_cidrs[vpn.tunnel1_index]
        psk                   = var.vpn_preshared_keys[vpn.tunnel1_index]
      }
      (format("%02d", vpn.tunnel2_index + 1)) = {
        name                  = length(var.cloudflare_tunnel_names) > 0 ? var.cloudflare_tunnel_names[vpn.tunnel2_index] : "${local.cloudflare_tunnel_name_prefix}-tun-${format("%02d", vpn.tunnel2_index + 1)}"
        vpn_connection_key    = vpn_key
        cloudflare_anycast_ip = vpn.cloudflare_anycast_ip
        customer_endpoint     = aws_vpn_connection.cloudflare[vpn_key].tunnel2_address
        aws_bgp_holdtime      = aws_vpn_connection.cloudflare[vpn_key].tunnel2_bgp_holdtime
        inside_cidr           = var.tunnel_inside_cidrs[vpn.tunnel2_index]
        psk                   = var.vpn_preshared_keys[vpn.tunnel2_index]
      }
    }
  ]...)
}

resource "cloudflare_magic_wan_ipsec_tunnel" "aws" {
  for_each = local.cloudflare_tunnels

  account_id          = var.cloudflare_account_id
  name                = each.value.name
  description         = "AWS Transit Gateway tunnel ${each.key} managed by Terraform"
  customer_endpoint   = each.value.customer_endpoint
  cloudflare_endpoint = each.value.cloudflare_anycast_ip
  # AWS uses host 1 and Cloudflare uses host 2 in each /30 inside network.
  interface_address = "${cidrhost(each.value.inside_cidr, 2)}/30"
  # The provider writes this secret to Terraform state; protect the backend.
  psk               = each.value.psk
  replay_protection = true
  # BGP and the Cloudflare routing table, not automatic return routing, select paths.
  automatic_return_routing = false

  # Leave target unset so bidirectional checks use the default target: the AWS
  # inside address in the same /30.
  health_check = {
    enabled   = true
    rate      = "mid"
    type      = "request"
    direction = "bidirectional"
  }

  bgp = {
    customer_asn   = var.aws_transit_gateway_asn
    extra_prefixes = var.cloudflare_additional_advertised_prefixes
  }
}

outputs.tf

创建 outputs.tf 以公开资源 ID、工作负载出口路由、有序隧道映射,以及每个已配置 anycast IP 的提供商刷新状态。

output "resource_ids" {
  description = "AWS resource IDs used to verify the deployment."
  value = {
    vpc_id                      = aws_vpc.workload.id
    workload_subnet_id          = aws_subnet.workload.id
    internet_gateway_id         = aws_internet_gateway.workload.id
    transit_gateway_id          = aws_ec2_transit_gateway.cloudflare.id
    transit_gateway_route_table = aws_ec2_transit_gateway_route_table.cloudflare.id
    vpc_attachment_id           = aws_ec2_transit_gateway_vpc_attachment.workload.id
    vpn_connection_ids          = { for key, vpn in aws_vpn_connection.cloudflare : key => vpn.id }
    vpn_attachment_ids          = { for key, vpn in aws_vpn_connection.cloudflare : key => vpn.transit_gateway_attachment_id }
    cloudflare_tunnel_ids       = { for key, tunnel in cloudflare_magic_wan_ipsec_tunnel.aws : key => tunnel.id }
  }
}

output "workload_egress_routes" {
  description = "Workload route-table destinations split between the VPN and Internet Gateway paths."
  value = {
    vpn              = sort(var.vpn_routed_prefixes)
    internet_default = aws_route.internet.destination_cidr_block
  }
}

output "bgp_asns" {
  description = "BGP ASNs used to configure Cloudflare WAN."
  value = {
    aws_transit_gateway = var.aws_transit_gateway_asn
    cloudflare          = var.cloudflare_asn
  }
}

output "cloudflare_tunnel_mapping" {
  description = "AWS and Cloudflare values for the two or four Terraform-managed tunnels."
  # Keep this list in tunnel-number order for direct operational correlation.
  value = [
    for key in sort(keys(local.cloudflare_tunnels)) : {
      tunnel                       = cloudflare_magic_wan_ipsec_tunnel.aws[key].name
      vpn_connection_id            = aws_vpn_connection.cloudflare[local.cloudflare_tunnels[key].vpn_connection_key].id
      aws_outside_ip               = local.cloudflare_tunnels[key].customer_endpoint
      cloudflare_anycast_ip        = local.cloudflare_tunnels[key].cloudflare_anycast_ip
      inside_cidr                  = local.cloudflare_tunnels[key].inside_cidr
      aws_inside_ip                = cidrhost(local.cloudflare_tunnels[key].inside_cidr, 1)
      cloudflare_interface_address = "${cidrhost(local.cloudflare_tunnels[key].inside_cidr, 2)}/30"
      # AWS sets this value; Cloudflare negotiates the lower of it and 240 seconds.
      aws_bgp_holdtime     = local.cloudflare_tunnels[key].aws_bgp_holdtime
      cloudflare_tunnel_id = cloudflare_magic_wan_ipsec_tunnel.aws[key].id
    }
  ]
}

output "cloudflare_bgp_status" {
  description = "Cloudflare BGP status refreshed during the most recent Terraform operation."
  # Provider status is a state snapshot, not continuous monitoring telemetry.
  value = {
    for key, tunnel in cloudflare_magic_wan_ipsec_tunnel.aws : key => tunnel.bgp_status
  }
}

output "vpn_telemetry" {
  description = "AWS tunnel telemetry refreshed during the most recent Terraform operation."
  # Refresh state before relying on these provider-reported values.
  value = {
    for key, vpn in aws_vpn_connection.cloudflare : key => vpn.vgw_telemetry
  }
}

terraform.tfvars.example

创建 terraform.tfvars.example 作为已审查的输入模板。将其复制为 terraform.tfvars,并在规划之前替换每个占位符。它配置一个 anycast IP、两个隧道 CIDR 和两个 PSK 的基线。具有两个 anycast IP 的客户改用以下模板。

expected_account_id   = "REPLACE_WITH_AWS_ACCOUNT_ID"
cloudflare_account_id = "REPLACE_WITH_CLOUDFLARE_ACCOUNT_ID"
deployment_name       = "cloudflare-wan-reference"
aws_region            = "us-east-2"

# These three subnets must be canonical, non-overlapping networks inside the VPC.
vpc_cidr             = "192.168.0.0/16"
workload_subnet_cidr = "192.168.125.0/24"
tgw_subnet_a_cidr    = "192.168.124.0/28"
tgw_subnet_b_cidr    = "192.168.124.16/28"

# Only these destinations use the Site-to-Site VPNs. All other IPv4 traffic
# uses the Internet Gateway default route.
vpn_routed_prefixes = [
  "172.16.0.0/16",
]

# Accounts using one anycast IP have two tunnels.
tunnel_inside_cidrs = [
  "169.254.240.44/30",
  "169.254.240.48/30",
]

# PSKs are sensitive and persist in Terraform state; never commit terraform.tfvars.
vpn_preshared_keys = [
  "REPLACE_WITH_UNIQUE_TUNNEL_01_PSK",
  "REPLACE_WITH_UNIQUE_TUNNEL_02_PSK",
]

# One anycast IP is the baseline and backs tunnels 01-02.
cloudflare_anycast_ips  = ["162.159.135.1"]
aws_transit_gateway_asn = 65020
# Set to the CF Account ASN shown under Networking > Routes > WAN configuration.
cloudflare_asn                            = 13335
cloudflare_additional_advertised_prefixes = []

# Optional. Cloudflare tunnel names must be unique in the Cloudflare account.
# Leave empty to use <deployment_name>-tun-01, -02, and so on, or list two names
# per anycast IP in tunnel order, for example:
# cloudflare_tunnel_names = ["aws-tun-01", "aws-tun-02"]
cloudflare_tunnel_names = []

terraform.tfvars.two-anycast-ips.example

创建 terraform.tfvars.two-anycast-ips.example 作为具有两个 anycast IP 的客户的输入模板。将其复制为 terraform.tfvars 而不是 terraform.tfvars.example。它配置两个 anycast IP、四个隧道 CIDR 和四个 PSK,从而创建两个客户网关、两个 Site-to-Site VPN 连接和四条 Cloudflare WAN 隧道。

expected_account_id   = "REPLACE_WITH_AWS_ACCOUNT_ID"
cloudflare_account_id = "REPLACE_WITH_CLOUDFLARE_ACCOUNT_ID"
deployment_name       = "cloudflare-wan-reference"
aws_region            = "us-east-2"

# These three subnets must be canonical, non-overlapping networks inside the VPC.
vpc_cidr             = "192.168.0.0/16"
workload_subnet_cidr = "192.168.125.0/24"
tgw_subnet_a_cidr    = "192.168.124.0/28"
tgw_subnet_b_cidr    = "192.168.124.16/28"

# Only these destinations use the Site-to-Site VPNs. All other IPv4 traffic
# uses the Internet Gateway default route.
vpn_routed_prefixes = [
  "172.16.0.0/16",
]

# Accounts using two anycast IPs have four tunnels. Entries 1-2 belong to
# anycast IP 1 and entries 3-4 belong to anycast IP 2.
tunnel_inside_cidrs = [
  "169.254.240.44/30",
  "169.254.240.48/30",
  "169.254.240.52/30",
  "169.254.240.56/30",
]

# PSKs are sensitive and persist in Terraform state; never commit terraform.tfvars.
vpn_preshared_keys = [
  "REPLACE_WITH_UNIQUE_TUNNEL_01_PSK",
  "REPLACE_WITH_UNIQUE_TUNNEL_02_PSK",
  "REPLACE_WITH_UNIQUE_TUNNEL_03_PSK",
  "REPLACE_WITH_UNIQUE_TUNNEL_04_PSK",
]

# List order is resource identity. Anycast IP 1 backs tunnels 01-02 and VPN
# connection 01; anycast IP 2 backs tunnels 03-04 and VPN connection 02.
cloudflare_anycast_ips  = ["162.159.135.1", "172.64.135.1"]
aws_transit_gateway_asn = 65020
# Set to the CF Account ASN shown under Networking > Routes > WAN configuration.
cloudflare_asn                            = 13335
cloudflare_additional_advertised_prefixes = []

# Optional. Cloudflare tunnel names must be unique in the Cloudflare account.
# Leave empty to use <deployment_name>-tun-01, -02, and so on, or list two names
# per anycast IP in tunnel order, for example:
# cloudflare_tunnel_names = ["aws-tun-01", "aws-tun-02", "aws-tun-03", "aws-tun-04"]
cloudflare_tunnel_names = []

tests/reference.tftest.hcl

先创建 tests/ 目录,然后创建 tests/reference.tftest.hcl 以运行 24 项测试:五个正向用例和十九个无效输入用例,且不联系 AWS 或 Cloudflare。

# Mock providers let plan assertions run without credentials or live API calls.
mock_provider "aws" {}
mock_provider "cloudflare" {}

# terraform test also loads terraform.tfvars from the module directory. Set every
# input here so a deployment's terraform.tfvars cannot change the test baseline.
variables {
  expected_account_id   = "123456789012"
  cloudflare_account_id = "0123456789abcdef0123456789abcdef"
  aws_region            = "us-east-2"
  deployment_name       = "cloudflare-wan-reference"
  vpc_cidr              = "192.168.0.0/16"
  workload_subnet_cidr  = "192.168.125.0/24"
  tgw_subnet_a_cidr     = "192.168.124.0/28"
  tgw_subnet_b_cidr     = "192.168.124.16/28"
  # Exercise multiple selective routes instead of relying on the empty default.
  vpn_routed_prefixes    = ["172.16.0.0/16", "172.17.0.0/16"]
  cloudflare_anycast_ips = ["162.159.135.1"]
  tunnel_inside_cidrs = [
    "169.254.240.44/30",
    "169.254.240.48/30",
  ]
  vpn_preshared_keys = [
    "A0123456789abcdef0123456789abcdef0123456789abcdef",
    "B0123456789abcdef0123456789abcdef0123456789abcdef",
  ]
  aws_transit_gateway_asn                   = 65020
  cloudflare_asn                            = 13335
  cloudflare_additional_advertised_prefixes = []
  cloudflare_tunnel_names                   = []
}

# Supply deterministic AZs so the two-AZ safety precondition can be tested offline.
override_data {
  target = data.aws_availability_zones.available
  values = {
    names = ["us-east-2a", "us-east-2b"]
  }
}

# AWS normally computes public IPv4 addresses during apply. Fixed plan-time values make the
# default AWS VPN connection's two Cloudflare WAN-to-AWS tunnel mappings testable offline.
override_resource {
  target          = aws_vpn_connection.cloudflare["01"]
  override_during = plan
  values = {
    tunnel1_address = "198.51.100.1"
    tunnel2_address = "198.51.100.2"
  }
}

# Make route targets known during plan so assertions can verify exact wiring.
override_resource {
  target          = aws_route_table.workload
  override_during = plan
  values = {
    id = "rtb-0123456789abcdef0"
  }
}

override_resource {
  target          = aws_internet_gateway.workload
  override_during = plan
  values = {
    id = "igw-0123456789abcdef0"
  }
}

override_resource {
  target          = aws_ec2_transit_gateway.cloudflare
  override_during = plan
  values = {
    id = "tgw-0123456789abcdef0"
  }
}

# This default positive case protects one anycast IP, one VPN, and two tunnels.
run "valid_reference_configuration" {
  command = plan

  assert {
    condition = (
      length(var.cloudflare_anycast_ips) == 1 &&
      length(var.tunnel_inside_cidrs) == 2 &&
      length(nonsensitive(var.vpn_preshared_keys)) == 2 &&
      length(aws_customer_gateway.cloudflare) == 1 &&
      length(aws_vpn_connection.cloudflare) == 1 &&
      length(cloudflare_magic_wan_ipsec_tunnel.aws) == 2
    )
    error_message = "The default configuration must create one customer gateway, one VPN, and two tunnels from two CIDRs and two PSKs."
  }

  assert {
    condition     = aws_ec2_transit_gateway.cloudflare.amazon_side_asn == var.aws_transit_gateway_asn
    error_message = "The Transit Gateway ASN does not match aws_transit_gateway_asn."
  }

  assert {
    condition     = cloudflare_magic_wan_ipsec_tunnel.aws["01"].name == "cloudflare-wan-reference-tun-01" && cloudflare_magic_wan_ipsec_tunnel.aws["02"].name == "cloudflare-wan-reference-tun-02"
    error_message = "Cloudflare tunnel names must be prefixed with deployment_name."
  }

  assert {
    condition     = cloudflare_magic_wan_ipsec_tunnel.aws["01"].interface_address == "${cidrhost(var.tunnel_inside_cidrs[0], 2)}/30" && cloudflare_magic_wan_ipsec_tunnel.aws["02"].interface_address == "${cidrhost(var.tunnel_inside_cidrs[1], 2)}/30"
    error_message = "A Cloudflare interface address does not match its tunnel CIDR."
  }

  assert {
    condition = (
      cloudflare_magic_wan_ipsec_tunnel.aws["01"].customer_endpoint == "198.51.100.1" &&
      cloudflare_magic_wan_ipsec_tunnel.aws["02"].customer_endpoint == "198.51.100.2"
    )
    error_message = "A customer_endpoint value is mapped to the wrong AWS VPN tunnel."
  }

  assert {
    condition = (
      cloudflare_magic_wan_ipsec_tunnel.aws["01"].cloudflare_endpoint == var.cloudflare_anycast_ips[0] &&
      cloudflare_magic_wan_ipsec_tunnel.aws["02"].cloudflare_endpoint == var.cloudflare_anycast_ips[0]
    )
    error_message = "A Cloudflare anycast IP is mapped to the wrong tunnel."
  }

  assert {
    condition     = cloudflare_magic_wan_ipsec_tunnel.aws["01"].replay_protection == true && cloudflare_magic_wan_ipsec_tunnel.aws["01"].automatic_return_routing == false && cloudflare_magic_wan_ipsec_tunnel.aws["01"].health_check.type == "request" && cloudflare_magic_wan_ipsec_tunnel.aws["01"].health_check.direction == "bidirectional"
    error_message = "The Cloudflare tunnel liveness or routing settings changed unexpectedly."
  }

  assert {
    condition = alltrue([
      for tunnel in cloudflare_magic_wan_ipsec_tunnel.aws :
      tunnel.health_check.enabled == true && tunnel.health_check.rate == "mid" && tunnel.health_check.type == "request" && tunnel.health_check.direction == "bidirectional"
    ])
    error_message = "Every Cloudflare tunnel must use enabled, medium-rate, request-type, bidirectional health checks."
  }

  assert {
    condition     = cloudflare_magic_wan_ipsec_tunnel.aws["01"].bgp.customer_asn == var.aws_transit_gateway_asn && toset(cloudflare_magic_wan_ipsec_tunnel.aws["01"].bgp.extra_prefixes) == toset(var.cloudflare_additional_advertised_prefixes)
    error_message = "The Cloudflare BGP settings do not match the configured inputs."
  }

  assert {
    condition     = aws_ec2_transit_gateway.cloudflare.default_route_table_association == "disable" && aws_ec2_transit_gateway.cloudflare.default_route_table_propagation == "disable" && aws_ec2_transit_gateway.cloudflare.vpn_ecmp_support == "enable"
    error_message = "The Transit Gateway routing controls changed unexpectedly."
  }

  assert {
    condition     = aws_subnet.workload.map_public_ip_on_launch == true && aws_route.internet.destination_cidr_block == "0.0.0.0/0" && aws_route.internet.gateway_id == "igw-0123456789abcdef0" && aws_route.internet.route_table_id == "rtb-0123456789abcdef0"
    error_message = "The public workload subnet must use the Internet Gateway default route."
  }

  assert {
    condition     = toset([for route in aws_route.cloudflare : route.destination_cidr_block]) == toset(var.vpn_routed_prefixes) && alltrue([for route in aws_route.cloudflare : route.transit_gateway_id == "tgw-0123456789abcdef0" && route.route_table_id == "rtb-0123456789abcdef0"])
    error_message = "The Transit Gateway routes do not match vpn_routed_prefixes."
  }

  assert {
    condition     = aws_customer_gateway.cloudflare["01"].ip_address == var.cloudflare_anycast_ips[0] && tostring(aws_customer_gateway.cloudflare["01"].bgp_asn) == tostring(var.cloudflare_asn)
    error_message = "The AWS customer gateway settings do not match the Cloudflare inputs."
  }

  assert {
    condition     = aws_vpn_connection.cloudflare["01"].tunnel1_inside_cidr == var.tunnel_inside_cidrs[0] && aws_vpn_connection.cloudflare["01"].tunnel2_inside_cidr == var.tunnel_inside_cidrs[1]
    error_message = "The default VPN has the wrong inside CIDRs."
  }

  assert {
    condition     = aws_vpn_connection.cloudflare["01"].static_routes_only == false && aws_vpn_connection.cloudflare["01"].tunnel1_startup_action == "start" && aws_vpn_connection.cloudflare["01"].tunnel1_dpd_timeout_action == "restart" && aws_vpn_connection.cloudflare["01"].tunnel1_replay_window_size == 2048
    error_message = "The dynamic-routing or tunnel liveness settings changed unexpectedly."
  }

  assert {
    condition     = aws_vpn_connection.cloudflare["01"].tunnel2_phase1_encryption_algorithms == toset(["AES256"]) && aws_vpn_connection.cloudflare["01"].tunnel2_phase2_integrity_algorithms == toset(["SHA2-256"]) && aws_vpn_connection.cloudflare["01"].tunnel2_phase1_dh_group_numbers == toset([20]) && aws_vpn_connection.cloudflare["01"].tunnel2_ike_versions == toset(["ikev2"])
    error_message = "The tunnel cryptographic settings changed unexpectedly."
  }

  assert {
    condition     = aws_vpn_connection.cloudflare["01"].tunnel1_phase1_lifetime_seconds == 28800 && aws_vpn_connection.cloudflare["01"].tunnel1_phase2_lifetime_seconds == 3600
    error_message = "The tunnel lifetimes changed unexpectedly."
  }
}

# Customers with two distinct anycast IPs use two VPNs and four tunnels.
run "valid_two_anycast_ip_configuration" {
  command = plan

  override_resource {
    target          = aws_vpn_connection.cloudflare["02"]
    override_during = plan
    values = {
      tunnel1_address = "198.51.100.3"
      tunnel2_address = "198.51.100.4"
    }
  }

  variables {
    cloudflare_anycast_ips = ["162.159.135.1", "162.159.135.2"]
    tunnel_inside_cidrs = [
      "169.254.240.44/30",
      "169.254.240.48/30",
      "169.254.240.52/30",
      "169.254.240.56/30",
    ]
    vpn_preshared_keys = [
      "A0123456789abcdef0123456789abcdef0123456789abcdef",
      "B0123456789abcdef0123456789abcdef0123456789abcdef",
      "C0123456789abcdef0123456789abcdef0123456789abcdef",
      "D0123456789abcdef0123456789abcdef0123456789abcdef",
    ]
  }

  assert {
    condition     = length(aws_customer_gateway.cloudflare) == 2 && length(aws_vpn_connection.cloudflare) == 2 && length(cloudflare_magic_wan_ipsec_tunnel.aws) == 4
    error_message = "The two-anycast-IP configuration must create two customer gateways, two AWS Site-to-Site VPN connections, and four Cloudflare WAN tunnels."
  }

  assert {
    condition     = aws_customer_gateway.cloudflare["01"].ip_address == var.cloudflare_anycast_ips[0] && aws_customer_gateway.cloudflare["02"].ip_address == var.cloudflare_anycast_ips[1]
    error_message = "A customer gateway is mapped to the wrong Cloudflare anycast IP."
  }

  assert {
    condition     = aws_customer_gateway.cloudflare["01"].device_name == "${var.deployment_name}-cgw-01" && aws_customer_gateway.cloudflare["02"].device_name == "${var.deployment_name}-cgw-02"
    error_message = "Each customer gateway must use a unique device name derived from deployment_name."
  }

  assert {
    condition     = cloudflare_magic_wan_ipsec_tunnel.aws["03"].cloudflare_endpoint == var.cloudflare_anycast_ips[1] && cloudflare_magic_wan_ipsec_tunnel.aws["04"].cloudflare_endpoint == var.cloudflare_anycast_ips[1]
    error_message = "Anycast IP 2 must map to Cloudflare tunnels 03 and 04."
  }

  assert {
    condition     = cloudflare_magic_wan_ipsec_tunnel.aws["03"].customer_endpoint == "198.51.100.3" && cloudflare_magic_wan_ipsec_tunnel.aws["04"].customer_endpoint == "198.51.100.4"
    error_message = "Cloudflare WAN tunnels 03 and 04 must map to AWS VPN 02 tunnels 1 and 2."
  }

  assert {
    condition     = [for key in sort(keys(cloudflare_magic_wan_ipsec_tunnel.aws)) : cloudflare_magic_wan_ipsec_tunnel.aws[key].name] == ["cloudflare-wan-reference-tun-01", "cloudflare-wan-reference-tun-02", "cloudflare-wan-reference-tun-03", "cloudflare-wan-reference-tun-04"]
    error_message = "All four Cloudflare tunnel names must be unique and prefixed with deployment_name."
  }

  assert {
    condition     = nonsensitive(cloudflare_magic_wan_ipsec_tunnel.aws["03"].psk) == nonsensitive(var.vpn_preshared_keys[2]) && nonsensitive(cloudflare_magic_wan_ipsec_tunnel.aws["04"].psk) == nonsensitive(var.vpn_preshared_keys[3])
    error_message = "Cloudflare tunnels 03 and 04 must use PSKs 3 and 4."
  }

  assert {
    condition     = aws_vpn_connection.cloudflare["02"].tunnel1_inside_cidr == var.tunnel_inside_cidrs[2] && aws_vpn_connection.cloudflare["02"].tunnel2_inside_cidr == var.tunnel_inside_cidrs[3]
    error_message = "VPN 02 must consume tunnel CIDRs at indexes 2 and 3."
  }
}

# The remaining runs verify a private CF Account ASN and confirm that unsafe or ambiguous inputs fail at plan time.
run "reject_non_network_tunnel_cidr" {
  command = plan

  variables {
    tunnel_inside_cidrs = [
      "169.254.240.45/30",
      "169.254.240.48/30",
    ]
  }

  expect_failures = [var.tunnel_inside_cidrs]
}

run "reject_unsupported_vpc_prefix" {
  command = plan

  variables {
    vpc_cidr = "192.168.0.0/15"
  }

  expect_failures = [var.vpc_cidr]
}

run "reject_unsupported_subnet_prefix" {
  command = plan

  variables {
    workload_subnet_cidr = "192.168.125.0/29"
  }

  expect_failures = [var.workload_subnet_cidr]
}

run "reject_overlapping_subnets" {
  command = plan

  variables {
    tgw_subnet_a_cidr = "192.168.125.0/24"
  }

  expect_failures = [aws_vpc.workload]
}

run "reject_duplicate_cloudflare_anycast_ips" {
  command = plan

  variables {
    cloudflare_anycast_ips = ["162.159.135.1", "162.159.135.1"]
    tunnel_inside_cidrs = [
      "169.254.240.44/30",
      "169.254.240.48/30",
      "169.254.240.52/30",
      "169.254.240.56/30",
    ]
    vpn_preshared_keys = [
      "A0123456789abcdef0123456789abcdef0123456789abcdef",
      "B0123456789abcdef0123456789abcdef0123456789abcdef",
      "C0123456789abcdef0123456789abcdef0123456789abcdef",
      "D0123456789abcdef0123456789abcdef0123456789abcdef",
    ]
  }

  expect_failures = [var.cloudflare_anycast_ips]
}

run "accept_private_cloudflare_asn" {
  command = plan

  variables {
    cloudflare_asn = 65000
  }

  assert {
    condition     = tostring(aws_customer_gateway.cloudflare["01"].bgp_asn) == "65000"
    error_message = "The AWS customer gateway must use a configured private CF Account ASN."
  }
}

run "reject_unsupported_cloudflare_asn" {
  command = plan

  variables {
    cloudflare_asn = 64511
  }

  expect_failures = [var.cloudflare_asn]
}

run "reject_cloudflare_asn_matching_tgw_asn" {
  command = plan

  variables {
    cloudflare_asn = 65020
  }

  expect_failures = [var.cloudflare_asn]
}

run "accept_aws_psk_characters" {
  command = plan

  variables {
    vpn_preshared_keys = [
      "Key.01_a",
      "_Key.02_b",
    ]
  }

  assert {
    condition     = nonsensitive(aws_vpn_connection.cloudflare["01"].tunnel1_preshared_key) == "Key.01_a"
    error_message = "An 8-character PSK with a period and underscore must be accepted."
  }
}

run "reject_psk_with_unsupported_character" {
  command = plan

  variables {
    vpn_preshared_keys = [
      "Invalid-psk-1",
      "B0123456789abcdef0123456789abcdef0123456789abcdef",
    ]
  }

  expect_failures = [var.vpn_preshared_keys]
}

run "reject_short_psk" {
  command = plan

  variables {
    vpn_preshared_keys = [
      "Short_7",
      "B0123456789abcdef0123456789abcdef0123456789abcdef",
    ]
  }

  expect_failures = [var.vpn_preshared_keys]
}

run "reject_psk_with_leading_zero" {
  command = plan

  variables {
    vpn_preshared_keys = [
      "0LeadingZeroKey",
      "B0123456789abcdef0123456789abcdef0123456789abcdef",
    ]
  }

  expect_failures = [var.vpn_preshared_keys]
}

run "reject_default_route_as_vpn_prefix" {
  command = plan

  variables {
    vpn_routed_prefixes = ["0.0.0.0/0"]
  }

  expect_failures = [var.vpn_routed_prefixes]
}

run "reject_mismatched_tunnel_input_cardinality" {
  command = plan

  variables {
    tunnel_inside_cidrs = [
      "169.254.240.44/30",
      "169.254.240.48/30",
      "169.254.240.52/30",
    ]
  }

  expect_failures = [var.tunnel_inside_cidrs]
}

run "reject_mismatched_psk_cardinality" {
  command = plan

  variables {
    vpn_preshared_keys = [
      "A0123456789abcdef0123456789abcdef0123456789abcdef",
    ]
  }

  expect_failures = [var.vpn_preshared_keys]
}

run "reject_duplicate_psks" {
  command = plan

  variables {
    vpn_preshared_keys = [
      "A0123456789abcdef0123456789abcdef0123456789abcdef",
      "A0123456789abcdef0123456789abcdef0123456789abcdef",
    ]
  }

  expect_failures = [var.vpn_preshared_keys]
}

run "reject_zero_cloudflare_anycast_ips" {
  command = plan

  variables {
    cloudflare_anycast_ips = []
    tunnel_inside_cidrs    = []
    vpn_preshared_keys     = []
  }

  expect_failures = [var.cloudflare_anycast_ips]
}

run "reject_more_than_two_cloudflare_anycast_ips" {
  command = plan

  variables {
    cloudflare_anycast_ips = ["162.159.135.1", "162.159.135.2", "162.159.135.3"]
    tunnel_inside_cidrs = [
      "169.254.240.44/30",
      "169.254.240.48/30",
      "169.254.240.52/30",
      "169.254.240.56/30",
      "169.254.240.60/30",
      "169.254.240.64/30",
    ]
    vpn_preshared_keys = [
      "A0123456789abcdef0123456789abcdef0123456789abcdef",
      "B0123456789abcdef0123456789abcdef0123456789abcdef",
      "C0123456789abcdef0123456789abcdef0123456789abcdef",
      "D0123456789abcdef0123456789abcdef0123456789abcdef",
      "E0123456789abcdef0123456789abcdef0123456789abcdef",
      "F0123456789abcdef0123456789abcdef0123456789abcdef",
    ]
  }

  expect_failures = [var.cloudflare_anycast_ips]
}

run "reject_vpn_prefix_overlapping_vpc" {
  command = plan

  variables {
    vpn_routed_prefixes = ["192.168.64.0/18"]
  }

  expect_failures = [var.vpn_routed_prefixes]
}

run "accept_custom_tunnel_names" {
  command = plan

  variables {
    cloudflare_tunnel_names = ["aws-usw1-tun-a", "aws-usw1-tun-b"]
  }

  assert {
    condition     = cloudflare_magic_wan_ipsec_tunnel.aws["01"].name == "aws-usw1-tun-a" && cloudflare_magic_wan_ipsec_tunnel.aws["02"].name == "aws-usw1-tun-b"
    error_message = "Supplied tunnel names must be applied in tunnel order."
  }
}

run "reject_duplicate_tunnel_names" {
  command = plan

  variables {
    cloudflare_tunnel_names = ["aws-tun", "aws-tun"]
  }

  expect_failures = [var.cloudflare_tunnel_names]
}

run "reject_mismatched_tunnel_name_count" {
  command = plan

  variables {
    cloudflare_tunnel_names = ["aws-tun-01"]
  }

  expect_failures = [var.cloudflare_tunnel_names]
}

该配置在创建资源之前验证以下条件:

  • 活动 AWS 账户与 expected_account_id 匹配
  • 该区域至少提供两个可用区
  • 所有三个子网 CIDR 都位于 VPC 内且不重叠
  • vpn_routed_prefixes 包含比 0.0.0.0/0 更具体且不与 VPC CIDR 重叠的唯一规范 IPv4 网络
  • tunnel_inside_cidrs 为每个已配置 anycast IP 包含恰好两个位于 169.254.240.0/20 内的唯一 /30 网络
  • vpn_preshared_keys 为每个已配置 anycast IP 包含恰好两个唯一 PSK,并且每个 PSK 满足 AWS 要求:8-64 个字母、数字、句点或下划线,且不以 0 开头
  • cloudflare_anycast_ips 包含一个或两个不同的 IPv4 地址
  • cloudflare_asn 为 13335 或从 64512 到 65534 的私有 ASN,且与 aws_transit_gateway_asn 不同
  • cloudflare_tunnel_names 为空,或为每个已配置 anycast IP 包含两个仅使用字母、数字、连字符和下划线的唯一名称
  • Cloudflare 账户 ID 是 32 个字符的十六进制标识符
  • 额外通告前缀是唯一的 IPv4 网络 CIDR

初始化并验证 Terraform

从您创建的 Terraform 目录运行这些命令:

terraform init
terraform fmt -check -recursive
terraform validate
terraform test

初始化会解析提供商约束、下载 AWS 和 Cloudflare 提供商,并创建或更新 .terraform.lock.hcl。验证会在不创建资源的情况下检查 Terraform 语法和提供商架构。测试使用模拟提供商,不会创建资源。

查看 Terraform 计划

创建已保存的 plan:

terraform plan -out cloudflare-wan.tfplan

审查每个提议的资源和值。对于基线,plan 应创建:

  • 一个 VPC
  • 一个公网工作负载子网
  • 两个 Transit Gateway 连接子网
  • 一个 Internet Gateway
  • 一个工作负载路由表
  • 一条 Internet 默认路由
  • 每个 vpn_routed_prefixes 条目一条 Transit Gateway 路由
  • 一个 Transit Gateway
  • 一个专用 Transit Gateway 路由表
  • 一个 VPC 连接
  • 一个客户网关
  • 一个包含两条 AWS IPsec/BGP 隧道的 Site-to-Site VPN 连接
  • 两条启用 BGP 的 Cloudflare WAN IPsec 隧道
  • 所需的 Transit Gateway 路由表关联和传播

该 plan 不应创建:

  • 虚拟机或测试主机
  • 独立弹性网络接口 (ENI);AWS 会在连接子网中为 Transit Gateway VPC 连接创建 ENI
  • 安全组
  • 弹性 IP 地址
  • NAT 服务

已保存的 plan 文件可能包含敏感值。请根据组织的密钥处理要求保护和删除 plan 文件。

应用 Terraform 计划

应用已审查的 plan:

terraform apply cloudflare-wan.tfplan

Terraform 会等待 AWS 为每个 VPN 分配公网 IPv4 地址,然后再创建对应的 Cloudflare 隧道。如果操作失败,请更正报告的问题并再次运行 terraform plan。Terraform 会在 state 中保留已成功创建的资源,并仅提议剩余工作。

如果 apply 创建了 AWS 资源,但 Cloudflare 请求因错误 9106(缺少授权标头)失败,则 Terraform 进程无法使用 CLOUDFLARE_API_TOKEN。请设置环境变量,创建并审查新的已保存 plan,然后应用新 plan。不要重用部分应用的已保存 plan,因为失败的 apply 期间 Terraform state 已更改。

Cloudflare 错误 1016 以及 local IP not in Cloudflare assigned IPs 表示配置的 Cloudflare anycast IP 未租给由 cloudflare_account_id 标识的账户。在此消息中,local IP 指的是 cloudflare_endpoint,而不是链路本地 interface_address。请在 Address Space(地址空间) > Leased IPs(租用 IP) 下验证账户 ID 和每个已配置 anycast IP,更新 terraform.tfvars,并创建新的 plan。更改 anycast IP 会替换其 AWS 客户网关,并更新 VPN 连接以使用替换网关。这可能会中断其隧道,因此请审查操作并使用维护窗口。

Terraform 配置会在销毁现有网关之前创建替换客户网关。此顺序使 AWS 可以在移除旧客户网关之前重新定位 VPN 连接。如果 apply 因 IncorrectState: The customer gateway is in use 失败,请确认 aws_customer_gateway 生命周期包含 create_before_destroy = true,丢弃失败的已保存 plan,并创建新的 plan。

apply 完成后删除 cloudflare-wan.tfplan。已保存的 plan 可能包含 VPN 预共享密钥。

显示 Terraform 输出

apply 完成后显示生成的隧道值:

terraform output cloudflare_tunnel_mapping
terraform output workload_egress_routes

隧道输出提供每个 Cloudflare 隧道 ID、AWS 公网 IPv4 地址、Cloudflare anycast IP、内部 CIDR、AWS 内部 IP 和 Cloudflare 接口地址。出口输出列出通过 VPN 路径和 Internet Gateway 默认路由的目的地。Terraform 已将这些值应用到托管资源。当您更改任何参考输入时,输出具有权威性。

隧道 内部 CIDR AWS 内部 IP Cloudflare 接口地址
cloudflare-wan-reference-tun-01 169.254.240.44/30 169.254.240.45 169.254.240.46/30
cloudflare-wan-reference-tun-02 169.254.240.48/30 169.254.240.49 169.254.240.50/30

该表使用默认 deployment_name;cloudflare_tunnel_mapping 中的 tunnel 字段显示实际名称。

按 VPN 连接和内部 CIDR 匹配隧道。不要通过排序生成的 AWS 公网 IPv4 地址来推断隧道顺序。

该表显示参考值。如果更改了隧道 CIDR,请仅使用 Terraform 返回的值。

使用 Terraform 时跳过手动 Cloudflare 隧道和 BGP 创建过程。继续进行 验证。仅使用手动部分来理解或审核 Terraform 配置的值。

验证 Terraform 部署

apply 之后刷新 Terraform state:

terraform apply -refresh-only

在批准之前审查仅刷新的 plan。然后显示 AWS 隧道遥测和 Cloudflare BGP 状态:

terraform output vpn_telemetry
terraform output cloudflare_bgp_status
terraform output workload_egress_routes

每条已配置隧道必须报告 UP。已接受路由计数应与 Cloudflare 通告的前缀数量匹配。在 Cloudflare 仪表板中确认每个已配置 BGP 会话为 Established(已建立)。确认 Cloudflare 从 AWS 学习到了 VPC CIDR。将 workload_egress_routes 与已批准的路由清单进行比较:即使 Internet Gateway 默认路由也匹配,AWS 最长前缀匹配仍会将匹配已配置 VPN 前缀的目的地发送到 Transit Gateway,而不匹配的 IPv4 目的地使用 0.0.0.0/0。完成 验证 中的每项路由、流量和故障转移检查。

同时在 AWS 控制台中验证这些资源:

  • VPC 连接和每个已配置的 VPN 连接使用专用 Transit Gateway 路由表
  • VPC 和每个已配置 VPN 连接的传播处于活动状态
  • 完整 VPC CIDR 显示为指向 VPC 连接的活动传播路由
  • 预期的 RFC 1918 前缀以及任何显式启用的公网前缀显示为通过 VPN 连接的活动传播路由
  • 工作负载子网与预期路由表关联,并在启动时启用公网 IPv4 分配
  • 每个 vpn_routed_prefixes 目的地都以 Transit Gateway 为目标
  • 工作负载路由表将 0.0.0.0/0 发送到 Internet Gateway,而不是 Transit Gateway
  • 此配置未创建虚拟机、独立 ENI、安全组、弹性 IP 地址、NAT 服务或测试主机

移除 Terraform 部署

创建并审查 destroy plan:

terraform plan -destroy -out cloudflare-wan-destroy.tfplan

应用已审查的 destroy plan:

terraform apply cloudflare-wan-destroy.tfplan

Terraform 会在移除其 AWS 依赖项(包括选择性 Transit Gateway 路由、Internet 默认路由、Internet Gateway 和 VPC 资源)之前移除托管的 Cloudflare 隧道。它仅移除当前 Terraform state 中跟踪的资源。除非您将手动创建的 Cloudflare 或 AWS 资源导入此 state,否则不会移除它们。

使用后删除已保存的 destroy plan。遵循包含 PSK 的本地或远程 state 版本的保留策略。

资源

Cloudflare 文档

AWS 文档

这篇文档对您有帮助吗?