Cloud Devops Expert

Core Services:

• Compute: EC2, Lambda (serverless), ECS/EKS (containers), Fargate

• Storage: S3 (object), EBS (block), EFS (file system)

• Database: RDS (relational), DynamoDB (NoSQL), Aurora (MySQL/PostgreSQL)

• Networking: VPC, ALB/NLB, CloudFront (CDN), Route 53 (DNS)

• Monitoring: CloudWatch (metrics, logs, alarms)

Best Practices:

• Use AWS Organizations for multi-account management

• Implement least privilege with IAM roles and policies

• Enable CloudTrail for audit logging

• Use AWS Config for compliance and resource tracking

• Tag all resources for cost allocation and management

GCP (Google Cloud Platform) Patterns

Core Services:

• Compute: Compute Engine (VMs), Cloud Functions (serverless), GKE (Kubernetes)

• Storage: Cloud Storage (object), Persistent Disk (block)

• Database: Cloud SQL, Cloud Spanner, Firestore

• Networking: VPC, Cloud Load Balancing, Cloud CDN

• Monitoring: Cloud Monitoring, Cloud Logging

Best Practices:

• Use Google Cloud Identity for centralized identity management

• Implement VPC Service Controls for security perimeters

• Enable Cloud Audit Logs for compliance

• Use labels for resource organization and billing

Azure Patterns

Core Services:

• Compute: Virtual Machines, Azure Functions, AKS (Kubernetes), Container Instances

• Storage: Blob Storage, Azure Files, Managed Disks

• Database: Azure SQL, Cosmos DB (NoSQL), PostgreSQL/MySQL

• Networking: Virtual Network, Application Gateway, Front Door (CDN)

• Monitoring: Azure Monitor, Log Analytics

Best Practices:

• Use Azure AD for identity and access management

• Implement Azure Policy for governance

• Enable Azure Security Center for threat protection

• Use resource groups for logical organization

Terraform Best Practices

Project Structure:

terraform/ ├── environments/ │ ├── dev/ │ │ ├── main.tf │ │ ├── variables.tf │ │ └── terraform.tfvars │ ├── staging/ │ └── prod/ ├── modules/ │ ├── vpc/ │ ├── eks/ │ └── rds/ └── global/ └── backend.tf

Code Organization:

• Use modules for reusable infrastructure components

• Separate environments with workspaces or directories

• Store state remotely (S3 + DynamoDB for AWS, GCS for GCP, Azure Blob for Azure)

• Use variables for environment-specific values

• Never commit secrets (use AWS Secrets Manager, HashiCorp Vault, etc.)

Terraform Workflow:

Initialize

terraform init

Plan (review changes)

terraform plan -out=tfplan

Apply (execute changes)

terraform apply tfplan

Destroy (when needed)

terraform destroy

Best Practices:

• Use terraform fmt for consistent formatting

• Use terraform validate to check syntax

• Implement state locking to prevent concurrent modifications

• Use terraform import for existing resources

• Version pin providers: required_version = "~> 1.5"

• Use data sources for referencing existing resources

• Implement depends_on for explicit resource dependencies

Kubernetes Deployment Patterns

Deployment Strategies:

• Rolling Update: Gradual replacement of pods (default)

• Blue/Green: Run two identical environments, switch traffic

• Canary: Gradual traffic shift to new version

• Recreate: Terminate old pods before creating new ones (downtime)

Resource Management:

apiVersion: apps/v1 kind: Deployment metadata: name: myapp spec: replicas: 3 selector: matchLabels: app: myapp template: metadata: labels: app: myapp spec: containers: - name: myapp image: myapp:v1.0.0 resources: requests: memory: '256Mi' cpu: '250m' limits: memory: '512Mi' cpu: '500m' livenessProbe: httpGet: path: /health port: 8080 readinessProbe: httpGet: path: /ready port: 8080

Best Practices:

• Use namespaces for environment/team isolation

• Implement RBAC for access control

• Define resource requests and limits

• Use liveness and readiness probes

• Use ConfigMaps and Secrets for configuration

• Implement Pod Security Policies (PSP) or Pod Security Standards (PSS)

• Use Horizontal Pod Autoscaler (HPA) for auto-scaling

CI/CD Pipeline Patterns

GitHub Actions Example:

name: CI/CD Pipeline

on: push: branches: [main, develop] pull_request: branches: [main]

jobs: test: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - name: Run tests run: npm test

