Direct Helm Chart Deployment

This page installs an Inferra LCF cluster from the tagged Cloudsmith release artifacts with Helm. It is intended for operators performing a production-style Kubernetes installation.

Or let lcf-cli do it

LCF-CLI Deployment is the recommended path: it discovers the cluster, sizes resources, and generates these values for you. Use this page when your process requires driving Helm directly.

Artifact Coordinates

Cloudsmith release publishing creates one OCI Helm chart and these OCI images.

Artifact

Coordinate

Version form

Helm chart

oci://docker.cloudsmith.io/lightbits/lightbits-inferra/charts/lcf

Chart version without v, for example 1.2.0

lcft image

docker.cloudsmith.io/lightbits/lightbits-inferra/lcf/lcft:vX.Y.Z

Image tag with v

lcfc image

docker.cloudsmith.io/lightbits/lightbits-inferra/lcf/lcfc:vX.Y.Z

Image tag with v

lcf-api image

docker.cloudsmith.io/lightbits/lightbits-inferra/lcf/lcf-api:vX.Y.Z

Image tag with v

Bootstrap helper

docker.cloudsmith.io/lightbits/lightbits-inferra/lcf/k8s-bootstrap-and-sync:vX.Y.Z

Image tag with v

Example Release Variables:

export LCF_NAMESPACE=lcf
export LCF_RELEASE=lcf
# SemVer form of the release, as in the lcf-cli path.
export LCF_VERSION=1.2.0
export LCF_IMAGE_TAG=v${LCF_VERSION}
export CLOUDSMITH_REGISTRY=docker.cloudsmith.io
export CLOUDSMITH_REPO=lightbits/lightbits-inferra
export CLOUDSMITH_TOKEN='REPLACE_WITH_CLOUDSMITH_READ_TOKEN'

Prerequisites

Requirement

Minimum

Notes

Kubernetes

1.28

The chart declares kubeVersion: >=1.28.0-0.

Helm

3.x

Required for OCI chart install.

kubectl

Compatible

Assumes current kube context or --kubeconfig.

Cloudsmith creds

Read access

Uses username token and password $CLOUDSMITH_TOKEN.

Storage nodes

Pre-mounted XFS

lcft uses host directories such as /data0, /data1, /dataN.

Inference nodes

GPU or CPU

lcfc runs where node-role.kubernetes.io/inference=true.

2 MiB huge pages

Recommended on inference and dual-role nodes

Backs the lcfc RAM tier. Optional; the tier falls back to smaller pages. See The lcfc memory limit is the RAM-tier size in LCF-CLI Deployment.

lcf-cli

Matching release

Used at the end to verify the deployment.

Production Sizing Requirements

Component

Memory limit

Values set in this guide

lcft

Sized from selected storage; request is set equal to the limit.

256Gi — a large-node example; lower it to what your node can schedule.

lcfc

Sizes the RAM tier: tier = limit − 16Gi

128Gi, for a ~112 GiB tier

Unlike lcft's, the lcfc limit is not a floor to clear — it is how much host RAM the KV tier gets. Raise it toward the node's memory on a dedicated node, or set it to node memory − engine budget − 16Gi where an inference engine shares the host. Step 5 of LCF-CLI Deployment covers this in full.

Step 1: Authenticate to Cloudsmith and Pull the Chart

helm registry login is rejected by an entitlement token — see the note in LCF-CLI Deployment. Write the credential into a registry configuration file of its own and pull the chart to a local file, which is what the rest of this page installs from:

export LCF_CHART_DIR="${PWD}/cloudsmith-charts"
export LCF_CHART="${LCF_CHART_DIR}/lcf-${LCF_VERSION}.tgz"

export INFERRA_HELM_REGISTRY_CONFIG="${PWD}/inferra-helm-registry.json"
rm -f "$INFERRA_HELM_REGISTRY_CONFIG"
(umask 077 && cat > "$INFERRA_HELM_REGISTRY_CONFIG" <<EOF
{"auths":{"${CLOUDSMITH_REGISTRY}":{"auth":"$(printf 'token:%s' "$CLOUDSMITH_TOKEN" | base64 -w0)"}}}
EOF
)

