Every data plane your tenant uses runs its own private image registry for data apps. dip app push drives it for you, but you can also work against it directly with plain docker or crane, which is useful in a CI system that doesn’t run dip.

Signing in

docker login
Sign in with an alt_ API key, not your interactive session. The key must have the apps:publish scope (ticked when it was minted) and its service user must have permission to create apps or update all apps in the tenant. The Data engineer role grants both. See Build and push an image for how those two are granted separately. Revoking a service-user API key refuses new sign-ins and requests using registry tokens issued from that key within a few seconds. A registry token issued from an expiring API key has an expiration no later than the key’s expiration. Your tenant must remain bound to the plane serving the registry. Publication credentials are short-lived. Expired credentials receive an authentication challenge so Docker can request a replacement; sign in again if your client asks for fresh credentials after an upgrade. Connection failures temporarily refuse sign-ins, pulls and pushes using API keys. Retry after connectivity recovers. When a registry token needs replacement, the registry returns a Bearer authentication challenge so your client can request a fresh token. This can happen after a restart or a change to your tenant’s plane bindings. A token exchange that needs a short recovery interval returns 503 with Retry-After; retry after the indicated delay.

Where the key is stored

dip app push and dip pipeline push sign in for you without saving the key. Each push logs in to a temporary Docker configuration that only that push uses, and deletes it when the push ends, whether the push succeeds, fails, or you stop it with Ctrl-C. The key never reaches ~/.docker/config.json or your system keychain, even on a machine whose Docker would otherwise pick the keychain by itself, such as a new Docker Desktop install that has no logins saved yet. Your own Docker settings, such as the current context, your buildx builders and your logins to other registries, work during the push as they always do. The registry login is limited to 90 seconds. A login normally takes a few seconds, so one that runs longer is waiting on something that will not answer, usually a Docker credential helper (docker-credential-osxkeychain or docker-credential-desktop on macOS) waiting for the keychain to be unlocked or for a prompt to be approved. The push then stops with one line naming the helper, instead of waiting with no output. A manual docker login, like the one above, does save the key in your Docker configuration or keychain until you remove it. A push made with an older version of dip saved it the same way. To remove a saved key, run:
Remove a saved registry key

Repository naming

Images live at <registry-host>/<tenant-slug>/<app-id>:<tag>. Your tenant’s slug is the namespace, so a key can only push under its own tenant, never another one’s. Pushing an image with no manifest label, or one that doesn’t parse, uploads the image but doesn’t register an app; the Publish history tab on the Live Apps page names the reason.
Push directly (no dip)

Who owns a pushed app?

Members can publish their own static apps by default, unless an administrator disables Publish own apps for one of their effective roles. Broad app publishing permission remains independent. The first accepted upload reserves its repository name for the authenticated publisher. If two publishers start uploading the same app name at once, only one can reserve it. Use a different app ID if someone else has already reserved the name. Registering an app also reserves its name, even when its images come from an external registry. Signing in or holding pull-only access does not reserve a name. Your registry token must grant push access to that exact repository before an upload can reserve it. If a credential expires while a registry token is being issued or used, the registry asks your client to authenticate again. Sign in again if the client cannot refresh it automatically. When registration succeeds, the authenticated user or service user becomes its owner and creator. With an API key, this is the service user the key belongs to. A push without a valid user or service-user identity cannot register an app. Only the owner or someone with permission to update all apps in the tenant can change that app’s image repositories or register another version. This includes explicitly named component images and component images retained by earlier versions. An owner needs Publish own apps or broad app update permission. Turning off Publish own apps blocks narrow publication even when the publisher signed in earlier. An explicit deny of App update also refuses publication. A deny for this specific app also applies. Permission to create apps alone does not let you register a version of another author’s app. Permission to update apps alone does not let you create a new app. An allowed push by someone else keeps the original owner. Ownership transfer requires broad app update permission; being the owner alone does not allow it. If the app belongs to someone else and you lack that permission, the upload is refused before replacing stored image content:
The existing image tag, app record and registered versions stay unchanged. This also protects writes addressed by image digest. Increasing version does not grant permission to update someone else’s app. If ownership or current permissions cannot be verified, the upload is refused; retry when the check is available again. Your push command prints the refusal. An upload refused before completion has no entry in Publish history; that tab reports completed pushes and their registration results. Changing an app’s owner or removing publication permission applies to the next upload request, even if the publisher signed in earlier. A request already accepted before the change can finish. Deleting the app record does not make its existing image repositories available to another publisher. If several apps reference one component repository, changing it requires permission for every app that uses it. Use separate repositories when the apps have different authors. Each new upload checks your current ownership and permissions, even if the image and tag are unchanged. If you lose permission after the upload completes, registration records a refusal without erasing an earlier success. The registry gives each push report a unique ID. Repeated delivery of the same report keeps one history entry with its first result. A successful report does not register the app again and stays successful even if the image can no longer be read. After a refusal, fix the problem and push again to create a new report. A report without an ID always checks your current ownership and permissions before registration. Registration checks ownership and current permissions again after a completed push. Passing the upload check does not guarantee registration if your permissions change before registration finishes. Own-app publication also refuses an app that is not static, including at this final check. Your push command prints the refusal:
Rebuild the app with dip app new --runtime frontend, or ask a Data engineer to publish it. See Own-app role settings.

