blockmine 1.23.4 → 1.25.0

package/.claude/skills/cloud-engineering/resources/multi-cloud-strategies.md

@@ -1,670 +0,0 @@
-# Multi-Cloud Strategies
-
-Guide to designing and implementing multi-cloud architectures, including service abstraction, workload distribution, vendor lock-in mitigation, and operational strategies across AWS, Azure, and GCP.
-
-## Table of Contents
-
-- [Multi-Cloud vs Single Cloud](#multi-cloud-vs-single-cloud)
-- [Multi-Cloud Patterns](#multi-cloud-patterns)
-- [Abstraction Layers](#abstraction-layers)
-- [Service Selection](#service-selection)
-- [Networking and Connectivity](#networking-and-connectivity)
-- [Data Management](#data-management)
-- [Security and Compliance](#security-and-compliance)
-- [Operational Considerations](#operational-considerations)
-- [Trade-Offs](#trade-offs)
-- [Best Practices](#best-practices)
-
-## Multi-Cloud vs Single Cloud
-
-### When to Choose Multi-Cloud
-
-**Valid Reasons:**
-```
-✅ Regulatory requirements (data residency)
-✅ Avoid vendor lock-in for critical workloads
-✅ Leverage best-of-breed services
-✅ Geographic distribution requirements
-✅ Merger/acquisition integration
-✅ Disaster recovery across cloud providers
-✅ Specific cloud expertise in different teams
-```
-
-**Invalid Reasons:**
-```
-❌ "Just in case" without clear business need
-❌ Complexity for complexity's sake
-❌ Attempting to be "cloud-agnostic" everywhere
-❌ Negotiation leverage alone
-❌ Developer preference without business case
-```
-
-### Cost-Benefit Analysis
-
-**Multi-Cloud Benefits:**
-- Risk mitigation (provider outages)
-- Negotiation leverage
-- Best-of-breed services
-- Innovation access
-- Geographic reach
-
-**Multi-Cloud Costs:**
-- Operational complexity (2-3x increase)
-- Training and expertise required
-- Tooling and process duplication
-- Network egress costs
-- Reduced economies of scale
-
-## Multi-Cloud Patterns
-
-### Pattern 1: Cloud-Agnostic Application Layer
-
-```
-┌─────────────────────────────────────────────┐
-│       Application Code (Cloud-Agnostic)     │
-│         (Containers, Kubernetes)            │
-└─────────────────┬───────────────────────────┘
-                  │
-┌─────────────────▼───────────────────────────┐
-│         Abstraction Layer                   │
-│  (Terraform, Pulumi, Crossplane)           │
-└─────────────────┬───────────────────────────┘
-                  │
-      ┌───────────┼───────────┐
-      │           │           │
-┌─────▼────┐ ┌────▼────┐ ┌────▼────┐
-│   AWS    │ │  Azure  │ │   GCP   │
-└──────────┘ └─────────┘ └─────────┘
-```
-
-**Implementation:**
-```yaml
-# Kubernetes deployment - runs anywhere
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: api-service
-spec:
-  replicas: 3
-  selector:
-    matchLabels:
-      app: api
-  template:
-    metadata:
-      labels:
-        app: api
-    spec:
-      containers:
-      - name: api
-        image: registry.example.com/api:v1.0.0
-        ports:
-        - containerPort: 8080
-        env:
-        - name: DATABASE_URL
-          valueFrom:
-            secretKeyRef:
-              name: db-credentials
-              key: url
-        resources:
-          requests:
-            memory: "256Mi"
-            cpu: "250m"
-          limits:
-            memory: "512Mi"
-            cpu: "500m"
-```
-
-### Pattern 2: Workload Distribution by Cloud Strength
-
-```
-┌──────────────────────────────────────────────┐
-│              Global Load Balancer            │
-│         (Cloudflare, F5, NS1)               │
-└────────┬─────────────────────┬───────────────┘
-         │                     │
-         │                     │
-    ┌────▼────┐           ┌────▼────┐
-    │   AWS   │           │   GCP   │
-    │         │           │         │
-    │  API &  │           │  Data   │
-    │ Compute │           │ & ML    │
-    └─────────┘           └─────────┘
-```
-
-**Example Distribution:**
-- AWS: General compute, mature services, breadth
-- GCP: Data analytics, ML/AI, BigQuery
-- Azure: Microsoft ecosystem, AD integration
-
-### Pattern 3: Primary + Disaster Recovery
-
-```
-┌────────────────┐           ┌────────────────┐
-│   AWS (Primary)│           │ Azure (DR)     │
-│                │           │                │
-│  Active-Active │◄─────────►│  Standby       │
-│  Replication   │           │  Ready         │
-└────────────────┘           └────────────────┘
-```
-
-### Pattern 4: Hybrid Multi-Cloud
-
-```
-┌────────────────────────────────────────┐
-│         On-Premises Data Center        │
-│      (Legacy Systems, Core Data)       │
-└────────────┬───────────────────────────┘
-             │
-    ┌────────┼────────┐
-    │        │        │
-┌───▼───┐ ┌──▼──┐ ┌──▼──┐
-│  AWS  │ │Azure│ │ GCP │
-│Compute│ │ AD  │ │ ML  │
-└───────┘ └─────┘ └─────┘
-```
-
-## Abstraction Layers
-
-### Infrastructure as Code - Terraform
-
-**Multi-Cloud Terraform Pattern:**
-```hcl
-# Multi-provider configuration
-terraform {
-  required_providers {
-    aws = {
-      source  = "hashicorp/aws"
-      version = "~> 5.0"
-    }
-    azurerm = {
-      source  = "hashicorp/azurerm"
-      version = "~> 3.0"
-    }
-    google = {
-      source  = "hashicorp/google"
-      version = "~> 5.0"
-    }
-  }
-}
-
-# Provider configurations
-provider "aws" {
-  region = var.aws_region
-}
-
-provider "azurerm" {
-  features {}
-}
-
-provider "google" {
-  project = var.gcp_project
-  region  = var.gcp_region
-}
-
-# Abstracted module for VM creation
-module "compute_aws" {
-  source = "./modules/compute"
-
-  provider_type   = "aws"
-  instance_type   = "t3.medium"
-  instance_count  = 3
-  vpc_id          = module.network_aws.vpc_id
-  subnet_ids      = module.network_aws.private_subnet_ids
-}
-
-module "compute_gcp" {
-  source = "./modules/compute"
-
-  provider_type   = "gcp"
-  instance_type   = "e2-medium"
-  instance_count  = 3
-  network_id      = module.network_gcp.network_id
-  subnet_ids      = module.network_gcp.subnet_ids
-}
-```
-
-### Kubernetes - Cloud-Agnostic Orchestration
-
-**Example: Multi-Cluster Service Mesh:**
-```yaml
-# Istio multi-cluster configuration
-apiVersion: install.istio.io/v1alpha1
-kind: IstioOperator
-metadata:
-  name: istio-multi-cloud
-spec:
-  profile: default
-  meshConfig:
-    # Enable multi-cluster
-    serviceSettings:
-      - settings:
-          clusterLocal: false
-        hosts:
-          - "*.global"
-
-  values:
-    global:
-      meshID: multi-cloud-mesh
-      multiCluster:
-        clusterName: aws-cluster
-      network: aws-network
-
-      # Trust domain for cross-cloud
-      trustDomain: multi-cloud.example.com
-
----
-# Service entry for GCP cluster
-apiVersion: networking.istio.io/v1beta1
-kind: ServiceEntry
-metadata:
-  name: api-gcp
-spec:
-  hosts:
-  - api.gcp.global
-  location: MESH_INTERNAL
-  ports:
-  - number: 8080
-    name: http
-    protocol: HTTP
-  resolution: DNS
-  endpoints:
-  - address: api.gcp-cluster.svc.cluster.local
-```
-
-### Application Layer Abstraction
-
-**Database Abstraction Example:**
-```go
-// Cloud-agnostic storage interface
-type StorageService interface {
-    Save(ctx context.Context, bucket string, key string, data []byte) error
-    Get(ctx context.Context, bucket string, key string) ([]byte, error)
-    Delete(ctx context.Context, bucket string, key string) error
-    List(ctx context.Context, bucket string, prefix string) ([]string, error)
-}
-
-// AWS S3 implementation
-type S3Storage struct {
-    client *s3.Client
-}
-
-func (s *S3Storage) Save(ctx context.Context, bucket string, key string, data []byte) error {
-    _, err := s.client.PutObject(ctx, &s3.PutObjectInput{
-        Bucket: aws.String(bucket),
-        Key:    aws.String(key),
-        Body:   bytes.NewReader(data),
-    })
-    return err
-}
-
-// GCP Cloud Storage implementation
-type GCSStorage struct {
-    client *storage.Client
-}
-
-func (g *GCSStorage) Save(ctx context.Context, bucket string, key string, data []byte) error {
-    wc := g.client.Bucket(bucket).Object(key).NewWriter(ctx)
-    defer wc.Close()
-    _, err := wc.Write(data)
-    return err
-}
-
-// Azure Blob Storage implementation
-type AzureBlobStorage struct {
-    client *azblob.Client
-}
-
-func (a *AzureBlobStorage) Save(ctx context.Context, bucket string, key string, data []byte) error {
-    _, err := a.client.UploadBuffer(ctx, bucket, key, data, &azblob.UploadBufferOptions{})
-    return err
-}
-
-// Factory pattern for cloud selection
-func NewStorageService(provider string) (StorageService, error) {
-    switch provider {
-    case "aws":
-        return newS3Storage()
-    case "gcp":
-        return newGCSStorage()
-    case "azure":
-        return newAzureBlobStorage()
-    default:
-        return nil, fmt.Errorf("unknown provider: %s", provider)
-    }
-}
-```
-
-## Service Selection
-
-### Service Mapping Across Clouds
-
-```yaml
-# Equivalent services
-Compute:
-  VM:
-    AWS: EC2
-    Azure: Virtual Machines
-    GCP: Compute Engine
-  Container:
-    AWS: ECS/EKS
-    Azure: ACI/AKS
-    GCP: Cloud Run/GKE
-  Serverless:
-    AWS: Lambda
-    Azure: Functions
-    GCP: Cloud Functions
-
-Storage:
-  Object:
-    AWS: S3
-    Azure: Blob Storage
-    GCP: Cloud Storage
-  Block:
-    AWS: EBS
-    Azure: Managed Disks
-    GCP: Persistent Disk
-
-Database:
-  SQL:
-    AWS: RDS
-    Azure: SQL Database
-    GCP: Cloud SQL
-  NoSQL:
-    AWS: DynamoDB
-    Azure: Cosmos DB
-    GCP: Firestore
-
-Networking:
-  VPC:
-    AWS: VPC
-    Azure: Virtual Network
-    GCP: VPC
-  Load Balancer:
-    AWS: ALB/NLB
-    Azure: Load Balancer
-    GCP: Cloud Load Balancing
-```
-
-### Decision Matrix for Service Selection
-
-```
-Criteria                AWS         Azure       GCP
-────────────────────────────────────────────────────
-Breadth of services     ★★★★★       ★★★★☆       ★★★☆☆
-Enterprise features     ★★★★☆       ★★★★★       ★★★☆☆
-Data/Analytics          ★★★★☆       ★★★☆☆       ★★★★★
-AI/ML capabilities      ★★★★☆       ★★★★☆       ★★★★★
-Microsoft integration   ★★☆☆☆       ★★★★★       ★★☆☆☆
-Cost competitiveness    ★★★☆☆       ★★★☆☆       ★★★★☆
-Global presence         ★★★★★       ★★★★☆       ★★★★☆
-Developer experience    ★★★★☆       ★★★☆☆       ★★★★☆
-```
-
-## Networking and Connectivity
-
-### Cross-Cloud Connectivity Options
-
-**1. VPN Connections:**
-```
-AWS VPC ←──VPN──→ Azure VNet ←──VPN──→ GCP VPC
-
-Pros: Encrypted, relatively simple
-Cons: Lower bandwidth, higher latency
-Cost: Low to moderate
-```
-
-**2. Direct Connect / ExpressRoute / Cloud Interconnect:**
-```
-AWS Direct Connect ←──→ On-Prem ←──→ Azure ExpressRoute
-                           ↕
-                    GCP Cloud Interconnect
-
-Pros: High bandwidth, low latency, dedicated
-Cons: Complex setup, higher cost
-Cost: High
-```
-
-**3. Third-Party SD-WAN:**
-```
-┌─────────────────────────────────────┐
-│        SD-WAN Controller            │
-│    (Cisco, VMware, Palo Alto)       │
-└──────┬────────────┬─────────────────┘
-       │            │
-   ┌───▼──┐    ┌────▼───┐    ┌───▼───┐
-   │ AWS  │    │ Azure  │    │  GCP  │
-   └──────┘    └────────┘    └───────┘
-```
-
-**4. Multi-Cloud Transit Hub:**
-```hcl
-# Example: Aviatrix multi-cloud network
-resource "aviatrix_transit_gateway" "aws" {
-  cloud_type   = 1  # AWS
-  account_name = "aws-account"
-  gw_name      = "aws-transit-gw"
-  vpc_id       = aws_vpc.main.id
-  vpc_reg      = var.aws_region
-  gw_size      = "t3.medium"
-  subnet       = aws_subnet.transit.cidr_block
-}
-
-resource "aviatrix_transit_gateway" "azure" {
-  cloud_type   = 8  # Azure
-  account_name = "azure-account"
-  gw_name      = "azure-transit-gw"
-  vpc_id       = azurerm_virtual_network.main.name
-  vpc_reg      = var.azure_region
-  gw_size      = "Standard_B2s"
-  subnet       = azurerm_subnet.transit.address_prefix
-}
-
-# Peering between transit gateways
-resource "aviatrix_transit_gateway_peering" "aws_azure" {
-  transit_gateway_name1 = aviatrix_transit_gateway.aws.gw_name
-  transit_gateway_name2 = aviatrix_transit_gateway.azure.gw_name
-}
-```
-
-## Data Management
-
-### Cross-Cloud Data Replication
-
-**Pattern: Event-Driven Replication:**
-```
-AWS S3 ──event──→ Lambda ──API──→ GCP Cloud Storage
-                    │
-                    └────────────→ Azure Blob Storage
-
-AWS DynamoDB ──stream──→ Lambda ──sync──→ Azure Cosmos DB
-```
-
-**Implementation Example:**
-```python
-# Lambda function for cross-cloud replication
-import boto3
-from google.cloud import storage as gcs_storage
-from azure.storage.blob import BlobServiceClient
-
-s3 = boto3.client('s3')
-gcs = gcs_storage.Client()
-azure_blob = BlobServiceClient.from_connection_string(os.environ['AZURE_CONNECTION'])
-
-def lambda_handler(event, context):
-    for record in event['Records']:
-        bucket = record['s3']['bucket']['name']
-        key = record['s3']['object']['key']
-
-        # Get object from S3
-        obj = s3.get_object(Bucket=bucket, Key=key)
-        data = obj['Body'].read()
-
-        # Replicate to GCP
-        gcs_bucket = gcs.bucket('backup-bucket-gcp')
-        blob = gcs_bucket.blob(key)
-        blob.upload_from_string(data)
-
-        # Replicate to Azure
-        blob_client = azure_blob.get_blob_client(
-            container='backup-container',
-            blob=key
-        )
-        blob_client.upload_blob(data, overwrite=True)
-
-    return {'statusCode': 200}
-```
-
-## Security and Compliance
-
-### Unified Identity Management
-
-**Option 1: Federated Identity (Recommended):**
-```
-     ┌──────────────────┐
-     │  Identity Provider│
-     │  (Okta, Auth0)   │
-     └────────┬──────────┘
-              │ SAML/OIDC
-     ┌────────┼────────┐
-     │        │        │
-┌────▼───┐ ┌──▼──┐ ┌──▼──┐
-│AWS IAM │ │Azure│ │ GCP │
-│  Role  │ │ AD  │ │ IAM │
-└────────┘ └─────┘ └─────┘
-```
-
-**Option 2: Cross-Account Roles:**
-```hcl
-# AWS IAM role for cross-cloud access
-resource "aws_iam_role" "gcp_access" {
-  name = "gcp-service-account-access"
-
-  assume_role_policy = jsonencode({
-    Version = "2012-10-17"
-    Statement = [{
-      Effect = "Allow"
-      Principal = {
-        Federated = "accounts.google.com"
-      }
-      Action = "sts:AssumeRoleWithWebIdentity"
-      Condition = {
-        StringEquals = {
-          "accounts.google.com:sub" = var.gcp_service_account_id
-        }
-      }
-    }]
-  })
-}
-```
-
-## Operational Considerations
-
-### Monitoring and Observability
-
-**Multi-Cloud Monitoring Stack:**
-```yaml
-# Centralized monitoring with Prometheus + Grafana
-Prometheus:
-  - Federation from each cloud
-  - Cloud-specific exporters:
-    * AWS: CloudWatch Exporter
-    * Azure: Azure Monitor Exporter
-    * GCP: Stackdriver Exporter
-
-Grafana:
-  - Unified dashboards
-  - Cross-cloud correlation
-  - Alert routing
-
-Logs:
-  - Ship to central: Elasticsearch, Splunk, Datadog
-  - Cloud-native: CloudWatch, Monitor, Cloud Logging
-  - Open source: Loki, FluentD
-```
-
-### Cost Management
-
-**Multi-Cloud Cost Tools:**
-- CloudHealth (VMware)
-- Cloudability (Apptio)
-- Kubecost (Kubernetes-specific)
-- Custom FinOps dashboards
-
-## Trade-Offs
-
-### Multi-Cloud Trade-Off Matrix
-
-```
-Aspect              Single Cloud    Multi-Cloud
-─────────────────────────────────────────────────
-Complexity          Low             High
-Operational Cost    Lower           Higher
-Skill Requirements  Focused         Broad
-Vendor Lock-in      Higher          Lower
-Innovation Speed    Faster          Slower
-Tooling             Native          Abstracted
-Data Transfer Cost  Low             High
-Reliability         High            Very High
-Negotiation Power   Lower           Higher
-```
-
-## Best Practices
-
-### 1. Start with Single Cloud
-Build expertise before expanding to multi-cloud.
-
-### 2. Use Kubernetes for Portability
-Containerize applications for cloud-agnostic deployment.
-
-### 3. Abstract at the Right Level
-- Don't abstract everything (diminishing returns)
-- Focus on business-critical portability
-- Use cloud-native services where appropriate
-
-### 4. Centralized Management
-- Single pane of glass for monitoring
-- Unified IAM/SSO
-- Centralized logging and audit
-
-### 5. Standardize Tooling
-- Same IaC tool (Terraform/Pulumi)
-- Same CI/CD platform
-- Same monitoring stack
-
-### 6. Network Design
-- Plan IP addressing carefully
-- Minimize cross-cloud data transfer
-- Use CDN for content delivery
-
-### 7. Cost Optimization
-- Track egress costs
-- Use reserved capacity appropriately
-- Implement FinOps practices
-
-### 8. Security Posture
-- Consistent security policies
-- Unified secret management
-- Regular security audits
-
-### 9. Disaster Recovery
-- Define RPO/RTO
-- Test failover regularly
-- Document runbooks
-
-### 10. Team Organization
-- Cloud Centers of Excellence
-- Cross-training
-- Clear ownership
-
-## Anti-Patterns
-
-❌ **Multi-cloud for the sake of it** without business justification
-❌ **Perfect cloud abstraction** trying to hide all cloud differences
-❌ **Ignoring cloud-native services** and building everything custom
-❌ **No unified monitoring** leading to operational blindness
-❌ **Underestimating complexity** and operational overhead
-❌ **Data replication everywhere** causing excessive egress costs
-❌ **Manual deployments** across multiple clouds
-❌ **No standardization** different tools for each cloud
-❌ **Split teams by cloud** creating silos
-❌ **Neglecting network design** causing performance issues