Token LabBuscar

DNS / AI OPERATIONS

IA para DNS: configuración, seguridad, inspección y observabilidad

Qué mejora la IA frente a reglas, qué evidencia necesita y cómo validar diagnósticos y cambios sin perder control.

Fuentes y versiones
En este artículo

1. Qué aporta realmente la IA al DNS

DNS conecta nombres con direcciones, correo y servicios. Un cambio puede afectar tráfico, certificados, descubrimiento interno y seguridad. Seguiremos el lanzamiento de api.example.com, pensando en desarrolladores, SRE y equipos de seguridad. La IA resulta útil al interpretar una intención incompleta y relacionar pruebas dispersas; las reglas siguen siendo mejores para validar sintaxis, firmas, permisos y temporizadores.

ML combina señales débiles de tráfico; los modelos temporales aprenden patrones por carga y horario; un LLM interpreta solicitudes, consulta documentación y propone pruebas. Un panel conversacional por sí solo no hace el DNS más fiable.

Trabajo Base determinista Aporte potencial de IA
Configuración Tipos, direcciones, TTL, conflictos Traducir intención y dependencias con inventario fiable
Seguridad Indicadores conocidos y políticas Ordenar comportamientos nuevos con datos representativos
Inspección Comprobaciones repetibles Agrupar por propietario e impacto empresarial
Observabilidad Mediciones y umbrales Relacionar cambios y perspectivas en hipótesis comprobables

2. Fundamentos: un registro correcto no basta

El cliente consulta normalmente a un resolvedor recursivo, que usa caché o sigue delegaciones desde raíz y TLD hasta los servidores autoritativos. El registrador suele controlar delegación/DS del padre; el proveedor aloja la zona hija. Ver un A correcto en el panel no demuestra que los clientes lo resuelvan.[S1]

Una zona es un espacio delegado; un RRset agrupa nombre, clase y tipo. A/AAAA dan direcciones, CNAME alias, MX correo, TXT políticas/verificación, NS/SOA autoridad. Un CNAME ordinario no puede coexistir con datos A/MX arbitrarios; existen excepciones DNSSEC especificadas. El ápice necesita SOA/NS: ALIAS, ANAME y flattening son funciones del proveedor, no un CNAME universal.[S2]

TTL no es un cronómetro de propagación mundial. También se almacenan respuestas negativas: su duración autoritativa deriva del mínimo entre TTL del SOA y SOA.MINIMUM. Políticas, cachés de aplicaciones y serve-stale modifican las observaciones.[S3][S4] DNSSEC autentica origen e integridad, no cifra consultas ni acredita una aplicación. DoT/DoH protegen sus conexiones; no sustituyen DNSSEC ni ocultan las consultas al resolvedor elegido. Un DS incompatible con DNSKEY/RRSIG puede causar SERVFAIL en validadores aunque la autoridad responda.[S5][S6][S7]

3. Escenario: publicar una API

La petición dice «mover la API al nuevo ingreso». Usamos example.com y las direcciones documentales 192.0.2.10 y 192.0.2.20, no objetivos desplegables. Es un caso didáctico original, no una auditoría de tokenlab.fyi.

Hay que identificar nombre, entorno, RRsets actual/objetivo, IPv6, proxy/CDN, certificado, ventana, reversión y dependencias de correo/verificación. Si faltan destino o propiedad, el resultado correcto es información pendiente, no un registro inventado. El contexto debe incluir ticket, instantánea/versionado de zona, activo, ámbito permitido, documentación, cambios y sondas. La salida es un diff mínimo con razones, pruebas y estado recuperable; se guarda aparte de la explicación.

Diseño original: la IA propone; los controles externos autorizan. La resolución DNS no pasa por el LLM.
Diseño original: la IA propone; los controles externos autorizan. La resolución DNS no pasa por el LLM. Abrir diagrama completo

4. Configuración: traducir y después verificar

Dar de alta correo puede requerir MX, SPF, DKIM, DMARC y TXT de varios proveedores. Un LLM puede reconciliar instrucciones con emisores existentes y proponer combinar SPF en vez de añadir políticas independientes. La mejora es reducir interpretación manual; límites de consultas SPF, destinos MX, selectores y alineación DMARC requieren validación específica. Que exista TXT no demuestra entrega autenticada.[S8][S9]

