685 lines
22 KiB
Markdown
685 lines
22 KiB
Markdown
# [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):**
|
|
```powershell
|
|
# 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):**
|
|
```bash
|
|
# 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**:
|
|
```bash
|
|
# 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:**
|
|
```bash
|
|
# 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):
|
|
```bash
|
|
# 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:**
|
|
```bash
|
|
# 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):**
|
|
```powershell
|
|
# 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):**
|
|
```powershell
|
|
# 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:**
|
|
```powershell
|
|
# 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:**
|
|
```bash
|
|
# 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:**
|
|
```powershell
|
|
# 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):**
|
|
```powershell
|
|
# 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:**
|
|
```powershell
|
|
# 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):**
|
|
```powershell
|
|
# 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:**
|
|
```bash
|
|
# 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):**
|
|
```bash
|
|
# 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:**
|
|
```bash
|
|
#!/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`*
|
|
```bash
|
|
#!/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`*
|
|
```powershell
|
|
# 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
|
|
```powershell
|
|
Set-NetIPInterface -Dhcp Enabled
|
|
Set-DnsClientServerAddress -ResetServerAddresses
|
|
```
|
|
- **En srv-dasu**: Remover IP local manteniendo configuración base
|
|
```bash
|
|
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
|
|
```bash
|
|
# 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):
|
|
```bash
|
|
# 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):
|
|
```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**:
|
|
```bash
|
|
# 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**:
|
|
```bash
|
|
# 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)**:
|
|
```bash
|
|
#!/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**:
|
|
```bash
|
|
# 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**:
|
|
```bash
|
|
# 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**:
|
|
```powershell
|
|
# 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**:
|
|
```bash
|
|
# 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](../plan/P2601_6.1.B%20-%20AD-Join:%20pc-dasu0%20al%20Dominio.md)
|
|
- [Nodo srv-dasu](../../nodos/srv-dasu.md)
|
|
- [Nodo pc-dasu0](../../nodos/pc-dasu0.md)
|
|
- [ADN 03 - Seguridad y Red](../../adn/03_seguridad.md)
|
|
|
|
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* |