---
title: "Kubernetes Egress Static IP on EKS, GKE, and AKS"
description: "How to give Kubernetes pods a static egress IP on EKS, GKE, and AKS: NAT gateways, Cloud NAT, outbound types, Cilium and Istio egress gateways, and proxies."
canonical: https://fixedmark.com/blog/kubernetes-egress-static-ip
updated: 2026-11-10
source: Fixedmark (https://fixedmark.com), BitMask LLP
---

Platforms · 12 min read

# Kubernetes Egress Static IP on EKS, GKE, and AKS

A pod has no public IP of its own. Its traffic is translated to the node's address, then to a NAT or load balancer address, so you fix that last hop with reserved addresses. Use a NAT gateway with Elastic IPs on EKS, Cloud NAT with a reserved pool on GKE, or AKS NAT Gateway or your own outbound IPs. For only some pods, use an egress gateway (Cilium, AKS Static Egress Gateway) or a static IP proxy.

## Where a pod's outbound address comes from

A pod gets a private address from the cluster network. When it opens a connection to the internet, that address is rewritten at least once before the packet leaves your cloud. The address the partner sees is whatever the last rewrite produced.

On most clusters the chain has two steps. First, the node translates the pod address to its own private address. Second, a NAT gateway, a load balancer, or the node's own public IP translates that to a public address. On EKS, the [Amazon VPC CNI](https://docs.aws.amazon.com/eks/latest/userguide/external-snat.html) rewrites a pod's IPv4 address to the primary private address of the node's primary network interface for any destination outside the VPC. GKE does the same by default through IP masquerade, per Google's [Cloud NAT product interactions](https://docs.cloud.google.com/nat/docs/nat-product-interactions) page.

That second step decides whether you have a static IP. If it is a node's own public address, the egress IP changes every time a node is replaced. Cluster autoscaling, spot interruptions, node image upgrades, and Kubernetes version upgrades all replace nodes. AWS states that an auto-assigned public IPv4 address is [released when the instance stops or terminates](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-instance-addressing.html), and a replacement node gets a new one. A partner that allowlisted last month's node IPs starts rejecting you after a routine upgrade.

So the rule is the same on every cloud. Put the nodes in private subnets with no public addresses, and send their internet traffic through one component that owns addresses you reserved. Then allowlist those addresses. EKS clusters on IPv6 skip translation entirely, and most partner allowlists are IPv4 only. See [IPv6 egress and IPv4-only allowlists](https://fixedmark.com/blog/ipv6-egress-and-ipv4-only-allowlists).

## EKS with NAT gateways and Elastic IPs

On EKS, place the node groups in private subnets. Give each private subnet a default route to a NAT gateway, and give each NAT gateway an Elastic IP. The Elastic IP is yours until you release it, so it survives every node replacement. AWS recommends private subnets for nodes in the same [outbound access guide](https://docs.aws.amazon.com/eks/latest/userguide/external-snat.html).

A classic zonal NAT gateway lives in one Availability Zone. For resilience you run one per AZ, and each one has its own Elastic IP. A cluster across three AZs therefore egresses from three addresses, and the partner must allowlist all three.

**Terminal**

```bash
# Repeat for each AZ that runs nodes (ap-south-1a shown).
# 1. Reserve an Elastic IP. This is an address you allowlist.
aws ec2 allocate-address --domain vpc --region ap-south-1

# 2. Create a zonal NAT gateway in that AZ's public subnet.
aws ec2 create-nat-gateway \
  --subnet-id subnet-0pub1a \
  --allocation-id eipalloc-0aaa1111 \
  --region ap-south-1

# 3. Point the AZ's private subnet route table at it.
aws ec2 create-route \
  --route-table-id rtb-0priv1a \
  --destination-cidr-block 0.0.0.0/0 \
  --nat-gateway-id nat-0aaa1111 \
  --region ap-south-1
```

### Regional NAT gateways

AWS now also offers a [regional NAT gateway](https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateways-regional.html). It spans every AZ where you have workloads, needs no public subnet, and supports up to 32 IP addresses per AZ. It has two modes. In automatic mode, AWS manages the IP addresses and AZ coverage, which AWS recommends for general use. For an allowlist, that is the wrong choice, because the gateway can pick up addresses you did not plan for.

Use manual mode instead. Per the [create-nat-gateway reference](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-nat-gateway.html), passing `--availability-zone-addresses` names the Elastic IPs for each AZ and turns off automatic expansion. Then read the `AutoScalingIps` field in the gateway's description. When it is `enabled`, AWS can add Elastic IPs in an AZ under heavy concurrent load to one destination, and every new address is one your partner has never seen.

**Terminal**

```bash
aws ec2 create-nat-gateway \
  --vpc-id vpc-0abc1234 \
  --availability-mode regional \
  --availability-zone-addresses \
    AvailabilityZone=ap-south-1a,AllocationIds=eipalloc-0aaa1111 \
    AvailabilityZone=ap-south-1b,AllocationIds=eipalloc-0bbb2222 \
  --region ap-south-1

# Check which addresses it uses and whether it may add more.
aws ec2 describe-nat-gateways \
  --nat-gateway-ids nat-0regional1 \
  --query 'NatGateways[0].[NatGatewayAddresses[].PublicIp, AutoScalingIps]' \
  --region ap-south-1
```

You will see advice to set `AWS_VPC_K8S_CNI_EXTERNALSNAT=true` on the `aws-node` DaemonSet. That setting moves the translation from the node to the NAT gateway so that appliances inside your network see pod IPs. It does not change the address the internet sees, which is still the NAT gateway's Elastic IP. You do not need it for allowlisting.

Each NAT gateway bills per hour and per GB processed, plus the public IPv4 charge on each Elastic IP. Run your traffic through the [NAT gateway cost calculator](https://fixedmark.com/tools/nat-gateway-cost-calculator), and see [the hidden costs of a NAT gateway](https://fixedmark.com/blog/nat-gateway-hidden-costs) and [the AWS public IPv4 charge](https://fixedmark.com/blog/aws-public-ipv4-charge-explained) for the line items.

## GKE with Cloud NAT and reserved addresses

On GKE, the fixed hop is Cloud NAT. Create the cluster with private nodes, so nodes have no external IPs. Google's [product interactions page](https://docs.cloud.google.com/nat/docs/nat-product-interactions) states that a Public NAT gateway can translate traffic for both nodes and Pods in a private cluster, provided the gateway covers the subnet's primary range and the Pod secondary range.

Public nodes are the common trap. The same page says that in a cluster whose nodes have external IPs, packets from a node's primary internal address are never processed by Cloud NAT. Pod traffic on those nodes reaches Cloud NAT only if you have changed IP masquerade so it no longer translates Pod traffic to the node address. If you keep public nodes, your egress IP is the node's external IP, and it changes with the node.

The second trap is automatic allocation. Google's own GKE example uses `--auto-allocate-nat-external-ips`, which lets Google choose and scale the addresses. For an allowlist, reserve regional static addresses and pass them with `--nat-external-ip-pool`. The [gcloud reference](https://docs.cloud.google.com/sdk/gcloud/reference/compute/routers/nats/create) describes each pool entry as the name of a reserved static IP address in the same region.

**Terminal**

```bash
# Two reserved addresses in Mumbai. These are what you allowlist.
gcloud compute addresses create gke-egress-1 gke-egress-2 \
  --region asia-south1

gcloud compute routers create gke-nat-router \
  --network prod-vpc \
  --region asia-south1

# SUBNET:ALL covers the node range and every secondary range (Pods, Services).
gcloud compute routers nats create gke-nat \
  --router gke-nat-router \
  --region asia-south1 \
  --nat-external-ip-pool gke-egress-1,gke-egress-2 \
  --nat-custom-subnet-ip-ranges gke-nodes-subnet:ALL
```

Cloud NAT hands each node a block of source ports on the pool addresses. With dynamic port allocation off, the default minimum is 64 ports per VM, per the same reference. A small manual pool and a large node count can run out of ports, which shows up as dropped or failed connections. Size the pool for your peak node count, and add addresses to the pool (and to the partner's allowlist) before you need them.

The [Cloud NAT comparison](https://fixedmark.com/compare/google-cloud-nat) covers what Cloud NAT costs and when a proxy is simpler.

## AKS outbound types

AKS names its egress design with an outbound type. Microsoft's [outbound types guide](https://learn.microsoft.com/en-us/azure/aks/egress-outboundtype) lists them, and each one gives a different answer to the static IP question.

_AKS outbound types and the address a partner sees_

| Outbound type            | Egress path                                            | Static IP story                                                                                                        |
| ------------------------ | ------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------- |
| `loadBalancer` (default) | Outbound rules on the cluster's Standard Load Balancer | AKS creates one public IP unless you supply your own IPs or IP prefixes. Bring your own so you control their lifetime. |
| `managedNATGateway`      | Azure NAT Gateway in an AKS-managed VNet               | Fixed NAT addresses. Newer API versions default to the StandardV2 SKU where available.                                 |
| `userAssignedNATGateway` | Your NAT Gateway on your own VNet subnet               | The NAT gateway's public IPs or prefix, which you own outright.                                                        |
| `userDefinedRouting`     | A `0.0.0.0/0` route to a firewall or appliance you run | The firewall's public IPs. Common in hub and spoke networks.                                                           |
| `none` and `block`       | No egress path, or egress blocked                      | For network isolated clusters. You add any egress yourself.                                                            |

Two warnings from that guide matter for allowlists. You can now change the outbound type after cluster creation, but Microsoft says the change disrupts connectivity and changes the cluster's egress IP address. Plan it as a migration and send the partner the new addresses first.

For the default load balancer path, Microsoft's [Standard Load Balancer guide](https://learn.microsoft.com/en-us/azure/aks/load-balancer-standard) lets you provide your own public IPs or prefixes. It also notes that a public IP created by AKS cannot be reused later as a bring your own address, so reserve your own from the start if you expect to rebuild the cluster.

### AKS Static Egress Gateway

AKS also has a per-pod option. [Static Egress Gateway](https://learn.microsoft.com/en-us/azure/aks/configure-static-egress-gateway) routes selected pods through a dedicated gateway node pool that holds a public IP prefix from `/28` to `/31`. You create the pool with `--mode gateway`, define a `StaticGatewayConfiguration` resource, and annotate the pod template. Only those pods use the prefix. Everything else keeps the cluster's normal outbound path.

**static-gateway.yaml**

```yaml
apiVersion: egressgateway.kubernetes.azure.com/v1alpha1
kind: StaticGatewayConfiguration
metadata:
  name: payouts-egress
  namespace: payouts
spec:
  gatewayNodepoolName: egressgw
  excludeCidrs:
    - 10.0.0.0/8
    - 169.254.169.254/32
---
# In the Deployment's pod template:
# metadata:
#   annotations:
#     kubernetes.azure.com/static-gateway-configuration: payouts-egress
```

Read the limits before you commit. The gateway pool does not support the cluster autoscaler. Pods must be in the same namespace as the configuration. Kubernetes network policies do not apply to the traffic the gateway carries. The feature is IPv4 only and does not work with Azure CNI Pod Subnet. Existing pods pick up the annotation only after a restart.

## Egress gateways inside the cluster

Cluster-wide NAT gives every workload the same address. Sometimes only the payouts service should leave from the address the bank allowlisted. An egress gateway does this inside Kubernetes. Selected pods send their external traffic to designated gateway nodes, and those nodes translate it to a known address.

### Cilium Egress Gateway

If your cluster runs Cilium, a `CiliumEgressGatewayPolicy` selects pods by label and destination CIDR and sends matching traffic out through a gateway node with a chosen source address. Per the [Cilium docs](https://docs.cilium.io/en/stable/network/egress-gateway/egress-gateway/), it requires `egressGateway.enabled=true`, `bpf.masquerade=true`, and `kubeProxyReplacement=true` in the Helm values.

**egress-policy.yaml**

```yaml
apiVersion: cilium.io/v2
kind: CiliumEgressGatewayPolicy
metadata:
  name: payouts-to-bank
spec:
  selectors:
    - podSelector:
        matchLabels:
          app: payouts-worker
          io.kubernetes.pod.namespace: payouts
  destinationCIDRs:
    - "203.0.113.0/24"   # the partner's API range
  egressGateway:
    nodeSelector:
      matchLabels:
        egress-gateway: "true"
    egressIP: 10.0.1.50  # must be assigned to a device on the gateway node
```

The `egressIP` is an address on the gateway node, usually a private one in a cloud VPC. That address still has to reach the internet through a public address you own. Either associate an Elastic IP (or your cloud's equivalent) with it on a gateway node in a public subnet, or put the gateway nodes behind a NAT with reserved addresses. The Cilium docs list limits that matter in production. Changing the gateway node breaks existing connections. New pods can send their first packets with the wrong source IP before the policy applies. If the node selector matches no node, matching traffic is dropped. Run more than one gateway node, and plan how you replace one.

### Istio and Calico

An [Istio egress gateway](https://istio.io/latest/docs/tasks/traffic-management/egress/egress-gateway/) is a set of Envoy pods that mesh traffic leaves through. Istio presents it as a way to apply monitoring and routing to traffic leaving the mesh. It does not, by itself, give you a static IP. The source address is still whatever the gateway pods' nodes use, so you pin those pods to a node pool with fixed addresses or put a NAT in front of them. Istio also says it cannot securely enforce that all egress goes through the gateway. Enforcement has to come from network policy, firewalls, or NAT configuration.

Calico has egress gateways too, but Tigera's [egress gateway docs](https://docs.tigera.io/use-cases/egress-gateways) say they are in Calico Enterprise and Calico Cloud only. Calico Open Source does not support them.

## Per-pod proxy routing

The last option skips cluster networking entirely. The workload sends the calls that need a fixed IP through an HTTP CONNECT or SOCKS5 proxy whose addresses are static. The partner sees the proxy's address. The cluster's own egress path can stay as it is, dynamic node IPs included.

This fits when a platform team owns the cluster network, when the workload runs in several clusters or clouds, or when only a few calls need the address. It works the same on any Kubernetes distribution.

Store the proxy URL in a Secret and expose it under its own variable name. Then pass it to the one client that calls the allowlisted API. Create the Secret from the command line rather than committing it to Git.

**Terminal**

```bash
kubectl create secret generic egress-proxy \
  --namespace payouts \
  --from-literal=PROXY_URL='https://USER:TOKEN@proxy.example.com:443'
```

**deployment.yaml**

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: payouts-worker
  namespace: payouts
spec:
  replicas: 2
  selector:
    matchLabels:
      app: payouts-worker
  template:
    metadata:
      labels:
        app: payouts-worker
    spec:
      containers:
        - name: worker
          image: registry.example.com/payouts-worker:1.4.2
          env:
            - name: PROXY_URL
              valueFrom:
                secretKeyRef:
                  name: egress-proxy
                  key: PROXY_URL
```

**Python**

```python
import os
import httpx

# Only this client uses the proxy. Calls to other services stay direct.
bank = httpx.Client(proxy=os.environ["PROXY_URL"], timeout=15)

payload = {"amount": 50000, "currency": "INR", "account": "ACC123"}
resp = bank.post("https://api.partner-bank.example/v1/payouts", json=payload)
resp.raise_for_status()
```

**Go**

```go
package bank

import (
	"net/http"
	"net/url"
	"os"
	"time"
)

// NewClient returns an HTTP client that sends every request through the proxy.
// Use it only for the allowlisted partner API.
func NewClient() (*http.Client, error) {
	proxyURL, err := url.Parse(os.Getenv("PROXY_URL"))
	if err != nil {
		return nil, err
	}
	transport := &http.Transport{Proxy: http.ProxyURL(proxyURL)}
	return &http.Client{Transport: transport, Timeout: 15 * time.Second}, nil
}
```

You can set `HTTPS_PROXY` on the container instead, and many runtimes will follow it. In a pod that is riskier than it looks. Calls to other Services, to the Kubernetes API, and to the cloud's metadata endpoint at `169.254.169.254` can all end up at the proxy, and so can cloud SDK calls that fetch credentials. If you use the variable, set `NO_PROXY` to cover `.svc`, `.cluster.local`, your Pod and Service CIDRs, and the metadata address. Go's [httpproxy package](https://pkg.go.dev/golang.org/x/net/http/httpproxy) accepts CIDR prefixes and domain suffixes there, and released Go versions read the uppercase variables before the lowercase ones. Other runtimes parse the list differently. See [HTTPS_PROXY and NO_PROXY across tools](https://fixedmark.com/blog/selective-proxying-no-proxy-and-per-client-agents) before you rely on it.

For databases, use SOCKS5. See [database connections through SOCKS5](https://fixedmark.com/blog/database-connections-through-socks5-pooling) and [SOCKS5 vs socks5h](https://fixedmark.com/blog/socks5-vs-socks5h-dns-resolution).

## Which option fits your cluster

_Ways to get a static egress IP from Kubernetes_

| Approach                                                                               | Scope                                  | What you allowlist                                              | Fits when                                                                          |
| -------------------------------------------------------------------------------------- | -------------------------------------- | --------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
| Cloud NAT layer (EKS NAT gateway, GKE Cloud NAT, AKS NAT Gateway or load balancer IPs) | Every pod in the VPC or cluster        | One address per AZ for zonal NAT gateways, or the reserved pool | Any workload may use the address, and you already run private nodes                |
| CNI egress gateway (Cilium, AKS Static Egress Gateway, Calico Enterprise)              | Selected pods or namespaces            | The gateway nodes' public addresses                             | One team needs its own address and you control the CNI                             |
| Istio egress gateway                                                                   | Mesh traffic you route to it           | The gateway nodes' addresses, fixed by NAT or node pool         | You already run Istio and want L7 policy on egress                                 |
| Per-client proxy                                                                       | Individual HTTP clients or connections | The proxy's addresses                                           | Few calls need it, the network is not yours to change, or you run several clusters |

Whatever you choose, keep the address list small and stable. Every change is a ticket in someone else's queue. Two addresses on separate infrastructure are the usual minimum, as [static IP pairs and failover](https://fixedmark.com/blog/static-ip-pairs-and-failover) explains. Keep the partner's authentication in place too, as argued in [IP allowlists in a zero trust world](https://fixedmark.com/blog/ip-allowlists-in-a-zero-trust-world).

## Check the address a partner will see

Check from inside the cluster before you send any address to a partner. Use the real workload's namespace and labels, so egress policies apply to the test pod as they will in production.

**Terminal**

```bash
# A throwaway pod with the workload's namespace and labels.
kubectl run egress-check --rm -it --restart=Never \
  --namespace payouts --labels app=payouts-worker \
  --image curlimages/curl --command -- \
  curl -s https://fixedmark.com/api/ip

# Or from a running pod, if its image has curl.
kubectl exec -n payouts deploy/payouts-worker -- curl -s https://fixedmark.com/api/ip
```

Run it several times, and from pods on nodes in different zones. With one NAT gateway per AZ you should see one address per zone. If you see an address you do not recognise, a node is still in a public subnet or a pool is still on automatic allocation. The [What's my IP tool](https://fixedmark.com/tools/whats-my-ip) shows the same thing from a browser.

## Doing this with Fixedmark

Fixedmark is the per-client proxy option, run for you. It gives your app a pair of static IPv4 addresses in Mumbai, Singapore, Newark, or Ashburn, reached through one proxy URL. You store that URL in a Secret, as above, and pass it to the clients that call allowlisted APIs. Fixedmark is in early access, and the [planned prices](https://fixedmark.com/pricing) put a dedicated IP pair on the Pro plan at $29 a month.

- The URL is HTTP CONNECT over a TLS endpoint on port 443. Databases and other TCP services use SOCKS5, over TLS on port 1443 (which `fm tunnel` uses), or plain on port 1080 for drivers that cannot do TLS, which sends the token in cleartext. TLS to the destination passes through and is never decrypted. See [concepts](https://fixedmark.com/docs/concepts) and the [Python](https://fixedmark.com/docs/python) and [Go](https://fixedmark.com/docs/go) guides for client code.
- The same pair works from every cluster and cloud you run, so one allowlist entry covers EKS in `ap-south-1` and a GKE cluster elsewhere.
- Your cluster's own NAT still carries the connection to the proxy, but its address no longer has to be stable or known to the partner.
- Connection logs show the destination, SNI, egress IP, and result of each connection, which helps when a partner says your call never arrived. On Business and above, [destination allowlists](https://fixedmark.com/docs/allowlists) limit a credential to the hosts it needs.
- The trial runs on a shared IP pair, so do not register its addresses with a bank or broker. Check what the partner sees with [Verify your egress IP](https://fixedmark.com/docs/verify-egress-ip).

## Sources

Checked November 2026. Confirm current details on the vendor's site before you decide. Prices and limits change.

- [Amazon EKS: Enable outbound internet access for Pods](https://docs.aws.amazon.com/eks/latest/userguide/external-snat.html)
- [Amazon VPC: Regional NAT gateways](https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateways-regional.html)
- [AWS CLI reference: create-nat-gateway](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-nat-gateway.html)
- [Amazon EC2: Instance IP addressing](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-instance-addressing.html)
- [Google Cloud: Cloud NAT product interactions](https://docs.cloud.google.com/nat/docs/nat-product-interactions)
- [Google Cloud: gcloud compute routers nats create](https://docs.cloud.google.com/sdk/gcloud/reference/compute/routers/nats/create)
- [Microsoft Learn: Customize cluster egress with outbound types in AKS](https://learn.microsoft.com/en-us/azure/aks/egress-outboundtype)
- [Microsoft Learn: Configure Static Egress Gateway in AKS](https://learn.microsoft.com/en-us/azure/aks/configure-static-egress-gateway)
- [Microsoft Learn: Use a public Standard Load Balancer in AKS](https://learn.microsoft.com/en-us/azure/aks/load-balancer-standard)
- [Cilium: Egress Gateway](https://docs.cilium.io/en/stable/network/egress-gateway/egress-gateway/)
- [Istio: Egress Gateways](https://istio.io/latest/docs/tasks/traffic-management/egress/egress-gateway/)
- [Tigera: Egress gateways](https://docs.tigera.io/use-cases/egress-gateways)
- [Go: golang.org/x/net/http/httpproxy](https://pkg.go.dev/golang.org/x/net/http/httpproxy)

Keep reading

## Related guides

- [Comparison AWS NAT Gateway The real monthly cost of a highly available AWS NAT Gateway, and when a static IP proxy is simpler.](https://fixedmark.com/compare/aws-nat-gateway)
- [Comparison Google Cloud NAT What a static outbound IP through Cloud NAT costs and involves on Google Cloud, and when a proxy is simpler.](https://fixedmark.com/compare/google-cloud-nat)
- [Use case Partner API allowlisting Give Salesforce, SOAP vendors, and payment gateways one dedicated IP pair to allowlist, wherever your code runs.](https://fixedmark.com/use-cases/partner-api-allowlisting)
- [Use case Bank and UPI APIs Whitelist one dedicated IP pair with your bank, UPI partner bank, or GSP, then deploy on Vercel or Railway without re-whitelisting.](https://fixedmark.com/use-cases/bank-and-upi-apis)
- [Tool NAT gateway cost calculator Work out what NAT gateways per AZ cost for your cluster's traffic.](https://fixedmark.com/tools/nat-gateway-cost-calculator)

## Frequently asked questions

### Do Kubernetes pods get their own public IP?

Not on EKS, GKE, or AKS by default. A pod's IPv4 address is private, and its internet traffic is translated to the node's address and then to a NAT gateway, load balancer, or node public IP. The partner sees that last address. EKS clusters on IPv6 are the exception, since IPv6 pod addresses are not translated.

### Will my egress IP change when the cluster autoscales?

It changes if nodes have their own public IPs, because new nodes get new addresses. It stays fixed behind a NAT gateway with Elastic IPs, Cloud NAT with a manual pool of reserved addresses, or an AKS NAT Gateway or load balancer with IPs you own. Automatic allocation modes can add addresses under load.

### Can I give one namespace a different static IP from the rest of the cluster?

Yes. Use an egress gateway that selects pods, such as a CiliumEgressGatewayPolicy or AKS Static Egress Gateway with a StaticGatewayConfiguration in that namespace. Calico's egress gateway needs Calico Enterprise or Calico Cloud. Or route that namespace's calls through a static IP proxy.

### Does an Istio egress gateway give me a static IP?

Not by itself. Traffic leaves from the nodes the gateway pods run on, so you still need those nodes behind a NAT with fixed addresses or in a node pool with reserved IPs. Istio also notes that it cannot securely force all traffic through the gateway.

### Should I set HTTPS_PROXY on the whole pod?

Only with a careful NO_PROXY that covers cluster DNS suffixes, Pod and Service CIDRs, and the cloud metadata address. Otherwise in-cluster calls and cloud SDK credential calls can go to the proxy. Passing the proxy to one client is safer.
