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

# Quickstart: Run a data plane in your VPC

> Install the Fabric AI Gateway data plane in your Kubernetes cluster, connect it to the control plane with workload attestation, and check that it serves traffic.

This quickstart applies to the Enterprise plan, where the control plane runs in Postman cloud and you run the data plane in your own VPC. It strings together the minimum steps to get one data plane running: register it in the console, create its Secret, install the Helm chart, and confirm it serves traffic. Each step links to the page with the full details.

This quickstart uses the distributed secret store, so you don't need a database. The gateway pods share the credentials the gateway stores among themselves, and each pod keeps its copy on its own volume. For the alternatives, see [Choose a secret store](/run/scale-and-high-availability#choose-a-secret-store).

## Prerequisites

Before you begin, make sure you have the following:

* A Kubernetes cluster with egress to the control plane's sync address. See [Requirements and sizing](/run/plan-a-deployment) and [Network and egress](/run/network).
* `kubectl` and Helm 3.
* The Helm chart from Postman.
* These images, in a registry your cluster can pull from:
  * The gateway image, from Postman.
  * `ghcr.io/huggingface/text-embeddings-inference:cpu-1.9`, the embedder for MCP tool search. When it starts, it downloads its model from `huggingface.co`. To run it without that access, see [Run the tool-search embedder](/run/embedder).
* A default StorageClass in the cluster. Each gateway pod gets its own 1 GiB volume.
* A NetworkPolicy controller, so that only gateway pods can reach the secret store's ports. Without one, the chart's NetworkPolicy has no effect.
* The **Super admin** role in the console, so you can open **Admin** > **Gateway health**.

## Register the data plane in the console

The data plane enrolls with its own Kubernetes service account token, so there's no token to mint or rotate.

1. Find your cluster's OIDC issuer:

   ```bash
   kubectl get --raw /.well-known/openid-configuration
   ```

   Copy the `issuer` value from the output. On EKS, you can also run `aws eks describe-cluster --name <cluster> --query cluster.identity.oidc.issuer --output text`.
2. In the console, open **Admin**, select **Gateway health**, and then select **Enroll data plane**.
3. Select **Workload attestation**, and enter the following. The namespace, service account, and audience must match what you install later in this quickstart, so use these values exactly.
   * **Cluster OIDC issuer URL**: the issuer from step 1.
   * **Namespace**: `pm-fabric-dp`. The quickstart installs the chart in this namespace.
   * **Service account**: `fabric-dp-sa`. The chart names it after the Helm release, `fabric-dp`.
   * **Audience**: `fabric-cp`.
   * **Tenant ID**: keep the prefilled value, and copy it for your values file.
4. Select **Register anchor**.
5. Copy the **Sync endpoint**, and select **Download CA bundle**. You need both for your values file.

After you register, the console also shows data plane configuration snippets. You don't need to apply them, because `attestation.enabled` in your values file sets the same things.

If the control plane can't reach your cluster's issuer, for example on a private cluster, select **Paste JWKS** instead, and paste the output of `kubectl get --raw /openid/v1/jwks`. If you can't use workload attestation, use a bootstrap token. See [Connect to the control plane](/run/connect-a-data-plane).

## Create the namespace and Secret

```bash
kubectl create namespace pm-fabric-dp

openssl rand -hex 32 > secret-key.txt

kubectl -n pm-fabric-dp create secret generic fabric-dp-secrets \
  --from-literal=FABRIC_GW_SECRET_KEY="$(cat secret-key.txt)"
```

`FABRIC_GW_SECRET_KEY` encrypts the credentials the gateway stores. If you lose it, the gateway can't decrypt them. Store it in your secret manager, and then delete `secret-key.txt`. You generate the encryption key yourself. It doesn't come from Postman. For every key and other ways to create the Secret, see [Secrets and keys](/run/secrets-and-keys).

## Write a values file

Save this as `my-values.yaml`, with your own values:

```yaml
image:
  repository: registry.example.com/fabric/gateway
  tag: "<tag-from-postman>"

secrets:
  app:
    existingSecret: fabric-dp-secrets

attestation:
  enabled: true

syncCA:
  pem: |
    <contents of the CA bundle>

embedder:
  image:
    repository: registry.example.com/fabric/text-embeddings-inference

distributed:
  enabled: true
  networkPolicy:
    # The chart's policy covers the store's ports only. Also allow the gateway's
    # own port, or clients can't reach it on a cluster that enforces policies.
    extraIngress:
      - ports:
          - protocol: TCP
            port: 8080

otelCollector:
  enabled: false   # turn telemetry export back on later

env:
  vars:
    FABRIC_GW_TENANT_ID: "<your-tenant-id>"
    FABRIC_GW_CP_ADDRESS: "<sync-endpoint>"
    OTEL_TRACES_EXPORTER: "none"
    OTEL_METRICS_EXPORTER: "none"
    OTEL_LOGS_EXPORTER: "none"
```

With the collector sidecar off, set all three exporters to `none`. Otherwise the gateway keeps trying to export to the missing sidecar, and **Gateway health** reports its telemetry export as degraded.

For telemetry, external URLs, and every other value, see [Helm values](/run/helm-values).

## Install the chart

Keep the release name `fabric-dp`, so the ServiceAccount is `fabric-dp-sa` and matches the anchor you registered.

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

Replace `./fabric-gateway-chart` with the path to the chart Postman gave you. Helm starts the gateway pods, which enroll with the control plane and then receive your configuration.

## Check that it's running

1. Check that the gateway pods are running and ready:

   ```bash
   kubectl -n pm-fabric-dp get pods -l app.kubernetes.io/name=fabric-gateway-chart
   ```

   Three pods appear, `fabric-gateway-chart-0` through `fabric-gateway-chart-2`. Each has `STATUS` `Running` and `READY` `1/1`.

2. In the console, open **Admin**, and then select **Gateway health**. Your pods appear as nodes with the status **Healthy**.

3. Select a node. Under **Config sync**, check that it shows **Connected** and an **Applied** version above `v0`. Until it does, the pod hasn't received your configuration, and requests to it can return a `503` or a `404`.

If a pod restarts in a loop, see [Troubleshoot enrollment](/run/connect-a-data-plane#troubleshoot-enrollment).

## Send a request

Connect a provider in the console. For the steps, see [Quickstart: Send your first request on the hosted gateway](/get-started/quickstart). Then send a request through your data plane:

1. In a separate terminal, forward the gateway's port. The command keeps running, so leave it open:

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

2. In the console, select **Admin** > **Data plane**, and set **Base URL** to `http://localhost:8080`. Then copy your route's path.

3. Send this request:

   ```bash
   curl -s http://localhost:8080<route-path>/v1/chat/completions \
     -H "fg-api-key: <gateway-key>" \
     -H "Content-Type: application/json" \
     -d '{"model": "gpt-4o-mini", "messages": [{"role": "user", "content": "Hello from Fabric Gateway!"}]}'
   ```

A `200 OK` with a chat completion confirms that your data plane carries traffic. To confirm that the data plane reports to the control plane, check that its node shows **Healthy** in **Gateway health**.

## Next steps

* To let clients outside the cluster reach the gateway, see [Expose the gateway](/run/expose-the-gateway).
* Before production traffic, work through the [Production checklist](/run/production-checklist).
* To set up monitoring, see [Monitor the data plane](/run/monitor).