Applied AI-Accelerated Government Development

Land It on Google Cloud Assured Workloads

Updated

Intermediate

What you'll learn

~60 min
  • Read your Assured Workloads package's product list (the list of Google services the compliance package lets you use) before writing code, because the lists differ between packages and decide which telemetry backend and sign-in route you may use
  • Point lesson 03's sign-in code at your agency identity provider's issuer (the URL that names who signs your ID tokens), and know why identity-aware proxy header checks are not taught here
  • Connect to the database with a secret in Secret Manager (Google's secret store) through the platform seam's secret kind (the seam is the one interface core code uses to ask for identity, database credential, secrets and telemetry), and own the rotation job Google does not run for you
  • Separate what runs on your laptop (type check, unit tests, collector validation) from what needs your Google Cloud project (sign-in, secret read, trace arrival, deploy), and write the runbook for the second group
ℹRead one of three

Lessons 34, 35 and 36 land the same seam on three clouds; read the one your agency uses, then lesson 37 for your code host. On a different cloud? Azure Government (34) · AWS GovCloud (35).

One file lands the whole seam

Lessons 03, 05, 08 and 16 built the reference app against the platform seam and ran it on a laptop with the local implementation. This lesson writes the third implementation: src/platform/google/index.ts, the file that makes the same app run on Cloud Run inside an Assured Workloads folder, with the database password held in Secret Manager and nowhere else.

Before the detail — Artifact: one file, src/platform/google/index.ts, selected by PLATFORM=google, a collector config, scripts/deploy/google.sh, and a verification runbook. Acceptance test: the reference type-checks, its unit tests pass and the collector config validates on your laptop, and four checks that need your Google Cloud project (sign-in, secret read, trace arrival, deploy) each have a command and an expected result you have run or have marked NOT RUN. Status of what follows: reusable guidance. The Google choices are one landing of the seam, and none of it is a federal requirement.

What the file lands, and where each piece plugs in:

Seam memberWhat the Google file suppliesCore code that uses it
identityYour identity provider’s issuer, client id and secret name, read from settingssrc/lib/auth/oidc.ts (lesson 03)
db.authA secret credential from Secret Manager, delivery runtimesrc/lib/db/connection.ts and withPool (lesson 08)
secrets.getThe latest version of a named secretThe client secret for sign-in (lesson 03)
telemetry.startOTLP to a collector, which exports to Cloud TracestartTelemetry (lesson 16), reached through registerTelemetry
HostCloud Run, an image in Artifact Registry, a service account, PLATFORM=googleThe deploy steps (lesson 18)

The model adapter for Vertex AI is not in this file. It sits behind its own interface in lesson 26, the model call behind your API.

⚠Typechecked, not run against Google

The Google adapter type-checks against the seam and the collector config validates, but no part of it has been run against Google Cloud. The reference has no local Secret Manager emulator, so even the secret read has no local test. Everything that touches Google stays NOT RUN until you run it in your project.

ℹStatus checked 2026-11-05

Availability, authorization, agency approval, region support, and price are five separate facts. This box holds the dated service facts for this lesson; the prose does not state any of them. Everything here is read from Google’s documentation, not run against a live project.

Boundary. Assured Workloads puts a folder under a compliance package and enforces it through “organization policy constraints and other features”. Endpoints do not change suffix (they stay *.googleapis.com), so a boundary violation shows up as a denied API call or region, not a different hostname. Source: https://docs.cloud.google.com/assured-workloads/docs/overview. UNVERIFIED: the regions each package allows (the locations page was not fetched).

The lists differ. Cloud Trace (cloudtrace.googleapis.com) is on the FedRAMP High supported-products list but is not in the IL4 product table; at IL4 it appears only as an unsupported Cloud Run integration. Workforce Identity Federation (iam.googleapis.com, sts.googleapis.com) is on the FedRAMP High list and is not named in the IL4 table. Sources: https://docs.cloud.google.com/assured-workloads/docs/supported-products and https://docs.cloud.google.com/assured-workloads/docs/control-packages/il4. The supported-products page is very large and only its first part was read. Identity-Aware Proxy is on both lists; its signed header x-goog-iap-jwt-assertion, and its use with workforce federation, are UNVERIFIED. UNVERIFIED: the Cloud Run unsupported-feature list for FedRAMP High, the Telemetry API (telemetry.googleapis.com) in either package, and Artifact Registry at IL4 (it is on the FedRAMP High list).

Secret Manager (secretmanager.googleapis.com) and Cloud SQL (sqladmin.googleapis.com) are on both lists with no restrictions noted.

Database. Cloud SQL for SQL Server does not support IAM database login: “IAM authentication isn’t supported for database operations.” Source: https://docs.cloud.google.com/sql/docs/sqlserver/iam-authentication. Microsoft Entra authentication exists on SQL Server 2022 or later only, and the first login needs gcloud or the Admin API: https://docs.cloud.google.com/sql/docs/sqlserver/integration-with-microsoft-entra-id. UNVERIFIED: whether it works with Azure Government Entra tenants.

Secrets and identity on Cloud Run. A secret reaches the service as an environment variable (resolved at instance start) or a mounted volume (always the latest version), and the service identity needs roles/secretmanager.secretAccessor: https://docs.cloud.google.com/run/docs/configuring/services/secrets. Google’s guidance is never to set GOOGLE_APPLICATION_CREDENTIALS on a Cloud Run service and to use a user-managed service account: https://docs.cloud.google.com/run/docs/securing/service-identity.

Recheck the cited sources and your agency’s authorization boundary before you rely on any of it.


Step one: read your package’s list

Before any code, open the product list for the package your folder uses and check four services: Secret Manager, Cloud SQL, Artifact Registry and the trace backend. The status box shows why: two packages that sound alike do not list the same products. A telemetry design that works in one package fails in the other with a denied call, and the failure looks like a permissions bug.

Plan the change with your agent

In gov-dev-reference-app, src/platform/google/index.ts already ships so npm run typecheck runs out of the box (either audit the existing implementation against the checklist below, or run git rm src/platform/google/index.ts on a practice branch to watch the agent build it from scratch). Open your agent in the project root, switch to Plan mode (Shift+Tab, /plan, or the mode picker), and paste your compliance package’s product table so the agent checks service coverage before planning src/platform/google/index.ts:

Using the package product list pasted below, check whether Secret Manager, Cloud SQL, Artifact Registry, Cloud Run, and Cloud Trace are listed, then plan src/platform/google/index.ts without editing files. Ask me anything unclear first.

What to check in the plan before you approve

  • The agent quotes the exact line from your pasted product table for each of the five services and flags any unlisted service as an explicit gap rather than inferring coverage.
  • identity reads OIDC_ISSUER, OIDC_CLIENT_ID, and OIDC_CLIENT_SECRET_NAME from settings, and secrets.get fetches versions/latest from Secret Manager using the Cloud Run service account.
  • db.auth uses kind: 'secret' with delivery: 'runtime', reading { user, password, rotatedAt } from DB_SECRET_NAME and requiring ROTATION_OWNER (because you own the rotation job).
  • telemetry.start sends OTLP to http://localhost:4318, leaving the trace backend exporter in deploy/google/otel-collector.yaml where it can be swapped if your package does not list Cloud Trace.

If the first plan assumes Cloud Trace is present in every compliance package or hardcodes GOOGLE_APPLICATION_CREDENTIALS, correct it before approving:

Do not set GOOGLE_APPLICATION_CREDENTIALS on Cloud Run, and add a comment on the collector config noting that the googlecloud exporter depends on the package list.

The answer decides one line of the collector config later in this lesson. Keep it in the repository next to the config.


Sign-in: your identity provider, your OIDC flow

Lesson 03’s oidc.ts is vendor-neutral: it takes an identity from the seam and runs authorization code with PKCE (a one-time proof that the party finishing sign-in started it), state and nonce. Google does not issue your workforce tokens here. The app runs that flow against the identity provider your agency already uses, so the reference implementation in src/platform/google/index.ts from gov-dev-reference-app only reads where it lives:

// src/platform/google/index.ts (excerpt)
export const googlePlatform: Platform = {
name: 'google',
identity: {
issuer: need('OIDC_ISSUER'),
clientId: need('OIDC_CLIENT_ID'),
clientSecretName: need('OIDC_CLIENT_SECRET_NAME'),
scopes: ['openid', 'profile'],
rolesFrom: (claims) => (Array.isArray(claims.roles) ? claims.roles.filter((r): r is string => typeof r === 'string') : []),
},

Three things to read in it. The issuer is whatever your provider publishes for discovery, and the library checks it on every token. clientSecretName is a name, never a value: oidc.ts receives the secret from platform.secrets.get, which reads Secret Manager. rolesFrom returns raw role names from a roles claim; if your provider names the claim differently, this is the one line to change, and lesson 05 maps the names to the closed role set.

Two alternatives exist, and neither is the default. Workforce Identity Federation (Google’s service that accepts tokens from an outside identity provider, so Google holds no user accounts) is an option only where your package lists it, and the status box shows it is not named in the IL4 table. Verifying a header that Identity-Aware Proxy (a Google service that signs in users before traffic reaches your app) adds is not taught here, because its header format and its use with federation are UNVERIFIED in this module’s sources. A pattern the sources do not support is not one to hand to an agent.


A database secret you rotate yourself

Lesson 08 split the credential into two kinds: token and secret. Cloud SQL for SQL Server has no IAM database login, so Google uses the secret kind: a user and password held in Secret Manager.

REFERENCE CODE src/platform/google/index.ts (excerpt): Secret Manager client and runtime database secret open reference hide reference Reference implementation from gov-dev-reference-app; open to inspect or compare with what your agent builds.
// src/platform/google/index.ts (excerpt)
import { SecretManagerServiceClient } from '@google-cloud/secret-manager';
// ...
const project = need('GOOGLE_CLOUD_PROJECT');
const sm = new SecretManagerServiceClient(); // the Cloud Run service account; needs roles/secretmanager.secretAccessor
async function latest(name: string): Promise<string> {
const [v] = await sm.accessSecretVersion({ name: `projects/${project}/secrets/${name}/versions/latest` });
const data = v.payload?.data;
if (!data) throw new Error(`secret ${name} has no value`);
return typeof data === 'string' ? data : Buffer.from(data).toString('utf8');
}
// ...
db: {
// Through the Cloud SQL private IP; the instance's server certificate is checked (encrypt: true).
target: { server: need('CLOUD_SQL_HOST'), database: need('CLOUD_SQL_DATABASE') },
auth: {
kind: 'secret',
get: async () => JSON.parse(await latest(need('DB_SECRET_NAME'))) as SecretCredential, // { user, password, rotatedAt }
rotationOwner: need('ROTATION_OWNER'),
maxAgeDays: Number(process.env.ROTATION_MAX_AGE_DAYS ?? 30),
delivery: 'runtime', // read through the API at connect time; an env-var secret would be 'startup'
},
},

Four design points live in those lines.

Google does not rotate it. The file’s own header says it: Google runs no managed rotation for this secret, so your rotation job does. The job (a scheduler such as Cloud Scheduler calling a job you own) sets the new password on the database login first, then adds a new secret version whose JSON value carries rotatedAt. rotationOwner is a named person or team mailbox who answers when that job fails, and maxAgeDays is how old the secret may get before lesson 08’s checkRotation() reports it overdue.

Delivery is runtime. The code reads versions/latest through the API at connect time, so a rotation reaches the app on its next connection, and lesson 08’s one-refresh-on-login-failure path recovers a connection opened with the old password. Cloud Run offers two other routes, and they behave differently: a secret passed as an environment variable is resolved when an instance starts, so it is startup and a rotation reaches the app only through a redeploy; a mounted volume always shows the latest version. If you choose the environment variable, set delivery: 'startup' and put the redeploy in the runbook.

The identity needs one role. The Cloud Run service account must hold roles/secretmanager.secretAccessor on the secrets it reads. A missing grant surfaces as a failed read with the secret’s name in the error, and the code turns a version with no payload into an error as well. Use a user-managed service account rather than the default one, and never set GOOGLE_APPLICATION_CREDENTIALS on the service.

The same call serves sign-in. secrets: { get: latest } is the same function, so the sign-in client secret is read from the same store with the same account.

The Entra route for SQL Server 2022 and later removes the stored password but adds setup, and its use with Azure Government tenants is UNVERIFIED, so this lesson does not take it.

Cloud SQL restricts what the database can do: the sysadmin role and CLR assemblies are unavailable, the collation cannot be changed after the instance is created, and the time zone can. Lesson 24’s schema contract is where those matter for a legacy database, so check them there before you choose the instance.


Telemetry: OTLP to a collector

The reference telemetry.start implementation in src/platform/google/index.ts from gov-dev-reference-app does not talk to Google directly; it points the standard OTLP exporter at a collector and starts lesson 16’s shared code:

// src/platform/google/index.ts (excerpt)
telemetry: {
// OTLP to a collector; its config exports to Cloud Trace (check the IL4 list first: lesson 36).
start: async (serviceName) => {
process.env.OTEL_EXPORTER_OTLP_ENDPOINT ??= 'http://localhost:4318';
const { startTelemetry } = await import('../../lib/telemetry/start.ts');
startTelemetry(serviceName);
},
},

The collector config is where the backend is chosen, so it is the one place your step-one answer lands:

REFERENCE CONFIG deploy/google/otel-collector.yaml: OpenTelemetry collector config for Cloud Run open reference hide reference Reference implementation from gov-dev-reference-app; open to inspect or compare with what your agent builds.
# deploy/google/otel-collector.yaml: the collector for Cloud Run (lesson 36).
# The app is unchanged: it sends OTLP to localhost:4318. Traces go to Cloud Trace; check
# that Cloud Trace is in your Assured Workloads package first (it is not on the IL4 list).
receivers:
otlp:
protocols:
http:
endpoint: 0.0.0.0:4318
processors:
batch: {}
exporters:
googlecloud:
project: ${env:GOOGLE_CLOUD_PROJECT}
service:
pipelines:
traces:
receivers: [otlp]
processors: [batch]
exporters: [googlecloud]

If Cloud Trace is not in your package, the googlecloud exporter is the one thing that changes: replace it, in both the exporters: block and the pipeline’s exporters: list, with an exporter for the backend your package allows. The app, the seam and the receivers stay as they are. The sources here do not name a replacement backend, so this lesson does not either.

The config is real: npm run validate:collectors runs the collector’s own validate command on it, and a planted bad exporter name makes that command fail. Validation proves the file is well formed, not that spans arrive; that is a runbook check.


The host: Cloud Run and Artifact Registry

The app runs as one container image. Artifact Registry (Google’s private image store) holds it, and Cloud Run (Google’s managed host for a container) runs it as a user-managed service account. Lesson 18 has the image and deploy steps; the Google-specific settings are these:

SettingValue
PLATFORMgoogle (any other value fails at startup; mainframe fails with PLATFORM must be one of: local, azure, aws, google)
GOOGLE_CLOUD_PROJECTThe project id
OIDC_ISSUER, OIDC_CLIENT_ID, OIDC_CLIENT_SECRET_NAMEYour identity provider’s issuer, the app’s client id, and the Secret Manager name holding its client secret
CLOUD_SQL_HOST, CLOUD_SQL_DATABASEThe private IP and database name from the console, never from an AI answer
DB_SECRET_NAME, ROTATION_OWNERThe database secret’s name, and the named owner of its rotation
ROTATION_MAX_AGE_DAYSOptional; the reference defaults to 30

GOOGLE_CLOUD_PROJECT, OIDC_ISSUER, OIDC_CLIENT_ID, OIDC_CLIENT_SECRET_NAME, CLOUD_SQL_HOST, CLOUD_SQL_DATABASE and ROTATION_OWNER are read with need(...) while the file loads, so a missing one stops the process at startup and the error names it. DB_SECRET_NAME is read inside the credential’s get() callback, so a missing value fails on first database use; add it to your startup check. Artifact Registry is on the FedRAMP High list and its IL4 status is UNVERIFIED in this module’s sources, so confirm it in step one before you choose where the image lives.

Lesson 19’s deploy stage calls scripts/deploy/<PLATFORM>.sh with one argument: the digest-qualified image reference, registry/repo@sha256:.... For this platform that file deploys the digest to the Cloud Run service and refuses to report success until the health URL from lesson 18 answers:

REFERENCE CODE scripts/deploy/google.sh: deploy Cloud Run revision by image digest and poll health check open reference hide reference Reference implementation from gov-dev-reference-app; open to inspect or compare with what your agent builds.
#!/usr/bin/env bash
# scripts/deploy/google.sh <region-docker.pkg.dev/project/repo/image@sha256:...>
set -euo pipefail
IMAGE="${1:?usage: google.sh <registry/repo/image@sha256:digest>}"
: "${SERVICE:?}" "${REGION:?}"
TIMEOUT="${HEALTH_TIMEOUT_SECONDS:-300}"
gcloud run deploy "$SERVICE" --image "$IMAGE" --region "$REGION"
URL="$(gcloud run services describe "$SERVICE" --region "$REGION" --format='value(status.url)')/api/health"
deadline=$((SECONDS + TIMEOUT))
until curl -fsS -o /dev/null "$URL"; do
if (( SECONDS >= deadline )); then
echo "deploy: $URL did not return 200 within ${TIMEOUT}s" >&2
exit 1
fi
sleep 5
done
echo "deploy: $IMAGE is serving at $URL"

The script never types a hostname: the image reference carries the registry, and the service URL comes from Cloud Run. The health route does not touch the database (lesson 18), so a slow database cannot fail the deploy, and the timeout turns a container that never starts into a non-zero exit that stops the pipeline. It is not in the reference and has not been run; see the check in “Prove it”. If your health route sits behind sign-in or a private ingress setting, the curl needs the matching credential, and this script does not supply one.

GKE is the exception, not the starting point: this module is PaaS first, and an orchestrator earns its place only when no managed container host can run the workload.


Plan, implement, check

The file already exists in the reference. In your own repository you would have your AI CLI write it, and the order matters: read-only planning first, then implementation, then the type check. Planning spellings per tool are in lesson 02’s four-tool table.

SESSION Land the seam on Google Assured Workloads
  1. Typed in the terminal: claude
  2. Mode:Plan mode
  3. You type in the session: Read src/platform/types.ts and src/platform/local/index.ts. Plan src/platform/google/index.ts: identity, db auth, secrets, telemetry. The database is Cloud SQL for SQL Server. Do not edit.
  4. The tool replies: Plan (read-only, nothing edited): 1. identity: issuer, client id and client-secret name come from OIDC_ISSUER, OIDC_CLIENT_ID, OIDC_CLIENT_SECRET_NAME; rolesFrom keeps strings from the roles claim. 2. db: Cloud SQL for SQL Server has no IAM database login, so auth is kind 'secret'. get() reads the latest version of DB_SECRET_NAME and parses { user, password, rotatedAt }. 3. delivery 'runtime': the code calls the Secret Manager API at connect time, so a rotation reaches the app without a redeploy. An env-var secret would be 'startup'. 4. rotation: Google runs none for this secret, so rotationOwner and maxAgeDays are required settings and the rotation job is a separate deliverable. 5. telemetry: set OTEL_EXPORTER_OTLP_ENDPOINT to a collector and call the shared startTelemetry. The exporter choice lives in the collector config. Open question I cannot answer from the repository: whether Cloud Trace is on your package's product list. I will leave a comment pointing at lesson 36 rather than assume it.
  5. Mode:Plan approved: plan mode off
  6. You type in the session: Approved. Implement it. Fail with a message that names the setting if any required setting is missing.
  7. The tool replies: Created src/platform/google/index.ts. - A small need(name) helper throws '<NAME> is not set' for each required setting, so a missing OIDC_ISSUER stops the process at startup, while DB_SECRET_NAME is read inside the credential's get() callback and fails on first database use, so check it at startup too. - secrets.get and the database credential share one latest(name) function that reads versions/latest. - The platform is registered in src/platform/index.ts under 'google' and loaded lazily, so PLATFORM=local never reads these settings.
  8. You type in the session: Run the type check and the unit tests.
  9. The tool replies: $ cd gov-dev-reference-app && npx tsc --noEmit $ echo $? 0 $ npx vitest run tests/unit/connection.test.ts 12 tests passed The file satisfies the Platform interface: db.auth is the 'secret' kind with delivery 'runtime', secrets.get returns Promise<string>, telemetry.start returns Promise<void>. This proves names and types. It does not prove a secret read, a login or a trace; the reference has no local Secret Manager emulator, so those need your project.
  10. You type in the session: In staging every database login fails and the log says the secret read was denied. Diagnose without changing code.
  11. The tool replies: The failure is on the secret read, before the database is reached. On your laptop the client used your own credentials; in staging it uses the Cloud Run service account, which has no access to the secret yet. Same code, different principal. Check, in order: 1. The service runs as the user-managed account you meant: gcloud run services describe <service> --region <region>. 2. That account holds roles/secretmanager.secretAccessor on the database secret and the client-secret entry. 3. The secret name in DB_SECRET_NAME matches exactly and has an enabled version. Grant the role, redeploy nothing: the read happens at connect time, so the next connection succeeds. No code change.

Illustrative session in Claude Code; the exact wording varies.


Prove it

Two groups of checks. Run the first on your laptop now; the second needs your Google Cloud project, so each line carries a status you fill in.

Runs locally. From the repository root of the reference:

Terminal window
cd gov-dev-reference-app
npx tsc --noEmit
npx vitest run tests/unit/connection.test.ts
npm run validate:collectors

npx tsc --noEmit type-checks the Google file against the seam’s interface. npx vitest run tests/unit/connection.test.ts runs the connection provider’s unit tests (12 passed on the reference), which cover both kinds of credential. npm run validate:collectors validates the collector config. None of the three starts a Google client or contacts Google.

Needs your project (NOT RUN here). None of these has been run against a live Google Cloud project for this lesson, and the reference has no local Secret Manager emulator to stand in. The runbook, with the expected result:

CheckCommand or actionExpectedStatus
Package listRead your package’s product list for Secret Manager, Cloud SQL, Artifact Registry, Cloud Run and Cloud TraceEach service is listed, or you have chosen a different collector exporterNOT RUN
Sign-inSet PLATFORM=google and the settings above, open /auth/login, sign in as a user with a roleThe session holds sub, your provider’s issuer, a name, and the role names you assignedNOT RUN
Secret read and loginIn the app, run one read through withPool; in the console, check the secret has an enabled versionThe read returns rows; the secret’s latest version carries rotatedAtNOT RUN
RotationRun your rotation job once, then make a requestThe job added a new version after changing the password; the request succeeds with no redeployNOT RUN
Trace arrivalMake three requests with the collector running, then open the trace backend your package allowsSpans from your app appear within a few minutes, under the name you expectNOT RUN
Deploy scriptExport SERVICE and REGION, run scripts/deploy/google.sh "$REGISTRY/platform-app@sha256:<digest>" with a digest already in the registry; then rerun it against a service that cannot start with HEALTH_TIMEOUT_SECONDS=30The first run prints the serving line and exits 0; the second exits non-zero after the timeoutNOT RUN

The negative cases belong in the runbook too. Remove the secretAccessor grant and expect a failed read with the secret’s name in the error. Disable every version of the secret and expect the same. Set PLATFORM=mainframe and expect the startup error from the table above; the reference’s environment tests already prove that last one against the local stack.


KNOWLEDGE CHECK

A new teammate asks why the Google adapter stores the database password in Secret Manager when the Azure adapter stores none. What is the accurate answer?

KNOWLEDGE CHECK

The collector validates and the app starts, but no traces appear in your Assured Workloads project. What do you check first?


Practice status

PracticeStatusAlso called
Read the compliance package’s product list before choosing servicescommon baselineservice allowlist review, boundary scoping
Database credential in a secret store with a named rotation owner and a maximum agecommon baselinesecret rotation, credential lifecycle
Secret read through the API at connect time, so rotation needs no redeploystrong optionalruntime secret fetch, latest-version read
OTLP to a collector, with the backend chosen in the collector configcommon baselinecollector sidecar, vendor-neutral telemetry
Sign-in run by the app against the agency identity provider of recordstrong optionalapp-level OIDC, bring-your-own identity
One implementation file selected by a startup variable that fails on unknown valuesreference-shopplatform adapter, fail-closed configuration
Managed container host first, Kubernetes by exceptionstrong optionalPaaS first

Scale: required | common baseline | strong optional | reference-shop (seen only at organizations that publish their own practice) | emerging

Key takeaway

  • Google Assured Workloads is one implementation of the seam. Core code did not change; one file supplies identity settings, a secret credential, a Secret Manager reader and a telemetry start, and one YAML file picks the trace backend.
  • The first step is reading your package’s product list, because the lists differ and the failure of a missing service looks like a permissions bug.
  • The type check, unit tests and collector validation prove the files’ shape. Sign-in, the secret read, rotation, trace arrival and the deploy script need your project and stay NOT RUN until you run them.
LEADERSHIP DECISION
Which compliance package the folder uses, and who owns the database secret's rotation job, since Google runs none for it.
PRACTITIONER ACTION
Read the package's product list, grant the service account secretAccessor, then run the runbook checks and record each result.
SUCCESS MEASURE
Audit finding avoided: no database password outside Secret Manager, and a rotation that completes with no redeploy and a recorded owner.

Legend: LEADERSHIP DECISION = what a leader decides · PRACTITIONER ACTION = what the engineer does next · SUCCESS MEASURE = how you know, in calendar time, assessor-hours or cost, contract or revenue risk, or audit finding avoided

Search lessons