TL;DR
- What happened: AWS introduced PrivateLink tunnel endpoints, allowing consumer VPCs to connect directly to an entire shared CIDR range in a provider account rather than enumerating individual target IP addresses behind load balancers.
- Who is affected: Enterprise network architects, platform engineers, SREs, and cloud security leads managing multi-account environments, vendor network integrations, or distributed clusters.
- Technical requirement: Client workloads must encapsulate outbound Layer 4 traffic using GENEVE (RFC 8926) over UDP port 6081 targeted at endpoint interfaces within the same Availability Zone.
- Security impact: Traffic is strictly unidirectional (consumer-initiated only) and permits overlapping IP space, but protocol support is restricted to TCP and DNS-UDP. ICMP, ping, and IP fragments are dropped. Access logs omit inner source IP addresses.
- What to do now: Scope Resource Access Manager (RAM) shares to minimal destination CIDRs (avoiding 0.0.0.0/0), validate Availability Zone mapping across accounts, automate host-level GENEVE encapsulation, and reference resource gateway security groups on provider targets.
Connecting applications across independent cloud environments traditionally forces network architects to choose between full network exposure or brittle, single-resource mappings. Standard AWS PrivateLink interface endpoints require explicit target enumeration through Network Load Balancers (NLBs), creating significant operational friction for multi-node distributed architectures. AWS expanded its inter-VPC networking capabilities by launching aws privatelink tunnel endpoints, enabling consumer Virtual Private Clouds (VPCs) to reach an entire shared Classless Inter-Domain Routing (CIDR) block hosted in a provider account.
Originally introduced in September 2026, the capability addresses longstanding multi-account integration challenges. As detailed in a technical walkthrough published by AWS engineers Bruce Pinsky and Ashish Kumar and reported by InfoQ on 18 November 2026, the feature establishes a unidirectional network path across accounts without exposing an entire VPC. By leveraging AWS Resource Access Manager (RAM) to share address ranges, organisations can expose dynamic target resources—including instances and microservices instantiated after the initial share configuration—without modifying client-side endpoint resources.
However, adopting tunnel endpoints introduces distinct architectural and operational requirements. Traffic sent from consumer applications to a tunnel endpoint must be encapsulated using the Generic Network Virtualization Encapsulation (GENEVE) protocol (RFC 8926) over User Datagram Protocol (UDP) port 6081 within matching Availability Zones. This analysis examines the packet-level mechanics, client-side operating system configuration, traffic constraints, security group implications, and Terraform provisioning workflows required to deploy tunnel endpoints in enterprise AWS environments.
Cross-Account VPC Connectivity Beyond Single-Resource Endpoints
Enterprise cloud architectures frequently rely on multi-account topologies to enforce security boundaries, isolate blast radiuses, and manage billing autonomy. When applications in a consumer VPC require access to services hosted in a provider VPC, network teams must select an inter-VPC connectivity model that balances administrative overhead against network exposure risks.
Standard PrivateLink interface endpoints solve cross-account access by placing an Elastic Network Interface (ENI) inside a consumer subnet. Traffic routed to this ENI traverses AWS internal infrastructure to reach a Network Load Balancer (NLB) or VPC Lattice service in the provider account. While this model isolates networks at Layer 4, it imposes strict structural limits:
- Single-IP and Single-Resource Mapping: Each interface endpoint maps to a specific load balancer or service. Connecting to multiple host destinations requires creating individual interface endpoints or configuring complex port-based mapping horizons on a single NLB.
- Distributed Cluster Complexity: Multi-node systems that perform client-side load balancing—such as self-managed Apache Kafka, Aerospike, or Cassandra—require client applications to discover and establish direct TCP connections to individual cluster nodes. Routing client traffic through a single NLB endpoint breaks node discovery unless every broker or node is mapped to a unique port and public/private address pair.
- High Ephemeral Resource Churn: When provider architectures rely on auto-scaling groups or short-lived compute instances, updating NLB target groups and maintaining consumer-side mapping configurations introduces deployment lag and potential connection failures.
This structural limitation creates the classic “vendor-access problem.” Third-party SaaS providers or internal platform teams hosting managed infrastructure need to reach, or be reached by, customer applications across account boundaries. Granting network access via traditional VPC Peering exposes the entire network topology in both directions. If a customer or partner organisation operates under strict regulatory compliance frameworks, security auditors often reject bidirectional peering due to the broad, uncontrolled attack surface it creates.
Tunnel endpoints address this gap by shifting the unit of sharing from an individual network load balancer to an entire CIDR address range defined in AWS RAM. A provider defines a network boundary (for example, 10.100.0.0/16), and any resource instantiated within that block automatically becomes reachable by the consumer. Resources residing outside that declared perimeter remain strictly isolated, satisfying compliance requirements while eliminating the need to reconfigure endpoints whenever target workloads scale.
Architectural Overview: RAM CIDR Sharing and Resource Gateways
The tunnel endpoint architecture establishes a decoupled, unidirectional connection boundary across AWS account borders. The topology relies on four primary components: the provider VPC, an AWS Resource Access Manager (RAM) CIDR resource configuration, an AWS Resource Gateway, and the consumer VPC Tunnel Endpoint.
+-----------------------------------------------------------------------------------+
| CONSUMER VPC |
| |
| +---------------------+ |
| | Client Application | |
| +----------+----------+ |
| | (Plain TCP payload) |
| v |
| +----------+----------+ GENEVE / UDP 6081 +-------------------------+ |
| | Linux Kernel / Proxy| ===========================> | VPC Tunnel Endpoint ENI | |
| +---------------------+ (Same Availability Zone) +------------+------------+ |
+--------------------------------------------------------------------|--------------+
|
AWS PrivateLink Backplane
|
+--------------------------------------------------------------------v--------------+
| PROVIDER VPC | |
| +------------+------------+ |
| | AWS Resource Gateway | |
| +------------+------------+ |
| | |
| Source NAT to Gateway IP address |
| v |
| +-----------------------+ +---------------+-----------+ |
| | Provider Workload B | | Provider Workload A | |
| | (10.100.1.20:9092) | | (10.100.1.10:9092) | |
| +-----------------------+ +---------------------------+ |
| ^ ^ |
| |_________________ Shared CIDR Range _________________| |
| (10.100.0.0/16) |
+-----------------------------------------------------------------------------------+
The provider network team initiates the architecture by defining a CIDR-type resource configuration in AWS RAM. This configuration specifies the network range that the consumer is permitted to reach. Once shared via RAM and accepted by the consumer account, the consumer provisions a VPC endpoint of type Tunnel within their local subnets, referencing the RAM resource configuration Amazon Resource Name (ARN).
On the provider side, AWS automatically manages an infrastructure component known as the AWS Resource Gateway. The resource gateway acts as the egress point where cross-account encapsulated packets enter the provider VPC as native IP traffic.
Key architectural properties governing this relationship include:
- Strict Unidirectionality: Connection initiation is permitted only from the consumer VPC toward the provider network. Applications in the provider VPC cannot open TCP streams or initiate network handshakes targeting IP addresses in the consumer VPC.
- Overlapping CIDR Support: The consumer VPC and provider VPC are permitted to use identical or overlapping IPv4 address spaces (for example, both VPCs assigned
10.0.0.0/16). Because the endpoint performs encapsulation and source network address translation (SNAT) at the boundary, IP space collisions between host networks do not disrupt routing. - Resource Gateway DNS Immutability: The DNS configuration setting of an AWS resource gateway cannot be modified after its creation. Network architects must evaluate and declare required DNS behaviors during the initial gateway setup phase.
Packet Mechanics: GENEVE Encapsulation over UDP Port 6081
Unlike standard interface endpoints that accept plain Ethernet packets routed to an ENI IP address, PrivateLink tunnel endpoints require client applications or intermediate proxies to explicitly wrap traffic in GENEVE (RFC 8926) headers prior to endpoint ingress.
GENEVE is a flexible network virtualisation protocol that encapsulates Layer 2 or Layer 3 frames inside UDP datagrams. In the tunnel endpoint architecture, outer datagrams are addressed to the tunnel endpoint’s local ENI IP address over UDP port 6081. The inner payload contains the original, unencapsulated IP packet addressed to the ultimate target host in the provider VPC.
Step-by-Step Packet Lifecycle
- Client Encapsulation: The client host or proxy intercepts traffic destined for the shared provider network range (e.g.,
10.100.1.10:9092). It constructs an inner IP packet with source10.0.1.50(client local IP) and destination10.100.1.10. The kernel or proxy wraps this frame in a GENEVE header (Virtual Network Identifier / VNI metadata) and encloses it within an outer UDP packet destined for the local Tunnel Endpoint ENI IP (e.g.,10.0.1.200:6081). - Endpoint Ingress & Decapsulation: The packet arrives at the tunnel endpoint ENI. According to AWS documentation and analysis by InfoQ, the endpoint performs three sequential operations:
- Strips the outer IP, UDP, and GENEVE headers.
- Validates that the inner destination IP address (
10.100.1.10) falls within the shared RAM CIDR boundary. If the inner destination lies outside the authorized range, the packet is silently dropped. - Rewrites the source IP address of the inner packet from the client’s local IP (
10.0.1.50) to the local IP address of the AWS Resource Gateway provisioned in the provider VPC.
- Provider Ingress & Delivery: The decapsulated plain IP packet enters the provider VPC. Target host
10.100.1.10receives a standard TCP frame arriving from the Resource Gateway source IP. Return traffic follows standard stateful connection tracking back to the Resource Gateway, which routes response packets back across the PrivateLink backplane to the consumer endpoint.
Availability Zone Placement Requirement
Tunnel endpoint subnets and provider resource gateways must reside in matching or overlapping Availability Zones. If a consumer endpoint is provisioned in an AZ where the provider’s resource gateway lacks an operational footprint, the association status will report as inaccessible, preventing packet delivery.
AWS has not publicly disclosed exact figures for maximum throughput ceilings, packet-per-second (PPS) limits, or latency overhead introduced by GENEVE header processing on tunnel endpoint ENIs. Architectural teams running high-throughput workloads should benchmark latency impact prior to full-scale deployment.
Client-Side Routing and Operating System Implementation Details
Because applications do not natively wrap TCP streams in GENEVE datagrams, platform engineers must implement encapsulation at the host kernel or intermediate proxy layer within the consumer VPC.
Native Linux Kernel Encapsulation
Modern Linux kernels contain native support for GENEVE interfaces through the netlink subsystem. Engineers can isolate vendor-bound traffic using network namespaces and Virtual Ethernet (veth) pairs or by attaching a virtual GENEVE interface directly to the host routing table.
The following example demonstrates creating a dedicated network namespace, configuring a GENEVE device (ID 0) targeted at a local Tunnel Endpoint ENI, and routing a shared provider CIDR (10.100.0.0/16) through the tunnel:
# Enable IP forwarding on host (test in staging environment first)
sudo sysctl -w net.ipv4.ip_forward=1
# Create a network namespace for shared vendor traffic
sudo ip netns add vendor_ns
# Create GENEVE interface pointed to local Tunnel Endpoint ENI IP (10.0.1.200)
sudo ip link add dev geneve0 type geneve id 0 remote 10.0.1.200 dstport 6081
# Move the GENEVE interface into the network namespace
sudo ip link set geneve0 netns vendor_ns
# Configure and bring up the interface inside the namespace
sudo ip netns exec vendor_ns ip link set dev geneve0 up
sudo ip netns exec vendor_ns ip addr add 10.0.1.50/24 dev geneve0
# Route the provider shared CIDR range into the tunnel interface
sudo ip netns exec vendor_ns ip route add 10.100.0.0/16 dev geneve0
# Execute client workloads within the namespace
sudo ip netns exec vendor_ns curl -v http://10.100.1.10:8080
Empirical Patterns and Proxy Deployments
Empirical testing conducted by Ryo Suzuki of cloud consultancy Classmethod provided practical insights into handling overlapping address spaces. Suzuki connected two VPCs that both utilized the 10.0.0.0/16 primary address space. HTTP traffic successfully reached target hosts across the tunnel endpoint, but required specific host-level networking strategies:
- Root-Level Relay Process: Running a custom GENEVE relay daemon with root privileges on client hosts to intercept outbound sockets and construct outer UDP/6081 frames.
- Destination
/32Routing: Adding explicit/32host routes to the client kernel routing table for every individual destination host in the provider network to prevent local VPC route collisions. Suzuki noted that “route management according to the number of destinations is required,” creating operational overhead as target node counts grow. - Intermediate Proxy Topologies (HAProxy / NAT): Placing a dedicated HAProxy instance or client-side NAT instance in front of the tunnel endpoint. Client applications send standard TCP requests to the proxy; the proxy encapsulates packets inside GENEVE and forwards them to the tunnel endpoint ENI.
| Implementation Pattern | Operational Overhead | Latency Impact | Failure Domain Risk |
|---|---|---|---|
| Direct Kernel Namespace | High (requires daemonset/agent configuration per application pod/host) | Minimal (kernel-native encapsulation) | Isolated to individual host instance |
| Per-Host /32 Route Tables | High (requires real-time route orchestration as targets churn) | Minimal (standard host routing table lookup) | Route desynchronisation across host fleet |
| Intermediate HAProxy / NAT Fleet | Medium (requires managing proxy EC2/container clusters) | Adds 1 additional network hop (~0.5–1.5ms) | Proxy cluster becomes potential bottleneck and SPOF |
Comparing Tunnel Endpoints with VPC Peering and AWS VPC Lattice
AWS offers multiple mechanisms for inter-VPC connectivity. Selecting the appropriate model requires evaluating OSI operating layer, access directionality, administrative boundaries, and security compliance constraints.
| Feature Metric | PrivateLink Tunnel Endpoints | VPC Peering | AWS VPC Lattice | Standard PrivateLink Interface |
|---|---|---|---|---|
| OSI Operating Layer | Layer 4 (TCP, DNS-UDP) | Layer 3 (All IP protocols) | Layer 7 (HTTP, HTTPS, gRPC) | Layer 4 (TCP, UDP) |
| Directionality | Unidirectional (Consumer → Provider) | Bidirectional (Full IP routing) | Unidirectional (Client → Service) | Unidirectional (Consumer → Provider) |
| Scope of Exposure | Shared CIDR range | Entire peered subnets/VPCs | Specific registered Service | Single NLB / IP target |
| Overlapping CIDRs | Supported | Not Supported | Supported | Supported |
| Encapsulation Required | Yes (GENEVE UDP 6081) | No (Native IP routing) | No (Standard HTTP/gRPC) | No (Native ENI forwarding) |
| Target Node Churn | Automatic reachability within CIDR | Automatic reachability within subnet | Handled via target group registration | Requires NLB target group update |
VPC Peering vs. Tunnel Endpoints
VPC Peering establishes full Layer 3 connectivity. While simple to deploy, peering bridges route tables in both directions. In vendor integrations or multi-tenant enterprise topologies, peering with an external or unregulated partner introduces risk: compromised instances in the partner network can actively scan and probe resources across the peer link. Tunnel endpoints enforce unidirectional boundaries at Layer 4, ensuring partner networks cannot initiate outbound connections back into the consumer network.
AWS VPC Lattice vs. Tunnel Endpoints
AWS VPC Lattice operates at Layer 7, providing service-level authentication, context-aware IAM policies, and application routing for HTTP, HTTPS, and gRPC traffic. However, non-HTTP protocols (such as raw TCP used by custom database wire protocols, Kafka binary protocols, or legacy enterprise applications) cannot run over VPC Lattice. PrivateLink tunnel endpoints provide network-level CIDR sharing for Layer 4 TCP workloads without requiring individual application service definitions for every microservice target.
Operational Limits, Traffic Constraints, and Security Boundaries
While tunnel endpoints offer flexible CIDR sharing, AWS enforces strict operational boundaries and protocol limitations that impact architecture design and security monitoring.
Supported and Dropped Protocols
Inner traffic encapsulated within GENEVE headers must conform to rigid protocol rules:
- Supported Protocols: Standard TCP streams and UDP traffic restricted exclusively to DNS (port 53).
- Explicitly Dropped Traffic: Internet Control Message Protocol (ICMP) datagrams (including
pingandtraceroute), non-DNS UDP traffic, and fragmented IP packets are silently dropped by the tunnel endpoint ENI. - No Private DNS Resolution: Private DNS names are not supported natively on tunnel endpoints. Consumer workloads must reference provider target instances directly by inner IP address or resolve hostnames via external DNS setups over permitted DNS-UDP paths.
Troubleshooting ICMP Failures
Standard network diagnostic utilities such as ping or mtr will fail across a PrivateLink tunnel endpoint. SREs and network operations teams must use Layer 4 connectivity tools (e.g., nc -zv <target-ip> <port> or tcping) to validate path reachability.
Security Group Reference Rules
Because the tunnel endpoint performs Source NAT (SNAT), target resources in the provider VPC do not see the client’s actual inner IP address (10.0.1.50). Instead, incoming packets present the IP address of the provider’s AWS Resource Gateway.
Consequently, provider security groups attached to target workloads (such as database nodes or Kafka brokers) cannot filter traffic based on individual client host IP addresses. Provider security groups must be configured to permit ingress traffic from:
- The specific Security Group assigned to the AWS Resource Gateway, or
- The subnet CIDR block containing the Resource Gateway ENIs.
Logging Limitations and Attribution Gaps
VPC Endpoint access logs for tunnel endpoints capture details regarding the consumer endpoint ID, bytes transferred, and connection metadata. However, access logs do not contain a field for the inner source IP address of the originating client host.
For provider security teams, this creates an attribution gap: log entries record that traffic entered via a specific vendor’s tunnel endpoint, but cannot distinguish which individual container, pod, or host behind that vendor’s endpoint initiated the TCP connection. AWS roadmap timelines for introducing inner source IP logging into VPC Flow Logs or endpoint logs remain unconfirmed.
The 0.0.0.0/0 Blast Radius Risk
When creating a CIDR resource configuration in AWS RAM, providers can technically define 0.0.0.0/0 as the shared address space. AWS documentation and InfoQ warn that sharing 0.0.0.0/0 grants the consumer account access to everything routable from the provider VPC.
If the provider VPC contains routes to AWS Direct Connect, Site-to-Site VPNs, secondary VPC Peering connections, or NAT Gateways, the consumer tunnel endpoint can transitively traverse those paths. In empirical tests conducted by Ryo Suzuki, a consumer VPC lacking an Internet Gateway or NAT Gateway shared 0.0.0.0/0 with a provider VPC containing a NAT Gateway; the consumer host successfully routed outbound public internet traffic through the provider’s NAT Gateway.
Strict RAM CIDR Scoping Mandatory
Never declare 0.0.0.0/0 in a production RAM resource configuration unless the explicit architectural goal is to provide full transit routing. Providers should restrict RAM shared configurations to explicit, narrow target subnets (e.g., 10.100.10.0/24).
Infrastructure as Code: Provisioning Tunnel Endpoints with Terraform
Support for tunnel endpoints was introduced in version 6.71.0 of the HashiCorp Terraform AWS Provider. The implementation introduces the Tunnel endpoint type on aws_vpc_endpoint resources and the cidr_resource configuration block within Lattice resource configurations.
The following example demonstrates declaring provider-side RAM CIDR sharing alongside consumer-side tunnel endpoint provisioning:
# Provider Account Configuration
# File: provider_network.tf
resource "aws_vpc_lattice_resource_configuration" "provider_cidr_share" {
name = "corp-kafka-cluster-share"
type = "CIDR"
cidr_resource {
ip_address_space = "10.100.0.0/16"
}
tags = {
Environment = "production"
ManagedBy = "terraform"
}
}
resource "aws_ram_resource_share" "provider_ram_share" {
name = "ram-share-kafka-cidr"
allow_external_principals = true
}
resource "aws_ram_resource_association" "ram_cidr_association" {
resource_arn = aws_vpc_lattice_resource_configuration.provider_cidr_share.arn
resource_share_arn = aws_ram_resource_share.provider_ram_share.arn
}
resource "aws_ram_principal_association" "ram_consumer_association" {
principal = "123456789012" # Consumer AWS Account ID
resource_share_arn = aws_ram_resource_share.provider_ram_share.arn
}
# -------------------------------------------------------------------
# Consumer Account Configuration
# File: consumer_endpoint.tf
resource "aws_vpc_endpoint" "tunnel_endpoint" {
vpc_id = "vpc-0a1b2c3d4e5f6789a"
service_name = aws_vpc_lattice_resource_configuration.provider_cidr_share.name
vpc_endpoint_type = "Tunnel"
subnet_ids = [
"subnet-0123456789abcdef0", # Must match provider AZ footprint
"subnet-abcdef0123456789a"
]
security_group_ids = [
"sg-0fe987654321ba098"
]
tags = {
Name = "vpce-tunnel-to-provider-kafka"
Environment = "production"
}
}
Billing Model Overview
Tunnel endpoint usage incurs split charges across consumer and provider AWS accounts across all 28 supported regions:
- Consumer Account: Billed an hourly fee for each tunnel endpoint provisioned, plus per-gigabyte data processing fees calculated under standard AWS PrivateLink rates.
- Provider Account: Billed per-gigabyte data processing fees for traffic flowing through the AWS Resource Gateway, calculated under AWS VPC Lattice pricing schedules.
Exact regional hourly and per-gigabyte monetary rates across all 28 supported AWS regions are not disclosed in standard release summaries and vary depending on target region economics.
Practical Guidance for Network Architects and Security Teams
To successfully integrate AWS PrivateLink tunnel endpoints without introducing security vulnerabilities or routing instability, platform teams should adhere to this implementation checklist:
Step 1: Enforce Strict CIDR Scoping
Audit all RAM resource configurations prior to sharing. Ensure CIDR blocks strictly bound the specific subnets hosting target application workloads. Never share top-level supernets or 0.0.0.0/0 unless building an intentional egress transit gateway model.
Step 2: Validate Availability Zone ID Mapping
AWS account AZ names (e.g., eu-west-1a) are randomly mapped to physical Availability Zone IDs (e.g., euw1-az1) across different accounts. Prior to provisioning resource gateways and tunnel endpoints, cross-reference account ZoneId attributes using the AWS CLI to ensure subnets sit in physically matching AZs:
aws ec2 describe-availability-zones --query "AvailabilityZones[*].[ZoneName, ZoneId]" --output table
Step 3: Automate Host-Level GENEVE Management
Avoid relying on manual, ad-hoc shell scripts to manage kernel network namespaces and GENEVE device interfaces. Platform teams deploying on Kubernetes should deploy a lightweight CNI plugin, systemd-networkd profile, or DaemonSet to automate GENEVE interface instantiation and routing table management during node boot sequences.
Step 4: Update Provider Security Groups and Compensating Controls
Update provider-side security groups to explicitly whitelist ingress traffic from the Resource Gateway security group on target ports (e.g., TCP 9092 for Kafka, TCP 5432 for PostgreSQL). Because inner client source IP addresses are omitted from access logs, mandate application-level authentication (such as TLS client certificates or SASL/SCRAM) to establish workload identity at Layer 7.
Common Operational Mistakes
- Attempting ICMP Health Checks: Configuring synthetic monitoring probes that rely on
pingtargeting inner IPs across the tunnel endpoint. ICMP will be dropped at the endpoint boundary, generating false-positive outage alerts. - Modifying Resource Gateway DNS Post-Creation: Expecting to update DNS settings on an existing resource gateway. Changing DNS settings requires destroying and recreating the gateway resource.
- Asymmetric AZ Subnet Allocation: Provisioning a consumer endpoint in a single AZ while target workloads span three AZs, resulting in degraded availability or inaccessible status state.
Key Takeaways for Enterprise AWS Infrastructure Engineers
AWS PrivateLink tunnel endpoints solve a fundamental scaling limitation of traditional inter-VPC networking. By shifting from single-resource load balancer targets to RAM-shared CIDR ranges, organisations can connect complex, multi-node clusters across accounts without maintaining rigid IP mapping horizons or exposing full networks via VPC Peering.
However, the architecture requires clear operational trade-offs. Requiring Layer 4 GENEVE (RFC 8926) encapsulation over UDP port 6081 shifts routing complexity to the client operating system or intermediate proxy layer. Furthermore, protocol limits (no ICMP, no non-DNS UDP) and logging gaps (omission of inner source IPs) necessitate strong compensating security controls at the application layer.
When evaluating inter-VPC patterns: select VPC Peering for trusted, internal same-organisation network mesh connectivity; choose AWS VPC Lattice for Layer 7 HTTP/gRPC microservice management; utilize standard PrivateLink Interface Endpoints for discrete, single-resource vendor integrations; and deploy PrivateLink Tunnel Endpoints when secure, unidirectional Layer 4 access to multi-node clusters or dynamic CIDR address ranges is required across account boundaries.
Frequently asked questions
What protocol is required to send traffic through an AWS PrivateLink tunnel endpoint?
Client workloads or intermediate proxies must encapsulate outbound IP frames inside GENEVE (RFC 8926) headers over UDP port 6081. The outer packet is addressed to the local tunnel endpoint interface IP, while the inner payload contains the TCP or DNS-UDP frame targeted at the provider network address.
How do PrivateLink tunnel endpoints differ from standard VPC Peering?
VPC Peering enables full, bidirectional Layer 3 network routing across peered subnets, exposing whole VPC topologies to both sides. PrivateLink tunnel endpoints enforce unidirectional access (consumer-to-provider only) across a restricted, RAM-shared CIDR block, allow overlapping IP spaces, and require client-side GENEVE encapsulation.
Can provider networks initiate connections back to the consumer VPC through a tunnel endpoint?
No. PrivateLink tunnel endpoints are strictly unidirectional. Network connections can only be established starting from the consumer VPC toward destination addresses inside the shared provider CIDR range. Resources in the provider network cannot initiate TCP handshakes or open sockets back to consumer workloads.
Why are ICMP ping tests failing across my AWS PrivateLink tunnel endpoint?
AWS PrivateLink tunnel endpoints explicitly drop ICMP traffic, IP fragment packets, and non-DNS UDP datagrams at the endpoint boundary. Only TCP streams and UDP port 53 (DNS) traffic are permitted. SRE teams must use Layer 4 connection testing tools such as netcat or tcping to verify routing.
Does AWS record the original inner client IP address in tunnel endpoint access logs?
No. VPC endpoint access logs record the consumer endpoint ID, transit byte counts, and connection metadata, but do not log the inner client source IP address. Traffic entering the provider VPC undergoes Source NAT, presenting the AWS Resource Gateway IP address as the source client to target servers.
Sources and further reading
This article was drafted with AI assistance from the publicly cited sources and passed automated checks for structure and sourcing. Verify critical details against the vendor advisories linked above before acting.