Flujo: leer estado real, proponer diff, validar tipos/ámbito/restricciones, previsualizar, autorizar/aplicar y verificar desde autoridad y recursivos representativos. DNSControl separa preview y push; octoDNS proporciona gestión declarativa multiproveedor. La IA aprovecha estas herramientas, no reemplaza su ejecución.[S10][S11]

Vincule aprobación a hash y versión esperada. Relea antes de aplicar y rechace planes obsoletos. Una actualización condicional atómica depende del proveedor; si falta, use escritor controlado, bloqueo y nuevo cálculo. Leer una vez no elimina carreras. Tras un timeout, compruebe ID y estado antes de reintentar. Los cambios multiproveedor requieren compensación ante éxito parcial.

Valide sufijos y punto final, TTL uniforme, segmentación TXT, comodines/delegación, direcciones privadas en zona pública, AAAA prematuro, CAA y cambios sensibles NS/DS. Si a las 12:00 reduce TTL de 3600 a 300 segundos, una caché creada a las 11:59:59 puede seguir usando el anterior hasta casi las 13:00. Espere la ventana anterior y mantenga solapamiento de servicio. Un TTL menor aumenta carga; una reversión tampoco retira respuestas ya almacenadas. 300 segundos no garantiza convergencia global en cinco minutos.[S3][S4]

RFC 9989 de mayo de 2026 sustituye RFC 7489/9091 para DMARC. Compruebe descubrimiento de políticas y soporte real del receptor antes de copiar plantillas antiguas.[S9]

5. Seguridad: comportamiento y contexto

Separe protección de infraestructura —disponibilidad, amplificación, capacidad, límites— de detección de abuso de terminales mediante DNS —phishing, C2, DGA, túneles—. Cambian la posición de observación y las acciones.

ML puede combinar longitud, distribución de caracteres, subdominios únicos, NXDOMAIN, periodicidad, tipos, edad, relaciones DNS e identidad del terminal. CDN y actualizaciones también producen nombres aleatorios. Puede superar un umbral aislado de entropía si aprende el entorno, pero hay que demostrarlo localmente. Cloudflare describe ML para DGA y túneles; no demuestra superioridad universal.[S12]

El LLM puede relacionar consultas con procesos EDR, explicar indicios y señalar lagunas. Una sospecha no justifica bloquear un CDN compartido en toda la empresa: prefiera observación, ámbito limitado, corroboración, caducidad y reversión. UDP/53 no cubre DoH externo; el análisis de tráfico cifrado no recupera mágicamente nombres exactos. La autoridad suele ver recursivos, no usuarios ni aciertos de caché.[S6][S7]

6. La trampa de la tasa base

Suponga un millón de ventanas terminal–dominio diarias, prevalencia maliciosa 0,01%: 100 casos. Con recall 95% y falsos positivos benignos 0,1%, aparecen 95 verdaderos positivos, 5 falsos negativos y unos 1000 falsos positivos. La precisión de alertas es solo 8,7%. Es aritmética sintética, no benchmark comercial.

p es prevalencia, r recall y f tasa de falsos positivos benignos, como fracciones. La precisión es la fracción maliciosa de alertas. Con , y resulta 0.086766.

Ejemplo sintético: 95 alertas verdaderas y unas 1000 falsas; precisión de solo 8,7%.
Ejemplo sintético: 95 alertas verdaderas y unas 1000 falsas; precisión de solo 8,7%. Abrir diagrama completo

Mida incidentes confirmados por hora de analista, falsas alertas por mil terminales, retraso y daño de bloqueos. Separe evaluación por tiempo y familias/relaciones de dominios para evitar fuga de datos. Vigile deriva y excepciones caducadas. Un score no equivale automáticamente a probabilidad calibrada. Compare en modo sombra con reglas antes de habilitar acciones: evidencia y autorización, no «confianza 0,98», justifican una intervención.

7. Inspección: comprobar y priorizar

Recoja NS padre/hijo, accesibilidad y glue necesario, convergencia autoritativa según proveedor, cadena/expiración DNSSEC, UDP/TCP, IPv4/IPv6, caché negativa, TTL, cadenas CNAME, huérfanos, CAA/correo y vistas.[S13][S14] GeoDNS y split-horizon pueden diferir legítimamente; un serial SOA compartido tampoco prueba equivalencia completa.

