dtic-DIIAA/docs/proy/P2601_Dasuten/proc/P2601.06.02_Comunicacion-Directa-Local.md

[PROC-2601-6.1.B] - Procedimiento de Comunicación Directa Local entre srv-dasu y pc-dasu0

1. Identificación y Objetivo

• ID: PROC-2601-6.1.B
• Responsable: Administrador de Infraestructura / Usuario Autorizado
• Objetivo: Establecer comunicación de red directa local entre srv-dasu (hypervisor Proxmox) y pc-dasu0 (PC física) cuando ambos dispositivos comparten el mismo router ISP en la oficina DASUTeN, optimizando el rendimiento y reduciendo la dependencia de Tailscale para operaciones locales.
• Frecuencia: Manual / Bajo Demanda (cuando ambos dispositivos están en la misma red física)

2. Alcance y Prerrequisitos

• Nodos Afectados:
  • srv-dasu (Hypervisor Proxmox VE - IP: 10.0.10.205 / Tailscale: 100.116.210.36)
  • pc-dasu0 (PC física Windows 10 - Tailscale: 100.65.62.44)
  • dc-dasuten (VM 100 - Controlador de Dominio - IP: 10.0.100.10)
• Sistemas: Linux (Proxmox/Debian), Windows 10, Windows Server Core
• Prerrequisitos:
  • Acceso SSH a srv-dasu con privilegios sudo
  • Acceso administrativo a pc-dasu0 (local o remoto)
  • Ambos dispositivos conectados al mismo router ISP en oficina DASUTeN
  • Tailscale operativo en ambos dispositivos (para failover)
  • Backup previo de configuraciones de red

3. Flujo de Tareas (Ejecución)

Este flujo debe seguirse secuencialmente. Utilizar iconos de estado según el adn/02_protocolo.md.

Paso	Tarea	Estado	Notas
1	Diagnóstico de Topología de Red Local	📍	Identificar configuración actual del router ISP
2	Configuración de IPs Locales en srv-dasu	⏳	Asignar IP local en subred del router
3	Configuración de IP Local en pc-dasu0	⏳	Asignar IP en misma subred
4	Pruebas de Conectividad Básica	⏳	Verificar ping bidireccional
5	Configuración de DNS Local	⏳	Apuntar a dc-dasuten via ruta local
6	Validación de AD-Join	⏳	Probar resolución de dominio
7	Configuración de Failover Tailscale	⏳	Mantener ruta Tailscale como backup
8	Scripts de Validación Automática	⏳	Crear e instalar herramientas de monitoreo

3.1 Paso 1: Diagnóstico de Topología de Red Local

Objetivo: Determinar la subred local asignada por el router ISP.

Procedimiento en pc-dasu0 (Windows):

# Obtener configuración IP actual
ipconfig /all

# Identificar:
# - Dirección IP asignada por DHCP
# - Máscara de subred
# - Gateway predeterminado
# - Servidores DNS

# Determinar rango de subred completa
$ipInfo = Get-NetIPAddress -AddressFamily IPv4 | Where-Object {$_.InterfaceAlias -like "*Ethernet*"}
$subnetMask = $ipInfo.PrefixLength
$ipAddress = $ipInfo.IPAddress
$gateway = (Get-NetRoute -DestinationPrefix "0.0.0.0/0" -AddressFamily IPv4).NextHop

# Calcular subred
$subnet = [System.Net.IPAddress]::Parse($ipAddress).GetAddressBytes()
$mask = [System.Net.IPAddress]::Parse(([System.Net.IPAddress]::Parse("255.255.255.255").GetAddressBytes() | ForEach-Object {$_ -shl (32-$subnetMask)}))
$network = [System.Net.IPAddress]::new(($subnet | ForEach-Object {$_ -band $mask.GetAddressBytes()[$i]; $i++}))

Write-Host "Subred detectada: $network/$subnetMask"
Write-Host "Gateway: $gateway"
Write-Host "IP Local: $ipAddress"

# Escanear dispositivos en la red local
arp -a | Select-String "dynamic" | ForEach-Object {
    $_.ToString().Split()[0]
} | Select-Object -First 10

Procedimiento en srv-dasu (Linux via SSH):

# Conectarse a srv-dasu via Tailscale
ssh -J root@100.116.210.36 rmonla@10.0.100.1

# Ver configuración de red actual
echo "=== Configuración de Interfaces ==="
ip addr show vmbr0
echo ""

