Settings → Data planes lists every plane your tenant can use, and is where you register a new one. Registering needs the DataPlane create privilege — data_admin and above; a viewer sees the list read-only. See the roles and permissions matrix for the full grid.

A tenant created by signing up already has one

If your tenant was created through self-serve sign-up (see Create a tenant), Settings → Data planes shows a banner above the list before you register anything:
“This workspace runs on <slug>. It’s managed automatically by us — registering a data plane of your own is optional.”
That row carries a vendor chip (tooltip “Owned and managed by the vendor”), and its Edit, Rotate credential and Delete actions are disabled — a tooltip explains why (“Managed by us — leaving this plane would leave the workspace with none.”). Registering your own plane in addition to this one is optional, not a replacement for it.

Registering a plane

Click Register data plane and fill in:
The operator choice is permanent. Choose The customer (BYOC) only if you’re prepared to run the cluster and keep it reachable — Dippr never generates or holds the private key for a plane you operate.

What you get back, once

Registration creates up to three of the four secrets below for the new plane: a managed plane gets a private key, a customer-operated plane never does, and only a customer-operated plane gets an image pull credential. Dippr keeps no readable copy of any of them, so each is returned exactly once and can’t be recovered later. The console’s register dialog shows the plane credential, the private key for a managed plane, and the image pull credential when there is one. Copy them before closing the dialog. Losing the credential is recoverable: rotate it from the plane list. Losing the private key is not: your only path forward is registering a new plane and re-entering the credentials of any integrations you want to move to it.

Does your plane need the plane service credential?

A plane service credential is a secret that names a data plane and no tenant. A plane uses it for work it does for every tenant on it at once.
  • A plane deployed for a single tenant, where the deployment names that one tenant, never reads it. Leave it out of the deployment.
  • A plane deployed with a fixed list of tenants, even a list of one, needs it only to report engine metrics for all of its tenants together. Adding a tenant to such a plane means redeploying it.
  • A plane that receives new tenants’ credentials automatically, after it’s deployed and without a redeploy, always needs it.
A plane with a fixed list that doesn’t report engine metrics never reads it. Where a plane does need it, its deployment won’t install until you supply it. It’s the wider of the two credentials: someone holding it can fetch the plane’s access policy and report engine metrics for every tenant on that plane. Store it like the plane credential. The console has no action that shows or reissues it. If you registered the plane in the console and later need one, ask your platform contact to issue a new one for the plane. Issuing a new one stops the previous one working, after a short window (well under a minute) while caches catch up, so update the plane’s deployment with the new value right away. The plane shows Disconnected until you deploy it with these values and it connects — see Reading plane status.

Inviting another tenant onto your plane

If you operate a plane, you can let another tenant run its integrations and engines on it too — useful for a vendor giving a customer’s team its own isolated space on shared infrastructure, or two teams sharing one cluster deliberately. This isn’t done from Settings → Data planes today; ask your platform contact for an invitation link.

Joining a plane you were invited to

Opening an invitation link takes you to Join a data plane. The page states what joining means before anything happens:
  • Your access rules apply on that cluster too. It enforces your tenant’s roles, grants, row filters and column masks, alongside every other tenant bound to the same plane.
  • Your connector work runs there. Integrations you pin to this plane run on that plane’s own infrastructure, inside the network its operator runs.
  • Its operator controls it. They can change its address, invite other tenants, and remove it. You can leave at any time by deleting the plane from your list.
To join, you supply your own encryption public key — generated in your own cluster, never reused from the plane’s own key or from another binding. The plane operator does not hold the private half, which is what keeps your integration credentials unreadable to them. Provide the private half only to a deployment of your own, dedicated to this binding.
1

Open the invitation link

The token travels after a # in the URL and is never sent to any server. If you’re not signed in, you’ll be sent to sign in first — the link still works afterward.
2

Generate your own encryption keypair

In your own cluster, not the plane operator’s. Paste the public half into the form.
3

Confirm

