Internet
    │
    ▼
Cloudflare (DNS + CDN + WAF)
    │
    ├── VPS Principal (cómputo primario)
    │       └── App principal
    │       └── Base de datos
    │
    ├── VPS Secundario / Cloud (failover)
    │       └── Réplica de la app
    │
    └── Almacenamiento objeto
            ├── AWS S3 (backups)
            └── Backblaze B2 (backups secundarios)

# Verificar la conectividad entre nodos de diferentes proveedores
# (Instalar herramientas de diagnóstico en cada nodo)
sudo apt-get install -y mtr traceroute iperf3

# Medir la latencia entre el VPS y AWS
mtr --report --report-cycles 20 ec2.amazonaws.com

# Medir el ancho de banda entre nodos (servidor)
iperf3 -s

# Medir el ancho de banda entre nodos (cliente)
iperf3 -c IP_DEL_SERVIDOR

# Crear health check via API de Cloudflare
curl -X POST "https://api.cloudflare.com/client/v4/user/load_balancing/pools" \
  -H "Authorization: Bearer TU_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "pool-servidores",
    "origins": [
      {
        "name": "vps-principal",
        "address": "1.2.3.4",
        "enabled": true,
        "weight": 1
      },
      {
        "name": "vps-secundario",
        "address": "5.6.7.8",
        "enabled": true,
        "weight": 1
      }
    ],
    "monitor": {
      "type": "http",
      "path": "/health",
      "interval": 30,
      "retries": 2,
      "timeout": 5
    },
    "minimum_origins": 1
  }'

#!/bin/bash
# Script de failover DNS automático usando la API de Cloudflare
# Guardar en: /usr/local/bin/failover-dns.sh

CF_TOKEN="tu_token_cloudflare"
ZONE_ID="tu_zone_id"
RECORD_ID="id_del_registro_a"
IP_PRINCIPAL="1.2.3.4"
IP_SECUNDARIO="5.6.7.8"
URL_HEALTH="http://${IP_PRINCIPAL}/health"

# Función para obtener la IP actual del registro DNS
obtener_ip_actual() {
  curl -s -X GET \
    "https://api.cloudflare.com/client/v4/zones/${ZONE_ID}/dns_records/${RECORD_ID}" \
    -H "Authorization: Bearer ${CF_TOKEN}" | \
    python3 -c "import sys, json; print(json.load(sys.stdin)['result']['content'])"
}

# Función para actualizar el registro DNS
actualizar_dns() {
  local nueva_ip=$1
  curl -s -X PATCH \
    "https://api.cloudflare.com/client/v4/zones/${ZONE_ID}/dns_records/${RECORD_ID}" \
    -H "Authorization: Bearer ${CF_TOKEN}" \
    -H "Content-Type: application/json" \
    -d "{\"content\":\"${nueva_ip}\"}" > /dev/null
  echo "[$(date)] DNS actualizado a: ${nueva_ip}"
}

# Verificar el servidor principal
if curl -s --max-time 10 --fail "$URL_HEALTH" > /dev/null 2>&1; then
  # El servidor principal responde
  IP_ACTUAL=$(obtener_ip_actual)
  if [ "$IP_ACTUAL" != "$IP_PRINCIPAL" ]; then
    echo "[$(date)] Servidor principal recuperado. Reactivando..."
    actualizar_dns "$IP_PRINCIPAL"
  fi
else
  # El servidor principal no responde: activar failover
  IP_ACTUAL=$(obtener_ip_actual)
  if [ "$IP_ACTUAL" != "$IP_SECUNDARIO" ]; then
    echo "[$(date)] ALERTA: Servidor principal caído. Activando failover..."
    actualizar_dns "$IP_SECUNDARIO"
    # Enviar alerta (requiere mailutils o similar)
    echo "Failover activado. IP cambiada a $IP_SECUNDARIO" | \
      mail -s "ALERTA: Failover DNS activado" [email protected]
  fi
fi

# Hacer el script ejecutable
chmod +x /usr/local/bin/failover-dns.sh

# Programar la verificación cada minuto
crontab -e
# Añadir:
# * * * * * /usr/local/bin/failover-dns.sh >> /var/log/failover-dns.log 2>&1

# Crear un endpoint /health sencillo en Nginx
cat > /etc/nginx/conf.d/health.conf << 'EOF'
server {
    listen 80;
    location /health {
        access_log off;
        return 200 "OK\n";
        add_header Content-Type text/plain;
    }
}
EOF

sudo nginx -t && sudo systemctl reload nginx

