Skip to main content

Installing from Google Cloud Marketplace

Availability

The Google Cloud Marketplace listing is being prepared. Until it is published, ask IXEN for access; the installation below is what the listing will deploy.

Qry installs on a GKE cluster in your project from the Google Cloud console. The listing deploys the same Qry as any other installation; what changes is that Google runs the installer and, if you buy a plan billed by Google, reports usage to Google.

GKE Autopilot

The console's Click to deploy form lists Autopilot clusters as ineligible ("Autopilot cluster integration with marketplace is in progress"). That limit is Google's and applies to every Kubernetes app in the Marketplace; Qry itself runs on Autopilot. On an Autopilot cluster, install from the command line: the plan, billing and license are the same.

What the form asks​

FieldWhat it is
Name and namespaceWhere Qry runs. Qry and the Python it runs for people stay in this one namespace.
Qry service accountQry's backend and workers. Its only permissions are in its own namespace: starting and stopping the pods that run people's Python and notebooks.
Python execution service accountThe pods that run people's code. It has no Kubernetes permissions.

Google generates the rest when you install: Qry's encryption secret, the PostgreSQL and Redis passwords, and a first-run setup code. None of them is written to the installer's log.

What it sets up​

  • Qry's backend, workers and web interface, with a PostgreSQL (pgvector) and a Redis in the namespace, each with its own password.
  • Network policies. Only Qry's pods can reach its PostgreSQL and Redis. Only Qry's backend and workers can reach the pods that run people's code. The code itself can still reach Qry's backend (the qry module in notebooks), the internet (for pip) and your own data sources. They need a cluster that enforces network policies; GKE with Dataplane V2 does.
  • No pod that runs people's code gets a Kubernetes token.

After installing​

  1. Create the administrator. Open Qry; it asks for the setup code and the first administrator's email and password. The code is in the installation's details in the Google Cloud console. Until an administrator exists, no one can register or sign in with SSO. See the first administrator.
  2. Check the license. With the plan billed by Google there is nothing to add: the subscription is the license. Admin › License shows it as billed by Google, with the entitlement, this month's active users and the last report Google accepted. If IXEN sent you a license file (for example under a separate contract), paste it there instead: a license file takes precedence over the subscription.
  3. Connect your data and your AI provider as in any installation: before installing lists what each team grants.

The plan billed by Google​

Qry is billed per monthly active user: each person who uses the installation in a calendar month (US Pacific time) is counted once, however much they use it, whether they sign in, use it through chat, a messaging channel or the qry CLI, or through an application that calls it with an API key. The owner of an API key counts whenever the key is used. IXEN's support accounts, listed in a signed support list you can see and remove in Admin › License, are not counted. Prices and tiers are on the listing; the free trial, when the listing offers one, covers its period and credit. The license terms are at qry.dev/eula.

How it is reported:

  • Qry records each person the first time they use it in the month, in its own database.
  • A small reporter beside Google's metering agent (one pod, <name>-billing-agent) sends Google the month's count every hour, and the agent sends how long the installation has been running (USD 0.01 an hour, about USD 7 a month per installation). The reports carry counts only: no names, email addresses or data. The agent keeps reports on disk and retries, and admits no connection from other pods.
  • Qry checks with Google that the subscription is active. If it cannot confirm it for seven days (the subscription was cancelled, or the cluster cannot reach Google), Qry stops working until it can; Admin › License says why.

The cluster needs to reach servicecontrol.googleapis.com; GKE does by default.

Installing from the command line​

The console is the usual way, and the only one for GKE Autopilot clusters. The same installation can be made with kubectl and helm from the listing's public repository, which holds the chart with the Marketplace's settings.

One-time setup​

You need gcloud, kubectl, helm 3 and openssl, and a GKE cluster that enforces network policies (Dataplane V2).

gcloud container clusters get-credentials CLUSTER --region REGION
# Google's Application resource, once per cluster:
kubectl apply -f "https://raw.githubusercontent.com/GoogleCloudPlatform/marketplace-k8s-app-tools/master/crd/app-crd.yaml"
git clone https://github.com/pueteam/qry-google-cloud-marketplace.git
cd qry-google-cloud-marketplace

Install​

export APP_INSTANCE_NAME=qry
export NAMESPACE=qry
export TAG=0.206.0 # a published version
export REGISTRY=marketplace.gcr.io/ixen/qry # the listing's registry

kubectl create namespace "$NAMESPACE"

# Keep these: the encryption secret protects every stored credential, and an
# update needs the same values. Stored readable by you alone.
umask 077
cat > qry-secrets.env <<EOF
SECRET_KEY=$(openssl rand -hex 24)
POSTGRES_PASSWORD=$(openssl rand -hex 16)
REDIS_PASSWORD=$(openssl rand -hex 16)
SETUP_CODE=$(openssl rand -hex 8)
EOF
. ./qry-secrets.env

