Install Dexter

Dexter runs as its own Helm release, configured by one values file. Install it one of two ways:

  • In a new namespace, in any Kubernetes cluster. Dexter does not have to share a cluster with Kloudfuse: it reads your telemetry through the Kloudfuse MCP server.

  • In the Kloudfuse namespace, beside an existing Kloudfuse install. The namespace, the image pull secret, and the Helm registry login are already in place, so the install is shorter.

Both start from the same values file and end with the same steps after the install.

Prerequisites

For either install:

  • A Kubernetes cluster with a default StorageClass, and kubectl access to it.

  • Helm 3.8 or later.

  • An Anthropic API key, or a Claude Max OAuth token.

  • A Kloudfuse cluster with the remote MCP server enabled, and a service account token for it.

  • To serve Dexter on your own domain: cert-manager installed in the cluster, and a DNS name you can point at a load balancer.

For a new namespace only:

  • The token.json that Kloudfuse provided for your Kloudfuse install.

For the Kloudfuse namespace only:

  • The machine you install and upgrade Kloudfuse from. Helm is already logged in to the registry there.

Create the values file

The defaults install Dexter privately, with sign-in required. Only the first step is required; the others change a default.

  1. Create the file in the directory you run Helm from:

    touch dexter-values.yaml
  2. To give Dexter’s data more room than the default 2 GiB, set the volume size. Set it before you install: whether the volume can grow later depends on your StorageClass.

    persistence:
      size: 10Gi
    yaml
  3. If your image pull secret is not named kfuse-image-pull-credentials, name yours:

    image:
      pullSecrets:
        - <PULL_SECRET>
    yaml
  4. If the cluster’s nodes are tainted, as the nodes of a Kloudfuse cluster usually are, schedule Dexter onto nodes it tolerates. Without this, the pod stays Pending and kubectl exec fails with pod …​ does not have a host assigned.

    List the nodes' labels and taints:

    kubectl get nodes -L kf_role -o custom-columns=NAME:.metadata.name,ROLE:.metadata.labels.kf_role,TAINTS:.spec.taints

    Then select one role and tolerate its taint. For example, for nodes labeled and tainted kf_role=query:

    nodeSelector:
      kf_role: query
    tolerations:
      - key: kf_role
        operator: Equal
        value: query
        effect: NoSchedule
    yaml
  5. If those nodes need a particular StorageClass, set it. For example, Google Cloud N4 machines attach only Hyperdisk, which has a 4 GiB minimum:

    persistence:
      storageClass: hyperdisk-balanced
      size: 10Gi
    yaml

    Set it before you install: the StorageClass of a bound volume cannot be changed. Changing it later means backing up /data, deleting the dexter-data PersistentVolumeClaim, and restoring the data into the new volume.

  6. To send Dexter’s own traces to Kloudfuse, including the spans of each investigation’s model calls, enable telemetry:

    telemetry:
      enabled: true
      serviceName: dexter
      otlpEndpoint: https://<KLOUDFUSE_HOST>/ingester/otlp
      otlpTracesEndpoint: https://<KLOUDFUSE_HOST>/ingester/otlp/traces
      genAiTracesEndpoint: https://<KLOUDFUSE_HOST>/ingester/otlp/genai/v1/traces
      captureMessageContent: NO_CONTENT
    yaml

    By default the spans include incident text, file paths, and user names. NO_CONTENT leaves the content out; SPAN_ONLY keeps it in the spans. Give each Dexter install its own serviceName to tell their traces apart.

Download dexter-values.yaml for a commented copy of these settings and the public-access ones in Serve Dexter on your domain.

Install in a new namespace

These steps create a dexter namespace and install Dexter in it.

Step 1: Log in to the Helm registry

cat token.json | helm registry login -u _json_key --password-stdin us-east1-docker.pkg.dev

Step 2: Create the namespace and image pull secret

Dexter pulls its image with this secret, the same one a Kloudfuse install creates in its own namespace.

kubectl create namespace dexter

kubectl create secret docker-registry kfuse-image-pull-credentials \
  --namespace dexter --docker-server us.gcr.io --docker-username _json_key \
  --docker-password="$(cat token.json)"

Step 3: Install Dexter

helm install dexter oci://us-east1-docker.pkg.dev/mvp-demo-301906/kfuse-helm/dexter \
  --namespace dexter \
  --version 1.0.0 \
  -f dexter-values.yaml

kubectl -n dexter rollout status deployment/dexter

This installs Dexter 1.0.0, the current release. To see the latest version, run helm show chart oci://us-east1-docker.pkg.dev/mvp-demo-301906/kfuse-helm/dexter.

Continue with Sign in, using dexter as the namespace.

Install in the Kloudfuse namespace

These steps install Dexter in the namespace of an existing Kloudfuse install, usually kfuse. If yours has another name, use it in place of kfuse.

