Construyendo un robot para cambiar y actualizar IP en Cloudflare según las IP recibidas del servidor de Amazon

Requisitos previos

Antes de comenzar, es necesario preparar los siguientes elementos para que el robot funcione correctamente.

• Cuenta de Cloudflare y acceso para administrar el DNS del dominio.
• Creación Token de API En Cloudflare con nivel de acceso Zona:DNS:Editar Para la zona deseada.
• Acceso a Identificación de zona Nombre de dominio y registro (p. ej. vpn.ejemplo.com).
• Un servidor o servicio en AWS (EC2) con una dirección IP pública a la que se puede acceder, o acceso a la API de AWS para realizar consultas.
• Herramientas básicas: rizo, jq, Python3+ solicitudes.
• Sugerencia de seguridad: Mantenga el token en Administrador de secretos de AWS o variables de entorno protegidas.

Métodos para obtener IP de AWS

Existen varios métodos comunes para obtener una dirección IP pública de los servidores de Amazon; la elección del método depende del escenario de implementación.

1. Dentro de EC2 (metadatos)

Si el script se ejecuta en la misma instancia EC2, la forma más sencilla es utilizar el servicio de metadatos:

curl -s http://169.254.169.254/latest/meta-data/public-ipv4

Para IPv6:

curl -s http://169.254.169.254/latest/meta-data/ipv6

2. Con AWS CLI/SDK

Usando describir-instancias Puedes filtrar por etiqueta o ID de instancia para obtener la IP. Con el rol de IAM, puedes eliminar la necesidad de claves de acceso.

aws ec2 describe-instances --instance-ids i-0123456789abcdef --query "Reservations[].Instances[].PublicIpAddress" --output text

3. IP elástica y redes complejas

Para configuraciones de red complejas o de IP elástica, verifique las asociaciones con describir-direcciones El método es apropiado.

Diseño de robots: arquitectura propuesta

Dependiendo de la necesidad y la escala, existen varios patrones arquitectónicos adecuados:

• Opción sencilla: El script se ejecuta en el mismo EC2 y verifica la IP cada n minutos; si cambia, se actualiza con la API de Cloudflare.
• Opción escalable: Múltiples EC2 en diferentes regiones → Un Lambda/Serverless central es responsable de recopilar direcciones IP y actualizar múltiples registros.
• Estado de guardado: Archivo local o S3/DB para almacenar la última IP registrada para evitar actualizaciones innecesarias.
• Manejo de errores y reintentos: Utilice retroceso y registro (CloudWatch).

Implementación rápida con Bash + curl (ejemplo práctico)

Este ejemplo asume que el script se ejecuta en la misma instancia EC2 y actualiza un registro A. Primero, obtenga el ID de zona y el ID de registro una vez:

curl -s -X GET "https://api.cloudflare.com/client/v4/zones?name=example.com" -H "Authorization: Bearer $CF_API_TOKEN" -H "Content-Type: application/json" | jq -r '.result[0].id'

curl -s -X GET "https://api.cloudflare.com/client/v4/zones/$ZONE_ID/dns_records?name=vpn.example.com" -H "Authorization: Bearer $CF_API_TOKEN" -H "Content-Type: application/json" | jq -r '.result[0].id'

Guión de muestra update-ip.sh:

#!/usr/bin/env bash
set -e
CF_TOKEN="---FROM SECRETS MANAGER OR ENV---"
ZONE_ID="your_zone_id"
RECORD_NAME="vpn.example.com"
RECORD_ID="your_record_id"
PROXY=false
TTL=120

get_ip() {
  curl -s http://169.254.169.254/latest/meta-data/public-ipv4
}

current_ip=$(get_ip)
old_ip_file="/var/run/current_ip_${RECORD_NAME}"

if [ -f "$old_ip_file" ]; then
  old_ip=$(cat "$old_ip_file")
else
  old_ip=""
fi

if [ "$current_ip" = "" ]; then
  echo "No public IP found" >&2
  exit 1
fi

if [ "$current_ip" != "$old_ip" ]; then
  echo "Updating Cloudflare DNS from $old_ip to $current_ip"
  payload=$(jq -n --arg type "A" --arg name "$RECORD_NAME" --arg content "$current_ip" --argjson proxied $PROXY --argjson ttl $TTL '{type:$type, name:$name, content:$content, proxied:$proxied, ttl:$ttl}')
  resp=$(curl -s -X PUT "https://api.cloudflare.com/client/v4/zones/$ZONE_ID/dns_records/$RECORD_ID" -H "Authorization: Bearer $CF_TOKEN" -H "Content-Type: application/json" --data "$payload")
  success=$(echo "$resp" | jq -r '.success')
  if [ "$success" = "true" ]; then
    echo "$current_ip" > "$old_ip_file"
    echo "Update successful"
  else
    echo "Update failed: $resp" >&2
    exit 2
  fi
else
  echo "IP unchanged ($current_ip)"
fi

Consejos: De jq Se utiliza para crear JSON. Almacenar IP en /var/ejecutar Esto es para evitar actualizaciones innecesarias. Mantenga el token en una variable de entorno o en el Administrador de Secretos, no en un script.

Implementación confiable con Python (ejemplo práctico)

Un ejemplo de un script de Python que se puede ejecutar como Lambda o en el servidor y administra múltiples registros.

requests
boto3

import os, requests, json
CF_TOKEN = os.environ['CF_TOKEN']
ZONE_ID = os.environ['ZONE_ID']
RECORDS = json.loads(os.environ.get('RECORDS_JSON', '[]'))

