Install VoisX Orchestrate
This guide installs VoisX Orchestrate for production on your existing Kubernetes cluster: OpenShift, AKS, EKS, GKE, RKE2 or upstream Kubernetes, with several worker nodes, PostgreSQL replicated across them, and backups to your own object storage. One voisctl install command does the work: it verifies the release, pushes every image into your registry, installs the cluster add-ons your cluster doesn't already run, sets up the secrets store and the model registry, generates every credential, installs Orchestrate and checks the result. No step needs internet access.
Before you start, check the requirements: supported platforms, node sizing, storage, your registry, hostnames and TLS, network policy and a backup target.
To evaluate Orchestrate or run a pilot, you can install everything on one server with k3s in about 30 minutes. That shape is not for production. See Evaluation or pilot on a single server.
What you need from us
All of it comes from the VoisX portal. See How you receive VoisX Orchestrate.
- The release bundle,
vois-orchestrate-<version>-base-linux-amd64.tar, with itsSHA256SUMSfile and the release notes. It holds a signed manifest, every image the release needs, the cluster add-ons, the Helm chart andvoisctl. - The release key fingerprint, sent to you separately from the files, to compare with the one in the release notes.
- Your licence file. You activate and apply it after the install. See Licence.
voisctl has the VoisX release public key built in, so you don't install a key.
Before you start
Have these ready. Each is described in Requirements.
| A cluster | Kubernetes 1.28 or later, linux/amd64 worker nodes, at least 3 of them. A context for it in your kubeconfig with cluster-admin rights. |
| Storage | A ReadWriteOnce block StorageClass, default or named. |
| A registry | Your registry's address and project, an account that can push to it, and its CA certificate if your own CA signed it. |
| Publishing | An ingress controller (or OpenShift's router), the hostnames for the console, API and voice in DNS, and a TLS certificate for them, or a cert-manager ClusterIssuer. |
| A model registry address | The DNS name and port your nodes will reach model images at: the bundled Harbor, or your own registry. |
| A backup target | An S3-compatible bucket outside the cluster, an access key pair and its CA if private. |
| OpenBao unsealing | Your KMS or HSM settings for auto-unseal, or a plan for who holds the unseal keys. |
| A NetworkPolicy engine | Needed for code agents. |
1. Verify the bundle
-
Check the downloaded files against
SHA256SUMS, and compare the release key fingerprint in the release notes with the one we sent you separately:sha256sum -c SHA256SUMS --ignore-missing -
Extract
voisctl, or the whole bundle once. Everyvoisctlcommand accepts either the.tarfile or the extracted directory:mkdir bundle
tar -xf vois-orchestrate-0.1.0-base-linux-amd64.tar -C bundlevoisctlis in the bundle atbundle/tools/voisctl. The examples below run it as./voisctl. Copy it out, or use the full path. -
Check the signature and every part of the bundle:
./voisctl verify --bundle ./bundleverifychecks the manifest's signature against the built-in VoisX release key, then re-hashes every image layer, the chart, the add-ons' charts and settings and every tool file, and checks each signed image's signature, software bill of materials and build provenance. It ends withOKand the version. If it reports an error, don't install the bundle. Ask us for another copy. -
Optionally, list what the bundle contains with
./voisctl inspect --bundle ./bundle.
2. Prepare the namespace
Orchestrate installs into the namespace vois-orchestrate. voisctl install creates it if it doesn't exist, but you need it first for the Secrets below.
-
Create the namespace (on OpenShift,
oc new-project vois-orchestrate):kubectl --context <your-context> create namespace vois-orchestrate -
If you use your own certificate, create the TLS Secret for your hostnames. One SAN or wildcard certificate from your enterprise CA can cover the console, API, sign-in and voice:
kubectl --context <your-context> -n vois-orchestrate create secret tls vois-orchestrate-tls \
--cert=tls.crt --key=tls.key -
Create the Secret with your backup target's access key pair:
kubectl --context <your-context> -n vois-orchestrate create secret generic backup-s3 \
--from-literal=ACCESS_KEY_ID=<key> --from-literal=ACCESS_SECRET_KEY=<secret> -
If your nodes don't already pull from your registry with their own identity (as they do with ECR, Artifact Registry or an attached ACR), create a pull Secret and name it under
imagePullSecretsin your values file:kubectl --context <your-context> -n vois-orchestrate create secret docker-registry orchestrate-registry \
--docker-server=registry.example.com \
--docker-username=<pull-account> --docker-password=<password>
Pass --context to kubectl, and --kube-context to Helm and to voisctl, on every command. A command without it runs against whatever cluster your kubeconfig points at, which on an admin workstation may well be another environment.
3. Create your values file
Create a values file with your settings only, for example site.yaml, and keep it in version control. You don't put passwords or keys in it, because voisctl install generates those, and you don't list images, because voisctl points every image at your registry by digest.
A production starting point:
image:
registry: registry.example.com
# imagePullSecrets: [orchestrate-registry] # if you made a pull Secret above
# Publishing: your ingress controller and your certificate
exposure:
mode: ingress
className: nginx # your IngressClass
tls:
mode: secret # or certManager with clusterIssuer: <name>
secretName: vois-orchestrate-tls
components:
web: { enabled: true, host: orchestrate.example.com }
api: { enabled: true, host: orchestrate-api.example.com }
keycloak: { enabled: true, host: orchestrate.example.com } # may share the console's hostname
# Off by default. Turn on only if apps outside the cluster call models;
# the hostname can be internal-only.
# model-gateway: { enabled: true, host: orchestrate-gateway.internal.example.com }
livekit:
publicHost: orchestrate-voice.example.com
stunServers: ["stun.example.internal:3478"]
podSecurity:
restricted: true
persistence:
storageClassName: "" # empty: the cluster's default class
# PostgreSQL: three instances on CloudNativePG, one per node, no lost commits
postgresHA:
mode: cnpg
bootstrap: initdb
instances: 3
podAntiAffinityType: required
storage: { size: 50Gi }
synchronous:
enabled: true
method: any
number: 1
dataDurability: required
failoverQuorum: true
# monitoring: { podMonitor: true, prometheusRule: true } # with the Prometheus operator
# The stateless services twice each, with PodDisruptionBudgets
availability:
replicas:
api: 2
web: 2
modelGateway: 2
toolExecution: 2
orchestrationWorker: 2
realtimeAgentWorker: 2
podDisruptionBudgets: true
# Backups to your S3-compatible storage, outside the cluster
backups:
s3:
endpointURL: https://s3.example.internal
bucket: orchestrate-backups
credentialsSecret: { name: backup-s3 }
# caSecret: { name: backup-ca } # an endpoint with a private CA
postgres: { enabled: true, retention: 30d }
qdrant: { enabled: true, keep: 7 }
minio: { enabled: true }
license: { enabled: true, keep: 30 }
# Code agents, once your NetworkPolicy engine enforces policy
agents:
enabled: true
networkPolicy:
enforced: true
wheelhouse:
enabled: true
Size the data volumes for your data before the first install, because the size and storage class can't change later. See Configuration. For every other setting, see the configuration reference, and for the high availability settings, Requirements.
Signing in to the console takes the browser to Keycloak's sign-in page and back, so Keycloak needs an address that people's browsers can reach. exposure.components.keycloak publishes only the sign-in paths, never Keycloak's admin console, and it can share the console's hostname.
4. Install
Rehearse first. --dry-run verifies the bundle and prints every Helm command it would run, without pushing or changing anything:
./voisctl install --bundle ./bundle \
--registry registry.example.com \
--registry-user <push-account> --registry-password <password> \
--registry-ca ./enterprise-ca.crt \
--kube-context <your-context> \
--with-prerequisites \
--model-registry-url harbor.example.internal \
--openbao-keys ./openbao-init.json \
-f site.yaml \
--dry-run
Then run the same command without --dry-run. On OpenShift, EKS or GKE, add that platform's --profile; see Platform notes.
| Option | What it is |
|---|---|
--registry, --registry-user, --registry-password | Your registry and an account that can push to it. Plain Basic authentication works. |
--registry-ca | The CA that signed your registry's certificate, if it is your own. Model builds pull their runtime image from your registry and must trust it. The file must be readable by the user running voisctl. |
--with-prerequisites | Install the cluster add-ons from the bundle. Add-ons already in the cluster are detected and left alone. |
--skip-prerequisite <name> | Leave out one add-on that you provide yourself: openbao for your own Vault, harbor for your own model registry, ingress-nginx on OpenShift or with your own controller. Repeat for more. |
--prerequisite-values <name>=<file> | Your own settings for one bundled add-on, for example OpenBao's auto-unseal seal or Harbor's certificate. |
--profile | A profile from the signed chart: openshift, eks or gke for that platform, or ha for production high availability on three or more nodes. Leave it out on AKS, RKE2 and upstream Kubernetes unless you want ha. Your -f files win over it. |
--model-registry-url | host[:port] the nodes reach model images at: the bundled Harbor's address, or your own registry. |
--openbao-keys | Where OpenBao's unseal or recovery keys are written, on this machine. The file must not exist yet. See OpenBao: the keys. |
--harbor-ca-out | Where Harbor's CA certificate is written for your nodes. Default ./harbor-ca.crt. |
-f | Your values file. Repeat for more files. Your files win over the profile. |
Make sure the --registry-ca file exists and is readable before you start. Today voisctl reads it only after the images are pushed and the add-ons installed, so a mistake there shows up well into the install. Rerunning the same command then carries on quickly.
In order, refusing to go on after any failure, voisctl install:
- verifies the bundle, as
voisctl verifydoes; - checks the cluster: the Kubernetes version, every node's architecture, a default StorageClass and Helm 3;
- creates the
vois-orchestratenamespace and generates every credential (database passwords, service keys, the console admin password and the rest) into the Secretvois-orchestrate-install-values, before anything else, so a retried install reuses them; - pushes every image into your registry and reads each digest back, with each image's signature beside it;
- installs the add-ons your cluster doesn't already run, in order: cert-manager, CloudNativePG and its Barman Cloud plugin, KServe, OpenBao, Harbor and ingress-nginx, each from your registry;
- sets up what the add-ons hold for Orchestrate (next section);
- installs Orchestrate, pointed at OpenBao and the model registry, with model builds using the bundled runtime images, the code-agent package index on, and the offline settings on: no telemetry or update checks, no remote price list, and no starter models that only the internet could build. Add
--onlineif your site reaches the internet and you want those; - checks the result: every Orchestrate Deployment runs the signed image digest, the database is at the schema revision this release expects, and the API reports the bundle's version.
It ends with Installed <version>. and a short Next list: the console password, how to activate the licence (online on the portal, or offline through your VoisX contact), the OpenBao keys and Harbor's CA. Most of the time goes on pushing images into your registry.
Until a licence is activated for this cluster, the console shows it Invalid and every admin change (models, agents, projects, users) is refused with 402. Reads and anything already running keep working. Activating takes a short request made on the cluster and an answer from the portal; see Licence.
What voisctl sets up for you
Between the add-ons and Orchestrate, voisctl does what used to be a page of manual commands. Each step checks before it writes, so it is safe to run again, and every voisctl upgrade --with-prerequisites runs them again.
| Step | What voisctl does |
|---|---|
| OpenBao initialisation | Once, on a new OpenBao: creates the unseal keys (or, with auto-unseal, recovery keys) and the root token and writes them to your --openbao-keys file. |
| OpenBao unseal | Unseals it with the keys in that file, unless it unseals itself from your KMS or HSM. |
| OpenBao setup | The secrets engine, the Kubernetes sign-in, and the policies and roles Orchestrate uses for cluster, connector, model-provider and code-agent credentials. |
| Harbor projects | A project for model images (with scan-on-push and a nightly scan) and one for the scanner's offline vulnerability database. With code agents on, a private project for agent images. |
| Harbor accounts | A robot account that model builds push with and one that model deployments pull with, and the Kubernetes Secrets that hold them. |
| Certificate trust | One CA bundle, Harbor's CA plus your --registry-ca, that model builds and the deployment controller trust. |
| Licence binding | Turned on, so a licence can be activated for this cluster with no further step. See Licence. |
OpenBao: the keys
OpenBao encrypts what it stores with a key it keeps only in memory. After any restart of its pod, such as a node drain or a cluster upgrade, it is sealed: Orchestrate keeps running, but nothing stored in OpenBao (connector, cluster, model-provider and code-agent credentials) can be read until it is unsealed. In production, decide how before you install:
- Auto-unseal from your KMS or HSM, so OpenBao unseals itself at every start. Write a
sealsetting for the bundled OpenBao into a file and pass it with--prerequisite-values openbao=seal.yaml: atransitseal against a Vault or OpenBao you already run, a cloud KMS, or an HSM that the bundled OpenBao version supports.voisctlthen writes recovery keys, used only for maintenance, to the--openbao-keysfile. Contact us for help with the seal settings, and test a restart of OpenBao's pod in staging before you rely on it. - Unseal keys held by people. The
--openbao-keysfile holds 5 unseal keys, of which any 3 unseal OpenBao. Someone must runvoisctl openbao unsealafter every restart. See After a restart: unseal OpenBao.
Either way, the file also holds the root token. voisctl writes it with mode 600 on the machine where you run voisctl, and never into the cluster.
- Move it off that machine into your secrets safe as soon as the install is done. With unseal keys, give each of 3 to 5 key holders one of the keys, so no single person can unseal alone.
- Keep the root token with your security team only. Orchestrate doesn't need it to run.
- Keep two copies, offline. If every copy of the keys is lost, OpenBao's data can't be recovered. You would have to set up every stored credential again.
- Don't store the keys in a Kubernetes Secret on the same cluster: anyone who can read it could read everything OpenBao protects.
If your security team runs an HA Vault or OpenBao already, you can use it instead of the bundled one. See Vault or OpenBao.
If the install fails
voisctl names the step that failed. Fix the cause and run the same command again. A retried install reuses the credentials it already generated and the OpenBao keys file it already wrote, leaves add-ons that are already installed alone, and carries on over a release that never finished. With --skip-import it also skips the push, if the images are already in your registry.
Install with Helm instead
If your change process needs plain Helm, for example through GitOps, run voisctl import to push the images, install the add-ons yourself as in Requirements, generate the credentials file (keep it out of version control, or encrypt it the way your GitOps tooling does) and install the chart from the bundle:
./voisctl secrets generate --out values-secrets.yaml
helm upgrade --install vois-orchestrate ./bundle/chart/vois-orchestrate-<version>.tgz \
--kube-context <your-context> --namespace vois-orchestrate \
-f site.yaml -f values-secrets.yaml --wait --timeout 15m
You then set image.registry and every third-party image value yourself, and set up OpenBao or Vault, Harbor and the CA bundle by hand. Afterwards, run voisctl upgrade ... --force once to pin every image to its signed digest. We recommend voisctl install instead.
The Secret vois-orchestrate-install-values is the other copy of the database passwords. Don't delete it. Later upgrades carry the installed values forward.
The namespace must be vois-orchestrate. Model builds and model deployments address that namespace by name, so voisctl install refuses any other.
Production high availability
With --profile ha on three or more nodes, losing any one node (drained, or powered off) keeps every service answering:
./voisctl install ... --with-prerequisites --profile ha -f site.yaml
| Part | With --profile ha |
|---|---|
| Storage | Longhorn, from the bundle, keeps three copies of every volume on three nodes. A service that runs once restarts on another node with its data. |
| Console, API, gateway, workers, OPA, audit, code agents | Two copies each, on different nodes, with PodDisruptionBudgets. |
| PostgreSQL | Three instances on CloudNativePG, one per node, synchronous commit to one standby. |
| Qdrant | A three-node cluster; every knowledge base is kept on all three. |
| MinIO | Distributed over three pods with two drives each, erasure coded. |
| Redis | A primary and two replicas under Sentinel. |
| OpenBao | A three-server raft cluster. |
| Ingress | Two ingress-nginx controllers on different nodes. |
| Licence Service, Keycloak, Temporal, deployment controller, LiveKit, Harbor | One copy each, restarted on a healthy node within about a minute. Admin changes keep working on the last licence answer meanwhile. |
Pods on a node that stops answering are replaced after 30 seconds instead of Kubernetes' default 5 minutes. Use the same setting on your API server for the rest of the cluster (--default-not-ready-toleration-seconds=30, --default-unreachable-toleration-seconds=30).
Each node needs open-iscsi with iscsid running (Longhorn attaches volumes over iSCSI) and, if multipathd runs, blacklist { devnode "^sd[a-z0-9]+" } in /etc/multipath.conf. Size the nodes so that two of them can carry everything: about 8 vCPU and 9 GiB for Orchestrate, plus the add-ons and Longhorn, before models.
Your own replicated storage (Ceph RBD, a SAN CSI driver, vSAN, Portworx) instead of Longhorn: add --skip-prerequisite longhorn, set persistence.storageClassName to your class in your values file, and pass Harbor's volumes the same class with --prerequisite-values harbor=<file>:
persistence:
persistentVolumeClaim:
registry: { storageClass: ceph-rbd }
jobservice: { jobLog: { storageClass: ceph-rbd } }
database: { storageClass: ceph-rbd }
redis: { storageClass: ceph-rbd }
trivy: { storageClass: ceph-rbd }
Storage that stays on one node (local-path, hostPath) is not enough for this profile.
OpenBao unsealing. A restarted OpenBao server is sealed, but the other two keep serving. With unseal keys (the default), run ./voisctl openbao unseal --kube-context <your-context> --keys <file>: it unseals every sealed server. For no manual step, set up a transit auto-unseal against a Vault or OpenBao your site runs outside this cluster; see OpenBao unsealing in production.
The profile is for a new install. Turning it on for an existing one changes how Qdrant, MinIO, Redis and OpenBao store their data, so it is a planned migration: contact us.
Platform notes
The steps above are the same everywhere. These are the differences per platform.
OpenShift
Add --profile openshift. It turns on OpenShift mode (platform.openshift: true): restricted-v2 pod security with no fixed user ids, OpenShift Routes for every component you publish (exposure.mode: route), and service accounts of their own for the few pods that need a wider SCC. Before the install:
oc new-project vois-orchestrate
# Voice media binds to the node's address: LiveKit alone gets hostnetwork-v2
oc adm policy add-scc-to-user hostnetwork-v2 -z livekit -n vois-orchestrate
# Model builds and Ollama model servers run as root: anyuid for those two accounts only
oc adm policy add-scc-to-user anyuid -z model-builder -z model-server -n vois-orchestrate
Don't grant anyuid or privileged to the default service account to work around a problem: most of Orchestrate runs under it, and would then try to start as root.
- Use the cluster's router, not the bundled ingress-nginx: add
--skip-prerequisite ingress-nginx. In your values file, dropexposure.modeandclassName(the profile sets them) and keep thecomponentshosts. Hosts under the cluster's*.appswildcard need no DNS work. - TLS:
exposure.tls.mode: secretputs your certificate on each Route and needs OpenShift 4.16 or later.certManagerneeds the cert-manager OpenShift Routes add-on; without it the router serves its default wildcard certificate. - cert-manager: the cert-manager Operator for Red Hat OpenShift is detected and left alone.
- KServe: Orchestrate uses upstream KServe v0.20.0 in RawDeployment mode, as bundled. OpenShift AI's KServe differs in version and default mode.
- Storage: OpenShift Data Foundation's
ocs-storagecluster-ceph-rbdor your block class. Not CephFS.
Amazon EKS
Add --profile eks. It sets the gp3 StorageClass for every volume, restricted pod security and the nginx IngressClass.
- Install the EBS CSI driver add-on, with an IAM role for its service account, and create the
gp3StorageClass (provisionerebs.csi.aws.com,type: gp3,encrypted: "true",volumeBindingMode: WaitForFirstConsumer). Without the driver every volume staysPending. - Images: push to ECR or your own registry. Pulls from ECR are authorised by the node role, so
imagePullSecretscan usually stay empty. - Publishing: the bundled ingress-nginx gets an AWS load balancer. With the AWS Load Balancer Controller instead, set
exposure.className: alb, terminate TLS on the load balancer with an ACM certificate (exposure.tls.mode: none, the ALB annotations underexposure.annotations), and setweb.nextAuthUrlandweb.apiUrlto thehttps://addresses. - Voice: LiveKit advertises the node's VPC address. Browsers outside the VPC need a TURN server, or nodes with public addresses and security-group rules for its ports.
Google GKE
Add --profile gke. It sets the standard-rwo StorageClass, restricted pod security and the nginx IngressClass. Use premium-rwo for SSD-backed PostgreSQL and Qdrant.
- Use GKE Standard. Autopilot refuses LiveKit's host-network pod.
- On a private cluster, the control plane reaches nodes only on ports 443 and 10250 by default. KServe's webhook listens on 9443: add a firewall rule from the control plane's range to the nodes for it, and for any other webhook port that isn't covered.
- Images: push to Artifact Registry. Nodes pull with their service account, which needs
roles/artifactregistry.reader. - Publishing: ingress-nginx is simpler than GKE's own
gceclass, which needs a BackendConfig for the voice WebSocket timeout that the chart doesn't create.
Azure AKS
No profile is needed. Use a Premium SSD CSI class such as managed-csi-premium for the data volumes, spread the worker pool over availability zones, and turn on a network policy engine on the cluster (Azure CNI powered by Cilium, or Calico) so code agents can run. Images can go to Azure Container Registry, attached to the cluster so nodes pull without a Secret.
RKE2, Rancher and upstream Kubernetes
No profile is needed. RKE2 ships ingress-nginx, which voisctl detects and leaves alone, and Canal or Calico, which enforce NetworkPolicy. Bring a CSI block StorageClass such as Longhorn or Ceph RBD, or bind to volumes you created beforehand with persistence.storageClassName: "-". Publish through your ingress controller behind your load balancer (a hardware load balancer, F5 or MetalLB).
5. Let the nodes trust the model registry
The nodes' container runtime pulls model images directly, so it must trust the model registry's certificate. That is node configuration, outside Kubernetes, the same as for your main registry. voisctl wrote the bundled Harbor's CA to ./harbor-ca.crt (or your --harbor-ca-out).
The simplest production setup avoids this step: give the bundled Harbor a certificate from a CA your nodes already trust, with --prerequisite-values harbor=<file>, or use your own registry for model images (see Model images). Otherwise, add the CA on every node:
| Platform | How |
|---|---|
| containerd (most clusters) | /etc/containerd/certs.d/<harbor-host[:port]>/ca.crt on every node, through your node image or bootstrap configuration so new nodes get it too. |
| OpenShift | Add the CA to a ConfigMap in openshift-config, keyed by the registry host, and name it in the cluster's image.config.openshift.io additionalTrustedCA. |
| RKE2 | Add the registry with tls.ca_file to /etc/rancher/rke2/registries.yaml on every node, and restart RKE2. |
Harbor's generated certificate is valid for a year and is replaced whenever an upgrade moves Harbor to a new version, so repeat this step after such an upgrade, or use a certificate of your own.
6. Sign in for the first time
The install creates one console user, admin, with a generated password. voisctl prints where it is; read keycloak.consoleAdminPassword from the credentials Secret:
kubectl --context <your-context> -n vois-orchestrate get secret vois-orchestrate-install-values \
-o jsonpath='{.data.values\.yaml}' | base64 -d | grep consoleAdminPassword
A later release will hand you the first admin password without kubectl. Until then, read it as above.
- Open your console hostname, for example
https://orchestrate.example.com, and choose Sign in. The browser goes to the Keycloak sign-in page. - Sign in as
adminwith that password. - Open the Licence page to check the licence status, then activate and apply your licence. Until you do, admin changes are refused with
402.
admin holds the platform admin role, which reaches everything. Create named accounts for the people who run the platform, and keep admin for emergencies.
To add people:
- With your identity provider. Realm admins connect an OpenID Connect or SAML 2.0 identity provider, such as Entra ID, Okta, ADFS or Ping, under Admin → Identity & SSO in the console, map its groups to roles, and can require one-time-password MFA. Identity providers inside your own network work on an air-gapped install.
- With Keycloak accounts. Create users in the
vois-orchestraterealm and give them a role. See Users, roles and projects.
The Keycloak admin console is never published outside the cluster. Reach it through a port-forward, and sign in with the Keycloak admin user (admin unless you changed keycloak.adminUser) and keycloak.adminPassword from the credentials Secret:
kubectl --context <your-context> -n vois-orchestrate port-forward svc/keycloak 8180:8080
Then open http://localhost:8180/admin. Harbor's admin password is in the Secret vois-orchestrate-prereq-harbor-values in the vois-orchestrate namespace.
7. Check the install
-
All pods ready.
kubectl --context <your-context> get pods -AEvery pod should reach
RunningandReady. If one doesn't, see Troubleshooting. -
The version. The API answers
GET /versionwithout sign-in:kubectl --context <your-context> -n vois-orchestrate exec deploy/api -- \
python3 -c "import urllib.request; print(urllib.request.urlopen('http://127.0.0.1:8000/version').read().decode())" -
The console. Sign in, and open Models, Licence, System and Audit log. Each page should load with data, not empty panels. Empty panels usually mean the console and API hostnames don't match your settings.
-
High availability. Check that the PostgreSQL cluster has every instance ready and on different nodes, and that a replica is synchronous:
kubectl --context <your-context> -n vois-orchestrate get pods -o wide -l cnpg.io/cluster=postgres-haThen prove failover and restore before go-live: see Failover drill and Restore drill.
-
Backups. The first PostgreSQL base backup starts as soon as the database is created. Check your bucket for it and for archived WAL files. With the database alerts on,
PostgresWalArchivingFailingtells you if archiving stops. -
A model. Bring a model's weights in through the local model store, build and deploy it from Models, then call it from the playground or through the Model Gateway with an API key. The build uses the bundled runtime image, so it needs no internet.
Install online from the VoisX registry
If your cluster can reach the internet, you can install from the VoisX release registry instead of a bundle, with the registry credential file from the portal. Keep the credential file private.
./voisctl verify --from-registry <registry> --version 0.1.0 --pull-secret ./<credential-file>.json
./voisctl install --from-registry <registry> --version 0.1.0 --pull-secret ./<credential-file>.json \
--kube-context <your-context> -f site.yaml
<registry> is the registry host we send with your credential. verify reads the signed release information from the registry, checks its signature against the built-in key and that the signed version is the one you asked for, then checks the chart and every image digest and signature. To copy every image into your own registry first and install from there, add --registry and your push account, as for a bundle. The credential expires with your licence; voisctl warns 14 days before.
The VoisX release registry is not open yet. Until it is, install from the bundle as above.