跳转到内容
本站为社区维护的非官方中文翻译,与 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
  • 安全组
  • Elastic 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 计划由随附的 terraform test 套件覆盖,该套件使用模拟 provider。

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 学习其路由的 Cloudflare WAN 连接站点未使用 AWS Transit Gateway ASN 65020;否则 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 工作流程。应用之前,请针对您的账户和网络审查生成的计划。不要为同一部署同时完成两种工作流程。

收集 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 和 BGP over IPsec。
  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 令牌运行以下命令:

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 gateway、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(中转网关 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(站点到站点 VPN 连接)。

  2. 选择 Create VPN connection(创建 VPN 连接)。

  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(创建 VPN 连接)。

  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(修改 VPN 隧道选项)。
  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 接口地址 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
预共享密钥 <TUNNEL_01_PSK> <TUNNEL_02_PSK>
隧道健康检查 已启用 已启用
健康检查速率 Medium Medium
健康检查类型 Request Request
健康检查方向 Bidirectional Bidirectional
健康检查目标 默认(不显示) 默认(不显示)
重放保护 已启用 已启用
自动回程路由 已禁用 已禁用

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

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

为每条隧道选择 Use my own pre-shared key(使用我自己的预共享密钥),并输入在匹配 AWS 隧道上配置的 PSK。此集成中 AWS 使用 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. 除非 AWS 必须接收 Unified Routing 数据平面中尚未合格的附加路由,否则将 Additional advertised prefix list(额外通告前缀列表) 留空。
  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 hold time,且无法更改。Cloudflare 通告 240 秒并使用较低值,因此以 AWS 值为准。Cloudflare 要求 hold time 至少为 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 添加黑洞静态路由。对于相同 CIDR,Transit Gateway 静态路由优先于 VPN 传播路由,但不优先于更具体的路由。Cloudflare 通过 BGP 从其他站点学习到的路由只能在源站点撤销或在 AWS 中阻止。在采用 Cloudflare Gateway 出口之前,请移除任何 0.0.0.0/0 黑洞路由。

有关更多信息,请参阅 AWS 文档中的 路由评估顺序 ↗。

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(站点到站点 VPN 连接)。
  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. 确认 192.168.0.0/16 是通过 AWS BGP 会话学习到的。
  6. 检查可用路由路径,并确认预期隧道贡献了路径。
  7. 确认完整的 AWS VPC 前缀存在,并且没有通告不相关的 AWS 前缀。

测试端到端连接

  1. 在可用时启动数据包捕获或流日志查询。
  2. 从 192.168.125.0/24 中允许的 AWS 工作负载,ping 或连接到从 Cloudflare WAN 学习到的前缀中的主机。
  3. 从连接到 Cloudflare WAN 的网络向 AWS 工作负载测试反向方向。
  4. 确认应用程序流没有被意外转换。
  5. 在维护窗口期间,禁用一条隧道,确认其 BGP 路径被撤销,同时流量继续通过另一条隧道。允许每侧最多使用协商的 BGP hold time 来声明会话中断,再加上最多几分钟供 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 作为已传播的 Transit Gateway 路由存在并指向 VPC 附件
  • 检查 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
  • 安全组
  • Elastic 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 区域 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 provider 在创建资源之前会根据此值验证活动账户。

创建限定到目标账户、具有 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 provider 以及账户防护
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 使用模拟 provider 测试参考不变量和无效输入

不要从列表创建 .terraform.lock.hcl。terraform init 会根据 provider 约束生成它,您应提交生成的文件以保留为部署审查过的 provider 选择。.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 和 provider 版本、配置 provider 身份验证、防护 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 的 provider 刷新状态。

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

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

查看 Terraform 计划

创建已保存的计划:

terraform plan -out cloudflare-wan.tfplan

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

  • 一个 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 路由表关联和传播

该计划不应创建:

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

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

应用 Terraform 计划

应用已审查的计划:

terraform apply cloudflare-wan.tfplan

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

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

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,并创建新计划。更改 anycast IP 会替换其 AWS 客户网关,并更新 VPN 连接以使用替换网关。这可能会中断其隧道,因此请审查操作并使用维护窗口。

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

apply 完成后删除 cloudflare-wan.tfplan。已保存的计划可能包含 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 状态:

terraform apply -refresh-only

在批准之前审查仅刷新计划。然后显示 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、安全组、Elastic IP 地址、NAT 服务或测试主机

移除 Terraform 部署

创建并审查销毁计划:

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

应用已审查的销毁计划:

terraform apply cloudflare-wan-destroy.tfplan

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

使用后删除已保存的销毁计划。对于包含 PSK 的本地或远程状态版本,请遵循保留策略。

资源

Cloudflare 文档

AWS 文档

这篇文档对您有帮助吗?