mkdir -p "$LCF_CHART_DIR"
helm pull "oci://${CLOUDSMITH_REGISTRY}/${CLOUDSMITH_REPO}/charts/lcf" \
--registry-config "$INFERRA_HELM_REGISTRY_CONFIG" \
--version "$LCF_VERSION" \
--destination "$LCF_CHART_DIR"
test -s "$LCF_CHART"
The registry config holds your token in clear text

The pull secret in Step 2 is built from the same file. Remove it with rm -f "$INFERRA_HELM_REGISTRY_CONFIG" when the install is finished. Your own Helm registry logins in ~/.config/helm/registry/config.json are not touched.

Step 2: Create the Namespace and Pull Secret

kubectl create namespace "$LCF_NAMESPACE" \
--dry-run=client -o yaml | kubectl apply -f -

kubectl -n "$LCF_NAMESPACE" create secret generic cloudsmith-pull-secret \
--type=kubernetes.io/dockerconfigjson \
--from-file=.dockerconfigjson="$INFERRA_HELM_REGISTRY_CONFIG" \
--dry-run=client -o yaml | kubectl apply -f -

The secret is read from the file Step 1 wrote — the registry credential format Helm and Kubernetes share — so the token never appears on a command line.

Step 3: Label Nodes

kubectl label node storage-01 node-role.kubernetes.io/storage=true --overwrite
kubectl label node storage-02 node-role.kubernetes.io/storage=true --overwrite
kubectl label node storage-03 node-role.kubernetes.io/storage=true --overwrite
kubectl label node gpu-01 node-role.kubernetes.io/inference=true --overwrite
kubectl label node gpu-02 node-role.kubernetes.io/inference=true --overwrite

Step 4: Prepare LCFT XFS Mount Points

Destructive formatting

mkfs.xfs -f deletes data on the selected device. Run it only on devices dedicated to LCF.

Example for one storage node:

sudo mkfs.xfs -f "$DEV0"
sudo mkdir -p /data0
sudo mount -o noatime,nodiratime "$DEV0" /data0

The full multi-device procedure, including persisting the mounts in /etc/fstab, is in LCF-CLI Deployment under Step 3: Prepare XFS Mount Points.

Step 5: Prepare Helm Values

Create inferra-prod-values.yaml:

global:
imageRegistry: "docker.cloudsmith.io/lightbits/lightbits-inferra"
imageTag: "${LCF_IMAGE_TAG}" # e.g. v1.2.0; substitute the literal value, Helm does not expand shell variables
imagePullSecrets:
- name: cloudsmith-pull-secret
lcft:
nodeSelector:
node-role.kubernetes.io/storage: "true"
resources:
# A large-node example. Size it from your selected storage capacity
# (LCF-CLI Deployment, Step 5 has the formula) and check the node can schedule it —
# `kubectl get node <node> -o jsonpath='{.status.allocatable.memory}'`.
# An over-large value leaves the lcft pod Pending for ever.
limits:
memory: "256Gi"
storage:
deviceSelector:
mountPoints:
enabled: true
paths:
- "/data0"
Helm does not expand shell variables

imageTag above shows ${LCF_IMAGE_TAG} for readability. Substitute the literal value (for example v1.2.0) before installing.

Step 6: Validate and Install

Both commands use the chart file pulled in Step 1, so neither re-authenticates to the registry.

Single-node clusters

On a cluster with one schedulable node, add lcf-api.replicas: 1 to inferra-prod-values.yaml. The chart requests two replicas with hard pod anti-affinity; the second can never be scheduled, and --wait will burn its whole timeout before failing the release.

helm template "$LCF_RELEASE" "$LCF_CHART" \
-f inferra-prod-values.yaml > inferra-rendered.yaml
helm upgrade --install "$LCF_RELEASE" "$LCF_CHART" \
--namespace "$LCF_NAMESPACE" \
--create-namespace \
-f inferra-prod-values.yaml \
--wait --timeout 20m

Next: verify the deployment with Troubleshooting, then prove the cache works with Post-Deployment Validation.