> ## Documentation Index
> Fetch the complete documentation index at: https://docs.getlilac.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Operator Installation

> Install the Lilac GPU operator in your Kubernetes cluster using Helm. Covers prerequisites, namespace setup, chart configuration, and verification.

This guide walks through installing the Lilac GPU operator in your cluster. The operator is deployed via a Helm chart hosted on AWS ECR.

## Prerequisites

* [Kubernetes 1.28+](https://kubernetes.io/docs/setup/) — if you're running a single node and aren't already in a Kubernetes cluster, [k3s](https://docs.k3s.io/quick-start) is a lightweight option that's easier to set up and connect
* [`kubectl`](https://kubernetes.io/docs/tasks/tools/#kubectl) configured with cluster admin access
* [`helm` v3](https://helm.sh/docs/intro/install/)
* NVIDIA GPU nodes with the [NVIDIA GPU Operator](https://docs.nvidia.com/datacenter/cloud-native/gpu-operator/latest/getting-started.html) installed
* A Lilac supplier API key (generated during [onboarding](/suppliers/getting-started))

## Install with Helm

<Steps>
  <Step title="Create the namespace">
    ```bash theme={null}
    kubectl create namespace lilac-system
    ```
  </Step>

  <Step title="Install the operator">
    ```bash theme={null}
    helm install lilac-gpu-operator \
      oci://public.ecr.aws/lilac/lilac-gpu-operator \
      --version 0.3.5 \
      --namespace lilac-system \
      --set apiKey="YOUR_SUPPLIER_API_KEY" \
      --set clusterName="my-gpu-cluster"
    ```

    <Note>
      If you hit AWS Public ECR rate limits while installing or pulling the operator image, use our Docker Hub mirror instead. Keep the same command and values, but replace `oci://public.ecr.aws/lilac/lilac-gpu-operator` with `oci://docker.io/getlilac/lilac-gpu-operator`.
    </Note>

    Replace `my-gpu-cluster` with a name that identifies this cluster in your dashboard.

    <Info>
      The Helm chart automatically creates the API key secret, control plane config, CRDs, RBAC, and service accounts. No manual setup required.
    </Info>
  </Step>

  <Step title="Verify the installation">
    ```bash theme={null}
    kubectl get pods -n lilac-system
    ```

    You should see the operator pod running:

    ```
    NAME                                              READY   STATUS    RESTARTS   AGE
    lilac-gpu-operator-...                             1/1     Running   0          30s
    ```
  </Step>

  <Step title="Create a GPU pool">
    Apply a basic `GPUPool` to tell the operator which GPUs to manage. Save the following as `gpu-pool.yaml` and apply it:

    ```yaml theme={null}
    apiVersion: gpu.getlilac.com/v1alpha1
    kind: GPUPool
    metadata:
      name: b200-gpu-pool
      namespace: lilac-system
    spec:
      nodeSelector:
        nvidia.com/gpu.product: B200
      cache:
        enabled: true
        capacity: 1000Gi
      workloads:
        inference: true
    ```

    ```bash theme={null}
    kubectl apply -f gpu-pool.yaml
    ```

    <Note>
      See [GPU Pool Configuration](/suppliers/operator/gpu-pools) for more advanced setups, including time-based schedules, preemption policies, per-node cache overrides, and Hugging Face token configuration.
    </Note>
  </Step>
</Steps>

## Verify Control Plane Connection

Check the operator logs to confirm it connected to the Lilac control plane:

```bash theme={null}
kubectl logs -n lilac-system deploy/lilac-gpu-operator
```

Look for a log line like:

```
INFO  control plane sync successful  cluster_id=abc123
```

Your cluster should also appear as **Connected** in the Lilac dashboard within 30 seconds.

## Helm Values

| Value                | Required | Default                    | Description                                |
| -------------------- | -------- | -------------------------- | ------------------------------------------ |
| `apiKey`             | Yes      | —                          | Supplier API key from the Lilac dashboard  |
| `clusterName`        | Yes      | —                          | Human-readable name for your cluster       |
| `controlPlaneUrl`    | No       | `https://api.getlilac.com` | Control plane URL                          |
| `disconnectTimeout`  | No       | `10m`                      | Time before cluster is marked disconnected |
| `image.tag`          | No       | Chart app version          | Override the operator image tag            |
| `resources.limits`   | No       | `cpu: 500m, memory: 128Mi` | Resource limits for the operator pod       |
| `resources.requests` | No       | `cpu: 10m, memory: 64Mi`   | Resource requests for the operator pod     |

## Upgrading

To upgrade your operator to the latest version, run:

```bash theme={null}
helm upgrade --install lilac-gpu-operator \
  oci://public.ecr.aws/lilac/lilac-gpu-operator \
  --version 0.3.5 \
  --namespace lilac-system \
  --reuse-values
```

## Uninstalling

```bash theme={null}
helm uninstall lilac-gpu-operator --namespace lilac-system
```

<Warning>
  Uninstalling the operator will drain all Lilac inference workloads from your cluster. Your own workloads are not affected.
</Warning>

## Next Steps

<Columns>
  <Card title="Configure GPU Pools" icon="layer-group" href="/suppliers/operator/gpu-pools">
    Define which GPUs Lilac can use and when.
  </Card>

  <Card title="How the Operator Works" icon="gears" href="/suppliers/operator/how-it-works">
    Understand the sync loop and architecture.
  </Card>
</Columns>