ai-qakit 1.0.0

package/templates/.claude/skills/infra-engineer/references/docker-compose.md

@@ -0,0 +1,292 @@
+# Docker Compose
+
+Multi-container application orchestration.
+
+## Basic Structure
+
+```yaml
+version: '3.8'
+
+services:
+  web:
+    build: .
+    ports:
+      - "3000:3000"
+    environment:
+      - NODE_ENV=production
+      - DATABASE_URL=postgresql://user:pass@db:5432/app
+    depends_on:
+      - db
+      - redis
+    volumes:
+      - ./src:/app/src
+    networks:
+      - app-network
+    restart: unless-stopped
+
+  db:
+    image: postgres:15-alpine
+    environment:
+      POSTGRES_USER: user
+      POSTGRES_PASSWORD: pass
+      POSTGRES_DB: app
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    networks:
+      - app-network
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U user"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+
+  redis:
+    image: redis:7-alpine
+    networks:
+      - app-network
+    volumes:
+      - redis_data:/data
+
+volumes:
+  postgres_data:
+  redis_data:
+
+networks:
+  app-network:
+    driver: bridge
+```
+
+## Commands
+
+```bash
+# Start services
+docker compose up
+docker compose up -d
+
+# Build images before starting
+docker compose up --build
+
+# Scale service
+docker compose up -d --scale web=3
+
+# Stop services
+docker compose down
+
+# Stop and remove volumes
+docker compose down --volumes
+
+# Logs
+docker compose logs
+docker compose logs -f web
+
+# Execute command
+docker compose exec web sh
+docker compose exec db psql -U user -d app
+
+# List services
+docker compose ps
+
+# Restart service
+docker compose restart web
+
+# Pull images
+docker compose pull
+
+# Validate
+docker compose config
+```
+
+## Environment-Specific Configs
+
+**compose.yml (base):**
+```yaml
+services:
+  web:
+    build: .
+    ports:
+      - "3000:3000"
+```
+
+**compose.override.yml (dev, auto-loaded):**
+```yaml
+services:
+  web:
+    volumes:
+      - ./src:/app/src  # Live reload
+    environment:
+      - NODE_ENV=development
+      - DEBUG=true
+    command: npm run dev
+```
+
+**compose.prod.yml (production):**
+```yaml
+services:
+  web:
+    image: registry.example.com/myapp:1.0
+    restart: always
+    environment:
+      - NODE_ENV=production
+    deploy:
+      replicas: 3
+      resources:
+        limits:
+          cpus: '0.5'
+          memory: 512M
+```
+
+**Usage:**
+```bash
+# Development (uses compose.yml + compose.override.yml)
+docker compose up
+
+# Production
+docker compose -f compose.yml -f compose.prod.yml up -d
+```
+
+## Health Checks
+
+```yaml
+services:
+  web:
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
+      interval: 30s
+      timeout: 3s
+      start_period: 40s
+      retries: 3
+```
+
+## Resource Limits
+
+```yaml
+services:
+  web:
+    deploy:
+      resources:
+        limits:
+          cpus: '0.5'
+          memory: 512M
+        reservations:
+          cpus: '0.25'
+          memory: 256M
+```
+
+## Logging
+
+```yaml
+services:
+  web:
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "10m"
+        max-file: "3"
+```
+
+## Environment Variables
+
+**Using .env file:**
+```bash
+# .env
+DATABASE_URL=postgresql://user:pass@db:5432/app
+API_KEY=secret
+```
+
+```yaml
+services:
+  web:
+    env_file:
+      - .env
+```
+
+## Networking
+
+Services on same network communicate via service name:
+
+```yaml
+services:
+  web:
+    depends_on:
+      - db
+    environment:
+      # Use service name as hostname
+      - DATABASE_URL=postgresql://user:pass@db:5432/app
+```
+
+## Volume Backup/Restore
+
+```bash
+# Backup
+docker compose run --rm -v app_data:/data -v $(pwd):/backup \
+  alpine tar czf /backup/backup.tar.gz /data
+
+# Restore
+docker compose run --rm -v app_data:/data -v $(pwd):/backup \
+  alpine tar xzf /backup/backup.tar.gz -C /data
+```
+
+## Common Stacks
+
+### Web + Database + Cache
+```yaml
+services:
+  web:
+    build: .
+    depends_on:
+      - db
+      - redis
+  db:
+    image: postgres:15-alpine
+  redis:
+    image: redis:7-alpine
+```
+
+### Microservices
+```yaml
+services:
+  api-gateway:
+    build: ./gateway
+  user-service:
+    build: ./services/users
+  order-service:
+    build: ./services/orders
+  rabbitmq:
+    image: rabbitmq:3-management
+```
+
+## Best Practices
+
+- Use named volumes for data persistence
+- Implement health checks for all services
+- Set restart policies for production
+- Use environment-specific compose files
+- Configure resource limits
+- Enable logging with size limits
+- Use depends_on for service ordering
+- Network isolation with custom networks
+
+## Troubleshooting
+
+```bash
+# View service logs
+docker compose logs -f service-name
+
+# Check service status
+docker compose ps
+
+# Restart specific service
+docker compose restart service-name
+
+# Rebuild service
+docker compose up --build service-name
+
+# Remove everything
+docker compose down --volumes --rmi all
+```
+
+## Resources
+
+- Docs: https://docs.docker.com/compose/
+- Compose Specification: https://docs.docker.com/compose/compose-file/
+- Best Practices: https://docs.docker.com/compose/production/