# Instalar rclone
curl https://rclone.org/install.sh | sudo bash

# Configurar múltiples backends
rclone config
# Añadir: aws-s3, backblaze-b2, google-cloud-storage, etc.

# Replicar entre proveedores
rclone sync aws-s3:mi-bucket-principal backblaze-b2:mi-bucket-backup \
  --transfers 10 \
  --checkers 20 \
  --log-file /var/log/rclone-sync.log

# Replicar a múltiples destinos
rclone copy /var/backups/ aws-s3:mi-bucket/backups/ &
rclone copy /var/backups/ backblaze-b2:mi-bucket/backups/ &
wait  # Esperar a que ambas operaciones terminen
echo "Replicación completada"

# En el servidor principal: configurar replicación streaming
# En postgresql.conf
cat >> /etc/postgresql/14/main/postgresql.conf << 'EOF'
wal_level = replica
max_wal_senders = 3
wal_keep_size = 256
synchronous_commit = local
EOF

# En pg_hba.conf: permitir conexión del servidor secundario
echo "host replication replicador IP_SECUNDARIO/32 md5" >> \
  /etc/postgresql/14/main/pg_hba.conf

sudo systemctl restart postgresql

# Crear usuario de replicación
sudo -u postgres psql -c "CREATE USER replicador REPLICATION LOGIN ENCRYPTED PASSWORD 'clave_segura';"

# En el servidor secundario: inicializar desde el principal
sudo -u postgres pg_basebackup \
  -h IP_PRINCIPAL \
  -U replicador \
  -D /var/lib/postgresql/14/main/ \
  -P -Xs -R

# main.tf - Configuración multi-proveedor

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
    google = {
      source  = "hashicorp/google"
      version = "~> 5.0"
    }
    cloudflare = {
      source  = "cloudflare/cloudflare"
      version = "~> 4.0"
    }
  }
}

# Proveedor AWS
provider "aws" {
  region = "eu-west-1"
}

# Proveedor Google Cloud
provider "google" {
  project = "mi-proyecto-gcp"
  region  = "europe-west1"
}

# Proveedor Cloudflare
provider "cloudflare" {
  api_token = var.cloudflare_token
}

# Bucket S3 para backups
resource "aws_s3_bucket" "backups" {
  bucket = "mis-backups-multi-cloud"
}

# Bucket GCS para réplica
resource "google_storage_bucket" "replica" {
  name     = "mis-backups-replica-gcp"
  location = "EU"
}

# Registro DNS en Cloudflare
resource "cloudflare_record" "www" {
  zone_id = var.cloudflare_zone_id
  name    = "www"
  value   = var.vps_ip
  type    = "A"
  proxied = true
}

# Inicializar Terraform con los proveedores
terraform init

# Ver el plan de ejecución
terraform plan

# Aplicar la configuración
terraform apply

# Instalar Prometheus con multi-target scraping
# prometheus.yml con targets de múltiples proveedores
cat > /etc/prometheus/prometheus.yml << 'EOF'
global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'vps-principal'
    static_configs:
      - targets: ['IP_VPS_PRINCIPAL:9100']
        labels:
          proveedor: 'propio'

  - job_name: 'aws-instancia'
    static_configs:
      - targets: ['IP_AWS:9100']
        labels:
          proveedor: 'aws'

  - job_name: 'gcp-instancia'
    static_configs:
      - targets: ['IP_GCP:9100']
        labels:
          proveedor: 'gcp'
EOF

sudo systemctl restart prometheus

# Calcular el coste de transferencia entre proveedores
# AWS cobra ~0.09$/GB de egress
# GCP cobra ~0.08$/GB de egress
# Backblaze B2: egress gratuito cuando se accede vía Cloudflare

# Script para monitorizar el uso de transferencia en AWS
aws cloudwatch get-metric-statistics \
  --namespace AWS/S3 \
  --metric-name BytesDownloaded \
  --dimensions Name=BucketName,Value=mi-bucket \
  --start-time $(date -d '7 days ago' -u +%Y-%m-%dT%H:%M:%SZ) \
  --end-time $(date -u +%Y-%m-%dT%H:%M:%SZ) \
  --period 604800 \
  --statistics Sum

# Verificar el estado de sincronización con rclone
rclone check aws-s3:bucket backblaze-b2:bucket --combined /tmp/diff-report.txt
cat /tmp/diff-report.txt

# Verificar las credenciales de cada proveedor
terraform plan -var-file="credenciales.tfvars"

# Reinicializar los providers
terraform init -upgrade