echo "=== Tabla de Rutas ==="
ip route show
echo ""

echo "=== Información DHCP (si aplica) ==="
cat /var/lib/dhcp/dhclient.leases 2>/dev/null | grep -A5 -B5 "interface.*vmbr0" || echo "No hay leases DHCP disponibles"
echo ""

# Detectar gateway local automáticamente
GATEWAY=$(ip route show default | awk '/default/ {print $3}')
if [ -n "$GATEWAY" ]; then
    echo "Gateway detectado: $GATEWAY"
    echo "=== Probando conectividad a gateway ==="
    ping -c 4 $GATEWAY
    
    # Determinar subred del gateway
    SUBNET=$(ip route show | grep "link src" | awk '{print $1}' | head -1)
    if [ -n "$SUBNET" ]; then
        echo "Subred detectada: $SUBNET"
        
        # Escanear dispositivos en la subred local
        echo "=== Dispositivos en subred local (primeros 5) ==="
        nmap -sn $SUBNET 2>/dev/null | grep "Nmap scan report" | head -5 || \
        echo "Instale nmap para escaneo completo: sudo apt install nmap"
    fi
else
    echo "⚠️ No se detectó gateway predeterminado"
    echo "Verifique conectividad física y configuración DHCP"
fi

# Verificar si hay IP local ya configurada
echo "=== IPs locales configuradas ==="
ip addr show vmbr0 | grep -E "inet (192\.168|10\.0\.0|172\.(1[6-9]|2[0-9]|3[0-1]))"

Salida Esperada:

• Subred local identificada (ej: 192.168.1.0/24, 10.0.0.0/24)
• Gateway del router ISP
• Rango de IPs disponibles en la subred
• Dispositivos detectados en la red local
• Confirmación de que srv-dasu y pc-dasu0 están en la misma subred física

Registro de Diagnóstico:

# Crear archivo de diagnóstico
sudo tee /tmp/red-local-diagnostico-$(date +%Y%m%d).txt << EOF
=== DIAGNÓSTICO DE RED LOCAL ===
Fecha: $(date)
Hostname: $(hostname)

CONFIGURACIÓN ACTUAL:
$(ip addr show vmbr0)

TABLA DE RUTAS:
$(ip route show)

GATEWAY DETECTADO: $GATEWAY
SUBRED DETECTADA: $SUBNET

DISPOSITIVOS EN RED (si se escaneó):
$(nmap -sn $SUBNET 2>/dev/null | grep "Nmap scan report" | head -10)

RECOMENDACIÓN DE IP LOCAL:
# Usar IP fuera del rango DHCP del router
# Ejemplo: Si router asigna 192.168.1.100-200
# Usar: 192.168.1.205 para srv-dasu
# Usar: 192.168.1.100 para pc-dasu0 (si está disponible)
EOF

3.2 Paso 2: Configuración de IP Local en srv-dasu

Objetivo: Asignar IP estática en subred local manteniendo configuración existente.

Procedimiento en srv-dasu:

# 1. Backup de configuración actual
sudo cp /etc/network/interfaces /etc/network/interfaces.backup.$(date +%Y%m%d)

# 2. Editar configuración de red
sudo nano /etc/network/interfaces

Configuración Recomendada (adaptar según subred local detectada):

# Configuración actual de vmbr0 (mantener)
auto vmbr0
iface vmbr0 inet dhcp
    bridge-ports enp3s0
    bridge-stp off
    bridge-fd 0
    # Red interna para VMs (mantener)
    post-up ip addr add 10.0.100.1/24 dev vmbr0
    pre-down ip addr del 10.0.100.1/24 dev vmbr0
    # IP estática local (agregar - adaptar según subred)
    post-up ip addr add 192.168.1.205/24 dev vmbr0
    pre-down ip addr del 192.168.1.205/24 dev vmbr0

Aplicar cambios:

# 3. Reiniciar servicio de red
sudo systemctl restart networking

# 4. Verificar configuración
ip addr show vmbr0
# Debe mostrar:
# - IP DHCP (de la red facultad si está conectado)
# - 10.0.100.1/24 (red interna VMs)
# - 192.168.1.205/24 (IP local)

# 5. Probar conectividad local
ping -c 4 192.168.1.1  # Gateway del router

3.3 Paso 3: Configuración de IP Local en pc-dasu0

Objetivo: Configurar IP estática en pc-dasu0 en misma subred.

Procedimiento en pc-dasu0 (Windows):

# 1. Abrir configuración de red
ncpa.cpl