The plane appears in your data planes list, marked as not your default — new integrations still land on the plane they did before, unless you choose this one explicitly.
An invitation is single-use, can expire, and the console gives the same message for every failure — unknown link, already used, expired, wrong tenant — so a leaked link can’t reveal which tenant it was meant for. If yours fails, confirm you’re signed into the tenant the invitation named, and ask for a fresh link rather than editing the one you have.

Binding credentials to the right key

An integration’s credentials are always sealed to the private key of the plane it’s registered on — the plane operator’s key for a plane you registered or were handed directly, or your own binding key for a plane you joined. You never choose this explicitly; it follows from which plane you pick when you register the integration.

What to allow outbound from a private plane

A plane you operate needs nothing open for inbound traffic. It only needs outbound access to your tenant’s control plane endpoint, so the connection can be locked down to that one destination from your own network policy. Every endpoint your plane connects to on the control plane presents a certificate from a public certificate authority, so your plane verifies it with the trust store it already has. You don’t copy or install a certificate authority from Dippr. If an older plane install names one for the control plane connection, remove it when you upgrade: a plane that trusts only that private certificate authority can’t connect.

Outbound IPs

A plane’s outbound IPs are the public addresses its cluster uses when it connects to Dippr. Once your Dippr deployment restricts plane connections, it admits a plane only from the addresses declared for it, so a BYOC plane needs a fixed outbound address: NAT on a reserved IP, not the changing public IPs of individual nodes. Enter one or more addresses, separated by commas, spaces or new lines:
  • A single address is stored as a /32 (IPv4) or /128 (IPv6).
  • A range can be no wider than /24 for IPv4 or /48 for IPv6.
  • Addresses that are never a plane’s public source are refused: private, shared (CGNAT), loopback, link-local, multicast and reserved ranges, the documentation example ranges (192.0.2.0/24, 198.51.100.0/24, 203.0.113.0/24, 2001:db8::/32, 3fff::/20), IPv6 ranges that carry an IPv4 address (6to4, Teredo, NAT64), and any IPv6 address outside the global unicast range 2000::/3.
  • A range with host bits set (an address that is not the first address of its range) is refused, and the message names the range you probably meant.
  • At most 16 entries per plane. Duplicates are removed.
A managed plane that runs with the control plane needs none. Declare them for a managed plane only if it runs in another cluster and connects over the internet. To change the list, click Edit on the plane’s row in Settings → Data planes and replace the addresses under Outbound IPs. Saving replaces the whole list, and leaving the field empty keeps the current one. Only the tenant that owns the plane can see or change the addresses: a tenant that joined the plane sees Set by the plane’s owner in their place, and cannot edit them. Each change is recorded in the access log as Plane egress changed. The Egress column of the plane list shows what each plane declared. A remote plane that declared nothing (any BYOC plane, or a managed plane that runs in another cluster) shows None declared in red: once Dippr restricts plane connections to declared addresses, that plane’s connections are refused unless they leave from an address another plane declared, and a refused connection only times out on the plane’s side. dip plane list reports the same list on an egress line.

Where a plane runs

The Runs column of the plane list says where each plane runs relative to the control plane: Every tenant bound to a plane sees this column, not only the plane’s owner: it says which side of the network the plane is on, not any address. It is set when the plane is registered and doesn’t change afterwards; a plane that moves to another cluster is registered again. dip plane list reports it on a runs line.

When plane connections are restricted

