The Security Framework
Security is a property of the platform, not a setting. The core modules that build each resource apply the guardrails. A developer cannot deploy an insecure resource. This page describes each layer.
Governance with CODEOWNERS
The platform keeps the CODEOWNERS file of the central GitOps repository.
- Git is the audit log. Each change links to a commit that shows who asked, who approved it when a rule requires approval, and when it applied.
- Ownership follows the manifest. When you name administrators for an
OrganizationalUnitor aProject, the platform writes aCODEOWNERSrule for the directory of that manifest. Example:/path/to/your-project/ @your-github-org/team-alpha-admins. - The owners review. A pull request that touches that directory asks the owners for review. Your branch rules decide if an approval must happen. Organization admins can bypass those rules.
- Files can move. The rule follows the resource, so you can keep files where you like.
IAM and least privilege
- Permissions inherit. IAM policies flow down the hierarchy: Organization, OU, Environment, Project. Put broad policies at the top and add specific grants below.
- Each application has its own identity. It is a dedicated Google service account that starts with zero permissions.
- Access is explicit. The permission must appear in the
accessControlblock of the application. The platform then creates a narrow IAM binding between that account and that resource. - People get access through three tiers. You set the tiers in the
permissionsblock of a manifest. See Access Tiers.
Network
The network denies by default.
- Hub and spoke. The VPC of the Core Project is the hub. Each service project is a spoke, connected to the hub by a VPC peer or Private Service Connect, and isolated from the other spokes.
- The platform derives the firewall rules. It generates least-privilege rules for the traffic that your manifests declare: ingress routes and
accessControlblocks. - One service mesh. GKE, Cloud Run and Compute Engine enroll in Google Cloud Service Mesh. It gives mutual TLS between services and the same metrics and traces on all compute.
- Egress uses an allow-list. Each project has a default-deny firewall and a NAT gateway. It allows the destinations in
allowedEgress. Google's services, the Debian and Windows update servers and private addresses inside the network are always allowed.
End-user authentication
- Authentication happens at the edge. Identity-Aware Proxy (IAP) checks the caller at the load balancer, backed by a Cloud Identity Platform (GCIP) tenant for each application. The application gets a verified identity and never handles raw credentials.
- You declare tenants. An
IdentityProvidermanifest sets the sign-in providers, the password policy, custom claims and maintenance or suspension controls. - Each route sets its rule. A route rule uses
IDENTITY_PROVIDERwith the allowed tenants, orINTERNALfor IAM-only tools. OnePublicIngresscan serve both. - Authorization is a separate option. A
PublicIngresswith anauthorizationDatabasegets an Ory Keto service for relation-based access decisions.
Sandboxing
Least-privilege IAM and a default-deny network give each application a sandbox. Experimental and AI-generated code gets these permissions:
- a baseline set of roles, for example a metric writer and a log writer;
- roles that the engine adds for the kind of app;
- the database and secret access that its manifests add.
Its outbound traffic reaches only the allow-list of its project, plus Google's services and operating-system update servers. A new grant is a pull request.
An Agent manifest sets what an agent can reach in its accessControl block. The engine provisions the identity of the agent separately. See Agentic Governance.
Encryption
- In transit. mTLS encrypts all mesh traffic. Google-managed certificates end TLS at public ingress.
- At rest. Google-managed keys encrypt everything the platform provisions. Customer-managed keys (CMEK) work for some resources, such as Pub/Sub topics.