Solution architecture outcome pattern: agent and its MCP servers
Some checks failed
check agents / check (push) Failing after 13s

The cp1-solution-architecture-agent and the sa-aws/azure/gcp-cloud MCP servers, a separate
stream from the individual and sub-agent patterns.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-05 22:13:25 +00:00
parent 8bb62a4a42
commit bc84ee4df6
267 changed files with 44287 additions and 45 deletions

View File

@@ -0,0 +1,34 @@
---
name: aws-iac-patterns
description: >-
Terraform patterns for AWS products that validate against one pinned version
of the hashicorp/aws provider: VPC, IAM roles, ECS on Fargate, Lambda, RDS, S3,
Secrets Manager and CloudWatch. Use when writing Terraform for an AWS product,
before writing the resource.
metadata:
scope: deployment guidance
provider: hashicorp/aws 6.10.0
---
# AWS IaC patterns
Every pattern here passes `terraform validate` against `hashicorp/aws 6.10.0`. A test runs that on each of them, so an argument you copy from a pattern is in the right block.
## How to use them
1. Write `assets/versions.tf` to your working copy as `terraform/versions.tf`, unchanged. It pins the provider version these patterns and the `terraform_schema` tool describe. Declare the `region` variable in `terraform/variables.tf`.
2. For each Element in the Target architecture, read the reference for its product with `load_skill_resource` and start from its pattern. Read only the references for products the Target architecture uses.
3. Change the pattern to meet the Element's Checks. For a setting the pattern does not show, call `terraform_schema` with `find` set to its name before you write it.
| Product | Reference |
| --- | --- |
| VPC | `references/vpc.md` |
| IAM role | `references/iam-role.md` |
| ECS on Fargate | `references/ecs-fargate.md` |
| Lambda | `references/lambda.md` |
| RDS PostgreSQL | `references/rds.md` |
| S3 bucket | `references/s3.md` |
| Secrets Manager | `references/secrets-manager.md` |
| CloudWatch alarm | `references/cloudwatch.md` |
For a product with no reference, use `terraform_schema` to find its resource type and arguments. Never write an argument you haven't confirmed.

View File

@@ -0,0 +1,13 @@
terraform {
required_version = ">= 1.9"
required_providers {
aws = {
source = "hashicorp/aws"
version = "6.10.0"
}
}
}
provider "aws" {
region = var.region
}

View File

@@ -0,0 +1,27 @@
# CloudWatch alarm
An alarm that notifies an SNS topic.
```hcl
resource "aws_sns_topic" "on_call" {
name = "on-call"
kms_master_key_id = "alias/aws/sns"
}
resource "aws_cloudwatch_metric_alarm" "errors" {
alarm_name = "ingest-errors"
namespace = "AWS/Lambda"
metric_name = "Errors"
statistic = "Sum"
period = 300
evaluation_periods = 1
threshold = 1
comparison_operator = "GreaterThanOrEqualToThreshold"
treat_missing_data = "notBreaching"
alarm_actions = [aws_sns_topic.on_call.arn]
dimensions = {
FunctionName = "ingest"
}
}
```

View File

@@ -0,0 +1,82 @@
# ECS on Fargate
A service on Fargate in private subnets, with logs and a deployment circuit breaker.
```hcl
variable "image" {
type = string
}
variable "execution_role_arn" {
type = string
}
variable "task_role_arn" {
type = string
}
variable "subnet_ids" {
type = list(string)
}
variable "security_group_ids" {
type = list(string)
}
resource "aws_ecs_cluster" "main" {
name = "workload"
setting {
name = "containerInsights"
value = "enabled"
}
}
resource "aws_cloudwatch_log_group" "api" {
name = "/ecs/api"
retention_in_days = 90
}
resource "aws_ecs_task_definition" "api" {
family = "api"
requires_compatibilities = ["FARGATE"]
network_mode = "awsvpc"
cpu = "512"
memory = "1024"
execution_role_arn = var.execution_role_arn
task_role_arn = var.task_role_arn
container_definitions = jsonencode([{
name = "api"
image = var.image
essential = true
portMappings = [{ containerPort = 8080 }]
logConfiguration = {
logDriver = "awslogs"
options = {
awslogs-group = aws_cloudwatch_log_group.api.name
awslogs-region = var.region
awslogs-stream-prefix = "api"
}
}
}])
}
resource "aws_ecs_service" "api" {
name = "api"
cluster = aws_ecs_cluster.main.id
task_definition = aws_ecs_task_definition.api.arn
launch_type = "FARGATE"
desired_count = 2
network_configuration {
subnets = var.subnet_ids
security_groups = var.security_group_ids
assign_public_ip = false
}
deployment_circuit_breaker {
enable = true
rollback = true
}
}
```

View File

@@ -0,0 +1,37 @@
# IAM role
A role a service assumes, with an inline policy of named actions on named resources.
```hcl
variable "bucket_arn" {
type = string
}
data "aws_iam_policy_document" "assume" {
statement {
actions = ["sts:AssumeRole"]
principals {
type = "Service"
identifiers = ["ecs-tasks.amazonaws.com"]
}
}
}
data "aws_iam_policy_document" "read" {
statement {
actions = ["s3:GetObject"]
resources = ["${var.bucket_arn}/*"]
}
}
resource "aws_iam_role" "task" {
name = "app-task"
assume_role_policy = data.aws_iam_policy_document.assume.json
}
resource "aws_iam_role_policy" "read" {
name = "read-objects"
role = aws_iam_role.task.id
policy = data.aws_iam_policy_document.read.json
}
```

View File

@@ -0,0 +1,43 @@
# Lambda
A function from a package in S3, with tracing and a dead-letter queue.
```hcl
variable "role_arn" {
type = string
}
variable "package_bucket" {
type = string
}
variable "package_key" {
type = string
}
resource "aws_sqs_queue" "dead_letters" {
name = "ingest-dlq"
message_retention_seconds = 1209600
sqs_managed_sse_enabled = true
}
resource "aws_lambda_function" "ingest" {
function_name = "ingest"
role = var.role_arn
runtime = "python3.13"
handler = "app.handler"
s3_bucket = var.package_bucket
s3_key = var.package_key
architectures = ["arm64"]
timeout = 30
memory_size = 512
dead_letter_config {
target_arn = aws_sqs_queue.dead_letters.arn
}
tracing_config {
mode = "Active"
}
}
```

View File

@@ -0,0 +1,33 @@
# RDS PostgreSQL
Multi-AZ, encrypted, private, with deletion protection and a password managed by AWS.
```hcl
variable "db_subnet_group" {
type = string
}
variable "security_group_ids" {
type = list(string)
}
resource "aws_db_instance" "main" {
identifier = "workload"
engine = "postgres"
engine_version = "16"
instance_class = "db.m7g.large"
allocated_storage = 100
storage_type = "gp3"
storage_encrypted = true
multi_az = true
publicly_accessible = false
db_subnet_group_name = var.db_subnet_group
vpc_security_group_ids = var.security_group_ids
username = "app_admin"
manage_master_user_password = true
backup_retention_period = 14
deletion_protection = true
skip_final_snapshot = false
final_snapshot_identifier = "workload-final"
}
```

View File

@@ -0,0 +1,49 @@
# S3 bucket
Public access blocked, encrypted, versioned, with a lifecycle rule.
```hcl
resource "aws_s3_bucket" "main" {
bucket = "workload-data-001"
}
resource "aws_s3_bucket_public_access_block" "main" {
bucket = aws_s3_bucket.main.id
block_public_acls = true
block_public_policy = true
ignore_public_acls = true
restrict_public_buckets = true
}
resource "aws_s3_bucket_server_side_encryption_configuration" "main" {
bucket = aws_s3_bucket.main.id
rule {
apply_server_side_encryption_by_default {
sse_algorithm = "aws:kms"
}
}
}
resource "aws_s3_bucket_versioning" "main" {
bucket = aws_s3_bucket.main.id
versioning_configuration {
status = "Enabled"
}
}
resource "aws_s3_bucket_lifecycle_configuration" "main" {
bucket = aws_s3_bucket.main.id
rule {
id = "tier-and-expire"
status = "Enabled"
filter {}
transition {
days = 30
storage_class = "STANDARD_IA"
}
noncurrent_version_expiration {
noncurrent_days = 90
}
}
}
```

View File

@@ -0,0 +1,16 @@
# Secrets Manager
A secret encrypted with a customer-managed key. Values never go in Terraform.
```hcl
resource "aws_kms_key" "secrets" {
description = "Workload secrets"
enable_key_rotation = true
}
resource "aws_secretsmanager_secret" "api_key" {
name = "workload/api-key"
kms_key_id = aws_kms_key.secrets.arn
recovery_window_in_days = 30
}
```

View File

@@ -0,0 +1,39 @@
# VPC
Private and public subnets in two Availability Zones. Add NAT, routes and endpoints as the design needs.
```hcl
variable "zones" {
type = list(string)
}
resource "aws_vpc" "main" {
cidr_block = "10.0.0.0/16"
enable_dns_hostnames = true
enable_dns_support = true
}
resource "aws_subnet" "private" {
count = 2
vpc_id = aws_vpc.main.id
availability_zone = var.zones[count.index]
cidr_block = cidrsubnet(aws_vpc.main.cidr_block, 4, count.index)
}
resource "aws_flow_log" "main" {
vpc_id = aws_vpc.main.id
traffic_type = "ALL"
log_destination_type = "cloud-watch-logs"
log_destination = aws_cloudwatch_log_group.flow.arn
iam_role_arn = var.flow_log_role_arn
}
variable "flow_log_role_arn" {
type = string
}
resource "aws_cloudwatch_log_group" "flow" {
name = "/vpc/flow"
retention_in_days = 90
}
```

View File

@@ -0,0 +1,253 @@
---
name: aws-solution-architecture
metadata:
category: MultiProductSolutions
derived-from: google-cloud-solution-architecture (Apache-2.0), changed for AWS
description: >-
Discovers requirements and designs multi-product system architectures and
deployment recommendations for complex workloads on AWS. Use when designing
end-to-end solutions, selecting and integrating AWS services, or running
requirements discovery for new workloads or migrations.
---
# AWS solution-architecture workflow
## Overview of the workflow
The workflow consists of the following phases:
* **Phase 1: Requirements discovery**. Gather detailed requirements related to
the cloud workload or use case that the user needs assistance for.
* **Phase 2: Solution architecture**. Use the requirements that were gathered
in Phase 1 to generate a detailed solution architecture for the cloud
workload or use case.
* **Phase 3: Solution validation**. Create a plan to validate the generated
solution, generate validation instructions and scripts, and provide them to
the user to execute (or perform a dry-run validation with explicit
permission from the user).
* **Phase 4: Solution packing and presentation**. Consolidate the generated
content and present the solution.
**Important notes about the workflow**:
* **Strict phase separation**: During Phase 1 (Requirements discovery), when
you ask the user clarifying questions, don't recommend, propose, or outline
any architectural designs, technical decompositions, cloud services, or
component mappings. Proposing solutions before functional and non-functional
requirements are thoroughly assessed causes confirmation bias and risks
anchoring the solution on specific products, features, or tools prematurely.
* **Iterative approval & task transitions**: For each deliverable in this
workflow (technical decompositions, product recommendations, diagrams,
architectural descriptions, and deployment scripts), explicitly present your
output to the user for approval. If the user requests modifications,
iteratively revise the content until approved before progressing to the
subsequent task or phase.
* **No autonomous execution of code and scripts**: Don't run any scripts or
code that you generate without explicit, unambiguous permission from the
user. Executing scripts autonomously can provision unintended cloud
resources (incurring unexpected costs), mutate live infrastructure, or pose
security and safety risks. Always offer the option for the user to execute
the commands manually.
* **When you can skip certain phases**: If the user's prompt indicates that a
specific phase or task in this workflow is already completed or approved
(e.g., "requirements discovery stage is completed", "product selection is
approved", or "architecture is confirmed"), don't repeat that phase or task.
Instead, skip directly to the requested task (such as generating the
technical decomposition, recommending products, or compiling the solution
guide).
## Phase 1: Requirements discovery
1. Gather the following requirements related to the workload or use case for
which the user needs assistance.
**CRITICAL**: You MUST NOT generate any architecture designs, product
recommendations, or technical decompositions until the user provides these
requirements.
* **Functional requirements**: Ask the user to describe the business
processes, activities, and use cases of their workload.
* **Non-functional requirements**: Ask the user to describe requirements
for security, privacy, compliance, reliability, disaster recovery, cost,
operations, performance, and sustainability.
* **CRITICAL**: If non-functional requirements are missing or
incomplete, you MUST ask the user to describe the requirements and
explicitly explain why they are important (e.g., because they
directly dictate operational SLAs, availability tiers, scaling
configuration, cost budgets, resource types, and the security
posture) when asking the user to supply them.
* **Current state**: Ask whether the workload currently runs on other
cloud providers or on-premises (if yes, prompt for the architecture of
the existing deployment).
* **System dependencies**: Ask the user to describe any dependencies
between their application and other workloads, products, systems, or
tools.
2. Review the input that the user has provided so far, and check whether there
are any ambiguities or contradictions (e.g., conflicting goals like complete
network isolation with zero internet exposure vs. real-time ingestion from
public APIs).
If you identify any ambiguities or contradictions in the user's
requirements, you must:
* Clearly describe the ambiguities and contradictions.
* Explain why the contradictory requirements cannot be simultaneously
satisfied.
* Request the user to clarify their trade-off preferences and choices to
resolve the ambiguities and contradictions.
* If the user delegates the choice to you (e.g., the user replies with
"do what you think is best" or "you decide"), then provide a clear
suggestion to resolve the ambiguity or contradiction, explain your
reasoning, and ask the user to approve your suggestion.
**CRITICAL**: Until all the ambiguities and contradictions that you identify
are resolved, don't recommend or generate any architecture design, technical
decomposition, or AWS product recommendations. Ambiguous or
contradictory requirements lead to invalid architectural assumptions.
3. Generate a technical decomposition of the components of the workload that
breaks down the solution into logical components. Present it to the user and
obtain approval before proceeding to Phase 2.
**CRITICAL**: Before proceeding to Phase 2, ensure that the user has
approved the technical decomposition. Misalignment of the technical
decomposition with the user's requirements will invalidate the outputs of
the subsequent phases in this workflow.
## Phase 2: Solution architecture
Use the approved requirements from Phase 1 to generate a comprehensive solution
architecture.
### Ground all generated content
For each task in this phase, to ensure that the generated content aligns with
the latest and official AWS guidance, you must ground the generated
content by using the following resources:
* The documentation tools you are given, when you have them: `aws_search_documents`
and `aws_get_documents`, on AWS documentation.
* AWS Architecture Center: https://aws.amazon.com/architecture/
* The AWS Well-Architected Framework: https://docs.aws.amazon.com/wellarchitected/latest/framework/welcome.html
For each item in the generated guidance, you must include citations to the
relevant official AWS documentation pages.
### Task 2.1: Identify AWS products and features required for the workload.
1. Recommend the products and features that are appropriate for each component
of the user's workload.
**CRITICAL**:
* Don't recommend any products or features that are deprecated, retired,
decommissioned, or unsupported. Check its status in the documentation when you have the tools; otherwise say
the status wasn't confirmed.
* If multiple products or features can be used for a component of the
workload, then do the following:
* Recommend the most appropriate product or feature. When alternative
products exist, the relevant product documentation might provide
guidance on when to choose each product. Follow that guidance.
* Mention the available alternative products or features.
* Explain the pros and cons of each alternative product or feature.
2. Present the generated product recommendations to the user and ask whether
any changes are needed.
**CRITICAL**: Don't generate anything further (architecture diagrams,
descriptions, or deployment configurations) in the same turn. Halt execution
immediately after listing the product choices until the user approves the
product selections.
3. After the user approves the product selections, proceed to Task 2.2.
### Task 2.2: Generate an architecture diagram.
1. Generate an architecture diagram in Mermaid format:
https://github.com/mermaid-js/mermaid.
2. Present the generated diagram to the user and obtain approval before
proceeding to Task 2.3.
### Task 2.3: Generate an architecture description.
1. Generate a description that explains the purpose of each component, the
relationships between the components, and the task flow or data flow.
2. Present the generated architecture description to the user and obtain
approval before proceeding to Task 2.4.
### Task 2.4: Generate design recommendations.
1. Generate design recommendations and best practices to optimally configure
each component in the architecture based on the workload's requirements.
**Important**:
* When generating design recommendations, incorporate the following:
* Functional requirements that were gathered in Phase 1.
* Non-functional requirements that were gathered in Phase 1.
* To generate guidance for non-functional requirements, use the following
skills, as appropriate:
- `aws-waf-security`
- `aws-waf-reliability`
- `aws-waf-cost-optimization`
- `aws-waf-operational-excellence`
- `aws-waf-performance-efficiency`
- `aws-waf-sustainability`
2. Present the generated recommendations to the user and obtain approval before
proceeding to Task 2.5.
### Task 2.5: Generate deployment guidance.
1. Generate deployment guidance, including infrastructure-as-code and
instructions to enable the user to deploy the solution.
2. Present the generated deployment guidance to the user and obtain approval
before proceeding to Phase 3.
## Phase 3: Solution validation
### Task 3.1: Pre-deployment validation
1. Create a pre-deployment plan to statically validate the generated solution
and verify that it meets the workload's requirements without provisioning
live resources:
* **Deployment dry-run**: Validate infrastructure syntax and preview the
resources that will be provisioned using dry-run commands (e.g.,
`terraform plan` or (where supported) the provider CLI's what-if or dry-run mode).
* **Architecture & policy analysis**: Perform static verification of
network routing topologies, firewall rules, and IAM enforcement against
best practices.
2. Present the static validation plan to the user and obtain explicit
permission from the user to execute the dry-run commands. If the user gives
permission, then run the commands; otherwise, or if the user prefers,
provide the exact commands that the user can run manually.
3. Troubleshoot and fix any errors or policy discrepancies identified during
dry-run checks until validation succeeds.
4. Proceed to Task 3.2
### Task 3.2: Runtime validation (Post-deployment)
1. Ask the user whether they choose to deploy the infrastructure now to perform
live runtime verification, or skip directly to Phase 4.
2. **If the user chooses to deploy the infrastructure**:
* After the user deploys the infrastructure, generate runtime verification
commands (using tools like `curl`, `ping`, or the provider CLI) and provide them
to the user to execute, to test live endpoint reachability, networking
paths, and load balancer routing.
* Troubleshoot any deployment or runtime routing issues until checks pass.
3. Proceed to Phase 4.
## Phase 4: Solution packaging and presentation
Package all the generated text and code artifacts for final presentation.
1. Consolidate the text artifacts that were generated in Phase 2 and Phase 3
into a single Markdown file named `solution-architecture-guide.md`, based on
the template in `assets/output-template.md`.
2. Request the user's permission to write the code files in the user's
workspace.
3. After the user gives permission, write the code files in the user's
workspace.

View File

@@ -0,0 +1,123 @@
<!-- Use this template to compile the content that you generate based on the
instructions in `SKILL.md`. -->
# AWS solution architecture: [Workload Name]
## 1. Executive summary and workload overview
[A brief description of the workload, its business goals, and the high-level
solution architecture proposed.]
## 2. Requirements and current state
### 2.1. Functional requirements
* **Business processes**: [Details of the business processes supported]
* **Activities and use cases**: [Details of the key activities and use cases]
### 2.2. Non-functional requirements
* **Security**: [Details of the security requirements including compliance,
encryption, access control requirements]
* **Reliability**: [Details of the reliability requirements including SLA,
RTO/RPO, backup, redundancy requirements]
* **Cost**: [Details of the cost constraints and pricing models]
* **Operations**: [Details of the operational requirements including
monitoring, logging, deployment, maintenance requirements]
* **Performance**: [Details of the performance requirements including latency,
throughput, scaling requirements]
* **Sustainability**: [Details of the sustainability requirements including
carbon footprint, resource optimization requirements]
### 2.3. Current state
[If applicable, describe the current on-premises or other-cloud architecture.]
* **Current infrastructure**: [Details of existing setup]
* **Pain points and drivers for migration/redesign**: [Details of the drivers
for migration/redesign]
### 2.4. Dependencies
* **Internal dependencies**: [Details of internal dependencies including other
workloads and internal services]
* **External dependencies**: [Details of external dependencies including
third-party products and on-premises tools]
## 3. Technical decomposition of the workload
[Technical decomposition of the workload components, breaking down the
application into logical services or layers.]
## 4. Proposed solution architecture
### 4.1. AWS products and features mapping
[Identify AWS products and features mapped to the technical
components. For each component, justify the selection, note alternatives
considered, and describe the pros and cons of the recommended product/feature
and alternatives.]
| Component | Recommended AWS product/feature | Justification and citations | Alternatives considered | Pros and cons of alternatives |
| :--- | :--- | :--- | :--- | :--- |
| **[Component Name]** | **[Product Name]** | [Why this product is chosen, citing official docs] | [Alternative product] | **Pros**: ... <br> **Cons**: ... |
### 4.2. Architecture diagram
[Architecture diagram in Mermaid format showing the relationships and flows
between the components of the architecture.]
```mermaid
%% Example structure
graph TD
User([User]) --> Web[Load Balancer]
Web --> App[Application Layer]
App --> DB[(Database)]
```
### 4.3. Architecture description
[Detailed description of the architecture. Describe the task flow and data
flow between the components of the architecture.]
* **Data flow**: [Describe the flow of data.]
* **Tasks/control flow**: [Describe the flow of tasks/control.]
## 5. Design and configuration recommendations
[Best practices and configuration recommendations for each pillar of the
AWS Architecture Framework.]
### 5.1. Security
* **Access control**: [E.g., IAM roles, least privilege]
* **Data protection**: [E.g., Encryption at rest/in transit, AWS KMS]
* **Network Security**: [E.g., VPC, security groups, AWS WAF, AWS PrivateLink]
### 5.2. Reliability
* **Redundant deployment**: [E.g., Multi-region/regional deployment, load
balancing]
* **Backup and DR**: [E.g., Backups, failover procedures, RTO/RPO strategies]
### 5.3. Operational Excellence
* **Monitoring and logging**: [E.g., Amazon CloudWatch, dashboards]
* **Infrastructure as Code (IaC)**: [E.g., Terraform]
### 5.4. Cost Optimization
* **Sizing and scaling**: [E.g., Autoscaling configuration, right-sizing resources]
* **Pricing models**: [E.g., Savings Plans, Spot Instances]
### 5.5. Performance Efficiency
* **Caching and CDN**: [E.g., Amazon CloudFront, Amazon ElastiCache]
* **Database and query optimization**: [E.g., Partitioning, indexing, caching]
### 5.6. Sustainability
* [E.g., Serverless adoption, resource utilization, carbon footprint]
## 6. Deployment guidance
[Instructions and code for deploying the architecture.]
### 6.1. Deployment prerequisites
* [Prerequisite 1: E.g., Account and Region setup]
* [Prerequisite 2: E.g., Installing SDK/tools]
* ...and so on
### 6.2. Step-by-step deployment instructions
1. [Step 1: E.g., Authenticate with AWS]
2. [Step 2: E.g., Initialize Terraform]
3. [Step 3: E.g., Apply Terraform configuration]
## 7. Validation plan
[Details of the steps to verify that the generated solution meets the workload's
requirements. Also include references to any validation scripts that were
generated.]
## 8. References
* [E.g., Regional managed instance groups](https://docs.cloud.google.com/compute/docs/instance-groups/regional-migs)

View File

@@ -0,0 +1,83 @@
---
name: aws-waf-cost-optimization
metadata:
category: WellArchitectedFramework
description: >-
Generates cost optimization guidance for AWS workloads based on the Cost
Optimization pillar of the AWS Well-Architected Framework. Use when
estimating, governing or reducing AWS spending, choosing pricing models or
planning data transfer.
---
# AWS Well-Architected Framework skill for the Cost Optimization pillar
## Overview
The Cost Optimization pillar is the ability to run systems that deliver business
value at the lowest price point. AWS organizes it into cloud financial
management, expenditure and usage awareness, cost-effective resources, managing
demand and supply, and optimizing over time.
## Core principles
The recommendations below follow the published framework. Written for this agent from AWS's published Well-Architected Framework. Question codes are AWS's.
- **Implement Cloud Financial Management**: Invest in the capability to manage
cost. Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/cost-dp.html
- **Adopt a consumption model**: Pay only for what is used. Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/cost-dp.html
- **Measure overall efficiency**: Compare business output with the cost of
delivering it. Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/cost-dp.html
- **Stop spending money on undifferentiated heavy lifting**: Let managed
services take on operational work. Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/cost-dp.html
- **Analyze and attribute expenditure**: Identify usage and cost, and attribute
it to owners. Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/cost-dp.html
## Relevant products
The following are _examples_ of products relevant to this pillar:
- **Visibility**: AWS Cost Explorer, AWS Budgets, AWS Cost Anomaly Detection,
cost allocation tags
- **Rates**: Savings Plans, Reserved Instances, Spot Instances
- **Sizing**: AWS Compute Optimizer, AWS Trusted Advisor
- **Data**: Amazon S3 Intelligent-Tiering, S3 Lifecycle
## Workload assessment questions
Ask appropriate questions to understand the requirements and constraints of the
workload and the organization. Choose from this list:
- COST 1: How do you implement cloud financial management?
- COST 2: How do you govern usage?
- COST 3: How do you monitor your cost and usage?
- COST 4: How do you decommission resources?
- COST 5: How do you evaluate cost when you select services?
- COST 6: How do you meet cost targets when you select resource type, size and
number?
- COST 7: How do you use pricing models to reduce cost?
- COST 8: How do you plan for data transfer charges?
- COST 9: How do you manage demand, and supply resources?
- COST 10: How do you evaluate new services?
- COST 11: How do you evaluate the cost of effort?
## Validation checklist
Use this checklist to evaluate the architecture against this pillar:
- Budgets, owners and anomaly alerts exist.
- Costs are tagged and attributed.
- Unused resources are found and decommissioned.
- Services were compared on cost.
- Sizing is based on measured use.
- Savings Plans or Spot are considered.
- Data transfer is estimated and designed for.
- Demand is managed with scaling, queues or throttling.

View File

@@ -0,0 +1,94 @@
---
name: aws-waf-operational-excellence
metadata:
category: WellArchitectedFramework
description: >-
Generates guidance for operating AWS workloads, based on the Operational
Excellence pillar of the AWS Well-Architected Framework. Use when designing
teams, observability, deployment, runbooks or continuous improvement for an
AWS workload.
---
# AWS Well-Architected Framework skill for the Operational Excellence pillar
## Overview
The Operational Excellence pillar is a commitment to building software correctly
while consistently delivering a great customer experience. It covers how teams
are organized, how a workload is designed and prepared, how it is run at scale,
and how it evolves.
## Core principles
The recommendations below follow the published framework. Written for this agent from AWS's published Well-Architected Framework. Question codes are AWS's.
- **Organize teams around business outcomes**: Tie structure and priorities to
what the business needs. Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/oe-design-principles.html
- **Implement observability for actionable insights**: Understand behaviour,
performance and health well enough to act. Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/oe-design-principles.html
- **Safely automate where possible**: Define operations as code, with
guardrails. Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/oe-design-principles.html
- **Make frequent, small, reversible changes**: Limit the impact of each change,
and keep rollback simple. Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/oe-design-principles.html
- **Refine operations procedures frequently**: Improve runbooks as the workload
changes, and rehearse them. Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/oe-design-principles.html
- **Anticipate failure**: Identify and test failure scenarios before they occur.
Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/oe-design-principles.html
- **Learn from all operational events and metrics**: Share what is learned
across teams. Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/oe-design-principles.html
- **Use managed services**: Reduce operational burden. Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/oe-design-principles.html
## Relevant products
The following are _examples_ of products relevant to this pillar:
- **Delivery**: AWS CodePipeline, AWS CodeBuild, AWS CodeDeploy
- **Infrastructure as code**: Terraform, AWS CloudFormation, AWS CDK
- **Observability**: Amazon CloudWatch, AWS X-Ray, Amazon Managed Grafana
- **Operations**: AWS Systems Manager, AWS Config, AWS Health Dashboard
## Workload assessment questions
Ask appropriate questions to understand the requirements and constraints of the
workload and the organization. Choose from this list:
- OPS 1: How do you determine what your priorities are?
- OPS 2: How do you structure your organization to support your business
outcomes?
- OPS 3: How does your organizational culture support your business outcomes?
- OPS 4: How do you implement observability in your workload?
- OPS 5: How do you reduce defects, ease remediation, and improve flow into
production?
- OPS 6: How do you mitigate deployment risks?
- OPS 7: How do you know that you are ready to support a workload?
- OPS 8: How do you utilize workload observability in your organization?
- OPS 9: How do you understand the health of your operations?
- OPS 10: How do you manage workload and operations events?
- OPS 11: How do you evolve operations?
## Validation checklist
Use this checklist to evaluate the architecture against this pillar:
- Business priorities and workload ownership are stated.
- All infrastructure is deployed from code in source control.
- Pipelines test changes, and changes are small and reversible.
- Application, infrastructure and business metrics are collected.
- Alarms lead to runbooks with named responders.
- Operational readiness is reviewed before launch.
- Events are reviewed and lessons are acted on.

View File

@@ -0,0 +1,79 @@
---
name: aws-waf-performance-efficiency
metadata:
category: WellArchitectedFramework
description: >-
Generates performance efficiency guidance for AWS workloads based on the
Performance Efficiency pillar of the AWS Well-Architected Framework. Use
when selecting architecture, compute, data and networking resources, or
setting performance practices on AWS.
---
# AWS Well-Architected Framework skill for the Performance Efficiency pillar
## Overview
The Performance Efficiency pillar is the ability to use cloud resources
efficiently to meet requirements, and to keep that efficiency as demand and
technology change. AWS organizes it into architecture selection, compute and
hardware, data management, networking and content delivery, and process and
culture.
## Core principles
The recommendations below follow the published framework. Written for this agent from AWS's published Well-Architected Framework. Question codes are AWS's.
- **Democratize advanced technologies**: Use managed services instead of
building specialist expertise. Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/perf-dp.html
- **Go global in minutes**: Deploy in multiple Regions to reduce latency.
Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/perf-dp.html
- **Use serverless architectures**: Remove the need to run servers for
traditional compute. Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/perf-dp.html
- **Experiment more often**: Compare instance types, storage and configurations.
Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/perf-dp.html
- **Consider mechanical sympathy**: Choose the approach that fits how the
workload accesses data and uses resources. Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/perf-dp.html
## Relevant products
The following are _examples_ of products relevant to this pillar:
- **Compute**: AWS Graviton, AWS Lambda, AWS Fargate, Amazon EC2 Auto Scaling
- **Data**: Amazon ElastiCache, DynamoDB Accelerator, Amazon Aurora read
replicas
- **Networking**: Amazon CloudFront, AWS Global Accelerator, placement groups
- **Measurement**: Amazon CloudWatch, AWS Compute Optimizer
## Workload assessment questions
Ask appropriate questions to understand the requirements and constraints of the
workload and the organization. Choose from this list:
- PERF 1: How do you select appropriate cloud resources and architecture for
your workload?
- PERF 2: How do you select and use compute resources in your workload?
- PERF 3: How do you store, manage, and access data in your workload?
- PERF 4: How do you select and configure networking resources in your workload?
- PERF 5: How do your organizational practices and culture contribute to
performance efficiency in your workload?
## Validation checklist
Use this checklist to evaluate the architecture against this pillar:
- Numeric performance targets exist.
- Architecture choices were compared with data.
- Compute type and size match the workload, and are reviewed.
- Data stores match access patterns.
- Caching is used where it serves the targets.
- Users are served from close Regions or the edge.
- Load tests run before release.

View File

@@ -0,0 +1,91 @@
---
name: aws-waf-reliability
metadata:
category: WellArchitectedFramework
description: >-
Generates guidance for reliability, availability, fault isolation and
disaster recovery for AWS workloads, based on the Reliability pillar of the
AWS Well-Architected Framework. Use when evaluating, designing or improving
how an AWS workload withstands and recovers from failure.
---
# AWS Well-Architected Framework skill for the Reliability pillar
## Overview
The Reliability pillar is the ability of a workload to perform its intended
function correctly and consistently when it is expected to. AWS organizes it
into foundations, workload architecture, change management and failure
management.
## Core principles
The recommendations below follow the published framework. Written for this agent from AWS's published Well-Architected Framework. Question codes are AWS's.
- **Automatically recover from failure**: Monitor key indicators, and trigger
recovery when a threshold is crossed. Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/rel-dp.html
- **Test recovery procedures**: Simulate failures to prove recovery works.
Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/rel-dp.html
- **Scale horizontally to increase aggregate workload availability**: Replace
one large resource with many small ones. Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/rel-dp.html
- **Stop guessing capacity**: Monitor demand, and add or remove resources
automatically. Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/rel-dp.html
- **Manage change through automation**: Make and track changes to infrastructure
by automation. Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/rel-dp.html
## Relevant products
The following are _examples_ of products relevant to this pillar:
- **Compute**: Multiple Availability Zones, Amazon EC2 Auto Scaling, Amazon ECS,
Amazon EKS, AWS Lambda
- **Networking**: Elastic Load Balancing, Amazon Route 53, AWS Global
Accelerator
- **Data**: Amazon RDS Multi-AZ, Amazon Aurora Global Database, Amazon S3
replication, DynamoDB global tables
- **Recovery and testing**: AWS Backup, AWS Elastic Disaster Recovery, AWS Fault
Injection Service, Service Quotas
## Workload assessment questions
Ask appropriate questions to understand the requirements and constraints of the
workload and the organization. Choose from this list:
- REL 1: How do you manage Service Quotas and constraints?
- REL 2: How do you plan your network topology?
- REL 3: How do you design your workload service architecture?
- REL 4: How do you design interactions in a distributed system to prevent
failures?
- REL 5: How do you design interactions in a distributed system to mitigate or
withstand failures?
- REL 6: How do you monitor workload resources?
- REL 7: How do you design your workload to adapt to changes in demand?
- REL 8: How do you implement change?
- REL 9: How do you back up data?
- REL 10: How do you use fault isolation to protect your workload?
- REL 11: How do you design your workload to withstand component failures?
- REL 12: How do you test reliability?
- REL 13: How do you plan for disaster recovery (DR)?
## Validation checklist
Use this checklist to evaluate the architecture against this pillar:
- Service quotas are known and monitored.
- The network has room to grow and no address overlap.
- Components are loosely coupled.
- Timeouts, retries with backoff, and throttling are designed in.
- The workload runs across multiple Availability Zones.
- Scaling is automatic and tested.
- Backups are automated, and restores are tested.
- The DR strategy meets stated RTO and RPO, and is rehearsed.
- Failure injection is part of testing.

View File

@@ -0,0 +1,99 @@
---
name: aws-waf-security
metadata:
category: WellArchitectedFramework
description: >-
Generates security guidance for AWS workloads based on the Security pillar
of the AWS Well-Architected Framework. Use when evaluating workloads,
identifying security requirements, and recommending identity, detection,
infrastructure, data and incident response controls.
---
# AWS Well-Architected Framework skill for the Security pillar
## Overview
The Security pillar is the ability to protect data, systems and assets while
taking advantage of cloud technologies. AWS organizes it into security
foundations, identity and access management, detection, infrastructure
protection, data protection, incident response and application security.
## Core principles
The recommendations below follow the published framework. Written for this agent from AWS's published Well-Architected Framework. Question codes are AWS's.
- **Implement a strong identity foundation**: Apply least privilege, separate
duties, centralize identity, and avoid long-term credentials. Grounding
document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/sec-design.html
- **Maintain traceability**: Monitor, alert and audit actions and changes in
real time. Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/sec-design.html
- **Apply security at all layers**: Use defense in depth across the edge,
network, compute, application and data. Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/sec-design.html
- **Automate security best practices**: Define controls as code in version
control. Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/sec-design.html
- **Protect data in transit and at rest**: Classify data, and use encryption,
tokenization and access control. Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/sec-design.html
- **Keep people away from data**: Reduce direct access and manual processing.
Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/sec-design.html
- **Prepare for security events**: Have incident management in place, and run
simulations. Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/sec-design.html
## Relevant products
The following are _examples_ of products relevant to this pillar:
- **Identity**: AWS IAM, AWS IAM Identity Center, AWS Organizations, service
control policies
- **Detection**: AWS CloudTrail, Amazon GuardDuty, AWS Security Hub, AWS Config
- **Infrastructure**: Amazon VPC, security groups, AWS WAF, AWS Shield, AWS
Network Firewall, AWS PrivateLink
- **Data**: AWS KMS, AWS CloudHSM, AWS Secrets Manager, Amazon Macie, AWS
Certificate Manager
## Workload assessment questions
Ask appropriate questions to understand the requirements and constraints of the
workload and the organization. Choose from this list:
- SEC 1: How do you securely operate your workload?
- SEC 2: How do you manage authentication for people and machines?
- SEC 3: How do you manage permissions for people and machines?
- SEC 4: How do you detect and investigate security events?
- SEC 5: How do you protect your network resources?
- SEC 6: How do you protect your compute resources?
- SEC 7: How do you classify your data?
- SEC 8: How do you protect your data at rest?
- SEC 9: How do you protect your data in transit?
- SEC 10: How do you anticipate, respond to, and recover from incidents?
- SEC 11: How do you incorporate and validate the security properties of
applications throughout the design, development, and deployment lifecycle?
## Validation checklist
Use this checklist to evaluate the architecture against this pillar:
- Accounts separate workloads and environments.
- People use federated identity with MFA, and workloads use roles, not long-term
keys.
- Permissions follow least privilege, and service control policies set
guardrails.
- CloudTrail is on, and findings reach a named responder.
- Network paths are restricted, with public exposure justified.
- Compute is patched and hardened.
- Data is classified, and encrypted at rest and in transit, with stated key
ownership.
- Secrets are held in Secrets Manager and rotated.
- Incident response is planned and simulated.

View File

@@ -0,0 +1,81 @@
---
name: aws-waf-sustainability
metadata:
category: WellArchitectedFramework
description: >-
Generates sustainability guidance for AWS workloads based on the
Sustainability pillar of the AWS Well-Architected Framework. Use when
choosing Regions, aligning resources to demand, or reducing the
environmental impact of an AWS workload.
---
# AWS Well-Architected Framework skill for the Sustainability pillar
## Overview
The Sustainability pillar covers understanding the impact of the services used,
quantifying it through the workload's lifecycle, and applying practices that
reduce it. AWS organizes it into Region selection, alignment to demand, software
and architecture, data, hardware and services, and process and culture.
## Core principles
The recommendations below follow the published framework. Written for this agent from AWS's published Well-Architected Framework. Question codes are AWS's.
- **Understand your impact**: Measure the workload's impact and model its
future. Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/sus-design-principles.html
- **Establish sustainability goals**: Set long-term goals, such as reducing
resources per transaction. Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/sus-design-principles.html
- **Maximize utilization**: Right-size so underlying hardware is used well.
Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/sus-design-principles.html
- **Anticipate and adopt new, more efficient hardware and software offerings**:
Keep designs flexible enough to adopt them. Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/sus-design-principles.html
- **Use managed services**: Share infrastructure across many customers.
Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/sus-design-principles.html
- **Reduce the downstream impact of your cloud workloads**: Reduce the energy or
resources customers need to use the service. Grounding document:
https://docs.aws.amazon.com/wellarchitected/latest/framework/sus-design-principles.html
## Relevant products
The following are _examples_ of products relevant to this pillar:
- **Compute**: AWS Graviton, AWS Lambda, AWS Fargate, Spot Instances
- **Data**: Amazon S3 Lifecycle, S3 Intelligent-Tiering
- **Measurement**: AWS Customer Carbon Footprint Tool
## Workload assessment questions
Ask appropriate questions to understand the requirements and constraints of the
workload and the organization. Choose from this list:
- SUS 1: How do you select Regions for your workload?
- SUS 2: How do you align cloud resources to your demand?
- SUS 3: How do you take advantage of software and architecture patterns to
support your sustainability goals?
- SUS 4: How do you take advantage of data management policies and patterns to
support your sustainability goals?
- SUS 5: How do you select and use cloud hardware and services in your
architecture to support your sustainability goals?
- SUS 6: How do your organizational processes support your sustainability goals?
## Validation checklist
Use this checklist to evaluate the architecture against this pillar:
- Region choice considers business requirements and sustainability goals.
- Resources scale to demand, and idle resources are removed.
- Asynchronous and scheduled work fits available capacity.
- Data lifecycle rules remove what is no longer needed.
- Efficient hardware and managed services are used.
- Metrics such as resources per transaction are tracked.

View File

@@ -0,0 +1,33 @@
---
name: azure-iac-patterns
description: >-
Terraform patterns for Azure products that validate against one pinned
version of the hashicorp/azurerm provider: virtual networks, managed identities,
Container Apps, PostgreSQL, Storage, Key Vault and Monitor. Use when writing
Terraform for an Azure product, before writing the resource.
metadata:
scope: deployment guidance
provider: hashicorp/azurerm 4.40.0
---
# Azure IaC patterns
Every pattern here passes `terraform validate` against `hashicorp/azurerm 4.40.0`. A test runs that on each of them, so an argument you copy from a pattern is in the right block.
## How to use them
1. Write `assets/versions.tf` to your working copy as `terraform/versions.tf`, unchanged. It pins the provider version these patterns and the `terraform_schema` tool describe. Declare the `subscription_id`, `location` and `resource_group_name` variables in `terraform/variables.tf`.
2. For each Element in the Target architecture, read the reference for its product with `load_skill_resource` and start from its pattern. Read only the references for products the Target architecture uses.
3. Change the pattern to meet the Element's Checks. For a setting the pattern does not show, call `terraform_schema` with `find` set to its name before you write it.
| Product | Reference |
| --- | --- |
| Virtual network | `references/networking.md` |
| Managed identity and role assignment | `references/identity.md` |
| Container Apps | `references/container-apps.md` |
| PostgreSQL Flexible Server | `references/postgresql.md` |
| Storage account | `references/storage.md` |
| Key Vault | `references/key-vault.md` |
| Azure Monitor alert | `references/monitoring.md` |
For a product with no reference, use `terraform_schema` to find its resource type and arguments. Never write an argument you haven't confirmed.

View File

@@ -0,0 +1,14 @@
terraform {
required_version = ">= 1.9"
required_providers {
azurerm = {
source = "hashicorp/azurerm"
version = "4.40.0"
}
}
}
provider "azurerm" {
subscription_id = var.subscription_id
features {}
}

View File

@@ -0,0 +1,60 @@
# Container Apps
An app in a Log Analytics-backed environment, with a user-assigned identity, HTTP ingress and scaling limits.
```hcl
variable "image" {
type = string
}
variable "identity_id" {
type = string
}
resource "azurerm_log_analytics_workspace" "main" {
name = "log-workload"
location = var.location
resource_group_name = var.resource_group_name
retention_in_days = 30
}
resource "azurerm_container_app_environment" "main" {
name = "cae-workload"
location = var.location
resource_group_name = var.resource_group_name
log_analytics_workspace_id = azurerm_log_analytics_workspace.main.id
}
resource "azurerm_container_app" "api" {
name = "ca-api"
container_app_environment_id = azurerm_container_app_environment.main.id
resource_group_name = var.resource_group_name
revision_mode = "Single"
identity {
type = "UserAssigned"
identity_ids = [var.identity_id]
}
ingress {
external_enabled = true
target_port = 8080
traffic_weight {
latest_revision = true
percentage = 100
}
}
template {
min_replicas = 2
max_replicas = 10
container {
name = "api"
image = var.image
cpu = 0.5
memory = "1Gi"
}
}
}
```

View File

@@ -0,0 +1,21 @@
# Managed identity and role assignment
Give a workload a user-assigned identity, and grant its role at the narrowest scope. `scope` here is one storage account's id.
```hcl
variable "storage_account_id" {
type = string
}
resource "azurerm_user_assigned_identity" "app" {
name = "id-app"
location = var.location
resource_group_name = var.resource_group_name
}
resource "azurerm_role_assignment" "app_blob_reader" {
scope = var.storage_account_id
role_definition_name = "Storage Blob Data Reader"
principal_id = azurerm_user_assigned_identity.app.principal_id
}
```

View File

@@ -0,0 +1,19 @@
# Key Vault
RBAC authorization, purge protection, and public access off.
```hcl
data "azurerm_client_config" "current" {}
resource "azurerm_key_vault" "main" {
name = "kv-workload-001"
location = var.location
resource_group_name = var.resource_group_name
tenant_id = data.azurerm_client_config.current.tenant_id
sku_name = "standard"
enable_rbac_authorization = true
purge_protection_enabled = true
soft_delete_retention_days = 90
public_network_access_enabled = false
}
```

View File

@@ -0,0 +1,45 @@
# Azure Monitor alert
A metric alert routed to an action group. `scopes` is the resource being watched.
```hcl
variable "watched_id" {
type = string
}
variable "on_call_email" {
type = string
}
resource "azurerm_monitor_action_group" "on_call" {
name = "ag-on-call"
resource_group_name = var.resource_group_name
short_name = "oncall"
email_receiver {
name = "on-call"
email_address = var.on_call_email
}
}
resource "azurerm_monitor_metric_alert" "cpu" {
name = "alert-cpu"
resource_group_name = var.resource_group_name
scopes = [var.watched_id]
severity = 2
frequency = "PT5M"
window_size = "PT15M"
criteria {
metric_namespace = "Microsoft.DBforPostgreSQL/flexibleServers"
metric_name = "cpu_percent"
aggregation = "Average"
operator = "GreaterThan"
threshold = 80
}
action {
action_group_id = azurerm_monitor_action_group.on_call.id
}
}
```

View File

@@ -0,0 +1,50 @@
# Virtual network
A virtual network with a delegated subnet, a network security group, and default deny for inbound traffic from the internet.
```hcl
resource "azurerm_virtual_network" "main" {
name = "vnet-workload"
location = var.location
resource_group_name = var.resource_group_name
address_space = ["10.0.0.0/16"]
}
resource "azurerm_subnet" "apps" {
name = "snet-apps"
resource_group_name = var.resource_group_name
virtual_network_name = azurerm_virtual_network.main.name
address_prefixes = ["10.0.0.0/23"]
delegation {
name = "container-apps"
service_delegation {
name = "Microsoft.App/environments"
actions = ["Microsoft.Network/virtualNetworks/subnets/join/action"]
}
}
}
resource "azurerm_network_security_group" "apps" {
name = "nsg-apps"
location = var.location
resource_group_name = var.resource_group_name
security_rule {
name = "deny-internet-inbound"
priority = 4000
direction = "Inbound"
access = "Deny"
protocol = "*"
source_port_range = "*"
destination_port_range = "*"
source_address_prefix = "Internet"
destination_address_prefix = "*"
}
}
resource "azurerm_subnet_network_security_group_association" "apps" {
subnet_id = azurerm_subnet.apps.id
network_security_group_id = azurerm_network_security_group.apps.id
}
```

View File

@@ -0,0 +1,28 @@
# PostgreSQL Flexible Server
Zone-redundant, with public access off, geo-redundant backup and Entra authentication.
```hcl
resource "azurerm_postgresql_flexible_server" "main" {
name = "psql-workload"
location = var.location
resource_group_name = var.resource_group_name
version = "16"
sku_name = "GP_Standard_D2ds_v5"
storage_mb = 65536
backup_retention_days = 14
geo_redundant_backup_enabled = true
public_network_access_enabled = false
zone = "1"
high_availability {
mode = "ZoneRedundant"
standby_availability_zone = "2"
}
authentication {
active_directory_auth_enabled = true
password_auth_enabled = false
}
}
```

View File

@@ -0,0 +1,23 @@
# Storage account
Zone-redundant, TLS 1.2, no public blob access, no shared keys, with versioning.
```hcl
resource "azurerm_storage_account" "main" {
name = "stworkload001"
location = var.location
resource_group_name = var.resource_group_name
account_tier = "Standard"
account_replication_type = "ZRS"
min_tls_version = "TLS1_2"
allow_nested_items_to_be_public = false
shared_access_key_enabled = false
blob_properties {
versioning_enabled = true
delete_retention_policy {
days = 30
}
}
}
```

View File

@@ -0,0 +1,252 @@
---
name: azure-solution-architecture
metadata:
category: MultiProductSolutions
derived-from: google-cloud-solution-architecture (Apache-2.0), changed for Azure
description: >-
Discovers requirements and designs multi-product system architectures and
deployment recommendations for complex workloads on Azure. Use when designing
end-to-end solutions, selecting and integrating Azure services, or running
requirements discovery for new workloads or migrations.
---
# Azure solution-architecture workflow
## Overview of the workflow
The workflow consists of the following phases:
* **Phase 1: Requirements discovery**. Gather detailed requirements related to
the cloud workload or use case that the user needs assistance for.
* **Phase 2: Solution architecture**. Use the requirements that were gathered
in Phase 1 to generate a detailed solution architecture for the cloud
workload or use case.
* **Phase 3: Solution validation**. Create a plan to validate the generated
solution, generate validation instructions and scripts, and provide them to
the user to execute (or perform a dry-run validation with explicit
permission from the user).
* **Phase 4: Solution packing and presentation**. Consolidate the generated
content and present the solution.
**Important notes about the workflow**:
* **Strict phase separation**: During Phase 1 (Requirements discovery), when
you ask the user clarifying questions, don't recommend, propose, or outline
any architectural designs, technical decompositions, cloud services, or
component mappings. Proposing solutions before functional and non-functional
requirements are thoroughly assessed causes confirmation bias and risks
anchoring the solution on specific products, features, or tools prematurely.
* **Iterative approval & task transitions**: For each deliverable in this
workflow (technical decompositions, product recommendations, diagrams,
architectural descriptions, and deployment scripts), explicitly present your
output to the user for approval. If the user requests modifications,
iteratively revise the content until approved before progressing to the
subsequent task or phase.
* **No autonomous execution of code and scripts**: Don't run any scripts or
code that you generate without explicit, unambiguous permission from the
user. Executing scripts autonomously can provision unintended cloud
resources (incurring unexpected costs), mutate live infrastructure, or pose
security and safety risks. Always offer the option for the user to execute
the commands manually.
* **When you can skip certain phases**: If the user's prompt indicates that a
specific phase or task in this workflow is already completed or approved
(e.g., "requirements discovery stage is completed", "product selection is
approved", or "architecture is confirmed"), don't repeat that phase or task.
Instead, skip directly to the requested task (such as generating the
technical decomposition, recommending products, or compiling the solution
guide).
## Phase 1: Requirements discovery
1. Gather the following requirements related to the workload or use case for
which the user needs assistance.
**CRITICAL**: You MUST NOT generate any architecture designs, product
recommendations, or technical decompositions until the user provides these
requirements.
* **Functional requirements**: Ask the user to describe the business
processes, activities, and use cases of their workload.
* **Non-functional requirements**: Ask the user to describe requirements
for security, privacy, compliance, reliability, disaster recovery, cost,
operations, performance, and sustainability.
* **CRITICAL**: If non-functional requirements are missing or
incomplete, you MUST ask the user to describe the requirements and
explicitly explain why they are important (e.g., because they
directly dictate operational SLAs, availability tiers, scaling
configuration, cost budgets, resource types, and the security
posture) when asking the user to supply them.
* **Current state**: Ask whether the workload currently runs on other
cloud providers or on-premises (if yes, prompt for the architecture of
the existing deployment).
* **System dependencies**: Ask the user to describe any dependencies
between their application and other workloads, products, systems, or
tools.
2. Review the input that the user has provided so far, and check whether there
are any ambiguities or contradictions (e.g., conflicting goals like complete
network isolation with zero internet exposure vs. real-time ingestion from
public APIs).
If you identify any ambiguities or contradictions in the user's
requirements, you must:
* Clearly describe the ambiguities and contradictions.
* Explain why the contradictory requirements cannot be simultaneously
satisfied.
* Request the user to clarify their trade-off preferences and choices to
resolve the ambiguities and contradictions.
* If the user delegates the choice to you (e.g., the user replies with
"do what you think is best" or "you decide"), then provide a clear
suggestion to resolve the ambiguity or contradiction, explain your
reasoning, and ask the user to approve your suggestion.
**CRITICAL**: Until all the ambiguities and contradictions that you identify
are resolved, don't recommend or generate any architecture design, technical
decomposition, or Azure product recommendations. Ambiguous or
contradictory requirements lead to invalid architectural assumptions.
3. Generate a technical decomposition of the components of the workload that
breaks down the solution into logical components. Present it to the user and
obtain approval before proceeding to Phase 2.
**CRITICAL**: Before proceeding to Phase 2, ensure that the user has
approved the technical decomposition. Misalignment of the technical
decomposition with the user's requirements will invalidate the outputs of
the subsequent phases in this workflow.
## Phase 2: Solution architecture
Use the approved requirements from Phase 1 to generate a comprehensive solution
architecture.
### Ground all generated content
For each task in this phase, to ensure that the generated content aligns with
the latest and official Azure guidance, you must ground the generated
content by using the following resources:
* The documentation tools you are given, when you have them: `azure_search_documents`
and `azure_get_documents`, on Microsoft Learn.
* The Azure Architecture Center: https://learn.microsoft.com/azure/architecture/
* The Azure Well-Architected Framework: https://learn.microsoft.com/azure/well-architected/
For each item in the generated guidance, you must include citations to the
relevant official Azure documentation pages.
### Task 2.1: Identify Azure products and features required for the workload.
1. Recommend the products and features that are appropriate for each component
of the user's workload.
**CRITICAL**:
* Don't recommend any products or features that are deprecated, retired,
decommissioned, or unsupported. Check its status in the documentation when you have the tools; otherwise say
the status wasn't confirmed.
* If multiple products or features can be used for a component of the
workload, then do the following:
* Recommend the most appropriate product or feature. When alternative
products exist, the relevant product documentation might provide
guidance on when to choose each product. Follow that guidance.
* Mention the available alternative products or features.
* Explain the pros and cons of each alternative product or feature.
2. Present the generated product recommendations to the user and ask whether
any changes are needed.
**CRITICAL**: Don't generate anything further (architecture diagrams,
descriptions, or deployment configurations) in the same turn. Halt execution
immediately after listing the product choices until the user approves the
product selections.
3. After the user approves the product selections, proceed to Task 2.2.
### Task 2.2: Generate an architecture diagram.
1. Generate an architecture diagram in Mermaid format:
https://github.com/mermaid-js/mermaid.
2. Present the generated diagram to the user and obtain approval before
proceeding to Task 2.3.
### Task 2.3: Generate an architecture description.
1. Generate a description that explains the purpose of each component, the
relationships between the components, and the task flow or data flow.
2. Present the generated architecture description to the user and obtain
approval before proceeding to Task 2.4.
### Task 2.4: Generate design recommendations.
1. Generate design recommendations and best practices to optimally configure
each component in the architecture based on the workload's requirements.
**Important**:
* When generating design recommendations, incorporate the following:
* Functional requirements that were gathered in Phase 1.
* Non-functional requirements that were gathered in Phase 1.
* To generate guidance for non-functional requirements, use the following
skills, as appropriate:
- `azure-waf-security`
- `azure-waf-reliability`
- `azure-waf-cost-optimization`
- `azure-waf-operational-excellence`
- `azure-waf-performance-efficiency`
2. Present the generated recommendations to the user and obtain approval before
proceeding to Task 2.5.
### Task 2.5: Generate deployment guidance.
1. Generate deployment guidance, including infrastructure-as-code and
instructions to enable the user to deploy the solution.
2. Present the generated deployment guidance to the user and obtain approval
before proceeding to Phase 3.
## Phase 3: Solution validation
### Task 3.1: Pre-deployment validation
1. Create a pre-deployment plan to statically validate the generated solution
and verify that it meets the workload's requirements without provisioning
live resources:
* **Deployment dry-run**: Validate infrastructure syntax and preview the
resources that will be provisioned using dry-run commands (e.g.,
`terraform plan` or (where supported) the provider CLI's what-if or dry-run mode).
* **Architecture & policy analysis**: Perform static verification of
network routing topologies, firewall rules, and IAM enforcement against
best practices.
2. Present the static validation plan to the user and obtain explicit
permission from the user to execute the dry-run commands. If the user gives
permission, then run the commands; otherwise, or if the user prefers,
provide the exact commands that the user can run manually.
3. Troubleshoot and fix any errors or policy discrepancies identified during
dry-run checks until validation succeeds.
4. Proceed to Task 3.2
### Task 3.2: Runtime validation (Post-deployment)
1. Ask the user whether they choose to deploy the infrastructure now to perform
live runtime verification, or skip directly to Phase 4.
2. **If the user chooses to deploy the infrastructure**:
* After the user deploys the infrastructure, generate runtime verification
commands (using tools like `curl`, `ping`, or the provider CLI) and provide them
to the user to execute, to test live endpoint reachability, networking
paths, and load balancer routing.
* Troubleshoot any deployment or runtime routing issues until checks pass.
3. Proceed to Phase 4.
## Phase 4: Solution packaging and presentation
Package all the generated text and code artifacts for final presentation.
1. Consolidate the text artifacts that were generated in Phase 2 and Phase 3
into a single Markdown file named `solution-architecture-guide.md`, based on
the template in `assets/output-template.md`.
2. Request the user's permission to write the code files in the user's
workspace.
3. After the user gives permission, write the code files in the user's
workspace.

View File

@@ -0,0 +1,120 @@
<!-- Use this template to compile the content that you generate based on the
instructions in `SKILL.md`. -->
# Azure solution architecture: [Workload Name]
## 1. Executive summary and workload overview
[A brief description of the workload, its business goals, and the high-level
solution architecture proposed.]
## 2. Requirements and current state
### 2.1. Functional requirements
* **Business processes**: [Details of the business processes supported]
* **Activities and use cases**: [Details of the key activities and use cases]
### 2.2. Non-functional requirements
* **Security**: [Details of the security requirements including compliance,
encryption, access control requirements]
* **Reliability**: [Details of the reliability requirements including SLA,
RTO/RPO, backup, redundancy requirements]
* **Cost**: [Details of the cost constraints and pricing models]
* **Operations**: [Details of the operational requirements including
monitoring, logging, deployment, maintenance requirements]
* **Performance**: [Details of the performance requirements including latency,
throughput, scaling requirements]
* **Sustainability**: [Details of the sustainability requirements including
carbon footprint, resource optimization requirements]
### 2.3. Current state
[If applicable, describe the current on-premises or other-cloud architecture.]
* **Current infrastructure**: [Details of existing setup]
* **Pain points and drivers for migration/redesign**: [Details of the drivers
for migration/redesign]
### 2.4. Dependencies
* **Internal dependencies**: [Details of internal dependencies including other
workloads and internal services]
* **External dependencies**: [Details of external dependencies including
third-party products and on-premises tools]
## 3. Technical decomposition of the workload
[Technical decomposition of the workload components, breaking down the
application into logical services or layers.]
## 4. Proposed solution architecture
### 4.1. Azure products and features mapping
[Identify Azure products and features mapped to the technical
components. For each component, justify the selection, note alternatives
considered, and describe the pros and cons of the recommended product/feature
and alternatives.]
| Component | Recommended Azure product/feature | Justification and citations | Alternatives considered | Pros and cons of alternatives |
| :--- | :--- | :--- | :--- | :--- |
| **[Component Name]** | **[Product Name]** | [Why this product is chosen, citing official docs] | [Alternative product] | **Pros**: ... <br> **Cons**: ... |
### 4.2. Architecture diagram
[Architecture diagram in Mermaid format showing the relationships and flows
between the components of the architecture.]
```mermaid
%% Example structure
graph TD
User([User]) --> Web[Load Balancer]
Web --> App[Application Layer]
App --> DB[(Database)]
```
### 4.3. Architecture description
[Detailed description of the architecture. Describe the task flow and data
flow between the components of the architecture.]
* **Data flow**: [Describe the flow of data.]
* **Tasks/control flow**: [Describe the flow of tasks/control.]
## 5. Design and configuration recommendations
[Best practices and configuration recommendations for each pillar of the
Azure Architecture Framework.]
### 5.1. Security
* **Access control**: [E.g., Azure RBAC, least privilege]
* **Data protection**: [E.g., Encryption at rest/in transit, Key Vault]
* **Network Security**: [E.g., Virtual networks, NSGs, Azure Firewall, Private Link]
### 5.2. Reliability
* **Redundant deployment**: [E.g., Multi-region/regional deployment, load
balancing]
* **Backup and DR**: [E.g., Backups, failover procedures, RTO/RPO strategies]
### 5.3. Operational Excellence
* **Monitoring and logging**: [E.g., Azure Monitor, Log Analytics, dashboards]
* **Infrastructure as Code (IaC)**: [E.g., Terraform, Bicep]
### 5.4. Cost Optimization
* **Sizing and scaling**: [E.g., Autoscaling configuration, right-sizing resources]
* **Pricing models**: [E.g., Reservations, savings plans, Spot VMs]
### 5.5. Performance Efficiency
* **Caching and CDN**: [E.g., Azure Front Door, Azure Managed Redis]
* **Database and query optimization**: [E.g., Partitioning, indexing, caching]
## 6. Deployment guidance
[Instructions and code for deploying the architecture.]
### 6.1. Deployment prerequisites
* [Prerequisite 1: E.g., Registering resource providers]
* [Prerequisite 2: E.g., Installing SDK/tools]
* ...and so on
### 6.2. Step-by-step deployment instructions
1. [Step 1: E.g., Authenticate with Azure]
2. [Step 2: E.g., Initialize Terraform]
3. [Step 3: E.g., Apply Terraform configuration]
## 7. Validation plan
[Details of the steps to verify that the generated solution meets the workload's
requirements. Also include references to any validation scripts that were
generated.]
## 8. References
* [E.g., Regional managed instance groups](https://docs.cloud.google.com/compute/docs/instance-groups/regional-migs)

View File

@@ -0,0 +1,119 @@
---
name: azure-waf-cost-optimization
metadata:
category: WellArchitectedFramework
description: >-
Generates cost optimization guidance for Azure workloads based on the Cost
Optimization pillar of the Azure Well-Architected Framework. Use when
estimating, governing or reducing Azure spending, choosing pricing models,
or balancing cost with other requirements.
---
# Azure Well-Architected Framework skill for the Cost Optimization pillar
## Overview
The Cost Optimization pillar seeks a good return on investment: spending that
matches the value a workload delivers, while it still meets its functional and
non-functional requirements. It is a continuous practice, tied to the wider
governance of cost management.
## Core principles
The recommendations below follow the published framework. Written for this agent from Microsoft's published design review checklist. Codes are Microsoft's.
- **Build financial responsibility** (CO:01): Train people, encourage
accountability and invest in tooling. Grounding document:
https://learn.microsoft.com/azure/well-architected/cost-optimization/create-culture-financial-responsibility
- **Maintain a cost model** (CO:02): Estimate initial cost, run rate and ongoing
cost, with a budget and buffer. Grounding document:
https://learn.microsoft.com/azure/well-architected/cost-optimization/cost-model
- **Collect and review cost data** (CO:03): Capture daily cost, trends and
forecasts, and automate alerts on thresholds and anomalies. Grounding
document:
https://learn.microsoft.com/azure/well-architected/cost-optimization/collect-review-cost-data
- **Set guardrails** (CO:04): Use release gates, policy, limits and access
controls, automated where possible. Grounding document:
https://learn.microsoft.com/azure/well-architected/cost-optimization/set-spending-guardrails
- **Get the best rates** (CO:05): Compare regions, tiers, consumption and
commitment pricing, and license portability. Grounding document:
https://learn.microsoft.com/azure/well-architected/cost-optimization/get-best-rates
- **Align usage to billing increments** (CO:06): Understand each meter and shape
use to it. Grounding document:
https://learn.microsoft.com/azure/well-architected/cost-optimization/align-usage-to-billing-increments
- **Optimize components** (CO:07): Remove or improve legacy, unneeded and
underused features and resources. Grounding document:
https://learn.microsoft.com/azure/well-architected/cost-optimization/optimize-component-costs
- **Optimize environments** (CO:08): Set availability, licensing and hours by
environment, with strategic trade-offs outside production. Grounding document:
https://learn.microsoft.com/azure/well-architected/cost-optimization/optimize-environment-costs
- **Optimize flows** (CO:09): Align each flow's cost with its priority.
Grounding document:
https://learn.microsoft.com/azure/well-architected/cost-optimization/optimize-flow-costs
- **Optimize data** (CO:10): Tier and retain data by priority, and review
replication, backups and formats. Grounding document:
https://learn.microsoft.com/azure/well-architected/cost-optimization/optimize-data-costs
- **Optimize code** (CO:11): Meet requirements with fewer or cheaper resources.
Grounding document:
https://learn.microsoft.com/azure/well-architected/cost-optimization/optimize-code-costs
- **Optimize scaling** (CO:12): Compare scaling configurations against the cost
model and the limits of each scale unit. Grounding document:
https://learn.microsoft.com/azure/well-architected/cost-optimization/optimize-scaling-costs
- **Optimize personnel time** (CO:13): Reduce effort on low-priority tasks
without degrading outcomes. Grounding document:
https://learn.microsoft.com/azure/well-architected/cost-optimization/optimize-personnel-time
- **Consolidate** (CO:14): Increase density, and use shared services outside the
workload. Grounding document:
https://learn.microsoft.com/azure/well-architected/cost-optimization/consolidation
## Relevant products
The following are _examples_ of products relevant to this pillar:
- **Visibility**: Microsoft Cost Management, budgets, cost anomaly alerts, tags
- **Rates**: Azure Reservations, Azure savings plans, Azure Hybrid Benefit, Spot
Virtual Machines
- **Estimation**: Azure Pricing Calculator
- **Data**: Blob Storage access tiers and lifecycle management
- **Governance**: Azure Policy, Azure Advisor
## Workload assessment questions
Ask appropriate questions to understand the requirements and constraints of the
workload and the organization. Choose from this list:
- What is the monthly budget, and who owns it?
- What drives the workload's cost, and how predictable is its usage?
- Is the demand steady enough for a reservation or savings plan?
- Which existing licenses could be reused?
- What are the hours and availability needs of non-production environments?
- How long must data be kept, and how often is it read?
- How are costs tagged and attributed?
- Which cost trade-offs against reliability or performance are acceptable?
## Validation checklist
Use this checklist to evaluate the architecture against this pillar:
- A cost model exists, with a budget and buffer.
- Budgets and anomaly alerts are configured.
- Resources are tagged so cost can be attributed.
- Sizing is justified by usage, not guessed.
- Autoscaling and scale-to-zero are used where demand varies.
- Reservations, savings plans and Azure Hybrid Benefit are considered.
- Non-production environments are reduced or shut down outside hours.
- Storage lifecycle rules follow data retention needs.
- Data transfer between regions is estimated.

View File

@@ -0,0 +1,103 @@
---
name: azure-waf-operational-excellence
metadata:
category: WellArchitectedFramework
description: >-
Generates guidance for operating Azure workloads, based on the Operational
Excellence pillar of the Azure Well-Architected Framework. Use when
designing DevOps practices, infrastructure as code, deployment pipelines,
observability, incident management or automation for an Azure workload.
---
# Azure Well-Architected Framework skill for the Operational Excellence pillar
## Overview
The Operational Excellence pillar supports repeatable, reliable and safe
deployments of infrastructure and code. It starts with a DevOps approach,
automates what is routine, keeps people for what benefits from their judgement,
and uses observability both to watch health and to test the design.
## Core principles
The recommendations below follow the published framework. Written for this agent from Microsoft's published design review checklist. Codes are Microsoft's.
- **Define standard practices** (OE:01): Align specialties to clear practices,
with accountability and a blameless culture. Grounding document:
https://learn.microsoft.com/azure/well-architected/operational-excellence/devops-culture
- **Standardize operations** (OE:02): Make routine, ad-hoc and emergency tasks
consistent and predictable. Grounding document:
https://learn.microsoft.com/azure/well-architected/operational-excellence/formalize-operations-tasks
- **Formalize development** (OE:03): Make the lifecycle from idea to delivery
transparent. Grounding document:
https://learn.microsoft.com/azure/well-architected/operational-excellence/formalize-development-practices
- **Standardize tools** (OE:04): Set source control, design patterns,
documentation and style. Grounding document:
https://learn.microsoft.com/azure/well-architected/operational-excellence/tools-processes
- **Use infrastructure as code** (OE:05): Prefer declarative, modular code with
quality assurance. Grounding document:
https://learn.microsoft.com/azure/well-architected/operational-excellence/infrastructure-as-code-design
- **Build a supply chain** (OE:06): Promote changes through automated, tested
pipelines and quality gates. Grounding document:
https://learn.microsoft.com/azure/well-architected/operational-excellence/workload-supply-chain
- **Design monitoring** (OE:07): Capture telemetry, metrics and logs from
infrastructure and code. Grounding document:
https://learn.microsoft.com/azure/well-architected/operational-excellence/observability
- **Manage incidents** (OE:08): Set roles, procedures and an architecture for
fast detection, diagnosis and recovery. Grounding document:
https://learn.microsoft.com/azure/well-architected/operational-excellence/incident-response
- **Test to business objectives** (OE:09): Adopt testing practices that uphold
quality standards. Grounding document:
https://learn.microsoft.com/azure/well-architected/operational-excellence/testing
- **Automate reliably** (OE:10): Automate repetitive tasks with clear return,
keeping automation secure and maintainable. Grounding document:
https://learn.microsoft.com/azure/well-architected/operational-excellence/enable-automation
- **Deploy safely** (OE:11): Release small increments with gates and progressive
exposure, with a plan for emergencies. Grounding document:
https://learn.microsoft.com/azure/well-architected/operational-excellence/safe-deployments
## Relevant products
The following are _examples_ of products relevant to this pillar:
- **Delivery**: GitHub Actions, Azure Pipelines, deployment slots, Azure
Deployment Environments
- **Infrastructure as code**: Terraform, Bicep
- **Observability**: Azure Monitor, Log Analytics, Application Insights, Managed
Grafana
- **Operations**: Azure Automation, Update Manager
## Workload assessment questions
Ask appropriate questions to understand the requirements and constraints of the
workload and the organization. Choose from this list:
- Who owns the workload in production, and how is on-call organized?
- How do changes reach production, and how are they rolled back?
- Is all infrastructure defined as code?
- What logs, metrics and traces are collected, and where?
- How are incidents declared, run and reviewed?
- Which routine tasks are still manual?
- How are environments kept consistent?
## Validation checklist
Use this checklist to evaluate the architecture against this pillar:
- Ownership and on-call are stated.
- All infrastructure is deployed from code in source control.
- Pipelines test and promote changes through environments.
- Deployments are incremental, with a tested rollback.
- Telemetry is central, and dashboards and alerts exist.
- Incident roles and runbooks exist, with blameless reviews.
- Routine tasks are automated where it pays.

View File

@@ -0,0 +1,107 @@
---
name: azure-waf-performance-efficiency
metadata:
category: WellArchitectedFramework
description: >-
Generates performance efficiency guidance for Azure workloads based on the
Performance Efficiency pillar of the Azure Well-Architected Framework. Use
when setting performance targets, planning capacity, selecting service
tiers, or designing scaling, partitioning and performance testing on Azure.
---
# Azure Well-Architected Framework skill for the Performance Efficiency pillar
## Overview
The Performance Efficiency pillar keeps every interaction efficient as demand
grows. Every system has a limit beyond which it needs redesign or human work, so
targets, capacity and scale units are decided in the design and tested in a
production-like environment.
## Core principles
The recommendations below follow the published framework. Written for this agent from Microsoft's published design review checklist. Codes are Microsoft's.
- **Define performance targets** (PE:01): Set numeric targets, tied to
requirements, for all flows. Grounding document:
https://learn.microsoft.com/azure/well-architected/performance-efficiency/performance-targets
- **Plan capacity** (PE:02): Plan ahead of seasonal change, releases, campaigns
and events. Grounding document:
https://learn.microsoft.com/azure/well-architected/performance-efficiency/capacity-planning
- **Select the right services** (PE:03): Choose services and tiers that reach
the targets and absorb expected change. Grounding document:
https://learn.microsoft.com/azure/well-architected/performance-efficiency/select-services
- **Measure consistently** (PE:04): Compare behaviour over time against
baselines to find degradation. Grounding document:
https://learn.microsoft.com/azure/well-architected/performance-efficiency/monitoring
- **Optimize scaling and partitioning** (PE:05): Base both on the workload's
scale unit. Grounding document:
https://learn.microsoft.com/azure/well-architected/performance-efficiency/scale-partition
- **Test performance** (PE:06): Test regularly in a production-like environment.
Grounding document:
https://learn.microsoft.com/azure/well-architected/performance-efficiency/performance-test
- **Optimize code and infrastructure** (PE:07): Offload responsibilities to the
platform. Grounding document:
https://learn.microsoft.com/azure/well-architected/performance-efficiency/optimize-code-infrastructure
- **Optimize data** (PE:08): Tune stores, partitions and indexes for actual use.
Grounding document:
https://learn.microsoft.com/azure/well-architected/performance-efficiency/optimize-data-performance
- **Prioritize critical flows** (PE:09): Give the most important flows the most
resources and attention. Grounding document:
https://learn.microsoft.com/azure/well-architected/performance-efficiency/prioritize-critical-flows
- **Optimize operational tasks** (PE:10): Limit the effect of scans, rotations,
backups, reindexing and deployments. Grounding document:
https://learn.microsoft.com/azure/well-architected/performance-efficiency/optimize-operational-tasks
- **Respond to live issues** (PE:11): Set communication and responsibility, and
learn from each event. Grounding document:
https://learn.microsoft.com/azure/well-architected/performance-efficiency/respond-live-performance-issues
- **Keep optimizing** (PE:12): Watch components that deteriorate over time, such
as databases and networking. Grounding document:
https://learn.microsoft.com/azure/well-architected/performance-efficiency/continuous-performance-optimize
## Relevant products
The following are _examples_ of products relevant to this pillar:
- **Scaling**: Autoscale, Virtual Machine Scale Sets, AKS cluster autoscaler,
KEDA
- **Delivery**: Azure Front Door, Azure CDN
- **Data**: Azure Managed Redis, Cosmos DB partitioning, Azure SQL read replicas
- **Testing**: Azure Load Testing, Application Insights
## Workload assessment questions
Ask appropriate questions to understand the requirements and constraints of the
workload and the organization. Choose from this list:
- What are the numeric targets for latency, throughput and concurrency?
- What is the expected peak, and when does it happen?
- What is the workload's scale unit?
- Which flows matter most under load?
- Where is data read and written, and at what rate?
- Where are users, relative to the workload's regions?
- How is performance tested before release?
## Validation checklist
Use this checklist to evaluate the architecture against this pillar:
- Each critical flow has a numeric target.
- Capacity is planned against a stated peak, and quotas are checked.
- Service tiers are justified against the targets.
- Scaling is automatic, with limits set.
- Data partitioning and caching match the access pattern.
- Performance baselines are recorded and compared.
- Load tests run in a production-like environment.
- Routine operations are scheduled away from peak.

View File

@@ -0,0 +1,114 @@
---
name: azure-waf-reliability
metadata:
category: WellArchitectedFramework
description: >-
Generates guidance for reliability, resilience, availability, redundancy,
failure recovery and disaster recovery for Azure workloads, based on the
Reliability pillar of the Azure Well-Architected Framework. Use when
evaluating, designing or improving how an Azure workload withstands and
recovers from failure.
---
# Azure Well-Architected Framework skill for the Reliability pillar
## Overview
The Reliability pillar helps a workload withstand faults and recover to a
working state within agreed targets. Decisions start from business requirements,
expressed as availability and recoverability targets, and they are weighed flow
by flow, because not every part of a workload needs the same protection.
## Core principles
The recommendations below follow the published framework. Written for this agent from Microsoft's published design review checklist. Codes are Microsoft's.
- **Keep the design simple** (RE:01): Add only the complexity that a business
goal justifies, and prefer platform capabilities to custom code. Grounding
document:
https://learn.microsoft.com/azure/well-architected/reliability/simplify
- **Rate user and system flows** (RE:02): Identify the flows through the
workload and rate each for criticality, so effort goes to what matters most.
Grounding document:
https://learn.microsoft.com/azure/well-architected/reliability/identify-flows
- **Analyse failure modes** (RE:03): List dependencies and failure points, with
a mitigation for each. Grounding document:
https://learn.microsoft.com/azure/well-architected/reliability/failure-mode-analysis
- **Set reliability and recovery targets** (RE:04): Define SLOs, RTO and RPO,
and build the health model on them. Grounding document:
https://learn.microsoft.com/azure/well-architected/reliability/metrics
- **Add redundancy where it counts** (RE:05): Replicate compute, data and
network across availability zones, or regions, in proportion to each flow's
criticality. Grounding document:
https://learn.microsoft.com/azure/well-architected/reliability/redundancy
- **Scale in time** (RE:06): Scale the application, data and infrastructure from
actual or predicted use, with little manual work. Grounding document:
https://learn.microsoft.com/azure/well-architected/reliability/scaling
- **Self-preserve and self-heal** (RE:07): Use retries, circuit breakers, queues
and health-based routing so the workload degrades gracefully and recovers by
itself. Grounding document:
https://learn.microsoft.com/azure/well-architected/reliability/self-preservation
- **Test resiliency** (RE:08): Inject faults with chaos engineering to prove the
workload withstands them and recovers within target. Grounding document:
https://learn.microsoft.com/azure/well-architected/reliability/reliability-test
- **Plan disaster recovery** (RE:09): Keep structured, documented and rehearsed
plans that cover every component and the system as a whole. Grounding
document:
https://learn.microsoft.com/azure/well-architected/reliability/disaster-recovery
- **Measure health continuously** (RE:10): Track uptime and reliability
indicators across components and critical flows, and keep the data for
detection and post-incident analysis. Grounding document:
https://learn.microsoft.com/azure/well-architected/reliability/monitoring
## Relevant products
The following are _examples_ of products relevant to this pillar:
- **Compute**: Availability zones, Virtual Machine Scale Sets, AKS, App Service,
Container Apps
- **Networking**: Azure Front Door, Traffic Manager, Application Gateway, Azure
Load Balancer
- **Data**: Zone-redundant storage, geo-redundant storage, Azure SQL
auto-failover groups, Cosmos DB multi-region
- **Recovery**: Azure Backup, Azure Site Recovery
- **Testing and health**: Azure Chaos Studio, Azure Monitor, Azure Service
Health, Azure Resource Health
## Workload assessment questions
Ask appropriate questions to understand the requirements and constraints of the
workload and the organization. Choose from this list:
- Which user and system flows matter most to the business, and what happens if
each one stops?
- What are the SLO, RTO and RPO for each critical flow?
- Which dependencies, inside and outside the workload, can fail, and how is each
failure handled?
- How is the workload deployed across availability zones and regions?
- How does it scale, and what are its quota and capacity limits?
- How are backups taken and restores tested?
- How often is failover rehearsed, and with what result?
- How is workload health measured and reported?
## Validation checklist
Use this checklist to evaluate the architecture against this pillar:
- Critical flows are named and rated, and each has a target.
- Failure mode analysis exists for the critical flows.
- No critical flow depends on a single instance, zone or unmanaged dependency.
- Zonal or regional redundancy matches the stated SLO, RTO and RPO.
- Autoscaling is configured, and quotas are checked against peak demand.
- Transient faults are handled with retries, timeouts and circuit breakers.
- Backups exist for all stateful components, and restores are tested.
- The disaster recovery plan is documented and rehearsed.
- Health signals exist for each critical flow, with alerts.

View File

@@ -0,0 +1,120 @@
---
name: azure-waf-security
metadata:
category: WellArchitectedFramework
description: >-
Generates security guidance for Azure workloads based on the Security pillar
of the Azure Well-Architected Framework and the Zero Trust model. Use when
evaluating workloads, identifying security requirements, and recommending
identity, network, data protection, secrets and security operations
controls.
---
# Azure Well-Architected Framework skill for the Security pillar
## Overview
The Security pillar protects the confidentiality, integrity and availability of
a workload, aligned with Zero Trust: verify explicitly, use least privilege, and
assume breach. Segmentation, identity and encryption are decided in the design,
and threat detection and response are planned before the workload runs.
## Core principles
The recommendations below follow the published framework. Written for this agent from Microsoft's published design review checklist. Codes are Microsoft's.
- **Establish a security baseline** (SE:01): Align to compliance requirements,
industry standards and platform recommendations, and measure against it
regularly. Grounding document:
https://learn.microsoft.com/azure/well-architected/security/establish-baseline
- **Secure the development lifecycle** (SE:02): Build security into design,
coding, build and release. Grounding document:
https://learn.microsoft.com/azure/well-architected/security/secure-development-lifecycle
- **Classify data** (SE:03): Label data and the systems that process it, and let
classification drive the design. Grounding document:
https://learn.microsoft.com/azure/well-architected/security/data-classification
- **Segment deliberately** (SE:04): Create perimeters across networks, roles,
workload identities and resource organization. Grounding document:
https://learn.microsoft.com/azure/well-architected/security/segmentation
- **Control identity and access** (SE:05): Make access strict, conditional and
auditable for users, operators and components, granting only what is
necessary. Grounding document:
https://learn.microsoft.com/azure/well-architected/security/identity-access
- **Control network traffic** (SE:06): Isolate and filter ingress and egress,
east-west and north-south, with defense in depth. Grounding document:
https://learn.microsoft.com/azure/well-architected/security/networking
- **Encrypt data** (SE:07): Use modern standard methods scoped to
classification, preferring platform encryption. Grounding document:
https://learn.microsoft.com/azure/well-architected/security/encryption
- **Harden resources** (SE:08): Reduce surface area and tighten configuration to
raise an attacker's cost. Grounding document:
https://learn.microsoft.com/azure/well-architected/security/harden-resources
- **Protect secrets** (SE:09): Harden storage, restrict and audit access, and
rotate regularly, with an emergency path. Grounding document:
https://learn.microsoft.com/azure/well-architected/security/application-secrets
- **Monitor for threats** (SE:10): Use platform-integrated detection that alerts
and feeds security operations. Grounding document:
https://learn.microsoft.com/azure/well-architected/security/monitor-threats
- **Test security** (SE:11): Combine prevention, validation of controls and
tests of detection. Grounding document:
https://learn.microsoft.com/azure/well-architected/security/test
- **Prepare incident response** (SE:12): Define and rehearse procedures for
localized issues through to disaster recovery, with named owners. Grounding
document:
https://learn.microsoft.com/azure/well-architected/security/incident-response
## Relevant products
The following are _examples_ of products relevant to this pillar:
- **Identity**: Microsoft Entra ID, managed identities, Azure RBAC, Privileged
Identity Management, Conditional Access
- **Network**: Virtual networks, network security groups, Azure Firewall,
Private Link, Azure DDoS Protection, Web Application Firewall
- **Data**: Azure Key Vault, Managed HSM, customer-managed keys, Microsoft
Purview
- **Detection**: Microsoft Defender for Cloud, Microsoft Sentinel
- **Governance**: Azure Policy, management groups
## Workload assessment questions
Ask appropriate questions to understand the requirements and constraints of the
workload and the organization. Choose from this list:
- Which compliance frameworks and data residency rules apply?
- How is data classified, and where is the most sensitive data?
- Who needs access, how do they authenticate, and how is privileged access
controlled?
- How do workload identities authenticate, and are any long-lived secrets in
use?
- What is exposed to the internet, and how is egress controlled?
- Who manages encryption keys, and how are they rotated?
- How are threats detected, and who responds?
- How is the software supply chain secured?
## Validation checklist
Use this checklist to evaluate the architecture against this pillar:
- A security baseline is named and measured against.
- Data is classified, and the classification drives controls.
- Workload identities are managed identities where the service supports them.
- Role assignments follow least privilege at the narrowest scope.
- Public endpoints are justified, and PaaS services use Private Link where
needed.
- Ingress and egress are filtered and logged.
- Data is encrypted at rest and in transit, and key ownership is stated.
- Secrets are held in Key Vault, with rotation.
- Defender for Cloud and central logging cover the workload.
- Incident response has named owners and is rehearsed.

View File

@@ -0,0 +1,38 @@
---
name: cloud-discovery
description: >-
Discovers and documents the current state of a workload's existing cloud
environment through the Cloud provider's read-only MCP discovery tools. Use
when requirements discovery needs the as-is architecture of resources that
already run in the user's cloud project or account.
metadata:
scope: requirements-discovery
---
# Cloud discovery
Describe what actually exists, so requirements rest on facts rather than recollection.
## Before you discover
Your discovery tools read the user's live cloud environment. The first call may pause the Execution to ask the user's permission. When permission is refused, work only from what the user tells you.
Ask the user which project, subscription or account and which regions hold the workload, unless the request already says. Discover only there.
## Steps
1. **Inventory first.** Use the broadest inventory tool available (an asset inventory or project search) to list the resource types and counts in scope.
2. **Detail what matters.** For each resource type that belongs to the workload, call the product's list and get tools for configuration: sizes, regions and zones, scaling, networking, identities and their roles.
3. **Map relationships.** Connect compute to its data stores, messaging, load balancers and identities, from configuration you have read, not from names alone.
4. **Record gaps.** When a tool reports a discovery gap (a server that's unavailable, an API that isn't enabled, a permission that's missing), list it under `Assumptions / discovery gaps` with the resource type it leaves unknown.
## Writing the current state
Under the `Current state` heading, give:
- a component inventory table: component, resource type, location, key configuration
- the relationships between components as a short list
- observed operational signals, such as alert policies and dashboards, when discovered
- `Assumptions / discovery gaps`
Report what exists, not what should change; recommendations belong to later Deliverables. Never include secrets, credentials, object contents or database rows, even when a tool returns them.

View File

@@ -0,0 +1,56 @@
---
name: google-cloud-iac-modules
description: >-
Published Terraform modules from the terraform-google-modules organisation
that are known to validate against the pinned hashicorp/google provider: VPC
network with Cloud NAT, private Cloud SQL for PostgreSQL, Cloud Storage
buckets and Cloud KMS. Use when writing Terraform for an Element that one of
these modules covers, to decide whether a module or plain resources fit and to
call the module correctly.
metadata:
scope: deployment guidance, validation results
provider: hashicorp/google 8.6.0
modules: terraform-google-modules
---
# Google Cloud IaC modules
You have this Skill because this Execution opted into published modules: `terraform_modules` is true in your context. Without that, infrastructure code is plain resources and a module call is refused.
A published module replaces several resources that must be wired together with one call that a team already maintains. It also hides the resources a Check is about. Use one only where the first outweighs the second.
## When to use a module
Use a module when **all** of these hold:
1. It is in the table below. Those are the only modules checked against `hashicorp/google` 8.6.0; a test validates each one's example here.
2. It replaces three or more resources that depend on each other, such as a network with its subnets and firewall rules, or a private database with the peering it needs.
3. Every Check on the Elements it covers can be met through one of its inputs. Confirm with `terraform_module`.
Otherwise write the resources directly, from the patterns Skill. A single resource, such as one service account, one topic or one secret, is always written directly.
| For | Module | Version | Reference |
| --- | --- | --- | --- |
| VPC, subnets, firewall rules, and Cloud NAT | `terraform-google-modules/network/google` and `terraform-google-modules/cloud-nat/google` | 18.3.1, 7.1.0 | `references/network.md` |
| Cloud SQL for PostgreSQL on a private address | `terraform-google-modules/sql-db/google//modules/postgresql` with `//modules/private_service_access` | 28.3.0 | `references/cloud-sql.md` |
| A Cloud Storage bucket with retention, lifecycle, encryption and grants | `terraform-google-modules/cloud-storage/google//modules/simple_bucket` | 12.4.1 | `references/cloud-storage.md` |
| A key ring, keys and their grants | `terraform-google-modules/kms/google` | 4.2.1 | `references/kms.md` |
Not usable with this provider version, so write these directly: the load balancer (`lb-http`), Pub/Sub, BigQuery, GKE, log export and the function modules all require `google` below 8. `terraform_module` says so for any module you look up.
## Rules for every module call
- `source` is `terraform-google-modules/<name>/google`, with `//modules/<submodule>` when the table gives one. `version` is one exact version. `terraform_validate` refuses any other source, a Git URL, a local path or a version range.
- Keep `terraform/versions.tf` from the patterns Skill unchanged. A module's own provider requirements are met by it.
- Pass every environment-specific value from a variable, as for resources.
- Before using an input the reference does not show, call `terraform_module` with `find` set to its name.
- Set every input a Check depends on, even when the module's default already gives that value. A Check is verified from a value written in the code; a default left unset can only be argued from the module's documentation, and changes when the module does.
- A module takes names, not always ids: read which one an input wants. Pass another module's output where one depends on the other, so Terraform orders them.
## Checks on an Element a module creates
A Check is still about the resource: "the instance has no public IP address". The code meets it through a module input.
- In `implementation.json`, `address` names the module and the input: `module.database.ip_configuration.ipv4_enabled`.
- When no input sets what a Check needs, the module does not fit that Element. Write its resources directly; do not mark the Check unimplementable, since the resource type does have the setting.
- When validating, read the input's value in the code and confirm with `terraform_module` what that input sets. An input left at its default is judged by the default the lookup shows, and the verdict says the value is a default and not set in the code. A Check is not verifiable only when neither the code nor the module's documentation shows what the resource will get.

View File

@@ -0,0 +1,102 @@
# Cloud SQL for PostgreSQL on a private address
A PostgreSQL instance reachable only inside a VPC, with the private services access it needs. Replaces a reserved range, a service networking connection, the instance, its database and its user.
- The instance must wait for the peering: pass `module.private_access.peering_completed` in `module_depends_on`.
- `ip_configuration.ipv4_enabled = false` is what removes the public address. `private_network` is the network's self link.
- `availability_type = "REGIONAL"` gives a standby in a second zone.
- `deletion_protection` is the Terraform guard; `deletion_protection_enabled` is the guard in the API. Set both from a variable.
- With `enable_default_user = true` the module generates a password and exposes it as an output. Prefer IAM database authentication: set `enable_default_user = false`, add the `cloudsql.iam_authentication` flag and list `iam_users`.
- `random_instance_name = true` adds a suffix, which lets an instance be recreated: a deleted instance's name is reserved for a week.
```hcl
variable "project_id" {
type = string
description = "Project to deploy into."
}
variable "region" {
type = string
description = "Region for regional resources."
}
variable "network_name" {
type = string
description = "Name of the VPC the database is reached from."
}
variable "network_self_link" {
type = string
description = "Self link of that VPC."
}
variable "app_service_account_email" {
type = string
description = "Service account that connects to the database."
}
variable "deletion_protection" {
type = bool
description = "Whether the instance is protected from deletion."
default = true
}
module "private_access" {
source = "terraform-google-modules/sql-db/google//modules/private_service_access"
version = "28.3.0"
project_id = var.project_id
vpc_network = var.network_name
prefix_length = 20
}
module "database" {
source = "terraform-google-modules/sql-db/google//modules/postgresql"
version = "28.3.0"
project_id = var.project_id
region = var.region
name = "workload"
random_instance_name = true
database_version = "POSTGRES_16"
edition = "ENTERPRISE"
tier = "db-custom-2-7680"
availability_type = "REGIONAL"
disk_autoresize = true
deletion_protection = var.deletion_protection
deletion_protection_enabled = var.deletion_protection
ip_configuration = {
ipv4_enabled = false
private_network = var.network_self_link
ssl_mode = "ENCRYPTED_ONLY"
}
backup_configuration = {
enabled = true
start_time = "02:00"
point_in_time_recovery_enabled = true
retained_backups = 14
retention_unit = "COUNT"
}
database_flags = [
{
name = "cloudsql.iam_authentication"
value = "on"
}
]
db_name = "app"
enable_default_user = false
iam_users = [
{
id = "app"
email = var.app_service_account_email
}
]
module_depends_on = [module.private_access.peering_completed]
}
```

View File

@@ -0,0 +1,68 @@
# Cloud Storage bucket
One bucket with its retention, lifecycle rules, encryption and grants. Use the module when the bucket has several of those; a plain bucket is one resource and is written directly.
- The module turns on uniform bucket-level access (`bucket_policy_only`) and `public_access_prevention = "enforced"` unless told otherwise.
- `retention_policy.retention_period` is in seconds. `is_locked = true` cannot be undone, and the bucket cannot then be deleted until every object has aged out: take it from a variable.
- `lifecycle_rules` takes `action` and `condition` as maps; condition values that are lists are given as comma-separated strings.
- `encryption.default_kms_key_name` needs the Cloud Storage service agent to hold the encrypter/decrypter role on the key first.
- `iam_members` grants on the bucket only, with `_iam_member`, so grants made elsewhere are kept.
```hcl
variable "project_id" {
type = string
description = "Project to deploy into."
}
variable "region" {
type = string
description = "Region for regional resources."
}
variable "lock_retention" {
type = bool
description = "Whether the retention policy is locked. Locking cannot be undone."
default = false
}
variable "reader_service_account_email" {
type = string
description = "Service account that reads the archive."
}
module "archive" {
source = "terraform-google-modules/cloud-storage/google//modules/simple_bucket"
version = "12.4.1"
project_id = var.project_id
name = "${var.project_id}-archive"
location = var.region
storage_class = "STANDARD"
versioning = true
force_destroy = false
retention_policy = {
is_locked = var.lock_retention
retention_period = 220752000
}
lifecycle_rules = [
{
action = {
type = "SetStorageClass"
storage_class = "ARCHIVE"
}
condition = {
age = 365
}
}
]
iam_members = [
{
role = "roles/storage.objectViewer"
member = "serviceAccount:${var.reader_service_account_email}"
}
]
}
```

View File

@@ -0,0 +1,54 @@
# Cloud KMS key ring and keys
A key ring, its keys and the grants that let products use them. Replaces a key ring, each key and each grant.
- The key ring's `location` must match the resource it protects.
- `prevent_destroy` is true unless set otherwise; keys and key rings cannot be deleted from Google Cloud in any case.
- `key_rotation_period` is in seconds with an `s`, such as `"7776000s"` for 90 days.
- `set_encrypters_for` and `set_decrypters_for` name the keys; `encrypters` and `decrypters` give one comma-separated string of members per key, in the same order.
- The member is the product's service agent, not the workload's service account.
- `module.kms.keys` is a map from key name to key id.
```hcl
variable "project_id" {
type = string
description = "Project to deploy into."
}
variable "region" {
type = string
description = "Region for regional resources."
}
data "google_storage_project_service_account" "this" {
project = var.project_id
}
module "kms" {
source = "terraform-google-modules/kms/google"
version = "4.2.1"
project_id = var.project_id
location = var.region
keyring = "workload"
keys = ["data"]
key_rotation_period = "7776000s"
prevent_destroy = true
set_encrypters_for = ["data"]
set_decrypters_for = ["data"]
encrypters = ["serviceAccount:${data.google_storage_project_service_account.this.email_address}"]
decrypters = ["serviceAccount:${data.google_storage_project_service_account.this.email_address}"]
}
resource "google_storage_bucket" "encrypted" {
project = var.project_id
name = "${var.project_id}-encrypted"
location = var.region
uniform_bucket_level_access = true
encryption {
default_kms_key_name = module.kms.keys["data"]
}
}
```

View File

@@ -0,0 +1,68 @@
# VPC network and Cloud NAT
A custom-mode VPC with its subnets and firewall rules, and outbound internet through Cloud NAT. Replaces a network, its subnetworks, a router, a NAT and each firewall rule.
- `subnets` is a list of objects whose values are all strings, including `"true"` for `subnet_private_access`.
- `network_name` is a name. Other resources want `module.network.network_self_link` or `network_id`; `subnets` is an output map keyed `"<region>/<subnet_name>"`.
- `ingress_rules` replaces the deprecated `firewall_rules`.
- The NAT module creates its router when `create_router = true`, and then needs `network`.
- Set `name` on the NAT. Left unset it gets a random suffix.
```hcl
variable "project_id" {
type = string
description = "Project to deploy into."
}
variable "region" {
type = string
description = "Region for regional resources."
}
module "network" {
source = "terraform-google-modules/network/google"
version = "18.3.1"
project_id = var.project_id
network_name = "workload"
routing_mode = "REGIONAL"
subnets = [
{
subnet_name = "workload"
subnet_ip = "10.10.0.0/24"
subnet_region = var.region
subnet_private_access = "true"
subnet_flow_logs = "true"
}
]
ingress_rules = [
{
name = "allow-health-checks"
source_ranges = ["130.211.0.0/22", "35.191.0.0/16"]
allow = [
{
protocol = "tcp"
ports = ["8080"]
}
]
}
]
}
module "nat" {
source = "terraform-google-modules/cloud-nat/google"
version = "7.1.0"
project_id = var.project_id
region = var.region
name = "workload-nat"
create_router = true
router = "workload-router"
network = module.network.network_self_link
log_config_enable = true
log_config_filter = "ERRORS_ONLY"
}
```

View File

@@ -0,0 +1,54 @@
---
name: google-cloud-iac-patterns
description: >-
Terraform patterns for Google Cloud products that validate against one pinned
version of the hashicorp/google provider: Cloud Run services and jobs,
Pub/Sub, Cloud Storage, IAM, Secret Manager, Cloud KMS, Cloud SQL,
networking, load balancing, Cloud Scheduler, Artifact Registry, Monitoring,
Firestore, BigQuery, Eventarc, GKE and API enablement. Use when writing
Terraform for a Google Cloud product, before writing the resource, to start
from a pattern whose arguments are known to be in the right place.
metadata:
scope: deployment guidance
provider: hashicorp/google 8.6.0
---
# Google Cloud IaC patterns
Every pattern here passes `terraform validate` against `hashicorp/google` 8.6.0. A test runs that on each of them, so an argument you copy from a pattern is in the right block.
## How to use them
1. Write `assets/versions.tf` to your working copy as `terraform/versions.tf`, unchanged. It pins the provider version these patterns and the `terraform_schema` tool describe. Declare the `project_id` and `region` variables it uses in `terraform/variables.tf`.
2. For each Element in the Target architecture, read the reference for its product with `load_skill_resource` and start from its pattern. Read only the references for products the Target architecture uses.
3. Change the pattern to meet the Element's Checks. For a setting the pattern does not show, call `terraform_schema` with `find` set to its name before you write it.
| Product | Reference |
| --- | --- |
| Enabling APIs | `references/project-services.md` |
| Service accounts and IAM grants | `references/iam.md` |
| Cloud Run service | `references/cloud-run-service.md` |
| Cloud Run job | `references/cloud-run-job.md` |
| Pub/Sub | `references/pubsub.md` |
| Cloud Storage | `references/cloud-storage.md` |
| Secret Manager | `references/secret-manager.md` |
| Cloud KMS | `references/kms.md` |
| Cloud SQL | `references/cloud-sql.md` |
| VPC networking | `references/networking.md` |
| External Application Load Balancer, TLS policy, firewall policy, Identity-Aware Proxy | `references/load-balancer.md` |
| Cloud Scheduler | `references/cloud-scheduler.md` |
| Artifact Registry | `references/artifact-registry.md` |
| Cloud Monitoring and Logging | `references/monitoring.md` |
| Firestore | `references/firestore.md` |
| BigQuery | `references/bigquery.md` |
| Eventarc | `references/eventarc.md` |
| Google Kubernetes Engine | `references/gke.md` |
A product with no reference has no pattern yet: write it from `terraform_schema` and the product documentation.
## Rules that hold for every product
- A Cloud Run service and a Cloud Run job are different resource types with different arguments. A setting of one is not a setting of the other. `references/cloud-run-job.md` lists what a job lacks.
- Grant a role with an `_iam_member` resource. An `_iam_binding` or `_iam_policy` resource removes grants made elsewhere.
- Give a Google-managed service agent its role before the resource that needs it, with `depends_on`. A key, a dead-letter topic and a push subscription all need one.
- Set `deletion_protection` from a variable on the resources that have it, so a test deployment can be removed.

View File

@@ -0,0 +1,15 @@
terraform {
required_version = ">= 1.9"
required_providers {
google = {
source = "hashicorp/google"
version = "8.6.0"
}
}
}
provider "google" {
project = var.project_id
region = var.region
}

View File

@@ -0,0 +1,65 @@
# Artifact Registry
A Docker repository with a cleanup policy, and the grant that lets a runtime identity pull from it.
- `format = "DOCKER"` for container images. The image path is `REGION-docker.pkg.dev/PROJECT/REPOSITORY/IMAGE`.
- Cleanup policies delete nothing while `cleanup_policy_dry_run` is `true`.
- `docker_config.immutable_tags = true` stops a tag being moved to a different image.
```hcl
variable "project_id" {
type = string
description = "Project to deploy into."
}
variable "region" {
type = string
description = "Region for regional resources."
}
resource "google_service_account" "runtime" {
project = var.project_id
account_id = "image-puller"
display_name = "Pulls workload images"
}
resource "google_artifact_registry_repository" "images" {
project = var.project_id
location = var.region
repository_id = "workload-images"
format = "DOCKER"
description = "Container images for the workload."
cleanup_policy_dry_run = false
docker_config {
immutable_tags = true
}
cleanup_policies {
id = "keep-recent"
action = "KEEP"
most_recent_versions {
keep_count = 10
}
}
cleanup_policies {
id = "delete-old-untagged"
action = "DELETE"
condition {
tag_state = "UNTAGGED"
older_than = "2592000s"
}
}
}
resource "google_artifact_registry_repository_iam_member" "runtime_pulls" {
project = var.project_id
location = google_artifact_registry_repository.images.location
repository = google_artifact_registry_repository.images.name
role = "roles/artifactregistry.reader"
member = google_service_account.runtime.member
}
```

View File

@@ -0,0 +1,92 @@
# BigQuery
A dataset, a partitioned and clustered table, and the grants for a writer and a reader.
- `location` is a region or `EU`/`US`, and cannot be changed. Queries cannot join datasets in different locations.
- `delete_contents_on_destroy = false` makes Terraform refuse to remove a dataset that still has tables.
- A table's `deletion_protection` is true unless set; take it from a variable so a test deployment can be removed.
- `schema` is a JSON string. Changing a column's type or mode replaces the table.
- Partition on a `DATE` or `TIMESTAMP` column with `time_partitioning`, and set `require_partition_filter` so a query cannot scan every partition. `expiration_ms` there removes old partitions.
- Grant on the dataset with `google_bigquery_dataset_iam_member`. A principal that runs queries also needs `roles/bigquery.jobUser` on the project.
- Do not mix `google_bigquery_dataset_iam_member` with `access` blocks on the dataset: each removes what the other sets.
```hcl
variable "project_id" {
type = string
description = "Project to deploy into."
}
variable "region" {
type = string
description = "Region for regional resources."
}
variable "writer_service_account_email" {
type = string
description = "Service account that loads rows."
}
variable "reader_service_account_email" {
type = string
description = "Service account that queries the dataset."
}
variable "deletion_protection" {
type = bool
description = "Whether the table is protected from deletion."
default = true
}
resource "google_bigquery_dataset" "analytics" {
project = var.project_id
dataset_id = "analytics"
location = var.region
delete_contents_on_destroy = false
default_table_expiration_ms = null
max_time_travel_hours = 168
}
resource "google_bigquery_table" "events" {
project = var.project_id
dataset_id = google_bigquery_dataset.analytics.dataset_id
table_id = "events"
deletion_protection = var.deletion_protection
require_partition_filter = true
clustering = ["event_type"]
time_partitioning {
type = "DAY"
field = "event_time"
expiration_ms = 34560000000
}
schema = jsonencode([
{ name = "event_id", type = "STRING", mode = "REQUIRED" },
{ name = "event_type", type = "STRING", mode = "REQUIRED" },
{ name = "event_time", type = "TIMESTAMP", mode = "REQUIRED" },
{ name = "payload", type = "JSON", mode = "NULLABLE" }
])
}
resource "google_bigquery_dataset_iam_member" "writer" {
project = var.project_id
dataset_id = google_bigquery_dataset.analytics.dataset_id
role = "roles/bigquery.dataEditor"
member = "serviceAccount:${var.writer_service_account_email}"
}
resource "google_bigquery_dataset_iam_member" "reader" {
project = var.project_id
dataset_id = google_bigquery_dataset.analytics.dataset_id
role = "roles/bigquery.dataViewer"
member = "serviceAccount:${var.reader_service_account_email}"
}
resource "google_project_iam_member" "reader_runs_queries" {
project = var.project_id
role = "roles/bigquery.jobUser"
member = "serviceAccount:${var.reader_service_account_email}"
}
```

View File

@@ -0,0 +1,95 @@
# Cloud Run job
`google_cloud_run_v2_job`: a task that runs to completion. It is a different resource type from a service, and its template is nested one level deeper.
What a job does not have. A Check that asks for one of these on a job cannot be met:
- `startup_cpu_boost` and `cpu_idle`. A job's `resources` block has `limits` only.
- `ingress`, `traffic`, `scaling`, `min_instance_count`, `max_instance_request_concurrency`. A job answers no requests.
- `liveness_probe`. A job's container has a `startup_probe` only.
Where a job's settings sit:
- `task_count` and `parallelism` are in `template`.
- `service_account`, `timeout`, `max_retries`, `execution_environment`, `vpc_access` and `encryption_key` are in `template.template`.
- `image`, `env`, `args`, `command` and `resources` are in `template.template.containers`.
- Whoever starts the job needs `roles/run.invoker` on it; Cloud Scheduler starts it with an HTTP call to the `:run` method.
```hcl
variable "project_id" {
type = string
description = "Project to deploy into."
}
variable "region" {
type = string
description = "Region for regional resources."
}
variable "image" {
type = string
description = "Container image reference, including the tag or digest."
}
variable "deletion_protection" {
type = bool
description = "Whether Terraform is prevented from deleting the job."
default = true
}
resource "google_service_account" "replay" {
project = var.project_id
account_id = "replay-job"
display_name = "Replay job"
}
resource "google_cloud_run_v2_job" "replay" {
project = var.project_id
name = "replay"
location = var.region
deletion_protection = var.deletion_protection
template {
task_count = 1
parallelism = 1
template {
service_account = google_service_account.replay.email
timeout = "3600s"
max_retries = 3
execution_environment = "EXECUTION_ENVIRONMENT_GEN2"
containers {
image = var.image
args = ["--mode=replay"]
resources {
limits = {
cpu = "1"
memory = "1Gi"
}
}
env {
name = "BATCH_SIZE"
value = "100"
}
}
}
}
}
resource "google_service_account" "operator" {
project = var.project_id
account_id = "replay-operator"
display_name = "Starts the replay job"
}
resource "google_cloud_run_v2_job_iam_member" "operator_runs_replay" {
project = var.project_id
location = google_cloud_run_v2_job.replay.location
name = google_cloud_run_v2_job.replay.name
role = "roles/run.invoker"
member = google_service_account.operator.member
}
```

View File

@@ -0,0 +1,144 @@
# Cloud Run service
`google_cloud_run_v2_service`: a long-running service that answers requests.
Where the settings sit, which is what goes wrong most often:
- `ingress`, `deletion_protection` and `traffic` are on the resource.
- `service_account`, `scaling`, `timeout`, `max_instance_request_concurrency`, `execution_environment`, `vpc_access` and `encryption_key` are in `template`.
- `image`, `env`, `ports`, `resources` and the probes are in `template.containers`.
- `cpu_idle` and `startup_cpu_boost` are in `template.containers.resources`, beside `limits`. They exist on a service only.
- `min_instance_count` and `max_instance_count` are in `template.scaling`.
- A secret is read through `env.value_source.secret_key_ref`; the service account needs `roles/secretmanager.secretAccessor` on that secret.
- Direct VPC egress is `template.vpc_access.network_interfaces`. A connector is `template.vpc_access.connector`. Use one of them.
- Public access is a grant of `roles/run.invoker` to `allUsers` together with `ingress = "INGRESS_TRAFFIC_ALL"`. A private service has neither.
```hcl
variable "project_id" {
type = string
description = "Project to deploy into."
}
variable "region" {
type = string
description = "Region for regional resources."
}
variable "image" {
type = string
description = "Container image reference, including the tag or digest."
}
variable "deletion_protection" {
type = bool
description = "Whether Terraform is prevented from deleting the service."
default = true
}
resource "google_service_account" "ingest" {
project = var.project_id
account_id = "ingest-service"
display_name = "Ingest service"
}
resource "google_secret_manager_secret" "signing_key" {
project = var.project_id
secret_id = "webhook-signing-key"
replication {
auto {}
}
}
resource "google_secret_manager_secret_iam_member" "ingest_reads_signing_key" {
project = var.project_id
secret_id = google_secret_manager_secret.signing_key.secret_id
role = "roles/secretmanager.secretAccessor"
member = google_service_account.ingest.member
}
resource "google_cloud_run_v2_service" "ingest" {
project = var.project_id
name = "ingest"
location = var.region
ingress = "INGRESS_TRAFFIC_ALL"
deletion_protection = var.deletion_protection
template {
service_account = google_service_account.ingest.email
timeout = "30s"
max_instance_request_concurrency = 80
execution_environment = "EXECUTION_ENVIRONMENT_GEN2"
scaling {
min_instance_count = 1
max_instance_count = 10
}
containers {
image = var.image
ports {
container_port = 8080
}
resources {
limits = {
cpu = "1"
memory = "512Mi"
}
cpu_idle = true
startup_cpu_boost = true
}
env {
name = "LOG_LEVEL"
value = "info"
}
env {
name = "SIGNING_KEY"
value_source {
secret_key_ref {
secret = google_secret_manager_secret.signing_key.secret_id
version = "latest"
}
}
}
startup_probe {
initial_delay_seconds = 0
period_seconds = 5
failure_threshold = 6
http_get {
path = "/healthz"
}
}
liveness_probe {
period_seconds = 30
http_get {
path = "/healthz"
}
}
}
}
traffic {
type = "TRAFFIC_TARGET_ALLOCATION_TYPE_LATEST"
percent = 100
}
depends_on = [google_secret_manager_secret_iam_member.ingest_reads_signing_key]
}
# Public access. Leave this out, and set ingress to INGRESS_TRAFFIC_INTERNAL_ONLY,
# for a service only other workloads call.
resource "google_cloud_run_v2_service_iam_member" "public" {
project = var.project_id
location = google_cloud_run_v2_service.ingest.location
name = google_cloud_run_v2_service.ingest.name
role = "roles/run.invoker"
member = "allUsers"
}
```

View File

@@ -0,0 +1,75 @@
# Cloud Scheduler
A schedule that starts a Cloud Run job, and one that calls a private Cloud Run service.
- A job is started by an HTTP POST to its `:run` method with an OAuth token (`oauth_token`). A service is called with an OIDC token (`oidc_token`). Using the wrong one is refused at run time, not by `terraform validate`.
- The schedule's service account needs `roles/run.invoker` on the job or service it starts.
- `schedule` is unix-cron; `time_zone` is an IANA name.
```hcl
variable "project_id" {
type = string
description = "Project to deploy into."
}
variable "region" {
type = string
description = "Region for regional resources."
}
variable "job_name" {
type = string
description = "Name of the Cloud Run job to start."
}
variable "service_url" {
type = string
description = "HTTPS URL of the private Cloud Run service to call."
}
resource "google_service_account" "scheduler" {
project = var.project_id
account_id = "nightly-scheduler"
display_name = "Identity of the nightly schedules"
}
resource "google_cloud_scheduler_job" "start_job" {
project = var.project_id
region = var.region
name = "start-nightly-job"
schedule = "0 2 * * *"
time_zone = "Etc/UTC"
attempt_deadline = "180s"
retry_config {
retry_count = 3
}
http_target {
http_method = "POST"
uri = "https://run.googleapis.com/v2/projects/${var.project_id}/locations/${var.region}/jobs/${var.job_name}:run"
oauth_token {
service_account_email = google_service_account.scheduler.email
}
}
}
resource "google_cloud_scheduler_job" "call_service" {
project = var.project_id
region = var.region
name = "call-nightly-service"
schedule = "30 2 * * *"
time_zone = "Etc/UTC"
http_target {
http_method = "POST"
uri = "${var.service_url}/tasks/nightly"
oidc_token {
service_account_email = google_service_account.scheduler.email
audience = var.service_url
}
}
}
```

View File

@@ -0,0 +1,124 @@
# Cloud SQL
A PostgreSQL instance with a private address, backups and IAM database authentication.
- A private address needs a reserved range and a service networking connection on the VPC first; the instance must `depends_on` the connection.
- `availability_type = "REGIONAL"` is high availability; `"ZONAL"` is a single zone.
- Backups, point-in-time recovery, flags and the address are all in `settings`.
- `deletion_protection` on the resource guards Terraform; `settings.deletion_protection_enabled` guards the API.
- Take the database password from Secret Manager at run time, or use IAM database authentication as here. Never put a password in the configuration.
```hcl
variable "project_id" {
type = string
description = "Project to deploy into."
}
variable "region" {
type = string
description = "Region for regional resources."
}
variable "deletion_protection" {
type = bool
description = "Whether Terraform is prevented from deleting the instance."
default = true
}
resource "google_compute_network" "main" {
project = var.project_id
name = "main"
auto_create_subnetworks = false
}
resource "google_compute_global_address" "private_services" {
project = var.project_id
name = "private-services"
purpose = "VPC_PEERING"
address_type = "INTERNAL"
prefix_length = 16
network = google_compute_network.main.id
}
resource "google_service_networking_connection" "private_services" {
network = google_compute_network.main.id
service = "servicenetworking.googleapis.com"
reserved_peering_ranges = [google_compute_global_address.private_services.name]
}
resource "google_service_account" "app" {
project = var.project_id
account_id = "orders-app"
display_name = "Orders application"
}
resource "google_sql_database_instance" "orders" {
project = var.project_id
name = "orders"
region = var.region
database_version = "POSTGRES_16"
deletion_protection = var.deletion_protection
settings {
tier = "db-custom-2-7680"
edition = "ENTERPRISE"
availability_type = "REGIONAL"
disk_type = "PD_SSD"
disk_autoresize = true
deletion_protection_enabled = var.deletion_protection
ip_configuration {
ipv4_enabled = false
private_network = google_compute_network.main.id
ssl_mode = "ENCRYPTED_ONLY"
}
backup_configuration {
enabled = true
point_in_time_recovery_enabled = true
start_time = "02:00"
backup_retention_settings {
retained_backups = 14
}
}
database_flags {
name = "cloudsql.iam_authentication"
value = "on"
}
maintenance_window {
day = 7
hour = 3
}
}
depends_on = [google_service_networking_connection.private_services]
}
resource "google_sql_database" "orders" {
project = var.project_id
name = "orders"
instance = google_sql_database_instance.orders.name
}
resource "google_sql_user" "app" {
project = var.project_id
name = trimsuffix(google_service_account.app.email, ".gserviceaccount.com")
instance = google_sql_database_instance.orders.name
type = "CLOUD_IAM_SERVICE_ACCOUNT"
}
resource "google_project_iam_member" "app_connects" {
project = var.project_id
role = "roles/cloudsql.client"
member = google_service_account.app.member
}
resource "google_project_iam_member" "app_logs_in" {
project = var.project_id
role = "roles/cloudsql.instanceUser"
member = google_service_account.app.member
}
```

View File

@@ -0,0 +1,67 @@
# Cloud Storage
A private bucket with a retention period and a lifecycle.
- Bucket names are global. Build the name from the project id.
- `uniform_bucket_level_access = true` and `public_access_prevention = "enforced"` keep the bucket private.
- `retention_policy.retention_period` is in seconds and stops objects being deleted before then. A lifecycle `Delete` rule with `age` in days removes them after. Retaining for 30 days and then deleting needs both.
- Versioning and a retention policy cannot be used on the same bucket.
- Customer-managed encryption is `encryption.default_kms_key_name`; the Cloud Storage service agent needs `roles/cloudkms.cryptoKeyEncrypterDecrypter` on the key first.
- `force_destroy = false` stops Terraform deleting a bucket that holds objects.
```hcl
variable "project_id" {
type = string
description = "Project to deploy into."
}
variable "region" {
type = string
description = "Region for regional resources."
}
resource "google_service_account" "writer" {
project = var.project_id
account_id = "raw-events-writer"
display_name = "Writes raw events"
}
resource "google_storage_bucket" "raw_events" {
project = var.project_id
name = "${var.project_id}-raw-events"
location = var.region
storage_class = "STANDARD"
uniform_bucket_level_access = true
public_access_prevention = "enforced"
force_destroy = false
retention_policy {
retention_period = 2592000
}
lifecycle_rule {
condition {
age = 31
}
action {
type = "Delete"
}
}
lifecycle_rule {
condition {
age = 7
}
action {
type = "SetStorageClass"
storage_class = "NEARLINE"
}
}
}
resource "google_storage_bucket_iam_member" "writer_creates_objects" {
bucket = google_storage_bucket.raw_events.name
role = "roles/storage.objectCreator"
member = google_service_account.writer.member
}
```

View File

@@ -0,0 +1,129 @@
# Eventarc
A trigger that delivers events to a Cloud Run service: one for messages on a Pub/Sub topic, one for objects finalised in a bucket.
- A trigger has its own service account. It needs `roles/eventarc.eventReceiver` on the project and `roles/run.invoker` on the service it calls.
- For a Pub/Sub trigger, name an existing topic under `transport.pubsub.topic`; left out, Eventarc creates a topic you do not manage.
- For a Cloud Storage trigger, `location` must be the bucket's location, and the Cloud Storage service agent needs `roles/pubsub.publisher` on the project before the trigger is created.
- `matching_criteria` attributes are exact. `type` is always present; a storage event also needs `bucket`.
- The destination service is named, with its `region`; `path` is optional.
- The service must not allow unauthenticated calls for this to be the only way in: grant `roles/run.invoker` to the trigger's service account only.
```hcl
variable "project_id" {
type = string
description = "Project to deploy into."
}
variable "region" {
type = string
description = "Region for regional resources."
}
variable "service_name" {
type = string
description = "Name of the Cloud Run service that receives the events."
}
variable "topic_id" {
type = string
description = "Id of the Pub/Sub topic whose messages are delivered."
}
variable "bucket_name" {
type = string
description = "Bucket whose new objects are delivered. It must be in var.region."
}
data "google_storage_project_service_account" "this" {
project = var.project_id
}
resource "google_service_account" "trigger" {
project = var.project_id
account_id = "eventarc-trigger"
display_name = "Eventarc trigger"
}
resource "google_project_iam_member" "trigger_receives_events" {
project = var.project_id
role = "roles/eventarc.eventReceiver"
member = "serviceAccount:${google_service_account.trigger.email}"
}
resource "google_cloud_run_v2_service_iam_member" "trigger_invokes_service" {
project = var.project_id
location = var.region
name = var.service_name
role = "roles/run.invoker"
member = "serviceAccount:${google_service_account.trigger.email}"
}
resource "google_project_iam_member" "storage_publishes_events" {
project = var.project_id
role = "roles/pubsub.publisher"
member = "serviceAccount:${data.google_storage_project_service_account.this.email_address}"
}
resource "google_eventarc_trigger" "on_message" {
project = var.project_id
name = "on-message"
location = var.region
service_account = google_service_account.trigger.email
matching_criteria {
attribute = "type"
value = "google.cloud.pubsub.topic.v1.messagePublished"
}
transport {
pubsub {
topic = var.topic_id
}
}
destination {
cloud_run_service {
service = var.service_name
region = var.region
path = "/events/message"
}
}
depends_on = [
google_project_iam_member.trigger_receives_events,
google_cloud_run_v2_service_iam_member.trigger_invokes_service,
]
}
resource "google_eventarc_trigger" "on_object" {
project = var.project_id
name = "on-object"
location = var.region
service_account = google_service_account.trigger.email
matching_criteria {
attribute = "type"
value = "google.cloud.storage.object.v1.finalized"
}
matching_criteria {
attribute = "bucket"
value = var.bucket_name
}
destination {
cloud_run_service {
service = var.service_name
region = var.region
path = "/events/object"
}
}
depends_on = [
google_project_iam_member.trigger_receives_events,
google_project_iam_member.storage_publishes_events,
google_cloud_run_v2_service_iam_member.trigger_invokes_service,
]
}
```

View File

@@ -0,0 +1,74 @@
# Firestore
A Firestore database in Native mode, with point-in-time recovery, a scheduled backup, a composite index and the grant a workload needs.
- A project's first database is named `(default)`. Any other name creates an additional database, which clients must name when they connect.
- `location_id` is a region or a multi-region such as `eur3`, and cannot be changed afterwards.
- `type` is `FIRESTORE_NATIVE` or `DATASTORE_MODE`, and cannot be changed once the database holds data.
- `delete_protection_state` is the guard in the API; `deletion_policy = "DELETE"` is needed before Terraform will remove a database at all.
- `point_in_time_recovery_enablement` keeps seven days of versions. A backup schedule is separate and keeps whole backups for `retention`, in seconds with an `s`.
- A workload reads and writes with `roles/datastore.user`, granted on the project. There is no per-database role; restrict with an IAM condition on the database name.
```hcl
variable "project_id" {
type = string
description = "Project to deploy into."
}
variable "region" {
type = string
description = "Region for regional resources."
}
variable "app_service_account_email" {
type = string
description = "Service account of the workload that uses the database."
}
resource "google_firestore_database" "app" {
project = var.project_id
name = "app"
location_id = var.region
type = "FIRESTORE_NATIVE"
concurrency_mode = "OPTIMISTIC"
point_in_time_recovery_enablement = "POINT_IN_TIME_RECOVERY_ENABLED"
delete_protection_state = "DELETE_PROTECTION_ENABLED"
deletion_policy = "ABANDON"
}
resource "google_firestore_backup_schedule" "daily" {
project = var.project_id
database = google_firestore_database.app.name
retention = "1209600s"
daily_recurrence {}
}
resource "google_firestore_index" "orders_by_customer" {
project = var.project_id
database = google_firestore_database.app.name
collection = "orders"
fields {
field_path = "customer_id"
order = "ASCENDING"
}
fields {
field_path = "created_at"
order = "DESCENDING"
}
}
resource "google_project_iam_member" "app_uses_firestore" {
project = var.project_id
role = "roles/datastore.user"
member = "serviceAccount:${var.app_service_account_email}"
condition {
title = "only-the-app-database"
expression = "resource.name == \"${google_firestore_database.app.id}\" || resource.name.startsWith(\"${google_firestore_database.app.id}/\")"
}
}
```

View File

@@ -0,0 +1,109 @@
# Google Kubernetes Engine
A private Autopilot cluster on an existing subnet, with its node service account and Workload Identity for one workload.
- `enable_autopilot = true` makes Google manage the nodes. Node pools, machine types and node counts are then not yours to set: leave out `node_pool`, `node_config` and `initial_node_count`.
- A regional `location` gives a control plane in three zones. A zone gives one.
- The subnet needs two secondary ranges, for Pods and Services, named in `ip_allocation_policy`.
- `enable_private_nodes = true` gives nodes no public address; they then need Cloud NAT to pull images from outside Google.
- `master_authorized_networks_config` limits who can reach the control plane. With `enable_private_endpoint = true` it has no public address at all.
- Give nodes a dedicated service account with `roles/container.defaultNodeServiceAccount`, not the Compute Engine default account.
- Autopilot has Workload Identity on. A Kubernetes service account acts as a Google service account through `roles/iam.workloadIdentityUser`, with the member `serviceAccount:PROJECT.svc.id.goog[NAMESPACE/KSA]`.
- `deletion_protection` is true unless set; take it from a variable.
```hcl
variable "project_id" {
type = string
description = "Project to deploy into."
}
variable "region" {
type = string
description = "Region for regional resources."
}
variable "network_id" {
type = string
description = "Id of the VPC the cluster is in."
}
variable "subnetwork_id" {
type = string
description = "Id of the subnet for nodes. It has secondary ranges named pods and services."
}
variable "admin_cidr" {
type = string
description = "Range allowed to reach the control plane."
}
variable "deletion_protection" {
type = bool
description = "Whether the cluster is protected from deletion."
default = true
}
resource "google_service_account" "nodes" {
project = var.project_id
account_id = "gke-nodes"
display_name = "GKE nodes"
}
resource "google_project_iam_member" "nodes_default_role" {
project = var.project_id
role = "roles/container.defaultNodeServiceAccount"
member = "serviceAccount:${google_service_account.nodes.email}"
}
resource "google_container_cluster" "workload" {
project = var.project_id
name = "workload"
location = var.region
enable_autopilot = true
deletion_protection = var.deletion_protection
network = var.network_id
subnetwork = var.subnetwork_id
ip_allocation_policy {
cluster_secondary_range_name = "pods"
services_secondary_range_name = "services"
}
private_cluster_config {
enable_private_nodes = true
enable_private_endpoint = false
}
master_authorized_networks_config {
cidr_blocks {
cidr_block = var.admin_cidr
display_name = "administrators"
}
}
cluster_autoscaling {
auto_provisioning_defaults {
service_account = google_service_account.nodes.email
}
}
release_channel {
channel = "REGULAR"
}
depends_on = [google_project_iam_member.nodes_default_role]
}
resource "google_service_account" "app" {
project = var.project_id
account_id = "orders-app"
display_name = "Orders application"
}
resource "google_service_account_iam_member" "app_workload_identity" {
service_account_id = google_service_account.app.name
role = "roles/iam.workloadIdentityUser"
member = "serviceAccount:${var.project_id}.svc.id.goog[orders/orders-app]"
}
```

View File

@@ -0,0 +1,40 @@
# Service accounts and IAM grants
One service account per workload identity, and one `_iam_member` resource per grant.
- `account_id` is 6 to 30 characters: lower-case letters, digits and hyphens.
- Use the narrowest resource the role can be granted on: the bucket, topic, secret or service, in preference to the project.
- A grant to a service account is `member = "serviceAccount:${...email}"`. The same value is the `member` attribute of the service account resource.
```hcl
variable "project_id" {
type = string
description = "Project to deploy into."
}
variable "region" {
type = string
description = "Region for regional resources."
}
resource "google_service_account" "worker" {
project = var.project_id
account_id = "event-worker"
display_name = "Event worker"
description = "Identity of the worker service."
}
# A project-level role, only when no narrower resource can take the grant.
resource "google_project_iam_member" "worker_metrics" {
project = var.project_id
role = "roles/monitoring.metricWriter"
member = google_service_account.worker.member
}
# Who may act as the service account, for example a deployment pipeline.
resource "google_service_account_iam_member" "deployer_acts_as_worker" {
service_account_id = google_service_account.worker.name
role = "roles/iam.serviceAccountUser"
member = "serviceAccount:deployer@${var.project_id}.iam.gserviceaccount.com"
}
```

View File

@@ -0,0 +1,79 @@
# Cloud KMS
A key ring and a key for customer-managed encryption, and the grant that lets a product use it.
- The key ring must be in the same location as the resource it protects.
- Key rings and keys cannot be deleted. `prevent_destroy` stops Terraform trying.
- `rotation_period` is in seconds, such as `"7776000s"` for 90 days.
- The product's service agent, not the workload's service account, needs `roles/cloudkms.cryptoKeyEncrypterDecrypter` on the key. The resource that uses the key must `depends_on` that grant.
- Service agents: Pub/Sub is `service-NUMBER@gcp-sa-pubsub.iam.gserviceaccount.com`, Cloud Run is `service-NUMBER@serverless-robot-prod.iam.gserviceaccount.com`, Cloud Storage comes from the `google_storage_project_service_account` data source.
```hcl
variable "project_id" {
type = string
description = "Project to deploy into."
}
variable "region" {
type = string
description = "Region for regional resources."
}
data "google_project" "this" {
project_id = var.project_id
}
data "google_storage_project_service_account" "this" {
project = var.project_id
}
resource "google_kms_key_ring" "workload" {
project = var.project_id
name = "workload"
location = var.region
}
resource "google_kms_crypto_key" "data" {
name = "data"
key_ring = google_kms_key_ring.workload.id
purpose = "ENCRYPT_DECRYPT"
rotation_period = "7776000s"
lifecycle {
prevent_destroy = true
}
}
resource "google_kms_crypto_key_iam_member" "pubsub_uses_key" {
crypto_key_id = google_kms_crypto_key.data.id
role = "roles/cloudkms.cryptoKeyEncrypterDecrypter"
member = "serviceAccount:service-${data.google_project.this.number}@gcp-sa-pubsub.iam.gserviceaccount.com"
}
resource "google_kms_crypto_key_iam_member" "storage_uses_key" {
crypto_key_id = google_kms_crypto_key.data.id
role = "roles/cloudkms.cryptoKeyEncrypterDecrypter"
member = "serviceAccount:${data.google_storage_project_service_account.this.email_address}"
}
resource "google_pubsub_topic" "encrypted" {
project = var.project_id
name = "encrypted-events"
kms_key_name = google_kms_crypto_key.data.id
depends_on = [google_kms_crypto_key_iam_member.pubsub_uses_key]
}
resource "google_storage_bucket" "encrypted" {
project = var.project_id
name = "${var.project_id}-encrypted"
location = var.region
uniform_bucket_level_access = true
encryption {
default_kms_key_name = google_kms_crypto_key.data.id
}
depends_on = [google_kms_crypto_key_iam_member.storage_uses_key]
}
```

View File

@@ -0,0 +1,184 @@
# External Application Load Balancer
A global HTTPS load balancer in front of a Cloud Run service, with a TLS policy, a web application firewall policy and, optionally, Identity-Aware Proxy.
The chain is: forwarding rule → target HTTPS proxy → URL map → backend service → serverless network endpoint group → Cloud Run service. Each setting lives on one link of it, and putting one on the wrong link is the usual mistake:
- **The minimum TLS version is on an SSL policy, attached to the target HTTPS proxy** (`ssl_policy`). A backend service has no `ssl_policy` setting.
- **The certificate is on the target HTTPS proxy** (`ssl_certificates`).
- **The firewall policy is attached to the backend service** (`security_policy`).
- **Identity-Aware Proxy is the `iap` block of the backend service.** It decides who reaches the application; what a signed-in user may do inside it is the application's own code and cannot be shown by infrastructure.
- **Request logging is the `log_config` block of the backend service.**
- A backend service for Cloud Run uses a serverless NEG and takes no `health_checks`, no `port_name` and no `timeout_sec`.
- `load_balancing_scheme = "EXTERNAL_MANAGED"` on both the backend service and the forwarding rule.
- Set the Cloud Run service's `ingress` to `INGRESS_TRAFFIC_INTERNAL_LOAD_BALANCER`, or it stays reachable around the load balancer.
- Redirecting HTTP to HTTPS needs a second URL map, target HTTP proxy and forwarding rule on port 80.
```hcl
variable "project_id" {
type = string
description = "Project to deploy into."
}
variable "region" {
type = string
description = "Region for regional resources."
}
variable "domain" {
type = string
description = "Domain name the load balancer serves."
}
resource "google_cloud_run_v2_service" "app" {
project = var.project_id
name = "booking-app"
location = var.region
ingress = "INGRESS_TRAFFIC_INTERNAL_LOAD_BALANCER"
template {
containers {
image = "us-docker.pkg.dev/cloudrun/container/hello"
}
}
}
resource "google_compute_region_network_endpoint_group" "app" {
project = var.project_id
name = "booking-app"
region = var.region
network_endpoint_type = "SERVERLESS"
cloud_run {
service = google_cloud_run_v2_service.app.name
}
}
resource "google_compute_security_policy" "edge" {
project = var.project_id
name = "booking-edge"
rule {
action = "deny(403)"
priority = 1000
match {
expr {
expression = "evaluatePreconfiguredWaf('sqli-v33-stable', {'sensitivity': 1})"
}
}
description = "Block SQL injection."
}
rule {
action = "allow"
priority = 2147483647
match {
versioned_expr = "SRC_IPS_V1"
config {
src_ip_ranges = ["*"]
}
}
description = "Default rule."
}
}
resource "google_compute_backend_service" "app" {
project = var.project_id
name = "booking-app"
protocol = "HTTPS"
load_balancing_scheme = "EXTERNAL_MANAGED"
security_policy = google_compute_security_policy.edge.id
backend {
group = google_compute_region_network_endpoint_group.app.id
}
# Only signed-in identities granted roles/iap.httpsResourceAccessor get through.
iap {
enabled = true
}
log_config {
enable = true
sample_rate = 1.0
}
}
resource "google_compute_url_map" "app" {
project = var.project_id
name = "booking-app"
default_service = google_compute_backend_service.app.id
}
resource "google_compute_ssl_policy" "modern" {
project = var.project_id
name = "tls-1-2-modern"
profile = "MODERN"
min_tls_version = "TLS_1_2"
}
resource "google_compute_managed_ssl_certificate" "app" {
project = var.project_id
name = "booking-app"
managed {
domains = [var.domain]
}
}
resource "google_compute_target_https_proxy" "app" {
project = var.project_id
name = "booking-app"
url_map = google_compute_url_map.app.id
ssl_certificates = [google_compute_managed_ssl_certificate.app.id]
ssl_policy = google_compute_ssl_policy.modern.id
}
resource "google_compute_global_address" "app" {
project = var.project_id
name = "booking-app"
}
resource "google_compute_global_forwarding_rule" "https" {
project = var.project_id
name = "booking-app-https"
load_balancing_scheme = "EXTERNAL_MANAGED"
ip_address = google_compute_global_address.app.id
port_range = "443"
target = google_compute_target_https_proxy.app.id
}
# HTTP to HTTPS.
resource "google_compute_url_map" "redirect" {
project = var.project_id
name = "booking-app-redirect"
default_url_redirect {
https_redirect = true
strip_query = false
}
}
resource "google_compute_target_http_proxy" "redirect" {
project = var.project_id
name = "booking-app-redirect"
url_map = google_compute_url_map.redirect.id
}
resource "google_compute_global_forwarding_rule" "http" {
project = var.project_id
name = "booking-app-http"
load_balancing_scheme = "EXTERNAL_MANAGED"
ip_address = google_compute_global_address.app.id
port_range = "80"
target = google_compute_target_http_proxy.redirect.id
}
# Who may pass Identity-Aware Proxy.
resource "google_iap_web_backend_service_iam_member" "staff" {
project = var.project_id
web_backend_service = google_compute_backend_service.app.name
role = "roles/iap.httpsResourceAccessor"
member = "domain:${var.domain}"
}
```

View File

@@ -0,0 +1,107 @@
# Cloud Monitoring and Logging
A notification channel, an alert on a metric, a log-based metric and a log sink.
- An alert policy needs `combiner` and at least one `conditions` block. A threshold condition's `filter` must name both a `metric.type` and a `resource.type`.
- Every `aggregations` block needs an `alignment_period` of at least `"60s"` and a `per_series_aligner` that fits the metric kind: `ALIGN_RATE` or `ALIGN_DELTA` for a delta or cumulative metric, `ALIGN_MEAN` or `ALIGN_MAX` for a gauge.
- A log-based metric's name is used in an alert filter as `logging.googleapis.com/user/NAME`.
- A sink's writer identity needs a grant on the destination, or nothing arrives.
```hcl
variable "project_id" {
type = string
description = "Project to deploy into."
}
variable "region" {
type = string
description = "Region for regional resources."
}
variable "alert_email" {
type = string
description = "Address alerts are sent to."
}
resource "google_monitoring_notification_channel" "email" {
project = var.project_id
display_name = "Operations email"
type = "email"
labels = {
email_address = var.alert_email
}
}
resource "google_monitoring_alert_policy" "server_errors" {
project = var.project_id
display_name = "Cloud Run 5xx responses"
combiner = "OR"
conditions {
display_name = "5xx rate above 1 per second for 5 minutes"
condition_threshold {
filter = "resource.type = \"cloud_run_revision\" AND metric.type = \"run.googleapis.com/request_count\" AND metric.labels.response_code_class = \"5xx\""
comparison = "COMPARISON_GT"
threshold_value = 1
duration = "300s"
aggregations {
alignment_period = "60s"
per_series_aligner = "ALIGN_RATE"
cross_series_reducer = "REDUCE_SUM"
group_by_fields = ["resource.labels.service_name"]
}
trigger {
count = 1
}
}
}
notification_channels = [google_monitoring_notification_channel.email.name]
alert_strategy {
auto_close = "1800s"
}
documentation {
content = "The service is returning server errors. Check the latest revision's logs."
mime_type = "text/markdown"
}
}
resource "google_logging_metric" "rejected_signatures" {
project = var.project_id
name = "rejected_signatures"
filter = "resource.type = \"cloud_run_revision\" AND jsonPayload.event = \"signature_rejected\""
metric_descriptor {
metric_kind = "DELTA"
value_type = "INT64"
unit = "1"
}
}
resource "google_storage_bucket" "audit_logs" {
project = var.project_id
name = "${var.project_id}-audit-logs"
location = var.region
uniform_bucket_level_access = true
}
resource "google_logging_project_sink" "audit" {
project = var.project_id
name = "audit-to-storage"
destination = "storage.googleapis.com/${google_storage_bucket.audit_logs.name}"
filter = "logName:\"cloudaudit.googleapis.com\""
unique_writer_identity = true
}
resource "google_storage_bucket_iam_member" "sink_writes" {
bucket = google_storage_bucket.audit_logs.name
role = "roles/storage.objectCreator"
member = google_logging_project_sink.audit.writer_identity
}
```

View File

@@ -0,0 +1,102 @@
# VPC networking
A custom-mode VPC, a subnet, outbound internet through Cloud NAT, and a firewall rule.
- `auto_create_subnetworks = false` gives a custom-mode network: only the subnets you declare.
- `private_ip_google_access = true` lets workloads without external addresses reach Google APIs.
- Cloud Run reaches the VPC with Direct VPC egress: `template.vpc_access.network_interfaces` naming this network and subnet. It needs no connector resource.
- Firewall rules match by `target_service_accounts` or `target_tags`. A rule with neither applies to the whole network.
```hcl
variable "project_id" {
type = string
description = "Project to deploy into."
}
variable "region" {
type = string
description = "Region for regional resources."
}
resource "google_compute_network" "main" {
project = var.project_id
name = "main"
auto_create_subnetworks = false
routing_mode = "REGIONAL"
}
resource "google_compute_subnetwork" "workloads" {
project = var.project_id
name = "workloads"
region = var.region
network = google_compute_network.main.id
ip_cidr_range = "10.10.0.0/24"
private_ip_google_access = true
log_config {
aggregation_interval = "INTERVAL_5_SEC"
flow_sampling = 0.5
metadata = "INCLUDE_ALL_METADATA"
}
}
resource "google_compute_router" "egress" {
project = var.project_id
name = "egress"
region = var.region
network = google_compute_network.main.id
}
resource "google_compute_router_nat" "egress" {
project = var.project_id
name = "egress"
region = var.region
router = google_compute_router.egress.name
nat_ip_allocate_option = "AUTO_ONLY"
source_subnetwork_ip_ranges_to_nat = "ALL_SUBNETWORKS_ALL_IP_RANGES"
log_config {
enable = true
filter = "ERRORS_ONLY"
}
}
resource "google_compute_firewall" "allow_health_checks" {
project = var.project_id
name = "allow-health-checks"
network = google_compute_network.main.id
direction = "INGRESS"
priority = 1000
# Google Cloud load balancer health check ranges.
source_ranges = ["130.211.0.0/22", "35.191.0.0/16"]
target_tags = ["web"]
allow {
protocol = "tcp"
ports = ["8080"]
}
}
resource "google_cloud_run_v2_service" "internal" {
project = var.project_id
name = "internal"
location = var.region
ingress = "INGRESS_TRAFFIC_INTERNAL_ONLY"
template {
containers {
image = "us-docker.pkg.dev/cloudrun/container/hello"
}
vpc_access {
egress = "PRIVATE_RANGES_ONLY"
network_interfaces {
network = google_compute_network.main.id
subnetwork = google_compute_subnetwork.workloads.id
}
}
}
}
```

View File

@@ -0,0 +1,33 @@
# Enabling APIs
Enable each API the Elements need, once, and make the first resource of each product depend on it.
- `disable_on_destroy = false` keeps the API on when the configuration is destroyed; other workloads in the project may use it.
```hcl
variable "project_id" {
type = string
description = "Project to deploy into."
}
variable "region" {
type = string
description = "Region for regional resources."
}
locals {
services = [
"run.googleapis.com",
"pubsub.googleapis.com",
"secretmanager.googleapis.com",
]
}
resource "google_project_service" "enabled" {
for_each = toset(local.services)
project = var.project_id
service = each.value
disable_on_destroy = false
}
```

View File

@@ -0,0 +1,111 @@
# Pub/Sub
A topic, a push subscription that calls a private Cloud Run service, and a dead-letter topic.
- A push subscription authenticates with `push_config.oidc_token`; its service account needs `roles/run.invoker` on the service it calls.
- Dead-lettering needs two grants to the Pub/Sub service agent: `roles/pubsub.publisher` on the dead-letter topic and `roles/pubsub.subscriber` on the source subscription. Without them messages are never moved.
- Give the dead-letter topic a subscription of its own, or the messages moved there are lost.
- `max_delivery_attempts` is 5 to 100. `ack_deadline_seconds` is 10 to 600.
- `message_retention_duration` is a duration in seconds, such as `"604800s"`.
- Customer-managed encryption is `kms_key_name` on the topic; the Pub/Sub service agent needs `roles/cloudkms.cryptoKeyEncrypterDecrypter` on the key first.
```hcl
variable "project_id" {
type = string
description = "Project to deploy into."
}
variable "region" {
type = string
description = "Region for regional resources."
}
variable "worker_url" {
type = string
description = "HTTPS URL of the service the subscription pushes to."
}
data "google_project" "this" {
project_id = var.project_id
}
locals {
pubsub_agent = "serviceAccount:service-${data.google_project.this.number}@gcp-sa-pubsub.iam.gserviceaccount.com"
}
resource "google_service_account" "push" {
project = var.project_id
account_id = "events-push"
display_name = "Identity Pub/Sub pushes with"
}
resource "google_pubsub_topic" "events" {
project = var.project_id
name = "events"
message_retention_duration = "604800s"
message_storage_policy {
allowed_persistence_regions = [var.region]
}
}
resource "google_pubsub_topic" "dead_letter" {
project = var.project_id
name = "events-dead-letter"
}
resource "google_pubsub_subscription" "dead_letter" {
project = var.project_id
name = "events-dead-letter"
topic = google_pubsub_topic.dead_letter.id
message_retention_duration = "1209600s"
expiration_policy {
ttl = ""
}
}
resource "google_pubsub_subscription" "worker" {
project = var.project_id
name = "events-worker"
topic = google_pubsub_topic.events.id
ack_deadline_seconds = 60
push_config {
push_endpoint = var.worker_url
oidc_token {
service_account_email = google_service_account.push.email
audience = var.worker_url
}
}
retry_policy {
minimum_backoff = "10s"
maximum_backoff = "600s"
}
dead_letter_policy {
dead_letter_topic = google_pubsub_topic.dead_letter.id
max_delivery_attempts = 5
}
expiration_policy {
ttl = ""
}
}
resource "google_pubsub_topic_iam_member" "agent_publishes_dead_letters" {
project = var.project_id
topic = google_pubsub_topic.dead_letter.name
role = "roles/pubsub.publisher"
member = local.pubsub_agent
}
resource "google_pubsub_subscription_iam_member" "agent_forwards_from_worker" {
project = var.project_id
subscription = google_pubsub_subscription.worker.name
role = "roles/pubsub.subscriber"
member = local.pubsub_agent
}
```

View File

@@ -0,0 +1,45 @@
# Secret Manager
Terraform creates the secret and who may read it. The value is added outside Terraform, so it never enters the state or the repository.
- `replication` is required: `auto {}` for Google-managed locations, or `user_managed` with one `replicas` block per location.
- Grant `roles/secretmanager.secretAccessor` on the secret, to the one identity that reads it.
- Never write a `google_secret_manager_secret_version` with the value in the configuration.
```hcl
variable "project_id" {
type = string
description = "Project to deploy into."
}
variable "region" {
type = string
description = "Region for regional resources."
}
resource "google_service_account" "reader" {
project = var.project_id
account_id = "api-key-reader"
display_name = "Reads the API key"
}
resource "google_secret_manager_secret" "api_key" {
project = var.project_id
secret_id = "partner-api-key"
replication {
user_managed {
replicas {
location = var.region
}
}
}
}
resource "google_secret_manager_secret_iam_member" "reader_reads_api_key" {
project = var.project_id
secret_id = google_secret_manager_secret.api_key.secret_id
role = "roles/secretmanager.secretAccessor"
member = google_service_account.reader.member
}
```

View File

@@ -0,0 +1,24 @@
---
name: google-cloud-lessons
description: >-
Rules learned from earlier solution-architecture work on Google Cloud, one set
per Deliverable. Each was proposed from problems that recurred across
Executions, approved by a person, and kept only while evaluation shows it
helps. Use before drafting a Deliverable, to read the lessons for that
Deliverable and follow them.
metadata:
scope: every Deliverable
---
# Lessons
Each reference below holds the lessons for one Deliverable. Read the one for the Deliverable you are producing, with `load_skill_resource`, before you draft, and follow every rule in it that applies. A rule here takes precedence over a general habit; your role's instructions and the contract `submit_deliverable` checks take precedence over a rule here.
<!-- lessons:begin -->
| Deliverable | Reference | Lessons |
| --- | --- | --- |
| deployment guidance | `references/deployment_guidance.md` | 1 |
| target architecture | `references/target_architecture.md` | 8 |
<!-- lessons:end -->
This Skill is written by the lessons loop (`app/learning/`), from proposals a person approved. Do not edit it by hand: change the proposal and publish again.

View File

@@ -0,0 +1,11 @@
# Lessons: deployment guidance
Rules learned from earlier work. Follow every one that applies.
## L-05: Include Required Arguments in Alert Policies
**Rule.** Always verify and include all required arguments (such as time window definitions) when configuring nested blocks in monitoring alert policies.
**Why.** Missing required arguments in nested blocks will cause Terraform validation to fail, preventing submission.
Published 2026-10-10, from lesson proposal 05.

View File

@@ -0,0 +1,67 @@
# Lessons: target architecture
Rules learned from earlier work. Follow every one that applies.
## L-01: Create Specific Checks for All Constraints
**Rule.** Create specific Checks for every explicit constraint, metric, or capability mentioned in a requirement, rather than relying on a single broad Check.
**Why.** If detailed constraints are missed, the validation phase will reject the design for incomplete coverage, forcing a revision.
Published 2026-10-10, from lesson proposal 01.
## L-02: Assign Checks to Every Element
**Rule.** Give every Element at least one Check before you submit.
**Why.** The submission tool will reject the architecture if any Element lacks a Check, wasting an attempt.
Published 2026-10-10, from lesson proposal 02.
## L-03: Verify Resource Arguments for Checks
**Rule.** Verify that the specific resource type used for an Element actually supports the configuration argument you specify in a Check. Remember that access policies and certain configurations often require entirely separate resources.
**Why.** If a Check specifies an argument that does not exist on the resource, it cannot be implemented, forcing an architectural revision.
Published 2026-10-10, from lesson proposal 03.
## L-06: Do Not Mark Requirements as Not Applicable
**Rule.** Do not list Requirements in the not applicable field, as this field is strictly for Design Recommendations. Ensure every Requirement has at least one Check.
**Why.** The submission tool will reject the deliverable if a Requirement lacks a Check or is incorrectly marked as not applicable.
Published 2026-10-10, from lesson proposal 06.
## L-07: Verify location constraints
**Rule.** When a requirement specifies where resources must be provisioned, such as a designated region or multi-zone placement, create a Check for the `region` or `location` argument on every applicable Element, naming the region the design uses. Do not write a Check about a property of the region that code cannot show, such as its carbon rating.
**Why.** Validation frequently catches missing location constraints. Without this Check, resources may be provisioned in default regions, violating location requirements. A Check about a region's carbon rating cannot be verified from code and sends the design back.
Published 2026-10-10, from lesson proposal 07.
## L-08: Cloud SQL backup encryption
**Rule.** When writing a Check for CMEK encryption on a `google_sql_database_instance`, do not require an `encryption_key_name` argument for backup storage, as the instance-level `encryption_key_name` automatically encrypts backups as well.
**Why.** The database instance resource does not have a separate encryption key argument for backups. Asking for one causes validation to reject the Check as un-implementable.
Published 2026-10-10, from lesson proposal 08.
## L-09: Backend Service capabilities
**Rule.** When writing Checks for a `google_compute_backend_service`, do not verify IAM roles inside the backend service or require health checks when it is configured with a Serverless NEG.
**Why.** Roles are verified via IAM bindings outside the backend service, and Serverless NEGs do not support health checks. Invalid Checks cause the design to be rejected during validation.
Published 2026-10-10, from lesson proposal 09.
## L-10: Pub/Sub persistence regions
**Rule.** When a requirement dictates that a messaging queue or topic must replicate across zones or stay within a specific region, create a Check for the `message_storage_policy.allowed_persistence_regions` argument on the topic Element.
**Why.** Without this Check, topics might use default storage policies that violate geographical or high-availability requirements.
Published 2026-10-10, from lesson proposal 10.

View File

@@ -0,0 +1,9 @@
{
"google-cloud-solution-architecture": "f5b8cdac4060",
"google-cloud-waf-cost-optimization": "b3febbf52e5c",
"google-cloud-waf-operational-excellence": "bdc6a9f415f6",
"google-cloud-waf-performance-optimization": "89a4947438cf",
"google-cloud-waf-reliability": "9baf33bd5b75",
"google-cloud-waf-security": "e791a44cda99",
"google-cloud-waf-sustainability": "7d0a6921cb59"
}

View File

@@ -0,0 +1,52 @@
---
name: iac-validation
description: >-
Checks Terraform infrastructure-as-code without provisioning anything, using
the local terraform_fmt, terraform_validate, terraform_plan and
terraform_schema tools. Use when writing deployment guidance or validating it
before deployment.
metadata:
scope: deployment-guidance validation
---
# IaC validation
Every check runs on a scratch copy of your Terraform files. Nothing is applied, and no state is written.
The files are your working copy: the files you wrote with `write_file`, or, when you are validating, the files that were submitted. Pass the tools no files.
## Tools
- `terraform_fmt()`: formats your working copy in place and names the files it changed.
- `terraform_validate()`: runs `init -backend=false` and `validate` offline. It reports syntax errors, unknown references, missing variables and invalid arguments.
- `terraform_plan(variables)`: previews the changes against the live cloud environment. It reads live state, so the first call may pause for the user's permission. Pass every variable the configuration requires.
- `terraform_schema(resource_type, block, find, resource_types)`: what a resource type accepts, from the provider's own schema. With `resource_types`, a list, it outlines every argument and block of each in one call; use that when you need several. With `resource_type` alone it lists the top-level arguments and outlines every block. With `block`, such as `template.containers`, it gives that block's arguments in full. With `find`, it says where an argument or block of that name sits, or that the resource type has none; give several names separated by commas to check them in one call.
- `terraform_module(source, version, find)`, only when the Execution opted into published modules: what a published module accepts, from the registry: its inputs with their types, its outputs and its submodules. It says when a module cannot be used with the pinned provider. `find` narrows the inputs to those matching the words given. Only modules from the namespaces the Cloud provider allows can be looked up or used.
## When writing deployment guidance
1. Run `terraform_fmt`, then `terraform_validate`.
2. Fix each error with `edit_file`, changing only the lines concerned, and run `terraform_validate` again until it passes.
3. A refusal about a module means one of two things. The Execution writes plain resources, so write them directly. Or the module is not from an approved namespace or not pinned to one exact version, so use an approved module at an exact version or write the resources directly.
4. On "An argument named X is not expected here" or "Unsupported block type", call `terraform_schema` with `find` set to the name. It is either in a different block, which the reply names, or it does not exist on that resource type. Never move it around by trial.
## When validating deployment guidance
1. Run `terraform_validate`, and report its verdict and output.
2. When permission to read the live environment is granted, run `terraform_plan` with the variable values from the requirements, or clearly marked placeholders. Summarise the resources to add, change and destroy, and flag any destroy or replace.
3. When a check can't run (a missing CLI, a refused permission or a provider download failure), give the user the exact commands to run themselves:
```bash
terraform init -backend=false
terraform validate
terraform plan -lock=false -var-file=<your.tfvars>
```
## Reporting verdicts
Give a verdict on every Check in the Target architecture. Record them with `verdict_put`, a few Checks per call; they are attached as `verdicts.json`, in the format the requirements-chain Skill gives, when you submit. The dry-run's result goes in its `dry_run` entry: `pass` when `terraform_validate` passes, `fail` with the error when it does not, and `not_run` when the tool could not run.
A Check fails when the code could meet it and does not. When `terraform_schema` shows the resource type has no such setting, no code could meet it: the verdict is `not_verifiable`, with the schema's answer as evidence.
Never suggest `terraform apply` as part of validation.

View File

@@ -0,0 +1,51 @@
---
name: example-organisation-standards
description: >-
An example of an organisation's cloud standards as an overlay Skill: naming,
mandatory labels, approved regions and a short list of things never to do.
Use on any Deliverable of an Execution that names this overlay, to apply the
organisation's standards on top of the Cloud provider's guidance.
metadata:
scope: every Deliverable
overlay: organisation standards (example)
---
# Organisation standards (example)
This is an example. Copy it, replace every rule with your organisation's own, and name the copy when you start an Execution. Nothing here is a real organisation's policy.
An overlay adds to the Cloud provider's guidance. Where the two disagree, this Skill wins; where a requirement the user stated disagrees with this Skill, say so in your Deliverable and follow the user's requirement.
## Naming
- Every resource is named `<workload>-<environment>-<purpose>`, lower case, with hyphens: `orders-prod-ingest`.
- `<environment>` is one of `dev`, `test`, `prod`, and comes from a variable.
## Labels
Every resource that accepts labels carries all four:
| Label | Value |
| --- | --- |
| `workload` | the workload's short name |
| `environment` | `dev`, `test` or `prod` |
| `owner` | the owning team's short name |
| `cost-centre` | the cost centre code, from a variable |
## Regions
- Deploy only to `europe-west1` or `europe-west4`.
- Data at rest stays in the European Union.
## Never
- No public IP address on a database.
- No service account key files; workloads use attached identities.
- No resource without deletion protection in `prod`, where the resource type has it.
## What each Specialist does with this
- **Requirements:** record each standard above that applies as a non-functional requirement, with this Skill as its source, so it is traced like any other.
- **Design recommendations and Target architecture:** a standard that applies becomes a Check on every Element it constrains.
- **Infrastructure code:** follow the naming and label rules exactly.
- **Validation:** the standards are verified through the Checks that came from them.

View File

@@ -0,0 +1,157 @@
---
name: requirements-chain
description: >-
Defines the data files that carry requirements through to code and validation:
requirements, components, products, recommendations, the Target architecture
graph, the implementation map and the verdicts. Use when producing or checking
any Deliverable of a solution-architecture Execution, to write its data file
in the right format and keep every id traceable.
metadata:
scope: every Deliverable
---
# Requirements chain
Every requirement must be traceable, by id, to the components that serve it, to the Elements and Checks that realise it, to the code that implements them, and to a validation verdict. Each Deliverable attaches one data file that carries its part of that chain. A submission is refused when a link is missing, and the refusal names it.
Ids are short and stable: reuse an id exactly as the earlier Deliverable wrote it, and never renumber.
## The files
### `requirements.json` (requirements)
A list. Number functional requirements `FR-1`, `FR-2` and non-functional ones `NFR-1`, `NFR-2`.
```json
[
{"id": "FR-1", "kind": "functional", "text": "Accept signed webhooks over HTTPS."},
{"id": "NFR-1", "kind": "non_functional", "text": "Raw events are encrypted at rest and retained for 30 days.",
"conditions": ["Raw events are encrypted at rest.", "Raw events are kept for 30 days and then deleted."]},
{"id": "NFR-2", "kind": "non_functional", "text": "The service is available 99.9% of each month, across two zones.",
"conditions": ["The service runs in at least two zones."],
"outside_code": ["Measured availability is at least 99.9% a month."]}
]
```
Every non-functional requirement lists its `conditions`: one entry for each separate thing that must be true for it to be met and that infrastructure configuration can show. What it asks for that configuration cannot show goes under `outside_code`: an outcome measured in operation, behaviour of the application's own code, a process people follow, or a property of a region or product that only its provider publishes, such as a region's carbon rating or a product's service level. For those, the condition is the choice that configuration can show: "every resource is in the one agreed region" is a condition, and "that region has a high carbon-free energy score" is `outside_code`. A requirement has at least one entry between the two; one that is entirely outside code has `"conditions": []`. Write each so it can be checked on its own, and so that together they say everything the text says. The Target architecture needs a Check for each one.
`kind` is `functional` or `non_functional`. Write one requirement per entry, so each can be checked on its own.
When the customer's scope is in your context, a requirement says what it comes from in `from`: the ids of the customer's own requirements, and the scope fields it carries.
```json
{"id": "NFR-4", "kind": "non_functional",
"text": "The network is a hub with spokes, joined to on-premises over a private 10Gbps connection.",
"conditions": ["A hub network is connected to every spoke network.", "A dedicated 10Gbps connection joins the hub to on-premises."],
"from": ["REQ-03", "networking.topology", "networking.hybrid_connectivity.type", "networking.hybrid_connectivity.bandwidth_gbps"]}
```
- Every requirement the customer wrote (`scope.stated.intent.requirements`) is named in the `from` of the requirement that covers it.
- Every field under `scope.binding` is a choice the customer stated that the design must honour. Each is named in the `from` of a non-functional requirement with at least one condition that shows it was honoured. Write the condition about what must exist or be set, in terms a Check can verify: "a hub network is connected to every spoke network", not "the topology is hub and spoke".
- One requirement may carry several fields that belong together. A submission is refused while any is carried by none.
### `components.json` (technical decomposition)
A list of components and the requirement ids each serves. Every functional requirement must be served by at least one component.
```json
[{"id": "C-1", "name": "Ingest endpoint", "requirements": ["FR-1"]}]
```
### `products.json` (product selection)
One entry per component, naming the product selected for it.
```json
[{"component": "C-1", "product": "Cloud Run"}]
```
### `recommendations.json` (design recommendations)
A list. Each recommendation names its pillar and the components it applies to; use an empty list for one that applies to the whole workload.
```json
[{"id": "DR-1", "pillar": "security", "text": "Encrypt the topic with a customer-managed key.", "components": ["C-2"],
"conditions": ["The topic is encrypted with a customer-managed key.", "The messaging service's own identity may use that key."]}]
```
Every recommendation lists its `conditions`, and `outside_code` where it applies, as a non-functional requirement does. When it applies to several components, give a condition for each.
Write one configurable decision per recommendation. "Harden the service" cannot become a Check; "disable public ingress on the worker service" can.
### `target-architecture.json` (Target architecture)
```json
{
"elements": [
{"id": "E-1", "name": "Ingest service", "component": "C-1", "product": "Cloud Run", "resource_type": "google_cloud_run_v2_service"},
{"id": "E-2", "name": "Ingest identity", "product": "IAM", "resource_type": "google_service_account"}
],
"relationships": [
{"id": "R-1", "from": "E-1", "to": "E-2", "kind": "runs as"}
],
"checks": [
{"id": "K-1", "applies_to": "E-1", "statement": "ingress is INGRESS_TRAFFIC_ALL and roles/run.invoker is granted to allUsers", "source": "FR-1"},
{"id": "K-2", "applies_to": "E-2", "statement": "the account is attached to E-1 only", "source": "DR-3"}
],
"not_applicable": [
{"recommendation": "DR-9", "reason": "Single region by requirement NFR-2."}
]
}
```
- **Elements.** One per resource to be created. `component` is the component it realises; leave it out for a supporting Element such as an identity, a key or a network. `product` for a component's Element is exactly the product selected for that component.
- **Relationships.** `from` and `to` are Element ids. `kind` says what the connection is: calls, publishes to, reads from, runs as, is granted access to.
- **Checks.** `applies_to` is an Element or Relationship id. `source` is the requirement or recommendation id the Check comes from. Every Element has at least one Check.
- **Coverage.** Every entry in the `conditions` of a non-functional requirement or a recommendation needs a Check that verifies it, with that requirement or recommendation as its `source`. An entry under `outside_code` gets no Check, and a requirement or recommendation with nothing but `outside_code` needs none. A condition that applies to several Elements needs a Check on each: "processing scales to zero when idle" applies to every processing Element, not one of them.
- **Completeness.** Every component has an Element. Every non-functional requirement and every recommendation is the `source` of at least one Check, unless the recommendation is listed under `not_applicable` with a reason. Every selected product appears on its component's Element.
#### Writing a Check
A Check is a statement that is true or false of the infrastructure code. Name the argument and the value.
- Verifiable: "`kms_key_name` is set on the topic", "`min_instance_count` is at least 2", "the subscription has a `dead_letter_policy` pointing at E-6".
- Not verifiable: "the service is secure", "follows least privilege", "scales well".
Split a broad recommendation into several Checks, one per setting. A Check that the validator cannot verify from the code is sent back to you.
A Check must name a setting its Element's resource type really has. Two similar resource types often differ: a setting of a long-running service may not exist on a batch job. A Check on a setting the resource type lacks is sent back to you.
The tables of Elements, Relationships and Checks, and the diagram, are written from this file when you submit. Write the graph once, here.
### `implementation.json` (deployment guidance)
One entry per Check in the Target architecture, saying where the code satisfies it. `file` is an attached file; `address` is the resource address and argument.
```json
[
{"check": "K-1", "file": "terraform/main.tf", "address": "google_cloud_run_v2_service.ingest.ingress"},
{"check": "K-7", "unimplementable": "google_cloud_run_v2_job has no startup_cpu_boost argument; it exists only on a service."}
]
```
When a module creates the resource, `address` is the module and the input that sets what the Check asks for, such as `module.database.ip_configuration.ipv4_enabled`.
When a Check names a setting its resource type does not have, give it an `unimplementable` entry in place of `file` and `address`, saying what the resource type lacks. Write no code for it. The Target architecture is revised before anything is validated.
Implement every Element, Relationship and Check, and nothing the Target architecture does not ask for. When you believe the Target architecture is wrong or incomplete, say so with `needs_input`; do not quietly build something else.
### `verdicts.json` (validation results)
```json
{
"dry_run": {"verdict": "pass", "evidence": "terraform validate: Success! The configuration is valid."},
"checks": [
{"check": "K-1", "verdict": "pass", "evidence": "main.tf: ingress = \"INGRESS_TRAFFIC_ALL\"; google_cloud_run_v2_service_iam_member.public"},
{"check": "K-2", "verdict": "fail", "evidence": "google_service_account.ingest is also attached to the worker service"}
],
"proposed_additions": [
{"statement": "the bucket has a retention_policy of 30 days", "applies_to": "E-5", "reason": "NFR-1 has no Check on retention"}
]
}
```
- Give every Check exactly one verdict: `pass`, `fail` or `not_verifiable`, with the evidence you read in the code.
- `dry_run.verdict` is `pass`, `fail`, or `not_run` when the tool could not run.
- Find every gap in one pass: go through each requirement and recommendation in turn and compare its `conditions` with the Checks that name it as `source`. Propose nothing for its `outside_code`.
- Judge the code against the Checks and nothing else. Something the Target architecture lacks is a `proposed_additions` entry, with the requirement or recommendation id it serves in `reason`. It is never a failed Check.

View File

@@ -0,0 +1,37 @@
---
name: scoping
description: >-
The scope spec: the structured statement of what a customer wants and the
facts a solution architecture depends on, with the catalogue of its fields.
Use when reading a scope spec in your context, to know what a field means,
whether the customer stated it or left it to you, and what binds your
Deliverable.
metadata:
scope: every Deliverable
---
# Scoping
A scope spec is a YAML file the customer's architect supplies, complete or partly filled. It sits beside the Intent, which stays in the customer's words. `assets/catalogue.yaml` lists every field it may hold: its type, when it must be settled, the question to ask for it, and guidance for a default.
## What a field says
| In the spec | Meaning |
| --- | --- |
| a value | The customer states this. It is theirs: use it as given. |
| `ask`, or left out | Not known yet. |
| `decide` | The customer leaves the choice to you. Choose, and record it as an assumption with what it affects. |
| `not_applicable` | It does not apply. Ask nothing and assume nothing. |
## Rules for every Specialist
- **A stated value binds you.** A region, a topology, a product, a setting or a number the spec states is the customer's decision. Honour it. If you believe it is wrong, say so with `needs_input`; do not quietly replace it.
- **A stated choice is not yours to generalise.** The rule that requirements name no products is about what you introduce. What the customer wrote stays as they wrote it.
- **Build nothing the customer excluded.** `intent.exclusions` is out of scope for every Deliverable.
- **The customer's own requirements carry their ids.** Each entry in `intent.requirements` must be met. When your work serves one, name its id.
- **An assumption is not the customer's decision.** A field under `assumed` was chosen for them, with the reason given. Work from it, and say so where your Deliverable depends on it: it may change when they answer.
- **Do not fill a gap silently.** A field under `to_ask` is still unknown. When your Deliverable needs it, assume a default and say that you did.
## The kinds of engagement
`engagement.kind` is `workload` (an application), `platform_foundation` (a landing zone or shared platform that workloads will later run on) or `migration`. A platform foundation has no users or response times of its own: its subject is the organisation's structure, shared networking, identity, environments and guardrails.

View File

@@ -0,0 +1,345 @@
# The scope spec's catalogue: every field a scope spec may hold.
#
# A field is a dotted path. `type` is one of: string, text, integer, number, boolean,
# date, list, enum, records. `tier` says when it must be settled: essential (always,
# before any work), important (asked when someone is present) or optional. A tier
# may differ by the kind of engagement. `question` is what to ask the customer for
# it. `default` guides the choice when the customer says "decide". `affects` says
# what a wrong assumption would change. `binds: true` marks a choice a design must
# honour: stated by the customer, it has to reach a requirement and its Checks.
#
# This catalogue names no Cloud provider. A provider's bundle adds allowed values
# for the fields marked `provider_values`.
schema_version: 1
kinds: [workload, platform_foundation, migration]
fields:
metadata.customer_case:
type: string
tier: essential
aliases: [metadata.engagement_id]
question: What short reference identifies this engagement?
metadata.engagement_reference:
type: string
metadata.client_name:
type: string
metadata.author:
type: string
metadata.revision:
type: string
engagement.kind:
type: enum
values: [workload, platform_foundation, migration]
tier: essential
question: >-
Is this an application workload, a platform foundation such as a landing zone,
or a migration of existing systems?
intent.statement:
type: text
tier: essential
question: In the customer's own words, what do they want?
intent.requirements:
type: records
keys: [id, statement]
optional_keys: [category]
question: Which requirements has the customer stated outright?
intent.exclusions:
type: list
tier: important
question: What has the customer said is out of scope?
default: Nothing is excluded beyond what the statement implies.
affects: what is designed and planned
intent.success_criteria:
type: list
question: How will the customer judge this a success?
default: The stated requirements are met.
estate.cloud_provider:
type: enum
provider_values: true
tier: essential
question: Which Cloud provider is this for?
estate.mode:
type: enum
values: [greenfield, brownfield_expansion, migration]
tier: essential
question: Is this a new estate, an extension of an existing one, or a migration?
estate.regions.primary:
binds: true
type: string
tier: essential
question: Which region should it run in?
estate.regions.secondary:
binds: true
type: string
question: Is there a second region, and which?
default: None, unless availability or recovery targets need one.
affects: resilience design and cost
estate.regions.resiliency_tier:
binds: true
type: enum
values: [single_region, warm_standby, active_active]
tier: important
question: How should it survive the loss of a region?
default: single_region
affects: resilience design and cost
estate.data_residency:
binds: true
type: string
tier: essential
question: Where must data stay?
estate.existing_systems:
type: text
tier: {migration: essential, platform_foundation: important, workload: important}
question: What exists today that this replaces, extends or must connect to?
default: Nothing exists today.
affects: connectivity, migration work and the plan
workload.users.who:
type: enum
values: [employees, customers, partners, public, systems]
tier: {workload: essential, migration: essential}
question: Who uses it?
workload.users.count:
type: integer
tier: {workload: essential, migration: essential}
question: How many users?
workload.users.peak_concurrent:
type: integer
tier: {workload: important, migration: important}
question: How many use it at once at peak?
default: A tenth of the user count.
affects: scaling limits and cost
workload.availability.target:
binds: true
type: string
tier: {workload: essential, migration: essential, platform_foundation: important}
question: What availability is required, as a percentage?
default: "99.9%"
affects: resilience design and cost
workload.availability.hours:
type: enum
values: [business_hours, extended, always]
tier: important
question: During which hours must it be available?
default: always
affects: scaling to zero and support
workload.availability.recovery_time:
binds: true
type: string
tier: important
question: How quickly must it recover from a failure?
default: 4 hours
affects: backup and standby design
workload.availability.recovery_point:
binds: true
type: string
tier: important
question: How much recent data may be lost in a failure?
default: 1 hour
affects: backup frequency
compliance.industry:
type: string
question: "Which industry is the customer in?"
compliance.frameworks:
binds: true
type: list
tier: essential
question: Which regulations or standards apply? An empty list if none.
compliance.data_classification:
binds: true
type: enum
values: [public, internal, confidential, restricted]
tier: essential
question: How sensitive is the data?
compliance.encryption.type:
binds: true
type: enum
values: [provider_managed, customer_managed]
provider_values: true
tier: important
question: Must the customer control the encryption keys?
default: provider_managed
affects: key management design
compliance.encryption.key_rotation_days:
binds: true
type: integer
question: How often must keys rotate, in days?
default: 90
compliance.audit_logging.retention_days:
binds: true
type: integer
tier: important
question: How long must audit logs be kept, in days?
default: 365
affects: storage cost and log design
compliance.audit_logging.immutable_retention_policy:
binds: true
type: boolean
question: Must audit logs be undeletable for that time?
default: false
networking.exposure:
binds: true
type: enum
values: [internal_only, internet_facing]
tier: important
question: Is it reached from the internet or only from inside?
default: internal_only
affects: perimeter design
networking.topology:
binds: true
type: enum
provider_values: true
tier: {platform_foundation: important}
question: Is a network topology already decided?
default: The simplest topology that meets the requirements.
affects: the whole network design
networking.hybrid_connectivity.enabled:
binds: true
type: boolean
tier: {platform_foundation: important, migration: important}
question: Must it connect privately to on-premises or another cloud?
default: false
affects: network design and lead time
networking.hybrid_connectivity.type:
binds: true
type: enum
provider_values: true
question: By what kind of connection?
networking.hybrid_connectivity.bandwidth_gbps:
binds: true
type: number
question: At what bandwidth, in Gbps?
networking.egress_control.model:
binds: true
type: enum
values: [direct, provider_managed, centralized_appliance]
question: How must traffic to the internet be controlled?
default: provider_managed
affects: network design and cost
networking.egress_control.appliance_vendor:
binds: true
type: string
question: Which inspection appliance, if one is mandated?
networking.cidr_allocations:
binds: true
type: text
tier: {platform_foundation: important}
question: Which IP ranges are allocated, and how large per environment?
default: Private ranges that do not overlap, sized for growth.
affects: every network resource
governance.identity_source_of_truth:
binds: true
type: string
tier: important
question: Which identity provider do people sign in with?
default: The Cloud provider's own identities.
affects: access design
governance.pipeline_authentication:
binds: true
type: string
question: How do delivery pipelines authenticate?
default: Short-lived federated credentials, no stored keys.
governance.environment_tiers:
binds: true
type: records
keys: [name]
optional_keys: [archetype]
tier: important
question: Which environments are needed?
default: development, test and production.
affects: the number of environments built and planned
operations.operating_model:
type: string
question: "Who runs the platform day to day?"
operations.support_hours:
type: enum
values: [business_hours, extended, always]
question: During which hours is it supported?
default: business_hours
operations.monitoring:
type: text
question: What monitoring and alerting is expected?
default: The Cloud provider's own monitoring, with alerts on availability and errors.
operations.change_process:
type: text
question: "How are changes approved and released?"
integrations:
type: records
keys: [name]
optional_keys: [direction, criticality]
question: Which other systems must it exchange data with?
default: None.
delivery.target_start_date:
type: date
question: "When should work start?"
delivery.window_weeks:
type: integer
tier: important
question: Is there a deadline, in weeks from the start?
default: No deadline; the plan gives the time the work needs.
affects: the plan and whether the scope fits
delivery.commercial_model:
type: enum
values: [time_and_materials, fixed_price_milestone, managed_service]
question: How is the work contracted?
delivery.iac_tooling:
type: string
question: "Which infrastructure-as-code tool?"
default: terraform
delivery.ci_cd:
type: string
question: "Which delivery pipeline tool?"
delivery.team_size:
type: integer
tier: important
question: How many engineers will build it?
default: 2
affects: the timeline
delivery.working_days_per_week:
type: integer
default: 5
cost.monthly_budget:
type: number
tier: {workload: essential, migration: essential, platform_foundation: important}
question: What is the monthly running budget?
default: No ceiling; cost is optimised within the requirements.
affects: product tiers and resilience choices
cost.currency:
type: string
default: "USD"
constraints.products_required:
binds: true
type: list
question: Which products has the customer mandated?
default: None.
constraints.products_forbidden:
binds: true
type: list
question: Which products are ruled out?
default: None.
constraints.other:
type: list
run.pre_approved:
type: boolean
default: false
run.allow_cloud_read:
type: boolean
default: false
run.overlay_skills:
type: list
default: []
run.terraform_modules:
type: boolean
default: false

View File

@@ -0,0 +1,202 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

View File

@@ -0,0 +1,12 @@
cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30 LICENSE
758242af40565fed981ccf3011824b728ddeb46c96b98f1363826686fe3e0482 google-cloud-solution-architecture/SKILL.md
1e860e851c27001a1354a2c384bdd0c01a7102ed8d878861bd4952e3265a6eff google-cloud-solution-architecture/assets/output-template.md
d1b69d4daf1f43eeff587247fb604123b79ab825b412719df2d19904919dc1f6 google-cloud-solution-architecture/references/architecture-guides.md
ef71c1f0d6929f0cd53c40bcd1afe090febfca28f32c6379670c26e042aa0121 google-cloud-solution-architecture/references/best-practices-guides.md
9dbd6f0046a84f9f3e58d12315a420a840eaa15f3824808f654200d3e8af971e google-cloud-solution-architecture/references/decision-making-guides.md
3ff42b6532c35829a3a6ab9465a6258e334f1d20b244c2e07228ccf95b55d27a google-cloud-waf-cost-optimization/SKILL.md
519aaf57bfacf495f594c46c50726361422c4483bf84adce6e647137e95657d7 google-cloud-waf-operational-excellence/SKILL.md
03e6b3e523712cad48dc62e09804250c241fc34e88c18aa81a7d5b2aada7759a google-cloud-waf-performance-optimization/SKILL.md
a8ebafc1aa138a5d13544e352abe9454bb48859fcc41520d57547a0796cbdc8b google-cloud-waf-reliability/SKILL.md
e5dc59635a2e6a3d720495f81ea89beeb3c05e76acb6479928a675dfa8466ded google-cloud-waf-security/SKILL.md
f270005fb37adb04b3579d1f2c262506a77831e9e8977a050f2eeb755e08d1e9 google-cloud-waf-sustainability/SKILL.md

View File

@@ -0,0 +1,20 @@
# Vendored Agent Skills: google/skills
Unmodified copies of upstream Agent Skills. Do not edit these files; re-run
`scripts/sync-vendored-skills.sh <commit>` and review the diff instead (ADR-0002).
- Source: https://github.com/google/skills
- Commit: `81a31a6e4300425598a69fd96c8e843c947ae308`
- Synced: 2026-09-15
- Licence: Apache License 2.0, see `LICENSE`
- Integrity: `SHA256SUMS` lists every vendored file; `tests/test_vendored_skills.py` verifies it.
## Skills
- `google-cloud-solution-architecture` (upstream `skills/cloud/google-cloud-solution-architecture`)
- `google-cloud-waf-security` (upstream `skills/cloud/google-cloud-waf-security`)
- `google-cloud-waf-reliability` (upstream `skills/cloud/google-cloud-waf-reliability`)
- `google-cloud-waf-cost-optimization` (upstream `skills/cloud/google-cloud-waf-cost-optimization`)
- `google-cloud-waf-operational-excellence` (upstream `skills/cloud/google-cloud-waf-operational-excellence`)
- `google-cloud-waf-performance-optimization` (upstream `skills/cloud/google-cloud-waf-performance-optimization`)
- `google-cloud-waf-sustainability` (upstream `skills/cloud/google-cloud-waf-sustainability`)

View File

@@ -0,0 +1,273 @@
---
name: google-cloud-solution-architecture
metadata:
category: MultiProductSolutions
description: >-
Interactively discovers requirements and designs holistic, multi-product
system architectures, solution blueprints, and deployment recommendations for
complex workloads on Google Cloud. Use when designing end-to-end cloud
solutions, selecting and integrating Google Cloud services, generating
architecture diagrams, or conducting requirements discovery for new cloud
workloads or migrations. Don't use for single-product tasks (use
product-specific skills), initial onboarding or authentication (use
google-cloud-recipe-*), Well-Architected Framework reviews or audits (use
google-cloud-waf-*), or workloads covered by specialized solution skills.
---
# Google Cloud solution-architecture workflow
## Overview of the workflow
The workflow consists of the following phases:
* **Phase 1: Requirements discovery**. Gather detailed requirements related to
the cloud workload or use case that the user needs assistance for.
* **Phase 2: Solution architecture**. Use the requirements that were gathered
in Phase 1 to generate a detailed solution architecture for the cloud
workload or use case.
* **Phase 3: Solution validation**. Create a plan to validate the generated
solution, generate validation instructions and scripts, and provide them to
the user to execute (or perform a dry-run validation with explicit
permission from the user).
* **Phase 4: Solution packing and presentation**. Consolidate the generated
content and present the solution.
**Important notes about the workflow**:
* **Strict phase separation**: During Phase 1 (Requirements discovery), when
you ask the user clarifying questions, don't recommend, propose, or outline
any architectural designs, technical decompositions, cloud services, or
component mappings. Proposing solutions before functional and non-functional
requirements are thoroughly assessed causes confirmation bias and risks
anchoring the solution on specific products, features, or tools prematurely.
* **Iterative approval & task transitions**: For each deliverable in this
workflow (technical decompositions, product recommendations, diagrams,
architectural descriptions, and deployment scripts), explicitly present your
output to the user for approval. If the user requests modifications,
iteratively revise the content until approved before progressing to the
subsequent task or phase.
* **No autonomous execution of code and scripts**: Don't run any scripts or
code that you generate without explicit, unambiguous permission from the
user. Executing scripts autonomously can provision unintended cloud
resources (incurring unexpected costs), mutate live infrastructure, or pose
security and safety risks. Always offer the option for the user to execute
the commands manually.
* **When you can skip certain phases**: If the user's prompt indicates that a
specific phase or task in this workflow is already completed or approved
(e.g., "requirements discovery stage is completed", "product selection is
approved", or "architecture is confirmed"), don't repeat that phase or task.
Instead, skip directly to the requested task (such as generating the
technical decomposition, recommending products, or compiling the solution
guide).
## Phase 1: Requirements discovery
1. Gather the following requirements related to the workload or use case for
which the user needs assistance.
**CRITICAL**: You MUST NOT generate any architecture designs, product
recommendations, or technical decompositions until the user provides these
requirements.
* **Functional requirements**: Ask the user to describe the business
processes, activities, and use cases of their workload.
* **Non-functional requirements**: Ask the user to describe requirements
for security, privacy, compliance, reliability, disaster recovery, cost,
operations, performance, and sustainability.
* **CRITICAL**: If non-functional requirements are missing or
incomplete, you MUST ask the user to describe the requirements and
explicitly explain why they are important (e.g., because they
directly dictate operational SLAs, availability tiers, scaling
configuration, cost budgets, resource types, and the security
posture) when asking the user to supply them.
* **Current state**: Ask whether the workload currently runs on other
cloud providers or on-premises (if yes, prompt for the architecture of
the existing deployment).
* **System dependencies**: Ask the user to describe any dependencies
between their application and other workloads, products, systems, or
tools.
2. Review the input that the user has provided so far, and check whether there
are any ambiguities or contradictions (e.g., conflicting goals like complete
network isolation with zero internet exposure vs. real-time ingestion from
public APIs).
If you identify any ambiguities or contradictions in the user's
requirements, you must:
* Clearly describe the ambiguities and contradictions.
* Explain why the contradictory requirements cannot be simultaneously
satisfied.
* Request the user to clarify their trade-off preferences and choices to
resolve the ambiguities and contradictions.
* If the user delegates the choice to you (e.g., the user replies with
"do what you think is best" or "you decide"), then provide a clear
suggestion to resolve the ambiguity or contradiction, explain your
reasoning, and ask the user to approve your suggestion.
**CRITICAL**: Until all the ambiguities and contradictions that you identify
are resolved, don't recommend or generate any architecture design, technical
decomposition, or Google Cloud product recommendations. Ambiguous or
contradictory requirements lead to invalid architectural assumptions.
3. Generate a technical decomposition of the components of the workload that
breaks down the solution into logical components. Present it to the user and
obtain approval before proceeding to Phase 2.
**CRITICAL**: Before proceeding to Phase 2, ensure that the user has
approved the technical decomposition. Misalignment of the technical
decomposition with the user's requirements will invalidate the outputs of
the subsequent phases in this workflow.
## Phase 2: Solution architecture
Use the approved requirements from Phase 1 to generate a comprehensive solution
architecture.
### Ground all generated content
For each task in this phase, to ensure that the generated content aligns with
the latest and official Google Cloud guidance, you must ground the generated
content by using the following resources:
* Google Developer Knowledge MCP server
* Server: https://developerknowledge.googleapis.com/mcp
* Tools:
* `developerknowledge:search_documents`
* `developerknowledge:get_documents`
* `developerknowledge:answer_query`
* Relevant skills from https://github.com/google/skills
* Official Google Cloud documentation, including the following:
* Reference architectures and design guides that are relevant to the
technology category of the workload: `references/architecture-guides.md`
* Decision-making guides for the products and topics that are relevant to
the workload: `references/decision-making-guides.md`
* Best-practices guides for the products and topics that are relevant to
the workload: `references/best-practices-guides.md`
For each item in the generated guidance, you must include citations to the
relevant official Google Cloud documentation pages.
### Task 2.1: Identify Google Cloud products and features required for the workload.
1. Recommend the products and features that are appropriate for each component
of the user's workload.
**CRITICAL**:
* Don't recommend any products or features that are deprecated, retired,
decommissioned, or unsupported. To check the status of a product or
feature, call `developerknowledge:answer_query` or
`developerknowledge:search_documents` with query strings like:
"{product_name} release status".
* If multiple products or features can be used for a component of the
workload, then do the following:
* Recommend the most appropriate product or feature. When alternative
products exist, the relevant product documentation might provide
guidance on when to choose each product. Follow that guidance.
* Mention the available alternative products or features.
* Explain the pros and cons of each alternative product or feature.
2. Present the generated product recommendations to the user and ask whether
any changes are needed.
**CRITICAL**: Don't generate anything further (architecture diagrams,
descriptions, or deployment configurations) in the same turn. Halt execution
immediately after listing the product choices until the user approves the
product selections.
3. After the user approves the product selections, proceed to Task 2.2.
### Task 2.2: Generate an architecture diagram.
1. Generate an architecture diagram in Mermaid format:
https://github.com/mermaid-js/mermaid.
2. Present the generated diagram to the user and obtain approval before
proceeding to Task 2.3.
### Task 2.3: Generate an architecture description.
1. Generate a description that explains the purpose of each component, the
relationships between the components, and the task flow or data flow.
2. Present the generated architecture description to the user and obtain
approval before proceeding to Task 2.4.
### Task 2.4: Generate design recommendations.
1. Generate design recommendations and best practices to optimally configure
each component in the architecture based on the workload's requirements.
**Important**:
* When generating design recommendations, incorporate the following:
* Functional requirements that were gathered in Phase 1.
* Non-functional requirements that were gathered in Phase 1.
* To generate guidance for non-functional requirements, use the following
skills, as appropriate:
- `google-cloud-waf-security`
- `google-cloud-waf-reliability`
- `google-cloud-waf-cost-optimization`
- `google-cloud-waf-operational-excellence`
- `google-cloud-waf-performance-optimization`
- `google-cloud-waf-sustainability`
If any of the specialized `google-cloud-waf-*` skills are not available in
your current workspace, derive design guidance directly from the
documentation references in `references/best-practices-guides.md`.
2. Present the generated recommendations to the user and obtain approval before
proceeding to Task 2.5.
### Task 2.5: Generate deployment guidance.
1. Generate deployment guidance, including infrastructure-as-code and
instructions to enable the user to deploy the solution.
2. Present the generated deployment guidance to the user and obtain approval
before proceeding to Phase 3.
## Phase 3: Solution validation
### Task 3.1: Pre-deployment validation
1. Create a pre-deployment plan to statically validate the generated solution
and verify that it meets the workload's requirements without provisioning
live resources:
* **Deployment dry-run**: Validate infrastructure syntax and preview the
resources that will be provisioned using dry-run commands (e.g.,
`terraform plan` or (where supported) `gcloud ... --dry-run`).
* **Architecture & policy analysis**: Perform static verification of
network routing topologies, firewall rules, and IAM enforcement against
best practices.
2. Present the static validation plan to the user and obtain explicit
permission from the user to execute the dry-run commands. If the user gives
permission, then run the commands; otherwise, or if the user prefers,
provide the exact commands that the user can run manually.
3. Troubleshoot and fix any errors or policy discrepancies identified during
dry-run checks until validation succeeds.
4. Proceed to Task 3.2
### Task 3.2: Runtime validation (Post-deployment)
1. Ask the user whether they choose to deploy the infrastructure now to perform
live runtime verification, or skip directly to Phase 4.
2. **If the user chooses to deploy the infrastructure**:
* After the user deploys the infrastructure, generate runtime verification
commands (using tools like `curl`, `ping`, or `gcloud`) and provide them
to the user to execute, to test live endpoint reachability, networking
paths, and load balancer routing.
* Troubleshoot any deployment or runtime routing issues until checks pass.
3. Proceed to Phase 4.
## Phase 4: Solution packaging and presentation
Package all the generated text and code artifacts for final presentation.
1. Consolidate the text artifacts that were generated in Phase 2 and Phase 3
into a single Markdown file named `solution-architecture-guide.md`, based on
the template in `assets/output-template.md`.
2. Request the user's permission to write the code files in the user's
workspace.
3. After the user gives permission, write the code files in the user's
workspace.

View File

@@ -0,0 +1,124 @@
<!-- Use this template to compile the content that you generate based on the
instructions in `SKILL.md`. -->
# Google Cloud solution architecture: [Workload Name]
## 1. Executive summary and workload overview
[A brief description of the workload, its business goals, and the high-level
solution architecture proposed.]
## 2. Requirements and current state
### 2.1. Functional requirements
* **Business processes**: [Details of the business processes supported]
* **Activities and use cases**: [Details of the key activities and use cases]
### 2.2. Non-functional requirements
* **Security**: [Details of the security requirements including compliance,
encryption, access control requirements]
* **Reliability**: [Details of the reliability requirements including SLA,
RTO/RPO, backup, redundancy requirements]
* **Cost**: [Details of the cost constraints and pricing models]
* **Operations**: [Details of the operational requirements including
monitoring, logging, deployment, maintenance requirements]
* **Performance**: [Details of the performance requirements including latency,
throughput, scaling requirements]
* **Sustainability**: [Details of the sustainability requirements including
carbon footprint, resource optimization requirements]
### 2.3. Current state
[If applicable, describe the current on-premises or other-cloud architecture.]
* **Current infrastructure**: [Details of existing setup]
* **Pain points and drivers for migration/redesign**: [Details of the drivers
for migration/redesign]
### 2.4. Dependencies
* **Internal dependencies**: [Details of internal dependencies including other
workloads and internal services]
* **External dependencies**: [Details of external dependencies including
third-party products and on-premises tools]
## 3. Technical decomposition of the workload
[Technical decomposition of the workload components, breaking down the
application into logical services or layers.]
## 4. Proposed solution architecture
### 4.1. Google Cloud products and features mapping
[Identify Google Cloud products and features mapped to the technical
components. For each component, justify the selection, note alternatives
considered, and describe the pros and cons of the recommended product/feature
and alternatives.]
| Component | Recommended Google Cloud product/feature | Justification and citations | Alternatives considered | Pros and cons of alternatives |
| :--- | :--- | :--- | :--- | :--- |
| **[Component Name]** | **[Product Name]** | [Why this product is chosen, citing official docs] | [Alternative product] | **Pros**: ... <br> **Cons**: ... |
### 4.2. Architecture diagram
[Architecture diagram in Mermaid format showing the relationships and flows
between the components of the architecture.]
```mermaid
%% Example structure
graph TD
User([User]) --> Web[Load Balancer]
Web --> App[Application Layer]
App --> DB[(Database)]
```
### 4.3. Architecture description
[Detailed description of the architecture. Describe the task flow and data
flow between the components of the architecture.]
* **Data flow**: [Describe the flow of data.]
* **Tasks/control flow**: [Describe the flow of tasks/control.]
## 5. Design and configuration recommendations
[Best practices and configuration recommendations for each pillar of the
Google Cloud Architecture Framework.]
### 5.1. Security, privacy, and compliance
* **Access control**: [E.g., IAM roles, least privilege policy]
* **Data protection**: [E.g., Encryption at rest/in transit, Cloud KMS]
* **Network Security**: [E.g., VPC, Firewalls, Cloud Armor, Private Service Connect]
### 5.2. Reliability
* **Redundant deployment**: [E.g., Multi-region/regional deployment, load
balancing]
* **Backup and DR**: [E.g., Backups, failover procedures, RTO/RPO strategies]
### 5.3. Operational excellence
* **Monitoring and logging**: [E.g., Cloud Logging, Cloud Monitoring, Dashboards]
* **Infrastructure as Code (IaC)**: [E.g., Terraform, Deployment Manager]
### 5.4. Cost optimization
* **Sizing and scaling**: [E.g., Autoscaling configuration, right-sizing resources]
* **Pricing models**: [E.g., Commitment discounts, Spot VMs, flat-rate pricing]
### 5.5. Performance efficiency
* **Caching and CDN**: [E.g., Cloud CDN, Memorystore]
* **Database and query optimization**: [E.g., Partitioning, indexing, caching]
### 5.6. Sustainability
* [E.g., Serverless adoption, resource utilization, carbon footprint]
## 6. Deployment guidance
[Instructions and code for deploying the architecture.]
### 6.1. Deployment prerequisites
* [Prerequisite 1: E.g., Enabling APIs]
* [Prerequisite 2: E.g., Installing SDK/tools]
* ...and so on
### 6.2. Step-by-step deployment instructions
1. [Step 1: E.g., Authenticate with Google Cloud]
2. [Step 2: E.g., Initialize Terraform]
3. [Step 3: E.g., Apply Terraform configuration]
## 7. Validation plan
[Details of the steps to verify that the generated solution meets the workload's
requirements. Also include references to any validation scripts that were
generated.]
## 8. References
* [E.g., Horizontal scalability](https://docs.cloud.google.com/architecture/framework/reliability/horizontal-scalability)
* [E.g., Regional managed instance groups](https://docs.cloud.google.com/compute/docs/instance-groups/regional-migs)

View File

@@ -0,0 +1,362 @@
# Architecture guides
| Technology category | Brief description | Line hints |
|---------------------|-------------------|------------|
| [Fundamentals](#fundamentals) | Design guides, reference architectures, and best practices for foundational cloud architectures, landing zones, and deployment archetypes. | Lines 19-46 |
| [AI and ML](#ai-ml) | Design guides, reference architectures, and best practices for AI, MLOps, generative AI, and agentic workflows. | Lines 47-98 |
| [Application development](#application-development) | Design guides, reference architectures, and best practices for building, deploying, and running applications in the cloud. | Lines 99-132 |
| [Security, privacy, and compliance](#security-privacy-and-compliance) | Design guides, reference architectures, and best practices for security, privacy, and compliance. | Lines 133-207 |
| [Reliability and disaster recovery](#reliability-and-disaster-recovery) | Design guides, reference architectures, and best practices for reliability and disaster recovery. | Lines 208-230 |
| [Data and analytics](#data-and-analytics) | Design guides, reference architectures, and best practices for data warehousing, data mesh, data analytics, and data streaming. | Lines 231-248 |
| [Databases](#databases) | Design guides, reference architectures, and best practices for planning and implementing databases for cloud workloads. | Lines 249-268 |
| [Migration](#migration) | Methodologies, assessment frameworks, and guides for migrating VMs, databases, and applications to Google Cloud. | Lines 269-295 |
| [Networking](#networking) | Design guides, reference architectures, and best practices for planning and implementing networking for cloud workloads. | Lines 296-315 |
| [Hybrid, multi-cloud, and distributed cloud](#hybrid-multi-cloud-and-distributed-cloud) | Design guides, reference architectures, and best practices for hybrid, multi-cloud, and distributed cloud environments. | Lines 316-337 |
| [Financial services](#financial-services) | Design guides, reference architectures, and best practices for financial services workloads. | Lines 338-341 |
| [Monitoring and logging](#monitoring-and-logging) | Best practices and operational patterns for observability, log streaming, and infrastructure monitoring. | Lines 342-354 |
| [Storage](#storage) | Design guides, reference architectures, and best practices to help you plan and implement storage for cloud workloads. | Lines 355-361 |
## <a id="fundamentals"></a>Fundamentals
- [Authentication and authorization](https://docs.cloud.google.com/architecture/blueprints/security-foundations/authentication-authorization.md.txt): Introduces how to use Cloud Identity to manage identities for accessing Google Cloud services.
- [Comparative analysis of Google Cloud deployment archetypes](https://docs.cloud.google.com/architecture/deployment-archetypes/comparison.md.txt): Compares the cloud deployment archetypes in terms of the availability they provide, resilience to zone and region outages, cost, and operational complexity.
- [Decide a resource hierarchy for your Google Cloud landing zone](https://docs.cloud.google.com/architecture/landing-zones/decide-resource-hierarchy.md.txt): Provides guidance to help you decide the resource hierarchy for your Google Cloud landing zone.
- [Decide how to onboard identities to Google Cloud](https://docs.cloud.google.com/architecture/landing-zones/decide-how-to-onboard-identities.md.txt): Describes identity provisioning options for Google Cloud and the decisions that you must make when you onboard your users to Cloud Identity or Google Workspace.
- [Decide the network design for your Google Cloud landing zone](https://docs.cloud.google.com/architecture/landing-zones/decide-network-design.md.txt): Describes common network designs for landing zones, and helps you choose the option that best meets your requirements.
- [Decide the security for your Google Cloud landing zone](https://docs.cloud.google.com/architecture/landing-zones/decide-security.md.txt): Provides guidance to help you decide the security design for your Google Cloud landing zone.
- [Deploy the blueprint](https://docs.cloud.google.com/architecture/blueprints/security-foundations/summary.md.txt): Describes the process to deploy an enterprise foundation using a blueprint.
- [Deployment methodology](https://docs.cloud.google.com/architecture/blueprints/security-foundations/deployment-methodology.md.txt): Provides guidance to use declarative infrastructure to deploy an enterprise foundations blueprint.
- [Detective controls](https://docs.cloud.google.com/architecture/blueprints/security-foundations/detective-controls.md.txt): Describes the threat detection and monitoring controls that are incorporated into an enterprise foundations blueprint.
- [Enterprise foundations blueprint](https://docs.cloud.google.com/architecture/blueprints/security-foundations.md.txt): Describes a blueprint to deploy foundational resources, configurations, and capabilities to help ensure consistent governance, security, scaling, and observability for your workloads in Google Cloud.
- [Google Cloud deployment archetypes](https://docs.cloud.google.com/architecture/deployment-archetypes.md.txt): Describes the deployment archetypes that you can use for cloud applications, the use cases for each deployment archetype and the design considerations.
- [Google Cloud global deployment archetype](https://docs.cloud.google.com/architecture/deployment-archetypes/global.md.txt): Describes the global deployment archetype, and its use cases and design considerations.
- [Google Cloud hybrid deployment archetype](https://docs.cloud.google.com/architecture/deployment-archetypes/hybrid.md.txt): Describes the hybrid deployment archetype, and its use cases and design considerations.
- [Google Cloud multi-regional deployment archetype](https://docs.cloud.google.com/architecture/deployment-archetypes/multiregional.md.txt): Describes the multi-regional deployment archetype, and its use cases and design considerations.
- [Google Cloud multicloud deployment archetype](https://docs.cloud.google.com/architecture/deployment-archetypes/multicloud.md.txt): Describes the multicloud deployment archetype, and its use cases and design considerations.
- [Google Cloud regional deployment archetype](https://docs.cloud.google.com/architecture/deployment-archetypes/regional.md.txt): Describes the regional deployment archetype, and its use cases and design considerations.
- [Google Cloud zonal deployment archetype](https://docs.cloud.google.com/architecture/deployment-archetypes/zonal.md.txt): Describes the zonal deployment archetype, and its use cases and design considerations.
- [Implement your Google Cloud landing zone network design](https://docs.cloud.google.com/architecture/landing-zones/implement-network-design.md.txt): Provides steps and guidance to implement your chosen network design for your landing zone.
- [Landing zone design in Google Cloud](https://docs.cloud.google.com/architecture/landing-zones.md.txt): This series shows how to design and build a landing zone in Google Cloud, guiding you through high-level decisions about identity onboarding, resource hierarchy, network design, and security.
- [Operations best practices](https://docs.cloud.google.com/architecture/blueprints/security-foundations/operation-best-practices.md.txt): Provides best practices for deploying and operating workloads in a Google Cloud environment that&#39;s based on an enterprise foundations blueprint.
- [Organization structure](https://docs.cloud.google.com/architecture/blueprints/security-foundations/organization-structure.md.txt): Describes how the resources in an enterprise foundations blueprint are organized.
- [Preventative controls for acceptable resource configurations](https://docs.cloud.google.com/architecture/blueprints/security-foundations/preventative-controls.md.txt): Describes preventative controls that you can incorporate into an enterprise foundations blueprint.
- [Well-Architected Framework: Cost optimization pillar](https://docs.cloud.google.com/architecture/framework/cost-optimization/printable.md.txt): Provides principles and recommendations to help you optimize the cost of your workloads in Google Cloud.
- [Well-Architected Framework: Performance optimization pillar](https://docs.cloud.google.com/architecture/framework/performance-optimization/printable.md.txt): Provides principles and recommendations to help you optimize the performance of your workloads in Google Cloud.
- [Well-Architected Framework: Sustainability pillar](https://docs.cloud.google.com/architecture/framework/sustainability/printable.md.txt): Provides principles and recommendations to help you design, build, and manage workloads in Google Cloud that are energy-efficient and carbon-aware.
## <a id="ai-ml"></a>AI and ML
- [Agentic AI use case: Administer interactive learning](https://docs.cloud.google.com/architecture/agentic-ai-interactive-learning.md.txt): Design a single-agent AI system that assesses a user&#39;s knowledge on a specific topic and generates a personalized learning experience.
- [Agentic AI use case: Automate data science workflows](https://docs.cloud.google.com/architecture/agentic-ai-data-science.md.txt): Design a multi-agent AI system that automates complex data analytics and machine learning tasks.
- [Agentic AI use case: Build a multicloud open data lakehouse](https://docs.cloud.google.com/architecture/agentic-ai-build-multicloud-open-data-lakehouse.md.txt): A high-level architecture to build a multicloud open data lakehouse that establishes a highly governed, secure pipeline from raw multicloud silos to AI and agentic driven actions.
- [Agentic AI use case: Classify multimodal data](https://docs.cloud.google.com/architecture/agentic-ai-classify-multimodal-data.md.txt): A high-level architecture to design a multi-agent AI system that analyzes disparate multimodal data and produces a high-confidence classification.
- [Agentic AI use case: Enable live bidirectional multimodal streaming](https://docs.cloud.google.com/architecture/agentic-ai-bidirectional-multimodal-streaming.md.txt): A high-level architecture to build and deploy a multi-agent AI system that provides technical guidance and automated safety monitoring through a continuous, bidirectional stream of multimodal data.
- [Agentic AI use case: Multimodal GraphRAG resource orchestration](https://docs.cloud.google.com/architecture/agentic-ai-multimodal-graph-rag-resource-orchestration.md.txt): A high-level architecture to build and deploy a multi-agent AI system that consolidates fragmented multimodal data into a searchable knowledge graph.
- [Agentic AI use case: Orchestrate access to disparate enterprise systems](https://docs.cloud.google.com/architecture/agenticai-orchestrate-access-disparate-systems.md.txt): Use agentic AI to orchestrate access to disparate enterprise systems.
- [Agentic AI use case: Orchestrate security operations workflows](https://docs.cloud.google.com/architecture/agentic-ai-orchestrate-security-ops-workflows.md.txt): A high-level architecture to build a multi-agent AI system that orchestrates complex investigation and triage processes in a security operations center (SOC).
- [Architecture for MLOps using TensorFlow Extended, Agent Platform Pipelines, and Cloud Build](https://docs.cloud.google.com/architecture/architecture-for-mlops-using-tfx-kubeflow-pipelines-and-cloud-build.md.txt): Describes the architecture of a machine learning (ML) system using TensorFlow Extended (TFX) libraries.
- [Automate utilization-review of health insurance claims using generative AI](https://docs.cloud.google.com/architecture/use-generative-ai-utilization-management.md.txt): A reference architecture for health insurance companies to automate prior authorization (PA) request processing and improve their utilization review (UR) processes.
- [Best practices for implementing machine learning on Google Cloud](https://docs.cloud.google.com/architecture/ml-on-gcp-best-practices.md.txt): Introduces best practices for implementing machine learning (ML) on Google Cloud, with a focus on custom-trained models based on your data and code.
- [Build an ML vision analytics solution with Dataflow and Cloud Vision API](https://docs.cloud.google.com/architecture/building-a-vision-analytics-solution.md.txt): How to deploy a Dataflow pipeline to process large-scale image files with Cloud Vision. Dataflow stores the results in BigQuery so that you can use them to train BigQuery ML pre-built models.
- [Build and deploy generative AI and machine learning models in an enterprise](https://docs.cloud.google.com/architecture/blueprints/genai-mlops-blueprint.md.txt): Describes the generative AI and machine learning (ML) blueprint, which deploys a pipeline for creating AI models.
- [Build trusted AI agents with Google Maps Platform](https://docs.cloud.google.com/architecture/agentic-ai-system-with-grounding-using-maps.md.txt): A high-level architecture to build trusted and effective AI agents by grounding them in real-world contextual data from Google Maps Platform and Google Calendar.
- [C3 AI architecture on Google Cloud](https://docs.cloud.google.com/architecture/partners/c3-ai-architecture.md.txt): Develop applications using C3 AI and Google Cloud.
- [Choose a design pattern for your agentic AI system](https://docs.cloud.google.com/architecture/choose-design-pattern-agentic-ai-system.md.txt): Learn how to select an agent design pattern to build your agentic system.
- [Choose your agentic AI architecture components](https://docs.cloud.google.com/architecture/choose-agentic-ai-architecture-components.md.txt): Learn how to select architecture components to build your agentic AI system.
- [Confidential computing for data analytics, AI, and federated learning](https://docs.cloud.google.com/architecture/security/confidential-computing-analytics-ai.md.txt): &#34;Learn about how you can use confidential computing in Google Cloud to encrypt data in use for confidential data analytics, AI machine learning, and federated learning.&#34;
- [Cross-silo and cross-device federated learning on Google Cloud](https://docs.cloud.google.com/architecture/cross-silo-cross-device-federated-learning-google-cloud.md.txt): Provides guidance to help you create a federated learning platform that supports either a cross-silo or cross-device architecture.
- [Delete the Generative AI document summarization](https://docs.cloud.google.com/architecture/ai-ml/generative-ai-document-summarization.md.txt): Delete the Generative AI document summarization Jump Start Solution.
- [Delete the Generative AI Knowledge Base](https://docs.cloud.google.com/architecture/ai-ml/generative-ai-knowledge-base.md.txt): Delete the Generative AI Knowledge Base Jump Start Solution.
- [Delete the Generative AI RAG with Cloud SQL](https://docs.cloud.google.com/architecture/ai-ml/generative-ai-rag.md.txt): Delete the Generative AI RAG with Cloud SQL Jump Start Solution.
- [Deploy an ML vision analytics solution with Dataflow and Cloud Vision API](https://docs.cloud.google.com/architecture/building-a-vision-analytics-solution/deployment.md.txt): Describes how to deploy a Dataflow pipeline that processes image files at scale with Cloud Vision API and then stores the processed output in BigQuery for analytics and model training.
- [Deploy and operate generative AI applications](https://docs.cloud.google.com/architecture/deploy-operate-generative-ai-applications.md.txt): Discusses techniques for building and operating generative AI applications using MLOps and DevOps principles.
- [Generative AI use case: Generate content for personalized marketing campaigns](https://docs.cloud.google.com/architecture/genai-marketing-campaigns.md.txt): Use AI to generate personalized content for targeted marketing campaigns.
- [Generative AI use case: Generate personalized product recommendations](https://docs.cloud.google.com/architecture/genai-product-recommendations.md.txt): Use AI to generate personalized product recommendations for a retail application.
- [Generative AI use case: Generate podcasts from audio files](https://docs.cloud.google.com/architecture/genai-podcasts-from-commentary.md.txt): Use AI to generate podcasts based on audio input.
- [Generative AI use case: Generate solutions for customer-support questions](https://docs.cloud.google.com/architecture/genai-customer-support.md.txt): Use AI to generate responses to support questions from customers.
- [Generative AI with RAG](https://docs.cloud.google.com/architecture/rag-reference-architectures.md.txt): Provides a list of reference architectures to deploy generative AI applications with retrieval-augmented generation (RAG) in Google Cloud.
- [GraphRAG infrastructure for generative AI using Agent Platform and Spanner Graph](https://docs.cloud.google.com/architecture/gen-ai-graphrag-spanner.md.txt): Design infrastructure for a generative AI application with GraphRAG using Spanner Graph.
- [Guidelines for developing high-quality, predictive ML solutions](https://docs.cloud.google.com/architecture/guidelines-for-developing-high-quality-ml-solutions.md.txt): Collates some guidelines to help you assess, ensure, and control quality in machine learning (ML) solutions.
- [Harness CI/CD pipeline for RAG applications](https://docs.cloud.google.com/architecture/partners/harness-cicd-pipeline-for-rag-app.md.txt): Shows you how to implement a Harness CI/CD pipeline for a RAG-capable application in Google Cloud.
- [Implement agentic analytics workflows for distributed data](https://docs.cloud.google.com/architecture/agentic-ai-cross-cloud-analytics.md.txt): A high-level architecture for implementing cross-cloud analytics workflows that use AI agents.
- [Implement two-tower retrieval for large-scale candidate generation](https://docs.cloud.google.com/architecture/implement-two-tower-retrieval-large-scale-candidate-generation.md.txt): Learn how to implement an end-to-end two-tower candidate generation workflow with Vertex AI.
- [MLOps: Continuous delivery and automation pipelines in machine learning](https://docs.cloud.google.com/architecture/mlops-continuous-delivery-and-automation-pipelines-in-machine-learning.md.txt): Discusses techniques for implementing and automating continuous integration (CI), continuous delivery (CD), and continuous training (CT) for machine learning (ML) systems.
- [Model development and data labeling with Google Cloud and Labelbox](https://docs.cloud.google.com/architecture/partners/model-development-data-labeling-labelbox-google-cloud.md.txt): Provides guidance for building a standardized pipeline to help accelerate the development of ML models.
- [Multi-agent AI system in Google Cloud](https://docs.cloud.google.com/architecture/multiagent-ai-system.md.txt): Design robust multi-agent AI systems in Google Cloud.
- [Multi-tenant agentic AI system](https://docs.cloud.google.com/architecture/multi-tenant-agentic-ai-system.md.txt): Design a multi-tenant agentic AI system on Google Cloud.
- [Networking for AI inference model serving on all backends](https://docs.cloud.google.com/architecture/networking-for-ai-inference.md.txt): Guidance to help you create a unified frontend for multiple AI models that are hosted on-premises or by any provider, including third-party and Google Cloud.
- [Networking for AI inference model serving on GKE](https://docs.cloud.google.com/architecture/networking-for-ai-inference-gke.md.txt): Guidance to help you create a multiple-model inference service using GKE.
- [Optimize AI and ML workloads with Cloud Storage FUSE](https://docs.cloud.google.com/architecture/optimize-ai-ml-workloads-cloud-storage-fuse.md.txt): Use Cloud Storage FUSE to optimize the performance of AI and ML workloads.
- [Optimize AI and ML workloads with Google Cloud Managed Lustre](https://docs.cloud.google.com/architecture/optimize-ai-ml-workloads-managed-lustre.md.txt): Shows how to use Managed Lustre to optimize the performance of AI and ML workloads.
- [Private connectivity for RAG-capable generative AI applications](https://docs.cloud.google.com/architecture/private-connectivity-rag-capable-gen-ai.md.txt): Implement network infrastructure to help improve security for your RAG-capable applications.
- [RAG infrastructure for generative AI using Agent Platform and AlloyDB for PostgreSQL](https://docs.cloud.google.com/architecture/rag-capable-gen-ai-app-using-vertex-ai.md.txt): Design infrastructure to run a generative AI application with retrieval-augmented generation using AlloyDB as the vector store.
- [RAG infrastructure for generative AI using Agent Platform and Vector Search](https://docs.cloud.google.com/architecture/gen-ai-rag-vertex-ai-vector-search.md.txt): Design infrastructure for a generative AI application with retrieval-augmented generation (RAG) using the vector search capabilities of Gemini Enterprise Agent Platform.
- [RAG infrastructure for generative AI using Gemini Enterprise and Agent Platform](https://docs.cloud.google.com/architecture/rag-genai-gemini-enterprise-vertexai.md.txt): Design infrastructure for a generative AI application with retrieval-augmented generation (RAG) using Gemini Enterprise and Gemini Enterprise Agent Platform.
- [RAG infrastructure for generative AI using GKE and Cloud SQL](https://docs.cloud.google.com/architecture/rag-capable-gen-ai-app-using-gke.md.txt): Shows you how to design the infrastructure for a generative AI application with RAG using GKE.
- [Single-agent AI system using ADK and Cloud Run](https://docs.cloud.google.com/architecture/single-agent-ai-system-adk-cloud-run.md.txt): Shows you how to build a single-agent AI system by using ADK and Cloud Run with Gemini and MCP.
- [Well-Architected Framework: AI and ML perspective](https://docs.cloud.google.com/architecture/framework/perspectives/ai-ml/printable.md.txt): Provides principles and recommendations to help you design, build, and manage AI and ML workloads in Google Cloud that meet your operational, security, reliability, cost, and performance goals.
## <a id="application-development"></a>Application development
- [Architecture decision records overview](https://docs.cloud.google.com/architecture/architecture-decision-records.md.txt): Explains when and how to use architecture decision records (ADRs) to document and explain design choices for applications on Google Cloud.
- [Best practices for automatically provisioning and configuring edge and bare metal systems and servers](https://docs.cloud.google.com/architecture/connected-devices/best-practices-provisioning-configuring-bare-metal.md.txt): Describes best practices for automatically provisioning and configuring edge devices and bare metal systems and servers.
- [Best practices for running cost-optimized Kubernetes applications on GKE](https://docs.cloud.google.com/architecture/best-practices-for-running-cost-effective-kubernetes-applications-on-gke.md.txt): Discusses best practices for running cost-optimized applications on Google Kubernetes Engine (GKE).
- [CI/CD pipeline for developing and delivering containerized apps](https://docs.cloud.google.com/architecture/app-development-and-delivery-with-cloud-code-gcb-cd-and-gke.md.txt): Describes how to set up and use a development, continuous integration (CI), and continuous delivery (CD) system using an integrated set of Google Cloud tools.
- [Configure Active Directory for VMs to automatically join a domain](https://docs.cloud.google.com/architecture/configuring-active-directory-for-vms-to-automatically-join-the-domain.md.txt): Shows you how to configure Active Directory and Compute Engine so that Windows virtual machine (VM) instances can automatically join an Active Directory domain.
- [Connected device architectures on Google Cloud](https://docs.cloud.google.com/architecture/connected-devices.md.txt): An overview on a series of approaches for connected device IoT architectures on Google Cloud.
- [Cymbal Bank application architecture](https://docs.cloud.google.com/architecture/blueprints/enterprise-application-blueprint/cymbal-bank.md.txt): Describes a sample containerized application that incorporates best practices from a blueprint for an enterprise developer platform.
- [Delete the Cloud SDK Client Library](https://docs.cloud.google.com/architecture/application-development/cloud-client-api.md.txt): Delete the Cloud SDK Client Library Jump Start Solution.
- [Delete the Dynamic web application with Python and JavaScript](https://docs.cloud.google.com/architecture/application-development/dynamic-app-python.md.txt): Delete the Dynamic web application with Python and JavaScript Jump Start Solution.
- [Delete the Ecommerce platform with serverless computing](https://docs.cloud.google.com/architecture/application-development/ecommerce-serverless.md.txt): Delete the Ecommerce platform with serverless computing Jump Start Solution.
- [Delete the Three-tier web app](https://docs.cloud.google.com/architecture/application-development/three-tier-web-app.md.txt): Delete the three-tier web app.
- [Deploy an Active Directory forest on Compute Engine](https://docs.cloud.google.com/architecture/deploy-an-active-directory-forest-on-compute-engine.md.txt): Shows you how to deploy an Active Directory forest on Compute Engine in a way that follows the best practices.
- [Deploy an enterprise developer platform on Google Cloud](https://docs.cloud.google.com/architecture/blueprints/enterprise-application-blueprint.md.txt): Describes the enterprise application blueprint, which deploys an internal developer platform that provides managed software development and delivery.
- [Deploy the blueprint](https://docs.cloud.google.com/architecture/blueprints/enterprise-application-blueprint/deploy-blueprint.md.txt): Describes the steps to deploy a blueprint for an enterprise developer platform.
- [Deployment methodology](https://docs.cloud.google.com/architecture/blueprints/enterprise-application-blueprint/deployment-methodology.md.txt): Describes the automated systems and pipelines that are used to deploy a blueprint for an enterprise developer platform.
- [Develop and deploy containerized apps using a CI/CD pipeline](https://docs.cloud.google.com/architecture/app-development-and-delivery-with-cloud-code-gcb-cd-and-gke/deployment.md.txt): Describes how to design and deploy a system for continuous integration (CI) and continuous delivery (CD) by using an integrated set of Google Cloud services and tools.
- [DevOps capabilities](https://docs.cloud.google.com/architecture/devops.md.txt)
- [From edge to multi-cluster mesh: Deploy globally distributed applications through GKE Gateway and Cloud Service Mesh](https://docs.cloud.google.com/architecture/build-apps-using-gateway-and-cloud-service/deployment.md.txt): Shows how to deploy globally distributed applications that are exposed through Google Kubernetes Engine (GKE) Gateway and Cloud Service Mesh.
- [From edge to multi-cluster mesh: Globally distributed applications exposed through GKE Gateway and Cloud Service Mesh](https://docs.cloud.google.com/architecture/build-apps-using-gateway-and-cloud-service.md.txt): Describes exposing applications externally through Google Kubernetes Engine (GKE) Gateways running on multiple GKE clusters within a service mesh.
- [IoT platform product architecture on Google Cloud](https://docs.cloud.google.com/architecture/connected-devices/iot-platform-product-architecture.md.txt): Describes basic architectural considerations and recommendations for deploying an IoT platform product architecture on Google Cloud.
- [Manage costs and attributions for the developer platform](https://docs.cloud.google.com/architecture/blueprints/enterprise-application-blueprint/manage-costs-attributions.md.txt): Provide guidance to manage costs when using a blueprint for an enterprise developer platform.
- [Multi-regional deployment on Compute Engine](https://docs.cloud.google.com/architecture/multiregional-vms.md.txt): Provides a reference architecture for a multi-tier application that runs on Compute Engine VMs in multiple regions and describes the design factors to consider when you build a multi-regional architecture.
- [Reference architecture: Resource management with ServiceNow](https://docs.cloud.google.com/architecture/resource-management-with-servicenow.md.txt): Provides architectural recommendations to integrate Google Cloud assets into ServiceNow discovery tools.
- [Regional deployment on Compute Engine](https://docs.cloud.google.com/architecture/regional-deployment-compute-engine.md.txt): Learn how to architect a multi-tier application that runs on Compute Engine VMs in multiple zones within a Google Cloud region.
- [Select a managed container runtime environment](https://docs.cloud.google.com/architecture/select-managed-container-runtime-environment.md.txt): Learn about managed runtime environments and assess your requirements to choose between Cloud Run and GKE Autopilot.
- [Service architecture](https://docs.cloud.google.com/architecture/blueprints/enterprise-application-blueprint/service-architecture.md.txt): Describes the service architecture of a blueprint for an enterprise developer platform.
- [Set up Chrome Remote Desktop for Linux on Compute Engine](https://docs.cloud.google.com/architecture/chrome-desktop-remote-on-compute-engine.md.txt): Shows you how to set up the Chrome Remote Desktop service on a Debian Linux virtual machine (VM) instance on Compute Engine. Chrome Remote Desktop allows you to remotely access applications with a graphical user interface.
- [Set up Chrome Remote Desktop for Windows on Compute Engine](https://docs.cloud.google.com/architecture/chrome-desktop-remote-windows-compute-engine.md.txt): Shows you how to set up the Chrome Remote Desktop service on a Microsoft Windows virtual machine (VM) instance on Compute Engine. Chrome Remote Desktop allows you to remotely access applications with a graphical user interface.
- [Single-zone deployment on Compute Engine](https://docs.cloud.google.com/architecture/single-zone-deployment-compute-engine.md.txt): Provides a reference architecture for a multi-tier application that runs on Compute Engine VMs in a single-zone region and describes the design factors to consider when you build a single-zone architecture.
- [Standalone MQTT broker architecture on Google Cloud](https://docs.cloud.google.com/architecture/connected-devices/mqtt-broker-architecture.md.txt): Describes an architecture for deploying an MQTT broker (the core application in an MQTT deployment) on Google Cloud.
- [Website hosting](https://docs.cloud.google.com/architecture/web-serving-overview.md.txt): How to host a website on Google Cloud. Google Cloud provides a robust, flexible, reliable, and scalable platform for serving websites.
## <a id="security-privacy-and-compliance"></a>Security, privacy, and compliance
- [Active Directory single sign-on](https://docs.cloud.google.com/architecture/identity/federating-gcp-with-active-directory-configuring-single-sign-on.md.txt): Shows how to set up single sign-on (SSO) between your Active Directory environment and your Cloud Identity or Google Workspace account by using Microsoft Active Directory Federation Services (AD FS) and SAML Federation.
- [Active Directory user account provisioning](https://docs.cloud.google.com/architecture/identity/federating-gcp-with-active-directory-synchronizing-user-accounts.md.txt): Shows how to set up user and group provisioning between Active Directory and your Cloud Identity or Google Workspace account by using Google Cloud Directory Sync (GCDS).
- [Architecture patterns](https://docs.cloud.google.com/architecture/hybrid-multicloud-secure-networking-patterns/architecture-patterns.md.txt): Discusses patterns that are designed based on the required communication models between applications residing in Google Cloud and in other environments.
- [Assess existing user accounts](https://docs.cloud.google.com/architecture/identity/assessing-existing-user-accounts.md.txt): Describes how to assess different types of existing user accounts when you&#39;re planning to manage identities across an organization.
- [Assess onboarding plans](https://docs.cloud.google.com/architecture/identity/assessing-onboarding-plans.md.txt): Provides guidance to onboard existing identities and new identities to Cloud Identity or Google Workspace.
- [Assess the impact of user account consolidation on federation](https://docs.cloud.google.com/architecture/identity/assessing-consolidation-impact-on-federation.md.txt): Describes how to assess the impact of user account consolidation on identity federation.
- [Automate malware scanning for files uploaded to Cloud Storage](https://docs.cloud.google.com/architecture/automate-malware-scanning-for-documents-uploaded-to-cloud-storage.md.txt): This document shows you how to build an event-driven pipeline that can help you automate the evaluation of files for malicious code.
- [Best practices for continuous access to Google Cloud](https://docs.cloud.google.com/architecture/security/best-practices-continuous-access-to-google-cloud.md.txt): Describes best practices for emergency access and IdP failover to ensure continuous access to Google Cloud.
- [Best practices for federating Google Cloud with an external identity provider](https://docs.cloud.google.com/architecture/identity/best-practices-for-federating.md.txt): Describes best practices for federating Google Cloud with an external identity provider.
- [Best practices for mitigating compromised OAuth tokens for Google Cloud CLI](https://docs.cloud.google.com/architecture/bps-for-mitigating-gcloud-oauth-tokens.md.txt): Describes how to mitigate the impact of an attacker compromising the OAuth tokens that are used by the gcloud CLI.
- [Best practices for planning accounts and organizations](https://docs.cloud.google.com/architecture/identity/best-practices-for-planning.md.txt): Provides guidance to determine the number of Cloud Identity or Google Workspace accounts, Google Cloud organizations, and billing accounts you need based on your security and organizational requirements.
- [Best practices for protecting against cryptocurrency mining attacks](https://docs.cloud.google.com/architecture/security/bps-for-protecting-against-crytocurrency-attacks.md.txt): Describes best practices for protecting against cryptocurrency mining attacks.
- [Best practices for running an IoT backend on Google Cloud](https://docs.cloud.google.com/architecture/connected-devices/bps-running-iot-backend-securely.md.txt): Describes best practices for running an IoT backend on Google Cloud.
- [Best practices for securing apps and resources by using context-aware access](https://docs.cloud.google.com/architecture/secure-apps-resources-using-context-aware-access/best-practices.md.txt): Describes best practices for using context-aware access to secure apps and resources.
- [Best practices for securing your applications and APIs using Apigee](https://docs.cloud.google.com/architecture/best-practices-securing-applications-and-apis-using-apigee.md.txt): Describes best practices that can help you to secure your applications and APIs using Apigee API management, Google Cloud Armor, reCAPTCHA Enterprise, and Cloud CDN.
- [Configure networks for FedRAMP and DoD in Google Cloud](https://docs.cloud.google.com/architecture/configure-networks-fedramp-dod-google-cloud.md.txt): Provides configuration guidance to help you to comply with design requirements for FedRAMP High and DoD IL2, IL4, and IL5 when you deploy Google Cloud networking policies.
- [De-identification and re-identification of PII in large-scale datasets using Sensitive Data Protection](https://docs.cloud.google.com/architecture/de-identification-re-identification-pii-using-cloud-dlp.md.txt): Discusses how to use Sensitive Data Protection to create an automated data transformation pipeline to de-identify sensitive data like personally identifiable information (PII).
- [Deploy a secured serverless architecture using Cloud Run functions](https://docs.cloud.google.com/architecture/blueprints/serverless-functions-blueprint.md.txt): Provides guidance on how to help protect serverless applications that use Cloud Functions (2nd gen) by layering additional controls onto your existing foundation.
- [Deploy a secured serverless architecture using Cloud Run](https://docs.cloud.google.com/architecture/blueprints/serverless-blueprint.md.txt): Provides guidance on how to help protect serverless applications that use Cloud Run by layering additional controls onto your existing foundation.
- [Deploy automated malware scanning for files uploaded to Cloud Storage](https://docs.cloud.google.com/architecture/automate-malware-scanning-for-documents-uploaded-to-cloud-storage/deployment.md.txt): Describes how to deploy an architecture for automated malware scanning of data in Cloud Storage.
- [Design considerations](https://docs.cloud.google.com/architecture/hybrid-multicloud-secure-networking-patterns/design-considerations.md.txt): Discusses some of the most common design considerations to analyze and take into account as part of your hybrid and multicloud networking design.
- [Design secure deployment pipelines](https://docs.cloud.google.com/architecture/design-secure-deployment-pipelines-bp.md.txt): Describes best practices for designing secure deployment pipelines based on your confidentiality, integrity, and availability requirements.
- [Evict consumer accounts](https://docs.cloud.google.com/architecture/identity/evicting-consumer-accounts.md.txt): Describes how to mitigate social engineering risks by removing (evicting) corporate email addresses from consumer accounts.
- [Example announcement](https://docs.cloud.google.com/architecture/identity/example-announcement.md.txt): Provides an example of an email to announce the migration of consumer accounts to managed accounts.
- [Federate Google Cloud with Active Directory](https://docs.cloud.google.com/architecture/identity/federating-gcp-with-active-directory-introduction.md.txt): Describes how you can configure Cloud Identity or Google Workspace to use Active Directory as IdP and authoritative source.
- [Federate Google Cloud with Microsoft Entra ID (formerly Azure AD)](https://docs.cloud.google.com/architecture/identity/federating-gcp-with-azure-active-directory.md.txt): Describes how to configure Cloud Identity or Google Workspace to use Microsoft Entra ID as the IdP and source for identities.
- [FortiGate architecture in Google Cloud](https://docs.cloud.google.com/architecture/partners/fortigate-architecture-in-cloud.md.txt): Describes the overall concepts around deploying a FortiGate Next Generation Firewall (NGFW) in Google Cloud.
- [Gated egress and gated ingress](https://docs.cloud.google.com/architecture/hybrid-multicloud-secure-networking-patterns/gated-egress-ingress.md.txt): Discusses scenarios that demand bidirectional usage of selected APIs between workloads that run in various environments.
- [Gated egress](https://docs.cloud.google.com/architecture/hybrid-multicloud-secure-networking-patterns/gated-egress.md.txt): Discusses how the gated egress pattern is based on exposing select APIs from various environments to workloads that are deployed in Google Cloud.
- [Gated ingress](https://docs.cloud.google.com/architecture/hybrid-multicloud-secure-networking-patterns/gated-ingress.md.txt): Discusses exposing select APIs of workloads running in Google Cloud to the private computing environment without exposing them to the public internet.
- [Gated patterns](https://docs.cloud.google.com/architecture/hybrid-multicloud-secure-networking-patterns/gated-patterns.md.txt): Discusses how gated patterns can be adapted to various applications with diverse requirements.
- [General best practices](https://docs.cloud.google.com/architecture/hybrid-multicloud-secure-networking-patterns/general-best-practices.md.txt): Discusses several common best practices that you can use for hybrid and multicloud architectures.
- [Handover patterns](https://docs.cloud.google.com/architecture/hybrid-multicloud-secure-networking-patterns/handover-pattern.md.txt): Discusses how to connect a private computing environment to projects in Google Cloud.
- [Hybrid and multicloud secure networking architecture patterns](https://docs.cloud.google.com/architecture/hybrid-multicloud-secure-networking-patterns.md.txt): Discusses several common secure network architecture patterns that you can use for hybrid and multicloud architectures.
- [Hybrid and multicloud secure networking architecture patterns](https://docs.cloud.google.com/architecture/hybrid-multicloud-secure-networking-patterns/one-page-view.md.txt): Describes common hybrid and multicloud architecture patterns, the scenarios that these patterns are best suited for, and best practices for using the paterns.
- [Identify and prioritize security risks with Wiz Security Graph and Google Cloud](https://docs.cloud.google.com/architecture/partners/id-prioritize-security-risks-with-wiz.md.txt): Describes how to identify and prioritize security risks in your cloud workloads with Wiz Security Graph and Google Cloud.
- [Import data into a secured BigQuery data warehouse](https://docs.cloud.google.com/architecture/blueprints/confidential-data-warehouse-blueprint.md.txt): Describes an architecture that you can use to help secure a data warehouse in a production environment, and provides best practices for data governance of a data warehouse in Google Cloud.
- [Keycloak single sign-on](https://docs.cloud.google.com/architecture/identity/keycloak-single-sign-on.md.txt): Shows how to set up single sign-on (SSO) between Keycloak and your Cloud Identity or Google Workspace account by using SAML federation.
- [Limiting scope of compliance for PCI environments in Google Cloud](https://docs.cloud.google.com/architecture/limiting-compliance-scope-pci-environments-google-cloud.md.txt): Describes best practices for architecting your cloud environment for Payment Card Industry (PCI) Security Standards Council compliance.
- [Mapping BeyondProd security principles to the blueprint](https://docs.cloud.google.com/architecture/blueprints/enterprise-application-blueprint/mapping-beyondprod-security-principles.md.txt): Provides the mapping between BeyondProd security principles and a blueprint for an enterprise developer platform.
- [Meshed pattern](https://docs.cloud.google.com/architecture/hybrid-multicloud-secure-networking-patterns/meshed-pattern.md.txt): Discusses a meshed pattern architecture that&#39;s based on establishing a hybrid network architecture that spans multiple computing environments.
- [Microsoft Entra ID (formerly Azure AD) B2B user provisioning and single sign-on](https://docs.cloud.google.com/architecture/identity/azure-ad-b2b-user-provisioning-and-sso.md.txt): Shows how to extend Microsoft Entra ID user provisioning and single sign-on to enable single sign-on (SSO) for Microsoft Entra ID B2B collaboration users.
- [Microsoft Entra ID (formerly Azure AD) user provisioning and single sign-on](https://docs.cloud.google.com/architecture/identity/federating-gcp-with-azure-ad-configuring-provisioning-and-single-sign-on.md.txt): Shows how to set up user provisioning and single sign-on (SSO) between a Microsoft Entra ID tenant and your Cloud Identity or Google Workspace account.
- [Microsoft My Apps portal integration](https://docs.cloud.google.com/architecture/identity/integrating-google-services-and-apps-with-azure-ad-portal.md.txt): Shows how to add Google services and Identity-Aware Proxy (IAP) web-secured web applications to the Microsoft My Apps portal and how to enable automatic sign-on for these applications.
- [Migrate consumer accounts](https://docs.cloud.google.com/architecture/identity/migrating-consumer-accounts.md.txt): Describes how to migrate consumer accounts to managed user accounts that are controlled by Cloud Identity or by Google Workspace.
- [Mirrored pattern](https://docs.cloud.google.com/architecture/hybrid-multicloud-secure-networking-patterns/mirrored-pattern.md.txt): Discusses replicating the design of a certain existing environment or environments to a new environment or environments.
- [Mitigate ransomware attacks using Google Cloud](https://docs.cloud.google.com/architecture/security/mitigating-ransomware-attacks.md.txt): Describes the ransomware attack sequence and how Google Cloud can help your organization mitigate the effects of ransomware attacks.
- [Network security for distributed applications in Cross-Cloud Network](https://docs.cloud.google.com/architecture/ccn-distributed-apps-design/security.md.txt): Describes how to design Cross-Cloud Network security for distributed applications.
- [Networking for secure intra-cloud access: Reference architectures](https://docs.cloud.google.com/architecture/network-secure-intra-cloud-access.md.txt): Describes security and network connectivity architectures for intra-cloud access.
- [Okta user provisioning and single sign-on](https://docs.cloud.google.com/architecture/identity/okta-provisioning-and-single-sign-on.md.txt): Shows how to set up user provisioning and single sign-on (SSO) between an Okta organization and your Cloud Identity or Google Workspace account.
- [Overview of consolidating accounts](https://docs.cloud.google.com/architecture/identity/overview-consolidating-accounts.md.txt): Describes how to consolidate existing consumer accounts so that you can manage and control user accounts.
- [Overview of Google identity management](https://docs.cloud.google.com/architecture/identity/overview-google-authentication.md.txt): Explains the domain model that Google services rely on for authentication and identity management.
- [Overview of identity and access management](https://docs.cloud.google.com/architecture/identity.md.txt): Explores the general practice of identity and access management (generally referred to as IAM) and the individuals who are subject to it, including corporate identities, customer identities, and service identities.
- [OWASP Top 10 2021 mitigation options on Google Cloud](https://docs.cloud.google.com/architecture/security/owasp-top-ten-mitigation.md.txt): Helps you identify Google Cloud products and mitigation strategies that can help you defend against common application-level attacks that are outlined in OWASP Top 10.
- [Patterns and practices for identity and access governance on Google Cloud](https://docs.cloud.google.com/architecture/patterns-practices-identity-access-governance-google-cloud.md.txt): Describes patterns and practices for identity and access governance on Google Cloud.
- [PCI Data Security Standard compliance](https://docs.cloud.google.com/architecture/pci-dss-compliance-in-gcp.md.txt): Shows how to implement the Payment Card Industry Data Security Standard (PCI DSS) for your business on Google Cloud.
- [PCI DSS compliance on GKE](https://docs.cloud.google.com/architecture/pci-dss-and-gke-guide.md.txt): Provides guidance to address the requirements of the Payment Card Industry Data Security Standard (PCI DSS) for Google Kubernetes Engine (GKE) applications.
- [Plan the onboarding process for your corporate identities](https://docs.cloud.google.com/architecture/identity/overview-assess-and-plan.md.txt): Provides guidance to assess requirements and develop a plan for onboarding corporate identities to Cloud Identity or Google Workspace.
- [Prepare your Google Workspace or Cloud Identity account](https://docs.cloud.google.com/architecture/identity/preparing-your-g-suite-or-cloud-identity-account.md.txt): Describes how to create a Cloud Identity or Google Workspace account and how to prepare the account for a production deployment.
- [Reconcile orphaned managed user accounts](https://docs.cloud.google.com/architecture/identity/reconciling-orphaned-managed-user-accounts.md.txt): Describes how to identify and reconcile orphaned user accounts.
- [Reference architectures](https://docs.cloud.google.com/architecture/identity/reference-architectures.md.txt): Provides architectures that you can use as references for managing corporate identities.
- [Remove Gmail from consumer accounts](https://docs.cloud.google.com/architecture/identity/removing-gmail-from-consumer-accounts.md.txt): Describes how to remove Gmail from an existing consumer account to enable the user account to be migrated to Cloud Identity or Google Workspace.
- [Sanitize Gmail accounts](https://docs.cloud.google.com/architecture/identity/sanitizing-gmail-accounts.md.txt): Describes how to sanitize existing Gmail accounts by deliberately removing any corporate email addresses from them.
- [Secure apps and resources by using context-aware access](https://docs.cloud.google.com/architecture/secure-apps-resources-using-context-aware-access.md.txt): Describes how you can enforce context-aware access for different types of apps and resources.
- [Secure data environments in Google Cloud](https://docs.cloud.google.com/architecture/secure-data-environments.md.txt): A high-level architecture to secure sensitive datasets against accidental exposure and malicious exfiltration.
- [Secure virtual private cloud networks with the Palo Alto VM-Series NGFW](https://docs.cloud.google.com/architecture/partners/palo-alto-networks-ngfw.md.txt): Describes the networking concepts that you need to understand to deploy Palo Alto Networks VM-Series next generation firewall (NGFW) in Google Cloud.
- [Security blueprint: PCI on GKE](https://docs.cloud.google.com/architecture/gke-pci-dss-blueprint.md.txt): Provides a Terraform-based blueprint for a Google Kubernetes Engine (GKE) environment that aligns with the Payment Card Industry Data Security Standard (PCI DSS).
- [Security log analytics in Google Cloud](https://docs.cloud.google.com/architecture/security-log-analytics.md.txt): Shows how to collect, export, and analyze logs from Google Cloud to help you audit usage and detect threats to your data and workloads. Use the included threat detection queries for BigQuery or Chronicle, or bring your own SIEM.
- [Single sign-on](https://docs.cloud.google.com/architecture/identity/single-sign-on.md.txt): Describes how to configure your Cloud Identity or Google Workspace account to use single sign-on (SSO).
- [Tokenizing sensitive cardholder data for PCI DSS](https://docs.cloud.google.com/architecture/tokenizing-sensitive-cardholder-data-for-pci-dss.md.txt): Shows how to set up an access-controlled credit and debit card tokenization service on Cloud Functions.
- [VMware Engine network security using centralized appliances](https://docs.cloud.google.com/architecture/gcve-advanced-network-security.md.txt): Provides guidance to design advanced network security for VMware Engine workloads to provide network protection features like DDoS mitigation, SSL offloading, NGFW, IPS/IDS, and DPI.
- [Well-Architected Framework: Security, privacy, and compliance pillar](https://docs.cloud.google.com/architecture/framework/security/printable.md.txt): Provides principles and recommendations to help you design, deploy, and operate Google Cloud workloads that meet your requirements for security, privacy, and compliance.
## <a id="reliability-and-disaster-recovery"></a>Reliability and disaster recovery
- [Architecting disaster recovery for cloud infrastructure outages](https://docs.cloud.google.com/architecture/disaster-recovery.md.txt): Describes how Google Cloud is designed for resilience, discusses the process for architecting resilient workloads on Google Cloud, and provides product-specific disaster recovery (DR) guidance for zonal and regional outages.
- [Architecting disaster recovery for locality-restricted workloads](https://docs.cloud.google.com/architecture/architecting-disaster-recovery-for-locality-restricted-workloads.md.txt): Discusses how to architect disaster recovery (DR) for locality-restricted workloads.
- [Architectures for high availability of PostgreSQL clusters on Compute Engine](https://docs.cloud.google.com/architecture/architectures-high-availability-postgresql-clusters-compute-engine.md.txt): Several architectures that provide high availability (HA) for PostgreSQL deployments on Google Cloud.
- [Assess the reliability requirements for your cloud workloads](https://docs.cloud.google.com/architecture/infra-reliability-guide/requirements.md.txt): Provides guidelines to help you assess the reliability requirements of your cloud workloads.
- [Building blocks of reliability in Google Cloud](https://docs.cloud.google.com/architecture/infra-reliability-guide/building-blocks.md.txt): Introduces the building blocks of reliability in Google Cloud.
- [Business continuity hybrid and multicloud patterns](https://docs.cloud.google.com/architecture/hybrid-multicloud-patterns-and-practices/business-continuity-patterns.md.txt): Discusses how the business continuity pattern relies on a redundant deployment of applications across multiple computing environments.
- [Business continuity with CI/CD on Google Cloud](https://docs.cloud.google.com/architecture/business-continuity-with-cicd-on-google-cloud.md.txt): &#34;Learn about developing a business continuity plan (BCP) for the CI/CD process.&#34;
- [Delete the Load balanced managed VMs](https://docs.cloud.google.com/architecture/reliability/load-balanced-vms.md.txt): Delete Load balanced managed VMs Jump Start Solution.
- [Design reliable infrastructure for your workloads in Google Cloud](https://docs.cloud.google.com/architecture/infra-reliability-guide/design.md.txt): Provides architectural recommendations to design reliable infrastructure for your cloud workloads.
- [Disaster recovery building blocks](https://docs.cloud.google.com/architecture/dr-scenarios-building-blocks.md.txt): Discusses Google Cloud services and products that you can use as building blocks for your disaster recovery (DR) plan.
- [Disaster recovery planning guide](https://docs.cloud.google.com/architecture/dr-scenarios-planning-guide.md.txt): The first part of a series that discusses disaster recovery (DR) in Google Cloud. This part provides an overview of the DR planning process: what you need to know in order to design and implement a DR plan.
- [Disaster recovery scenarios for applications](https://docs.cloud.google.com/architecture/dr-scenarios-for-applications.md.txt): Explores common disaster recovery (DR) scenarios for applications.
- [Disaster recovery scenarios for data](https://docs.cloud.google.com/architecture/dr-scenarios-for-data.md.txt): Discusses disaster recovery (DR) scenarios for backing up and recovering data.
- [Disaster recovery use cases: locality-restricted data analytics applications](https://docs.cloud.google.com/architecture/dr-scenarios-locality-restricted-data-analytics.md.txt): Describes disaster recovery (DR) use cases for locality-restricted data analytics applications.
- [Google Cloud infrastructure reliability guide](https://docs.cloud.google.com/architecture/infra-reliability-guide.md.txt): Introduces the building blocks of reliability in Google Cloud, and provides architectural recommendations to design reliable infrastructure for your cloud workloads.
- [Manage and monitor your Google Cloud infrastructure](https://docs.cloud.google.com/architecture/infra-reliability-guide/manage-and-monitor.md.txt): Summarizes guidelines to manage and monitor your infrastructure resources for reliability.
- [Manage traffic and load for your workloads in Google Cloud](https://docs.cloud.google.com/architecture/infra-reliability-guide/traffic-load.md.txt): Describes traffic-management and load-management techniques that you can use to improve the reliability of your cloud workloads.
- [Migrate across Google Cloud regions: Design resilient single-region environments on Google Cloud](https://docs.cloud.google.com/architecture/migrate-across-regions/design-resilient-single-region-environments.md.txt): Design resilient, single-region environments on Google Cloud.
- [Patterns for scalable and resilient apps](https://docs.cloud.google.com/architecture/scalable-and-resilient-apps.md.txt): Introduces some patterns and practices for creating apps that are resilient and scalable, two essential goals of many modern architecture exercises.
- [Well-Architected Framework: Reliability pillar](https://docs.cloud.google.com/architecture/framework/reliability/printable.md.txt): Provides principles and recommendations to help you design, deploy, and manage reliable workloads in Google Cloud.
## <a id="data-and-analytics"></a>Data and analytics
- [Analytics hybrid and multicloud pattern](https://docs.cloud.google.com/architecture/hybrid-multicloud-patterns-and-practices/analytics-hybrid-multicloud-pattern.md.txt): Discusses that the objective of the analytics hybrid and multicloud pattern is to capitalize on the split between transactional and analytics workloads.
- [Architecture and functions in a data mesh](https://docs.cloud.google.com/architecture/data-mesh.md.txt): Describes the architecture and components of a data mesh that&#39;s deployed in Google Cloud.
- [Build data products in a data mesh](https://docs.cloud.google.com/architecture/build-data-products-data-mesh.md.txt): Describes design considerations for building data products in a data mesh.
- [Continuous data replication to BigQuery using Striim](https://docs.cloud.google.com/architecture/partners/continuous-data-replication-bigquery-striim.md.txt): Demonstrates how to migrate a MySQL database to BigQuery using Striim. Striim is a comprehensive streaming extract, transform, and load (ETL) platform.
- [Continuous data replication to Spanner using Striim](https://docs.cloud.google.com/architecture/partners/continuous-data-replication-cloud-spanner-striim.md.txt): How to migrate a MySQL database to Cloud Spanner using Striim.
- [Data management with Cohesity Helios and Google Cloud](https://docs.cloud.google.com/architecture/partners/using-cohesity-with-cloud-storage-for-enterprise-hybrid-data-protection.md.txt): How Cohesity works with Google Cloud Storage. Cohesity is a hyperconverged secondary storage system for consolidating backup, test/dev, file services, and analytic datasets onto a scalable data platform.
- [Delete the Analytics lakehouse](https://docs.cloud.google.com/architecture/big-data-analytics/analytics-lakehouse.md.txt): Delete Analytics lakehouse Jump Start Solution.
- [Delete the Data warehouse with BigQuery](https://docs.cloud.google.com/architecture/big-data-analytics/data-warehouse.md.txt): Delete Data warehouse with BigQuery Jump Start Solution.
- [Deploy an enterprise data management and analytics platform](https://docs.cloud.google.com/architecture/blueprints/deploy_enterprise_data_mesh.md.txt): Describes an enterprise-ready data mesh architecture that you can deploy to protect confidential data.
- [Deploy scalable BigQuery backup automation](https://docs.cloud.google.com/architecture/scalable-bigquery-backup-automation/deployment.md.txt): Build a solution to automate recurrent BigQuery backup operations at scale, with two backup methods: BigQuery snapshots and exports to Cloud Storage.
- [Design a self-service data platform for a data mesh](https://docs.cloud.google.com/architecture/design-self-service-data-platform-data-mesh.md.txt): Describes how to design a self-service data-mesh platform that domain teams can use to create and consume data products.
- [Device on Pub/Sub connection to Google Cloud](https://docs.cloud.google.com/architecture/connected-devices/device-pubsub-architecture.md.txt): Describes architectural considerations when you directly connect an IoT aggregation device or gateway to Pub/Sub.
- [Discover and consume data products in a data mesh](https://docs.cloud.google.com/architecture/discover-consume-data-products-data-mesh.md.txt): Discusses how domain teams can discover and consume data products in a data mesh.
- [Migrate to Google Cloud: Transfer your large datasets](https://docs.cloud.google.com/architecture/migration-to-google-cloud-transferring-your-large-datasets.md.txt): Provides guidance for transferring large datasets efficiently for workloads that you migrate to Google Cloud.
- [Scalable BigQuery backup automation](https://docs.cloud.google.com/architecture/scalable-bigquery-backup-automation.md.txt): Build a solution to automate recurrent BigQuery backup operations at scale, with two backup methods: BigQuery snapshots and exports to Cloud Storage.
## <a id="databases"></a>Databases
- [Apache Guacamole on GKE and Cloud SQL](https://docs.cloud.google.com/architecture/deploy-guacamole-gke.md.txt): Describes an architecture for hosting Apache Guacamole on Google Kubernetes Engine (GKE) and Cloud SQL. Apache Guacamole offers a fully browser-based way to access remote desktops through Remote Desktop Protocol (RDP).
- [Database migration: Concepts and principles (Part 1)](https://docs.cloud.google.com/architecture/database-migration-concepts-principles-part-1.md.txt): Introduces concepts, principles, terminology, and architecture of near-zero downtime database migration from on-premises or other cloud environments.
- [Database migration: Concepts and principles (Part 2)](https://docs.cloud.google.com/architecture/database-migration-concepts-principles-part-2.md.txt): Discusses how to set up and execute the database migration process, including failure scenarios.
- [Define the scope of your migration to Redis Enterprise Cloud](https://docs.cloud.google.com/architecture/partners/riot-live-migration-redis-enterprise-cloud/assessment.md.txt): Describes how to define the scope of a migration that uses RIOT Live Migration to migrate to fully managed Redis Enterprise Cloud in Google Cloud.
- [Deploy Apache Guacamole on GKE and Cloud SQL](https://docs.cloud.google.com/architecture/deploy-guacamole-gke/deployment.md.txt): Describes how to deploy Apache Guacamole on Google Kubernetes Engine (GKE) and Cloud SQL.
- [Deploy RIOT Live Migration to migrate to Redis Enterprise Cloud](https://docs.cloud.google.com/architecture/partners/riot-live-migration-redis-enterprise-cloud/deployment.md.txt): Describes how to deploy an architecture to migrate from Redis-compatible sources to fully managed Redis Enterprise Cloud in Google Cloud using RIOT Live Migration service.
- [Enterprise application on Compute Engine with Oracle Exadata](https://docs.cloud.google.com/architecture/enterprise-app-oracle-exadata-database-compute-engine.md.txt): Provides a reference architecture for an application that&#39;s hosted on Compute Engine VMs with connectivity to Oracle Cloud Infrastructure (OCI) Exadata databases in Google Cloud.
- [Enterprise application with Oracle Database on Compute Engine](https://docs.cloud.google.com/architecture/enterprise-app-oracle-database-compute-engine.md.txt): Provides a reference architecture to host an application that uses an Oracle database, deployed on Compute Engine VMs.
- [Global deployment with Compute Engine and Spanner](https://docs.cloud.google.com/architecture/global-deployment-compute-engine-spanner.md.txt): Learn how to architect a multi-tier application that runs on Compute Engine VMs and Spanner in a global topology on Google Cloud.
- [Microsoft SQL Server Always On availability group in Google Cloud](https://docs.cloud.google.com/architecture/sql-server-alwayson-availability-group-compute-engine.md.txt): Provides a reference architecture for deploying high-availability
(HA) Microsoft SQL Server databases in Google Cloud by using an Always On availability group.
- [Migrate from AWS to Google Cloud: Migrate from Amazon RDS and Amazon Aurora for MySQL to Cloud SQL for MySQL](https://docs.cloud.google.com/architecture/migrate-aws-rds-to-sql-mysql.md.txt): Describes how to design, implement, and validate a plan to migrate from Amazon Relational Database Service (RDS) or Aurora to Cloud SQL for MySQL.
- [Migrate from AWS to Google Cloud: Migrate from Amazon RDS and Amazon Aurora for PostgreSQL to Cloud SQL and AlloyDB for PostgreSQL](https://docs.cloud.google.com/architecture/migrate-aws-rds-aurora-to-postgresql.md.txt): Describes how to design, implement, and validate a plan to migrate from Amazon Relational Database Service (RDS) or Aurora to Cloud SQL for PostgreSQL or AlloyDB for PostgreSQL.
- [Migrate from AWS to Google Cloud: Migrate from Amazon RDS for SQL Server to Cloud SQL for SQL Server](https://docs.cloud.google.com/architecture/migrate-aws-rds-to-cloudsql-for-sqlserver.md.txt): Describes how to design, implement, and validate a plan to migrate from Amazon Relational Database Service (RDS) to Cloud SQL for SQL Server.
- [Multicloud database management: Architectures, use cases, and best practices](https://docs.cloud.google.com/architecture/multi-cloud-database-management.md.txt): Describes architectures, use cases, and best practices for multicloud database management.
- [Oracle E-Business Suite on Compute Engine with Oracle Exadata](https://docs.cloud.google.com/architecture/oracle-ebs-with-oci-exadata.md.txt): Shows how to build the infrastructure to run Oracle E-Business Suite applications with Oracle Cloud Infrastructure Exadata in Google Cloud.
- [Oracle E-Business Suite with Oracle Database on Compute Engine](https://docs.cloud.google.com/architecture/oracle-ebs-on-compute-engine-vm.md.txt): Shows how to build the infrastructure to run Oracle E-Business Suite applications with Oracle Database on Compute Engine VMs in Google Cloud.
- [Oracle PeopleSoft on Compute Engine with Oracle Exadata](https://docs.cloud.google.com/architecture/oracle-peoplesoft-with-oci-exadata.md.txt): Shows how to build the infrastructure to run Oracle PeopleSoft applications with Oracle Cloud Infrastructure Exadata in Google Cloud.
- [Use RIOT Live Migration to migrate to Redis Enterprise Cloud](https://docs.cloud.google.com/architecture/partners/riot-live-migration-redis-enterprise-cloud.md.txt): Describes an architecture to migrate from Redis-compatible sources to fully managed Redis Enterprise Cloud in Google Cloud using RIOT Live Migration service.
## <a id="migration"></a>Migration
- [Architect your workloads](https://docs.cloud.google.com/architecture/migrate-across-regions/architect-workloads.md.txt): Design resilient, single-region environments on Google Cloud.
- [Designing networks for migrating enterprise workloads: Architectural approaches](https://docs.cloud.google.com/architecture/network-architecture.md.txt): Provides an overview of networking and security architectures for enterprises that are migrating workloads to Google Cloud.
- [Log and monitor on-premises resources with BindPlane](https://docs.cloud.google.com/architecture/logging-and-monitoring-on-premises-resources-with-bindplane.md.txt): Describes considerations and design patterns for using Cloud Logging, Cloud Monitoring, and BindPlane to provide logging and monitoring services for on-premises resources.
- [Log on-premises resources with BindPlane](https://docs.cloud.google.com/architecture/logging-on-premises-resources-with-bindplane.md.txt): Describes how to use Cloud Logging and BindPlane to log on-premises resources.
- [Migrate across Google Cloud regions: Get started](https://docs.cloud.google.com/architecture/migrate-across-regions.md.txt): Start preparing your workloads and data for migration across Google Cloud regions.
- [Migrate across Google Cloud regions: Prepare data and batch workloads for migration across regions](https://docs.cloud.google.com/architecture/migrate-across-regions/prepare-data-and-batch-workloads.md.txt): Prepare data and batch workloads for migration across regions.
- [Migrate containers to Google Cloud: Migrate from Kubernetes to GKE](https://docs.cloud.google.com/architecture/migrating-containers-kubernetes-gke.md.txt): Describes how to design, implement, and validate a plan to migrate from Kubernetes to Google Kubernetes Engine (GKE).
- [Migrate from AWS to Google Cloud: Get started](https://docs.cloud.google.com/architecture/migration-from-aws-get-started.md.txt): Describes how to design, implement, and validate a plan to migrate from AWS to Google Cloud.
- [Migrate from AWS to Google Cloud: Migrate from Amazon EC2 to Compute Engine](https://docs.cloud.google.com/architecture/migrate-amazon-ec2-to-compute-engine.md.txt): Describes how to design, implement, and validate a plan to migrate from Amazon EC2 to Compute Engine.
- [Migrate from AWS to Google Cloud: Migrate from Amazon EKS to GKE](https://docs.cloud.google.com/architecture/migrate-amazon-eks-to-gke.md.txt): Design, implement, and validate a plan to migrate from Amazon EKS to Google Kubernetes Engine.
- [Migrate from AWS to Google Cloud: Migrate from Amazon S3 to Cloud Storage](https://docs.cloud.google.com/architecture/migrate-amazon-s3-to-cloud-storage.md.txt): Describes how to design, implement, and validate a plan to migrate from Amazon S3 to Cloud Storage.
- [Migrate from AWS to Google Cloud: Migrate from AWS Lambda to Cloud Run](https://docs.cloud.google.com/architecture/migrate-aws-lambda-to-cloudrun.md.txt): Describes how to design, implement, and validate a plan to migrate from AWS Lambda to Cloud Run.
- [Migrate from Azure to Google Cloud: Get started](https://docs.cloud.google.com/architecture/migration-from-azure-get-started.md.txt): Describes how to design, implement, and validate a plan to migrate from Azure to Google Cloud.
- [Migrate on-premises VMs to Google Cloud](https://docs.cloud.google.com/architecture/migrate-on-premises-vms.md.txt): Provides links to guides for migrating on-premises VM workloads to Google Cloud.
- [Migrate to a Google Cloud VMware Engine platform](https://docs.cloud.google.com/architecture/blueprints/vmware-engine-blueprint.md.txt): Describes the VMware Engine blueprint, which deploys a platform for VM workloads.
- [Migrate to Google Cloud: Assess and discover your workloads](https://docs.cloud.google.com/architecture/migration-to-gcp-assessing-and-discovering-your-workloads.md.txt): Describes the activities in the assessment phase of the process to migrate to Google Cloud.
- [Migrate to Google Cloud: Best practices for validating a migration plan](https://docs.cloud.google.com/architecture/migration-to-google-cloud-best-practices.md.txt): Describes how to design, implement, and validate a plan to migrate to Google Cloud.
- [Migrate to Google Cloud: Deploy your workloads](https://docs.cloud.google.com/architecture/migration-to-gcp-deploying-your-workloads.md.txt): Describes the activities in the deployment phase of the process to migrate to Google Cloud.
- [Migrate to Google Cloud: Get started](https://docs.cloud.google.com/architecture/migration-to-gcp-getting-started.md.txt): Helps you plan, design, and implement the process of migrating your application and infrastructure workloads to Google Cloud, including computing, database, and storage workloads.
- [Migrate to Google Cloud: Migrate from manual deployments to automated, containerized deployments](https://docs.cloud.google.com/architecture/migration-to-google-cloud-automated-containerized-deployments.md.txt): Describes how to plan and design a migration path from manual deployments to automated, containerized deployments in Google Cloud.
- [Migrate to Google Cloud: Minimize costs](https://docs.cloud.google.com/architecture/migration-to-google-cloud-minimize-costs.md.txt): Provide guidance to help you optimize the costs of workloads that you migrate to single-region and multi-region environments in Google Cloud.
- [Migrate to Google Cloud: Optimize your environment](https://docs.cloud.google.com/architecture/migration-to-google-cloud-optimizing-your-environment.md.txt): Provides guidance to help you continuously optimize the environment for a workload that you&#39;ve migrated to Google Cloud.
- [Migrate to Google Cloud: Plan and build your foundation](https://docs.cloud.google.com/architecture/migration-to-google-cloud-building-your-foundation.md.txt): Describes how to plan and build a foundation on Google Cloud.
- [Monitor on-premises resources with BindPlane](https://docs.cloud.google.com/architecture/monitoring-on-premises-resources-with-bindplane.md.txt): Describes how to use Cloud Monitoring and BindPlane to monitor on-premises resources.
## <a id="networking"></a>Networking
- [Best practices and reference architectures for VPC design](https://docs.cloud.google.com/architecture/best-practices-vpc-design.md.txt): This guide introduces best practices and typical enterprise architectures for the design of virtual private clouds (VPCs) with Google Cloud.
- [Cross-Cloud Network for distributed applications](https://docs.cloud.google.com/architecture/ccn-distributed-apps-design.md.txt): Describes how to design Cross-Cloud Network for distributed applications.
- [Cross-Cloud Network inter-VPC connectivity using Network Connectivity Center](https://docs.cloud.google.com/architecture/ccn-distributed-apps-design/ccn-ncc-vpn-ra.md.txt): Describes how to design the network segmentation structure and connectivity of Cross-Cloud Network with Network Connectivity Center.
- [Cross-Cloud Network inter-VPC connectivity using VPC Network Peering](https://docs.cloud.google.com/architecture/ccn-distributed-apps-design/ccn-vnp-vpn-ra.md.txt): Describes how to design the network segmentation structure and connectivity of Cross-Cloud Network for distributed applications.
- [Deploy Windows applications on managed Kubernetes](https://docs.cloud.google.com/architecture/manage-and-scale-windows-networking/deployment.md.txt): Describes how to deploy a reference architecture to manage and scale networking for Windows applications that run on managed Kubernetes.
- [From edge to mesh: Deploy service mesh applications through GKE Gateway](https://docs.cloud.google.com/architecture/exposing-service-mesh-apps-through-gke-ingress/deployment.md.txt): Shows how to combine Cloud Service Mesh with Cloud Load Balancing to expose applications in a service mesh to internet clients.
- [From edge to mesh: Expose service mesh applications through GKE Gateway](https://docs.cloud.google.com/architecture/exposing-service-mesh-apps-through-gke-ingress.md.txt): Combines Cloud Service Mesh with Cloud Load Balancing to expose applications in a service mesh to internet clients.
- [Hub-and-spoke network architecture](https://docs.cloud.google.com/architecture/deploy-hub-spoke-vpc-network-topology.md.txt): Discusses the architectural options for designing hub-and-spoke network topologies in Google Cloud.
- [Manage and scale networking for Windows applications that run on managed Kubernetes](https://docs.cloud.google.com/architecture/manage-and-scale-windows-networking.md.txt): Discusses how to manage networking for Windows applications that run on Google Kubernetes Engine using Cloud Service Mesh and Envoy gateways.
- [Multi-agent private networking patterns in Google Cloud](https://docs.cloud.google.com/architecture/multi-agent-private-networking-patterns.md.txt): Guidance to help you design private networking infrastructure that supports a publicly accessible, multi-agent, Gemini Enterprise app with private connections between agents, subagents, and tools.
- [Network segmentation and connectivity for distributed applications in Cross-Cloud Network](https://docs.cloud.google.com/architecture/ccn-distributed-apps-design/connectivity.md.txt): Describe how to design the network segmentation structure and connectivity of Cross-Cloud Network for distributed applications.
- [Networking for hybrid and multi-cloud workloads: Reference architectures](https://docs.cloud.google.com/architecture/network-hybrid-multicloud.md.txt): Discusses networking for a scenario where workloads run in more than one place, such as on-premises and the cloud, or in multiple cloud environments.
- [Networking for internet-facing application delivery: Reference architectures](https://docs.cloud.google.com/architecture/network-application-delivery.md.txt): Describes reference architectures to help you design networking and security for internet-facing application delivery.
- [Patterns for using floating IP addresses in Compute Engine](https://docs.cloud.google.com/architecture/patterns-for-floating-ip-addresses-in-compute-engine.md.txt): How to use floating IP address patterns when migrating applications to Compute Engine from an on-premises network.
- [Service networking for distributed applications in Cross-Cloud Network](https://docs.cloud.google.com/architecture/ccn-distributed-apps-design/service-networking.md.txt): Describes how to design Cross-Cloud Network service networking for distributed applications.
- [Use Google Cloud Armor, load balancing, and Cloud CDN to deploy programmable global front ends](https://docs.cloud.google.com/architecture/deploy-programmable-gfe-cloud-armor-lb-cdn.md.txt): Provides an architecture that uses a global front end which incorporates Google Cloud best practices to help scale, secure, and accelerate the delivery of your internet-facing applications.
- [VPC Network Peering Cross-Cloud Network with NVAs and regional affinity](https://docs.cloud.google.com/architecture/ccn-distributed-apps-design/ccn-nva-ra.md.txt): Describes how to include NVAs into a regional affinity CCN deployment.
## <a id="hybrid-multi-cloud-and-distributed-cloud"></a>Hybrid, multi-cloud, and distributed cloud
- [Architectural approaches to adopt a hybrid or multicloud architecture](https://docs.cloud.google.com/architecture/hybrid-multicloud-patterns/adopt.md.txt): Provides guidance on common proven approaches and considerations to migrate your workload to the cloud.
- [Authenticate workforce users in a hybrid environment](https://docs.cloud.google.com/architecture/authenticating-corporate-users-in-a-hybrid-environment.md.txt): How to extend your identity management solution to Google Cloud to enable your workforce to authenticate and consume services in a hybrid computing environment.
- [Build a hybrid render farm](https://docs.cloud.google.com/architecture/building-a-hybrid-render-farm.md.txt): Provides guidance on extending your existing, on-premises render farm to use compute resources on Google Cloud (Google Cloud).
- [Build hybrid and multicloud architectures using Google Cloud](https://docs.cloud.google.com/architecture/hybrid-multicloud-patterns.md.txt): Provides practical guidance on planning and architecting your hybrid and multi-cloud environments using Google Cloud.
- [Cloud bursting pattern](https://docs.cloud.google.com/architecture/hybrid-multicloud-patterns-and-practices/cloud-bursting-pattern.md.txt): Discusses how to manage bursty workloads with the cloud bursting architecture pattern.
- [Distributed architecture patterns](https://docs.cloud.google.com/architecture/hybrid-multicloud-patterns-and-practices/distributed-patterns.md.txt): Discusses how to avoid or overcome design constraints and how to take advantage of each computing environment in a distributed architecture.
- [Drivers, considerations, strategy, and approaches](https://docs.cloud.google.com/architecture/hybrid-multicloud-patterns/drivers.md.txt): Defines and discusses business objectives, drivers, and requirements, and how these factors can influence your design decisions.
- [Edge hybrid pattern](https://docs.cloud.google.com/architecture/hybrid-multicloud-patterns-and-practices/edge-hybrid-pattern.md.txt): Discusses how the edge hybrid pattern addresses connectivity challenges by running time- and business-critical workloads locally, at the edge of the network.
- [Environment hybrid pattern](https://docs.cloud.google.com/architecture/hybrid-multicloud-patterns-and-practices/environment-hybrid-pattern.md.txt): Discusses how to keep the production environment of a workload in the existing data center but use the public cloud for other, non-production environments.
- [Hybrid and multicloud architecture patterns](https://docs.cloud.google.com/architecture/hybrid-multicloud-patterns-and-practices.md.txt): Discusses common hybrid and multicloud architecture patterns, and describes the scenarios that these patterns are best suited for.
- [Hybrid and multicloud architecture patterns](https://docs.cloud.google.com/architecture/hybrid-multicloud-patterns-and-practices/one-page-view.md.txt): Discusses common hybrid and multicloud architecture patterns. It also describes the scenarios that these patterns are best suited for.
- [Hybrid and multicloud monitoring and logging patterns](https://docs.cloud.google.com/architecture/hybrid-and-multi-cloud-monitoring-and-logging-patterns.md.txt): Discusses monitoring and logging architectures for hybrid and multicloud deployments, and provides best practices for implementing them by using Google Cloud.
- [Other considerations](https://docs.cloud.google.com/architecture/hybrid-multicloud-patterns/other-considerations.md.txt): Highlights essential core design considerations that play a pivotal role in shaping your overall hybrid and multicloud architecture.
- [Partitioned multicloud pattern](https://docs.cloud.google.com/architecture/hybrid-multicloud-patterns-and-practices/partitioned-multicloud-pattern.md.txt): Discusses how the pattern combines multiple public cloud environments that are operated by different CSPs and the flexibility it offers.
- [Patterns for authenticating workforce users in a hybrid environment](https://docs.cloud.google.com/architecture/patterns-for-authenticating-corporate-users-in-a-hybrid-environment.md.txt): Discusses patterns for authenticating workforce users in a hybrid cloud environment.
- [Patterns for connecting other cloud service providers with Google Cloud](https://docs.cloud.google.com/architecture/patterns-for-connecting-other-csps-with-gcp.md.txt): Helps cloud architects and operations professionals decide how to connect Google Cloud with other cloud service providers (CSP) such as Amazon Web Services (AWS) and Microsoft Azure.
- [Patterns for using Active Directory in a hybrid environment](https://docs.cloud.google.com/architecture/patterns-for-using-active-directory-in-a-hybrid-environment.md.txt): Requirements to consider when you deploy Active Directory to Google Cloud and helps you choose the right architecture.
- [Plan a hybrid and multicloud strategy](https://docs.cloud.google.com/architecture/hybrid-multicloud-patterns/strategy.md.txt): Discusses how to plan your hybrid and multi-cloud strategy.
- [Tiered hybrid pattern](https://docs.cloud.google.com/architecture/hybrid-multicloud-patterns-and-practices/tiered-hybrid-pattern.md.txt): Discusses the opportunties and challenges that a tiered hybrid architecture pattern offers.
## <a id="financial-services"></a>Financial services
- [Well-Architected Framework: Financial services (FS) perspective](https://docs.cloud.google.com/architecture/framework/perspectives/fsi/printable.md.txt): Provides principles and recommendations to help you design, build, and manage financial services (FS) applications in Google Cloud that meet your operational, security, reliability, cost, and performance goals.
## <a id="monitoring-and-logging"></a>Monitoring and logging
- [Cloud Monitoring metric export](https://docs.cloud.google.com/architecture/monitoring-metric-export.md.txt): Describes a way to export Cloud Monitoring metrics for long-term analysis.
- [Deploy a job to import logs from Cloud Storage to Cloud Logging](https://docs.cloud.google.com/architecture/import-logs-from-storage-to-logging/deployment.md.txt): Learn how to import logs that were previously exported to Cloud Storage back to Cloud Logging.
- [Deploy log streaming from Google Cloud to Datadog](https://docs.cloud.google.com/architecture/partners/stream-cloud-logs-to-datadog/deployment.md.txt): Learn how to deploy a solution that sends log files to a Cloud Logging sink and then to Datadog.
- [Developer platform controls](https://docs.cloud.google.com/architecture/blueprints/enterprise-application-blueprint/developer-platform-controls.md.txt): Describes the security, networking, and reliability controls that are used in the blueprint for an enterprise developer platform.
- [Import logs from Cloud Storage to Cloud Logging](https://docs.cloud.google.com/architecture/import-logs-from-storage-to-logging.md.txt): Learn how to import logs that were previously exported to Cloud Storage back to Cloud Logging.
- [Logging and monitoring](https://docs.cloud.google.com/architecture/blueprints/enterprise-application-blueprint/logging-monitoring.md.txt): Describes how logging and monitoring work in a blueprint for an enterprise developer platform.
- [Operations for both the developer platform and applications](https://docs.cloud.google.com/architecture/blueprints/enterprise-application-blueprint/ops-developer-platform-applications.md.txt): Provides guidance to efficiently operate an enterprise developer platform and the deployed applications.
- [Stream logs from Google Cloud to Datadog](https://docs.cloud.google.com/architecture/partners/stream-cloud-logs-to-datadog.md.txt): Provides an architecture to send log event data from across your Google Cloud ecosystem to Datadog Log Management.
- [Stream logs from Google Cloud to Splunk](https://docs.cloud.google.com/architecture/stream-logs-from-google-cloud-to-splunk.md.txt): Create a production-ready, scalable, fault-tolerant, log export mechanism that streams logs and events from your resources in Google Cloud into Splunk.
- [Well-Architected Framework: Operational excellence pillar](https://docs.cloud.google.com/architecture/framework/operational-excellence/printable.md.txt): Provides principles and recommendations to help you manage and operate workloads efficiently in Google Cloud.
## <a id="storage"></a>Storage
- [Configuring SaaS data protection for Google Workspace data with Spin.AI](https://docs.cloud.google.com/architecture/partners/backing-up-workspace-data-with-spinone.md.txt): How to configure SpinOne - All-in-One SaaS Data Protection with Cloud Storage.
- [Design an optimal storage strategy for your cloud workload](https://docs.cloud.google.com/architecture/storage-advisor.md.txt): Provides guidance to help you design a storage strategy that&#39;s aligned with the requirements of your cloud workload.
- [Google Workspace Backup with Afi.ai](https://docs.cloud.google.com/architecture/partners/google-workspace-backup-with-afi-ai.md.txt): Describes how to set up an automated Google Workspace backup using Afi.ai.
- [Parallel file systems for HPC workloads](https://docs.cloud.google.com/architecture/parallel-file-systems-for-hpc.md.txt): Describes the storage options in Google Cloud for high performance computing (HPC) workloads, and provides guidance for when you should use parallel file systems like Managed Lustre for HPC workloads.

View File

@@ -0,0 +1,231 @@
# Product-specific best practices guides
| Product | Line hints |
|---------|------------|
| [Best practices covering multiple products](#multiple-products) | Lines 31-34 |
| [AI Hypercomputer](#ai-hypercomputer) | Lines 35-38 |
| [AlloyDB](#alloydb) | Lines 39-45 |
| [Backup and Disaster Recovery (DR) Service](#backup-and-disaster-recovery-dr-service) | Lines 46-53 |
| [BigQuery](#bigquery) | Lines 54-68 |
| [Cloud Armor](#cloud-armor) | Lines 69-72 |
| [Cloud Load Balancing](#cloud-load-balancing) | Lines 73-76 |
| [Cloud Run](#cloud-run) | Lines 77-84 |
| [Cloud Service Mesh](#cloud-service-mesh) | Lines 85-94 |
| [Cloud SQL](#cloud-sql) | Lines 95-102 |
| [Cloud Storage](#cloud-storage) | Lines 103-108 |
| [Compute Engine](#compute-engine) | Lines 109-125 |
| [Gemini Enterprise Agent Platform](#gemini-enterprise-agent-platform) | Lines 126-132 |
| [Google Kubernetes Engine (GKE)](#google-kubernetes-engine-gke) | Lines 133-152 |
| [Identity and Access Management (IAM)](#identity-and-access-management-iam) | Lines 153-162 |
| [Managed Service for Apache Spark](#managed-service-for-apache-spark) | Lines 163-167 |
| [Memorystore](#memorystore) | Lines 168-176 |
| [Migration](#migration) | Lines 177-181 |
| [Network Connectivity](#network-connectivity) | Lines 182-187 |
| [Observability in Google Cloud](#observability-in-google-cloud) | Lines 188-196 |
| [Pub/Sub](#pub-sub) | Lines 197-202 |
| [Security Command Center](#security-command-center) | Lines 203-206 |
| [Security](#security) | Lines 207-216 |
| [Spanner](#spanner) | Lines 217-228 |
| [Vertex AI](#vertex-ai) | Lines 229-232 |
## <a id="multiple-products"></a>Best practices covering multiple products
- https://docs.cloud.google.com/workload-manager/docs/reference/best-practices-general.md.txt
## <a id="ai-hypercomputer"></a>AI Hypercomputer
- https://docs.cloud.google.com/ai-hypercomputer/docs/networking-best-practices.md.txt
## <a id="alloydb"></a>AlloyDB
- https://docs.cloud.google.com/alloydb/docs/ai/best-practices-tuning-scann.md.txt
- https://docs.cloud.google.com/alloydb/docs/auth-proxy/best-practices.md.txt
- https://docs.cloud.google.com/alloydb/docs/import-export-best-practices.md.txt
- https://docs.cloud.google.com/alloydb/docs/security-best-practices.md.txt
## <a id="backup-and-disaster-recovery-dr-service"></a>Backup and Disaster Recovery (DR) Service
- https://docs.cloud.google.com/backup-disaster-recovery/docs/concepts/backup-plan-policy-best-practices.md.txt
- https://docs.cloud.google.com/backup-disaster-recovery/docs/concepts/best-practices-cyber-resilience.md.txt
- https://docs.cloud.google.com/backup-disaster-recovery/docs/concepts/best-practices-ransomware.md.txt
- https://docs.cloud.google.com/backup-disaster-recovery/docs/concepts/policy-specific-best-practices.md.txt
- https://docs.cloud.google.com/backup-disaster-recovery/docs/create-plan/schedule-best-practices-at-a-glance.md.txt
## <a id="bigquery"></a>BigQuery
- https://docs.cloud.google.com/bigquery/docs/best-practices-costs.md.txt
- https://docs.cloud.google.com/bigquery/docs/best-practices-for-multi-tenant-workloads-on-bigquery.md.txt
- https://docs.cloud.google.com/bigquery/docs/best-practices-performance-compute.md.txt
- https://docs.cloud.google.com/bigquery/docs/best-practices-performance-functions.md.txt
- https://docs.cloud.google.com/bigquery/docs/best-practices-performance-nested.md.txt
- https://docs.cloud.google.com/bigquery/docs/best-practices-performance-overview.md.txt
- https://docs.cloud.google.com/bigquery/docs/best-practices-policy-tags.md.txt
- https://docs.cloud.google.com/bigquery/docs/best-practices-row-level-security.md.txt
- https://docs.cloud.google.com/bigquery/docs/best-practices-spatial-analysis.md.txt
- https://docs.cloud.google.com/bigquery/docs/best-practices-storage.md.txt
- https://docs.cloud.google.com/bigquery/docs/graph-query-best-practices.md.txt
- https://docs.cloud.google.com/bigquery/docs/write-api-best-practices.md.txt
## <a id="cloud-armor"></a>Cloud Armor
- https://docs.cloud.google.com/armor/docs/best-practices.md.txt
## <a id="cloud-load-balancing"></a>Cloud Load Balancing
- https://docs.cloud.google.com/load-balancing/docs/https/http-load-balancing-best-practices.md.txt
## <a id="cloud-run"></a>Cloud Run
- https://docs.cloud.google.com/run/docs/configuring/jobs/gpu-best-practices.md.txt
- https://docs.cloud.google.com/run/docs/configuring/networking-best-practices.md.txt
- https://docs.cloud.google.com/run/docs/configuring/services/gpu-best-practices.md.txt
- https://docs.cloud.google.com/run/docs/configuring/workerpools/gpu-best-practices.md.txt
- https://docs.cloud.google.com/run/docs/tips/functions-best-practices.md.txt
## <a id="cloud-service-mesh"></a>Cloud Service Mesh
- https://docs.cloud.google.com/service-mesh/docs/canonical-service-best-practices.md.txt
- https://docs.cloud.google.com/service-mesh/docs/istio-apis/security/best-practices.md.txt
- https://docs.cloud.google.com/service-mesh/docs/istio-apis/security/egress-gateways-best-practices.md.txt
- https://docs.cloud.google.com/service-mesh/docs/operate-and-maintain/scalability-best-practices.md.txt
- https://docs.cloud.google.com/service-mesh/docs/security/anthos-service-mesh-security-best-practices.md.txt
- https://docs.cloud.google.com/service-mesh/docs/security/best-practices.md.txt
- https://docs.cloud.google.com/service-mesh/docs/security/egress-gateways-best-practices.md.txt
## <a id="cloud-sql"></a>Cloud SQL
- https://docs.cloud.google.com/sql/docs/best-practices.md.txt
- https://docs.cloud.google.com/sql/docs/mysql/best-practices.md.txt
- https://docs.cloud.google.com/sql/docs/postgres/best-practices.md.txt
- https://docs.cloud.google.com/sql/docs/postgres/manage-memory-usage-best-practices.md.txt
- https://docs.cloud.google.com/sql/docs/sqlserver/best-practices.md.txt
## <a id="cloud-storage"></a>Cloud Storage
- https://docs.cloud.google.com/storage/docs/best-practices-media-workload.md.txt
- https://docs.cloud.google.com/storage/docs/best-practices.md.txt
- https://docs.cloud.google.com/storage/docs/hns-buckets-best-practices.md.txt
## <a id="compute-engine"></a>Compute Engine
- https://docs.cloud.google.com/compute/docs/api/best-practices.md.txt
- https://docs.cloud.google.com/compute/docs/connect/ssh-best-practices/auditing.md.txt
- https://docs.cloud.google.com/compute/docs/connect/ssh-best-practices/credentials.md.txt
- https://docs.cloud.google.com/compute/docs/connect/ssh-best-practices.md.txt
- https://docs.cloud.google.com/compute/docs/connect/ssh-best-practices/login-access.md.txt
- https://docs.cloud.google.com/compute/docs/connect/ssh-best-practices/network-access.md.txt
- https://docs.cloud.google.com/compute/docs/disks/snapshot-best-practices.md.txt
- https://docs.cloud.google.com/compute/docs/images/image-families-best-practices.md.txt
- https://docs.cloud.google.com/compute/docs/images/image-management-best-practices.md.txt
- https://docs.cloud.google.com/compute/docs/instances/best-practices-shared-reservations.md.txt
- https://docs.cloud.google.com/compute/docs/instances/sql-server/best-practices.md.txt
- https://docs.cloud.google.com/compute/docs/instances/windows/best-practices.md.txt
- https://docs.cloud.google.com/compute/docs/instances/windows/windows-best-practices.md.txt
- https://docs.cloud.google.com/compute/docs/nodes/sole-tenant-best-practices.md.txt
## <a id="gemini-enterprise-agent-platform"></a>Gemini Enterprise Agent Platform
- https://docs.cloud.google.com/gemini-enterprise-agent-platform/govern/policies/best-practices.md.txt
- https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/capabilities/gemini-image-generation-best-practices.md.txt
- https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/live-api/best-practices.md.txt
- https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/video/best-practice.md.txt
## <a id="google-kubernetes-engine-gke"></a>Google Kubernetes Engine (GKE)
- https://docs.cloud.google.com/kubernetes-engine/docs/best-practices/batch-platform-on-gke.md.txt
- https://docs.cloud.google.com/kubernetes-engine/docs/best-practices/enterprise-multitenancy.md.txt
- https://docs.cloud.google.com/kubernetes-engine/docs/best-practices.md.txt
- https://docs.cloud.google.com/kubernetes-engine/docs/best-practices/machine-learning/inference/autoscaling-tpu.md.txt
- https://docs.cloud.google.com/kubernetes-engine/docs/best-practices/machine-learning/inference/autoscaling.md.txt
- https://docs.cloud.google.com/kubernetes-engine/docs/best-practices/machine-learning/inference/batch-inference.md.txt
- https://docs.cloud.google.com/kubernetes-engine/docs/best-practices/machine-learning/inference.md.txt
- https://docs.cloud.google.com/kubernetes-engine/docs/best-practices/machine-learning/inference/llm-optimization.md.txt
- https://docs.cloud.google.com/kubernetes-engine/docs/best-practices/networking.md.txt
- https://docs.cloud.google.com/kubernetes-engine/docs/best-practices/optimize-ai-utilization.md.txt
- https://docs.cloud.google.com/kubernetes-engine/docs/best-practices/rbac.md.txt
- https://docs.cloud.google.com/kubernetes-engine/docs/best-practices/run-hpc.md.txt
- https://docs.cloud.google.com/kubernetes-engine/docs/best-practices/scalability.md.txt
- https://docs.cloud.google.com/kubernetes-engine/docs/best-practices/upgrading-clusters.md.txt
- https://docs.cloud.google.com/kubernetes-engine/docs/concepts/best-practices-continuous-integration-delivery-kubernetes.md.txt
- https://docs.cloud.google.com/kubernetes-engine/security/ai-security-best-practices.md.txt
- https://docs.cloud.google.com/kubernetes-engine/docs/how-to/hardening-your-cluster.md.txt
## <a id="identity-and-access-management-iam"></a>Identity and Access Management (IAM)
- https://docs.cloud.google.com/iam/docs/best-practices-for-managing-service-account-keys.md.txt
- https://docs.cloud.google.com/iam/docs/best-practices-for-using-service-accounts-in-deployment-pipelines.md.txt
- https://docs.cloud.google.com/iam/docs/best-practices-for-using-workload-identity-federation.md.txt
- https://docs.cloud.google.com/iam/docs/best-practices-service-accounts.md.txt
- https://docs.cloud.google.com/iam/docs/best-practices-workforce-identity-federation.md.txt
- https://docs.cloud.google.com/iam/docs/groups-best-practices.md.txt
- https://docs.cloud.google.com/iam/docs/pam-best-practices.md.txt
## <a id="managed-service-for-apache-spark"></a>Managed Service for Apache Spark
- https://docs.cloud.google.com/managed-spark/docs/concepts/security-best-practices.md.txt
- https://docs.cloud.google.com/managed-spark/docs/guides/best-practices.md.txt
## <a id="memorystore"></a>Memorystore
- https://docs.cloud.google.com/memorystore/docs/cluster/general-best-practices.md.txt
- https://docs.cloud.google.com/memorystore/docs/memcached/best-practices.md.txt
- https://docs.cloud.google.com/memorystore/docs/memcached/memory-management-best-practices.md.txt
- https://docs.cloud.google.com/memorystore/docs/redis/general-best-practices.md.txt
- https://docs.cloud.google.com/memorystore/docs/redis/memory-management-best-practices.md.txt
- https://docs.cloud.google.com/memorystore/docs/valkey/general-best-practices.md.txt
## <a id="migration"></a>Migration
- https://docs.cloud.google.com/migrate/containers/docs/planning-best-practices.md.txt
- https://docs.cloud.google.com/migrate/virtual-machines/docs/5.0/discover/migrating-vms-migrate-for-compute-engine-best-practices.md.txt
## <a id="network-connectivity"></a>Network Connectivity
- https://docs.cloud.google.com/network-connectivity/docs/interconnect/concepts/best-practices.md.txt
- https://docs.cloud.google.com/network-connectivity/docs/router/concepts/best-practices.md.txt
- https://docs.cloud.google.com/network-connectivity/docs/vpn/concepts/best-practices.md.txt
## <a id="observability-in-google-cloud"></a>Observability in Google Cloud
- https://docs.cloud.google.com/stackdriver/docs/managed-prometheus/best-practices/config.md.txt
- https://docs.cloud.google.com/stackdriver/docs/managed-prometheus/best-practices/ingest-and-query.md.txt
- https://docs.cloud.google.com/stackdriver/docs/managed-prometheus/best-practices/multi-tenant.md.txt
- https://docs.cloud.google.com/stackdriver/docs/managed-prometheus/best-practices/rule-alert-mgd.md.txt
- https://docs.cloud.google.com/stackdriver/docs/managed-prometheus/best-practices/rule-alert-self.md.txt
- https://docs.cloud.google.com/stackdriver/docs/managed-prometheus/best-practices/unusual-configs.md.txt
## <a id="pub-sub"></a>Pub/Sub
- https://docs.cloud.google.com/pubsub/docs/metrics-autoscaling-best-practices.md.txt
- https://docs.cloud.google.com/pubsub/docs/publish-best-practices.md.txt
- https://docs.cloud.google.com/pubsub/docs/subscribe-best-practices.md.txt
## <a id="security-command-center"></a>Security Command Center
- https://docs.cloud.google.com/security-command-center/docs/cryptomining-detection-best-practices.md.txt
## <a id="security"></a>Security
- https://docs.cloud.google.com/docs/security/security-best-practices-catalog/agents-applications.md.txt
- https://docs.cloud.google.com/docs/security/security-best-practices-catalog/data-management.md.txt
- https://docs.cloud.google.com/docs/security/security-best-practices-catalog.md.txt
- https://docs.cloud.google.com/docs/security/security-best-practices-catalog/infrastructure.md.txt
- https://docs.cloud.google.com/docs/security/security-best-practices-catalog/recommended-iam-groups.md.txt
- https://docs.cloud.google.com/docs/security/security-best-practices-catalog/secure-enterprise-foundations.md.txt
- https://docs.cloud.google.com/docs/security/security-best-practices-catalog/tools-inference.md.txt
## <a id="spanner"></a>Spanner
- https://docs.cloud.google.com/spanner/docs/best-practices-gaming-database.md.txt
- https://docs.cloud.google.com/spanner/docs/dml-best-practices.md.txt
- https://docs.cloud.google.com/spanner/docs/graph/algorithm-best-practices.md.txt
- https://docs.cloud.google.com/spanner/docs/graph/best-practices-designing-schema.md.txt
- https://docs.cloud.google.com/spanner/docs/graph/best-practices-tuning-queries.md.txt
- https://docs.cloud.google.com/spanner/docs/schema-updates-best-practices.md.txt
- https://docs.cloud.google.com/spanner/docs/sql-best-practices.md.txt
- https://docs.cloud.google.com/spanner/docs/vector-index-best-practices.md.txt
- https://docs.cloud.google.com/spanner/docs/vector-search-best-practices.md.txt
## <a id="vertex-ai"></a>Vertex AI
- https://docs.cloud.google.com/vertex-ai/docs/featurestore/best-practices.md.txt

View File

@@ -0,0 +1,62 @@
# Decision-making guides
| Topic | Document | Description |
| :---- | :---- | :---- |
| Agentic AI: Architecture | https://docs.cloud.google.com/architecture/choose-agentic-ai-architecture-components.md.txt | Provides architectural guidance for selecting the optimal building blocks and services on Google Cloud to power your agentic AI applications. |
| Agentic AI: Design pattern | https://docs.cloud.google.com/architecture/choose-design-pattern-agentic-ai-system.md.txt | Helps you analyze your workload and select the best design pattern (single-agent, multi-agent, etc.) for constructing your generative AI system. |
| AlloyDB Omni: Deployment environment | https://docs.cloud.google.com/alloydb/omni/docs/choose-deployment.md.txt | Provides guidance on choosing the best target environment (single container, Kubernetes, or serverless) for deploying AlloyDB Omni. |
| AlloyDB: Connectivity | https://docs.cloud.google.com/alloydb/docs/choose-alloydb-connectivity.md.txt | Compares AlloyDB connectivity methods, including AlloyDB Auth Proxy, Private Service Connect (PSC), and direct VPC peering, to help you select the appropriate method. |
| AlloyDB: Machine types | https://docs.cloud.google.com/alloydb/docs/choose-machine-type.md.txt | Explains how to select the appropriate machine type for your AlloyDB primary and read instances based on vCPUs, memory, and performance. |
| AlloyDB: Vector index | https://docs.cloud.google.com/alloydb/docs/ai/choose-index-strategy.md.txt | Compares Approximate Nearest Neighbors (ANN) and K-Nearest Neighbors (KNN) indexing strategies to help you choose the appropriate model for vector search. |
| App Engine: Environment | https://docs.cloud.google.com/appengine/docs/the-appengine-environments.md.txt | Compares the App Engine Standard and Flexible environments, helping you select the appropriate environment based on language support, scaling speed, and customization requirements. |
| App Hub: Setup model | https://docs.cloud.google.com/app-hub/docs/set-up-app-hub.md.txt | Helps you select the best approach (single-project, multi-project, or organization-level) for setting up and configuring App Hub. |
| Application hosting | https://cloud.google.com/hosting-options | Compares application hosting (compute) options: Compute Engine, GKE, Cloud Run, App Engine |
| BigQuery: ETL vs. ELT | https://docs.cloud.google.com/bigquery/docs/load-transform-export-intro.md.txt | Describes the data integration approaches to load and transform data in BigQuery using the extract, load, and transform (ELT) or the extract, transform, load (ETL) processes. |
| BigQuery: Natural language processing function | https://docs.cloud.google.com/bigquery/docs/choose-ml-text-function.md.txt | Compares the capabilities of BigQuery ML text functions, such as AI.GENERATE\_TEXT, ML.TRANSLATE, and ML.UNDERSTAND\_TEXT, to help you choose between them. |
| BigQuery: Text generation function | https://docs.cloud.google.com/bigquery/docs/choose-text-generation-function.md.txt | Compares the different text generation options in BigQuery ML (such as using Gemini models vs. other LLMs) to select the appropriate fit. |
| Bigtable: SSD vs HDD | https://docs.cloud.google.com/bigtable/docs/choosing-ssd-hdd.md.txt | Compares the performance, cost, and use cases of SSD versus HDD storage to help you select the best disk layout for your Cloud Bigtable instances. |
| CDN products: Cloud CDN vs. Media CDN | https://docs.cloud.google.com/cdn/docs/choose-cdn-product.md.txt | Helps you select the best CDN product (Cloud CDN vs. Media CDN) based on your content delivery requirements and architecture. |
| Cloud Run: When to use | https://docs.cloud.google.com/run/docs/fit-for-run.md.txt | Provides a checklist and technical assessment guide to determine if your containerized application is well-suited for deployment on Cloud Run. |
| Cloud SQL for MySQL: Editions | https://docs.cloud.google.com/sql/docs/mysql/choose-edition.md.txt | Provides guidance on choosing between Enterprise and Enterprise Plus editions for Cloud SQL for MySQL. |
| Cloud SQL for MySQL: Machine series | https://docs.cloud.google.com/sql/docs/mysql/machine-series-overview.md.txt | Guides you in choosing the optimal machine family and series (general-purpose, memory-optimized, etc.) for your Cloud SQL for MySQL instances. |
| Cloud SQL for MySQL: Storage | https://docs.cloud.google.com/sql/docs/mysql/storage-options-overview.md.txt | Helps you select the best storage options (SSD vs. HDD, automatic storage increase) for Cloud SQL for MySQL databases based on IOPS and throughput needs. |
| Cloud SQL for MySQL: Region availability | https://docs.cloud.google.com/sql/docs/mysql/region-availability-overview.md.txt | Provides information on regional availability and feature support across Google Cloud regions for Cloud SQL for MySQL. |
| Cloud SQL for PostgreSQL: Editions | https://docs.cloud.google.com/sql/docs/postgres/choose-edition.md.txt | Provides guidance on choosing between Enterprise and Enterprise Plus editions for Cloud SQL for PostgreSQL. |
| Cloud SQL for PostgreSQL: Machine series | https://docs.cloud.google.com/sql/docs/postgres/machine-series-overview.md.txt | Guides you in choosing the optimal machine family and series (general-purpose, memory-optimized, etc.) for your Cloud SQL for PostgreSQL instances. |
| Cloud SQL for PostgreSQL: Region availability | https://docs.cloud.google.com/sql/docs/postgres/region-availability-overview.md.txt | Provides information on regional availability and feature support across Google Cloud regions for Cloud SQL for PostgreSQL. |
| Cloud SQL for PostgreSQL: Storage | https://docs.cloud.google.com/sql/docs/postgres/storage-options-overview.md.txt | Helps you select the best storage options (SSD vs. HDD, automatic storage increase) for Cloud SQL for PostgreSQL databases based on IOPS and throughput needs. |
| Cloud SQL for SQL Server: Editions | https://docs.cloud.google.com/sql/docs/sqlserver/choose-edition.md.txt | Provides guidance on choosing between Enterprise and Enterprise Plus editions for Cloud SQL for SQL Server. |
| Cloud SQL for SQL Server: Machine series | https://docs.cloud.google.com/sql/docs/sqlserver/machine-series-overview.md.txt | Guides you in choosing the optimal machine family and series (general-purpose, memory-optimized, etc.) for your Cloud SQL for SQL Server instances. |
| Cloud SQL for SQL Server: Region availability | https://docs.cloud.google.com/sql/docs/sqlserver/region-availability-overview.md.txt | Provides information on regional availability and feature support across Google Cloud regions for Cloud SQL for SQL Server. |
| Cloud SQL for SQL Server: Storage | https://docs.cloud.google.com/sql/docs/sqlserver/storage-options-overview.md.txt | Helps you select the best storage options (SSD vs. HDD, automatic storage increase) for Cloud SQL for SQL Server databases based on IOPS and throughput needs. |
| Cloud Storage: Bucket location | https://docs.cloud.google.com/storage/docs/locations.md.txt | Provides guidance to help you choose appropriate locations for Cloud Storage buckets. |
| Compute Engine: Migration path | https://docs.cloud.google.com/compute/docs/import.md.txt | Helps you evaluate and select the best migration strategy and toolset for migrating your virtual machine workloads into Compute Engine. |
| Compute Engine: Reservation type | https://docs.cloud.google.com/compute/docs/instances/choose-reservation-type.md.txt | Describes reservation types to help you decide how to reserve compute capacity for Compute Engine instances based on your workload needs. |
| Compute Engine: VM deployment strategy | https://docs.cloud.google.com/compute/docs/choose-compute-deployment-option.md.txt | Helps you select an appropriate VM deployment strategy on Compute Engine based on workload resilience, scalability, and cost requirements. |
| Compute Engine: Region selection | https://docs.cloud.google.com/solutions/best-practices-compute-engine-region-selection.md.txt | Describes the criteria that you should consider when you choose Google Cloud regions for your Compute Engine resources |
| Container runtimes | https://docs.cloud.google.com/architecture/select-managed-container-runtime-environment.md.txt | A selection guide comparing managed container options (GKE Autopilot vs. Cloud Run vs. App Engine Flexible) based on organizational and technical factors. |
| Container runtimes: GKE vs. Cloud Run | https://docs.cloud.google.com/kubernetes-engine/docs/concepts/gke-and-cloud-run.md.txt | Provides a comparison of GKE and Cloud Run and their advantages, and helps you find out if a single-platform or hybrid strategy will work for you. |
| Databases: Google Cloud database services | https://github.com/google/skills/blob/main/skills/cloud/cloud-databases-onboarding/references/recommendation_matrix.txt | Provides guidance to help you choose appropriate Google Cloud database services based on the requirements of your workload. |
| Eventarc: Advanced vs. Standard | https://docs.cloud.google.com/eventarc/standard/docs/choose-product-edition.md.txt | Compares the features, scalability, and event-routing models of Eventarc Standard and Eventarc Advanced to help you choose the appropriate edition. |
| Firestore: Native mode vs. Datastore mode | https://docs.cloud.google.com/datastore/docs/firestore-or-datastore.md.txt | Detailed guide comparing Firestore in Native mode versus Datastore mode, including features, scaling limits, and target use cases. |
| Gemini Enterprise Agent Platform: Serverless training method | https://docs.cloud.google.com/vertex-ai/docs/training/custom-training-methods.md.txt | Helps you compare custom training options in Agent Platform, such as custom jobs, hyperparameter tuning jobs, and training pipelines. |
| Gemini Enterprise Agent Platform: Training method | https://docs.cloud.google.com/vertex-ai/docs/start/training-methods.md.txt | Guides you in selecting the appropriate model training approach in Agent Platform, comparing AutoML, custom training, and BigQuery ML. |
| Gemini Enterprise Agent Platform: Vector database for RAG Engine | https://docs.cloud.google.com/gemini-enterprise-agent-platform/build/rag-engine/vector-db-choices.md.txt | Describes and compare the vector database options that are supported on Agent Platform RAG Engine. |
| GKE: Cluster mode | https://docs.cloud.google.com/kubernetes-engine/docs/concepts/choose-cluster-mode.md.txt | Compares GKE Autopilot and Standard modes to help you decide which level of operational control and management is best for your cluster. |
| GKE: Multi-cluster load balancing API | https://docs.cloud.google.com/kubernetes-engine/docs/concepts/choose-mc-lb-api.md.txt | Compares Multi-Cluster Gateway versus Multi-Cluster Ingress to help you choose the correct multi-cluster load balancing approach for GKE. |
| GKE: Predefined ComputeClasses for Autopilot Pods | https://docs.cloud.google.com/kubernetes-engine/docs/how-to/autopilot-compute-classes.md.txt | Explains GKE Autopilot ComputeClasses (Balanced, Scale-Out, Performance) to help you choose the appropriate hardware profile for your containers. |
| Google Cloud Observability: Instrumentation strategy | https://docs.cloud.google.com/stackdriver/docs/instrumentation/choose-approach.md.txt | Guides you through the process of choosing a telemetry instrumentation strategy (such as OpenTelemetry vs. legacy agents) for Google Cloud Observability. |
| Load balancing | https://docs.cloud.google.com/load-balancing/docs/choosing-load-balancer.md.txt | Helps you choose the appropriate Google Cloud load balancer based on client location, protocol, and proxy requirements. |
| Looker: Hosting | https://docs.cloud.google.com/looker/docs/choosing-hosting-option.md.txt | Provides a comprehensive guide to selecting the optimal hosting model (Looker-hosted vs. customer-hosted) based on your requirements |
| Model inference on GKE: Load balancing strategy | https://docs.cloud.google.com/kubernetes-engine/docs/concepts/machine-learning/choose-lb-strategy.md.txt | Provides guidance on load balancing strategies for AI/ML inference workloads on Google Kubernetes Engine. |
| Network Connectivity | https://docs.cloud.google.com/network-connectivity/docs/how-to/choose-product.md.txt | Provides guidance to help you choose appropriate hybrid connectivity options: Cloud Interconnect, Cloud VPN, and Network Connectivity Center. |
| Pub/Sub vs. Cloud Managed Service for Apache Kafka | https://docs.cloud.google.com/pubsub/docs/choose-pubsub-kafka.md.txt | Compares serverless global Pub/Sub versus Google Cloud's Managed Service for Apache Kafka. |
| Pub/Sub vs. Cloud Tasks | https://docs.cloud.google.com/pubsub/docs/choosing-pubsub-or-cloud-tasks.md.txt | Describes the fundamental differences (implicit vs. explicit invocation) between Pub/Sub and Cloud Tasks. |
| Pub/Sub vs. Pub/Sub Lite | https://docs.cloud.google.com/pubsub/docs/choosing-pubsub-or-lite.md.txt | Helps you choose between standard Pub/Sub and Pub/Sub Lite based on budget, operations, and scale requirements. |
| Secret Manager: Replication policy | https://docs.cloud.google.com/secret-manager/docs/choosing-replication.md.txt | Compares automatic replication versus user-managed replication policies in Secret Manager to help you decide how to secure and distribute secrets. |
| Security Command Center: Security sources | https://docs.cloud.google.com/security-command-center/docs/concepts-security-sources.md.txt | Guides you on choosing and configuring security sources (built-in, Google-provided, and third-party) to integrate with Security Command Center. |
| Storage for AI and ML | https://docs.cloud.google.com/ai-hypercomputer/docs/storage.md.txt | Introduces and compares storage services in Google Cloud that can best help you optimize GPU or TPU performance and provides recommendations on the ideal service for specific AI and ML use cases. |
| Storage strategy | https://docs.cloud.google.com/architecture/storage-advisor.md.txt | Helps you understand and choose appropriate storage services for any workload. |
| VPC: Private access | https://docs.cloud.google.com/vpc/docs/private-access-options.md.txt | Compares different private access options on Google Cloud VPC, such as Private Google Access, Private Service Connect, and serverless VPC access. |
| Workflows vs. Application Integration | https://docs.cloud.google.com/workflows/docs/choose-app-integ-or-workflows.md.txt | Compares the capabilities and ideal scenarios for Google Cloud Workflows and Application Integration to help you choose the appropriate orchestration service. |
| Workflows vs. Managed Airflow for service orchestration | https://docs.cloud.google.com/workflows/docs/choose-orchestration.md.txt | Compares Workflows versus Managed Service for Apache Airflow (Cloud Composer) based on latency, scaling models, and language (YAML vs. Python). |

View File

@@ -0,0 +1,179 @@
---
name: google-cloud-waf-cost-optimization
metadata:
category: WellArchitectedFramework
description: Generates cost optimization guidance for Google Cloud workloads based on the Google Cloud Well-Architected Framework (WAF). Use this skill to evaluate a workload, identify cost requirements and constraints, and provide actionable recommendations for build, deploy, and manage the workload cost-efficiently in Google Cloud.
---
# Google Cloud Well-Architected Framework skill for the Cost Optimization pillar
## Overview
The Cost Optimization pillar of the Google Cloud Well-Architected Framework
provides a structured approach to optimize the costs of your cloud workloads
while maximizing business value. Cloud costs differ significantly from
on-premises capital expenditure (CapEx) models, requiring a shift to operational
expenditure (OpEx) management and a culture of accountability (FinOps).
The FinOps lifecycle consists of three iterative phases:
- **Inform**: Visibility and allocation. Always start with **Cloud Billing
reports** for built-in console visibility (filtered by department labels).
Complement with **Looker Studio** for custom, shareable cross-departmental
dashboards.
- **Optimize**: Rates and usage. Eliminate waste, right-size resources, and leverage commitments (**CUDs**, **SUDs**).
- **Operate**: Continuous improvement. Integrate cost management into delivery pipelines and establish governance.
## Operational instructions
- **Comprehensive First**: Always provide a complete list of standard recommendations/strategies relevant to the service or scenario mentioned. Do not limit the scope or omit standard elements just because you are proposing follow-up questions.
- **Full Conjunction**: When an instruction bundles multiple actions (e.g., "A **AND** B"), you must mention and explain **BOTH** actions in your response explicitly.
- **Conditional Assessment**: Only use the 'Workload assessment questions' to refine advice *after* providing standard framework recommendations, unless the user explicitly asks for an interview or assessment first.
## Core principles
The recommendations in the cost optimization pillar of the Well-Architected
Framework are aligned with the following core principles:
- **Align cloud spending with business value**: Ensure that your cloud
resources deliver measurable business value by aligning IT spending with
business objectives. Prioritize investments that directly contribute to
revenue, customer satisfaction, or operational efficiency. Grounding
document:
https://docs.cloud.google.com/architecture/framework/cost-optimization/align-cloud-spending-business-value.md.txt
- **Foster a culture of cost awareness**: Ensure that people across your
organization consider the cost impact of their decisions and activities.
Provide teams with the visibility and information they need to make informed,
cost-conscious choices. Grounding document:
https://docs.cloud.google.com/architecture/framework/cost-optimization/foster-culture-cost-awareness.md.txt
- **Optimize resource usage**: Provision only the resources that you need and
pay only for what you consume. Select the most cost-effective resource types,
sizes, and locations that meet your technical and business requirements.
Grounding document:
https://docs.cloud.google.com/architecture/framework/cost-optimization/optimize-resource-usage.md.txt
- **Optimize continuously**: Continuously monitor your cloud resource usage and
costs, and proactively make adjustments as needed to optimize your spending.
This iterative approach helps identify and address inefficiencies before they
become significant. Grounding document:
https://docs.cloud.google.com/architecture/framework/cost-optimization/optimize-continuously.md.txt
## Relevant Google Cloud products
The following are _examples_ of Google Cloud products and features that are
relevant to cost optimization:
- **Visibility and monitoring**:
- **Cloud Billing reports**: Built-in dashboards for visualizing spending and
trends. **Essential for visibility within the console.**
- **BigQuery billing export**: Enables granular, custom analysis of billing
data using SQL and BI tools.
- **Looker Studio**: Used for creating detailed, shared cost dashboards and
reports. **Use alongside Cloud Billing reports for custom visual insights.**
- **Billing alerts and budgets**: Automated notifications when spending
reaches predefined thresholds.
- **Storage Insights**: Used to analyze Cloud Storage access patterns and identify
cost-saving opportunities.
- **Automation and optimization tools**:
- **Recommender / Active Assist**: Automatically identifies idle resources,
rightsizing opportunities, and unused commitments.
- **Cloud Hub Optimization**: Integrates billing and resource utilization data
to help developers and application owners quickly identify their most
expensive, fluctuating, or underutilized cloud resources.
- **FinOps hub**: Presents active savings and optimization opportunities in
one dashboard.
- **Billing quotas**: Limits on resource consumption to prevent unexpected
cost spikes.
- **Efficient infrastructure**:
- **Managed services and serverless services**: Services like Cloud Run, Cloud
Run functions, and GKE Autopilot reduce operational overhead and pay-per-use
scaling.
- **Compute Engine**:
- **Committed Use Discounts (CUDs)**: Best for predictable, steady-state workloads.
- **Spot VMs**: Best for fault-tolerant, interruptible, or unpredictable batch tasks.
- **Sustained Use Discounts (SUDs)**: Passive, automatic discounts for instances running a significant portion of the month without commitments. **Always mention this as a passive alternative or complement to CUDs.**
- **Cloud Storage Lifecycle Policies**: Automated moves data to lower-cost
storage classes (Nearline, Coldline, Archive) based on age or access.
**Note**: Always recommend **Storage Insights** first to understand current
access patterns before defining lifecycle rules.
- **Networking and Content Delivery**:
- **Location awareness**: Keep traffic within a single region where possible to avoid inter-region data transfer costs.
- **Cloud CDN**: Caches content to reduce data egress from the origin.
- **Network Service Tiers**: Offers **Standard Tier** as a lower-cost option compared to **Premium Tier** for latency-tolerant traffic.
- **Cloud Interconnect / Direct Peering**: Optimizes costs for high-volume data transfer to on-premises environments. **Note**: Always clarify hybrid connectivity options when discussing egress control, as on-premises sync is often a factor in multi-regional designs.
- **Managed Databases**:
- **Instance sizing**: Right-size CPU and memory based on Cloud Monitoring metrics.
- **High Availability (HA)**: Implement HA only for production environments to avoid doubling node costs for all environments.
- **Storage Optimization**: Optimize storage costs by managing backup retention policies **AND** explicitly identifying and deleting unused or idle resources (like unused and orphaned disks, expired snapshots, or idle instances).
- **Organization and governance**:
- **Resource Manager**: Logical structure (Organizations, Folders, Projects)
for cost attribution.
- **Labels**: Metadata tags for categorizing and filtering costs by
environment, team, or application.
- **Organization Policy Service**: Enforces constraints (e.g., restricted
regions or machine types) to control costs.
## Workload assessment questions
Ask appropriate questions to understand the cost-related requirements and
constraints of the workload and the user's organization. Choose questions from
the following list:
- How do you incorporate cost considerations into your cloud architecture design
process?
- How do you foster a culture of cost awareness among your development teams?
- How do you monitor and manage cloud costs across different projects or
departments?
- What strategies do you use to optimize the cost of your compute resources?
- How do you balance cost optimization with the need for agility and innovation?
- How do you ensure that you are not over-provisioning cloud resources?
- How do you use data and analytics to drive cost optimization decisions?
- How do you optimize costs in different environments (e.g., development,
testing, production)?
- How do you ensure that your cost optimization efforts are sustainable and
ongoing?
- How do you measure the success of your cloud cost optimization initiatives?
## Validation checklist
Use the following checklist to evaluate the architecture's alignment with
cost-optimization recommendations:
- **Cost Attribution**: 100% of resources are labeled with key metadata
(e.g., `env`, `team`, `app`).
- **Granular Visibility**: BigQuery billing export is enabled and used for
regular cost reviews.
- **Budgets and Alerts**: Every project or business unit has defined budgets
and active alerts.
- **Rightsizing**: Resources are regularly adjusted based on rightsizing
suggestions provided by Active Assist Recommender.
- **Commitment Strategy**: Spend is reviewed monthly to optimize Committed Use Discount (CUD) coverage. For non-committed workloads, verify if **Sustained Use Discounts (SUDs)** are being captured automatically.
- **Idle Resource Management**: Unused disks, IP addresses, and idle VMs are
identified and removed monthly.
- **Managed Services**: Serverless options are preferred for new workloads
unless specific technical constraints exist.
- **Storage Tiers**: Lifecycle policies are active for all major storage
buckets to minimize archival costs. Be aware of **retrieval fees**
associated with Nearline, Coldline and Archive storage classes.
- **Network Egress**: Data transfer is minimized by keeping traffic regional,
using **Cloud CDN**, and leveraging **Standard Network Tier** where
appropriate. High-volume on-premises traffic uses **Direct Peering** or
**Cloud Interconnect** (always verify if hybrid connectivity is involved).
- **Native Reporting**: **Cloud Billing reports** must be used for standard
views of spending trends in the console.
- **Custom Dashboards**: **Looker Studio** is used for advanced, shareable, and
customized reporting.

View File

@@ -0,0 +1,149 @@
---
name: google-cloud-waf-operational-excellence
metadata:
category: WellArchitectedFramework
description: >-
Generates operations-focused guidance for Google Cloud workloads based on the
design principles and recommendations in the Operational Excellence pillar of
the Google Cloud Well-Architected Framework (WAF). Use this skill to evaluate
a workload, identify operational requirements, and provide actionable
recommendations for deployment, monitoring, and incident management.
---
# Google Cloud Well-Architected Framework skill for the Operational Excellence pillar
## Overview
The operational excellence pillar in the Google Cloud Well-Architected Framework
provides recommendations to operate workloads efficiently on Google Cloud.
Operational excellence in the cloud involves designing, implementing, and
managing cloud solutions that provide value, performance, security, and
reliability. The recommendations in this pillar help you to continuously improve
and adapt workloads to meet the dynamic and ever-evolving needs in the cloud.
## Core principles
The recommendations in the operational excellence pillar of the Well-Architected
Framework are aligned with the following core principles:
- **Ensure operational readiness**: Define and measure criteria for a workload
to be considered ready for production, including staffing, processes, and
governance. Grounding document:
https://docs.cloud.google.com/architecture/framework/operational-excellence/operational-readiness-and-performance-using-cloudops.md.txt
- **Manage incidents and problems**: Establish structured processes for
incident response, communication, and root cause analysis to minimize impact
and prevent recurrence. Grounding document:
https://docs.cloud.google.com/architecture/framework/operational-excellence/manage-incidents-and-problems.md.txt
- **Manage and optimize cloud resources**: Monitor resource utilization and
right-size environments to maintain performance while ensuring operational
efficiency. Grounding document:
https://docs.cloud.google.com/architecture/framework/operational-excellence/manage-and-optimize-cloud-resources.md.txt
- **Automate and manage change**: Use Infrastructure as Code (IaC) and CI/CD
pipelines to ensure consistent, repeatable, and low-risk deployments and
configuration changes. Grounding document:
https://docs.cloud.google.com/architecture/framework/operational-excellence/automate-and-manage-change.md.txt
- **Continuously improve and innovate**: Regularly review architectures,
monitor industry trends, and adapt operations to meet evolving business
needs. Grounding document:
https://docs.cloud.google.com/architecture/framework/operational-excellence/continuously-improve-and-innovate.md.txt
## Relevant Google Cloud products
The following are _examples_ of Google Cloud products and features that are
relevant to operational excellence:
- **Observability and monitoring**
- **Cloud Monitoring**: Full-stack observability for Google Cloud and
hybrid environments.
- **Cloud Logging**: Real-time log management and analysis at scale.
- **Error Reporting**: Aggregates and displays errors for running cloud
services.
- **Service Monitoring**: Tools for defining and tracking Service Level
Objectives (SLOs).
- **Automation and CI/CD**
- **Cloud Build**: Serverless platform for building, testing, and
deploying software.
- **Cloud Deploy**: Managed continuous delivery service for GKE, Cloud
Run, and GCE.
- **Terraform / Infrastructure Manager**: Managed service for
Infrastructure as Code (IaC) automation.
- **Artifact Registry**: Central repository for managing build artifacts
and container images.
- **Resource management and optimization**
- **Recommender (Active Assist)**: Automatically identifies idle resources
and right-sizing opportunities.
- **Resource Manager**: Hierarchical management of resources across
organizations, folders, and projects.
- **Incident response**
- **Incident response & management (IRM)**: Structured tools and processes
for managing operational disruptions.
## Workload assessment questions
Ask appropriate questions to understand operations-related requirements and
constraints of the workload and the user's organization. Choose questions from
the following list:
- **Operational readiness and performance**
- How do you define and measure operational readiness for your cloud
workloads and what specific criteria or metrics do you use?
- Describe your process for defining, tracking, and achieving SLOs for
your critical workloads.
- **Incident and problem management**
- Describe your incident management process, including roles,
responsibilities, and communication channels.
- How do you conduct post-incident reviews (PIRs) to identify root causes
and implement preventive measures?
- **Resource management and optimization**
- How do you ensure that your cloud resources are right-sized for your
workloads, and what tools or techniques do you use?
- **Change automation**
- Describe your change management process, including approval workflows,
testing procedures, and deployment strategies.
- How do you automate deployments, ensure their consistency and manage
configuration?
- **Continuous improvement**
- How do you ensure that your cloud operations are continuously adapting
to meet evolving business needs and technological advancements?
## Validation checklist
Use the following checklist to evaluate the architecture's alignment with
operational excellence recommendations:
- **Operational readiness**
- [ ] A formal framework or set of criteria exists to assess operational
readiness before production deployment.
- [ ] Service Level Objectives (SLOs) are explicitly defined and monitored
using automated tools.
- **Incident management**
- [ ] Incident response roles and communication channels are clearly
defined and documented.
- [ ] A structured, blameless post-mortem process is followed for all
major incidents.
- **Change automation**
- [ ] All infrastructure changes are performed using Infrastructure as
Code (IaC) to ensure consistency.
- [ ] CI/CD pipelines are integrated with automated testing for all
deployment changes.
- **Resource optimization**
- [ ] Resource utilization is regularly reviewed using recommendations
from Active Assist or performance data.
- **Culture of improvement**
- [ ] A documented strategy is in place for regularly reviewing and
adapting cloud operations to industry advancements.

View File

@@ -0,0 +1,149 @@
---
name: google-cloud-waf-performance-optimization
metadata:
category: WellArchitectedFramework
description: >-
Generates performance-focused guidance for Google Cloud workloads based on the
design principles and recommendations in the Performance Optimization pillar
of the Google Cloud Well-Architected Framework (WAF). Use this skill
to evaluate a workload, identify performance requirements, and provide
actionable recommendations for resource allocation, modular design, and
elasticity.
---
# Google Cloud Well-Architected Framework skill for the Performance Optimization pillar
## Overview
The Performance Optimization pillar of the Google Cloud Well-Architected
Framework provides principles and recommendations to help you design, build, and
operate high-performing workloads. It focuses on efficiently allocating
resources, leveraging modular architectures, and using data-driven insights to
continuously monitor and improve performance as your business needs evolve.
## Core principles
The recommendations in the performance optimization pillar of the
Well-Architected Framework are aligned with the following core principles:
- **Plan resource allocation**: Carefully select and configure the compute,
storage, and networking resources that best match the specific requirements
of your workload. Grounding document:
https://docs.cloud.google.com/architecture/framework/performance-optimization/plan-resource-allocation.md.txt
- **Take advantage of elasticity**: Utilize automated scaling and serverless
technologies to dynamically adjust resource capacity in response to
real-time demand fluctuations. Grounding document:
https://docs.cloud.google.com/architecture/framework/performance-optimization/elasticity.md.txt
- **Promote modular design**: Architect systems using independent, loosely
coupled components to enhance scalability and allow individual parts to be
optimized without affecting the entire system. Grounding document:
https://docs.cloud.google.com/architecture/framework/performance-optimization/promote-modular-design.md.txt
- **Continuously monitor and improve performance**: Implement robust
observability to identify bottlenecks and use performance data to drive
iterative enhancements throughout the software development lifecycle.
Grounding document:
https://docs.cloud.google.com/architecture/framework/performance-optimization/continuously-monitor-and-improve-performance.md.txt
## Relevant Google Cloud products
The following are _examples_ of Google Cloud products and features that are
relevant to performance optimization:
- **Compute and scaling**
- **Compute Engine (MIGs)**: Managed instance groups that support
autoscaling and load balancing for VM-based workloads.
- **Google Kubernetes Engine (GKE)**: Provides container orchestration
with horizontal and vertical pod autoscaling.
- **Cloud Run**: A fully managed serverless platform that automatically
scales containers to zero or up based on traffic.
- **Data and caching**
- **Cloud CDN**: Low-latency content delivery network to cache static and
dynamic content closer to end-users.
- **Memorystore**: Managed in-memory data store for Valkey and Redis to
provide sub-millisecond data access.
- **Bigtable**: NoSQL database service for analytical and operational
workloads requiring low latency and high throughput.
- **Spanner**: RDBMS that provides global consistency, high availability,
and horizontal scaling for mission-critical transactional applications.
- **Performance analysis and monitoring**
- **Cloud Trace**: Distributed tracing system that helps identify latency
bottlenecks.
- **Cloud Profiler**: Continuous CPU and memory profiling to identify
resource-heavy application code.
- **Cloud Monitoring**: Provides dashboards and alerts based on
performance KPIs like latency and throughput.
## Workload assessment questions
Ask appropriate questions to understand the performance-related requirements and
constraints of the workload and the user's organization. Choose questions from
the following list:
- **Plan resource allocation**
- When initially provisioning compute resources for a new application,
which approach do you use to determine the required capacity for
expected peak loads?
- Which caching strategies (browser, in-memory, CDN, database) do you
utilize to improve performance and responsiveness?
- How do you optimize the performance of your data storage solutions
(e.g., SSD vs HDD, storage classes) for your applications?
- **Promote modular design**
- Which architectural patterns (microservices, asynchronous messaging,
stateless servers) do you employ to enhance performance and resilience?
- How do you design your application to minimize the impact of failures in
one part of the system on other parts?
- **Continuously monitor and improve performance**
- How frequently do you review and analyze the performance of your
production applications and infrastructure?
- Which tools or techniques (APM, distributed tracing, load testing) do
you use to proactively identify and diagnose performance bottlenecks?
- How do you incorporate performance considerations into your software
development lifecycle (SDLC)?
- **Take advantage of elasticity**
- Which methods do you use to manage and optimize the cost of your cloud
resources while maintaining performance?
- How do you typically handle sudden spikes in traffic or workload on your
applications?
## Validation checklist
Use the following checklist to evaluate the architecture's alignment with
performance optimization recommendations:
- **Resource allocation**
- [ ] Initial provisioning is based on load testing or historical data
rather than general estimates.
- [ ] Caching is implemented at multiple layers (CDN, in-memory, or
browser) to offload backend systems.
- [ ] Storage types (SSD/HDD) and classes are selected based on the
specific I/O requirements of the workload.
- **Modular design**
- [ ] The architecture uses microservices or decoupled components to allow
independent scaling.
- [ ] Circuit breakers or bulkheads are implemented to isolate failures
and prevent performance degradation across the system.
- **Monitoring and continuous improvement**
- [ ] Automated dashboards and alerts are configured for key performance
indicators (KPIs).
- [ ] Distributed tracing and profiling tools are used to identify
code-level bottlenecks.
- [ ] Performance testing (unit and integration) is integrated into the
software development lifecycle.
- **Elasticity**
- [ ] Auto-scaling rules are configured and validated to handle variable
demand.
- [ ] The architecture leverages serverless or managed services to
dynamically match capacity to load.
- [ ] Resource utilization is reviewed regularly to eliminate idle
overhead and balance cost with performance.

View File

@@ -0,0 +1,147 @@
---
name: google-cloud-waf-reliability
metadata:
category: WellArchitectedFramework
description: >-
Generates guidance for reliability, resilience, availability, redundancy,
fault-tolerance, and disaster recovery (DR) for Google Cloud workloads based
on the design principles and recommendations in the Google Cloud
Well-Architected Framework. Use when the user asks to evaluate, design, or
improve the reliability, resilience, availability, or disaster recovery
capabilities of Google Cloud workloads.
---
# Google Cloud Well-Architected Framework skill for the Reliability pillar
## Overview
The Reliability pillar of the Google Cloud Well-Architected Framework provides
principles and recommendations to help you design, deploy, and manage reliable,
resilient, and highly available workloads in Google Cloud. A reliable system
consistently performs its intended functions under defined conditions, is
resilient to failures, and recovers gracefully from disruptions, thereby
minimizing downtime, enhancing user experience, and ensuring data integrity.
## Core principles
The recommendations in the reliability pillar of the Well-Architected Framework
are aligned with the following core principles:
- **Define reliability based on user-experience goals**: Measurement of
reliability should reflect the actual experience of the system's users rather
than merely relying on infrastructure metrics. Focus on outcomes that matter
most to users. Grounding document:
https://docs.cloud.google.com/architecture/framework/reliability/define-reliability-based-on-user-experience-goals.md.txt
- **Set realistic targets for reliability**: Determine appropriate Service
Level Objectives (SLOs) that balance the cost and complexity of maximizing
availability against business requirements. Provide guidance on defining
Service Level Objectives (SLOs) based on monitoring signals, error budgets,
and user experience goals. Grounding document:
https://docs.cloud.google.com/architecture/framework/reliability/set-targets.md.txt
- **Build highly available systems through resource redundancy**: Eliminate
single points of failure by duplicating critical components across zones and
regions to maintain operations during localized outages. Grounding document:
https://docs.cloud.google.com/architecture/framework/reliability/build-highly-available-systems.md.txt
- **Take advantage of horizontal scalability**: Design system architectures to
scale horizontally (adding more instances) to seamlessly accommodate load
fluctuations and improve overall fault tolerance. Incorporate proactive
capacity planning to monitor and adjust project quotas and resource
availability anticipating sudden load spikes. Grounding document:
https://docs.cloud.google.com/architecture/framework/reliability/horizontal-scalability.md.txt
- **Detect potential failures by using observability**: Implement thorough
monitoring, logging, and alerting systems to proactively detect, diagnose,
and address anomalies before they cause user-facing issues. Monitor the
golden signals (latency, traffic, errors, and saturation) and set up alerts
for when the signals cross specified thresholds. Use Cloud Monitoring to
build comprehensive dashboards for the golden signals. Grounding document:
https://docs.cloud.google.com/architecture/framework/reliability/observability.md.txt
- **Design for graceful degradation**: Architect systems to maintain critical
functionality, even if at reduced performance or with limited features, when
dependencies fail or the system experiences extreme stress. To avoid
cascading failures, recommend setting up alerts to detect failures early,
using the circuit-breaker pattern, handling timeouts effectively to release
blocked resources, utilizing retries with exponential backoff and jitter to
avoid overwhelming recovering backend systems, and returning custom error
responses or static fallback pages. Grounding document:
https://docs.cloud.google.com/architecture/framework/reliability/graceful-degradation.md.txt
- **Perform testing for recovery from failures**: Build confidence in system
resilience by continuously simulating failures and verifying the
effectiveness of automated and manual recovery procedures. Grounding
document:
https://docs.cloud.google.com/architecture/framework/reliability/perform-testing-for-recovery-from-failures.md.txt
- **Perform testing for recovery from data loss**: Regularly test backup and
restore protocols to ensure rapid recovery from data corruption or loss,
remaining within the defined Recovery Time Objective (RTO) and Recovery Point
Objective (RPO). Grounding document:
https://docs.cloud.google.com/architecture/framework/reliability/perform-testing-for-recovery-from-data-loss.md.txt
- **Conduct thorough postmortems**: Foster a blameless culture by investigating
outages comprehensively to understand root causes, followed by implementing
measures that prevent recurrence. Grounding document:
https://docs.cloud.google.com/architecture/framework/reliability/conduct-postmortems.md.txt
## Relevant Google Cloud products
The following are _examples_ of Google Cloud products and features that are
relevant to reliability:
- **Compute**: Compute Engine Managed Instance Groups (MIGs), Google Kubernetes
Engine (GKE), Cloud Run
- **Networking**: Cloud Load Balancing, Cloud CDN, Cloud DNS
- **Storage and databases**: Cloud Storage (multi-region), Cloud SQL High
Availability, Spanner, Filestore, Firestore
- **Operations**: Cloud Monitoring, Cloud Logging, Google Cloud Managed Service
for Prometheus
- **Disaster recovery**: Backup and DR Service, Filestore backups
## Workload assessment questions
Ask appropriate questions to understand the reliability-related requirements and
constraints of the workload and the user's organization. Choose questions from
the following list:
- How does your organization define and measure the reliability of your systems
in relation to user experience?
- How does your organization approach setting reliability targets for your
services?
- What is your organization's strategy for ensuring high availability through
resource redundancy?
- How does your organization leverage horizontal scalability to maintain
performance and reliability?
- How does your organization utilize observability (metrics, logs, traces) to
gain insights and detect potential failures?
- How does your organization manage alerting based on observability data to
ensure timely responses to significant issues without causing alert fatigue?
- What measures does your organization take to ensure systems can gracefully
degrade during high load or partial failures?
- How frequently and comprehensively does your organization test for recovery
from system failures (e.g., regional failovers, release rollbacks)?
- What is your organization's approach to testing for recovery from data loss?
- How does your organization conduct and utilize postmortems after incidents?
## Validation checklist
Use the following checklist to evaluate the architecture's alignment with
reliability recommendations:
- User-focused SLIs and SLOs are explicitly defined and actively monitored.
- The architecture avoids single points of failure through cross-zone or
cross-region redundancy.
- Autoscaling is enabled to handle variable demand without manual intervention.
- Application and infrastructure health checks are configured to trigger
automated failovers.
- Regular backup schedules are in place, and restoration processes are routinely
tested.
- The system architecture incorporates patterns like circuit breakers, retries
with exponential backoff, and rate limiting to support graceful degradation.
- Game days or chaos engineering practices are regularly held to validate
failure recovery.
- A formalized, blameless postmortem process exists to ensure organizational
learning from operational incidents.

View File

@@ -0,0 +1,352 @@
---
name: google-cloud-waf-security
metadata:
category: WellArchitectedFramework
description: >-
Generates security-focused guidance for Google Cloud workloads based on the
design principles and recommendations in the Google Cloud Well-Architected
Framework (WAF). Use this skill to evaluate workloads, identify security
requirements, and provide actionable recommendations for IAM, network
security, data protection, and operational security.
---
# Google Cloud Well-Architected Framework skill for the Security pillar
## Overview
The security pillar of the Google Cloud Well-Architected Framework provides
design principles and best practices for building a robust security posture by
integrating security into every layer of the architecture for cloud workloads.
It focuses on maintaining confidentiality and integrity of data and systems
while ensuring compliance and privacy. It provides a structured approach to risk
management, threat defense, and identity control, enabling you to operate cloud
workloads securely and at scale.
## Workflow
When this skill is activated, follow these steps to evaluate and improve the
security posture of the specified Google Cloud workload:
1. **Understand the context**: Ask targeted questions from the **Workload
assessment questions** list to gather information about the user's current
architecture, security requirements, and constraints.
2. **Analyze and identify gaps**: Evaluate the workload against the **Core
principles** and the **Validation checklist** to identify security
vulnerabilities, missing controls, or deviations from best practices.
3. **Formulate recommendations**: Provide actionable, prioritized guidance
based on the Google Cloud Well-Architected Framework. Recommend specific
products from **Relevant Google Cloud products** to address the identified
gaps.
4. **Explain the recommendations**: Align all recommendations with the
appropriate **Core principles** and state the benefits that each
recommendation provides.
5. **Iterate and refine**: Help the user adapt the recommendations to their
specific requirements and constraints.
## Core principles
The recommendations in the security pillar of the Well-Architected Framework are
aligned with the following core principles:
- **Implement security by design**: Integrate cloud security and network
security considerations starting from the initial design phase of your
applications and infrastructure. Google Cloud provides architecture
blueprints and recommendations to help you apply this principle. Grounding
document:
https://docs.cloud.google.com/architecture/framework/security/implement-security-by-design.md.txt
- **Implement zero trust**: Use a _never trust, always verify_ approach, where
access to resources is granted based on continuous verification of trust.
Google Cloud supports this principle through products like Chrome Enterprise
Premium, Identity-Aware Proxy (IAP) and IAM Recommender. Grounding document:
https://docs.cloud.google.com/architecture/framework/security/implement-zero-trust.md.txt
- **Implement shift-left security**: Implement security controls early in the
software development lifecycle. Avoid security defects before system changes
are made. Detect and fix security bugs early, fast, and reliably after the
system changes are committed. Google Cloud supports this principle through
products like Cloud Build, Binary Authorization, and Artifact Registry.
Grounding document:
https://docs.cloud.google.com/architecture/framework/security/implement-shift-left-security.md.txt
- **Implement preemptive cyber defense**: Adopt a proactive approach to
security by implementing robust fundamental measures like threat
intelligence. This approach helps you build a foundation for more effective
threat detection and response. Google Cloud's approach to layered security
controls aligns with this principle. Google Cloud supports this principle
through products like Security Command Center, Google Threat Intelligence,
and Google SecOps. Grounding document:
https://docs.cloud.google.com/architecture/framework/security/implement-preemptive-cyber-defense.md.txt
- **Use AI securely and responsibly**: Develop and deploy AI systems in a
responsible and secure manner. The recommendations for this principle are
aligned with guidance in the AI and ML perspective of the Well-Architected
Framework and in Google's Secure AI Framework (SAIF). Grounding document:
https://docs.cloud.google.com/architecture/framework/security/use-ai-securely-and-responsibly.md.txt
- **Use AI for security**: Use AI capabilities to improve your existing
security systems and processes through Gemini in Security and overall
platform-security capabilities. Use AI as a tool to increase the automation
of remedial work and ensure security hygiene to make other systems more
secure. Google Cloud supports this principle through products like Google
Threat Intelligence and Google SecOps. Grounding document:
https://docs.cloud.google.com/architecture/framework/security/use-ai-for-security.md.txt
- **Meet regulatory, compliance, and privacy needs**: Adhere to
industry-specific regulations, compliance standards, and privacy
requirements. Google Cloud helps you meet these obligations through products
like Assured Workloads, Organization Policy Service, and our compliance
resource center. Grounding document:
https://docs.cloud.google.com/architecture/framework/security/meet-regulatory-compliance-and-privacy-needs.md.txt
- **Shared responsibilities and shared fate on Google Cloud**: Understand that
Google is responsible for the security _of_ the cloud and you're responsible
for the security of your workloads _in_ the cloud. Recognize how this division
of responsibilities varies based on the workload type. Learn what Google does
to help ensure that security _of_ the cloud. Take appropriate actions to help
ensure that your workloads are secure _in_ the cloud.
Grounding document: https://docs.cloud.google.com/architecture/framework/security/shared-responsibility-shared-fate.md.txt
## Relevant Google Cloud products
The following are _examples_ of Google Cloud products and features that are
relevant to security:
- **Identity and access management**
- **Cloud Identity**: Manage user lifecycles, authentication, and identity
federation.
- **Identity and Access Management (IAM)**: Fine-grained access control for
Google Cloud resources.
- **Identity-Aware Proxy (IAP)**: Secure access to applications without a VPN.
- **Chrome Enterprise Premium**: Endpoint security and context-aware access.
- **IAM Recommender**: Provide policy intelligence.
- **Network security**
- **Google Cloud Armor**: DDoS protection and Web Application Firewall (WAF).
- **VPC Service Controls**: Define security perimeters to prevent data
exfiltration.
- **Cloud Next-Generation Firewall (NGFW)**: Advanced threat protection for
network traffic.
- **Shared VPC**: Centralized network management across projects.
- **Cloud Interconnect and IPsec VPN**: Secure, private connectivity.
-**Private Service Connect**: Provide private access to managed services
- **Data security**
- **Cloud Key Management Service (KMS)**: Manage encryption keys.
- **Sensitive Data Protection (formerly Cloud DLP)**: Discover and redact
sensitive data.
- **Confidential Computing**: Encrypt data in use (memory).
- **Security operations (SecOps)**
- **Google SecOps (Chronicle)**: Threat detection and security analytics.
- **Security Command Center (SCC)**: Centralized vulnerability and threat
management.
- **Cloud Logging and Cloud Monitoring**: Visibility into system activity.
- **BigQuery**: Storing exported logs for analysis.
- **Automation and supply chain**
- **Cloud Build**: Secure CI/CD pipelines.
- **Artifact Analysis**: Vulnerability scanning for container images.
- **Binary Authorization**: Deploy-time policy enforcement.
- **Assured open source software**: Use secured OSS packages.
## Workload assessment questions
Ask appropriate questions to understand the security-related requirements and
constraints of the workload and the user's organization. Choose questions from
the following list:
- **Security by design**:
- How do you incorporate security considerations into your project's initial
planning and design phases?
- How do you define and document security requirements for new applications
and services?
- How do you ensure that security is integrated into your development
lifecycle?
- What tools and techniques do you use to perform threat modeling during the
design phase?
- How do you manage and prioritize security vulnerabilities discovered during
the design and development process?
- How do you handle security updates and patches for your applications and
infrastructure?
- How do you document and communicate security design decisions to your team
and stakeholders?
- How do you ensure that security configurations are consistently applied
across your environments?
- How do you validate the effectiveness of your security controls and
measures?
- How do you handle security exceptions and deviations from your security
design?
- **Zero trust**:
- How do you verify and authenticate users and devices accessing your Google
Cloud resources?
- How do you implement the principle of least privilege for access control?
- How do you monitor and control network traffic within your Google Cloud
environment?
- How do you secure data in transit and at rest in your Google Cloud
environment?
- How do you implement continuous monitoring and logging of user and device
activity?
- How do you handle and respond to security incidents and breaches in a Zero
Trust environment?
- How do you manage and update security policies and controls in a Zero Trust
environment?
- How do you ensure that third-party applications and services comply with
your Zero Trust principles?
- How do you handle remote access and BYOD devices in a Zero Trust
environment?
- How do you educate and train your employees on Zero Trust principles and
practices?
- **Shift-left security**:
- How do you integrate security testing into your development pipeline early
in the process?
- What types of security testing do you perform during the development phase?
- How do you provide developers with feedback on security vulnerabilities and
best practices?
- How do you empower developers to take ownership of security in their code?
- How do you ensure that security requirements are clearly defined and
communicated to developers?
- How do you measure the effectiveness of your Shift Left security
initiatives?
- How do you handle security dependencies and third-party libraries in your
code?
- How do you manage and update security configurations in your development
environment?
- How do you handle security exceptions and deviations from your security
policies in development?
- How do you promote a culture of security awareness and responsibility among
developers?
- **Preemptive cyber defense**:
- How do you proactively identify and mitigate potential security threats
before they impact your systems?
- What tools and techniques do you use for continuous security monitoring and
analysis?
- How do you respond to and remediate security alerts and incidents?
- How do you simulate and test your incident response plans?
- How do you stay up-to-date with the latest security threats and
vulnerabilities?
- How do you handle and mitigate DDoS attacks against your applications and
services?
- How do you protect your sensitive data from insider threats?
- How do you ensure that your security controls are effective against advanced
persistent threats (APTs)?
- How do you handle security vulnerabilities in your supply chain?
- How do you adapt your security posture to evolving threats and technologies?
- **Security of AI workloads**:
- How do you ensure the security of your AI models and data?
- How do you address potential biases and ethical concerns in your AI models?
- How do you protect your AI models from adversarial attacks and data
poisoning?
- How do you ensure the privacy of data used in your AI models?
- How do you explain and interpret the decisions made by your AI models?
- How do you manage and control access to your AI models and data?
- How do you ensure compliance with regulations and standards related to
AI and ML?
- How do you monitor and detect anomalies in the behavior of your AI models?
- How do you handle and respond to security incidents involving your AI
models?
- How do you educate and train your employees on the secure and responsible
use of AI and ML?
- **AI for security**:
- How do you leverage AI and ML to enhance your security posture?
- What types of AI models do you use for security purposes?
- How do you train and validate your AI models for security applications?
- How do you ensure the accuracy and reliability of AI-based security
systems?
- How do you handle false positives and false negatives from AI-based
security systems?
- How do you integrate AI-based security systems with your existing security
infrastructure?
- How do you manage and update your AI models for security applications?
- How do you explain and interpret the decisions made by your AI models for
security applications?
- How do you ensure the ethical and responsible use of AI and ML for security
purposes?
- How do you measure the effectiveness of AI and ML in improving your security
posture?
- **Regulatory compliance and privacy**:
- What regulatory compliance frameworks and privacy standards do you need to
adhere to?
- How do you assess and manage compliance risks in your Google Cloud
environment?
- How do you ensure the privacy of sensitive data stored and processed in
Google Cloud?
- How do you handle data subject requests (DSRs) related to privacy
regulations?
- How do you document and track compliance activities and evidence?
- How do you ensure that third-party vendors and partners comply with your
regulatory and privacy requirements?
- How do you handle data breaches and security incidents related to compliance
regulations?
- How do you stay up-to-date with changes in regulatory compliance and privacy
standards?
- How do you educate and train your employees on regulatory compliance and
privacy requirements?
- How do you demonstrate and prove compliance to auditors and regulators?
## Validation checklist
Use the following checklist to evaluate the architecture's alignment with
security recommendations:
- **Security by design**:
- Are system components selected based on their security features and
hardening?
- Is defense-in-depth implemented at the network, host, and application
layers?
- Are safe libraries and application frameworks used to prevent common
vulnerabilities?
- Is a risk assessment performed using industry standards?
- **Zero trust**:
- Is Cloud Identity used as a centralized identity provider for managing user
lifecycles and federation?
- Is access control enforced based on user identity and context (device,
location)?
- Are private connectivity methods (Cloud Interconnect, VPN) used for internal
traffic?
- Are default networks disabled in all projects?
- Are VPC Service Controls perimeters established around sensitive data?
- **Shift-left security**:
- Is infrastructure provisioned using Infrastructure as Code
(e.g., Terraform)?
- Are automated security scans integrated into the CI/CD pipeline?
- Is there a process for scanning and patching vulnerabilities in
dependencies?
- Is Binary Authorization used to ensure only trusted images are deployed?
- **Preemptive cyber defense**:
- Is threat intelligence integrated into security operations?
- Is security logging enabled and centralized for all critical resources?
- Are automated responses configured for common security threats?
- Are defenses validated through periodic testing or red-teaming?
- **AI security and governance**:
- Are AI pipelines secured against tampering and data poisoning?
- Is differential privacy or data masking used for training data where
appropriate?
- Are Vertex Explainable AI and fairness indicators used for model governance?

View File

@@ -0,0 +1,253 @@
---
name: google-cloud-waf-sustainability
metadata:
category: WellArchitectedFramework
description: >-
Generates sustainability-focused guidance for Google Cloud workloads based on
the design principles and recommendations in the Google Cloud Well-Architected
Framework (WAF). Use this skill to evaluate a workload, identify environmental
impact requirements, and provide actionable recommendations to build, deploy,
and manage the workload sustainably in Google Cloud.
---
# Google Cloud Well-Architected Framework skill for the Sustainability pillar
## Overview
The Sustainability pillar of the Google Cloud Well-Architected Framework
provides principles and recommendations to help you minimize the environmental
impact of your cloud workloads. It focuses on a shared responsibility
model—Google optimizes the sustainability *of* the cloud, while customers
optimize sustainability *in* the cloud. By making informed decisions about
architecture, resource allocation, and region selection, you can significantly
reduce your carbon footprint and improve overall energy efficiency.
## Core principles
The recommendations in the sustainability pillar of the Well-Architected
Framework are aligned with the following core principles:
- **Shared responsibility**: Define the boundaries of responsibility and
embrace a shared fate model, working with your cloud provider and partners
to achieve optimal environmental outcomes for the entire ecosystem.
Grounding document:
https://docs.cloud.google.com/architecture/framework/sustainability.md.txt
- **Use regions that consume low-carbon energy**: Prioritize Google Cloud
regions with a high percentage of Carbon-Free Energy (CFE) and "Low CO2"
indicators to lower the gross carbon emissions of your deployments.
Grounding document:
https://docs.cloud.google.com/architecture/framework/sustainability/low-carbon-regions.md.txt
- **Optimize AI and ML workloads**: Maximize computations per watt by matching
algorithmic needs to specialized hardware (like TPUs) and applying
mathematical techniques to reduce computational complexity. Grounding
document:
https://docs.cloud.google.com/architecture/framework/sustainability/ai-ml-energy-efficiency.md.txt
- **Optimize resource usage**: Eliminate energy waste by scaling resources to
zero when idle, rightsizing virtual machines, and prioritizing managed
services that dynamically match actual demand. Grounding document:
https://docs.cloud.google.com/architecture/framework/sustainability/optimize-resource-usage.md.txt
- **Develop energy-efficient software**: Design your applications to minimize
unnecessary CPU, memory, and network activity on both backend servers and
end-user devices by using event-driven logic and optimized assets. Grounding
document:
https://docs.cloud.google.com/architecture/framework/sustainability/energy-efficient-software.md.txt
- **Optimize data and storage**: Reduce the environmental footprint of your
storage by implementing lifecycle management to archive cold data and
eliminating "dark data" that provides no business value. Grounding document:
https://docs.cloud.google.com/architecture/framework/sustainability/optimize-storage.md.txt
- **Continuously measure and improve**: Gain visibility into your carbon
emissions by analyzing granular data, identifying hotspots, and taking
proactive steps to remediate inefficiencies. Grounding document:
https://docs.cloud.google.com/architecture/framework/sustainability/continuously-measure-improve.md.txt
- **Promote a culture of sustainability**: Embed sustainability into your
organizational governance, connect technical decisions to environmental
goals, and ensure staff have the skills to implement green practices.
Grounding document:
https://docs.cloud.google.com/architecture/framework/sustainability/culture.md.txt
- **Align sustainability practices with industry guidelines**: Ensure that
your sustainability initiatives are aligned with industry guidelines for
measurement, reporting, and verification, such as W3C Web Sustainability
Guidelines, Green Software Foundation, and Greenhouse Gas Protocol.
Grounding document:
https://docs.cloud.google.com/architecture/framework/sustainability/industry-guidelines.md.txt
## Relevant Google Cloud products
The following are _examples_ of Google Cloud products and features that are
relevant to sustainability:
- **Visibility and measurement**:
- **Carbon Footprint**: Provides dashboard visibility into greenhouse gas
emissions associated with Google Cloud usage.
- **BigQuery**: Analyzes exported Carbon Footprint data alongside billing
data to identify emission hotspots.
- **Infrastructure and operations**:
- **Google Cloud Region Picker**: Helps weigh carbon footprint, cost, and
latency when selecting deployment locations.
- **Active Assist / Recommender**: Automatically identifies idle resources
and provides VM rightsizing recommendations to reduce waste.
- **Cloud Run / GKE Autopilot**: Fully managed compute environments that
optimize cluster usage and can scale to zero when idle.
- **Cloud Batch**: Optimizes the scheduling of batch jobs, allowing
execution during periods of high Carbon-Free Energy.
- **Spot VMs**: Utilizes unused data center capacity for fault-tolerant
workloads, improving overall hardware efficiency.
- **Data and AI**:
- **Cloud Storage Lifecycle Management**: Automatically transitions older
data to lower-energy storage classes (Nearline, Coldline, Archive).
- **Cloud TPUs**: Specialized hardware optimized for the energy efficiency
of large-scale AI/ML matrix multiplications.
## Workload assessment questions
Ask appropriate questions to understand the sustainability-related requirements
and constraints of the workload and the user's organization. Choose questions
from the following list:
- **Cloud sustainability**:
- How do you define the boundaries of sustainability responsibility
between your organization and your cloud provider?
- How do you leverage cloud capabilities and AI to drive sustainability
outcomes for your broader business operations?
- How does your cloud strategy account for the sustainability impact of
your partner ecosystem and multi-cloud environments?
- **Use regions that consume low-carbon energy**:
- How do you incorporate carbon intensity into your Google Cloud region
selection strategy?
- **Optimize AI and ML workloads**:
- How do you optimize the energy efficiency of your AI and machine
learning lifecycles?
- **Optimize resource usage**:
- How do you ensure your infrastructure footprint dynamically matches
actual workload demand?
- How do you select and maintain the hardware types used for your cloud
workloads?
- What is your strategy for handling non-urgent or compute-intensive
background tasks?
- How do you balance the need for high availability and disaster recovery
with sustainability?
- **Develop energy-efficient software**:
- How do you ensure your backend logic minimizes unnecessary CPU, memory,
and network activity?
- How do you manage the overall efficiency and maintenance of your
codebase for sustainability?
- How do you minimize the data volume and processing load that your
application places on end-user devices?
- How does your user experience (UX) design contribute to energy
efficiency for the end user?
- **Optimize data and storage**:
- What process do you have for managing the environmental footprint of
your data and storage?
- **Continuously measure and improve**:
- How do you analyze your carbon data to prioritize optimization efforts?
- How is sustainability measurement embedded into your organization’s
governance and culture?
- What is your current process for gaining visibility into your
cloud-related carbon emissions?
- What proactive steps do you take to remediate identified carbon
hotspots?
- **Promote a culture of sustainability**:
- How do you connect individual technical decisions to the organization's
mission and hold teams accountable for results?
- How do you ensure your technical and business staff have the specific
skills required to implement sustainability practices?
## Validation checklist
Use the following checklist to evaluate the architecture's alignment with
sustainability recommendations:
- **Cloud sustainability**:
- [ ] The organization embraces a shared responsibility and shared fate
model for sustainability.
- [ ] AI is used as a catalyst for profitability and resilience to
streamline operations, or sustainability is integrated into the design
process to create positive feedback loops.
- [ ] Collaborations with sustainable partners are prioritized and
multi-cloud data portability is leveraged, or internal practices align
with recognized global standards like the Green Software Foundation.
- **Use regions that consume low-carbon energy**:
- [ ] A data-driven policy prioritizes regions with high Carbon-Free
Energy (CFE%) and "Low CO2" indicators, or the Google Cloud Region
Picker is actively used to balance carbon footprint with cost and
latency.
- **Optimize AI and ML workloads**:
- [ ] Algorithmic needs are matched to specialized hardware (TPUs) to
maximize computations per watt, or mathematical techniques like model
compression and PEFT are applied to reduce computational complexity.
- **Optimize resource usage**:
- [ ] Fully managed services that scale to zero when idle are utilized, or
Horizontal Pod Autoscaling (HPA) and Vertical Pod Autoscaling (VPA) are
used in GKE to prevent over-provisioning.
- [ ] A formal process exists to upgrade to the newest machine types for
improved performance-per-watt, or workloads are actively matched to
specialized machine families.
- [ ] Batch jobs are proactively scheduled to run during periods or in
regions with the highest proportion of CFE, or Spot VMs are utilized for
non-critical batch jobs.
- [ ] "Cold DR" or serverless failover is prioritized to ensure secondary
regions remain at zero energy consumption until an event occurs, or
Infrastructure as Code (IaC) is used to rapidly provision a recovery
environment only when needed.
- **Develop energy-efficient software**:
- [ ] Resource-intensive busy loops or constant polling are replaced with
event-driven logic, or algorithms with optimal time complexity and data
structures are prioritized.
- [ ] The "Don't Repeat Yourself" (DRY) principle is adhered to with
regular refactoring, or intelligent caching (e.g., Memorystore) is
implemented with smart eviction policies.
- [ ] The download size of website products is measured and maintained
against a strict budget, or CI/CD pipelines automate the minimization
and compression of HTML, CSS, and JS files.
- [ ] Static sites or Progressive Web Apps (PWAs) are preferred for faster
loading, or DOM manipulation is minimized to reduce device power
consumption.
- **Optimize data and storage**:
- [ ] Object Lifecycle Management is used to automatically move cold data
to Archive storage, or discovery techniques (e.g., Dataplex) are used to
identify and eliminate "dark data".
- **Continuously measure and improve**:
- [ ] Carbon data is analyzed by project, region, and service to identify
gross emitters, or carbon data is joined with Billing data in BigQuery
to correlate cost and environmental impact.
- [ ] A formal GreenOps function defines accountability for carbon
reduction targets, or verified Carbon Footprint data from BigQuery
supports formal ESG disclosures.
- [ ] Applications are instrumented to measure the specific carbon
intensity of software features, or automated exports of Carbon Footprint
data to BigQuery are configured for deep analysis.
- [ ] The unattended project recommender and Active Assist are regularly
used to decommission idle resources, or proactive projects re-architect
hotspots by shifting workloads to low-carbon regions.
- **Promote a culture of sustainability**:
- [ ] Abstract carbon metrics are transformed into tangible progress
indicators in annual reports, or sustainability is treated as a
first-class technical requirement (NFR) tied to KPIs and performance
reviews.
- [ ] Training tailored to specific job roles (e.g., developers on code
efficiency, FinOps on carbon unit economics) is provided, or teams are
formally trained to access and interpret carbon footprint data.