Which plane’s registry

Your tenant can run more than one data plane, and each has its own registry, reachable at <tenant-slug>.registry.<plane-domain>. An app can only be installed on the plane its image was pushed to. The console’s Register app dialog shows the registry host for your tenant’s default plane; dip plane list lists every plane’s registry host if you have more than one.

Quotas

The byte quota, where set, is checked periodically rather than on every byte uploaded. A push that starts under quota is allowed to finish even if it ends up slightly over, and the next sweep is what moves you to pull-only.

How long are published images kept?

An app publication succeeds only after its exact image is retained, including every platform image and attestation it contains. Reusing a public tag or publishing a rebuild of the same app version does not remove the earlier image’s bytes. Retention keeps those bytes available; it does not choose which version an installation runs. Retained images stay in your tenant’s registry until your tenant is purged after deletion. Uninstalling an app does not reclaim them, and retained bytes count toward your tenant’s byte quota. Tags beginning with altimate-retain- are reserved for new pushes. Valid retention tags do not count toward your tag quota; older user tags with that prefix count normally. Use your own tags for publishes. Ownership and version checks run before retention. Rejected pushes remain visible with their reason. During temporary registry maintenance, publication retries automatically for up to an hour. If the image still cannot be kept, the push shows “couldn’t keep this version; push again” and no version is published. Push again after the registry recovers. An install started during registry maintenance waits up to a few minutes. If maintenance is still running, the install fails and you can retry it after maintenance finishes. A newer publication can overtake a waiting push and cause its final check to reject it. Bytes already retained still count toward your quota until tenant purge.

Deleting images

There’s no delete operation on the registry itself in v1. A compromised CI key should never be able to erase your tenant’s apps. Garbage collection of unreferenced image layers happens automatically on the plane’s own schedule; it isn’t something you trigger. It preserves retained images. During maintenance, pulls remain available but pushes are temporarily refused; retry after maintenance finishes. If maintenance is interrupted, recovery is automatic. Pushes stay paused until the interrupted maintenance task has timed out and cleanup has stopped, followed by a five-minute recovery period. Retry your push afterward; no routine administrator action is needed. After an interrupted push, cleanup waits through a five-minute recovery period before resuming automatically. Your pushes are not affected by that wait: an upload that drops its connection, times out or fails partway never holds up the next push, so retry straight away. After a registry restart, pushes pause only until the automatic recovery check finishes. Five minutes is a practical bound. If a write continues for longer after your client disconnects and overlaps scheduled cleanup, that push can lose image data and become unavailable to pull. Re-push the image to recover. This does not expose data or affect another tenant, and scheduled cleanup runs rarely. If pushes remain unavailable, contact your tenant administrator.

Troubleshooting

Build and push an image

Push your app’s image with dip app push, or bring your own.

Install an app

What happens once your image is registered on the Live Apps page.