# 2. Propiedades del adaptador Ethernet -> IPv4
# Configurar:
# - IP: 192.168.1.100 (ejemplo, usar IP disponible)
# - Máscara: 255.255.255.0
# - Gateway: 192.168.1.1 (router ISP)
# - DNS Primario: 10.0.100.10 (dc-dasuten via ruta local)
# - DNS Secundario: 8.8.8.8

# 3. Aplicar cambios

Alternativa via PowerShell (remoto):

# Si se tiene acceso remoto via Tailscale
$adapter = Get-NetAdapter -Name "Ethernet"
New-NetIPAddress -InterfaceIndex $adapter.ifIndex `
  -IPAddress 192.168.1.100 `
  -PrefixLength 24 `
  -DefaultGateway 192.168.1.1

Set-DnsClientServerAddress -InterfaceIndex $adapter.ifIndex `
  -ServerAddresses ("10.0.100.10", "8.8.8.8")

3.4 Paso 4: Pruebas de Conectividad Básica

Objetivo: Validar comunicación bidireccional.

Desde pc-dasu0:

# Probar conectividad a srv-dasu
ping 192.168.1.205
ping 10.0.100.1  # Gateway interno VMs

# Probar conectividad a dc-dasuten (via srv-dasu)
ping 10.0.100.10

# Verificar ruta
tracert 10.0.100.10
# Debe mostrar: pc-dasu0 -> router -> srv-dasu -> dc-dasuten

Desde srv-dasu:

# Probar conectividad a pc-dasu0
ping -c 4 192.168.1.100

# Verificar que VMs pueden comunicarse
ping -c 4 10.0.100.10  # dc-dasuten

3.5 Paso 5: Configuración de DNS Local

Objetivo: Configurar resolución DNS directa al controlador de dominio.

En pc-dasu0:

# Verificar resolución DNS
nslookup dc-dasuten.dasuten.utnlr
# Debe resolver a 10.0.100.10

# Probar resolución inversa
nslookup 10.0.100.10
# Debe resolver a dc-dasuten.dasuten.utnlr

# Verificar registro en DNS del dominio
nslookup -type=SRV _ldap._tcp.dasuten.utnlr

Configuración de Suffix DNS (si es necesario):

# Agregar suffix DNS al adaptador
Set-DnsClientGlobalSetting -SuffixSearchList @("dasuten.utnlr")

3.6 Paso 6: Validación de AD-Join

Objetivo: Probar funcionalidad de unión al dominio.

Pruebas preliminares:

# 1. Verificar que se puede alcanzar el dominio
Test-Connection dc-dasuten.dasuten.utnlr -Count 4

# 2. Probar autenticación (sin unir aún)
Test-ComputerSecureChannel -Server dc-dasuten.dasuten.utnlr

# 3. Verificar puertos LDAP/Kerberos
Test-NetConnection dc-dasuten.dasuten.utnlr -Port 389  # LDAP
Test-NetConnection dc-dasuten.dasuten.utnlr -Port 88   # Kerberos
Test-NetConnection dc-dasuten.dasuten.utnlr -Port 445  # SMB

Procedimiento de unión al dominio (si aplica):

# Unir al dominio (solo si es necesario)
Add-Computer -DomainName "dasuten.utnlr" `
  -Credential (Get-Credential) `
  -Restart

3.7 Paso 7: Configuración de Failover Tailscale

Objetivo: Mantener Tailscale como ruta de respaldo.

Verificar estado Tailscale:

# En srv-dasu
tailscale status
# Debe mostrar: 100.116.210.36

# En pc-dasu0 (via PowerShell)
tailscale status
# Debe mostrar: 100.65.62.44

Configurar métricas de ruta (en srv-dasu):

# Verificar rutas actuales
ip route show

# Tailscale debe tener métrica más alta (menos preferida)
# La ruta local (192.168.1.0/24) debe tener métrica más baja

Script de monitoreo de conectividad:

#!/bin/bash
# /usr/local/bin/check-local-connectivity.sh
LOCAL_IP="192.168.1.100"
TAILSCALE_IP="100.65.62.44"

if ping -c 2 -W 1 $LOCAL_IP > /dev/null 2>&1; then
    echo "✅ Conectividad LOCAL activa"
    exit 0
else
    echo "⚠️  Fallo conectividad local, usando Tailscale"
    # Aquí se podrían activar reglas de failover
    exit 1
fi

3.8 Paso 8: Scripts de Validación Automática

