Documentation · Google Cloud
Adequacy in your own Google Cloud project
The self-hosted edition of Adequacy runs on one virtual machine in your Google Cloud project. You deploy it from Adequacy’s listing on Google Cloud Marketplace (coming soon). Users, chats and usage records are stored in your project. To answer a question, the question and the source passages go to the AI model provider you choose: with Vertex AI they stay in Google Cloud; with the Anthropic or OpenAI API they leave it (see What leaves your project). Google bills the hourly licence on your Google Cloud bill, with no limit on users.
This guide is for the person who deploys and runs it. People who use it find the user guide in the app, at /docs.
What you deploy
- One VM,
<name>-vm, where<name>is the deployment name you choose. It runs Debian 13 and Docker with three containers: Caddy for HTTPS, the web app, and the API with the MCP server. Shielded VM and OS Login are on. - A separate data disk,
<name>-data, mounted at/var/lib/adequacy. It holds the database (users, chats, usage, settings and API keys) and the legal sources. Upgrades replace the VM but keep this disk. - A service account for the VM that can only write logs and metrics and call Vertex AI models.
- Firewall rules that deny all other inbound traffic. SSH is allowed only through IAP TCP forwarding (
35.235.240.0/20). - With IAP sign-in, an HTTPS load balancer with Identity-Aware Proxy in front of the VM.
Everything in Adequacy is included: the chat, the REST API, the MCP server, the obligations matrix and transfer map, and the Sources page, for all seven jurisdictions. The legal sources are updated by signed updates, normally daily. Answers are regulatory information, not legal advice.
The deployment turns on these APIs in your project: Compute Engine, Vertex AI, Cloud Logging, Cloud Monitoring, IAM, Cloud Resource Manager and Identity-Aware Proxy. They stay on if you delete the deployment.
Before you start
- A Google Cloud project with billing turned on.
- Permissions for the identity that deploys (on the deployment page you choose a service account for this). On the project it needs Compute Admin, Service Account Admin, Service Account User, Project IAM Admin, Role Administrator and Service Usage Admin, plus IAP Policy Admin for IAP sign-in. Together these are close to Owner: give them to the deployment’s own service account only, and only while you deploy, update or delete.
- If your organisation doesn’t let you create custom roles, turn off Least-privilege Vertex AI role (
predict_only_role). The VM then getsroles/aiplatform.userinstead of a custom role with onlyaiplatform.endpoints.predict. - For IAP sign-in: a domain name whose DNS you can change, and the email address of the first administrator.
- The VPC network must be in the same project: Shared VPC isn’t supported. The VM uses IPv4 only.
- If your organisation forbids external IPs on VMs (
constraints/compute.vmExternalIpAccess), choose IAP sign-in, with Outbound access set to Cloud NAT or None.
Deploy
- Open Adequacy’s listing on Google Cloud Marketplace (coming soon). Choose Get started (or Launch), accept the terms (Agree), and go on to the deployment page (Deploy). Google may label these buttons slightly differently.
- On the deployment page, choose the service account that deploys (with the permissions above) and fill in the form. The settings are listed below. Tick I have read and accept the Adequacy reliance notice (see The reliance notice): the deployment can’t start without it.
- Start the deployment (Deploy, at the bottom of the form). Marketplace runs it in your project with Infrastructure Manager. When it finishes, the deployment’s page shows the outputs and next steps.
- The VM’s first boot then takes about 5 minutes. Continue with After deploying.
Google Cloud Marketplace lists your deployments on its Solutions (solution deployments) page in the console, with their resources, details, logs and next steps.
Settings
Each setting below is a field on the deployment page; the first column is the setting’s name in the deployment. Some appear only for one sign-in mode, and some are under More options.
| Setting | Field | Default and use |
|---|---|---|
| accept_reliance_notice | I have read and accept the Adequacy reliance notice | Required, with no default. Unticked, the deployment stops with an error. See The reliance notice. |
| goog_cm_deployment_name | Deployment name | Names every resource (<name> in this guide). Lowercase letters, digits and hyphens, at most 40 characters, starting with a letter. |
| zone | Zone | europe-west1-b. Where the VM and its disks run. |
| machine_type | Machine type | e2-medium, which suits most teams. The minimum is e2-small. |
| auth_mode | Sign-in | local (local accounts, the quick start) or iap (Google Cloud IAP). See Sign-in. |
| domain | Domain name | Empty. Required for IAP; optional for local accounts. |
| admin_email | Administrator's email | Empty. Required for IAP: this person becomes the admin. Optional for local accounts. |
| admin_iap_member | The administrator's IAP identity (optional) | IAP only. Empty means user:<admin_email>. Set it for a group or a workforce pool. |
| iap_members | Who else may sign in (IAP) | IAP only. IAM principals, such as group:privacy-team@example.com or domain:example.com. |
| api_behind_iap | Put the REST API and MCP behind IAP too | IAP only. Off: the API and MCP take API keys and skip IAP. |
| source_ranges | Who can reach the VM (CIDR ranges) | Local accounts only. 0.0.0.0/0 (anywhere). Ranges allowed on ports 80 and 443. |
| network | Network | default. A network in this project. |
| subnetwork | Subnetwork | Empty, for an auto mode network such as default. |
| egress | Outbound access | external_ip. cloud_nat (no external IP) and none (your network provides it) need IAP. |
| lb_address | Load balancer IP address (optional) | IAP only. Empty reserves a new global address. |
| chat_history_retention_days | Chat history retention, in days | 365. Chats are deleted after this many days without activity (1 to 365). |
| boot_disk_type | Boot disk type | pd-balanced. The boot disk holds only the system and the app. |
| boot_disk_size_gb | Boot disk size in GB | 20 (20 to 1000). |
| data_disk_type | Data disk type | pd-balanced. Fixed once deployed. |
| data_disk_size_gb | Data disk size in GB | 20 (10 to 65536). You can grow it later in place. |
| existing_data_disk | Use an existing data disk (optional) | Empty: a new disk. The name of a disk in the same zone, to reuse or restore one. |
| keep_data_disk_on_delete | Keep the data disk when this deployment is deleted | Off. |
| snapshot_data_disk_before_destroy | Snapshot the data disk before it is deleted | On. |
| predict_only_role | Least-privilege Vertex AI role | On. |
| labels | Labels | Added to the VM, its disks, IP addresses and forwarding rules. |
| source_image | Image version | The newest Adequacy image. Change it to upgrade. |
The reliance notice
Before anyone uses Adequacy, they accept a short notice: Adequacy gives regulatory information drawn from official publications, not legal advice; the content can be incomplete or out of date; answers are written by AI and can be wrong, even when they cite a source; check the official source linked in each citation before you rely on an answer, and take professional advice for decisions that matter; and each person is responsible for how they use the information.
- When you deploy, you accept it in the form, for your organisation. The version you accepted is passed to the VM and recorded at its first boot; admins see it in Admin → Users.
- Each person reads and accepts it at their first sign-in: with local accounts, after choosing their own password; with IAP, straight after signing in with Google. Until then Adequacy shows them nothing else. When an upgrade brings a new version of the notice, everyone accepts it again at their next visit.
- API keys (REST and MCP) work once their owner has accepted a version of the notice. Before that, every call is refused with HTTP 428 and a message to sign in and accept it.
- Each acceptance is recorded in your deployment’s database, in your project: who, which version and when. No IP address is kept, and Amzu Information Technology Ltd can’t see it.
After deploying
The deployment’s outputs:
| Output | What it is |
|---|---|
| site_url | The address of Adequacy. |
| admin_user | Local accounts: the first admin's username, admin- and six random characters. IAP: the administrator's email. |
| admin_password | Local accounts only, marked sensitive: the first admin's temporary password. |
| ip_address | The public IP address: the VM's (local accounts) or the load balancer's (IAP). |
| dns_record | The DNS A record to create, when you set a domain. |
| ssh_command | SSH to the VM through IAP, for recovery. |
| vm_name | The VM's name. |
| vm_id | The VM's numeric ID. It changes when the VM is replaced. |
| data_disk | The data disk's name, to reuse it later. |
| next_steps | What to do next, for your sign-in mode. |
Local accounts
- Wait about 5 minutes for the first boot.
- If you set a domain, create the DNS record in
dns_record. The VM gets a Let’s Encrypt certificate once the name resolves. Without a domain, the VM uses a self-signed certificate, so your browser warns you the first time. - Open
site_urland sign in asadmin_userwithadmin_password. You choose a new password straight away, then accept the reliance notice. - In Admin → Users, add people. In Admin → AI model, choose the model (see AI models).
If the deployment page hides admin_password, read it from the VM’s metadata:
gcloud compute instances describe <name>-vm --zone <zone> --project <project> \ --format='value(metadata.items.adequacy-admin-password)'
Sign in as soon as the VM is up. Until the admin changes it, the temporary password can be read by anyone with compute.instances.get on the VM (Compute Viewer, project Viewer and above), by any process on the VM, and by anyone who can read the deployment’s outputs. After the change, the password in the metadata is useless.
IAP
- Create the DNS record in
dns_record. Google issues the certificate once the name resolves, which takes 15 to 60 minutes. Until then, HTTPS fails. - Open
site_urland sign in with Google as the administrator’s email. That person becomes the admin, and accepts the reliance notice first. - In Admin → AI model, choose the model.
Sign-in: local accounts or IAP
Local accounts (auth_mode = local)
- The quick start. It needs no domain. People sign in with a username and a password kept in Adequacy.
- Admins add people in Admin → Users and give each a temporary password, which they change at first sign-in. There is no email, so there is no “forgot password”: an admin resets it.
- Passwords are 12 to 256 characters and can’t contain the username. After 10 failed sign-ins in a row, an account locks for 15 minutes. A session lasts 12 hours.
- The VM gets a static external IP address,
<name>-ip. Ports 80 and 443 are open to Who can reach the VM (source_ranges), by default anywhere. Narrow it to your offices or VPN to keep the sign-in page off the internet. - HTTPS: with a domain, Caddy gets a Let’s Encrypt certificate. Let’s Encrypt must reach the VM from the internet for this, so keep
source_rangesopen, or use IAP. Without a domain, Caddy serves a self-signed certificate on the IP address.
Google Cloud IAP (auth_mode = iap)
- People sign in with your organisation’s Google identities: Cloud Identity, Google Workspace, and Okta or Microsoft Entra ID federated into them. Password sign-in is off.
- It needs a domain and the administrator’s email. The deployment creates a global external Application Load Balancer with a Google-managed certificate for the domain, HTTPS on port 443 (TLS 1.2 or later), and a redirect from HTTP to HTTPS.
- The web app is the backend service
<name>-ui, with IAP on. It uses IAP’s Google-managed OAuth client. The VM accepts port 80 only from the load balancer and its health checks (130.211.0.0/22,35.191.0.0/16). - Who may sign in: the administrator (
admin_iap_member, by defaultuser:<admin_email>) andiap_membersget the role IAP-secured Web App User (roles/iap.httpsResourceAccessor) on<name>-ui. To add people later, changeiap_members, or in the console go to Security → Identity-Aware Proxy, select<name>-ui, click Add principal and give the role IAP-secured Web App User. - People appear in Admin → Users after they first sign in, as members. The person with the administrator’s email becomes admin on first sign-in, as long as no admin exists yet. Admins can change roles, and disable or delete users.
- The REST API and MCP stay outside IAP by default, so scripts and AI tools can call them. The load balancer sends these exact paths to the backend service
<name>-api, which has IAP off:/v1/query,/v1/matrix,/v1/transfers,/v1/corpus,/v1/documents,/mcp,/api-docsand/openapi.json./v1/queryand/mcpstill need an Adequacy API key. The others return only the legal sources, the matrix and the API reference. Turn on Put the REST API and MCP behind IAP too (api_behind_iap) to send everything through IAP; scripts then need IAP credentials.
Switching later
- Local accounts to IAP: the load balancer is created and the VM’s static IP is released, so point your DNS record at the new
ip_address. People arrive through IAP as new users. Chat history kept under their local accounts isn’t moved across. - IAP to local accounts: the data disk already has its first admin, so no new one is created and the
admin_userandadmin_passwordoutputs don’t work. Create an admin over SSH withcreate-admin(see Recovery).
IAP with Workforce Identity Federation
IAP’s Google-managed OAuth client admits identities in your Google Cloud organisation. People who sign in through a Workforce Identity Federation pool need a custom OAuth client instead. Terraform can’t create it, because Google retired the IAP OAuth Admin API, so you set it up once, after deploying with IAP sign-in.
You need a workforce pool with one provider, in the same organisation as the project. Google’s guide asks the provider to map the email address, for example google.email=assertion.email. If IAP passes your identity provider’s email to Adequacy, the person whose email matches the administrator’s email becomes admin when they first sign in. Otherwise, an existing admin can make them admin in Admin → Users, or you can over SSH with python -m app.admin_cli make-admin <username>, using the username that list-users shows (see Recovery).
Create a workforce OAuth client in a project of the same organisation, with a placeholder redirect URI for now:
gcloud iam oauth-clients create adequacy-iap \ --project=<project> --location=global \ --client-type="CONFIDENTIAL_CLIENT" \ --display-name="Adequacy IAP" \ --allowed-scopes="https://www.googleapis.com/auth/cloud-platform" \ --allowed-redirect-uris="https://example.com/placeholder" \ --allowed-grant-types="authorization_code_grant"
Read its
clientId, then set the redirect URI to IAP’s:gcloud iam oauth-clients describe adequacy-iap --project=<project> --location=global gcloud iam oauth-clients update adequacy-iap --project=<project> --location=global \ --allowed-redirect-uris="https://iap.googleapis.com/v1/oauth/clientIds/<CLIENT_ID>:handleRedirect"
Create a secret, and read its
clientSecret:gcloud iam oauth-clients credentials create adequacy-iap-secret \ --oauth-client=adequacy-iap --project=<project> --location=global gcloud iam oauth-clients credentials describe adequacy-iap-secret \ --oauth-client=adequacy-iap --project=<project> --location=global
Write
iap_settings.yaml, and apply it to the web app’s backend service in the deployment’s project. Delete the file afterwards: it holds the secret.access_settings: identity_sources: ["WORKFORCE_IDENTITY_FEDERATION"] workforce_identity_settings: workforce_pools: ["locations/global/workforcePools/<POOL>"] oauth2: client_id: "<CLIENT_ID>" client_secret: "<CLIENT_SECRET>"gcloud iap settings set iap_settings.yaml --project=<project> \ --resource-type=compute --service=<name>-ui
- Give the pool’s people access with
principal://orprincipalSet://identifiers, iniap_membersandadmin_iap_member, for exampleprincipalSet://iam.googleapis.com/locations/global/workforcePools/<POOL>/*. Or add them on the Identity-Aware Proxy page, as above.
Google’s limits: one workforce pool per application, with one provider; the pool, the OAuth client and the application in the same organisation; and no device-based access levels. Scripts can’t pass IAP with workforce identities (only Google service accounts can), so keep the REST API and MCP outside IAP. See Google’s guide, Configure IAP with Workforce Identity Federation.
AI models
An admin chooses the model that writes the answers in Admin → AI model. A change applies from the next question, with no restart. Test connection sends one tiny question and shows how long the answer took, or the exact error and how to fix it.
| Choice | Setup |
|---|---|
| Gemini on Vertex AI | The default. It works without setup: the deployment lets the VM's service account call Vertex AI models. If a test fails, enable the Vertex AI API (gcloud services enable aiplatform.googleapis.com). It answers in Vertex AI's EU or US multi-region, or globally (see Vertex AI location below). |
| Claude on Vertex AI | Enable Claude Haiku 5.5 in Vertex AI Model Garden (console → Vertex AI → Model Garden → Claude → Enable) and accept Anthropic's terms. Then test. |
| Claude on the Anthropic API | Create a key at console.anthropic.com → API keys, and paste it in. |
| OpenAI | Create a key at platform.openai.com → API keys, and paste it in. |
- Model: leave it empty for the provider’s default model, or enter another model ID from the same provider.
- Vertex AI location: where Google processes the model’s requests. Leave it empty for the default, which follows the VM’s region. Gemini doesn’t answer in single regions, so from a VM in Europe its requests go to Vertex AI’s EU multi-region,
eu, and are processed in the EU. VMs in the UK (europe-west2) and Switzerland (europe-west6) also send Gemini requests to the EU multi-region; an admin can set another location here. From a VM in North America they go to the US multi-region,us. From anywhere else they go to the global endpoint,global, where Google may process them in any region. Claude answers in the VM’s region by default. To choose another location, entereu,us,globalor a region such aseurope-west1(if it offers the model). - Advanced: the VM reads Gemini’s default location at each boot from the instance metadata key
adequacy-vertex-generation-location(eu,us,globalor a region), when it is set. A Terraform or Marketplace update removes metadata keys it didn’t set, so prefer the Vertex AI location field. - API keys for Anthropic and OpenAI are stored on the data disk and never shown again: the page shows only their last four characters.
- Search: whichever model answers, questions are matched to the sources with Vertex AI’s
gemini-embedding-001, at Vertex AI’s endpoint for the VM’s region.
What leaves your project
Users, chats, usage records, settings and API keys stay on the data disk in your project. The containers log to Cloud Logging in your project. Only these leave the VM:
- Model calls, to answer a question. The question goes to Vertex AI in your project to find the matching source passages. The question and those passages then go to the model your admin chose: Gemini or Claude on Vertex AI in your project, or Anthropic’s or OpenAI’s API. For a chat follow-up, the model also receives the last few exchanges of the conversation. With Anthropic or OpenAI, this data leaves Google Cloud, under your own agreement with them. To match the question to the sources, it goes to Vertex AI’s endpoint for the VM’s region; where Google processes it depends on Google’s data residency terms for the model. Gemini requests from a VM in Europe go to Vertex AI’s EU multi-region and are processed in the EU; from a VM in North America, they go to the US multi-region. From anywhere else they go to the global endpoint, where Google may process them in any region. Claude on Vertex AI uses the VM’s region. An admin can change this in Admin → AI model (Vertex AI location).
- Update checks, to Amzu Information Technology Ltd. At boot, once a day at a random minute between 07:00 and 08:00 UTC, and when an admin clicks Check now in Admin → Content, the VM asks our content service for new legal sources. It sends a Google-signed identity token for the VM, which names your project, zone and instance and carries the licence, so that only licensed deployments get updates. Our service logs the project number and instance ID, and Google Cloud’s request logs record the address the check came from. We use them to count deployments and to limit how often each VM checks, and our Google Cloud logs keep them for 30 days. The VM then downloads the update from Cloud Storage through short-lived links. No questions, answers, users or usage are sent to us.
- Other connections: Debian’s and Docker’s package servers, for security updates; with IAP, Google’s public keys for checking sign-ins; and with local accounts and a domain, Let’s Encrypt. The containers are in the image, so nothing is downloaded to start them.
Costs
Everything below is on your Google Cloud bill, except Anthropic and OpenAI.
- Adequacy’s licence: an hourly charge for each running VM, with no limit on users. Google bills it through Marketplace. The price is on Adequacy’s listing on Google Cloud Marketplace (coming soon). For annual terms, ask us about a private offer.
- The VM: the machine type you choose (
e2-mediumby default), while it runs. - Disks: the boot disk and the data disk, whether or not the VM runs.
- Networking: the VM’s external IP address (with local accounts, and with IAP when
egressisexternal_ip); with IAP, the load balancer and the data it processes; withegressset tocloud_nat, Cloud NAT. - The AI provider: Vertex AI per use, for Gemini, Claude and the search embeddings. With Anthropic’s or OpenAI’s API, they bill you directly.
- Also: snapshots of the data disk until you delete them, and Cloud Logging beyond its free allowance.
Stopping the VM stops the VM and licence charges. Disks, IP addresses, the load balancer and snapshots still cost money. Estimate the rest with the Google Cloud pricing calculator.
Upgrades and changes
Marketplace deploys through Infrastructure Manager. To change a setting, update that deployment with new input values: in the console, find it under Infrastructure Manager → Deployments, choose to edit it (Edit), change the input values, and apply the change (Update). The console’s labels may differ slightly.
- Upgrading: set
source_image(Image version) to the new image. The VM and its boot disk are replaced. The data disk is detached and attached to the new VM. When an upgrade changes the database, the app first copies it to a backup on the data disk, kept for 7 days. Expect a few minutes of downtime. - Settings read at boot also replace the VM, keeping the data disk:
auth_mode,domain,admin_email,chat_history_retention_daysandlb_address, and any change to the load balancer’s address, the VM’s static IP or the data disk. - In place: labels,
iap_members,api_behind_iapand the firewall ranges. - The data disk: raising
data_disk_size_gbgrows it in place. Lowering it, or changing the zone, replaces it with an empty disk, so the app starts afresh (its first admin from the outputs again) until you restore; by default the old one is snapshotted first (see Backups and restore). Changingdata_disk_typelater has no effect. - Security updates: the VM applies Debian security updates daily. Docker and the app’s containers are updated by new images, so upgrade when one is released.
Legal source updates
Updates to the legal sources need no upgrade: they arrive as signed updates, normally daily. The VM checks each update’s signature and every file before it switches over, and keeps the version before. Admin → Content shows the version in use and the last check. Check now checks at once (up to 6 times an hour). Roll back to previous returns to the version before and pauses updates until an admin clicks Resume updates. Each update is valid for 14 days after we publish it. If the one in use passes that date without a newer one arriving, the app shows a banner that its content may be out of date; answers keep working.
Sources and credits
The Sources page of your deployment lists every official document its answers are drawn from, with each publisher’s licence and the credit it asks for. Where a source’s licence requires an acknowledgement, it appears with that source: on the Sources page, and at the start of the document’s own text. Adequacy is independent, and not affiliated with or endorsed by any regulator or government it quotes.
Release records
Every update carries a release record, covered by the update’s signature, so you can show which official texts, as of which dates, an answer relied on. A record holds:
- the update’s version, when we built it, and the version before it;
- how many sources it has, and how many were added, changed, unchanged or removed since the version before, with the dates its sources were fetched between;
- the checks we ran before publishing it: the signature check, and the change check, which stops an update that changes too much at once. The record says if we published past the change check after reviewing the change;
- every source: its title, jurisdiction and link, when we fetched it and when it was published (if known), whether it was added, changed or unchanged, and where it came from: crawled, a seed, or uploaded by our content team (with the time and the file’s hash); and the sources removed.
Admin → Content shows the record of the update in use as Release notes, and every update the VM has imported under Release history; choose one to see its notes. The VM keeps each record for good, also after the update’s files are removed. Download record (JSON) saves the record exactly as signed, and Download sources (CSV) its sources, for your own audits.
Amzu Information Technology Ltd keeps a ledger of every update it publishes: each record, with the hash and signature of the update it came with, in private storage. Entries are written so they can’t be overwritten, and the storage’s retention policy currently keeps them for 7 years. If you need to show what an update held, ask us and we can confirm it from the ledger.
Each answer records the update it was written from, while the VM keeps its answer trace (a year). In the chat, an answer shows “Sources as of content release” and the version, also when you reopen a saved conversation while the trace is kept, and each cited source shows when it was fetched and published. API and MCP answers include it as content_version, and each citation as fetched_at and published_at.
Backups and restore
Everything to back up is on the data disk, <name>-data (or the disk in existing_data_disk). The boot disk holds nothing you need.
Scheduled snapshots
The deployment doesn’t schedule backups. Add a snapshot schedule to the data disk, for example daily, kept for 14 days:
gcloud compute resource-policies create snapshot-schedule <name>-daily \ --project <project> --region <region> \ --daily-schedule --start-time 03:00 --max-retention-days 14 gcloud compute disks add-resource-policies <name>-data \ --project <project> --zone <zone> --resource-policies <name>-daily
Snapshots hold your users’ data, so keep them only as long as you need them.
Snapshots the deployment takes
With Snapshot the data disk before it is deleted on (the default), the deployment snapshots the data disk as <name>-data-YYYYMMDD-HHMMSS whenever it deletes it: when you delete the deployment, change the zone, or lower the data disk size. Under an organisation policy that allows a single region (constraints/gcp.resourceLocations), the snapshot can fail and stop the change. Store snapshots in the disk’s region with gcloud compute snapshot-settings update --storage-location-policy=local-region --project <project>, or turn the setting off first.
Restore
Find the snapshot: the deployment’s own are named
<name>-data-YYYYMMDD-HHMMSS.gcloud compute snapshots list --project <project> \ --filter="name~^<name>-data-" --format="table(name,diskSizeGb,creationTimestamp)" \ --sort-by=creationTimestamp
Pick the one taken when your disk was replaced or deleted: its time is that change’s, and its size the old disk’s. It isn’t always the newest: a restore deletes the deployment’s own disk too (below), after a snapshot of it, so after a smaller size or a new zone the newest snapshot is of the empty disk that replaced yours.
Create a disk from it, in the deployment’s zone, of the deployment’s data disk type (
data_disk_type:pd-balancedunless you chose another). The disk is the snapshot’s size; a--sizemust be at least that.gcloud compute disks create <name>-restored --project <project> --zone <zone> \ --source-snapshot <snapshot> --type <data_disk_type>
- To keep the current data disk as well, first update the deployment with Keep the data disk when this deployment is deleted on.
- Update the deployment with
existing_data_diskset to<name>-restored. The VM is replaced and starts on the restored disk. The deployment never deletes or snapshots a disk named here. Its own<name>-datadisk, if it has one, is deleted unless you kept it, by default after one more snapshot, of that disk. Keepexisting_data_diskset in every later update, upgrades included: emptied, it gives the deployment a new, empty<name>-datadisk (the restored disk stays in the project, unused). - Sign in with the accounts on the restored disk. It already has a first admin, so the
admin_userandadmin_passwordoutputs don’t apply.
Deleting a deployment
- Delete it where Google Cloud Marketplace lists it (the Solutions page above), or as an Infrastructure Manager deployment. By default the data disk is snapshotted first; the snapshot costs money until you delete it.
- To keep the disk instead, update the deployment with Keep the data disk when this deployment is deleted on, then delete it. To deploy again under the same name, set
existing_data_diskto<name>-data. - To leave nothing behind, update the deployment with Snapshot the data disk before it is deleted off, then delete it.
Recovery
SSH to the VM with the ssh_command output. You need IAP-secured Tunnel User (roles/iap.tunnelResourceAccessor), Compute OS Admin Login (roles/compute.osAdminLogin), and Service Account User on the VM’s service account.
gcloud compute ssh <name>-vm --zone <zone> --project <project> --tunnel-through-iap
On the VM, run the recovery commands in the app’s container:
sudo docker compose --project-directory /opt/adequacy \ --env-file /var/lib/adequacy/env/compose.env -f /opt/adequacy/compose.yaml \ exec backend python -m app.admin_cli <command>
| Command | What it does |
|---|---|
| list-users | Lists users with their role, status and last sign-in. |
| reset-password <user> | Local accounts: sets a temporary password, which you type twice at a hidden prompt. The user must change it at next sign-in, and their sessions end. |
| make-admin <user> | Makes the user an enabled admin. With IAP, use the username list-users shows (their email, when IAP passed one), after they have signed in once. |
| create-admin <user> | Local accounts: creates a new admin with a temporary password, when no admin can sign in. |
- A locked account unlocks after 15 minutes, or at once with
reset-password. - Health: every minute the VM restarts any container that fails its health check, up to 3 times an hour per container. The containers’ logs are in Cloud Logging, in your project.
- Answers fail: run Test connection in Admin → AI model. It names the problem, such as an API that isn’t enabled, a model that isn’t enabled, a bad key or a quota.
- Sources not updating: Admin → Content shows the last check and why it failed. The VM keeps serving the version it has.
Support
Email adequacy-support@amzuit.com. We answer in UK business hours, Monday to Friday, 09:00 to 17:30 UK time, excluding public holidays in England, and aim to send a first response within one UK business day. A private offer can add a service-level agreement.
Include the version (in the app’s footer), the deployment name, the zone, the sign-in mode, what you did, what happened and when. Never send passwords or API keys, and send your users’ questions only if we need them to look into a wrong answer.
Google bills the licence, so questions about your invoice go to Google Cloud Billing. The end-user licence agreement on Adequacy’s listing on Google Cloud Marketplace (coming soon) governs your use. For anything else about Adequacy, see the Sources page and the Matrix.