A customer-operated data plane is the part of Dippr that runs your query engines, apps and MCP endpoint inside a cluster you own, while your tenant stays in Dippr’s control plane. dip plane install puts one into your cluster in one command: it generates the plane’s keypair on your machine, registers the plane with your tenant, writes every credential straight into Secrets in your cluster, and installs the published chart pinned by digest. The plane’s private key is created on your machine and never leaves your cluster. No credential is printed at any point.

What you need before you start

Install on GKE

  1. Create the cluster with Dataplane V2, which enforces network policies, and with Workload Identity on. Use private nodes behind Cloud NAT with a reserved static IP; that IP is your --egress-cidr.
  2. Create the bucket and set its soft delete retention to 0: gcloud storage buckets update gs://<bucket> --clear-soft-delete. Tenant deletion cannot confirm that data is gone from a bucket that keeps deleted objects.
  3. Create a Google service account for the plane. Grant it roles/storage.objectAdmin and roles/storage.legacyBucketReader on the bucket, and roles/iam.serviceAccountTokenCreator on itself (the plane signs upload URLs as it). Bind the cluster service accounts worker and wsdb in the plane’s namespace to it with roles/iam.workloadIdentityUser. Agents use a second, separate service account that may only read and create under _altimate/agents/ in the bucket, plus delete on the inbox objects there only (see the agents identity table in the BYOC profile).
  4. In your values file (below), set objectStore.gcpServiceAccount to the plane’s service account and the agents’ service account under appgw.serviceAccount.annotations.

Install on EKS

  1. Turn on network policy enforcement: the Amazon VPC CNI’s network policy agent, or Calico.
  2. Put the nodes in private subnets behind an AWS NAT Gateway on an Elastic IP; that IP is your --egress-cidr.
  3. Create the bucket and an IAM role for service accounts (IRSA) that may read and write it. Annotate the worker and wsdb service accounts with it in your values file (worker.serviceAccount.annotations and wsdb.serviceAccount.annotations, eks.amazonaws.com/role-arn). Agents get a second role limited to _altimate/agents/.

Install on AKS

Not supported yet. dip plane install --cloud azure stops before changing anything, and the chart refuses Azure storage, because only the agent store speaks Azure Blob; the plane’s other storage clients speak only S3 and Google Cloud Storage.

Your values file

dip supplies everything it knows: the plane’s id, your tenant, your control plane’s addresses and the names of the Secrets it writes. Your file carries what only you know. The keys below are those of the customer-operated profile that ships with the chart; dip plane install installs only a chart release that includes it, and stops before registering anything otherwise. The chart refuses to install until each of these is set, and names the missing one. dip checks your values against the chart before it registers anything, so set global.imageRegistry. dip keeps the registry your values file sets; only when it sets none does dip install from the registry your control plane issued the plane’s pull credential for.

Pull the images from your own registry

The plane can pull every image from a registry you run, for clusters that may not reach Dippr’s registry. Copy the release into your registry, keeping each image’s path under the registry, and set global.imageRegistry to it. The plane then pulls everything from there, including the five third-party images it runs, which the release publishes under altimate/upstream/: The release notes list every image the chart names, in the chart’s section under “Every image the chart names, for copying into your own registry”. Each keeps the tag, and the digest where it has one, that the release publishes. Save that list as images.txt and copy each image by digest (this needs crane, logged in to both registries):
The copy stops at the first image it cannot read or copy, or that is not under SRC, and says which. A list with no image in it (empty, or only blank lines) is refused. The list covers every image the chart renders with its own defaults, including ones behind features you have off, so a feature you turn on later finds its image already there. An image you name yourself (for example opaDataplane.image set to a full reference) is used as written and is not in the list: make it reachable from your cluster. Copy the new list for each release you upgrade to. The release’s images are signed in Dippr’s registry; crane copy by digest keeps the bytes the signature covers. dip plane install keeps the global.imageRegistry your values file sets. Only when your values files set none, and your control plane issues the plane an image pull credential, does dip set it to the registry that credential is for. Name the Secrets your own registry needs in global.imagePullSecrets.

Run it

Check what will happen first. A dry run changes nothing and prints the steps and the values dip will pass, with secrets redacted:
Then run the same command without --dry-run. dip reports each step:
  1. the keypair is generated and the private key is written to the Secret altimate-plane-key;
  2. the plane is registered with your tenant;
  3. the plane credential goes to the Secret altimate-plane-credential, the plane’s service credential to altimate-plane-service-credential, and the image pull credential, when your control plane issues one, to altimate-plane-pull;
  4. the plane’s other generated secrets are created, and the chart is installed as the release altimate-dp.
With an image pull credential and no registry of your own, dip adds altimate-plane-pull to the global.imagePullSecrets your values file sets and keeps your entries. Engines pull with it in the plane’s namespace, and the worker copies it into the apps namespace before it starts a static app. The plane appears in Settings → Data planes as soon as it is registered, and reads Connected once its pods are running. See Data plane status.

If the install stops part way

Run the same command again. Progress is kept in the ConfigMap altimate-plane-install in the plane’s namespace, and a plane is never registered twice. When a run stops after the plane was registered, it prints what exists and how to start over instead:
  • delete the plane in Settings → Data planes;
  • helm -n altimate uninstall altimate-dp, if the chart was installed;
  • kubectl -n altimate delete secret,configmap -l app.kubernetes.io/managed-by=dip.
If registration succeeded but its credentials could not be written to the cluster, dip keeps them in a file readable only by you, under your dip configuration folder, until the next run writes them and deletes the file.

Upgrading

If your plane pulls from your own registry, copy the new release’s images into it first (see Pull the images from your own registry). From this release on, the plane also pulls the five third-party images under altimate/upstream/ from your registry; releases before it pulled those from Dippr’s registry, so a mirror filled for an earlier release does not have them, and an upgrade without copying them leaves those pods unable to pull their images. Set global.imageTag in your values file to the new release’s tag, then run dip plane install again with the new release’s --chart. Change both together: the chart’s templates come from --chart, but every plane image is pulled at global.imageTag, so a new chart with the old tag runs the old images. The run skips registration, keeps every generated secret, and runs helm upgrade. An upgrade signs in the same way the install did. With dip login, the run still needs data_planes:administer: the scope your first install added stays on that sign-in, so later runs do not ask again, and every dip command that sign-in makes carries it. To keep the scope off your everyday sign-in, run installs and upgrades with DIPPR_API_KEY set to an API key minted with it instead.