Crear script de validación completo:

Script para srv-dasu (/usr/local/bin/validate-local-network.sh): Nota: También disponible en docs/procedimientos/scripts/diagnostico_red_local.sh

#!/bin/bash
# Script de validación de red local
LOG_FILE="/var/log/local-network-validation.log"

echo "=== Validación de Red Local $(date) ===" | tee -a $LOG_FILE

# 1. Verificar IPs locales
echo "1. Verificando IPs configuradas..." | tee -a $LOG_FILE
ip addr show vmbr0 | grep -E "192\.168\.1|10\.0\.100\.1" | tee -a $LOG_FILE

# 2. Probar conectividad a pc-dasu0
echo "2. Probando conectividad a pc-dasu0..." | tee -a $LOG_FILE
if ping -c 3 -W 2 192.168.1.100 > /dev/null 2>&1; then
    echo "✅ Ping exitoso a pc-dasu0" | tee -a $LOG_FILE
else
    echo "❌ Fallo ping a pc-dasu0" | tee -a $LOG_FILE
fi

# 3. Verificar rutas
echo "3. Verificando tabla de rutas..." | tee -a $LOG_FILE
ip route show | grep -E "192\.168\.1|10\.0\.100" | tee -a $LOG_FILE

# 4. Verificar estado Tailscale
echo "4. Verificando estado Tailscale..." | tee -a $LOG_FILE
tailscale status --json | jq -r '.Self.TailscaleIPs[0]' | tee -a $LOG_FILE

echo "=== Validación completada ===" | tee -a $LOG_FILE

Script para pc-dasu0 (C:\Scripts\Validate-LocalNetwork.ps1): Nota: También disponible en docs/procedimientos/scripts/Diagnose-LocalNetwork.ps1

# Script de validación para Windows
$LogFile = "C:\Logs\LocalNetwork-Validation.log"
$LocalIP = "192.168.1.205"  # srv-dasu
$DomainController = "10.0.100.10"

"=== Validación de Red Local $(Get-Date) ===" | Out-File -FilePath $LogFile -Append

# 1. Verificar IP local
"1. Configuración IP local:" | Out-File -FilePath $LogFile -Append
Get-NetIPAddress -AddressFamily IPv4 | Where-Object {$_.IPAddress -like "192.168.1.*"} | 
    Select-Object IPAddress, PrefixLength | Out-File -FilePath $LogFile -Append

# 2. Probar conectividad
"2. Probando conectividad:" | Out-File -FilePath $LogFile -Append
if (Test-Connection -ComputerName $LocalIP -Count 2 -Quiet) {
    "✅ Conectividad local OK" | Out-File -FilePath $LogFile -Append
} else {
    "❌ Fallo conectividad local" | Out-File -FilePath $LogFile -Append
}

# 3. Verificar DNS
"3. Verificando resolución DNS:" | Out-File -FilePath $LogFile -Append
try {
    $DnsResult = Resolve-DnsName -Name "dc-dasuten.dasuten.utnlr" -ErrorAction Stop
    "✅ DNS resuelve: $($DnsResult.IPAddress)" | Out-File -FilePath $LogFile -Append
} catch {
    "❌ Fallo resolución DNS" | Out-File -FilePath $LogFile -Append
}

# 4. Verificar puertos críticos
"4. Verificando puertos del dominio:" | Out-File -FilePath $LogFile -Append
$Ports = @(389, 88, 445, 53)
foreach ($Port in $Ports) {
    $Test = Test-NetConnection -ComputerName $DomainController -Port $Port -WarningAction SilentlyContinue
    if ($Test.TcpTestSucceeded) {
        "✅ Puerto $Port abierto" | Out-File -FilePath $LogFile -Append
    } else {
        "❌ Puerto $Port cerrado" | Out-File -FilePath $LogFile -Append
    }
}

4. Verificación y Validación

• Ping bidireccional exitoso entre pc-dasu0 (192.168.1.100) y srv-dasu (192.168.1.205)
• Resolución DNS de dc-dasuten.dasuten.utnlr a 10.0.100.10
• Conexión LDAP/Kerberos al controlador de dominio
• Tailscale operativo como respaldo (IPs: 100.116.210.36 y 100.65.62.44)
• Scripts de validación ejecutados sin errores críticos
• Resultado Esperado: ✅ Comunicación local establecida con latencia <5ms, failover Tailscale configurado, capacidad de AD-Join verificada

5. Plan de Reversión (Hombre Muerto)