La IA puede agrupar miles de alias de un proveedor retirado, vincular hallazgos al pago crítico y localizar responsables. Su aporte depende del grafo de activos y dependencias. Un CNAME que termina en NXDOMAIN o HTTP 404 no prueba secuestro: confirme reglas de reclamación y propiedad sin apropiarse del recurso. La limpieza requiere dependencias verificadas y copia recuperable.

8. Observabilidad: conservar cada perspectiva

Distinga cliente/caché local, recursivo, autoridad y aplicación/TLS. Una respuesta rápida puede ser un error rápido.

Capa Evidencia Límite
Cliente/sonda Nombre, tipo, resolvedor, vista, RCODE, RRset esperado, duración, tiempo Solo representa esa perspectiva
Recursivo Caché, upstream, validación, timeout, carga No ve tráfico externo
Autoridad Consultas, códigos, red, TCP, capacidad No cuenta todas las consultas de usuarios
Cambios/aplicación Diff, versión, aprobación, TLS/HTTP Correlación temporal no es causalidad

CoreDNS exporta solicitudes, respuestas y duración mediante Prometheus; otros plugins añaden métricas. Verifique versiones, etiquetas y límites de medición. No use QNAME/IP de alta cardinalidad como etiquetas: guárdelos en logs controlados, muestreados y con retención.[S15] Los modelos temporales aportan bases por carga/temporada; el LLM genera consultas limitadas y pruebas discriminantes. La explicación siempre debe volver a evidencia medible.

9. Incidente: NXDOMAIN después del alta

A las 12:00 se consulta el nombre inexistente, TTL negativo 900 segundos. Se crea a las 12:02. A las 12:03 la autoridad y el recursivo A responden bien, pero B devuelve NXDOMAIN con unos 720 segundos restantes. Compare caché negativa, delegación, DNSSEC, vista privada y fallo de red. Examine respuestas directas, TTL decreciente, creación, vista y EDE. EDE no siempre está disponible ni es una prueba autónoma.[S16]

Incidente sintético: comparar perspectivas antes de sondear. Son indicios, no una causa demostrada.
Incidente sintético: comparar perspectivas antes de sondear. Son indicios, no una causa demostrada. Abrir diagrama completo

La secuencia favorece caché negativa: repita tras la ventana y limpie únicamente cachés propias con autorización si procede. Mantenga estable la autoridad correcta. Si persiste, descarte la hipótesis. Con SERVFAIL en validadores revise DS/DNSKEY/RRSIG, tiempos, relojes, fragmentación y TCP; no elimine DS ni desactive DNSSEC como arreglo genérico. La IA mejora la elección de la próxima prueba, no convierte un síntoma en causa.

10. Kubernetes y varias nubes

La lentitud puede venir de sufijos/ndots, CoreDNS, reenvío, NodeLocal DNSCache, conntrack, pérdidas o autoridad upstream. Un nombre corto genera varias consultas; un proceso sano no demuestra conectividad del nodo.[S17] La IA puede relacionar DNSPolicy, resolv.conf, nodos, despliegues y métricas para contrastar «solo estos nodos» o «solo fallos de caché», siempre con ventana y mapeo correctos.

En multinube conserve cuenta, proyecto, región, red y vista al investigar zonas privadas, endpoints y reenvío. No combine nombres internos y públicos idénticos. Las herramientas deben recibir ámbito desde identidad autenticada, no desde una elección libre del modelo.

11. Arquitectura y límites de confianza

Use colectores deterministas, almacén de evidencia, reglas/estadística/ML, LLM con recuperación y herramientas, y plano independiente de política/aprobación/ejecución. Guarde ID, fuente, tiempo, vista, consulta, respuesta original y versión. Separe observaciones de hipótesis.

Limite schema, nombres, tasa, timeout y tamaño. TXT, logs y tickets son datos no confiables: una orden de borrar la zona dentro de ellos no concede permiso. Mantenga claves persistentes fuera del modelo y audite identidad, hash, caducidad y versiones. La investigación LLM debe quedar fuera de la ruta crítica de resolución. Si falla, DNS, alertas y runbooks siguen funcionando. Abra lectura primero, borradores después y acciones acotadas tras evaluación.

12. Herramientas y productos

