Deployment

Install on Google Cloud

Deploy ScanSuite Teams into your own Google Cloud project on Cloud Run with Terraform, with installation examples.

View as Markdown

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.

Scope: static analysis

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.

PartHow it runs
Web UI and APIA Cloud Run service behind an external HTTPS load balancer with Cloud Armor, which admits only your address ranges.
Background workersCloud Run worker pools: housekeeping and recovery of interrupted scans, the scheduler, and the sandbox for AI proof-of-concept checks.
ScansOne Cloud Run job execution per scan, 4 vCPU and 16 GiB, gone when the scan ends.
Database migrationA Cloud Run job that deploy.sh runs before the services start.
DatabaseCloud SQL for PostgreSQL 16, private IP, nightly backups (14 kept) and point-in-time recovery over 7 days.
Task queueMemorystore for Redis, private IP, TLS.
Scan artefactsA Cloud Storage bucket, with earlier versions kept for 30 days.
Outbound trafficCloud NAT on fixed addresses, for allowlists at your git server and AI endpoint.
MonitoringAn uptime check and alerts on errors, failed uploads, database and Redis load.

1. Before you start

PrerequisiteCheckExpected
A Google Cloud project with billinggcloud 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 CLIgcloud --versionGoogle Cloud SDK and a version
Terraform 1.6 or newerterraform versionTerraform 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 -1a 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 UIcurl -4 -s https://ifconfig.mean 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.

Let an agent prepare the deployment
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:

PlaceholderWhere 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:

bash
git clone https://github.com/cepxeo/scansuite.git
cp /path/to/<name>_<LICENCE_CODE>.lic scansuite/key/
cd scansuite/gcp
ls ../key/*.lic

Expected: 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:

bash
gcloud auth login
gcloud auth application-default login
gcloud config set project <PROJECT_ID>

Check:

bash
gcloud config get-value account
gcloud auth application-default print-access-token >/dev/null && echo ADC ok

Expected: 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.

Shell
cp terraform.tfvars.example terraform.tfvars
SettingWhat to putDefault
project_idYour project ID.required
regionThe region. With another region also set zones and primary_zone (example D).europe-west3
image_tagYour licence code.required
dockerhub_usernameThe registry user name from your order.required
web_allowed_cidrsThe 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
timezoneThe time zone scheduled scans run in, such as Europe/Berlin. Set it: the default is Europe/Moscow.Europe/Moscow
alert_emailWhere alerts go.none

Optional preview, which changes nothing:

Shell
terraform init && terraform plan

Expected: 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:

bash
read -rsp 'Registry access token: ' TF_VAR_dockerhub_token; echo; export TF_VAR_dockerhub_token
./deploy.sh

The 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:

bash
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:

  1. 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 as europe-west1, or global), 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 the scan_egress_ips output. Click Save.
  2. AI models → Add model: Name, Connection, Model ID (the Claude model ID). Click Save.
  3. Task routing → Change on the Default row → First model → Save.
  4. 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.

bash
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:

terraform.tfvars
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     = 1

When 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:

terraform.tfvars
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 = true

After 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:

terraform.tfvars
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_range output from the corporate network to this VPC;
  • has the corporate DNS servers forward run.app to the addresses that the dns_inbound_forwarders_command output lists, so internal browsers resolve the url output.

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:

terraform.tfvars
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:

terraform.tfvars
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:

terraform.tfvars
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:

terraform.tfvars
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

SettingWhat it doesDefaultWhen to change
project_idThe project to deploy into.required—
regionThe region.europe-west3Another region; set zones and primary_zone with it.
zonesThe region's zones, which place Redis and the database standby.europe-west3-a, -b, -cWith region.
primary_zoneThe main zone.europe-west3-bWith region.
name_prefixPrefix of every resource name.scansuiteA second installation in the project (example E).
environmentLabel of every resource: dev, stage or prod; also adjusts a few sizes.proddev for a trial.
platformcloudrun, or gke for a regional GKE Standard cluster running the same images.cloudrunOnly when you need node-level control or a longer termination grace period than Cloud Run allows; see the GKE settings below.
timezoneThe time zone of the containers; scheduled scans follow it.Europe/MoscowAlways: set your own.
alert_emailWhere alert notifications go.none: alerts without a channelProduction.
deletion_protectionCloud SQL and the services refuse deletion by anything but destroy.sh.falsetrue for production.

Access

SettingWhat it doesDefaultWhen to change
web_allowed_cidrsRanges allowed through the load balancer, at most 10.empty: the whole internetAlways, before the first deploy.
domain_nameThe UI's host name, with a Google-managed certificate.none: the load balancer IP with a self-signed certificateProduction.
manage_dnsCreate a Cloud DNS zone and the A record for domain_name; you delegate the zone.falseYour DNS is in this project.
internal_onlyNo load balancer; the UI on its Cloud Run address, to internal callers only.falseNo access from the internet (example C). Cloud Run only.

Images and licence

SettingWhat it doesDefaultWhen to change
image_tagYour licence code: the tag of the three images.required unless image_web, image_worker and image_worker_poc are all setEach new release.
dockerhub_usernameThe registry user name from your order.none—
dockerhub_tokenThe registry access token. Give it as TF_VAR_dockerhub_token in the shell, never in the file.none—
image_sourceThe Docker Hub namespace the images come from.appsec4uDo not change.
image_repositoryWhere the images are read from, up to the image name.the remote repository in front of Docker HubSet by deploy.sh with LOCAL_IMAGES=1.
source_registryYour own registry to copy the images from, such as registry.corp.example/scansuite.noneNo Docker Hub access (example C).
source_image_namesThe image names in source_registry, when they differ.teams-web, teams-worker, teams-worker-pocYour registry names them otherwise.
image_web, image_worker, image_worker_pocFull image references, used as given.derivedMirrored images (example F).
image_digestsWritten by deploy.sh to images.auto.tfvars.json.—Never by hand.
key_dirThe folder holding the licence file.../keyThe licence is elsewhere.
pyarmor_license_fileThe licence file name inside key_dir.the only .lic therekey_dir holds several.

Network

SettingWhat it doesDefaultWhen to change
egress_modenat: Cloud NAT on fixed addresses. none: no route to the internet; Google APIs through Private Google Access.natnone for example C (Cloud Run only).
nat_ip_countHow many fixed outbound addresses to reserve.2Keep them stable: they are what git servers and AI endpoints allow.
google_apis_vipWith egress_mode = none: private (every Google API) or restricted (VPC Service Controls).privaterestricted inside a perimeter.
subnet_cidrThe subnet.10.10.0.0/20When the VPC is connected to a corporate network.
psa_cidrThe range for Cloud SQL and Memorystore, at least a /24.10.30.0.0/16As subnet_cidr.
dns_forwarding_zonesInternal domains forwarded to your DNS servers, such as { "corp.example." = ["10.0.0.53"] }.noneScans must resolve internal git hosts.
dns_inbound_forwardingInbound DNS forwarders your DNS servers forward run.app to.falseExample C.

Database, Redis and storage

SettingWhat it doesDefaultWhen to change
cloudsql_nameThe Cloud SQL instance name.<name_prefix>-pgRedeploying within a week of a teardown (example G).
cloudsql_tierThe Cloud SQL machine tier.db-custom-2-8192 (2 vCPU, 8 GB)Smaller for a trial, larger for many teams.
cloudsql_disk_gbThe database disk in GB; it grows automatically.100Smaller for a trial.
cloudsql_haA standby database in another zone.truefalse for a trial: about half the database cost.
redis_memory_gbMemorystore capacity in GB.41 for a trial.
redis_haA Redis replica with automatic failover.truefalse for a trial.
redis_tlsEncrypted traffic to Redis. Changing it replaces the instance and drops queued work.trueOnly when no scan is running.
artifact_retention_daysDays earlier versions of stored artefacts are kept.30Your retention policy.
artifact_bucket_force_destroyLet a teardown delete the artefact bucket with its contents.falseLeave it: destroy.sh --delete-artifacts sets it.

Cloud Run sizing

SettingWhat it doesDefaultWhen to change
scan_cpuvCPU per scan, at most 8.4Very large repositories.
scan_memoryMemory per scan, at most 32Gi. The repository clone is held in memory and counts against it.16GiVery large repositories.
scan_task_timeout_secondsThe longest a scan may run.172800 (48 hours)Rarely.
web_min_instancesWarm web instances.10 saves money; the first visit after a quiet period waits for a cold start.
web_max_instancesThe most web instances.4Many concurrent users.
admin_instancesInstances of the background worker.1Rarely.
poc_replicasSandboxes for proof-of-concept checks.21 for a trial.

Scans and AI keys

SettingWhat it doesDefaultWhen to change
enable_static_scansStatic analyses.TrueLeave it.
enable_dynamic_scansDynamic and infrastructure scans, which need a Docker daemon this deployment does not have.FalseLeave it.
llm_service_account_emailAnother service account to grant the Vertex AI and bucket roles to.noneOnly when Vertex AI must be called with another service account's key instead of the deployment's own identity.
llm_sa_key_filePath to that service account's key file, mounted for the application.noneAs above.
llm_sa_key_b64The same key, base64-encoded. Prefer llm_sa_key_file, or add the secret version yourself to keep the key out of the Terraform state.noneAs above.

GKE only (platform = "gke")

SettingWhat it doesDefaultWhen to change
master_authorized_cidrsRanges allowed to reach the cluster's control plane.the address you run Terraform fromDeploying from a pipeline.
enable_secrets_encryptionEncrypt Kubernetes secrets with a Cloud KMS key as well.falseYour policy requires it.
pods_cidr, services_cidr, master_cidrThe cluster's address ranges.10.20.0.0/14, 10.24.0.0/20, 172.16.0.0/28They overlap your network.
general_machine_typeMachines for the web UI and the scheduler.e2-standard-2Many users.
scan_engine_machine_typeMachines for the scan workers.n2-standard-4Large repositories.
worker_replicasScan workers; each runs one scan at a time.1More parallel scans.
poc_machine_typeMachines for the proof-of-concept sandbox.e2-standard-2Rarely.
scratch_disk_gbScan work space per worker, in GB.200Large repositories.
image_pull_registryThe registry the image pull secret signs in to.Docker HubImages from your own registry.

Environment variables and script options

Variable or optionUsed byWhat it does
TF_VAR_dockerhub_tokendeploy.shThe registry access token. Typed by a person, never stored in the file.
TF_VAR_project_iddeploy.shThe project, instead of project_id in terraform.tfvars.
SOURCE_REGISTRY_USERNAME, SOURCE_REGISTRY_TOKENdeploy.shThe account deploy.sh copies the images from source_registry with; signed out again afterwards.
LOCAL_IMAGES=1deploy.shPush the images from the local Docker engine instead of reading them from the registry.
MIGRATE=1deploy.shRun the database migration even when the images have not changed. It cancels running scans.
extra argumentsdeploy.sh, destroy.shPassed on to terraform.
-y, --yesdestroy.shDo not ask for the project ID.
--delete-artifactsdestroy.shAlso delete the artefact bucket with the stored scan artefacts.

Outputs

terraform output prints them at any time; terraform output -raw <name> prints one.

OutputWhat it is
urlWhere ScanSuite is served.
load_balancer_ipThe load balancer address, for the DNS record. Empty with internal_only.
scan_egress_ipsThe fixed addresses scans and AI calls leave from, for allowlists. Empty with egress_mode = none.
google_apis_rangeWith egress_mode = none: the range to route from the corporate network.
dns_inbound_forwarders_commandLists the addresses your DNS servers forward run.app to.
artifact_bucketThe bucket holding the scan artefacts.
secret_namesThe Secret Manager entries holding the generated passwords.
migrate_job_name, migrate_commandThe migration job, and the command that runs it.
imagesThe exact images the services run.
artifact_registry_urlWhere mirrored images are pushed (example F).

9. Day-to-day operation

  • Change a setting: edit terraform.tfvars and run ./deploy.sh again. While the images stay the same, running scans carry on.
  • A new release: put the new .lic in ../key/ and remove the old one, set image_tag to the new code, run git 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_cidrs and run ./deploy.sh.
  • Logs: in the console under Logging → Logs Explorer, or:
bash
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.tfstate holds 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:

ItemDefaultsTrial (example A)
Cloud SQL200-25050-70
Memorystore150-20035-45
Cloud Run services300-400200-250
Load balancer, Cloud Armor, Cloud NAT50-8050-80
Storage, secrets, registry, logs10-3010-30
Scans, 4 vCPU and 16 GiB eachabout 0.5 per scan-hourthe 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.

bash
./destroy.sh                      # asks you to type the project ID
./destroy.sh --delete-artifacts   # also delete the stored scan artefacts

It 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.

Common messages

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