There is no registry login and no namespace or secret to create:

  • The namespace and the kfuse-image-pull-credentials secret already exist; the Kloudfuse install created them.

  • Helm is already logged in to the registry on the machine you install and upgrade Kloudfuse from. Run the steps from that machine.

Step 1: Schedule Dexter on Kloudfuse nodes

The nodes of a Kloudfuse cluster are usually tainted, so set nodeSelector and tolerations in dexter-values.yaml as described in Create the values file.

Pick nodes where the Kloudfuse observability agent runs. On other nodes, Dexter’s own logs and metrics are never collected.

kubectl -n kfuse get pods -o wide | grep observability-agent

Step 2: Install Dexter

helm install dexter oci://us-east1-docker.pkg.dev/mvp-demo-301906/kfuse-helm/dexter \
  --namespace kfuse \
  --version 1.0.0 \
  -f dexter-values.yaml

kubectl -n kfuse rollout status deployment/dexter

This installs Dexter 1.0.0, the current release. To see the latest version, run helm show chart oci://us-east1-docker.pkg.dev/mvp-demo-301906/kfuse-helm/dexter.

Continue with Sign in, using kfuse as the namespace.

Sign in

In the commands from here on, replace <namespace> with the namespace you installed Dexter in: dexter for a new namespace, or the Kloudfuse namespace, usually kfuse.

On first start, Dexter creates a super admin account, admin, with a generated password.

  1. Read the initial password:

    kubectl -n <namespace> exec deployment/dexter -- cat /data/settings/initial-admin-password

    helm install prints this command too.

  2. Open Dexter through a port-forward:

    kubectl -n <namespace> port-forward svc/dexter 3000:3000
  3. Sign in at http://localhost:3000 as admin with the initial password.

To sign in through Okta, Google, or Azure AD, add the provider under Admin > Identity providers.

Lost the admin password? Delete the account file and restart Dexter. It recreates admin with a new initial password, which you read with the command in the first step:

kubectl -n <namespace> exec deployment/dexter -- rm /data/settings/local-users.json
kubectl -n <namespace> rollout restart deployment/dexter

Serve Dexter on your domain

Skip this section to keep Dexter private and reach it through a port-forward.

  1. Add the ingress settings to dexter-values.yaml, with host set to the DNS name for Dexter:

    ingress:
      enabled: true
      host: <HOST>
    yaml
  2. If you already have a static IP address for Dexter, set it in the same file. Otherwise, skip to the next step and let the cloud assign one.

    ingress-nginx:
      controller:
        service:
          loadBalancerIP: <STATIC_IP>
    yaml

    The address must be a regional static IP in the cluster’s region, reserved in the same cloud project as the cluster. A global address, the kind a GCE Ingress uses, cannot be assigned to a load balancer Service. An address from another project leaves EXTERNAL-IP at <pending>, and the Service’s events read requested ip …​ is neither static nor assigned to the LB.

  3. Apply the change. Dexter gets its own load balancer and HTTPS with a Let’s Encrypt certificate:

    helm upgrade dexter oci://us-east1-docker.pkg.dev/mvp-demo-301906/kfuse-helm/dexter \
      --namespace <namespace> \
      --version 1.0.0 \
      -f dexter-values.yaml
  4. Find the load balancer’s EXTERNAL-IP. If you set loadBalancerIP, it is that address:

    kubectl -n <namespace> get svc -l app.kubernetes.io/instance=dexter,app.kubernetes.io/component=controller
  5. Create a DNS A record that points <HOST> at that address.

    cert-manager issues the certificate a minute or two after the name resolves. When READY shows True, HTTPS serves it within a few seconds:

    kubectl -n <namespace> get certificate
If the cluster already runs an ingress controller, use it instead: add ingress-nginx.enabled: false to the values file and set ingress.className to that controller’s IngressClass.

The bundled controller creates an IngressClass named dexter, and an IngressClass belongs to the whole cluster, not to a namespace. A second Dexter install with its own controller in the same cluster fails with IngressClass "dexter" in namespace "" exists and cannot be imported into the current release.

Give the second install its own class name, the same in all four places:

ingress:
  className: dexter-2
ingress-nginx:
  fullnameOverride: dexter-2-ingress-nginx
  controller:
    ingressClass: dexter-2
    ingressClassResource:
      name: dexter-2
      controllerValue: k8s.io/ingress-nginx-dexter-2
yaml

Deleting a namespace does not remove its Dexter’s IngressClass or ClusterIssuer: delete them by name, or uninstall the release with helm uninstall before deleting the namespace.

Connect Anthropic and Kloudfuse

  1. Open Dexter at https://<HOST>, or at http://localhost:3000 through the port-forward if you kept Dexter private, and sign in.

  2. Under Admin > Integrations, connect:

    • Anthropic: your Anthropic API key or Claude Max OAuth token.

    • Kloudfuse: the MCP address of your Kloudfuse cluster, https://<KLOUDFUSE_HOST>/mcp, and its service account token.