Skip to main content
Version: 2.0

App Creation Flow

This page explains what happens between selecting Deploy in the Deploy Application wizard and having a live, reachable app with a TLS certificate — usually within a few minutes.

The key idea: every tenant deploys into their own vCluster (see CloudSpaces) running on an existing host cluster. There is no per-app infrastructure to build, so deploying is fast, and every app is isolated from other tenants.

From Deploy to live

The four stages the Deploy Application wizard shows. Select a stage for details.

Select a stage to see what happens behind it.

Two sources, one deployment path​

You can start from either:

  • A container image — any image in a public or private registry. KubeOpera deploys it directly.
  • A GitHub repository — KubeOpera builds an image first, then deploys it.

For a repository, build-service runs a Kaniko build in the host cluster's kubeopera-builds namespace using the Dockerfile path and build context you choose, and pushes the result to KubeOpera's built-in registry, where each tenant's images are isolated. From then on the build's image follows exactly the same path as a registry image. A pipeline is registered for the repository automatically, so you can follow the build in Pipelines. See build-service.

What the wizard asks for​

FieldNotes
NameUsed for the app's namespace and web address.
SourceA container image, or a GitHub repository with a Dockerfile path and build context.
Registry credentialsOnly for private images (or private base images).
Target vClusterShown only when your CloudSpace has more than one vCluster.
PortThe port your container listens on.
Environment variablesPlain values, or references to an existing Secret.
ResourcesCPU and memory requests and limits.
AutoscalingOptional minimum and maximum replicas and a CPU target.
TLSOn by default — KubeOpera issues a certificate for your app automatically.

What happens when you deploy​

  1. Desired state is recorded. kubeopera-api saves the app and creates a KubeOperaApp custom resource with your configuration.
  2. Manifests are generated. app-controller reconciles the resource and asks the app service to generate Kubernetes manifests — Deployment, Service, Ingress, Namespace and anything else the configuration needs.
  3. Manifests are committed to Git. app-controller pushes them to the fleet repository, so every deployment is versioned and reviewable.
  4. Flux deploys inside your vCluster. A Flux GitRepository and Kustomization inside your vCluster pick up the commit and apply it there — your workloads never run in shared host namespaces.
  5. Ingress and TLS are set up. The generated Ingress requests a certificate from cert-manager using a DNS-01 challenge. vCluster syncs the Ingress to the host cluster, where cert-manager and external-dns issue the certificate and create the DNS record.
  6. Your app gets an address. KubeOpera assigns <app>-<cloudspace>.apps.kubeopera.io (or your own domain, if you've configured one).

Deleting an app reverses all of this: its manifests are removed from Git and Flux cleans up every resource it created.

Watching the deployment​

The wizard's progress view reflects reality, not a timer. It checks three things in order:

  1. GitOps sync — has Flux applied the latest commit?
  2. Workload readiness — are the Deployment's pods ready inside your vCluster?
  3. Reachability — does an HTTPS request to the app's address actually succeed?

The View live app link appears only once the app responds.

How long does it take?

Most of the wait on a first TLS-enabled deploy is certificate issuance: DNS propagation plus Let's Encrypt validation typically takes two to three minutes after the pods are ready. Deploys without TLS, and redeploys of an app that already has a certificate, are reachable almost as soon as the pods are ready.

After deployment​

From the app's page you can:

  • view logs, pods and events from inside your vCluster;
  • see metrics, cost and AI advice for the app;
  • change configuration and redeploy — every change goes through Git the same way;
  • roll back to a previous version.

API​

The app endpoints — POST/GET/PUT/DELETE /apps, GET /apps/{id}/deploy-status, /logs, /pods and /events — are documented with request and response examples on the kubeopera-api page.

Next steps​