HEADERS = {
    "Authorization": f"Bearer {CF_TOKEN}",
    "Content-Type": "application/json"
}

def get_ec2_public_ip():
    try:
        r = requests.get("http://169.254.169.254/latest/meta-data/public-ipv4", timeout=2)
        if r.ok:
            return r.text.strip()
    except:
        pass
    return None

def find_record_id(name, type="A"):
    url = f"https://api.cloudflare.com/client/v4/zones/{ZONE_ID}/dns_records?name={name}&type={type}"
    r = requests.get(url, headers=HEADERS)
    data = r.json()
    if data.get("success") and data["result"]:
        return data["result"][0]["id"]
    return None

def update_record(record_id, name, ip, type="A", ttl=120, proxied=False):
    url = f"https://api.cloudflare.com/client/v4/zones/{ZONE_ID}/dns_records/{record_id}"
    payload = {"type": type, "name": name, "content": ip, "ttl": ttl, "proxied": proxied}
    r = requests.put(url, headers=HEADERS, json=payload)
    return r.json()

def lambda_handler(event, context=None):
    ip = get_ec2_public_ip()
    if not ip:
        print("No public IP found")
        return
    for rec in RECORDS:
        name = rec["name"]
        typ = rec.get("type","A")
        rec_id = find_record_id(name, typ)
        if not rec_id:
            print(f"No record id for {name}")
            continue
        resp = update_record(rec_id, name, ip, typ, rec.get("ttl",120), rec.get("proxied",False))
        print(resp)

if __name__ == "__main__":
    lambda_handler(None)

Implementación y gestión (systemd, cron, Lambda)

Algunos métodos comunes para ejecutar y gestionar un robot:

• systemd:Crea una unidad que ejecute el script cada 5 minutos o un servicio demonio que monitoree los cambios.
• cron:Ejecución periódica (cada n minutos) con memoria de estado local para evitar actualizaciones redundantes.
• AWS Lambda y EventBridge:Ejecución periódica sin mantenimiento del servidor, con rol IAM y Secrets Manager.
• Registros:Envía registros a CloudWatch y define alarmas para errores persistentes.

Seguridad, almacenamiento de claves y acceso mínimo

Requisitos de seguridad para reducir el riesgo y adherirse al principio de mínimo acceso:

• Token API limitado: En Cloudflare, use el token API en lugar de la clave API global y limite el alcance a Zona:DNS:Editar Sólo para la zona deseada.
• Rol de IAM: En AWS, utilice el rol IAM para EC2/Lambda y use AWS Secrets Manager o SSM Parameter Store para almacenar CF_TOKEN.
• Eliminar token de los registros: Borre los registros del almacenamiento de tokens y utilice TLS.
• Actualizaciones de límites: Si la IP no ha cambiado, no envíe ninguna actualización para evitar el límite de velocidad.

Consejos prácticos: TTL, Proxy, IPv6, Solución de problemas y Monitoreo

• Tiempo de vidaUn TTL bajo (por ejemplo, 120 s) es bueno para cambios rápidos, pero aumenta las consultas.
• Proxy (nube naranja de Cloudflare):Si desea que el tráfico pase a través de Cloudflare (CDN, WAF, protección DDoS), proxy=verdadero. Pero para los intercambios de IP de lista blanca, como los que se usan para hacer listas blancas, necesitas... proxy=falso Para preservar la propiedad intelectual real.
• IPv6:Si existe una dirección IPv6, actualizar AAAA Los registros también son esenciales.
• Reintentos:Utilice un retroceso exponencial y registre errores cuando encuentre errores de red.
• Escucha:Mantenga métricas sobre actualizaciones exitosas/fallidas, tiempos de respuesta de API y cambios de IP en el panel y configure notificaciones para errores frecuentes.

Comparación y recomendaciones prácticas para el trading, los juegos y la web

Comercio: El ping y la estabilidad son muy importantes. Se recomienda usar un VPS de trading con una ubicación cercana al exchange y con protección anti-DDoS. Para una IP fija, use una IP elástica o un robot de actualización. Para algunas API de exchange proxy=falso Es necesario.

Juego: La baja latencia y la estabilidad son importantes. Usa una ubicación cercana a los jugadores. Dependiendo del juego, la decisión de usar Cloudflare Spectrum o no usar ningún proxy es crucial.

Web y API: Usando Cloudflare con proxy=verdadero Recomendado para CDN, WAF y protección DDoS. En este caso, cambiar la IP es menos crítico, pero es necesario gestionar el origen.

Conclusión

Usando los métodos discutidos anteriormente, puedes actualizar de manera automática y segura los registros DNS en Cloudflare según las IP recibidas de EC2.

• De Token API limitado Utilice Cloudflare.
• De Rol de IAM y Administrador de secretos Aproveche AWS.
• Implemente un registro, monitoreo y reintentos adecuados para que el proceso sea sólido.
• Para necesidades específicas (comercio, juegos, IA/renderizado), utilice servidores especializados, Anti-DDoS y ubicaciones optimizadas para reducir la latencia y aumentar la estabilidad.

Disposición a recibir asistencia técnica

Si necesita ayuda con la implementación profesional, la elección de la ubicación adecuada o la implementación segura en AWS y Cloudflare, puede comunicarse con el equipo técnico para brindarle una solución personalizada y soporte completo.

Preguntas frecuentes