Important

En caso de fallo crítico o pérdida de conectividad, seguir estos pasos inmediatamente.

1. Gatillo de Reversión:

   • Error en paso 4 (fallo ping bidireccional tras 3 intentos)
   • Pérdida completa de conectividad a internet
   • Incapacidad para acceder a recursos críticos por más de 5 minutos

2. Acciones de Reversión:

   • En pc-dasu0: Restaurar configuración DHCP automática

     Set-NetIPInterface -Dhcp Enabled
     Set-DnsClientServerAddress -ResetServerAddresses
     

   • En srv-dasu: Remover IP local manteniendo configuración base

     sudo ip addr del 192.168.1.205/24 dev vmbr0
     sudo systemctl restart networking
     

   • Forzar uso de Tailscale: Verificar que ambas máquinas están conectadas a Tailscale

     # En srv-dasu
     tailscale up --reset
     
     # En pc-dasu0 (via PowerShell si hay acceso)
     tailscale up --reset
     

3. Verificación post-reversión:

   • Confirmar conectividad via Tailscale entre nodos
   • Verificar que servicios críticos (dc-dasuten) son accesibles
   • Documentar incidente y causas raíz identificadas

---

6. Anexos Técnicos

Anexo 0: Scripts de Diagnóstico Automático

Scripts disponibles en docs/procedimientos/scripts/:

1. diagnostico_red_local.sh (para srv-dasu - Linux):

   # Copiar y hacer ejecutable
   sudo cp docs/procedimientos/scripts/diagnostico_red_local.sh /usr/local/bin/
   sudo chmod +x /usr/local/bin/diagnostico_red_local.sh
   
   # Ejecutar diagnóstico
   sudo diagnostico_red_local.sh vmbr0
   

2. Diagnose-LocalNetwork.ps1 (para pc-dasu0 - Windows PowerShell):

   # Ejecutar como administrador
   Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
   .\docs\procedimientos\scripts\Diagnose-LocalNetwork.ps1 -Detailed $true
   

Características de los scripts:

• Diagnóstico automático de topología de red
• Detección de subred local y gateway
• Verificación de conectividad a recursos críticos
• Validación de configuración DNS
• Comprobación de estado Tailscale
• Generación de reportes detallados
• Recomendaciones específicas para configuración local

Anexo A: Configuración de Red de Referencia

Topología Final Objetivo:

Router ISP (Oficina DASUTeN)
    ├── Subred Local: 192.168.1.0/24
    │   ├── srv-dasu: 192.168.1.205/24 (IP local) + 10.0.100.1/24 (gateway VMs)
    │   └── pc-dasu0: 192.168.1.100/24
    └── Conexión WAN a Internet
        └── Tailscale VPN (Failover)
            ├── srv-dasu: 100.116.210.36
            └── pc-dasu0: 100.65.62.44

Tabla de IPs Críticas:

Nodo	IP Local	IP Tailscale	IP Interna VMs	Propósito
srv-dasu	192.168.1.205	100.116.210.36	10.0.100.1	Hypervisor Proxmox
pc-dasu0	192.168.1.100	100.65.62.44	-	PC física cliente
dc-dasuten	-	-	10.0.100.10	Controlador de Dominio
sql-dasuten	-	-	10.0.100.11	SQL Server

Anexo B: Comandos de Diagnóstico Rápido

Diagnóstico de Conectividad Local:

# Desde srv-dasu
ping -c 4 192.168.1.100
traceroute 192.168.1.100
ss -tulpn | grep :22  # Verificar SSH

# Desde pc-dasu0 (PowerShell)
Test-NetConnection 192.168.1.205 -Port 22
Test-NetConnection 10.0.100.10 -Port 389
Resolve-DnsName dc-dasuten.dasuten.utnlr

Diagnóstico de Rutas:

# En srv-dasu
ip route show
ip rule show
tailscale status --json | jq '.Self.TailscaleIPs'

# En pc-dasu0
route print
Get-NetRoute -AddressFamily IPv4

Anexo C: Script de Monitoreo Automático

Script para crontab (srv-dasu):

#!/bin/bash
# /usr/local/bin/monitor-local-network.sh
LOCAL_PC="192.168.1.100"
TAILSCALE_PC="100.65.62.44"
LOG="/var/log/network-monitor.log"
ALERT_THRESHOLD=3