Capa Opciones Uso y límite
Declaración DNSControl / octoDNS Proveedores y diff revisable [S10][S11]
Consultas dig / dnspython / DNSViz Respuestas reales y cadena DNSSEC [S14][S18]
Descubrimiento CoreDNS Plugins y telemetría; IA auxiliar [S15][S17]
Evidencia Prometheus / Grafana / logs existentes Antes del interfaz conversacional
Protección comercial Cloudflare / Infoblox Evaluar cobertura, falsos positivos y controles [S12][S19]

Cloudflare documenta protección adaptada a bases de tráfico y ML DGA/túneles: tareas distintas. Infoblox describe inteligencia, análisis streaming y ML. Son capacidades declaradas, sin comparación uniforme aquí; confirme producto y contrato.[S12][S19][S20] En GitOps empiece por investigación de solo lectura y borradores de PR. Para una zona pequeña estable quizá basten IaC y monitorización convencional.

13. Demostrar beneficio y coste

Compare proceso actual, automatización con reglas y las mismas herramientas más IA. Reproduzca incidentes comparables. Mida distribución de tiempos, localización correcta, citas de evidencia, cambios innecesarios, bloqueos falsos, revisión y coste. Las malas sugerencias rechazadas también cuentan.

Defina SLO por respuestas correctas y oportunas desde vistas especificadas: NOERROR puede no contener datos y NXDOMAIN puede ser esperado. Separe sondas y peticiones reales. Diez millones de sondas al 99,99% permiten 1000 fallos, no 1000 minutos.

Ejemplo hipotético: 200 investigaciones mensuales ahorran ocho minutos a $60/h: $1600 brutos. Restando $300 de modelo, $600 de mantenimiento y $200 de revisión quedan $500. Añadir $3000 de pérdida esperada por incidentes invierte el resultado. Mejor significa decidir antes con riesgo y coste aceptables. Despliegue inventario/evidencia, asistencia de lectura, diff y finalmente acciones tras modo sombra. Investigue calibración, baja prevalencia, transferencia, privacidad y diagnóstico causal verificable.

14. Experimento local y ejercicios

El programa Python 3.11+ usa biblioteca estándar, sin red, claves ni escrituras. Demuestra un control A/CNAME deliberadamente limitado, análisis de caché negativa por tiempo/vista y aritmética de tasa base. Prueba barreras deterministas, no inteligencia LLM ni un validador completo.

Descargue el archivo Python y ejecútelo localmente, sin red ni clave.

dns-evidence-gate.py
python3 dns-evidence-gate.py

Salida esperada

checks=25 clean=candidate stale_plan=rejected cache=negative_cache_candidate
synthetic_tp=95 fn=5 fp=999.9 precision=8.6766%
Python · dns-evidence-gate.py
"""Offline teaching fixture. No network, model calls, or production writes.
Python 3.11+. Only A/CNAME records, not a complete DNS validator.
"""
import copy
import hashlib
import ipaddress
import json
import math


def canonical_name(value):
    if not isinstance(value, str) or not value.endswith('.'):
        raise ValueError('absolute_name_required')
    name = value.lower()
    labels = name[:-1].split('.')
    if len(name.encode('ascii')) > 254 or any(
        not label or len(label) > 63 or
        any(c not in 'abcdefghijklmnopqrstuvwxyz0123456789-' for c in label) or
        label.startswith('-') or label.endswith('-') for label in labels
    ):
        raise ValueError('restricted_hostname_required')
    return name


def validate(records, zone='example.com.'):
    """Restricted hostname-only zone policy, deliberately rejects other types."""
    zone = canonical_name(zone)
    by_name = {}
    for record in records:
        if set(record) != {'name', 'type', 'ttl', 'value'}:
            raise ValueError('schema')
        name = canonical_name(record['name'])
        if name != zone and not name.endswith('.' + zone):
            raise ValueError('outside_zone')
        ttl = record['ttl']
        if type(ttl) is not int or not 30 <= ttl <= 86400:
            raise ValueError('ttl_policy')
        kind, value = record['type'], record['value']
        if kind == 'A':
            if ipaddress.ip_address(value).version != 4:
                raise ValueError('ipv4_required')
        elif kind == 'CNAME':
            canonical_name(value)
            if name == zone:
                raise ValueError('apex_cname')
        else:
            raise ValueError('unsupported_type')
        by_name.setdefault(name, []).append(record)
    for rr in by_name.values():
        if any(r['type'] == 'CNAME' for r in rr) and len(rr) != 1:
            raise ValueError('cname_conflict')
        if len({r['ttl'] for r in rr}) != 1:
            raise ValueError('rrset_ttl')
    return 'candidate'


