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

# Rental Operator Quick Start

> Install Rental Operator with Helm, store your API key in a Secret, and rent your first GPU with a GPURental.

This guide installs Rental Operator in a Kubernetes cluster, rents one GPU, connects to it over SSH, and releases it.

## Prerequisites

> **Kubernetes 1.35 to 1.37**
>
> A cluster you can reach with `kubectl`. A local kind cluster works.

> **Helm 3**
>
> To install the chart from the GitHub container registry.

> **[An API key](https://app.hyperbolic.ai/settings/api-keys)**
>
> Create one under **Settings > API Keys** in the dashboard.

> **An SSH key pair**
>
> Its public key is saved on your account so you can reach the rental.

Your balance must cover at least one hour of runtime across all your instances, including the new rental. See [Pricing](https://hyperbolic.ai/docs/on-demand/pricing.md).

> [!WARNING]
>
> A local cluster still rents real GPUs, billed to your account. Delete your GPURentals before you delete the cluster or uninstall the operator. Otherwise nothing is left to end them, and they keep billing until you terminate them in the [dashboard](https://app.hyperbolic.ai).

## Rent your first GPU

**1. Install the operator**

```bash theme={null}
helm install rental-operator \
  oci://ghcr.io/hyperboliclabs/charts/rental-operator \
  --namespace rental-operator-system --create-namespace
```

To limit the operator to some namespaces, use the [namespaced install](https://github.com/HyperbolicLabs/rental-operator/blob/main/docs/install.md#namespaced-install).

**2. Store your API key**

In the namespace where your rentals will live, create a Secret and label it. The operator uses only Secrets with that label. `read -rs` waits for you to paste the key, without echoing it or saving it in your shell history.

```bash theme={null}
read -rs HYPERBOLIC_API_KEY
kubectl create secret generic hyperbolic-key \
  --from-literal=api-key="$HYPERBOLIC_API_KEY"
kubectl label secret hyperbolic-key compute.hyperbolic.ai/credentials=true
unset HYPERBOLIC_API_KEY
```

**3. Create a ProviderConfig**

Save this as `providerconfig.yaml`:

```yaml theme={null}
apiVersion: compute.hyperbolic.ai/v1alpha1
kind: ProviderConfig
metadata:
  name: default
spec:
  credentials:
    secretRef:
      name: hyperbolic-key
      key: api-key
```

Apply it and check that the key works:

```bash theme={null}
kubectl apply -f providerconfig.yaml
kubectl get providerconfig default
```

`READY` shows `True` once Hyperbolic accepts the key, and `BALANCE` shows your balance in cents.

**4. Save your SSH public key**

```bash theme={null}
kubectl apply -f - <<EOF
apiVersion: compute.hyperbolic.ai/v1alpha1
kind: SSHKey
metadata:
  name: me
spec:
  providerConfigRef: { name: default }
  publicKey: $(cat ~/.ssh/id_ed25519.pub)
EOF
```

Change the path if your public key isn't `~/.ssh/id_ed25519.pub`. If your account already has this key, the SSHKey uses it and never deletes it.

**5. Rent a GPU**

Save this as `gpurental.yaml`, with the GPU type and count you need:

```yaml theme={null}
apiVersion: compute.hyperbolic.ai/v1alpha1
kind: GPURental
metadata:
  name: my-first-rental
spec:
  providerConfigRef: { name: default }
  gpuType: h100
  gpuCount: 1
  sshKeyRefs:
    - name: me
```

Apply it and watch it start:

```bash theme={null}
kubectl apply -f gpurental.yaml
kubectl get gpurental my-first-rental -w
```

The phase moves from `Provisioning` to `Running`.

**6. Connect over SSH**

```bash theme={null}
kubectl get gpurental my-first-rental -o jsonpath='{.status.instances[*].ssh}'
```

It prints the address as `user@host:port`, for example `root@203.0.113.10:22`. Connect with the port passed to `ssh`:

```bash theme={null}
ssh -p 22 root@203.0.113.10
```

**7. Release the GPU**

```bash theme={null}
kubectl delete gpurental my-first-rental
```

The resource stays in `Terminating` until Hyperbolic confirms the rental is gone, then disappears.

## Common issues

`kubectl get gpurental my-first-rental -o wide` adds a `REASON` column that says why a rental is waiting. For the ProviderConfig, `kubectl describe providerconfig default` shows the reason under Conditions.

> **ProviderConfig shows SecretNotLabeled**
>
> The Secret is missing its label. Run the `kubectl label` command from step 2.

> **ProviderConfig shows Unauthenticated**
>
> Hyperbolic rejected the key. Create a new key in the [dashboard](https://app.hyperbolic.ai/settings/api-keys) and update the Secret.

> **GPURental is Blocked with SSHKeyNotReady**
>
> The SSHKey it names doesn't exist or isn't saved on your account yet. Check that `kubectl get sshkey me` shows `READY` as `True`, or complete step 4.

> **GPURental is Blocked with InsufficientBalance**
>
> Your balance doesn't cover about an hour of runtime across your instances and this rental, so nothing was created. Add credits or turn on [Auto Top-Up](https://hyperbolic.ai/docs/general/auto-top-up.md). The operator checks again every five minutes.

> **GPURental is Blocked with AvailabilityUnavailable**
>
> No capacity matches the GPU type and count right now, or the type isn't in the catalog. The operator checks again every five minutes. To try another type or count, or to drop `region` so any region works, delete the GPURental and apply a new one. Those fields can't change in place.

## Next steps

> **[Rental Operator overview](https://hyperbolic.ai/docs/rental-operator/overview.md)**
>
> How it works, its limits, and the full reference.

> **[Common operations](https://github.com/HyperbolicLabs/rental-operator/blob/main/docs/operations.md)**
>
> Regions, ports, terminating, orphaning and rebooting.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.