Install on Google Cloud
Deploy ScanSuite Teams into your own Google Cloud project on Cloud Run with Terraform, with installation examples.
ScanSuite Teams can run in your own Google Cloud project instead of on a server. A Terraform configuration in the gcp folder of the installation repository builds everything with one command and removes it with another. The application runs on Cloud Run with managed services around it, so there is no virtual machine to patch. A first deployment takes 20 to 30 minutes.
Cloud Run has no Docker daemon, so the scanners that run as containers of their own — dynamic web scanning (DAST), infrastructure scanning and the AI pentest — do not run here. Code (SAST), dependency (SCA), infrastructure-as-code, secrets and AI code analysis all work. For the other scan types, install on a server: Install ScanSuite Teams.
What gets built
Everything lives in one project. Passwords are generated on the first deploy and kept in Secret Manager; the database and Redis have private addresses only; the images are read through the project's Artifact Registry, pinned to exact digests.
| Part | How it runs |
|---|---|
| Web UI and API | A Cloud Run service behind an external HTTPS load balancer with Cloud Armor, which admits only your address ranges. |
| Background workers | Cloud Run worker pools: housekeeping and recovery of interrupted scans, the scheduler, and the sandbox for AI proof-of-concept checks. |
| Scans | One Cloud Run job execution per scan, 4 vCPU and 16 GiB, gone when the scan ends. |
| Database migration | A Cloud Run job that deploy.sh runs before the services start. |
| Database | Cloud SQL for PostgreSQL 16, private IP, nightly backups (14 kept) and point-in-time recovery over 7 days. |
| Task queue | Memorystore for Redis, private IP, TLS. |
| Scan artefacts | A Cloud Storage bucket, with earlier versions kept for 30 days. |
| Outbound traffic | Cloud NAT on fixed addresses, for allowlists at your git server and AI endpoint. |
| Monitoring | An uptime check and alerts on errors, failed uploads, database and Redis load. |
1. Before you start
| Prerequisite | Check | Expected |
|---|---|---|
| A Google Cloud project with billing | gcloud billing projects describe <PROJECT_ID> --format='value(billingEnabled)' | True |
| Your account is Owner, or Editor plus Project IAM Admin (the deployment creates service accounts and grants them roles) | gcloud projects get-iam-policy <PROJECT_ID> --flatten=bindings --filter='bindings.members:user:<YOUR_ACCOUNT>' --format='value(bindings.role)' | roles/owner, or roles/editor and roles/resourcemanager.projectIamAdmin |
| The Google Cloud CLI | gcloud --version | Google Cloud SDK and a version |
| Terraform 1.6 or newer | terraform version | Terraform v1.6.0 or later |
| git, bash and curl (Linux, macOS, or Windows with WSL or Git Bash) | git --version; bash --version | head -1; curl --version | head -1 | a version line each |
| The licence file and the registry user name and access token, from your order | — | See step 2 |
| Your public IPv4 address, or the ranges allowed to open the web UI | curl -4 -s https://ifconfig.me | an IPv4 address |
Create the project and link a billing account to it in the Google Cloud console (Billing), if that is not done yet. A project of its own for ScanSuite is simplest.
Using https://scansuite.eu/documentation/installation/install-on-google-cloud, check my prerequisites, write terraform.tfvars for a <trial|production> installation in project <PROJECT_ID> with my IPv4 address in web_allowed_cidrs, run terraform init and terraform plan, and show me both. Do not run ./deploy.sh or ./destroy.sh until I say so. I will sign in to Google Cloud and export the registry token myself; never ask me for it.Paste it into Claude Code or another coding agent. See Working with AI agents.
The values this page uses:
| Placeholder | Where it comes from |
|---|---|
| <PROJECT_ID> | Your project ID: gcloud projects list. |
| <YOUR_ACCOUNT> | The Google account you deploy with: gcloud config get-value account. |
| <LICENCE_CODE> | The six characters after the last underscore of the licence file name, <name>_<LICENCE_CODE>.lic. It is also the image tag. |
| <REGISTRY_USER> | The registry user name sent with your order. |
| <YOUR_IPV4> | The output of curl -4 -s https://ifconfig.me, or your office and VPN ranges. |
| <YOUR_DOMAIN> | Optional: the name the UI is served on, such as scansuite.example.com. |
2. Get the installation files
Get the files, add your licence, and change to the gcp folder:
git clone https://github.com/cepxeo/scansuite.git
cp /path/to/<name>_<LICENCE_CODE>.lic scansuite/key/
cd scansuite/gcp
ls ../key/*.licExpected: exactly one .lic file listed. With several, set pyarmor_license_file to the one matching image_tag.
3. Sign in to Google Cloud
Sign in twice — once for gcloud, once for Terraform (Application Default Credentials). Each opens a browser where you choose your account:
gcloud auth login
gcloud auth application-default login
gcloud config set project <PROJECT_ID>Check:
gcloud config get-value account
gcloud auth application-default print-access-token >/dev/null && echo ADC okExpected: your account, then ADC ok.
4. Write the settings
Copy the example settings and edit the copy. Section 7 has complete examples; the settings reference lists every setting.
cp terraform.tfvars.example terraform.tfvars| Setting | What to put | Default |
|---|---|---|
| project_id | Your project ID. | required |
| region | The region. With another region also set zones and primary_zone (example D). | europe-west3 |
| image_tag | Your licence code. | required |
| dockerhub_username | The registry user name from your order. | required |
| web_allowed_cidrs | The address ranges allowed to open the UI, up to 10, such as ["203.0.113.10/32"]. Set it before the first deploy: the setup page belongs to whoever opens it first. | open to the internet |
| timezone | The time zone scheduled scans run in, such as Europe/Berlin. Set it: the default is Europe/Moscow. | Europe/Moscow |
| alert_email | Where alerts go. | none |
Optional preview, which changes nothing:
terraform init && terraform planExpected: Plan: N to add, 0 to change, 0 to destroy. The registry token is not needed for the preview.
5. Deploy
./deploy.sh creates and changes resources without a further question: running it is the approval. Type the registry access token into the shell yourself — it is kept in Secret Manager, readable only by Artifact Registry, and never written to the settings file:
read -rsp 'Registry access token: ' TF_VAR_dockerhub_token; echo; export TF_VAR_dockerhub_token
./deploy.shThe script checks your sign-in, the project's billing and the licence before creating anything; creates the project's Artifact Registry and finds the exact images for your licence code; builds the network, database, Redis, storage and secrets and runs the database migration; then starts the services, the load balancer and monitoring. Re-running it is safe at any point.
Expected: the run ends with ==> Done, the outputs, and a Next list. Check that the setup page answers:
terraform output url
curl -sk -o /dev/null -w '%{http_code}\n' "$(terraform output -raw url)/setup"Expected: the address, then 200. A new load balancer can take 5 to 10 minutes to answer; until then the check may print 404 or fail — wait and try again.
6. Sign in and connect AI
Open the url output right away and create the first account on the setup page, choosing the password yourself — as on a server, see Create the first account in Install ScanSuite Teams. Without a domain name the address is the load balancer's IP with a self-signed certificate, so the browser warns once. Whoever opens the page first gets that account.
Fields and checks are the same as on a server: Install ScanSuite Teams, step 5. Then connect the AI provider — with no scanner containers the model does the analysis, so this is not optional. In the user menu (top right) open System Settings → Shared services:
- AI connections → Add connection. For Vertex AI in this project: Kind Vertex AI (Claude), Google Cloud project ID
<PROJECT_ID>, Vertex AI region where the model is offered (such aseurope-west1, orglobal), and switch on Use the deployment's own identity (no key): the installation's service account already has the Vertex AI User role. Any OpenAI-compatible endpoint works too; scans reach it from the addresses in thescan_egress_ipsoutput. Click Save. - AI models → Add model: Name, Connection, Model ID (the Claude model ID). Click Save.
- Task routing → Change on the Default row → First model → Save.
- System AI → Test connection. Expected: Answered in N s: …
Enable the Claude model for the project in the Google Cloud console under Vertex AI → Model Garden before you test; this accepts the model provider's terms.
Every field and the per-task routing are in AI providers and cost. Then continue with Quick start.
Your own domain
With domain_name set, the UI gets a Google-managed certificate once the name resolves to the load balancer:
Point the DNS A record of <YOUR_DOMAIN> at the load_balancer_ip output. With manage_dns = true the deployment creates the zone and the record instead, and you delegate the zone at your registrar.
dig +short <YOUR_DOMAIN>
terraform output -raw load_balancer_ip
gcloud compute ssl-certificates list --project <PROJECT_ID>Expected: the same address twice, and the certificate's status ACTIVE — up to an hour after the name resolves.
7. Installation examples
Examples A, B and C are complete terraform.tfvars files; D to G are lines to add to one of them. The registry token always comes from the shell, as in step 5.
A. A trial installation
Small sizes without standby copies, the UI open to one address — about half the cost of the defaults:
project_id = "acme-scansuite-trial"
region = "europe-west3"
environment = "dev"
image_tag = "a1b2c3"
dockerhub_username = "<REGISTRY_USER>"
web_allowed_cidrs = ["203.0.113.10/32"]
timezone = "Europe/Berlin"
# Smaller than the production defaults, without standby copies.
cloudsql_ha = false
cloudsql_tier = "db-custom-1-3840" # 1 vCPU, 3.75 GB
cloudsql_disk_gb = 20
redis_ha = false
redis_memory_gb = 1
poc_replicas = 1When the trial is over, ./destroy.sh --delete-artifacts removes everything, the stored scan artefacts included.
B. A production installation
The default sizes (a standby database and Redis), your own domain with a Google-managed certificate, alerts, and protection against accidental deletion:
project_id = "acme-scansuite"
region = "europe-west3"
environment = "prod"
image_tag = "a1b2c3"
dockerhub_username = "<REGISTRY_USER>"
domain_name = "scansuite.acme.example"
web_allowed_cidrs = ["198.51.100.0/24", "203.0.113.10/32"] # office and VPN
timezone = "Europe/Berlin"
alert_email = "secops@acme.example"
deletion_protection = trueAfter the first deploy, point the domain at the load balancer as in Your own domain above. Before anyone else runs the deployment, move the Terraform state to a Cloud Storage bucket, as backend.tf.example describes.
C. No access from the internet
For a corporate network that reaches the project's VPC over VPN, Interconnect or Network Connectivity Center. There is no load balancer and no route to the internet: the UI is served on its Cloud Run address to callers inside the network only, Google APIs (Vertex AI, Cloud Storage) are reached through Private Google Access, and the images are copied from your own registry. Start from terraform.tfvars.internal.example, which has every line below with comments:
project_id = "acme-scansuite"
region = "europe-west3"
environment = "prod"
deletion_protection = true
internal_only = true
egress_mode = "none"
google_apis_vip = "restricted" # "private" outside a VPC Service Controls perimeter
# From the corporate address plan: must not overlap anything there.
subnet_cidr = "10.120.0.0/24"
psa_cidr = "10.120.16.0/20"
# Internal names the scans resolve (your git hosts), forwarded to the corporate DNS servers.
dns_forwarding_zones = { "corp.example." = ["10.0.0.53", "10.0.1.53"] }
dns_inbound_forwarding = true
image_tag = "a1b2c3"
source_registry = "registry.corp.example/scansuite"
timezone = "Europe/Berlin"
alert_email = "secops@acme.example"Export SOURCE_REGISTRY_USERNAME and SOURCE_REGISTRY_TOKEN (your registry's robot account) in the shell before ./deploy.sh, the same way as the token in step 5. After the deploy, your network team:
- routes the
google_apis_rangeoutput from the corporate network to this VPC; - has the corporate DNS servers forward
run.appto the addresses that thedns_inbound_forwarders_commandoutput lists, so internal browsers resolve theurloutput.
web_allowed_cidrs and domain_name are not used, and the uptime alert is left out: Google's probers cannot reach an internal address. Scans reach internal hosts from the subnet range, and the scan_egress_ips output is empty.
D. Another region
Set the region and its zones together; the zones place Redis and the database's standby:
region = "europe-west4"
zones = ["europe-west4-a", "europe-west4-b", "europe-west4-c"]
primary_zone = "europe-west4-b"E. A second installation in the same project
Such as a test installation next to production. Deploy it from its own copy of the folder, so it has its own Terraform state (cp -r scansuite/gcp scansuite/gcp-test), and give it its own prefix, so every resource gets its own name:
name_prefix = "scansuite-test"Keep the prefix short: the artefact bucket is named <name_prefix>-artifacts-<project_id>, at most 63 characters.
F. Images from your own registry
Where the installation must not read Docker Hub at all, copy the three images into the project's registry once per release with ./scripts/mirror-images.sh <PROJECT_ID> <LICENCE_CODE> [region] [repository] (region defaults to europe-west3, repository to scansuite; Docker needed, signed in to Docker Hub with the registry user). It prints the lines to add; image_tag and dockerhub_username are then not needed:
image_web = "europe-west3-docker.pkg.dev/acme-scansuite/scansuite/teams-web:a1b2c3"
image_worker = "europe-west3-docker.pkg.dev/acme-scansuite/scansuite/teams-worker:a1b2c3"
image_worker_poc = "europe-west3-docker.pkg.dev/acme-scansuite/scansuite/teams-worker-poc:a1b2c3"G. Deploying again soon after a teardown
Cloud SQL keeps a deleted instance's name for about a week. To deploy again in that time, give the database another name:
cloudsql_name = "scansuite-pg-2"8. Settings reference
Every setting of terraform.tfvars. Change one by editing the file and running ./deploy.sh again.
Project and placement
| Setting | What it does | Default | When to change |
|---|---|---|---|
| project_id | The project to deploy into. | required | — |
| region | The region. | europe-west3 | Another region; set zones and primary_zone with it. |
| zones | The region's zones, which place Redis and the database standby. | europe-west3-a, -b, -c | With region. |
| primary_zone | The main zone. | europe-west3-b | With region. |
| name_prefix | Prefix of every resource name. | scansuite | A second installation in the project (example E). |
| environment | Label of every resource: dev, stage or prod; also adjusts a few sizes. | prod | dev for a trial. |
| platform | cloudrun, or gke for a regional GKE Standard cluster running the same images. | cloudrun | Only when you need node-level control or a longer termination grace period than Cloud Run allows; see the GKE settings below. |
| timezone | The time zone of the containers; scheduled scans follow it. | Europe/Moscow | Always: set your own. |
| alert_email | Where alert notifications go. | none: alerts without a channel | Production. |
| deletion_protection | Cloud SQL and the services refuse deletion by anything but destroy.sh. | false | true for production. |
Access
| Setting | What it does | Default | When to change |
|---|---|---|---|
| web_allowed_cidrs | Ranges allowed through the load balancer, at most 10. | empty: the whole internet | Always, before the first deploy. |
| domain_name | The UI's host name, with a Google-managed certificate. | none: the load balancer IP with a self-signed certificate | Production. |
| manage_dns | Create a Cloud DNS zone and the A record for domain_name; you delegate the zone. | false | Your DNS is in this project. |
| internal_only | No load balancer; the UI on its Cloud Run address, to internal callers only. | false | No access from the internet (example C). Cloud Run only. |
Images and licence
| Setting | What it does | Default | When to change |
|---|---|---|---|
| image_tag | Your licence code: the tag of the three images. | required unless image_web, image_worker and image_worker_poc are all set | Each new release. |
| dockerhub_username | The registry user name from your order. | none | — |
| dockerhub_token | The registry access token. Give it as TF_VAR_dockerhub_token in the shell, never in the file. | none | — |
| image_source | The Docker Hub namespace the images come from. | appsec4u | Do not change. |
| image_repository | Where the images are read from, up to the image name. | the remote repository in front of Docker Hub | Set by deploy.sh with LOCAL_IMAGES=1. |
| source_registry | Your own registry to copy the images from, such as registry.corp.example/scansuite. | none | No Docker Hub access (example C). |
| source_image_names | The image names in source_registry, when they differ. | teams-web, teams-worker, teams-worker-poc | Your registry names them otherwise. |
| image_web, image_worker, image_worker_poc | Full image references, used as given. | derived | Mirrored images (example F). |
| image_digests | Written by deploy.sh to images.auto.tfvars.json. | — | Never by hand. |
| key_dir | The folder holding the licence file. | ../key | The licence is elsewhere. |
| pyarmor_license_file | The licence file name inside key_dir. | the only .lic there | key_dir holds several. |
Network
| Setting | What it does | Default | When to change |
|---|---|---|---|
| egress_mode | nat: Cloud NAT on fixed addresses. none: no route to the internet; Google APIs through Private Google Access. | nat | none for example C (Cloud Run only). |
| nat_ip_count | How many fixed outbound addresses to reserve. | 2 | Keep them stable: they are what git servers and AI endpoints allow. |
| google_apis_vip | With egress_mode = none: private (every Google API) or restricted (VPC Service Controls). | private | restricted inside a perimeter. |
| subnet_cidr | The subnet. | 10.10.0.0/20 | When the VPC is connected to a corporate network. |
| psa_cidr | The range for Cloud SQL and Memorystore, at least a /24. | 10.30.0.0/16 | As subnet_cidr. |
| dns_forwarding_zones | Internal domains forwarded to your DNS servers, such as { "corp.example." = ["10.0.0.53"] }. | none | Scans must resolve internal git hosts. |
| dns_inbound_forwarding | Inbound DNS forwarders your DNS servers forward run.app to. | false | Example C. |
Database, Redis and storage
| Setting | What it does | Default | When to change |
|---|---|---|---|
| cloudsql_name | The Cloud SQL instance name. | <name_prefix>-pg | Redeploying within a week of a teardown (example G). |
| cloudsql_tier | The Cloud SQL machine tier. | db-custom-2-8192 (2 vCPU, 8 GB) | Smaller for a trial, larger for many teams. |
| cloudsql_disk_gb | The database disk in GB; it grows automatically. | 100 | Smaller for a trial. |
| cloudsql_ha | A standby database in another zone. | true | false for a trial: about half the database cost. |
| redis_memory_gb | Memorystore capacity in GB. | 4 | 1 for a trial. |
| redis_ha | A Redis replica with automatic failover. | true | false for a trial. |
| redis_tls | Encrypted traffic to Redis. Changing it replaces the instance and drops queued work. | true | Only when no scan is running. |
| artifact_retention_days | Days earlier versions of stored artefacts are kept. | 30 | Your retention policy. |
| artifact_bucket_force_destroy | Let a teardown delete the artefact bucket with its contents. | false | Leave it: destroy.sh --delete-artifacts sets it. |
Cloud Run sizing
| Setting | What it does | Default | When to change |
|---|---|---|---|
| scan_cpu | vCPU per scan, at most 8. | 4 | Very large repositories. |
| scan_memory | Memory per scan, at most 32Gi. The repository clone is held in memory and counts against it. | 16Gi | Very large repositories. |
| scan_task_timeout_seconds | The longest a scan may run. | 172800 (48 hours) | Rarely. |
| web_min_instances | Warm web instances. | 1 | 0 saves money; the first visit after a quiet period waits for a cold start. |
| web_max_instances | The most web instances. | 4 | Many concurrent users. |
| admin_instances | Instances of the background worker. | 1 | Rarely. |
| poc_replicas | Sandboxes for proof-of-concept checks. | 2 | 1 for a trial. |
Scans and AI keys
| Setting | What it does | Default | When to change |
|---|---|---|---|
| enable_static_scans | Static analyses. | True | Leave it. |
| enable_dynamic_scans | Dynamic and infrastructure scans, which need a Docker daemon this deployment does not have. | False | Leave it. |
| llm_service_account_email | Another service account to grant the Vertex AI and bucket roles to. | none | Only when Vertex AI must be called with another service account's key instead of the deployment's own identity. |
| llm_sa_key_file | Path to that service account's key file, mounted for the application. | none | As above. |
| llm_sa_key_b64 | The same key, base64-encoded. Prefer llm_sa_key_file, or add the secret version yourself to keep the key out of the Terraform state. | none | As above. |
GKE only (platform = "gke")
| Setting | What it does | Default | When to change |
|---|---|---|---|
| master_authorized_cidrs | Ranges allowed to reach the cluster's control plane. | the address you run Terraform from | Deploying from a pipeline. |
| enable_secrets_encryption | Encrypt Kubernetes secrets with a Cloud KMS key as well. | false | Your policy requires it. |
| pods_cidr, services_cidr, master_cidr | The cluster's address ranges. | 10.20.0.0/14, 10.24.0.0/20, 172.16.0.0/28 | They overlap your network. |
| general_machine_type | Machines for the web UI and the scheduler. | e2-standard-2 | Many users. |
| scan_engine_machine_type | Machines for the scan workers. | n2-standard-4 | Large repositories. |
| worker_replicas | Scan workers; each runs one scan at a time. | 1 | More parallel scans. |
| poc_machine_type | Machines for the proof-of-concept sandbox. | e2-standard-2 | Rarely. |
| scratch_disk_gb | Scan work space per worker, in GB. | 200 | Large repositories. |
| image_pull_registry | The registry the image pull secret signs in to. | Docker Hub | Images from your own registry. |
Environment variables and script options
| Variable or option | Used by | What it does |
|---|---|---|
| TF_VAR_dockerhub_token | deploy.sh | The registry access token. Typed by a person, never stored in the file. |
| TF_VAR_project_id | deploy.sh | The project, instead of project_id in terraform.tfvars. |
| SOURCE_REGISTRY_USERNAME, SOURCE_REGISTRY_TOKEN | deploy.sh | The account deploy.sh copies the images from source_registry with; signed out again afterwards. |
| LOCAL_IMAGES=1 | deploy.sh | Push the images from the local Docker engine instead of reading them from the registry. |
| MIGRATE=1 | deploy.sh | Run the database migration even when the images have not changed. It cancels running scans. |
| extra arguments | deploy.sh, destroy.sh | Passed on to terraform. |
| -y, --yes | destroy.sh | Do not ask for the project ID. |
| --delete-artifacts | destroy.sh | Also delete the artefact bucket with the stored scan artefacts. |
Outputs
terraform output prints them at any time; terraform output -raw <name> prints one.
| Output | What it is |
|---|---|
| url | Where ScanSuite is served. |
| load_balancer_ip | The load balancer address, for the DNS record. Empty with internal_only. |
| scan_egress_ips | The fixed addresses scans and AI calls leave from, for allowlists. Empty with egress_mode = none. |
| google_apis_range | With egress_mode = none: the range to route from the corporate network. |
| dns_inbound_forwarders_command | Lists the addresses your DNS servers forward run.app to. |
| artifact_bucket | The bucket holding the scan artefacts. |
| secret_names | The Secret Manager entries holding the generated passwords. |
| migrate_job_name, migrate_command | The migration job, and the command that runs it. |
| images | The exact images the services run. |
| artifact_registry_url | Where mirrored images are pushed (example F). |
9. Day-to-day operation
- Change a setting: edit
terraform.tfvarsand run./deploy.shagain. While the images stay the same, running scans carry on. - A new release: put the new
.licin../key/and remove the old one, setimage_tagto the new code, rungit pull, then./deploy.sh. The migration cancels scans still running, so update when none is. - Interrupted scans recover by themselves: a scan whose execution stopped shows no progress for 90 minutes and is then started again.
- Browser uploads are limited to 32 MiB on Cloud Run; scan larger code from its git repository.
- Your address changed and the UI no longer opens: update
web_allowed_cidrsand run./deploy.sh. - Logs: in the console under Logging → Logs Explorer, or:
gcloud logging read 'resource.type="cloud_run_revision" AND resource.labels.service_name="scansuite-web"' --limit 50 --format='value(textPayload)'
gcloud logging read 'resource.type="cloud_run_job" AND resource.labels.job_name="scansuite-sast"' --limit 100 --format='value(textPayload)'- Backups: Cloud SQL backs up every night and supports point-in-time recovery; restore in the console under SQL → Backups.
- Keep the Terraform state safe:
terraform.tfstateholds the generated passwords and your licence. Keep it private, back it up after every deploy, and move it to a Cloud Storage bucket before a second person or a pipeline deploys.
Rough monthly costs in USD; check your region in the Google Cloud pricing calculator:
| Item | Defaults | Trial (example A) |
|---|---|---|
| Cloud SQL | 200-250 | 50-70 |
| Memorystore | 150-200 | 35-45 |
| Cloud Run services | 300-400 | 200-250 |
| Load balancer, Cloud Armor, Cloud NAT | 50-80 | 50-80 |
| Storage, secrets, registry, logs | 10-30 | 10-30 |
| Scans, 4 vCPU and 16 GiB each | about 0.5 per scan-hour | the same |
10. Tear down
Tearing down deletes the database with all scan data. A person decides to run destroy.sh and types the project ID when it asks.
./destroy.sh # asks you to type the project ID
./destroy.sh --delete-artifacts # also delete the stored scan artefactsIt deletes everything the deployment created in about 15 minutes. The scan artefacts' bucket is kept unless you pass --delete-artifacts. If a run stops part-way, run it again: it carries on with what is left. One stop is normal — Cloud Run keeps a few addresses in the network for up to two hours after its services are deleted, and only Google can release them. The script says so; nothing left at that point is billed. Check that nothing is left with terraform state list, which then prints nothing.
billing is not enabled: link a billing account to the project. no licence in ../key/: put your .lic there, or set pyarmor_license_file. could not find teams-web:<code>: check image_tag, dockerhub_username and the token. The Cloud SQL instance already exists: example G. A zone error after changing the region: example D. An API "has not been used in project": a newly enabled API needs a few minutes; run ./deploy.sh again. The page does not load: check that your address is in web_allowed_cidrs; a new load balancer can take 5 to 10 minutes to answer. The URL opens the sign-in page, not the setup page: someone else created the first account — run ./destroy.sh and deploy again with a tighter web_allowed_cidrs. The migration fails: read its log with gcloud logging read 'resource.type="cloud_run_job" AND resource.labels.job_name="scansuite-migrate"' --limit 50 --format='value(textPayload)', fix the cause and run ./deploy.sh again. Anything else: run ./deploy.sh again first — every step is safe to repeat.
Last reviewed 2026-10-19