def plan_hash(records):
    return hashlib.sha256(json.dumps(records, sort_keys=True,
                                     separators=(',', ':')).encode()).hexdigest()


def apply_gate(records, approved_hash, expected_version, actual_version):
    # Illustrates checks, not an atomic provider write or a lock.
    if expected_version != actual_version:
        raise ValueError('stale_plan')
    if plan_hash(records) != approved_hash:
        raise ValueError('changed_plan')
    return validate(records)


def diagnose(authority, recursive, now):
    """Suggest a hypothesis and next test; never claims proven root cause."""
    required = {'name', 'type', 'view', 'at', 'rcode', 'answer', 'source'}
    if not authority or not required <= authority.keys() or not required <= recursive.keys():
        return 'investigate'
    if any(not 0 <= now - o['at'] <= 60 for o in (authority, recursive)):
        return 'investigate'
    if any(authority[k] != recursive[k] for k in ('name', 'type', 'view')):
        return 'investigate'
    ttl = recursive.get('negative_ttl')
    if (authority['source'] == 'authoritative' and
        recursive['source'] == 'recursive' and
        authority['rcode'] == 'NOERROR' and authority['answer'] and
        recursive['rcode'] == 'NXDOMAIN' and not recursive['answer'] and
        type(ttl) is int and ttl - (now - recursive['at']) > 0):
        return 'negative_cache_candidate'
    return 'investigate'


def run_checks():
    checks = 0
    def reject(fn):
        nonlocal checks
        try:
            fn()
        except (ValueError, UnicodeError):
            checks += 1
        else:
            raise AssertionError('unsafe candidate accepted')
    clean = [{'name': 'api.example.com.', 'type': 'A',
              'ttl': 300, 'value': '192.0.2.20'}]
    assert validate(clean) == 'candidate'
    checks += 1
    for patch in ({'value': 'not-an-ip'}, {'value': '2001:db8::1'},
                  {'name': 'api.otherexample.com.'}, {'ttl': True}, {'ttl': 0},
                  {'name': 'api.example.com'}, {'type': 'TXT'}, {'extra': 1}):
        bad = copy.deepcopy(clean)
        bad[0].update(patch)
        reject(lambda: validate(bad))
    alias = {'name': 'api.example.com.', 'type': 'CNAME',
             'ttl': 300, 'value': 'edge.example.net.'}
    reject(lambda: validate(clean + [alias]))
    reject(lambda: validate([dict(alias, name='example.com.')]))
    reject(lambda: validate(clean + [dict(clean[0], ttl=600, value='192.0.2.10')]))
    digest = plan_hash(clean)
    assert apply_gate(clean, digest, 'v1', 'v1') == 'candidate'
    checks += 1
    reject(lambda: apply_gate(clean, digest, 'v1', 'v2'))
    reject(lambda: apply_gate([dict(clean[0], ttl=600)], digest, 'v1', 'v1'))
    auth = {'name': 'api.example.com.', 'type': 'A', 'view': 'public',
            'at': 180, 'rcode': 'NOERROR', 'answer': ['192.0.2.20'],
            'source': 'authoritative'}
    rec = dict(auth, source='recursive', rcode='NXDOMAIN', answer=[], negative_ttl=720)
    assert diagnose(auth, rec, 180) == 'negative_cache_candidate'
    checks += 1
    for a, r, now in ((None, rec, 180), (auth, dict(rec, view='private'), 180),
                      (auth, rec, 241), (auth, dict(rec, negative_ttl=0), 180),
                      (auth, dict(rec, rcode='SERVFAIL'), 180),
                      (auth, dict(rec, type='AAAA'), 180),
                      (dict(auth, answer=[]), rec, 180),
                      (auth, dict(rec, at=200), 180)):
        assert diagnose(a, r, now) == 'investigate'
        checks += 1
    tp, fn, fp = 100 * .95, 100 * .05, 999900 * .001
    precision = tp / (tp + fp)
    assert math.isclose(precision, .086765914695406, rel_tol=1e-12)
    checks += 1
    print(f'checks={checks} clean=candidate stale_plan=rejected cache=negative_cache_candidate')
    print(f'synthetic_tp={tp:.0f} fn={fn:.0f} fp={fp:.1f} precision={precision:.4%}')