Your Dippr deployment decides whether plane connections are restricted to declared addresses. Below the plane list, Settings → Data planes says which state it is in:
  • Plane connections are restricted: data planes can pick up work only from outbound IPs that are declared in your deployment, by any plane or by your deployment’s operator. The list is shared, not per plane. A BYOC plane that declared none shows Not on the allowlist: no egress CIDRs declared in the Egress column: nothing admits it by its own declaration, so its connections are refused unless its traffic leaves from an address another plane declared or one in your deployment’s own list. Declare each plane’s own outbound IPs. A BYOC plane is also checked on its own declaration when it signs in to pick up work: Dippr issues the short-lived credential it uses only when the request arrives from one of that plane’s outbound IPs, so another plane’s declaration does not cover it here. A refused plane’s error names the address Dippr saw. If that address is a private one (for example 10.0.0.5), the deployment’s network is hiding the plane’s real address, and the fix is on your Dippr operator’s side, not the plane’s. Planes managed by Dippr are not checked. A change to a plane’s outbound IPs applies to this check within 30 seconds, and the plane asks again at its next sign-in, within two minutes.
  • Plane connections are not restricted yet (enforcement: open): any address can connect. Declare each BYOC plane’s outbound IPs now; once the restriction is switched on, a plane without them is refused unless another declaration covers its address.
  • Nothing is shown when your deployment runs every plane next to Dippr’s own services.
Adding or changing a plane’s outbound IPs takes effect within a minute. dip plane list reports the same state on a temporal line.

Pulling Dippr’s images from a registry that needs a login

An image pull Secret is a Secret in your cluster that holds the registry login your cluster uses to download Dippr’s images. If your plane pulls them from a registry that needs one, name the Secret in the plane’s global.imagePullSecrets value and create it in the plane’s own namespace. Data apps run in a separate namespace from the rest of the plane. A component that uses staticRoot runs a Dippr image there, so it needs the same login in that namespace. The plane handles this for you:
  • Before it starts such a component, it copies every Secret named in global.imagePullSecrets from the plane’s namespace into the apps namespace. It copies again each time a suspended app starts.
  • When you replace the Secret in the plane’s namespace, the copy follows within five minutes. You don’t need to reinstall any app.
  • If a named Secret is missing from the plane’s namespace, or isn’t an image pull Secret, the plane refuses to start the component, and the app’s error names plane_pull_secret_missing. Create the Secret, then install or start the app again.
  • If the apps namespace already holds a Secret with that name that the plane didn’t copy, the plane leaves it alone, and the app’s error names plane_pull_secret_conflict. Delete that Secret so the plane can copy its own.
  • Names that start with app-, pl- or agent-task- are reserved for the apps’ own objects. The plane refuses to copy such a Secret, and the app’s error names plane_pull_secret_conflict. Rename the Secret.
  • Uninstalling an app keeps the copy, because other apps on the plane use it. The copy is removed with the apps namespace.
Engines run in the plane’s own namespace and use the Secret where it is.

Rotating or revoking a plane’s credential

If a plane credential is exposed, rotate it from the plane list: Rotate credential on that plane’s row. A new credential is issued and the old one stops working immediately — the plane is refused until its operator installs the new value, so do this only when you’re ready to redeploy the plane with the new value right after.
Edit and Rotate credential apply to a plane you run yourself. On a plane the vendor runs for you — the shared plane your workspace was placed on at signup — these actions are not offered: it has no credential of yours to rotate, and its name and address are facts about shared infrastructure you don’t operate. Only a platform administrator can rename such a plane. A plane you register and run yourself, even one co-located with the vendor, keeps both actions.
Rotation isn’t instantaneous in effect — a short window (well under a minute) may still accept the old credential while caches catch up. Treat a rotation as effective once you’ve confirmed the plane reconnects with the new value, not the instant you click the button.
To revoke a credential without replacing it, rotate and discard the new value — the plane is refused on its next call to the control plane and stays that way until it’s given a new credential.

Admin placement on a vendor plane

A platform administrator can bind an active tenant from Tenants → Bind to fleet plane. The planes offered are the deployment’s self-serve fleet planes. An operator must first prepare the vendor plane and add it to that list. Listing a plane there also places every new self-serve signup on it. The administrator explicitly selects the plane and confirms that tenant work and secrets will run on vendor infrastructure. An existing default is preserved; the first binding becomes default when none exists. This action does not convert a customer plane into a vendor plane. Binding and credential delivery do not assert connectivity. Check Settings → Data planes for the normal connected status. Pending delivery can be retried for the same tenant and plane. Clearing the fleet entitlement does not remove an existing binding or its access.