build: needs: test runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - name: Build Docker image run: docker build -t myapp:${{ github.sha }} . - name: Push to registry run: docker push myapp:${{ github.sha }}

deploy: needs: build runs-on: ubuntu-latest if: github.ref == 'refs/heads/main' steps: - name: Deploy to Kubernetes run: kubectl set image deployment/myapp myapp=myapp:${{ github.sha }}

Best Practices:

• Implement automated testing (unit, integration, e2e)

• Use matrix builds for multi-platform testing

• Cache dependencies to speed up builds

• Use secrets management for sensitive data

• Implement deployment gates and approvals for production

• Use semantic versioning for releases

• Implement rollback strategies

Infrastructure as Code (IaC) Principles

Version Control:

• Store all infrastructure code in Git

• Use pull requests for code review

• Implement branch protection rules

• Tag releases for production deployments

Testing:

• Use terraform plan to preview changes

• Implement policy-as-code with Sentinel, OPA, or Checkov

• Use tflint for Terraform linting

• Test modules in isolation

Documentation:

• Document module inputs and outputs

• Maintain README files for each module

• Use terraform-docs to auto-generate documentation

Monitoring and Observability

The Three Pillars:

Metrics (Prometheus + Grafana)

• Use Prometheus for metrics collection

• Define SLIs (Service Level Indicators)

• Set up alerting rules

• Create Grafana dashboards for visualization

Logs (ELK Stack, CloudWatch, Cloud Logging)

• Centralize logs from all services

• Implement structured logging (JSON format)

• Use log aggregation and parsing

• Set up log-based alerts

Traces (Jaeger, Zipkin, X-Ray)

• Implement distributed tracing

• Track request flow across microservices

• Identify performance bottlenecks

• Correlate traces with logs and metrics

Observability Best Practices:

• Define SLOs (Service Level Objectives) and SLAs

• Implement health check endpoints

• Use APM (Application Performance Monitoring) tools

• Set up on-call rotations and runbooks

• Practice incident response procedures

Container Orchestration (Kubernetes)

Helm Charts:

• Use Helm for package management

• Create reusable chart templates

• Use values files for environment-specific configuration

• Version and publish charts to chart repository

Kubernetes Operators:

• Automate operational tasks

• Manage complex stateful applications

• Examples: Prometheus Operator, Postgres Operator

Service Mesh (Istio, Linkerd):

• Implement traffic management (canary, blue/green)

• Enable mutual TLS for service-to-service communication

• Implement circuit breakers and retries

• Observe traffic with distributed tracing

Cost Optimization

AWS Cost Optimization:

• Use Reserved Instances or Savings Plans for predictable workloads

• Implement auto-scaling to match demand

• Use S3 lifecycle policies to transition to cheaper storage classes

• Enable Cost Explorer and set up budgets

• Right-size instances based on usage metrics

Multi-Cloud Cost Management:

• Use tags/labels for cost allocation

• Implement chargeback models for team accountability

• Use spot/preemptible instances for non-critical workloads

• Monitor unused resources (idle VMs, unattached volumes)

Cloudflare Developer Platform

Cloudflare Workers & Pages:

• Edge computing platform for serverless functions

• Deploy at the edge (close to users globally)

• Use Workers KV for edge key-value storage

• Use Durable Objects for stateful applications

Cloudflare Primitives:

• R2: S3-compatible object storage (no egress fees)

• D1: SQLite-based serverless database

• KV: Key-value storage (globally distributed)

• AI: Run AI inference at the edge

• Queues: Message queuing service

• Vectorize: Vector database for embeddings

Configuration (wrangler.toml):

name = "my-worker" main = "src/index.ts" compatibility_date = "2024-01-01"

[[kv_namespaces]] binding = "MY_KV" id = "xxx"

[[r2_buckets]] binding = "MY_BUCKET" bucket_name = "my-bucket"

[[d1_databases]] binding = "DB" database_name = "my-db" database_id = "xxx"

Consolidated Skills

This expert skill consolidates 1 individual skills:

• cloudflare-developer-tools-rule

Related Skills

• docker-compose
• Container orchestration and multi-container application management

Memory Protocol (MANDATORY)

Before starting:

cat .claude/context/memory/learnings.md

After completing: Record any new patterns or exceptions discovered.

ASSUME INTERRUPTION: Your context may reset. If it's not in memory, it didn't happen.