if __name__ == '__main__':
    run_checks()

Pruebas negativas: conflicto CNAME/A, dirección inválida, nombre fuera de zona, TTL inválido, estado cambiado tras aprobación, vistas distintas, evidencia antigua, TTL agotado y ausencia de autoridad. La incertidumbre produce investigate. Para producción adapte colectores de solo lectura conservando respuestas y límites; candidate nunca concede escritura.

Ejercicios: diseñe alta de nombre frente a cambio existente con TTL 3600 y negativo 900; separe fallo DNSSEC de red; mida errores con CDN benigno y separación temporal/familiar; cambie el estado tras aprobación y demuestre rechazo. El dominio práctico exige diseñar, implementar, depurar y evaluar independientemente.

Predecir, comprobar y conservar evidencia

Antes de revelar la respuesta, predice un resultado. Después registra diferencias y una prueba de transferencia. Se guarda localmente y se comparte entre idiomas.

Abrir cuaderno / exportar / borrar →

El alcance de revisión matemática se registra por lección. No certifica reproducción empírica del artículo; anota posibles errores. Alcance de revisión

Fuentes primarias y lecturas

Fuentes comprobadas el 16 de noviembre de 2026. Diseño y cálculos didácticos originales; funciones según documentos oficiales. Sin benchmark comercial ni auditoría DNS de producción.

  1. S1 · RFC 1034 — DNS conceptshttps://www.rfc-editor.org/rfc/rfc1034 · 2026-11-16
  2. S2 · RFC 2181 — DNS clarificationshttps://www.rfc-editor.org/rfc/rfc2181 · 2026-11-16
  3. S3 · RFC 2308 — Negative cachinghttps://www.rfc-editor.org/rfc/rfc2308 · 2026-11-16
  4. S4 · RFC 8767 — Serve stalehttps://www.rfc-editor.org/rfc/rfc8767 · 2026-11-16
  5. S5 · RFC 4033 — DNSSEC introductionhttps://www.rfc-editor.org/rfc/rfc4033 · 2026-11-16
  6. S6 · RFC 7858 — DNS over TLShttps://www.rfc-editor.org/rfc/rfc7858 · 2026-11-16
  7. S7 · RFC 8484 — DNS over HTTPShttps://www.rfc-editor.org/rfc/rfc8484 · 2026-11-16
  8. S8 · RFC 7208 — SPFhttps://www.rfc-editor.org/rfc/rfc7208 · 2026-11-16
  9. S9 · RFC 9989 — DMARC (May 2026; obsoletes RFC 7489/9091)https://www.rfc-editor.org/info/rfc9989/ · 2026-11-16
  10. S10 · DNSControl — preview/pushhttps://docs.dnscontrol.org/commands/preview-push · 2026-11-16
  11. S11 · octoDNS — official repositoryhttps://github.com/octodns/octodns · 2026-11-16
  12. S12 · Cloudflare — ML for malicious domainshttps://blog.cloudflare.com/threat-detection-machine-learning-models/ · 2026-11-16
  13. S13 · RFC 9471 — Glue requirementshttps://www.rfc-editor.org/rfc/rfc9471 · 2026-11-16
  14. S14 · DNSViz — DNSSEC visualizationhttps://dnsviz.net/ · 2026-11-16
  15. S15 · CoreDNS — Prometheus metricshttps://coredns.io/plugins/metrics/ · 2026-11-16
  16. S16 · RFC 8914 — Extended DNS Errorshttps://www.rfc-editor.org/rfc/rfc8914 · 2026-11-16
  17. S17 · Kubernetes — Debugging DNS resolutionhttps://kubernetes.io/docs/tasks/administer-cluster/dns-debugging-resolution/ · 2026-11-16
  18. S18 · dnspython — official documentationhttps://www.dnspython.org/ · 2026-11-16
  19. S19 · Infoblox — Threat Defensehttps://www.infoblox.com/products/threat-defense/ · 2026-11-16
  20. S20 · Cloudflare — Advanced DNS Protectionhttps://developers.cloudflare.com/ddos-protection/advanced-ddos-systems/overview/advanced-dns-protection/ · 2026-11-16

Seguir aprendiendo

RAG · Agent architecture