check_connectivity() {
    local target=$1
    local type=$2
    
    if ping -c 2 -W 1 "$target" > /dev/null 2>&1; then
        echo "$(date): ✅ $type conectividad OK a $target" >> "$LOG"
        return 0
    else
        echo "$(date): ⚠️  $type conectividad FALLIDA a $target" >> "$LOG"
        return 1
    fi
}

# Monitoreo principal
if check_connectivity "$LOCAL_PC" "LOCAL"; then
    # Conectividad local OK
    exit 0
else
    # Fallo local, verificar Tailscale
    if check_connectivity "$TAILSCALE_PC" "TAILSCALE"; then
        echo "$(date): 🔄 Cambiando a ruta Tailscale" >> "$LOG"
        # Aquí se podrían activar reglas de failover automático
    else
        echo "$(date): 🚨 FALLO CRÍTICO - Sin conectividad local ni Tailscale" >> "$LOG"
        # Notificación de alerta
    fi
fi

Configurar en crontab:

# Ejecutar cada 5 minutos
*/5 * * * * /usr/local/bin/monitor-local-network.sh

Anexo D: Solución de Problemas Comunes

Problema 1: No hay respuesta de ping entre dispositivos

• Causas posibles: Firewall bloqueando ICMP, subred incorrecta, VLANs
• Solución:

  # En srv-dasu
  sudo iptables -I INPUT -s 192.168.1.0/24 -j ACCEPT
  sudo iptables -I OUTPUT -d 192.168.1.0/24 -j ACCEPT
  
  # En pc-dasu0 (PowerShell como Admin)
  New-NetFirewallRule -DisplayName "Allow-Local-ICMP" `
    -Direction Inbound -Protocol ICMPv4 -IcmpType 8 `
    -RemoteAddress 192.168.1.0/24 -Action Allow
  

Problema 2: DNS no resuelve dc-dasuten

• Causas posibles: Ruta no configurada, firewall bloqueando puerto 53
• Solución:

  # Verificar que la ruta existe
  Test-NetConnection 10.0.100.10 -Port 53
  
  # Forzar registro DNS
  ipconfig /flushdns
  ipconfig /registerdns
  
  # Probar con nslookup especificando servidor
  nslookup dc-dasuten.dasuten.utnlr 10.0.100.10
  

Problema 3: Conflictos de IP

• Causas posibles: IP duplicada en la red
• Solución:

  # En srv-dasu
  sudo arping -c 3 -I vmbr0 192.168.1.205
  # Si hay respuesta, cambiar IP
  sudo ip addr del 192.168.1.205/24 dev vmbr0
  sudo ip addr add 192.168.1.206/24 dev vmbr0
  

Anexo E: Checklist de Implementación

Pre-Implementación:

• Backup de configuraciones de red actuales
• Documentar IPs actuales de todos los dispositivos
• Verificar que Tailscale está operativo en ambos nodos
• Comunicar ventana de mantenimiento a usuarios afectados

Implementación:

• Configurar IP local en srv-dasu (Paso 2)
• Configurar IP local en pc-dasu0 (Paso 3)
• Validar conectividad básica (Paso 4)
• Configurar DNS (Paso 5)
• Validar AD-Join (Paso 6)
• Configurar failover Tailscale (Paso 7)
• Instalar scripts de validación (Paso 8)

Post-Implementación:

• Ejecutar scripts de validación completos
• Documentar configuración final
• Probar failover manualmente
• Monitorear durante 24 horas

---

7. Referencias

1. Documentación Relacionada:

   • Plan P2601_6.1.B - AD-Join: pc-dasu0 al Dominio
   • Nodo srv-dasu
   • Nodo pc-dasu0
   • ADN 03 - Seguridad y Red

2. Scripts de Soporte:

   • docs/procedimientos/scripts/diagnostico_red_local.sh - Diagnóstico Linux
   • docs/procedimientos/scripts/Diagnose-LocalNetwork.ps1 - Diagnóstico Windows
   • Scripts de validación incluidos en este documento

3. Herramientas Utilizadas:

   • Tailscale: VPN mesh para failover
   • OpenSSH: Administración remota de srv-dasu
   • PowerShell: Automatización en Windows
   • iptables/nftables: Gestión de firewall en Linux

4. Estándares de Red:

   • RFC 1918: Direccionamiento IP privado
   • Best Practices para redes híbridas
   • Protocolos AD DS: LDAP (389), Kerberos (88), DNS (53)

---

Documento generado bajo el ADN del proyecto srv-ns8. Última actualización: $(date +%Y-%m-%d) Versión: 1.0