> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.fabricgateway.ai/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.fabricgateway.ai/_mcp/server.

# Network and egress

> Every network path the Fabric AI Gateway data plane uses, the egress you need to allow, and the ports inside the cluster.

This page applies to the Enterprise plan, where you run the data plane in your own VPC. It lists every network path the data plane's components use, so you can pre-authorize firewall and security group rules before you install. The data plane only makes outbound connections to Postman. The control plane never connects in to your VPC.

With workload attestation, the control plane also reads your cluster's public signing keys from its OIDC issuer URL, unless you paste the keys when you register the trust anchor. If your issuer isn't reachable from the internet, select **Paste JWKS**. See [Connect to the control plane](/run/connect-a-data-plane).

## Data flow

1. Your clients send requests to the gateway Service on port `8080`.
2. The gateway pods keep an mTLS connection open to the control plane's sync address for enrollment, certificate renewal, and configuration sync. If the pods can't reach it, they never become ready.
3. The gateway pods call your LLM providers, MCP servers, and APIs. With the MySQL secret store, they also read and write credentials in MySQL.
4. The gateway calls the embedder inside the cluster for MCP tool search. The embedder downloads its model from `huggingface.co` at startup unless you run it offline.
5. The collector sidecar in each gateway pod exports traces, metrics, and logs to your telemetry backend. With `otelCollector.enabled: false`, there's no sidecar, so set `OTEL_EXPORTER_OTLP_ENDPOINT` to your backend and the gateway pods export directly. Otherwise telemetry is dropped.

## Required egress

Allow these outbound paths from the cluster:

| From                                                      | To                                                                       | Port                                                                                       | Purpose                                                 | Required                  |
| --------------------------------------------------------- | ------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------ | ------------------------------------------------------- | ------------------------- |
| Gateway pods                                              | Control plane sync address                                               | The port in the address Postman gives you, `9090` in the chart's examples (gRPC over mTLS) | Enrollment, certificate renewal, and configuration sync | Yes                       |
| Gateway pods                                              | Your LLM providers, MCP servers, and APIs                                | Each upstream's port, usually `443`                                                        | Request traffic                                         | Yes                       |
| Gateway pods                                              | Your identity providers (OAuth and OIDC discovery, token, and JWKS URLs) | Usually `443`                                                                              | Client authentication and account connections           | If you use them           |
| Gateway pods and migration Job                            | MySQL                                                                    | `3306`                                                                                     | Secret store and schema migrations                      | With the MySQL store      |
| Collector sidecar, or gateway pods with the collector off | Your telemetry backend                                                   | Your backend's port (the chart's ClickHouse example uses `9440`)                           | Traces, metrics, and logs                               | If you export telemetry   |
| Embedder                                                  | `huggingface.co`                                                         | `443`                                                                                      | Downloads the embedding model at startup                | Unless you run it offline |
| Gateway pods                                              | Your coordination Redis                                                  | Your Redis port                                                                            | Shared rate-limit counters                              | Only if you turn it on    |

To send outbound calls through a proxy, set `global.env.HTTP_PROXY` and `HTTPS_PROXY`. They apply to the gateway, collector, embedder, and migration Job.

On AWS, these paths map to security group egress rules on the nodes or pods that run the gateway and embedder. If the gateway's ServiceAccount uses an IAM role (IRSA), the pods also need to reach the regional STS endpoint, or a VPC endpoint for STS. Without it, the credential exchange fails even when every other rule is correct.

> **Note**
>
> If a proxy or load balancer between the data plane and the control plane ends TLS, the control plane can't see the data plane's client certificate, and certificate renewal fails. Let the sync connection pass through with TLS intact. If you run Istio, set `istio.enabled` so the sidecar doesn't intercept the ports in `istio.excludeOutboundPorts`, `4317,4318,9090` by default. Only those ports are excluded, so if your sync address uses a port other than `9090`, add it to that list.

## Calls to private hosts

To protect against server-side request forgery, the gateway never connects to link-local, cloud metadata, or multicast addresses. It refuses loopback addresses by default. To let routes reach an upstream on loopback, set `FABRIC_GW_SSRF_ALLOW_LOOPBACK_UPSTREAMS` to `"true"`. Private addresses (RFC 1918, carrier-grade NAT, and IPv6 unique local) are a different case for each kind of call:

* **Your upstreams.** Routes can reach LLM providers, MCP servers, and APIs on private addresses by default. To block private upstreams, set `FABRIC_GW_SSRF_BLOCK_PRIVATE_UPSTREAMS` to `"true"`. Then list any private hosts your routes still need in `FABRIC_GW_SSRF_ALLOW_PRIVATE_UPSTREAM_HOSTS`, a comma-separated list of exact hostnames or `*.` wildcards. The allow list has no effect unless blocking is on. The same rule applies to the gateway's calls to the embedder. If you turn on blocking, also add the embedder's host name to `FABRIC_GW_SSRF_ALLOW_PRIVATE_UPSTREAM_HOSTS`, exactly as it appears in your tool search embedder URL. The chart's embedder Service is `fabric-gateway-embedder`. Otherwise, MCP tool search fails.
* **The gateway's own authentication calls.** OAuth and OIDC discovery, client registration, token exchange, and JWT Auth key fetches don't reach private addresses unless you list the host in `FABRIC_GW_SSRF_ALLOW_PRIVATE_HOSTS`. This list is empty by default and doesn't affect upstreams. Add a host only if, for example, your identity provider is on your private network.

Set these variables under `env.vars`. The chart's values file sets only `FABRIC_GW_SSRF_ALLOW_PRIVATE_HOSTS`, so add the others yourself. See [Helm values](/run/helm-values#gateway-environment).

## Ports inside the cluster

These ports are used only between pods in the cluster. You don't need egress rules for them, but a NetworkPolicy must allow them.

| From                                    | To                          | Port                                  | Purpose                                                        |
| --------------------------------------- | --------------------------- | ------------------------------------- | -------------------------------------------------------------- |
| Clients in the cluster, or your ingress | Gateway Service             | `8080` (plain HTTP)                   | Request traffic                                                |
| Kubelet                                 | Gateway container           | `8080`, path `/healthz`               | Liveness, readiness, and startup probes                        |
| Gateway pods                            | Embedder Service            | `80`, forwarded to `8080`             | Tool-search embeddings                                         |
| Gateway container                       | Collector sidecar, same pod | `4317` (gRPC), `4318` (HTTP)          | OTLP from the gateway                                          |
| Collector sidecar                       | Itself and the embedder     | `8888`, and the embedder's `/metrics` | Metrics scrape                                                 |
| Kubelet                                 | Collector sidecar           | `13133`                               | Collector health checks                                        |
| Gateway pods                            | Other gateway pods          | `3320` (data), `3322` (gossip)        | Distributed secret store only                                  |
| Gateway container                       | OPA sidecar, same pod       | `8181`, on loopback only              | Policy decisions, only with `opa.enabled`                      |
| Kubelet                                 | OPA sidecar                 | `8181`, path `/health`                | Readiness check, only with `opa.enabled`                       |
| Callers of the egress proxy             | Gateway container           | `8090` (`llmEgress.port`)             | Transponder LLM egress callback, only with `llmEgress.enabled` |

> **Warning**
>
> With `opa.enabled`, gateway pods don't become ready. OPA listens only on loopback, so the kubelet's readiness check on port `8181` fails. See [Helm values](/run/helm-values#feature-toggles).

With the distributed store, the chart adds a NetworkPolicy that limits ports `3320` and `3322` to gateway pods. That policy allows no other traffic into gateway pods, so on a cluster that enforces NetworkPolicy it also blocks client traffic to port `8080`. Add a rule for `8080` to your values file:

```yaml
distributed:
  networkPolicy:
    extraIngress:
      - ports:
          - protocol: TCP
            port: 8080
```

This rule allows traffic to port `8080` from any source. To limit it to your ingress controller, add a `from` selector to the rule.

With `embedder.networkPolicy.enabled`, only gateway pods can reach the embedder. The policy limits ingress only, to the embedder's container port `8080`, and doesn't restrict egress. In `embedder.networkPolicy.extraIngress`, use port `8080`, not the Service port `80`.

For how clients outside the cluster reach port `8080`, see [Expose the gateway](/run/expose-the-gateway).

## Next steps

* To check cluster requirements, see [Requirements and sizing](/run/plan-a-deployment).
* To install the chart, see [Install with Helm](/run/install).
* To let clients reach the gateway, see [Expose the gateway](/run/expose-the-gateway).