> 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.

# Expose the gateway to your clients

> Make the Fabric AI Gateway data plane reachable from outside the cluster with an ingress or load balancer, end TLS, and set its host name in your values and the console.

This page applies to the Enterprise plan, where you run the data plane in your own VPC. The gateway Service is `ClusterIP` by default and speaks plain HTTP on port `8080`, so out of the box only clients inside the cluster can reach it. The chart ships no Ingress. This page shows how to expose the gateway, where to end TLS, and how to tell the gateway and the console the host name your clients use.

## Prerequisites

Before you begin, make sure you have the following:

* A data plane that's installed and enrolled. See [Install with Helm](/run/install).
* A host name for the gateway, for example `gateway.example.com`, and a TLS certificate for it.
* An ingress controller, a cloud load balancer, or a service mesh, depending on how you expose it.
* The **Manage access control** permission, to open **Admin** > **Data plane** in the console.

## Check the gateway before you expose it

To confirm the gateway answers before you set up ingress, forward its port:

```bash
kubectl -n pm-fabric-dp port-forward svc/fabric-gateway-chart 8080:8080
curl -s localhost:8080/healthz
```

The response is `{"status":"ok"}`.

## Choose how clients reach the gateway

* **Clients in the cluster** need nothing extra, unless you use the distributed store. See the warning at the end of this section. They reach the gateway at `fabric-gateway-chart.pm-fabric-dp.svc.cluster.local:8080`.
* **Clients outside the cluster** need one of the following:
  * **An Ingress or Gateway API route** that you manage, pointing at the `fabric-gateway-chart` Service on port `8080`. The ingress controller, host name, and TLS policy are yours.

  * **A load balancer Service.** Set `service.type` to `LoadBalancer` (or `NodePort`), and pass cloud load balancer settings in `service.annotations`. For example, for an internal Network Load Balancer on AWS through the AWS Load Balancer Controller, which must be installed in the cluster:

    ```yaml
    service:
      type: LoadBalancer
      annotations:
        service.beta.kubernetes.io/aws-load-balancer-type: external
        service.beta.kubernetes.io/aws-load-balancer-nlb-target-type: ip
        service.beta.kubernetes.io/aws-load-balancer-scheme: internal
    ```

  * **A service mesh.** Route to the gateway Service through your mesh's ingress gateway, with routing resources you manage. The chart's `istio.enabled` value only changes the gateway pods' outbound traffic. It doesn't create ingress routing.

> **Warning**
>
> With the distributed store (`distributed.enabled: true`), the chart adds a NetworkPolicy that allows only ports `3320` and `3322` between gateway pods. On a cluster that enforces NetworkPolicy, it also blocks client traffic to port `8080`, from inside and outside the cluster. Add a rule that allows it:
>
> ```yaml
> distributed:
>   networkPolicy:
>     extraIngress:
>       - ports:
>           - protocol: TCP
>             port: 8080
> ```
>
> To admit only your ingress controller and in-cluster clients, add a `from` list to the rule.

## End TLS at your ingress

The gateway Service speaks plain HTTP. End and enforce TLS at your ingress layer or load balancer, and keep the hop from there to the Service inside your network.

LLM streaming responses and MCP streams stay open much longer than a typical request. Raise the idle or read timeout on your ingress or load balancer, and turn off response buffering, so streamed responses aren't cut off or held back.

This client-facing path is separate from the data plane's own mTLS connection to the control plane. Exposing the gateway doesn't change that connection.

## Set the host name

Once clients can reach the gateway at its external URL, tell the gateway and the console what that URL is. If you know the host name before you install, set both URLs in your install values, and you won't need this upgrade.

1. In your values file, set both external URLs to the URL your clients use:

   ```yaml
   env:
     vars:
       FABRIC_GW_ADMIN_EXTERNAL_URL: "https://gateway.example.com"
       FABRIC_GW_BROKER_EXTERNAL_URL: "https://gateway.example.com"
   ```

   The gateway uses these to build the OAuth callback URLs and the account-connection links it sends to your users' browsers, so they must be reachable from those browsers.

2. If the data plane enrolls with a bootstrap token, mint a new token in the console and update `FABRIC_GW_SYNC_BOOTSTRAP_TOKEN` in the app Secret. See [Enroll with a bootstrap token](/run/connect-a-data-plane#enroll-with-a-bootstrap-token). The upgrade replaces every gateway pod, and with the chart's default store each new pod enrolls again. With workload attestation or the distributed store, skip this step.

3. Apply the change:

   ```bash
   helm upgrade fabric-dp ./fabric-gateway-chart -n pm-fabric-dp -f my-values.yaml
   ```

4. In the console, open **Admin**, and then select **Data plane**.

5. Under **Data plane endpoint**, enter the URL in **Base URL**, including `https://`, and select **Save**.

The console uses the base URL only to build copy-ready route links. It stays on the control plane and isn't sent to the data plane. If the field reads **Managed by Postman for this workspace**, Postman sets it for you.

## Verify

From a machine outside the cluster, call the health endpoint through your host name:

```bash
curl -s https://gateway.example.com/healthz
```

The response is `{"status":"ok"}`. To send a first request through the gateway, see [Authenticate and send a request](/use/authenticate).

## Next steps

* To check every network path, see [Network and egress](/run/network).
* Before you send production traffic, work through the [Production checklist](/run/production-checklist).
* To add replicas behind your load balancer, see [Scale and run a highly available data plane](/run/scale-and-high-availability).