helm template "$APP_INSTANCE_NAME" chart/qry-platform --namespace "$NAMESPACE" \
--set serviceAccount.create=true \
--set pythonExecution.rbac.create=true \
--set backend.image.full="$REGISTRY:$TAG" \
--set frontend.image.full="$REGISTRY/frontend:$TAG" \
--set postgresql.image.registry="${REGISTRY%%/*}" \
--set postgresql.image.repository="${REGISTRY#*/}/postgres" \
--set postgresql.image.tag="$TAG" \
--set redis.image.registry="${REGISTRY%%/*}" \
--set redis.image.repository="${REGISTRY#*/}/redis" \
--set redis.image.tag="$TAG" \
--set runtimeImages.pythonExecutor="$REGISTRY/python-executor:$TAG" \
--set runtimeImages.pythonSession="$REGISTRY/python-session:$TAG" \
--set backend.secrets.secretKey="$SECRET_KEY" \
--set postgresql.auth.password="$POSTGRES_PASSWORD" \
--set redis.auth.password="$REDIS_PASSWORD" \
--set bootstrap.setupCode="$SETUP_CODE" \
> "${APP_INSTANCE_NAME}_manifest.yaml"

kubectl apply -n "$NAMESPACE" -f "${APP_INSTANCE_NAME}_manifest.yaml"

With the plan billed by Google, the command line needs the reporting key the console's installation would have created. In the listing, choose Deploy via command line and Download service account key; apply the file it downloads to the namespace before the manifest, and add its Secret's name when rendering:

kubectl apply -n "$NAMESPACE" -f service-account-key.yaml   # the downloaded key
# and in the helm template command above:
# --set googleMarketplace.reportingSecret=<metadata.name in service-account-key.yaml>

If the download fails with "service account … does not exist", the account was just created and Google has not finished setting it up: reload the page, choose that account under Reporting service account and download again.

Without it there is no subscription to bill, and so no license: Qry runs as an unlicensed installation (one user and one data source, for 30 days from its first start) until a license file is added.

The manifest holds the secrets too: delete it, or keep it where qry-secrets.env is. To pin images by digest instead of tag, put @sha256:… in place of :$TAG.

Check it with helm test's pod, which the manifest includes: it confirms that the backend is ready, that the API and the web interface answer, and that Redis refuses a pod without its password.

kubectl get pods -n "$NAMESPACE" -w      # until every pod is Running

Using Qry​

The web interface is the qry-frontend Service; it also serves the API under /api. To try it from your machine:

kubectl port-forward -n "$NAMESPACE" svc/qry-frontend 8080:8080

and open http://localhost:8080. For your users, put it behind your load balancer or an Ingress with TLS. Then create the administrator and check the license as in After installing.

Back up and restore​

Everything Qry keeps is in its PostgreSQL database: users, permissions, conversations, notebooks, settings and the stored credentials. Redis holds only queues and caches. The credentials are encrypted with the installation's encryption secret, so a backup is the database and that secret.

# The encryption secret (keep it apart from the dump):
kubectl get secret qry-backend-secrets -n "$NAMESPACE" -o jsonpath='{.data.JWT_SECRET_KEY}' | base64 -d > qry-secret-key.txt
# The database:
kubectl exec -n "$NAMESPACE" postgres-0 -- pg_dump -U postgres -Fc qrydb > qry-$(date +%F).dump

To restore into an installation with the same encryption secret:

kubectl scale -n "$NAMESPACE" deploy --all --replicas=0          # stop Qry, keep PostgreSQL
kubectl exec -n "$NAMESPACE" postgres-0 -- psql -U postgres -c 'DROP DATABASE qrydb WITH (FORCE)' -c 'CREATE DATABASE qrydb'
kubectl exec -i -n "$NAMESPACE" postgres-0 -- pg_restore -U postgres -d qrydb < qry-2026-11-03.dump
kubectl scale -n "$NAMESPACE" deploy qry-backend qry-frontend qry-worker celery-worker celery-worker-heavy celery-beat redis --replicas=1

Then raise the replica counts back to what they were. Restoring into an installation with another encryption secret keeps everything except the stored credentials, which have to be entered again.

Updating​

Each Qry version is published to the listing after Google's own verification passes on it. An installation follows its version track (for example 0.206). From the console, the installation's details offer the update. From the command line, render the manifest again with the new TAG and the same qry-secrets.env, and apply it; the database is migrated before the new backend starts. Take a backup first.

Scaling​

The parts of Qry that carry load scale with their replica count:

WorkloadWhat it doesScale it when
qry-backendthe API and the web sessionsmany people at once
qry-workerchat answers (10 at a time per pod)answers wait in the queue (Admin › System)
celery-worker, celery-worker-heavyscheduled tasks; data pipelines and profilingscheduled work runs late
kubectl scale -n "$NAMESPACE" deploy/qry-worker --replicas=3

The pods that run people's Python are started on demand, one per session, and need room in the cluster rather than replicas. PostgreSQL and Redis run one replica each.

Uninstalling​

Take a backup first if you may want the data again.

From the console, delete the application: the database's volume (postgres-pvc) is kept until you delete it with kubectl delete -n "$NAMESPACE" pvc postgres-pvc.

From the command line, deleting the manifest deletes the volume too, because the manifest holds it:

kubectl delete -n "$NAMESPACE" -f "${APP_INSTANCE_NAME}_manifest.yaml"