package/templates/.claude/skills/infra-engineer/references/finops-basics.md

@@ -0,0 +1,278 @@
+# FinOps Basics
+
+Financial Operations (FinOps) - cultural practice of bringing financial accountability to cloud spending through collaboration between engineering, finance, and business teams.
+
+## FinOps Principles
+
+### Core Values
+1. **Teams collaborate**: Cross-functional accountability for cloud spend
+2. **Everyone owns usage**: Engineers make cost-conscious decisions
+3. **Centralized team**: FinOps team enables and drives best practices
+4. **Reports accessible**: Real-time visibility into cloud costs
+5. **Decisions driven by business value**: Cost vs. performance trade-offs
+6. **Take advantage of variable cost**: Leverage cloud pricing models
+
+## FinOps Lifecycle
+
+### 1. Inform Phase
+**Goal**: Understand current cloud spending
+
+**Actions:**
+- Enable cost allocation tags
+- Implement showback/chargeback
+- Create cost dashboards
+- Analyze spending trends
+- Benchmark against industry
+
+**Tools:**
+- AWS Cost Explorer
+- Azure Cost Management
+- GCP Cost Management
+- CloudHealth
+- Datadog Cloud Cost Management
+
+### 2. Optimize Phase
+**Goal**: Reduce cloud spend while maintaining performance
+
+**Actions:**
+- Rightsize resources (downsize over-provisioned)
+- Purchase reserved capacity
+- Use spot/preemptible instances
+- Implement auto-scaling
+- Clean up unused resources
+- Optimize storage tiers
+
+### 3. Operate Phase
+**Goal**: Continuously monitor and improve
+
+**Actions:**
+- Set budget alerts
+- Track KPIs (cost per customer, cost per transaction)
+- Regular cost reviews
+- Enforce governance policies
+- Celebrate wins, share learnings
+
+## Cost Optimization Strategies
+
+### 1. Compute Optimization
+
+**Rightsizing**
+```bash
+# AWS: Analyze CloudWatch metrics
+aws cloudwatch get-metric-statistics \
+  --namespace AWS/EC2 \
+  --metric-name CPUUtilization \
+  --dimensions Name=InstanceId,Value=i-1234567890 \
+  --start-time 2024-01-01T00:00:00Z \
+  --end-time 2024-01-31T23:59:59Z \
+  --period 3600 \
+  --statistics Average
+
+# Recommendation: If avg CPU < 20%, downsize instance type
+```
+
+**Reserved Instances (AWS/Azure/GCP)**
+- **Commitment**: 1 or 3 years
+- **Discount**: Up to 72% vs on-demand
+- **Best For**: Steady-state, predictable workloads
+- **Types**: Standard (fixed instance), Convertible (changeable)
+
+**Savings Plans (AWS)**
+- **Commitment**: $X/hour for 1 or 3 years
+- **Discount**: Up to 72%
+- **Flexibility**: Applies across instance family, size, region, OS
+
+**Spot/Preemptible Instances**
+- **Discount**: Up to 90% vs on-demand
+- **Risk**: Can be interrupted with short notice
+- **Best For**: Fault-tolerant, flexible workloads (batch processing, CI/CD)
+
+### 2. Storage Optimization
+
+**S3 Lifecycle Policies (AWS)**
+```yaml
+Transition objects to cheaper tiers:
+- Day 0-30: S3 Standard ($0.023/GB)
+- Day 30-90: S3 Intelligent-Tiering (auto-optimization)
+- Day 90+: Glacier Flexible Retrieval ($0.0036/GB)
+- Delete after 365 days
+```
+
+**Storage Cleanup**
+```bash
+# Find old EBS snapshots (AWS)
+aws ec2 describe-snapshots --owner-ids self \
+  --query 'Snapshots[?StartTime<=`2023-01-01`].[SnapshotId,StartTime,VolumeSize]'
+
+# Delete unattached volumes
+aws ec2 describe-volumes --filters Name=status,Values=available
+```
+
+### 3. Auto-Scaling
+
+**Horizontal Pod Autoscaler (Kubernetes)**
+```yaml
+apiVersion: autoscaling/v2
+kind: HorizontalPodAutoscaler
+metadata:
+  name: app-hpa
+spec:
+  scaleTargetRef:
+    apiVersion: apps/v1
+    kind: Deployment
+    name: app
+  minReplicas: 2
+  maxReplicas: 10
+  metrics:
+  - type: Resource
+    resource:
+      name: cpu
+      target:
+        type: Utilization
+        averageUtilization: 70
+```
+
+**Time-Based Scaling**
+```bash
+# Scale down dev environment at night
+# AWS Auto Scaling scheduled action
+aws autoscaling put-scheduled-update-group-action \
+  --auto-scaling-group-name dev-asg \
+  --scheduled-action-name scale-down-evening \
+  --recurrence "0 18 * * *" \
+  --min-size 0 --max-size 0 --desired-capacity 0
+```
+
+### 4. Container Cost Optimization
+
+**Kubernetes Resource Requests/Limits**
+```yaml
+# Set appropriate requests (guaranteed) and limits (max)
+resources:
+  requests:
+    memory: "256Mi"
+    cpu: "250m"
+  limits:
+    memory: "512Mi"
+    cpu: "500m"
+```
+
+**Cluster Autoscaler**
+- Automatically adjusts node count based on pod resource requests
+- Removes underutilized nodes
+- AWS: Cluster Autoscaler, Karpenter
+- GCP: GKE Autopilot
+
+**Kubecost**
+- Real-time cost visibility for Kubernetes
+- Cost allocation by namespace, deployment, pod
+- Recommendations for rightsizing and efficiency
+
+## Tagging Strategy
+
+### Mandatory Tags
+```yaml
+Cost Center: finance, engineering, marketing
+Environment: dev, staging, prod
+Project: project-alpha, project-beta
+Owner: team-name or email
+Expiration: 2024-12-31 (for temporary resources)
+```
+
+### AWS Tag Enforcement (IAM Policy)
+```json
+{
+  "Version": "2012-10-17",
+  "Statement": [{
+    "Effect": "Deny",
+    "Action": "ec2:RunInstances",
+    "Resource": "arn:aws:ec2:*:*:instance/*",
+    "Condition": {
+      "StringNotLike": {
+        "aws:RequestTag/CostCenter": "*"
+      }
+    }
+  }]
+}
+```
+
+## Budget and Alerts
+
+### AWS Budgets
+```bash
+# Create budget with alert
+aws budgets create-budget \
+  --account-id 123456789012 \
+  --budget file://budget.json \
+  --notifications-with-subscribers file://notifications.json
+```
+
+### Azure Budget Alert
+```bash
+az consumption budget create \
+  --budget-name monthly-budget \
+  --amount 10000 \
+  --time-grain Monthly \
+  --resource-group myResourceGroup
+```
+
+### GCP Budget Alert
+```bash
+gcloud billing budgets create \
+  --billing-account=BILLING_ACCOUNT_ID \
+  --display-name="Monthly Budget" \
+  --budget-amount=10000 \
+  --threshold-rule=percent=80 \
+  --threshold-rule=percent=100
+```
+
+## FinOps Metrics (KPIs)
+
+### Unit Economics
+- **Cost per User**: Total cloud cost / Active users
+- **Cost per Transaction**: Total cloud cost / Transactions
+- **Cost per Environment**: Dev vs staging vs production spend
+
+### Efficiency Metrics
+- **Coverage**: % of compute covered by RI/savings plans
+- **Utilization**: % of purchased RI/savings plans used
+- **Waste**: Idle resources, unattached volumes, old snapshots
+- **Rightsizing Opportunities**: Over-provisioned resources
+
+### Financial Metrics
+- **Month-over-Month Growth**: Spending trend
+- **Budget Variance**: Actual vs forecasted spend
+- **Cost Avoidance**: Savings from optimization initiatives
+
+## FinOps Tools
+
+### Native Cloud Tools
+- **AWS**: Cost Explorer, Budgets, Compute Optimizer, Trusted Advisor
+- **Azure**: Cost Management + Billing, Advisor
+- **GCP**: Cost Management, Recommender
+
+### Third-Party Tools
+- **CloudHealth**: Multi-cloud cost management
+- **Kubecost**: Kubernetes cost monitoring
+- **Infracost**: Cost estimation for Terraform
+- **Spot.io**: Automated infrastructure optimization
+- **Datadog Cloud Cost**: Integrated monitoring and cost
+
+## Best Practices
+
+1. **Tag Everything**: Consistent tagging for cost allocation
+2. **Regular Reviews**: Weekly/monthly cost reviews with teams
+3. **Forecast Proactively**: Predict spending based on growth
+4. **Educate Teams**: FinOps training for engineers
+5. **Automate Cleanup**: Scripts to delete orphaned resources
+6. **Right Commitment Level**: Balance flexibility vs savings
+7. **Measure Unit Costs**: Track cost per business metric
+8. **Celebrate Wins**: Recognize teams for cost savings
+
+## Resources
+
+- FinOps Foundation: https://www.finops.org
+- AWS Cost Optimization: https://aws.amazon.com/pricing/cost-optimization
+- Azure FinOps: https://learn.microsoft.com/azure/cost-management-billing
+- GCP Cost Optimization: https://cloud.google.com/cost-management
+- Kubecost: https://www.kubecost.com