Repository navigation
feat(platform): app-to-app calls with private networking and scopes - #156
Open
Alexanderamiri wants to merge 8 commits into
Open
Alexanderamiri wants to merge 8 commits into
Alexanderamiri wants to merge 8 commits into
Conversation
…es in app.yaml
Every app gets its own task security group ({team}-{app}-tasks, ALB ingress on
the app port only) and a Cloud Map name {team}-{app}.javabin.internal in a new
shared private namespace. RDS now accepts only the app's own group, closing the
cross-team database network path.
app.yaml gains calls: (caller) and provides: {scopes, consumers} (callee). The
app-network module writes the request to /javabin/apps/{team}/{app}/network and
the generator injects the peer URL, scope string and M2M credentials.
The boundary denies deleting or retagging the shared namespace.
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
Recomputes every edge from the app network requests: adds/revokes security group rules where both sides agree, keeps Cognito resource servers and client-credentials clients in the internal pool, and writes peer URLs and client credentials into the caller's SSM path. Daily reconcile audits Cloud Map names and borrowed security groups. app-secret-rollout ignores network and peers-status. Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
Terraform Plan🚧 Changes detected — Plan: 11 to add, 5 to change, 0 to destroy. Plan outputLLM ReviewRisk: 🔴 HIGH Plan creates 11 resources (app-peers-sync Lambda with IAM role, EventBridge rules, service discovery namespace) and updates 5 (developer boundary, three team guardrail policies, and a Lambda code change); nothing is destroyed, but the IAM boundary/guardrail changes add servicediscovery:Delete* and a malformed servicediscovery:*agResource wildcard, and the new Lambda role grants security-group edits.
|
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
Terraform Plan🚧 Changes detected — Plan: 11 to add, 5 to change, 0 to destroy. Plan outputLLM ReviewRisk: 🟡 MEDIUM Plan creates 11 resources (a new app-peers-sync Lambda with IAM role, EventBridge rules, service discovery namespace) and updates 5 (developer boundary, three team guardrail policies, and one Lambda code update), with 0 destroys.
|
The Cloud Map namespace creates a Route53 private hosted zone. Route53 ignores tag conditions, so DenyShared/DenyXTeam never applied to it: a team could UPSERT another app's A record and capture M2M bearer tokens sent over plain HTTP. DenyPlatInfra now denies route53:C*/D* (change, create, delete, disassociate, disable) on that zone's ARN; reads stay allowed. The guardrail copies get the same rule. Bytes come from writing DenyPlatInfra's ECS/ELB/DynamoDB ARNs with *:* region/account, as DenyBadName already does: 6,050 of 6,144. Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
…ate zone
- An app whose network request is invalid is frozen, not removed: its
managed rules, resource server and client scopes stay while every valid
side still declares the edge (the valid side can still withdraw). Peers
see callee-invalid / caller-invalid.
- <APP>_SCOPES is now an SSM secret peer-{t}-{a}-scopes holding the scopes
the caller's client really holds ("none" if none), so a callee granting
fewer scopes no longer makes the caller's token request fail outright;
a change restarts the caller via app-secret-rollout.
- Daily reconcile compares the private zone's records with Cloud Map
instances.
- app-network: token_url uses an explicit internal_pool_domain variable.
- ecs-service: validate at most one service registry.
- Docs: network-only calls are not caller authentication, name squatting,
first-deploy dependency on app-peers-sync, frozen state.
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
Terraform Plan🚧 Changes detected — Plan: 11 to add, 5 to change, 0 to destroy. Plan output
LLM ReviewRisk: 🔴 HIGH Plan creates 11 resources (Lambda app-peers-sync with EventBridge rules, a private DNS namespace, and IAM role/policy), updates 5 IAM policies (developer boundary and team guardrails) plus one Lambda code update, and destroys nothing; the IAM policy changes are the main concern.
|
Denying by the zone's ARN made the whole developer boundary and every team guardrail "known after apply" (the zone ID only exists after apply), so the plan review could not see the boundary at all. Use what is known at plan time instead: - DenyAppDNS: route53:ChangeResourceRecordSets where any record name matches *javabin.internal (Route53 ignores tags; record names are the supported condition key). Verified with the IAM policy simulator: denied for <app>.javabin.internal and the apex, allowed for testteam.java.no. - DenyNetwork: route53:DeleteHostedZone everywhere (teams only write records, zones are platform-managed). Disassociating the zone's only VPC is impossible for a private zone. - Bytes: ec2:*InternetGateway / ec2:*NatGateway replace six explicit actions (also denies egress-only IGWs). 6,067 of 6,144. - app-peers-sync may list records in any zone (read-only), so its policy is readable in the plan too. Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
Terraform Plan🚧 Changes detected — Plan: 11 to add, 5 to change, 0 to destroy. Plan outputLLM ReviewRisk: 🔴 HIGH Plan creates 11 resources (app-peers-sync Lambda, EventBridge rules, IAM role/policy, private DNS namespace javabin.internal) and updates 5 IAM policies and one Lambda, with 0 destroys; the developer boundary and team guardrail policy changes remove existing Deny protections and add broad new permissions, which is a security concern requiring review before apply.
|
… append Inserting it mid-list shifted every later statement, and the plan showed DenyPlatInfra being renamed to DenyAppDNS. Same policy, same size. Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
Terraform Plan🚧 Changes detected — Plan: 11 to add, 5 to change, 0 to destroy. Plan outputLLM ReviewRisk: 🔴 HIGH Plan creates 11 resources (app-peers-sync Lambda, EventBridge rules, IAM role/policies, Cloud Map namespace) and updates 5 (developer boundary, three team guardrail policies, one Lambda code change), with no destroys; however, the IAM policy edits weaken guardrails and the new Lambda role has security-group editing rights.
|
Member
Author
|
About the HIGH risk rating on the latest plan (753ca02) The review reads the boundary edits as loosening. They tighten the boundary:
Checked with the IAM policy simulator on the rendered statements:
The size is 6,067 of 6,144 bytes. 🤖 Generated with Claude Code |
Alexanderamiri
added a commit
that referenced
this pull request
Oct 24, 2026
…th doctor (#167) ## Why Part of #157. Internal-pool sign-in goes through the `GoogleSAML` app, which always answers for the browser's active Google account. A personal Gmail gets a dead-end `403 app_not_configured_for_user` page with no account chooser. The classic hosted UI drops `prompt=`, so Cognito can't ask SAML for one either. The fix is a Google OIDC IdP, with an Internal-consent OAuth client and `prompt=select_account`. The investigation also found that teams can't see why sign-in fails, and can't recover: - invalid requests and console drift are visible only in CloudWatch; - a replaced client leaves running tasks on a deleted client ID; - callback typos show up only as `redirect_mismatch` in the browser; - an `auth.groups` typo denies everyone. **Merge #166 (internal-pool lockdown) first.** This branch is rebased on it and reuses its per-pool IdP list, so until #166 merges this PR's diff and plan also contain #166's two commits. After #166 lands, GitHub shows only the last commit. This PR is safe to merge before the Google credentials exist. Every Google behaviour change is gated, and with #166 the internal default is `["GoogleSAML"]` (what cupcake's client has live today). ## What **identity (Terraform)** - `aws_cognito_identity_provider.internal_google` is now gated on SSM `/javabin/platform/google-oauth/internal/{client-id,client-secret}`, read with `aws_ssm_parameters_by_path`, instead of a tfvar. Its count stays 0 until both exist. - `authorize_scopes = "openid email profile"`, and mapping `email`, `email_verified`, `name`, `username=sub`. - `authorize_url = …/v2/auth?hd=java.no&prompt=select_account`. You can turn this off with `google_authorize_url_params = false` for the managed-login fallback. - Uses #166's per-pool lists `internal_identity_providers` (default `["GoogleSAML"]`, COGNITO refused) and `external_identity_providers` (`["COGNITO"]`), env `INTERNAL_IDENTITY_PROVIDERS`/`EXTERNAL_IDENTITY_PROVIDERS`. The same internal list is auth-claims' `FEDERATED_IDENTITY_PROVIDERS`, so the cutover changes clients and the trust list together. - Adding the Google IdP changes no client until this list names it. - An output precondition fails the plan if `Google` is listed without the SSM credentials or with an empty `google_workspace_domain` (auth-claims' `REQUIRED_EMAIL_DOMAIN`). - auth-claims: IdPs in `EMAIL_VERIFIED_IDENTITY_PROVIDERS` (default `Google`) are not trusted on the IdP name alone; their users also need `email_verified=true`, mapped from Google's claim. - The external pool keeps its `google_client_id` tfvar path. It is unchanged and still empty. **app-auth-sync** - `cognito-client-id`, `-secret` and the new `-identity-provider` are written **only when the value changes**. - The secret is not decrypted. It changes only with a new client ID. - The client ID is written last, so restarted tasks find the matching secret. - Writes `/javabin/apps/{team}/{app}/auth-status` (String JSON, always valid and under 4096 bytes: list fields are dropped, never sliced). Fields: `status` (synced/invalid/error), `error`, `client_id`, `client_id_changed_at` (carried over between syncs), `identity_providers`, `pool_domain`, URLs, `drift_corrected` (fields a reconcile reverted; also logged as `WARN drift`), `unknown_groups`/`empty_groups` (checked against `group#` items in the memberships table), `request_version`, `synced_at`. - A declared IdP missing from the pool is #166's `PoolMisconfigured` skip: status `error` in auth-status, the client is left as it is. - Reconcile no longer stops at a failing app, and returns normally instead of raising (an async invoke would retry the whole run twice). The failure is logged as `Sync failed for …`, which #166's `javabin-app-auth-sync-skipped` metric filter now also counts. - Callback/logout URLs with a `#fragment` are rejected by the Lambda too. - IAM: `dynamodb:GetItem` on the memberships table, plus write access to `*/cognito-client-identity-provider` and `*/auth-status`. **Team access to auth-status** - Teams read it through their existing `/javabin/apps/{team}/*` read grant. - Writes are denied for `auth-status` in the team-provisioner permission-set policy (CI-applied), and in `terraform/org/identity-center.tf` (human-applied; see user actions). **app-secret-rollout** - `cognito-client-id` and `cognito-client-identity-provider` are no longer ignored. A replaced client (case 9/15) or an IdP cutover now restarts the service. - `auth-status` and `cognito-client-secret` are ignored: auth-status is rewritten on every sync, and a new secret always comes with a new ID written right after it, so restarting on the secret would deploy once with the old ID. - There is no restart loop, because unchanged values are never rewritten. **generate-modules.py** - Callback/logout URLs must: - use `https`, except `http://localhost` / `127.0.0.1`; - have no `#fragment`; - have a host equal to `routing.host` or listed in the new optional `auth.extra_hosts`. - `client: none` combined with `callback_urls`, `logout_urls`, `scopes` or `extra_hosts` is rejected; these were silently ignored before. - `COGNITO_IDENTITY_PROVIDER` is injected (an ECS secret from `module.auth.identity_provider_arn`) and can be aliased through `auth.env`. - Auth resolution is factored into `resolve_auth()`, which the doctor reuses. - Both live apps (frosting, cupcake-backend) still generate. Tests use their verbatim app.yaml. **cognito-app-client module** - New outputs `identity_provider_arn` and `auth_status_parameter_name`. **scripts/auth-doctor.py** - Uses team credentials only: app.yaml, the app's own SSM parameters, and unauthenticated HTTP. - Checks: - the request matches app.yaml; - auth-status is synced for the current request version, and its client ID matches `cognito-client-id`; - drift and unknown/empty groups are reported; - `/oauth2/authorize` for every callback URL redirects to the IdP, not `/error?error=redirect_mismatch` (it warns if Google isn't given `prompt=select_account`); - `/logout` for every logout URL redirects back (a mismatch lands on the hosted UI `/login`, verified live); - best effort, WARN only: the service's PRIMARY-deployment tasks started after `client_id_changed_at` (skipped until auth-status records one; `cognito-client-id`'s LastModifiedDate is useless because the old code rewrote it on every reconcile). - A non-JSON auth-status is a FAIL, not a traceback. When auth-status is missing altogether, the doctor waits at most 30 s instead of the full `--wait`. - `--json` is the hook for a future `javabin auth doctor`. javabin-cli is not changed here. - `tf-apply.yml` gets a non-blocking `Auth doctor` step (`continue-on-error`, `--wait 180`, skipped for apps without auth). **platform-ci** - After apply, `scripts/reconcile-app-auth.sh` queues an async reconcile. This writes the new `cognito-client-identity-provider` and `auth-status` parameters right away, so an app redeploy that picks up the new `COGNITO_IDENTITY_PROVIDER` secret doesn't hit `ParameterNotFound`. It is non-blocking, and the 03:30 reconcile is the backstop. **Docs** - `docs/cognito-google-setup.md` is rewritten: - exact GCP steps (Internal consent screen, a separate Web OAuth client, redirect `https://javabin-internal.auth.eu-central-1.amazoncognito.com/oauth2/idpresponse`; the old doc listed a nonexistent `auth-internal.javazone.no`); - SSM commands; - the post-apply curl probe and the managed-login fallback; - cutover and user plan. - `docs/cognito-saml-setup.md` is marked superseded. It also noted that its groups mapping never existed. - `docs/app-yaml-reference.md`: IdP list, URL rules and `extra_hosts`, the `/logout` exact-match rule, group denial (`error_description`), `COGNITO_IDENTITY_PROVIDER`, auth-status and the doctor. - `docs/lambda-functions.md`, `docs/reusable-modules.md` and `CLAUDE.md` are updated. ## How verified - `python3 -m unittest discover -s terraform/lambda-src/tests` passes (111, including #166's), and `-s scripts/tests` passes (67, including the fmt check of generated TF). New tests cover: - no-op syncs write only auth-status; - secret written before ID on replacement; - status content: invalid, error, drift vs request change, unknown/empty groups; - declared IdP list, cutover switching the IdP param without touching the client ID, a missing IdP failing cleanly; - reconcile continuing past a failing app; - rollout restarting on `cognito-client-*`; - URL validation; - doctor scenarios, including non-JSON status, the short wait for a missing status, and draining/stale tasks; - auth-status size limit (bytes, valid JSON), `client_id_changed_at` carry-over, fragments rejected; - auth-claims refusing Google users without `email_verified=true`. - `terraform fmt -recursive -check` and `terraform validate` (platform root) pass. - Live, read-only: the doctor against frosting's app.yaml. - Request check passes. auth-status doesn't exist yet, as expected before deploy. - Probes against the live `cupcake-cupcake` client: callback → GoogleSAML ✔, `/nope` → `redirect_mismatch` ✔, logout exact ✔, logout without trailing slash → hosted UI `/login` (this is why the logout check looks for "redirects back"). - Live pool state checked: 4 users, all `GoogleSAML_*` external-provider users, no native users. `/javabin/apps/*` has only cupcake's `auth` and `cognito-client-id`. ## Rollout & user actions Merging (after #166) changes nothing about Google sign-in: - The Google IdP isn't created without SSM credentials. - The internal IdP list default is #166's `["GoogleSAML"]`, which equals cupcake's live client (`SupportedIdentityProviders=[GoogleSAML]`). The post-apply reconcile therefore does not put COGNITO back; on main without #166, the old 03:30 reconcile would. - On the first reconcile, cupcake gets `cognito-client-identity-provider = GoogleSAML` (Create, so no restart) and an `auth-status`. Expected plan: the `aws_ssm_parameters_by_path` read, and in-place updates to the app-auth-sync role policy, function env/code, app-secret-rollout code and team-provisioner code. No destroys. User actions: 1. **Human apply `terraform/org`** (identity-center.tf). It adds `auth-status` to the `javabin-developer` permission set's platform-managed deny. Per-team permission sets get it from team-provisioner on its next run. 2. **GCP (when ready):** create the Internal-consent OAuth client and store it in SSM, following `docs/cognito-google-setup.md` §1–2. Then re-run platform CI on main. The plan creates the `Google` IdP, and clients are untouched. 3. **Verify:** run the §3 curl probe (or the doctor after cutover) to confirm Cognito keeps `prompt=select_account`. If it doesn't, use the documented managed-login fallback. 4. **Cutover (separate PR):** `internal_identity_providers = ["Google"]`. #166 (server-side domain check, no self sign-up) is a hard prerequisite, which stacking on it guarantees. - Users get a new `sub`. Platform memberships and groups are keyed by email, so nothing to migrate there; cupcake should check for `sub`-keyed data. - Delete the 4 `GoogleSAML_*` users and the `GoogleSAML` IdP a week later, and turn off the Google Admin SAML app. ## Interactions - **#166 (lockdown):** this PR is stacked on it and reuses its variable, output, env names and `identity_providers(pool, upid)`. It adds to #166's code: the Google precondition on `internal_identity_providers`, `EMAIL_VERIFIED_IDENTITY_PROVIDERS` in auth-claims, and a second pattern on the skipped-sync metric filter. If #166 is squash-merged, I rebase this branch onto main with `--onto`. - **#158 / `feat/alb-login`:** both change `app_auth_sync` (`client_settings`, `sync`, `_put_param`, `reconcile`) and `generate-modules.py` auth handling. Expect textual conflicts; the slot threading composes with this. - Login slots should write `auth-status` and `cognito-client-identity-provider` next to the slot request (`…/login-N/`). The rollout regex already ignores slot params. - service-routing's hardcoded `internal_identity_provider = "GoogleSAML"` should go away: with a single IdP per client it is unnecessary, and after cutover it points at a deleted IdP. Otherwise read the slot's `cognito-client-identity-provider`. - **#156:** also edits `app_secret_rollout/handler.py`, a small conflict. ## Follow-ups - The developer boundary (team CI roles, gate-vended apply credentials) doesn't deny writing `auth-status`/`cognito-client-*`. It is at 5,946/6,144 bytes and #156 adds to it, so I left it alone; the limitation is now documented in `docs/lambda-functions.md` and `docs/app-yaml-reference.md`. The impact stays inside the team's own app: a forged status, or one extra restart before the next sync puts a credential back. A Deny in the team CI role policies is the follow-up if we want it enforced. - Drop `ALLOW_USER_SRP_AUTH` from internal clients. With #166 there is no COGNITO and no self sign-up, so it is unused there, but changing client auth flows is #166-adjacent scope. - `javabin auth doctor` in javabin-cli, wrapping `scripts/auth-doctor.py --json`. - Doctor check that the task definition contains every `auth.env` alias; canary-client probe in platform CI after identity applies. - `auth.accept_clients` for `client: none` backends (case 13). 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-authored-by: Claude Opus 5.5 (1M context) <[email protected]>
This branch has not been deployed
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Why
Apps can only reach each other over the internet today (cupcake-backend calls sleepingpill at
https://sleepingpill.javazone.nowith basic auth), and every app task sharesjavabin-ecs-tasks-sg, so any team's task can reach any team's database port. This PR lets an app declare private app-to-app calls inapp.yaml, optionally with OAuth scopes, and gives every app its own security group.Design and options (Service Connect, internal ALB, VPC Lattice and Cognito M2M):
explore/app-to-app-design.md(outside the repo).What
app.yaml
An edge exists only when both sides declare it. Granted scopes are what the caller requested, intersected with what the callee allows that caller.
Per-app network (new module
app-network, emitted for every app){team}-{app}-tasks. The ALB can reach only the app's port.{team}-{app}.javabin.internalin a new shared private namespace (networking/)./javabin/apps/{team}/{app}/network.ecs-servicegets an optionalservice_registry_arns.service-rdsnow allows ingress only from the app's own group, which closes the cross-team database known issue.Lambda
javabin-app-peers-sync*/network, plus a daily reconcile at 03:45 UTC. Every run recomputes everything.managed-by=javabin-app-peers-sync, and rules a team created itself are never touched.{team}-{app}-tasks, tagteam={team}). Otherwise a team could make the Lambda open another team's group.{t}-{a}per callee, and one client-credentials clientm2m.{t}-{a}per caller, with 60-minute tokens.peer-{t}-{a}-url,peer-{t}-{a}-scopes(scopes the caller's client really holds for that callee, ornone),m2m-client-{id,secret}andpeers-statusinto the caller's own path, only when a value changes. app-secret-rollout restarts the caller when the URL, scopes or credentials change.callee-invalid/caller-invalid.javabin.internalRoute53 zone is an A record Cloud Map wrote for a registered instance, and that no task is wearing another app's security group. Findings go to Slack and are never auto-fixed.javabin-network=appin the platform VPC, tags only when a rule is created, and Cognito access only on the internal pool.Injected variables
<APP>_URL(or theenv:name),<..>_SCOPES(SSM secret with the granted scopes),PEER_AUTH_TOKEN_URL,PEER_AUTH_CLIENT_ID,PEER_AUTH_CLIENT_SECRET.PEER_AUTH_ISSUER,PEER_AUTH_JWKS_URL,PEER_AUTH_SCOPE_PREFIX.environment:, resources or auth.Boundary
DenySharedaddsservicediscovery:Delete*.DenyTagStripaddsservicediscovery:TagResourceandservicediscovery:UntagResource, so teams cannot delete or retag the shared namespace. Both statements are Deny statements with conditions onteam=shared(andplatformfor tags), so teams' own Cloud Map services are unaffected.DenyAppDNS: deniesroute53:ChangeResourceRecordSetswhen any record name matches*javabin.internal. The namespace creates a Route53 private zone, and Route53 ignores tag conditions, so without this any team could rewrite another app's private A record and capture its M2M tokens. Record names are known at plan time, unlike the zone ID, so the boundary stays readable in the plan. IAM policy simulator: denied forcupcake-cupcake.javabin.internaland the apex, allowed fortestteam.java.no.DenyNetworkaddsroute53:DeleteHostedZone(teams only write records; zones are platform-managed). Theroute53:DeleteHostedZoneinDenySharednever worked, because of the tag condition, so it moved here. A private zone's only VPC cannot be disassociated.DenyNetwork's four internet-gateway and two NAT-gateway actions becomeec2:*InternetGatewayandec2:*NatGateway, which also covers egress-only IGWs.DenyPlatInfra's ECS, ELB and DynamoDB ARNs use*:*for region/account, asDenyBadNamealready does. Both changes only make the denies broader.terraform console: main is 5,946 bytes (live v8: 5,947). This PR brings it to 6,067 of 6,144, leaving 77 bytes. The per-team guardrail copies are smaller still.Rollout notes
main, so cupcake-cupcake, cupcake-cupcake-backend, jzwatch-jz-watch and testteam-platform-test-app move to their own security group and get a Cloud Map registration in one in-place ECS update (a rolling deploy). The new group's ALB rule is created before the service switches, enforced bydepends_onon the module output. None of these apps has a database.javabin.internalnamespace. An app plan that runs between this merge and the end of the platform apply fails, and passes when re-run.auth-claims. If the internal pool moves to V3_0,auth-claimsmust passTokenGeneration_ClientCredentialsevents through untouched.How verified
python3 -m unittest discover -s scripts/tests: 56 OK, including theterraform fmt -checktest on generated output for the cupcake and frosting fixtures and a caller/callee pair.python3 -m unittest discover -s terraform/lambda-src/tests: 89 OK.test_app_peers_sync.pycovers consent and scope intersection, pending and callee-missing states, rule add, revoke and port change, team rules left alone, refusal of another team's SG, resource-server ordering, the client with and without grants, caller deletion, writes only on change, invalid requests keeping their credentials, and the audits.terraform fmt -check -recursive terraform: clean.terraform validateonmodules/app-networkandmodules/ecs-service: valid. The platform root is validated by this PR's Terraform Plan check.Follow-ups
SP_BASE_URLwith basic auth.peers-statusafter apply.javabin-ecs-tasks-sgand theecs_tasks_security_group_idoutput of platform-data once all four services have migrated.javabin-alb-sg.ecs-deploycheck that the peer parameters exist and point topeers-statuswhen they do not. The first-deploy dependency is documented in the meantime.DenySharedhas no Lambda actions, so a team could update ateam=sharedLambda, and Route53 record writes in the public app zones are not team-scoped. The privatejavabin.internalzone is now protected in this PR.🤖 Generated with Claude Code