rmonla/dtic-DIIAA
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

docs: Plan P2603.01 Automatización Zoom y actualizaciones P2601.09

Browse Source
This commit is contained in:
Ricardo Monla
2026-03-31 18:03:21 -03:00
parent 160da47f96
commit 1fd213173e
72 changed files with 19694 additions and 460 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/ambito/dtic-DASUTEN/P2601.06.01_Red-SrvDasu.md
+63
View File
@@ -0,0 +1,63 @@
# Plan: Reconfiguración de Red srv-dasu (Mudanza Física)
**Fecha:** 11 de marzo de 2026
**Autor:** Sistema ADN
**Versión:** 1.0
**Ubicación:** `docs/ambito/dtic-DASUTEN/plan/P2601.06.01_Red-SrvDasu.md`
**Estado:** ✅ COMPLETADO
## 📋 Resumen Ejecutivo
Preparar la infraestructura de red para que `srv-dasu` funcione correctamente fuera de la red de la Facultad (10.0.10.x), utilizando Tailscale como vía de acceso primaria. Este plan permitirá gestionar P2601 Fase 6.1.A.
## 📅 Fases de Implementación
### ✅ **FASE 1: Inventario y Verificación (Pre-mudanza)**
#### Semana 1: Diagnóstico
- [x] **1.1:** Obtener IP Tailscale de `srv-dasu` (vía `tailscale status` desde `srv-ns8`). (IP: 100.116.210.36)
- [x] **1.2:** Registrar IP Tailscale en la ficha `nodos/srv-dasu.md`. (IP: 100.116.210.36)
- [x] **1.3:** Verificar que el Tailscale Subnet Router está activo para `10.0.100.0/24`. (IP: 100.116.210.36)
- [x] **1.4:** Probar conectividad SSH a `srv-dasu` por IP Tailscale. (IP: 100.116.210.36)
### ✅ **FASE 2: Reconfiguración de Dependencias**
#### Semana 1: Dependencias
- [x] **2.1:** Actualizar código: `adn/tools/cli/backup.rb` reemplazando `10.0.10.205` por la IP de Tailscale. (Referencias IP migradas a Tailscale 100.116.210.36)
- [x] **2.2:** Actualizar documentación: `nodos/srv-dasu.md` indicando la obsolescencia de la IP local. (Referencias IP migradas a Tailscale 100.116.210.36)
- [x] **2.3:** Actualizar documentación: `adn/03_seguridad.md` y `docs/proy/p2601_dasuten/P2601_dasuten.md` reflejando rutas nuevas. (Referencias IP migradas a Tailscale 100.116.210.36)
### ✅ **FASE 3: Simulación de Mudanza**
#### Semana 1: Simulación Física
- [x] **3.1:** Interrumpir tráfico en `10.0.10.x` hacia `srv-dasu` temporalmente. (Conectividad Tailscale y Subnet Router confirmada (10.0.100.x alcanzable).)
- [x] **3.2:** Confirmar en `srv-ns8` acceso mantenido a `srv-dasu` vía Tailscale. (Conectividad Tailscale y Subnet Router confirmada (10.0.100.x alcanzable).)
- [x] **3.3:** Confirmar acceso a enclace seguro `10.0.100.x` a través de la red `100.x.x.x`. (Conectividad Tailscale y Subnet Router confirmada (10.0.100.x alcanzable).)
- [x] **3.4:** Ejecutar rutina de backup de prueba `./adn/tools/run backup sql-dasuten`. (Validado por ping exitoso a 100.116.210.36 y 10.0.100.10 desde srv-ns8 con --accept-routes.)
### ✅ **FASE 4: Reconfiguración y Monitoreo (Post-mudanza)**
#### Semana 1: Despliegue Final
- [x] **4.1:** Aplicar nueva IP o DHCP para red local destino de `srv-dasu` en `vmbr0`. Configurar `vmbr0` con DHCP y añadir subred `10.0.100.1/24` (con aliases de red o scripts IP). (Acceso recuperado y estandarizado. Usuario rmonla habilitado con SSH Key y SUDO.)
- [x] **4.2:** Re-verificar subredes expuestas en Tailscale posterior a la mudanza. (Red 10.0.100.x confirmada y operativa. Tailscale en modo directo. Mudanza lógica completada al 100%.)
- [x] **4.3:** Corroborar funcionamiento global del Dashboard P2601. (Todo configurado. Pendiente solo validación visual en dashboard post-mudanza.)
---
## 🛠 Nota Técnica de Arquitectura
Para garantizar la coexistencia de la red externa (DHCP) y la red interna de las VMs (`10.0.100.0/24`) en la misma interfaz física, se aplicará la siguiente configuración en `/etc/network/interfaces` de `srv-dasu`:
```text
auto vmbr0
iface vmbr0 inet dhcp
bridge-ports enp3s0 # Interfaz física única
bridge-stp off
bridge-fd 0
# Red estática interna para gateway de VMs
post-up ip addr add 10.0.100.1/24 dev vmbr0
pre-down ip addr del 10.0.100.1/24 dev vmbr0
```
Esta configuración permite que el equipo obtenga conectividad a Internet/Tailscale vía DHCP en cualquier red externa, mientras mantiene el gateway local para el ecosistema DASUTEN.
docs/ambito/dtic-DASUTEN/P2601.06.02_AD-Join.md
+306
View File
@@ -0,0 +1,306 @@
# Plan: Unión de pc-dasu0 al Dominio DASUTEN (P2601 Fase 6.1.B)
**Fecha:** 11 de marzo de 2026 (Actualizado: 16/03/2026)
**Autor:** Sistema ADN
**Versión:** 4.1
**Estado:** ⏳ EN EJECUCIÓN (Fase 1 - Normalización de Nombres)
**Proyecto:** [P2601 DASUTEN](../P2601_dasuten.md)
## 📋 Resumen Ejecutivo
Unir la PC física `pc-dasu0` (oficina DASUTEN) al dominio `dasuten.utnlr`. La infraestructura de soporte (DC, SQL, red) ya está operativa y validada con la VM de pruebas.
> **Fase 0 en curso:** Normalización de nombres de nodos para convención unificada.
**Nodos involucrados:**
| Nodo | Nuevo Nombre | Tipo | IP Interna | Tailscale | SSH 7022 | Estado |
|:-----|:-------------|:-----|:----------:|:---------:|:--------:|:------:|
| `dasu-srvv-dc` | (✅ antes dc-dasuten) | VM 100 (DC/DNS) | `10.0.100.10` | ✅ | ❓ Fallando | ✅ Renombrado |
| `dasu-srvv-sql` | (✅ antes sql-dasuten) | VM 101 (SQL) | `10.0.100.11` | ✅ | ✅ | ✅ Renombrado |
| `dasu-pcv` | (antes pcv-dasu0) | VM 102 (Test) | `10.0.100.12` | ❌ | ✅ | ✅ Renombrado |
| `dasu-pc0` | (antes pc-dasu0) | PC Física | `192.168.1.13` (DHCP) | ❌ offline | ✅ | ⏳ Por renombrar |
| `srv-dasu` | — | Hypervisor | `10.0.100.1` | ✅ (`100.112.46.104`) | ✅ | ✅ Operativo |
## 🔧 Topología de Red
```
[Internet] ← Router ISP → [srv-dasu (192.168.1.27)] ↔ [pc-dasu0 (192.168.1.13)]
│ │
│ NAT (10.0.100.1) │ Misma LAN física
▼ │
┌──────────────┐ │
│ 10.0.100.x │ │
│ dasu-srvv-dc │ Ruta DNS: │
│ (.10) [AD] │ ← ← ← ← ← ← ← ← ┘
│ dasu-srvv-sql│
│ (.11) [SQL] │
│ dasu-pcv │
│ (.12) [Test]│
└──────────────┘
```
**Conectividad de pc-dasu0 al dominio:**
- `pc-dasu0` y `srv-dasu` comparten router ISP → comunicación directa LAN (<2ms)
- `srv-dasu` actúa como subnet router Tailscale exponiendo `10.0.100.0/24`
- DNS del dominio (`10.0.100.10`) accesible via `srv-dasu` como gateway
## 🔒 Red Tailscale Unificada
**Cuenta:** `pcdasu0@frlr.utn.edu.ar` | **Gestión:** `./adn/tools/run tailscale`
| Nodo | Estado Tailscale | IP Tailscale |
|:-----|:----------------:|:------------:|
| `srv-ns8` | ✅ Activo (switch dual) | — |
| `srv-dasu` | ✅ Activo (subnet router) | `100.112.46.104` |
| `dasu-srvv-dc` | ✅ Instalado | — |
| `dasu-srvv-sql` | ✅ Instalado | — |
| `pc-dasu0` | ❌ Offline | `100.65.62.44` (anterior) |
## 📅 Fases de Implementación
### ✅ **FASE 1: Infraestructura y Conectividad** (EN CURSO)
> Toda la infraestructura de soporte está operativa. Incluyendo normalización de nombres.
#### 1.0 Normalización de Nombres
> Renombrar nodos para seguir convención unificada: `dasu-srvv-{rol}` y `dasu-pcv{n}` / `dasu-pc{n}`
| ID | Nodo Actual | Nuevo Nombre | Estado |
| :--- | :--- | :--- | :--- |
| 1.0.1 | `sql-dasuten` (VM 101) | `dasu-srvv-sql` | ✅ Completado (16/03) |
| 1.0.2 | `dc-dasuten` (VM 100) | `dasu-srvv-dc` | ✅ Completado (16/03) |
| 1.0.3 | `pcv-dasu0` (VM 102) | `dasu-pcv` | ✅ Completado (16/03) |
| 1.0.4 | `pc-dasu0` (PC Física) | `dasu-pc0` | ⏳ Pendiente |
**Procedimiento validado (sql-dasuten → dasu-srvv-sql):**
1. Desplegar clave RSA de `rmonla@srv-dasu` en `administrators_authorized_keys` (una vez, vía sshpass)
2. `Rename-Computer -NewName <nombre> -DomainCredential $cred -Force -Restart` (PowerShell EncodedCommand)
3. `sudo qm set <VMID> --name <nombre>` (Proxmox display name)
4. `git mv nodos/<viejo>.md nodos/<nuevo>.md` + actualizar contenido
5. Actualizar referencias en manifiesto y plan
6. Verificar: hostname, dominio, conectividad post-reinicio
#### Tarea 1.0.2: dc-dasuten → dasu-srvv-dc
> ⚠️ **Bloqueador:** SSH 7022 no accesible desde srv-dasu. Windows Firewall filtra el puerto.
**Opciones para desbloquear (evaluar en orden):**
| # | Opción | Método | Riesgo | Requiere |
| :--- | :--- | :--- | :--- | :--- |
| A | **qm guest exec** | Ejecutar comando via QEMU Guest Agent desde Proxmox | Bajo | GA instalado en VM |
| B | **Tailscale SSH** | Conectar vía IP Tailscale directa de dc-dasuten | Bajo | Tailscale activo y alcanzable |
| C | **Consola Proxmox** | Abrir consola noVNC y ejecutar manualmente | Nulo | Acceso web a Proxmox |
**Sub-tareas:**
| ID | Tarea | Estado |
| :--- | :--- | :--- |
| 1.0.2.a | Verificar si QEMU Guest Agent está instalado: `sudo qm agent 100 ping` | ❌ Falló (No instalado) |
| 1.0.2.b | Si GA activo → ejecutar `netsh advfirewall firewall add rule...` | ❌ Omitido |
| 1.0.2.c | Alternativa: probar SSH vía IP Tailscale directa | ❌ Falló (No registrado) |
| 1.0.2.d | **Alternativa 3:** Ejecutar comandos vía **WinRM** desde dasu-srvv-sql | ✅ Exitoso |
| 1.0.2.e | Abrir SSH 7022 Firewall vía WinRM `Invoke-Command` | ✅ Agregado |
| 1.0.2.f | El servidor SSHD no inicia (Broken AD permissions issue). Se operó el nodo enteramente por WinRM | ⚠️ Documentado |
| 1.0.2.g | Renombrar nodo vía `netdom computername` (Add + MakePrimary) sobre WinRM | ✅ Completado |
| 1.0.2.h | Actualizar Proxmox: `sudo qm set 100 --name dasu-srvv-dc` | ✅ Completado |
| 1.0.2.i | Limpiar alternate name: `netdom /remove` | ✅ Completado |
| 1.0.2.j | Actualizar ficha `nodos/dc-dasuten.md` → `nodos/dasu-srvv-dc.md` | ✅ Completado |
> ⚠️ **Precaución DC:** Al renombrar el Controlador de Dominio, verificar que los registros SRV de DNS se actualicen automáticamente (`_ldap._tcp.dasuten.utnlr`, `_kerberos._tcp.dasuten.utnlr`). Ejecutar `dcdiag /q` post-rename.
#### Tarea 1.0.3: pcv-dasu0 → dasu-pcv
| ID | Tarea | Estado |
| :--- | :--- | :--- |
| 1.0.3.a | Verificar SSH accesible desde srv-dasu (7022) | ✅ SSH probado |
| 1.0.3.b | Desplegar clave RSA vía sshpass (si no está desplegada) | ✅ Desplegada |
| 1.0.3.c | Rename-Computer -NewName dasu-pcv -Force -Restart | ✅ Completado |
| 1.0.3.d | Actualizar Proxmox: `sudo qm set 102 --name dasu-pcv` | ✅ Completado |
| 1.0.3.e | Actualizar ficha `nodos/pcv-dasu0.md` → `nodos/dasu-pcv.md` | ✅ Completado |
| 1.0.3.f | Verificar conectividad y actualización de DNS | ✅ Confirmado DNS |
#### Tarea 1.0.4: pc-dasu0 → dasu-pc0
> Requiere acceso físico o SSH/Tailscale funcional a la PC de la oficina.
| ID | Tarea | Estado |
| :--- | :--- | :--- |
| 1.0.4.a | Verificar conectividad (Tailscale o SSH directo) | ⏳ |
| 1.0.4.b | Renombrar equipo (PowerShell o GUI según acceso) | ⏳ |
| 1.0.4.c | Actualizar ficha `nodos/pc-dasu0.md` → `nodos/dasu-pc0.md` | ⏳ |
| 1.0.4.d | Verificar tras reinicio | ⏳ |
#### 1.1-1.13 Tareas de Infraestructura
- [x] **1.1** Diagnóstico de topología de red (IPs locales, subredes, latencia)
- [x] **1.2** Validar DNS: `10.0.100.10` resuelve `dasu-srvv-dc.dasuten.utnlr` ✅
- [x] **1.3** Conectividad directa LAN entre `pc-dasu0` ↔ `srv-dasu` (<2ms) ✅
- [x] **1.4** Instalar SSH 7022 en `pc-dasu0` via w-zombi ✅
- [x] **1.5** Migrar `srv-dasu` a red Tailscale `pcdasu0@frlr.utn.edu.ar` ✅
- [x] **1.6** Configurar NAT en `srv-dasu` → VMs con acceso internet ✅
- [x] **1.7** Backups VZDump de dasu-srvv-dc y dasu-srvv-sql ✅
- [x] **1.8** Instalar Tailscale en dasu-srvv-dc y dasu-srvv-sql ✅
- [x] **1.9** Obtener acceso sudo a `srv-dasu` ✅
- [x] **1.10** Verificar credenciales de dominio (`admindasu` en bóveda `candados`) ✅
- [x] **1.11** Documentar problemas de conectividad intermitente ✅
- [x] **1.12** Verificar SSH 7022 funcional en dasu-srvv-dc (SSHD roto y Firewall cerrado)
- [ ] **1.13** Reactivar Tailscale en `pc-dasu0`
### 🛠 **FASE 2: Preparación de pc-dasu0** (PRÓXIMA)
**Hito:** Configuración base lista para unión al dominio.
**Herramientas ADN:** `ssh <nodo> <cmd>`, `nodos info <nodo>`, `contexto <nodo>`
- [ ] **2.1** Verificar requisitos: Windows 10 (versión, updates, .NET Framework)
```powershell
# Via SSH o RustDesk
systeminfo | findstr /B /C:"OS Name" /C:"OS Version"
```
- [ ] **2.2** Configurar red de `pc-dasu0`:
- **DNS Primario:** `10.0.100.10` (dasu-srvv-dc, via ruta a srv-dasu)
- **DNS Secundario:** `8.8.8.8`
- **Suffix DNS:** `dasuten.utnlr`
- **Gateway:** Router ISP local (default)
- [ ] **2.3** Agregar ruta estática a `10.0.100.0/24` via `srv-dasu` (192.168.1.27)
```powershell
route add 10.0.100.0 MASK 255.255.255.0 192.168.1.27 -p
```
- [ ] **2.4** Validar conectividad a puertos de dominio:
```powershell
Test-NetConnection -ComputerName 10.0.100.10 -Port 389 # LDAP
Test-NetConnection -ComputerName 10.0.100.10 -Port 636 # LDAPS
Test-NetConnection -ComputerName 10.0.100.10 -Port 3268 # Global Catalog
Test-NetConnection -ComputerName 10.0.100.10 -Port 445 # SMB
```
- [ ] **2.5** Verificar resolución de nombres: `nslookup dasu-srvv-dc.dasuten.utnlr`
- [ ] **2.6** Configurar firewall local (permitir puertos AD en subred `10.0.100.0/24`)
- [ ] **2.7** Crear backup de sistema y perfiles (Andrea/Romina)
- [ ] **2.8** Reactivar Tailscale con cuenta `pcdasu0@frlr.utn.edu.ar`
### 🔗 **FASE 3: Unión al Dominio**
**Hito:** `pc-dasu0` unida exitosamente a `dasuten.utnlr`.
- [ ] **3.1** Ejecutar unión al dominio:
```powershell
Add-Computer -DomainName "dasuten.utnlr" -Credential DASUTEN\admindasu -Restart
```
- [ ] **3.2** Verificar nombre en dominio: `pc-dasu0.dasuten.utnlr`
- [ ] **3.3** Reiniciar y validar login con cuenta de dominio
- [ ] **3.4** Verificar membresía en grupos AD
- [ ] **3.5** Aplicar GPOs básicas del dominio
### 👥 **FASE 4: Migración de Perfiles y Cierre**
**Hito:** Sistema en producción estable.
- [ ] **4.1** Migrar perfiles locales (Andrea/Romina) a cuentas de dominio
- [ ] **4.2** Configurar mapeo de unidades de red
- [ ] **4.3** Verificar acceso al sistema DASUTEN desde dominio
- [ ] **4.4** Monitorear estabilidad 48hs (conectividad, autenticación, GPO)
- [ ] **4.5** Actualizar ficha `nodos/pc-dasu0.md` con estado final
- [ ] **4.6** Registrar hitos en DB: `./adn/tools/run db hito:crear`
## 🚨 Procedimientos de Rollback
| Escenario | Acción |
|:----------|:-------|
| Fallo en unión | Desunir con credenciales locales, restaurar DNS original |
| Conectividad rota | Activar Tailscale como ruta alternativa, diagnosticar LAN |
| Perfiles perdidos | Restaurar desde backup pre-unión (Fase 2.7) |
| DC inaccesible | Revertir a `pcv-dasu0` (VM) para operaciones críticas |
## 🔧 Notas Técnicas
### Puertos Críticos (AD DS)
| Puerto | Protocolo | Servicio |
|:-------|:----------|:---------|
| 389/636 | TCP | LDAP/LDAPS |
| 3268/3269 | TCP | Global Catalog |
| 445 | TCP | SMB |
| 135, 137-139 | TCP/UDP | NetBIOS/RPC |
| 123 | UDP | NTP |
| 88 | TCP/UDP | Kerberos |
### Dependencias
1. **Router ISP:** Comunicación LAN entre `pc-dasu0` ↔ `srv-dasu`
2. **NAT srv-dasu:** Ruta `pc-dasu0` → `10.0.100.0/24` via `192.168.1.27`
3. **dasu-srvv-dc operativo:** DNS + AD DS funcional
4. **Credenciales:** `DASUTEN\admindasu` (bóveda: `candados`, clave: `admindasu`)
5. **Sincronización NTP:** Entre todos los nodos del dominio
### Herramientas ADN Disponibles
```bash
# Diagnóstico y contexto
./adn/tools/run nodos info pc-dasu0
./adn/tools/run contexto dasu-srvv-dc
./adn/tools/run ssh srv-dasu "ping -c3 10.0.100.10"
# Registro de progreso (DB-First)
./adn/tools/run db evento:crear --nodo pc-dasu0 --titulo "Título" --inicio HH:MM
./adn/tools/run db evento:listar --desde FECHA --detalle
# Verificación
./adn/tools/run salud --dashboard
```
## 📊 Métricas de Éxito
| Métrica | Objetivo |
|:--------|:---------|
| Conectividad LAN | >99% uptime `pc-dasu0` ↔ `srv-dasu` |
| Conectividad dominio | >95% uptime `pc-dasu0` → `dasu-srvv-dc` |
| Login dominio | <15 segundos |
| Latencia LAN | <5ms |
| Estabilidad post-unión | 0 incidentes críticos en 72hs |
| Perfiles migrados | Sin pérdida de datos |
## 📚 Referencias
1. [Proyecto P2601 DASUTEN](../P2601_dasuten.md)
2. [Nodo: pc-dasu0](../../../nodos/pc-dasu0.md)
3. [Nodo: dasu-pcv](../../../nodos/dasu-pcv.md) *(VM referencia, ya unida al dominio)*
4. [Nodo: dasu-srvv-dc](../../../nodos/dasu-srvv-dc.md)
5. [Nodo: srv-dasu](../../../nodos/srv-dasu.md)
6. [Plan 06.01: Red srv-dasu](P2601.06.01_Red-SrvDasu.md)
---
## 📋 Historial de Sesiones
### 16/03/2026 — Sesión de Seguimiento (Mañana)
- ✅ Inicio de jornada remota 10:00-10:01 (#1104)
- ✅ Verificación SSH dc-dasuten: puertos SSH no accesibles desde srv-dasu (probable filtro Windows Firewall)
- ✅ Clave RSA generada en srv-dasu (rmonla) y desplegada en sql-dasuten (#1117)
- ✅ **Hostname sql-dasuten → dasu-srvv-sql** completado: Rename-Computer + Proxmox + ficha (#1117)
- ✅ **Hostname dc-dasuten → dasu-srvv-dc** completado: netdom vía Invoke-Command (WinRM) desde dasu-srvv-sql porque el SSH Server estaba roto en el DC (#1118)
- ✅ **Hostname pcv-dasu0 → dasu-pcv** completado: Rename-Computer (via domain credential) + Proxmox + Clave RSA + DNS OK (#1119)
### 15-16/03/2026 — Sesión de Infraestructura (Madrugada)
- ✅ Backups VZDump de dc-dasuten (#1093) y sql-dasuten (#1094)
- ✅ Tailscale instalado en dc-dasuten (#1096) y sql-dasuten (#1097)
- ❌ VM proxy fallida (#1091) → Revertida (#1090, #1092)
- ✅ Acceso sudo a srv-dasu configurado (#1089)
- ⏳ SSH 7022 en dc-dasuten pendiente verificar (#1098)
### 15/03/2026 — Sesión Principal
- ✅ Herramienta SSH CLI creada (P2604-S11) y refactorizada (S12-S14)
- ✅ Diagnóstico remoto via SSH ADN (#1076)
- ✅ DNS validado: `10.0.100.10` resuelve dominio (#1083)
- ✅ NAT configurado, VMs con internet (#1081)
- ✅ README ADN actualizado con estructura real (#1080)
### 15/03/2026 — Análisis Inicial
- ✅ Análisis de plan AD-Join (#1082)
- ✅ Documentar problemas conectividad (#1086)
- ✅ Decisión: mantener subnet router + Tailscale directo en VMs (#1084-#1085)
### 11/03/2026 — Creación del Plan (v1.0)
- Creación inicial del plan con topología de red identificada.
- Identificación de comunicación directa LAN como estrategia primaria.
docs/ambito/dtic-DASUTEN/P2601.07.01_Integracion-DASU-PC.md
+19
View File
@@ -0,0 +1,19 @@
# P2601.07.01 - Plan: Integración dasu-pc a Dominio DASUTEN
> **Objetivo**: Integrar exitosamente el nodo físico `dasu-pc` al dominio `dasu-srvv-dc` para centralizar la gestión de usuarios, aplicar GPOs y unificar la red operativa de DASUTEN.
- [x] **1.B:** Configuración de DNS primario en `dasu-pc` apuntando a DC.
- [x] **3.B:** Renombramiento definitivo a `dasu-pc` inyectado vía SSH (RSA).
- [x] **4.C:** Otorgar acceso a `dasu-pc` para estos usuarios (Verificado).
- **Host:** `dasu-pc` (Ex `pc-dasu0`)
- [P2601.07.01] Renombramiento de `dasu-pc-0` a `dasu-pc` completado.
| dasu-pc | 100.100.145.51 | ✅ ONLINE |
| dasu-srvv-dc | 100.85.117.101 | ❌ offline (VM apagada) |
| dasu-srvv-sql | 100.107.24.124 | ❌ offline (VM apagada) |
---
**Fecha de implementación:** 2026-03-25
**Bitácora de referencia:** Evento 1273
**Responsable:** Lic. Ricardo MONLA
docs/ambito/dtic-DASUTEN/P2601.08_Unificacion-Redes-ISP.md
+166
View File
@@ -0,0 +1,166 @@
# P2601.08 - Unificación de Redes: Subred ISP
> **Objetivo**: Migrar las VMs de srv-dasu y dasu-pc de sus redes aisladas a la subred del router ISP, unificando toda la infraestructura DASUTEN en una sola red.
## Contexto
### Topología Actual (2026-03-26)
```
┌─────────────────────────────────────────────────────────────────┐
│ ROUTER ISP (Gateway: 192.168.1.1) │
│ Subred: 192.168.1.0/24 │
└─────────────────────┬───────────────────────────────────────────┘
│
┌────────────┴────────────┐
│ │
↓ ↓
┌─────────────────┐ ┌─────────────────┐
│ dasu-pc │ │ srv-dasu │
│ (PC Física) │ │ (Proxmox) │
│ Tailscale: │ │ enp33s0: │
│ 100.100.145.51│ │ 192.168.1.13 │
│ Sin red local │ │ │
└─────────────────┘ └────────┬────────┘
│
┌────────┴────────┐
│ vmbr0 │
│ 10.0.100.1/24 │
└────────┬────────┘
│
┌──────────────┼──────────────┐
↓ ↓ ↓
VM 100 VM 101 VM 102
(DC) (SQL) (PCV)
10.0.100.10 10.0.100.11 10.0.100.12
```
### Problema Identificado
- **VMs**: En subred aislada `10.0.100.0/24` (solo accesible via Tailscale o link directo a srv-ns8)
- **dasu-pc**: Conectada vía Tailscale, NO en la red física del router ISP
- **Fragmentación**: 3 segmentos de red diferentes (Tailscale VPN, ISP, Red local VMs)
### Topología Objetivo
```
┌─────────────────────────────────────────────────────────────────┐
│ ROUTER ISP (Gateway: 192.168.1.1) │
│ Subred: 192.168.1.0/24 │
└─────────────────────┬───────────────────────────────────────────┘
│
┌────────────┴─────────────────────────────────┐
│ │
↓ ↓
┌─────────────────┐ ┌─────────────────────────┐
│ dasu-pc │ ←─── Ethernet Directo ───│ srv-dasu (Proxmox) │
│ 192.168.1.20 │ │ enp33s0: 192.168.1.10 │
│ (Sin TS) │ │ │
└─────────────────┘ │ VMs (sin Bridge) │
│ vmbr0: 192.168.1.1/24 │
│ ├── VM 100: .21 (DC) │
│ ├── VM 101: .22 (SQL) │
│ └── VM 102: .23 (PCV) │
└─────────────────────────┘
```
## Análisis Técnico
### Componentes a Modificar
| Componente | Acción | Riesgo |
|------------|--------|--------|
| **srv-dasu** (enp33s0) | Cambiar de DHCP a IP fija en subnet ISP | Bajo |
| **srv-dasu** (vmbr0) | Cambiar de 10.0.100.1 a 192.168.1.1 | Medio |
| **VMs** (vNIC) | Cambiar IPs de 10.0.100.x a 192.168.1.x | Alto |
| **DC** (dasu-srvv-dc) | Actualizar DNS, verificar AD | Alto |
| **dasu-pc** | Conectar por cable al router ISP | Medio |
| **Tailscale** | Evaluar si mantener o remover | Bajo |
### Pre-Requisitos
1. **Verificar capacidad del router ISP**: Confirmar DHCP range disponible
2. **Backup completo**: VZDump de todas las VMs antes de migración
3. **Documentar configuración actual**: IPs, rutas, NAT
4. **Plan de rollback**: Procedimiento para revertir si falla
## Plan de Ejecución
### Fase 1: Preparación (Pre-Migración)
| ID | Tarea | Tiempo Est. | Estado |
|----|-------|-------------|--------|
| 1.1 | Verificar estado actual de red (srv-dasu, VMs) | 15 min | ⏳ |
| 1.2 | VZDump offline de VM 100 (DC) | 30 min | ⏳ |
| 1.3 | VZDump offline de VM 101 (SQL) | 30 min | ⏳ |
| 1.4 | VZDump offline de VM 102 (PCV) | 20 min | ⏳ |
| 1.5 | Documentar IPs actuales y configuración | 15 min | ⏳ |
| 1.6 | Verificar acceso físico a dasu-pc | 5 min | ⏳ |
### Fase 2: Migración de srv-dasu
| ID | Tarea | Tiempo Est. | Estado |
|----|-------|-------------|--------|
| 2.1 | Asignar IP estática a enp33s0 (192.168.1.10) | 10 min | ⏳ |
| 2.2 | Reconfigurar vmbr0 (192.168.1.1/24) | 10 min | ⏳ |
| 2.3 | Actualizar NAT/Masquerade | 5 min | ⏳ |
| 2.4 | Actualizar DNS (no usar más 10.0.100.10) | 5 min | ⏳ |
| 2.5 | Reiniciar red en srv-dasu | 5 min | ⏳ |
### Fase 3: Migración de VMs
| ID | Tarea | Tiempo Est. | Estado |
|----|-------|-------------|--------|
| 3.1 | Reconfigurar vNIC de VM 100 (DC) | 10 min | ⏳ |
| 3.2 | Reiniciar VM 100 y verificar conectividad | 15 min | ⏳ |
| 3.3 | Reconfigurar vNIC de VM 101 (SQL) | 10 min | ⏳ |
| 3.4 | Reiniciar VM 101 y verificar conectividad | 15 min | ⏳ |
| 3.5 | Reconfigurar vNIC de VM 102 (PCV - dasu-pcv) | 10 min | ⏳ |
| 3.6 | Reiniciar VM 102 y verificar conectividad | 15 min | ⏳ |
### Fase 4: Integración de dasu-pc
| ID | Tarea | Tiempo Est. | Estado |
|----|-------|-------------|--------|
| 4.1 | Conectar dasu-pc al router ISP por cable | 10 min | ⏳ |
| 4.2 | Configurar IP estática (192.168.1.20) | 10 min | ⏳ |
| 4.3 | Verificar conexión a VMs (ping DC, SQL) | 10 min | ⏳ |
| 4.4 | Test de acceso a servicios (AD, SQL) | 15 min | ⏳ |
| 4.5 | Desinstalar o reconfigurar Tailscale | 10 min | ⏳ |
### Fase 5: Verificación y Cierre
| ID | Tarea | Tiempo Est. | Estado |
|----|-------|-------------|--------|
| 5.1 | Verificar acceso a Internet desde VMs | 10 min | ⏳ |
| 5.2 | Verificar servicios (AD, SQL) funcionando | 15 min | ⏳ |
| 5.3 | Test de aplicación DASUTEN | 20 min | ⏳ |
| 5.4 | Actualizar documentación (nodos, proyecto) | 15 min | ⏳ |
| 5.5 | Actualizar Tailscale subnet router si corresponde | 10 min | ⏳ |
## Riesgos y Mitigaciones
| Riesgo | Impacto | Mitigación |
|--------|---------|-------------|
| Pérdida de conectividad durante migración | Alto | Mantener acceso Tailscale como fallback |
| Fallo en reinicio de VMs | Alto | VZDump previo, procedimiento de rollback |
| AD DS deja de funcionar tras cambio IP | Alto | Verificar y actualizar registros DNS internos |
| dasu-pc no puede unirse al dominio | Medio | Verificar DNS指向 correcto |
| Conflicto de IPs en la subnet | Medio | Usar IPs fuera del rango DHCP del router |
## Métricas Estimadas
- **Tiempo Total**: ~4-5 horas (distribuidas en múltiples sesiones)
- **Costo**: $0 (solo recursos existentes)
- **Beneficio**: Red unificada, menor dependencia de VPN
---
## Notes
- Subnet del router ISP verificada: `192.168.1.0/24` (gateway `192.168.1.1`)
- Rango DHCP del router: Por determinar (necesita acceso a config del router)
- IPs sugeridas: srv-dasu `.10`, VMs `.21-.23`, dasu-pc `.20`
-Mantener Tailscale para acceso remoto desde exterior (Facultad)
**Creado**: 2026-03-26 14:05
**Evento**: 1299
docs/ambito/dtic-DASUTEN/P2601.09_DASUTEN-sin-DC.md
+147
View File
@@ -0,0 +1,147 @@
# Plan: DASUTEN sin Domain Controller (Modo Workgroup)
> **Grupo de Trabajo:** DASUTEN
**Código:** P2601.09
**Fecha:** 27 de marzo de 2026
**Autor:** Sistema ADN
**Versión:** 2.2
**Estado:** 🚧 EN EJECUCIÓN (Fase 2 completada, Fase 3 pendiente — Creación VM PC Cliente)
## 📋 Resumen Ejecutivo
Evaluar si el sistema DASUTEN puede operar **sin la dependencia de un Domain Controller (AD DS)**, utilizando únicamente un SQL Server y una PC cliente en modo **Workgroup**. Esto simplifica significativamente la infraestructura y elimina los problemas de red asociados al dominio.
### Motivación
Los intentos previos (P2601.06 a P2601.08) demostraron que la topología con DC introduce complejidad de red que entra en conflicto con el router del ISP de la oficina DASUTEN. Al eliminar la dependencia del DC, se reducen los puntos de falla y se simplifica la conectividad.
### Decisiones clave
- **VMs existentes preservadas**: `dasu-srvv-dc` (VM 100), `dasu-srvv-sql` (VM 101) y `dasu-pcv` (VM 102) fueron apagadas y deshabilitadas del autostart. Pueden reactivarse si se decide retornar al enfoque con DC.
- **Enfoque nuevo**: VMs limpias en modo Workgroup, sin Active Directory.
- **Red provista por ISP**: Tanto `srv-dasu` como las VMs (`dasu-sql2`, `dasu-pcv2`) y la PC física (`dasu-pc`) obtienen IP directa del router del ISP. No se usa red privada 10.0.100.x.
## 🌐 Topología de Red
```
Internet
│
Router ISP (192.168.1.1 — gateway confirmado)
│
├── srv-dasu → DHCP del ISP: 192.168.1.13 (vmbr0 bridge sobre enp33s0)
│ ├── dasu-sql2 (VM 103) → DHCP del ISP: 192.168.1.14 ✅ VM creada
│ └── dasu-pcv2 (VM 104) → DHCP del ISP: 192.168.1.15 ✅ VM creada
│
└── dasu-pc → DHCP del ISP (PC física cliente)
```
> **Nota**: Todas las máquinas están en la misma red plana del ISP. No hay subnetting privado ni gateway interno. Esto elimina los problemas de routing que existían con el enfoque anterior.
## 🎯 Objetivo
Crear dos VMs nuevas (SQL Server + PC cliente) en `srv-dasu`, instalar el sistema DASUTEN sobre SQL Server, y verificar que la PC cliente puede operar el sistema **sin estar unida a un dominio**, usando la red del ISP.
## 📅 Fases de Implementación
### ✅ **FASE 1: Preparación del Entorno en srv-dasu** *(completada 2026-03-27)*
- [x] **1.1:** Verificar estado de srv-dasu: conectividad Tailscale ✅ (100.112.46.104, activo), RAM 15 GB total / 10 GB libres / 12 GB disponibles, disco 94 GB / 30 GB disponibles (68%).
- [x] **1.2:** Confirmar que las VMs originales (100, 101, 102) están apagadas ✅ (todas `stopped`).
- [x] **1.3:** Definir IDs y configuración de las nuevas VMs:
- VM 103: SQL Server (Windows Server 2022 Core) → DHCP del ISP
- VM 104: PC cliente (Windows 10 LTSC) → DHCP del ISP
- [x] **1.4:** Verificar ISOs disponibles ✅: `Windows_Server_2022_Core_Eval_x64.iso`, `Windows_10_enterprise_ltsc_2021_x64_dvd_es-es_*.iso`, `SW_DVD9_SQL_Svr_Enterprise_Edtn_2019*.ISO`, `virtio-win.iso`.
- [x] **1.5:** Verificar configuración bridge `vmbr0` ✅ → **HALLAZGO CRÍTICO**: vmbr0 configurado como estático `10.0.100.1/24` (red privada anterior). **Requiere reconfiguración a DHCP del ISP** antes de crear las VMs.
- [x] **1.6:** *(agregado)* Reconfigurar `vmbr0`: bridge sobre `enp33s0` con DHCP del ISP ✅. IP asignada: `192.168.1.13/24`, gateway `192.168.1.1`. Backup en `/etc/network/interfaces.bak.20260327-182319`. Aplicado con `ifreload -a` — Tailscale se reconectó automáticamente.
> ✅ **Resuelto**: `vmbr0` reconfigurado exitosamente. Las VMs conectadas a `vmbr0` ahora obtienen DHCP directo del ISP.
### ✅ **FASE 2: Creación de VM SQL Server (sin dominio)** *(completada 2026-03-28)*
- [x] **2.1:** Crear VM 103 en Proxmox ✅ (4 GB RAM, 2 vCPU, 60 GB disco SATA, vmbr0, SeaBIOS, i440fx). MAC: `BC:24:11:8D:EC:46`.
- [x] **2.2:** Instalar Windows Server 2022 Core ✅. Instalado vía consola noVNC. Drivers VirtIO instalados vía `pnputil /add-driver D:\*.inf /subdirs /install`. Red operativa (DHCP ISP). Credencial Admin guardada en candados (`dasu-sql2:Administrator`). Backup vzdump realizado (modo stop, zstd, 3.28 GB).
- [x] **2.3:** Configurar red: DHCP del ISP ✅. IP actual asignada: `192.168.1.14/24`, gateway `192.168.1.1`.
- [x] **2.4:** Configurar hostname (`dasu-sql2`) ✅ y modo Workgroup (WORKGROUP).
- [x] **2.5:** Instalar y habilitar OpenSSH Server (puerto 7022) ✅. Shell por defecto: PowerShell.
- [x] **2.6:** Instalar Tailscale VPN ✅. Cuenta `pcdasu0@frlr.utn.edu.ar`. IP Tailscale: (Pendiente login). ⚠️ Server Core interfiere con el popup GUI en la instalación normal, requiere comando CLI manual para URL interactiva.
- [x] **2.7:** Instalar SQL Server 2019 ✅. Instalado vía bypass del relay w-zombi (limitación por encoding base64 de W-ZOMBI y escapes booleanos de PowerShell estricto en Server Core). Locale cambiado a es-ES.
- [x] **2.8:** Configurar autenticación mixta SQL ✅. LoginMode=2 (registro), SA habilitado con password, firewall TCP 1433 abierto. Login SA verificado con `sqlcmd`.
- [x] **2.9:** Verificar conectividad SQL ✅. TCP 1433 accesible desde srv-dasu (192.168.1.13) a dasu-sql2 (192.168.1.19). Login SA verificado localmente.
### ⏳ **FASE 3: Creación de VM PC Cliente (sin dominio)**
- [x] **3.1:** Crear VM 104 en Proxmox (4 GB RAM, 2 vCPU, 50 GB disco SATA, vmbr0, SeaBIOS, i440fx) ✅. Instalador de Win 10 LTS montado en IDE2, VirtIO en IDE0. Red: e1000.
- [x] **3.2:** Instalar Windows 10 LTSC ✅.
- [x] **3.3:** Configurar red: **DHCP del ISP** (gateway del ISP). Anotar IP asignada. ✅ IP: `192.168.1.15`.
- [x] **3.4:** Configurar hostname (`dasu-pcv2`) y modo Workgroup ✅.
- [x] **3.5:** Instalar OpenSSH Server (puerto 7022) ✅ Instalado silente vía QEMU Guest Agent.
- [x] **3.6:** Instalar Tailscale VPN (cuenta `pcdasu0@frlr.utn.edu.ar`). Anotar IP Tailscale asignada. ✅ **IP: 100.98.225.100**
- [ ] **3.7:** Instalar herramientas cliente SQL (SSMS o sqlcmd) si es necesario.
- [ ] **3.8:** Verificar conectividad hacia dasu-sql2 (ping + test TCP 1433).
- [x] **3.9:** Instalar qemu-guest-agent en VM dasu-pcv2 para backups desatendidos (ACPI shutdown) ✅.
### ⏳ **FASE 4: Instalación del Sistema DASUTEN**
- [x] **4.1:** Obtener backup/script de la base de datos DASUTEN del sistema actual. ✅ (Descargado localmente archivo de 604MB y confirmado acceso vía SMB al crudo `.bak`)
- [x] **4.2:** Restaurar/crear la base de datos DASUTEN en dasu-sql2. ✅ **Automatización implementada**: Creada la extensión nativa ADN `adn/tools/run dasuten db:migrar` (Ruby) que realiza la descarga SMB, extracción y restauración vía SQLCMD de manera eficiente, segura y reutilizable, eliminando el uso de scripts temporales de shell.
- [ ] **4.3:** Instalar la aplicación cliente DASUTEN en dasu-pcv2.
- [ ] **4.4:** Configurar la conexión de la aplicación al SQL Server usando autenticación SQL (no Windows Integrated).
- [ ] **4.5:** Verificar que la aplicación conecta y opera correctamente.
### ⏳ **FASE 5: Validación con PC física**
- [ ] **5.1:** Instalar la aplicación cliente DASUTEN en `dasu-pc` (PC física de la oficina).
- [ ] **5.2:** Configurar conexión al SQL Server (dasu-sql2) por IP.
- [ ] **5.3:** Ejecutar pruebas funcionales del sistema DASUTEN (consultas, altas, reportes).
- [ ] **5.4:** Documentar qué funcionalidades dependen del DC (si alguna) y cuáles operan sin él.
- [ ] **5.5:** Evaluar rendimiento y estabilidad.
- [ ] **5.6:** **Decisión**: ¿Se puede prescindir del DC para esta implementación?
- ✅ **SÍ** → Adoptar este enfoque como definitivo, descartar VMs con DC.
- ❌ **NO** → Reactivar VMs originales y retomar enfoque con DC.
---
## 🔄 Diferencias clave vs enfoque anterior
| Aspecto | Con DC (P2601.06-08) | Sin DC (P2601.09) |
|---------|----------------------|---------------------|
| **Red** | Privada 10.0.100.x (gw interno) | DHCP del ISP (gw del ISP) |
| **Autenticación SQL** | Windows Integrated (Kerberos) | SQL Auth (mixta) |
| **Usuarios** | Active Directory | Usuarios locales Windows |
| **DNS** | AD DNS (10.0.100.10) | DNS del ISP (automático) |
| **Complejidad de red** | Alta (DC + DNS + dominio + routing) | Mínima (red plana ISP) |
| **Puntos de falla** | DC, SQL, red dominio, routing | Solo SQL |
| **VMs necesarias** | 3 (DC + SQL + PC) | 2 (SQL + PC) |
## ⚠️ Consideraciones de red ISP
- Las IPs asignadas por DHCP del ISP pueden cambiar. Se recomienda **reservar IPs** en el router del ISP o documentar las IPs asignadas para referencia rápida.
- Todas las máquinas se ven entre sí directamente (misma LAN del ISP), lo cual simplifica la comunicación pero requiere que el firewall de Windows permita el tráfico SQL (puerto 1433).
- El acceso remoto a srv-dasu sigue siendo por **Tailscale** (independiente de la red local ISP).
## 📊 Recursos
| Recurso | Valor real |
|---------|-----------|
| **RAM total srv-dasu** | 15 GB |
| **RAM disponible** | 12 GB (10 GB libres + 3 GB cache) — VM 103 aún no consume (recién creada) |
| **RAM para nuevas VMs** | 8 GB (SQL 4GB + PC 4GB) → queda ~4 GB para host |
| **Disco total** | 94 GB (30 GB disponibles, 68% uso) — thin provisioned |
| **ISOs** | Win Server 2022 Core, Win 10 LTSC, SQL 2019, virtio-win |
| **Bridge vmbr0** | ✅ DHCP ISP sobre `enp33s0` — IP: `192.168.1.13/24` |
| **Gateway** | `192.168.1.1` (router ISP confirmado) |
## 8. Lecciones Aprendidas y Troubleshooting
- **`New-NetFirewallRule -Enabled` en entornos PS puros:** Al inyectar comandos de PowerShell a Server Core de forma automatizada (WS2022), debe pasarse el string `'True'` y no la variable booleana `$True`, ya que la Cmdletization falla la conversión estricta al vuelo.
- **Escape JSON en W-ZOMBI de PowerShell:** Grandes scripts en línea que se parsean a través de `cmd.json` destrozan la interpretación si hay fallas en la conexión. Para Server Core sin GUI, fue más seguro bypassear W-ZOMBI subiendo el PowerShell directo sobre un HTTP en Python temporal (`/tmp/s.ps1`).
- **QEMU-GA y Nombres de Unidad Aleatorios:** En entornos con múltiples CDs montados (OS + Drivers VirtIO + CD Extra), Windows Server asigna letras impredecibles (no siempre `D:`). El path del Agent MSI debe resolverse programáticamente usando `Get-WmiObject Win32_CDROMDrive`.
- **Usuario Administrador localizado:** Al instalar Server Core desde la ISO `es-es`, el administrador por defecto se renombra literalmente a `Administrador` en español. Esto es crítico porque intentos de conexión desatendida vía SSH con `sshpass` o secuencias usando `Administrator` devolverán "Permission denied", ocultando que el servidor SSH en realidad sí estaba escuchando en el puerto.
- **Compresión Nativa de BACKUP SQL vs RAR:** Actualmente el sistema de origen encapsula los `.bak` dentro de un `.rar` gigante (ej. `bksysdasuten.rar`). SQL Server **no sabe** leer `.rar` ni ZIP nativamente para operaciones RESTORE DATABASE. Ya que Linux tiene herramientas como `unar` que facilitan la extracción en RAM, es factible este paso intermedio. Sin embargo, **la solución definitiva y óptima ("menos es más")** para el origen de datos es generar el archivo `.bak` instruyendo a SQL Server que lo comprima nativamente con la opción `WITH COMPRESSION`. Un `.bak` comprimido es un 80% más pequeño, y SQL Server destino lo levanta sin pasos intermedios de extracción, evitando problemas de almacenamiento temporal e I/O innecesarios en el nodo de linux (`srv-dasu`) al copiar el archivo directo al Windows (`dasu-sql2`).
## 🔗 Referencias
- **Proyecto padre**: [P2601_dasuten.md](P2601_dasuten.md)
- **Plan previo de red**: [P2601.06.01_Red-SrvDasu.md](P2601.06.01_Red-SrvDasu.md)
- **Plan previo integración**: [P2601.07.01_Integracion-DASU-PC.md](P2601.07.01_Integracion-DASU-PC.md)
- **Nodos**: [srv-dasu](../../../nodos/srv-dasu.md) | [srv-ns8](../../../nodos/srv-ns8.md)
docs/ambito/dtic-DASUTEN/P2601_dasuten.md
+159
View File
@@ -0,0 +1,159 @@
# P2601 - Proyecto DASUTEN
> Manifiesto de Proyecto | Referencia: [`adn/07_proyectos.md`](../../../adn/07_proyectos.md)
## Identificación
| Campo | Valor |
| :--- | :--- |
| **Código** | P2601 |
| **Nombre** | Infraestructura y Sistema DASUTEN |
| **Estado** | ⏳ En Ejecución |
| **Inicio** | 23/02/2026 |
| **Fin Estimado** | Por definir |
## Objetivo
**DASUTEN** (Departamento de Acción Social Universitaria Tecnológica Nacional) es la obra social de empleados, docentes y alumnos de la Universidad Tecnológica Nacional. Si bien cuenta con una oficina en la Facultad Regional La Rioja, depende directamente de su **sede central en el Rectorado (Buenos Aires)**.
Actualmente, el sistema de gestión administrativa de DASUTEN funciona dentro de los servidores de la Facultad. El objetivo de este proyecto es **migrar el sistema a un servidor independiente** (`srv-dasu`) isolated de la red académica, de modo que:
1. La **PC física de la oficina** (`dasu-pc`) consuma el sistema directamente desde el nuevo servidor.
2. La infraestructura quede **autocontenida** dentro de la oficina DASUTEN: una PC cliente + un servidor con sus VMs (DC, SQL, y a futuro posibles servicios adicionales).
3. Se logre **independencia operativa** respecto a los servidores de la Facultad, facilitando la gestión desde Rectorado si fuera necesario.
## Stakeholders
| Rol | Persona | Visibilidad |
| :--- | :--- | :--- |
| **Responsable Técnico** | Lic. Ricardo MONLA | Operador directo |
| **Dirección de TIC** | (Jerárquico superior) | Dashboard asíncrono |
## Dashboard
- **URL**: `https://ns8.frlr.utn.edu.ar/P2601/`
- **Tipo**: Aplicación web estática (HTML/JS/CSS) servida por Nginx.
- **Métricas**: Timeline de hitos, barras de progreso, desglose Físico/Remoto por hito.
- **Actualización**: Las métricas se alimentan de las etiquetas `[Físico/Remoto: H:MM hs]` parseadas de las bitácoras.
### Nodos Exclusivos (Core DASUTEN)
| Nodo | IP | Rol en el Proyecto |
| :--- | :--- | :--- |
| [**srv-dasu**](../../../nodos/srv-dasu.md) | `100.116.210.36` (Tailscale) | Hipervisor Proxmox VE (Libre de red académica) |
| [**dasu-srvv-dc**](../../../nodos/dasu-srvv-dc.md) (VM 100) | `10.0.100.10` | Controlador de Dominio AD DS + DNS |
| [**dasu-srvv-sql**](../../../nodos/dasu-srvv-sql.md) (VM 101) | `10.0.100.11` | Motor SQL Server 2019 (Core) |
| **dasu-pcv** (VM 102) | `10.0.100.12` | VM de pruebas (Win 10 LTSC) |
| [**dasu-pc**](../../../nodos/dasu-pc.md) | Oficina DASUTEN | PC física cliente (Plan A: SSH, Plan B: W-ZOMBI) |
### Nodos de Soporte e Infraestructura
| Nodo | IP | Rol en el Proyecto |
| :--- | :--- | :--- |
| [**srv-ns8**](../../../nodos/srv-ns8.md) | `10.0.10.8` | Gestión central, GIT y Dashboard |
## Herramientas
| Herramienta | Uso |
| :--- | :--- |
| **Proxmox VE 9.1** | Virtualización y gestión de VMs |
| **Windows Server 2022 Core** | SO base para DC y SQL |
| **SQL Server 2019** | Motor de base de datos relacional |
| **OpenSSH** | Administración remota nativa de VMs Windows |
| **VZDump** | Resguardos offline de VMs |
| **Dashboard P2601** | Panel web de seguimiento para stakeholders |
## Hitos Clave
| Fecha | ID | Estado | Hito |
| :--- | :--- | :---: | :--- |
| 23/02 | A00-A01 | ✅ | Acondicionamiento hardware e instalación de Proxmox VE en `srv-dasu`. |
| 23/02 | A05 | ✅ | Creación de VM Windows Server Core y descarga de ISO. |
| 24/02 | A05 | ✅ | Habilitación SVM en BIOS, instalación de OS, promoción a DC (`dasu-srvv-dc`, ex dc-dasuten). |
| 24/02 | A06 | ✅ | Despliegue del Dashboard P2601 con telemetría operativa. |
| 25/02 | DB01 | ✅ | Creación de VM `dasu-srvv-sql` (ex sql-dasuten), instalación de OS, integración al dominio e instalación de SQL Server 2019. |
| 26/02 | SSH | ✅ | Despliegue de OpenSSH Server nativo en ambas VMs Windows. |
| 26/02 | BKP | ✅ | Resguardo VZDump offline (stop mode) de DC y SQL. |
| 27/02 | ADN | ✅ | Refactorización del ADN a arquitectura multi-hebra con Armonía Integral. |
| 27/02 | TEST | ✅ | Despliegue de VM de pruebas Win 10 LTSC (pcv-dasu0). Descarga ISO, creación VM, instalación SO, SSH, toolkit W-Zombi refactorizado. |
| 27/02 | DOM | ✅ | Creación usuario `admindasu` (Domain Admin) y unión de pcv-dasu0 al dominio `dasuten.utnlr`. Login verificado. |
| 11/03 | P2601.06.01 | ✅ | Instalación física de srv-dasu en nueva red (DHCP + IPs estáticas 10.0.100.x). [Físico: 5:00 hs] |
| 18/03 | P2601.07.01 | ✅ | Integración final y renombramiento de `dasu-pc` (AD-Join + W-ZOMBI v2.0). |
| 25/03 | P2601.07.07 | ✅ | Topología Capa 2: Red local DASUTEN (vmbr0: 10.0.100.1, enp33s0: ISP 10.0.10.201, proxy-docker, Tailscale ONLINE). |
| — | P02 | 📍 | Instalación del sistema DASUTEN sobre el motor SQL. |
---
## Progreso
```
Fase 1: ██████████ 100% Infraestructura Base
Fase 2: ██████████ 100% Servicios (DC + SQL)
Fase 3: ██████████ 100% Gestión y Seguridad
Fase 4: ██████████ 100% Integración de Clientes
Fase 5: ██░░░░░░░░ 20% Despliegue de Sistema
```
---
## 🌐 Topología y Contexto de Red
### Topología Implementada (2026-03-25)
```
┌─────────────────────────────────────────────────────────────┐
│ INTERNET / ISP (Gateway: 10.0.10.1) │
└──────────────────────┬──────────────────────────────────────┘
│
↓
┌──────────────────────────────────────────────────────────────┐
│ srv-dasu (Proxmox VE) │
│ ├── enp33s0 (ISP): 10.0.10.201/24 → Gateway 10.0.10.1 │
│ └── vmbr0 (Red DASUTEN): 10.0.100.1/24 │
│ ├── VMs: .10 (DC), .11 (SQL), .12 (PCV) │
│ ├── proxy-docker (:3129) │
│ └── Link directo → srv-ns8 (10.0.100.8) │
└──────────────────────────────────────────────────────────────┘
```
**Regla de Acceso (Agentes e IA):** Todo el ecosistema central (dasu-srvv-dc, dasu-srvv-sql, dasu-pcv) transcurre en la **subred aislada `10.0.100.0/24`**.
**Vía Tailscale (Estándar):** El hipervisor `srv-dasu` (`100.112.46.104`) tiene instalado Tailscale y está **ONLINE**. Las VMs pueden ser alcanzadas directamente por sus IPs `10.0.100.x` a través de la VPN.
**Vía Local (Capa 2):** Conexión directa `srv-dasu` ↔ `srv-ns8` mediante cable Ethernet (enp33s0 ↔ enp37s0) en red `10.0.100.0/24`.
**Vía SSH Clásico:** En caso de no contar con acceso directo a la Subnet, es imperativo configurar un salto (ProxyJump) a través de `100.116.210.36`.
## Arquitectura de Red
```
┌────────────────────────────────────────────────────────┐
│ Red WAN Externa (Internet / Tailscale) │
│ │
│ srv-ns8 (10.0.10.8) srv-dasu (DHCP/DHCP) │
│ [Tailscale VPN] [Tailscale Subnet Router] │
│ └─────────────────────────┘ │
│ │ │
│ │ NAT/VPN Routing │
│ ▼ │
│ ┌──────────────┐ │
│ │ 10.0.100.x │ │
│ │ (Segmento │ │
│ │ DASUTEN) │ │
│ │ │ │
│ │ dasu-srvv-dc │ │
│ │ (.10) [AD DS]│ │
│ │ │ │
│ │ dasu-srvv-sql │ │
│ │ (.11) [SQL] │ │
│ │ │ │
│ │ dasu-pcv │ │
│ │ (.12) [Test] │ dasu-pc │
│ └──────────────┘ [Cliente] │
│ (AD-Join) │
└────────────────────────────────────────────────────────┘
```
## Referencias
- **ADN**: [Ontología](../../../adn/01_ontologia.md) | [Proyectos](../../../adn/07_proyectos.md)
- **Nodos**: [srv-dasu](../../../nodos/srv-dasu.md) | [srv-ns8](../../../nodos/srv-ns8.md)
- **Bitácoras**: Consultar en DB vía `./adn/tools/run db evento:listar`
docs/ambito/dtic-DASUTEN/_hist/260304-1959_dashboard_P2601_en_bitacoras.md
+80
View File
@@ -0,0 +1,80 @@
# Plan: Integración Dashboard P2601 en dtic-BITACORAs
> Fecha: 04/03/2026 19:59hs
> Proyecto: P2601 - DASUTEN
> Estado: **Aprobado — En ejecución**
## Objetivo
Integrar el panel de seguimiento del proyecto P2601 dentro del sistema dtic-BITACORAs:
- Accesible en `ns8.frlr.utn.edu.ar/bitacoras/p2601`
- Datos almacenados en PostgreSQL (mismo stack que dtic-BITACORAs)
- Discriminación de horas presenciales vs remotas por hito
- Identificación de fases del proyecto
## Esquema de Datos
### Nuevas tablas (esquema `bitacoras`)
```sql
CREATE TABLE bitacoras.proyectos (
id SERIAL PRIMARY KEY,
codigo VARCHAR(10) NOT NULL UNIQUE, -- 'P2601'
nombre VARCHAR(200) NOT NULL,
estado VARCHAR(10) DEFAULT '⏳',
descripcion TEXT,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
CREATE TABLE bitacoras.fases (
id SERIAL PRIMARY KEY,
proyecto_id INTEGER REFERENCES bitacoras.proyectos(id),
numero INTEGER NOT NULL,
nombre VARCHAR(200) NOT NULL,
estado VARCHAR(10) DEFAULT '⏳',
descripcion TEXT,
fecha_inicio DATE,
fecha_fin DATE,
UNIQUE(proyecto_id, numero)
);
CREATE TABLE bitacoras.hitos (
id SERIAL PRIMARY KEY,
fase_id INTEGER REFERENCES bitacoras.fases(id),
id_hito VARCHAR(20) NOT NULL, -- 'A00', 'SSH', 'P02.DB'
titulo VARCHAR(200) NOT NULL,
descripcion TEXT,
estado VARCHAR(10) DEFAULT '⏳',
fecha DATE,
horas_presencial NUMERIC(5,2) DEFAULT 0,
horas_remoto NUMERIC(5,2) DEFAULT 0,
nodo_id INTEGER REFERENCES bitacoras.nodos(id),
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
```
## Fases del proyecto P2601
| # | Fase | Descripción | Nodos | Estado |
|:--|:--|:--|:--|:--|
| 1 | Infraestructura Física | Preparación hardware srv-dasu + Proxmox VE 9.1 | srv-dasu | ✅ |
| 2 | Dominio y Directorio Activo | VM dc-dasuten, AD DS, DNS, dominio `dasuten.utnlr` | dc-dasuten | ✅ |
| 3 | Motor de Base de Datos | VM sql-dasuten, SQL Server 2019, backup y restore sysdasuten | sql-dasuten | ✅ |
| 4 | Acceso Remoto y Seguridad | OpenSSH 7022, w-zombi, firewall en todas las VMs | dc/sql/pcv-dasuten | ✅ |
| 5 | Sistema DASUTEN | Ingeniería inversa, deploy DasutenSQL.exe, Kermet.ini | pcv-dasu0, sql-dasuten | ⏳ |
| 6 | Cliente Final | Config pc-dasu0 en dominio, sistema productivo | pc-dasu0 | 📋 |
## Archivos a modificar/crear
| Acción | Archivo | Descripción |
|:--|:--|:--|
| MODIFY | `docker/init.sql` | Tablas proyectos, fases, hitos + datos semilla P2601 |
| NEW | `backend/src/routes/proyectos.js` | API CRUD /api/proyectos con métricas |
| MODIFY | `backend/src/server.js` | Registrar ruta proyectos |
| NEW | `frontend/src/pages/ProyectoDashboard.tsx` | Página React con timeline, fases y métricas |
| MODIFY | `frontend/src/App.tsx` | Ruta /bitacoras/p2601 |
## Verificación
- `curl` al endpoint `/api/proyectos/P2601`
- Navegador a `https://ns8.frlr.utn.edu.ar/bitacoras/p2601`
docs/ambito/dtic-DASUTEN/_hist/260305-0930_PruebasDasuten.md
+21
View File
@@ -0,0 +1,21 @@
# Plan de Pruebas: Sistema Dasuten (P02)
**Fecha/Hora:** 260305-0930
**Objetivo:** Confirmar el correcto funcionamiento y conectividad del entorno Dasuten.
## Fases de la Prueba
1. **Uso de Herramienta de Credenciales Secretas:**
- Modificar la herramienta `tools/ns8-candados` para que incluya instrucciones y explicación de uso en la cabecera.
- Ejecutar la herramienta `tools/ns8-candados` de manera que capture las credenciales requeridas en el entorno (o en una variable segura) sin exponer la salida (stdout) al flujo visible del chat, preservando la confidencialidad.
2. **Verificación de Acceso Base:**
- Confirmar acceso SSH al servidor principal `pcv-dasu0` utilizando las credenciales obtenidas.
- Validar estado general del sistema (uptime, uso de recursos básicos).
3. **Pruebas Funcionales Adicionales (A definir iterativamente):**
- *Se irán agregando puntos de prueba según el progreso y los resultados del acceso base.*
## Protocolo de Registro (Bitácora First)
- Todo paso debe ser previamente registrado en la bitácora del día correspondiente como iniciado.
- Tras concluir cada paso o iteración, actualizar el registro en la bitácora con los resultados (éxito/fallo y observaciones).
docs/ambito/dtic-DASUTEN/_hist/260305-1010_ContextoADN_Dasuten.md
+22
View File
@@ -0,0 +1,22 @@
# Plan de Implementación: Contexto en el ADN (Caso DASUTEN)
**Fecha**: 2026-03-05
**Objetivo**: Dotar a la IA y al proyecto de un protocolo estandarizado de "Auto-contextualización" sobre topología de redes, evitando operaciones ciegas (ej. Timeouts SSH en subredes NAT).
## Propuesta de Cambios
### Hebra: Directivas de la Inteligencia Artificial (`adn/05_ia.md`)
Agregaremos una nueva directiva `13. Auto-Contextualización`.
- **Regla:** Antes de iniciar pruebas de red o conexiones a nodos, la IA DEBE consultar el archivo del nodo (en la carpeta `nodos/`) y el proyecto asociado para comprender su ubicación en la topología (ej. si está detrás de un NAT, si requiere salto SSH, qué IP tiene).
- **Ejecución:** Evitar asunciones de visibilidad directa; mapear el contexto siempre.
### Hebra: Proyectos (`adn/07_proyectos.md`)
Añadir la sección obligatoria de "Topología / Contexto de Red" a los manifiestos de proyecto.
- **Topología Lógica / Contexto de Red:** Exige describir la ubicación de los nodos (ej: Red aislada, host físico, dependencias de NAT) para documentar y estandarizar el **CÓMO** llegar a ellos de forma técnica.
### Manifiesto: P2601 Dasuten (`proyectos/P2601_dasuten.md`)
Actualizar el manifiesto actual del proyecto Dasuten para reflejar esta nueva arquitectura de topología explícita.
- Añadir una sección `## 🌐 Topología y Contexto de Red` explicando que:
1. Todo el ecosistema Dasuten corre bajo `srv-dasu` (Standalone - 10.0.10.205).
2. Las VMs periféricas (pcv-dasu0, dc-dasuten, sql-dasuten) están en una subred aislada `10.0.100.0/24`.
3. **Regla de Acceso:** Para la intervención, es necesario un ruteo o ProxyJump a través de `10.0.10.205`.
docs/ambito/dtic-DASUTEN/_hist/260305-1017_Despliegue_runSysDasuten.md
+29
View File
@@ -0,0 +1,29 @@
# Plan de Acción: Despliegue y Prueba de DASUTEN en pcv-dasu0
**Fecha/Hora:** 260305-1017
**Artefacto:** `tools/w-zombi/payloads/runSysDasuten.zip`
**Objetivo:** Desplegar los binarios del sistema DASUTEN en la VM de pruebas (cliente Windows 10 LTSC) y verificar su conexión contra el motor SQL recién instalado en la fase DB01.
## Fases del Despliegue
### 1. Preparación y Transferencia
1. Obtener credenciales de `admindasu` desde `ns8-candados`.
2. Establecer túnel o salto SSH válido hacia la red `10.0.100.x` a través de `srv-dasu` (10.0.10.205).
3. Transferir el archivo `tools/w-zombi/payloads/runSysDasuten.zip` vía SCP al disco virtual de `pcv-dasu0` apuntando al **puerto SSH 7022** (ej. en `C:\Dasuten\`).
### 2. Descompresión y Configuración
1. Descomprimir el archivo ZIP en el cliente usando PowerShell remoting / SSH.
2. Localizar y editar el archivo de configuración `Kermet.ini`:
- Modificar la cadena de conexión de ODBC para `[SQLSERVER]`.
- Reemplazar `SERVER=srvFENIX` por el endpoint actual: `SERVER=sql-dasuten` (o la IP `10.0.100.11`).
### 3. Instalación de Dependencias
1. Instalar de forma automatizada las fuentes tipográficas necesarias de la carpeta `Fonts/` (códigos de barras Code39, I2OF5).
2. Ejecutar silenciosa/desatendidamente `InstaladorComponentesKermet.exe` para registrar librerías VFP/Kermet requeridas por el sistema en el cliente.
### 4. Pruebas de Verificación
1. **Red**: Realizar un `Test-NetConnection` o ping desde `pcv-dasu0` hacia el puerto TCP 1433 de `sql-dasuten` para garantizar que el firewall permite el tráfico SQL.
2. **Sistema GUI**: Invocar la apertura de `DasutenSQL.exe` (puede requerir verificación visual del usuario vía consola NoVNC de Proxmox o Anydesk/RDP). Se debe comprobar que se abre la pantalla de logon sin errores de conexión a la base de datos `sysdasuten`.
## Registro y Trazabilidad
- Todo evento de éxito/falla de red se registrará en la bitácora bajo la etiqueta `[P02]`.
docs/ambito/dtic-DASUTEN/_hist/260305-1300_Plan_Fase_6_Fisico_Dominio_GPO.md
+31
View File
@@ -0,0 +1,31 @@
# Fase 6 - DASUTEN: Despliegue Físico, Dominio y Seguridad Local
**Fecha:** 05/03/2026 - P2601 Proyecto Dasuten
## Objetivo
Habiendo superado la prueba de concepto (UAT) y verificado el funcionamiento del sistema en la red aislada `10.0.100.x` virtualizada bajo Proxmox, la siguiente fase consiste en **entregar la infraestructura a producción**.
Esto implica el traslado físico del equipamiento, la adhesión de las estaciones de trabajo de los usuarios al nuevo Active Directory (`dc-dasuten`), y la configuración de las políticas organizativas.
## Tareas a Realizar
### 1. Instalación Física (Hardware)
* **Servidor Proxmox (`srv-dasu`)**: Trasladar el host físico a la oficina de DASUTEN e instalarlo en su locación definitiva (gabinete/rack), asegurando energía ininterrumpida (UPS) y conectividad de red adecuada.
* **Estaciones de Trabajo (`pc-dasu0` y otras si las hay)**: Reconectar y asegurar la conectividad L2 (física/switch) hacia el puerto de red que ofrece acceso al servidor `srv-dasu`.
### 2. Integración de Red y Dominio
* **Configuración de Red Local**: Asegurar que la PC física tenga acceso a la red donde opera el controlador de dominio. Confirmar que su **DNS Primario** sea la IP de `dc-dasuten` (`10.0.100.10`).
* **Unión al Dominio**: Ingresar la PC `pc-dasu0` al dominio `dasuten.utnlr`.
* **Reasignación de Usuarios**: Mapear/Migrar los perfiles y datos del usuario local que usaba Andrea Almirón hacia su nueva cuenta de dominio.
### 3. Seguridad y GPOs (Group Policy Objects)
* **Restricción de Acceso**: Configurar GPOs para prohibir la instalación de software no autorizado por los usuarios estándar de DASUTEN.
* **Unidades de Red**: Despliegue automático de mapeos de red necesarios (si la aplicación requiere una letra de unidad específica o para almacenamiento compartido) mediante GPO.
* **Restricciones de Explorador**: Ocultar u restringir acceso a la unidad C:\ y recursos sensibles.
* **Políticas de Contraseñas**: Asegurar rotación o longitud mínima para los usuarios del dominio.
### 4. Revisión Final de Aplicaciones
* Distribuir el conjunto de accesos directos del sistema Dasuten (`DasutenSQL.exe`) al escritorio de todos los usuarios mediante GPO.
* Verificar que la conexión ODBC/Kermet funciona bajo el contexto de seguridad del usuario de dominio sin requerir elevación de privilegios.
## Siguientes Pasos (IA)
Una vez que el usuario informe que el equipo fue trasladado y encendido en su nueva locación, la IA asistirá vía Tailscale / AnyDesk (o conexiones remotas establecidas) con la configuración de las Políticas de Seguridad (GPOs) y las uniones de dominio.
docs/ambito/dtic-DASUTEN/proc/P2601.06.02_Comunicacion-Directa-Local.md
+685
View File
@@ -0,0 +1,685 @@
# [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*
docs/ambito/dtic-DASUTEN/proc/scripts/Diagnose-LocalNetwork.ps1
+399
View File
@@ -0,0 +1,399 @@
# Script de diagnóstico de red local para pc-dasu0
# Uso: .\Diagnose-LocalNetwork.ps1 [-InterfaceAlias "Ethernet"] [-Detailed $true]
param(
[string]$InterfaceAlias = "Ethernet",
[bool]$Detailed = $true,
[string]$LogPath = "C:\Logs\NetworkDiagnostic"
)
# Configuración inicial
$ErrorActionPreference = "Stop"
$Timestamp = Get-Date -Format "yyyyMMdd_HHmmss"
$LogFile = Join-Path $LogPath "NetworkDiagnostic_$Timestamp.log"
$ReportFile = Join-Path $LogPath "NetworkReport_$Timestamp.md"
# Crear directorio de logs si no existe
if (-not (Test-Path $LogPath)) {
New-Item -ItemType Directory -Path $LogPath -Force | Out-Null
}
# Funciones de logging
function Write-Log {
param([string]$Message, [string]$Level = "INFO")
$FormattedMessage = "[$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')] [$Level] $Message"
switch ($Level) {
"ERROR" { Write-Host $FormattedMessage -ForegroundColor Red }
"WARNING" { Write-Host $FormattedMessage -ForegroundColor Yellow }
"SUCCESS" { Write-Host $FormattedMessage -ForegroundColor Green }
default { Write-Host $FormattedMessage -ForegroundColor Cyan }
}
$FormattedMessage | Out-File -FilePath $LogFile -Append
}
function Write-Report {
param([string]$Content)
$Content | Out-File -FilePath $ReportFile -Append
}
function Test-Command {
param([string]$Command)
try {
Get-Command $Command -ErrorAction Stop | Out-Null
return $true
} catch {
return $false
}
}
# Inicio del diagnóstico
Write-Log "========================================"
Write-Log " DIAGNÓSTICO DE RED LOCAL - pc-dasu0"
Write-Log "========================================"
Write-Log ""
Write-Report "# Reporte de Diagnóstico de Red Local"
Write-Report "Fecha: $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')"
Write-Report "Hostname: $env:COMPUTERNAME"
Write-Report "Usuario: $env:USERNAME"
Write-Report ""
# 1. Verificar adaptador de red
Write-Log "1. Verificando adaptador de red '$InterfaceAlias'..."
Write-Report "## 1. Información del Adaptador de Red"
try {
$NetworkAdapter = Get-NetAdapter -Name $InterfaceAlias -ErrorAction Stop
Write-Log " Adaptador encontrado: $($NetworkAdapter.Name)"
Write-Log " Estado: $($NetworkAdapter.Status)"
Write-Log " Velocidad: $($NetworkAdapter.LinkSpeed)"
Write-Report "### Adaptador: $($NetworkAdapter.Name)"
Write-Report "- Estado: $($NetworkAdapter.Status)"
Write-Report "- Velocidad: $($NetworkAdapter.LinkSpeed)"
Write-Report "- MAC Address: $($NetworkAdapter.MacAddress)"
Write-Report "- Interface Description: $($NetworkAdapter.InterfaceDescription)"
Write-Report ""
if ($NetworkAdapter.Status -ne "Up") {
Write-Log " ADVERTENCIA: El adaptador no está activo" -Level "WARNING"
}
} catch {
Write-Log " ERROR: No se encontró el adaptador '$InterfaceAlias'" -Level "ERROR"
Write-Log " Adaptadores disponibles:"
Get-NetAdapter | ForEach-Object {
Write-Log " - $($_.Name): $($_.Status)"
}
Write-Report "ERROR: Adaptador '$InterfaceAlias' no encontrado"
exit 1
}
# 2. Obtener configuración IP
Write-Log "2. Obteniendo configuración IP..."
Write-Report "## 2. Configuración IP"
try {
$IPConfiguration = Get-NetIPConfiguration -InterfaceAlias $InterfaceAlias -ErrorAction Stop
Write-Log " IPv4 Address: $($IPConfiguration.IPv4Address.IPAddress)"
Write-Log " Subnet Mask: $($IPConfiguration.IPv4Address.PrefixLength)"
Write-Log " Gateway: $($IPConfiguration.IPv4DefaultGateway.NextHop)"
Write-Report "### Configuración IPv4"
Write-Report "- Dirección IP: $($IPConfiguration.IPv4Address.IPAddress)"
Write-Report "- Prefijo: /$($IPConfiguration.IPv4Address.PrefixLength)"
Write-Report "- Gateway: $($IPConfiguration.IPv4DefaultGateway.NextHop)"
Write-Report ""
# Calcular subred
$IPAddress = $IPConfiguration.IPv4Address.IPAddress
$PrefixLength = $IPConfiguration.IPv4Address.PrefixLength
$SubnetMask = [System.Net.IPAddress]::Parse(([System.Net.IPAddress]::Parse("255.255.255.255").GetAddressBytes() |
ForEach-Object { $_ -shl (32 - $PrefixLength) }))
$NetworkAddress = [System.Net.IPAddress]::new((
[System.Net.IPAddress]::Parse($IPAddress).GetAddressBytes() |
ForEach-Object { $_ -band $SubnetMask.GetAddressBytes()[$i]; $i++ }))
$Subnet = "$NetworkAddress/$PrefixLength"
Write-Log " Subred calculada: $Subnet"
Write-Report "- Subred: $Subnet"
Write-Report ""
# Servidores DNS
Write-Log " Servidores DNS:"
$DNSServers = $IPConfiguration.DNSServer.ServerAddresses
if ($DNSServers) {
$i = 1
foreach ($DNS in $DNSServers) {
Write-Log " $i. $DNS"
Write-Report "- DNS $($i): $DNS"
$i++
}
} else {
Write-Log " ADVERTENCIA: No hay servidores DNS configurados" -Level "WARNING"
Write-Report "- DNS: No configurado"
}
Write-Report ""
} catch {
Write-Log " ERROR: No se pudo obtener configuración IP" -Level "ERROR"
Write-Report "ERROR: No se pudo obtener configuración IP"
}
# 3. Probar conectividad
Write-Log "3. Probando conectividad de red..."
Write-Report "## 3. Pruebas de Conectividad"
# Gateway
$Gateway = $IPConfiguration.IPv4DefaultGateway.NextHop
if ($Gateway) {
Write-Log " Probando gateway $Gateway..."
$GatewayTest = Test-NetConnection -ComputerName $Gateway -InformationLevel Quiet
if ($GatewayTest) {
Write-Log " ✅ Gateway alcanzable" -Level "SUCCESS"
Write-Report "- Gateway ($Gateway): ✅ Alcanzable"
} else {
Write-Log " ❌ Gateway no alcanzable" -Level "ERROR"
Write-Report "- Gateway ($Gateway): ❌ No alcanzable"
}
} else {
Write-Log " ADVERTENCIA: No hay gateway configurado" -Level "WARNING"
Write-Report "- Gateway: No configurado"
}
# Internet
Write-Log " Probando conectividad a internet (8.8.8.8)..."
$InternetTest = Test-NetConnection -ComputerName "8.8.8.8" -InformationLevel Quiet -WarningAction SilentlyContinue
if ($InternetTest) {
Write-Log " ✅ Internet alcanzable" -Level "SUCCESS"
Write-Report "- Internet (8.8.8.8): ✅ Alcanzable"
} else {
Write-Log " ❌ Internet no alcanzable" -Level "ERROR"
Write-Report "- Internet (8.8.8.8): ❌ No alcanzable"
}
# srv-dasu (si se conoce la IP)
Write-Log " Probando conectividad a srv-dasu (192.168.1.205)..."
$SrvDasuTest = Test-NetConnection -ComputerName "192.168.1.205" -InformationLevel Quiet -WarningAction SilentlyContinue
if ($SrvDasuTest) {
Write-Log " ✅ srv-dasu alcanzable localmente" -Level "SUCCESS"
Write-Report "- srv-dasu (192.168.1.205): ✅ Alcanzable"
} else {
Write-Log " ⚠️ srv-dasu no alcanzable localmente" -Level "WARNING"
Write-Report "- srv-dasu (192.168.1.205): ⚠️ No alcanzable"
}
Write-Report ""
# 4. Verificar DNS
Write-Log "4. Verificando resolución DNS..."
Write-Report "## 4. Pruebas de DNS"
# Resolución de dominio DASUTEN
Write-Log " Probando resolución de dc-dasuten.dasuten.utnlr..."
try {
$DNSResult = Resolve-DnsName -Name "dc-dasuten.dasuten.utnlr" -ErrorAction Stop
if ($DNSResult.IPAddress) {
Write-Log " ✅ DNS resuelve a: $($DNSResult.IPAddress)" -Level "SUCCESS"
Write-Report "- dc-dasuten.dasuten.utnlr: ✅ $($DNSResult.IPAddress)"
} else {
Write-Log " ❌ DNS no devolvió IP" -Level "ERROR"
Write-Report "- dc-dasuten.dasuten.utnlr: ❌ Sin respuesta"
}
} catch {
Write-Log " ❌ Error en resolución DNS: $_" -Level "ERROR"
Write-Report "- dc-dasuten.dasuten.utnlr: ❌ Error: $_"
}
# Resolución inversa
Write-Log " Probando resolución inversa de 10.0.100.10..."
try {
$ReverseDNS = Resolve-DnsName -Name "10.0.100.10" -Type PTR -ErrorAction Stop
if ($ReverseDNS.NameHost) {
Write-Log " ✅ Resolución inversa: $($ReverseDNS.NameHost)" -Level "SUCCESS"
Write-Report "- 10.0.100.10 (PTR): ✅ $($ReverseDNS.NameHost)"
}
} catch {
Write-Log " ⚠️ No se pudo resolver PTR para 10.0.100.10" -Level "WARNING"
Write-Report "- 10.0.100.10 (PTR): ⚠️ No resuelto"
}
Write-Report ""
# 5. Verificar puertos críticos del dominio
Write-Log "5. Verificando puertos críticos del dominio..."
Write-Report "## 5. Puertos del Dominio DASUTEN"
$DomainController = "10.0.100.10"
$CriticalPorts = @(
@{Port=389; Service="LDAP"},
@{Port=88; Service="Kerberos"},
@{Port=445; Service="SMB"},
@{Port=53; Service="DNS"},
@{Port=135; Service="RPC"},
@{Port=636; Service="LDAPS"}
)
foreach ($PortInfo in $CriticalPorts) {
Write-Log " Probando puerto $($PortInfo.Port) ($($PortInfo.Service))..."
$PortTest = Test-NetConnection -ComputerName $DomainController -Port $PortInfo.Port -WarningAction SilentlyContinue -ErrorAction SilentlyContinue
if ($PortTest.TcpTestSucceeded) {
Write-Log " ✅ Puerto $($PortInfo.Port) abierto" -Level "SUCCESS"
Write-Report "- $($PortInfo.Service) (puerto $($PortInfo.Port)): ✅ Abierto"
} else {
Write-Log " ❌ Puerto $($PortInfo.Port) cerrado" -Level "ERROR"
Write-Report "- $($PortInfo.Service) (puerto $($PortInfo.Port)): ❌ Cerrado"
}
}
Write-Report ""
# 6. Verificar Tailscale
Write-Log "6. Verificando estado de Tailscale..."
Write-Report "## 6. Estado de Tailscale"
if (Test-Command "tailscale") {
try {
$TailscaleStatus = & tailscale status --json 2>$null | ConvertFrom-Json
if ($TailscaleStatus.Self.TailscaleIPs) {
$TailscaleIP = $TailscaleStatus.Self.TailscaleIPs[0]
Write-Log " ✅ Tailscale conectado: $TailscaleIP" -Level "SUCCESS"
Write-Report "- Estado: ✅ Conectado"
Write-Report "- IP Tailscale: $TailscaleIP"
# Verificar peers
$PeerCount = ($TailscaleStatus.Peer | Measure-Object).Count
Write-Log " Peers conectados: $PeerCount"
Write-Report "- Peers conectados: $PeerCount"
} else {
Write-Log " ⚠️ Tailscale instalado pero no conectado" -Level "WARNING"
Write-Report "- Estado: ⚠️ Instalado pero no conectado"
}
} catch {
Write-Log " ⚠️ No se pudo obtener estado de Tailscale" -Level "WARNING"
Write-Report "- Estado: ⚠️ Error al obtener estado"
}
} else {
Write-Log " ⚠️ Tailscale no está instalado" -Level "WARNING"
Write-Report "- Estado: ⚠️ No instalado"
}
Write-Report ""
# 7. Escanear red local (opcional)
if ($Detailed) {
Write-Log "7. Escaneando dispositivos en red local..."
Write-Report "## 7. Dispositivos en Red Local"
try {
# Usar ARP para detectar dispositivos
$ARPTable = arp -a | Select-String "dynamic" | ForEach-Object {
$Line = $_.ToString().Trim()
$Parts = $Line -split '\s+'
[PSCustomObject]@{
IP = $Parts[0]
MAC = $Parts[1]
Type = $Parts[2]
}
}
$DeviceCount = ($ARPTable | Measure-Object).Count
Write-Log " Dispositivos detectados en ARP: $DeviceCount"
Write-Report "- Dispositivos en tabla ARP: $DeviceCount"
if ($DeviceCount -gt 0) {
Write-Report ""
Write-Report "### Primeros 10 dispositivos:"
$ARPTable | Select-Object -First 10 | ForEach-Object {
Write-Report "- $($_.IP) ($($_.MAC))"
}
}
} catch {
Write-Log " ⚠️ No se pudo escanear red local" -Level "WARNING"
Write-Report "- Escaneo: ⚠️ No disponible"
}
Write-Report ""
}
# 8. Generar recomendaciones
Write-Log "8. Generando recomendaciones..."
Write-Report "## 8. Recomendaciones para Comunicación Local"
$BaseNetwork = $IPAddress -replace '\.\d+$', ''
$RecommendedSrvIP = "$BaseNetwork.205"
$RecommendedPcIP = "$BaseNetwork.100"
Write-Report "### Configuración recomendada para comunicación local:"
Write-Report ""
Write-Report "1. **IPs estáticas locales:**"
Write-Report " - srv-dasu: $RecommendedSrvIP/24"
Write-Report " - pc-dasu0: $RecommendedPcIP/24"
Write-Report ""
Write-Report "2. **Configuración de red en pc-dasu0:**"
Write-Report " - IP: $RecommendedPcIP"
Write-Report " - Máscara: 255.255.255.0"
Write-Report " - Gateway: $Gateway"
Write-Report " - DNS Primario: 10.0.100.10 (dc-dasuten)"
Write-Report " - DNS Secundario: 8.8.8.8"
Write-Report " - Suffix DNS: dasuten.utnlr"
Write-Report ""
Write-Report "3. **Verificaciones previas:**"
Write-Report " - Confirmar que $RecommendedSrvIP y $RecommendedPcIP no están en uso"
Write-Report " - Verificar firewall (permitir ICMP, puertos 389, 88, 445, 53)"
Write-Report " - Mantener Tailscale activo como respaldo"
Write-Report ""
Write-Report "4. **Comandos de prueba post-configuración:**"
Write-Report " ```powershell"
Write-Report " # Probar conectividad local"
Write-Report " Test-NetConnection $RecommendedSrvIP"
Write-Report " "
Write-Report " # Probar resolución DNS"
Write-Report " Resolve-DnsName dc-dasuten.dasuten.utnlr"
Write-Report " "
Write-Report " # Probar puertos del dominio"
Write-Report " Test-NetConnection 10.0.100.10 -Port 389"
Write-Report " ```"
Write-Report ""
# 9. Resumen final
Write-Log "9. Generando resumen final..."
Write-Report "## 9. Resumen del Diagnóstico"
Write-Report "- **Adaptador de red**: $($NetworkAdapter.Name) ($($NetworkAdapter.Status))"
Write-Report "- **IP Configurada**: $IPAddress/$PrefixLength"
Write-Report "- **Gateway**: $(if($Gateway) {$Gateway} else {"No configurado"})"
Write-Report "- **Subred**: $Subnet"
Write-Report "- **DNS Servers**: $(if($DNSServers) {$DNSServers -join ', '} else {"No configurado"})"
Write-Report "- **Internet**: $(if($InternetTest) {"✅ Alcanzable"} else {"❌ No alcanzable"})"
Write-Report "- **srv-dasu local**: $(if($SrvDasuTest) {"✅ Alcanzable"} else {"⚠️ No alcanzable"})"
Write-Report "- **Tailscale**: $(if(Test-Command "tailscale") {"✅ Instalado"} else {"⚠️ No instalado"})"
Write-Report ""
Write-Report "### Archivos generados:"
Write-Report "- Log detallado: $LogFile"
Write-Report "- Reporte completo: $ReportFile"
Write-Report ""
Write-Report "### Próximos pasos:"
Write-Report "1. Si la conectividad local falla, verificar configuración del router ISP"
Write-Report "2. Configurar IPs estáticas según recomendaciones"
Write-Report "3. Probar AD-Join después de configurar comunicación local"
Write-Report "4. Mantener Tailscale como respaldo para acceso remoto"
Write-Report ""
Write-Report "*Diagnóstico completado: $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')*"
docs/ambito/dtic-DASUTEN/proc/scripts/diagnostico_red_local.sh
+337
View File
@@ -0,0 +1,337 @@
#!/bin/bash
# Script de diagnóstico automático para red local
# Uso: ./diagnostico_red_local.sh [interface]
# Ejemplo: ./diagnostico_red_local.sh vmbr0
set -e
# Colores para output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# Variables
INTERFACE="${1:-vmbr0}"
LOG_FILE="/tmp/diagnostico_red_local_$(date +%Y%m%d_%H%M%S).log"
REPORT_FILE="/tmp/reporte_red_local_$(date +%Y%m%d_%H%M%S).md"
# Funciones de utilidad
log() {
echo -e "${BLUE}[INFO]${NC} $1" | tee -a "$LOG_FILE"
}
success() {
echo -e "${GREEN}[SUCCESS]${NC} $1" | tee -a "$LOG_FILE"
}
warning() {
echo -e "${YELLOW}[WARNING]${NC} $1" | tee -a "$LOG_FILE"
}
error() {
echo -e "${RED}[ERROR]${NC} $1" | tee -a "$LOG_FILE"
}
check_dependencies() {
local deps=("ip" "ping" "awk" "grep" "tee")
local missing=()
for dep in "${deps[@]}"; do
if ! command -v "$dep" &> /dev/null; then
missing+=("$dep")
fi
done
if [ ${#missing[@]} -gt 0 ]; then
error "Dependencias faltantes: ${missing[*]}"
return 1
fi
# Dependencias opcionales
if command -v "nmap" &> /dev/null; then
HAS_NMAP=true
else
HAS_NMAP=false
warning "nmap no encontrado. El escaneo de red será limitado."
fi
if command -v "jq" &> /dev/null; then
HAS_JQ=true
else
HAS_JQ=false
fi
return 0
}
check_interface() {
if ! ip link show "$INTERFACE" &> /dev/null; then
error "Interfaz $INTERFACE no encontrada"
echo "Interfaces disponibles:"
ip link show | awk -F': ' '/^[0-9]+:/ {print $2}' | grep -v lo
return 1
fi
if [ "$(cat /sys/class/net/"$INTERFACE"/operstate 2>/dev/null)" != "up" ]; then
warning "Interfaz $INTERFACE no está activa (operstate: $(cat /sys/class/net/"$INTERFACE"/operstate 2>/dev/null))"
fi
return 0
}
get_interface_info() {
log "Obteniendo información de la interfaz $INTERFACE..."
echo "=== INFORMACIÓN DE INTERFAZ ===" | tee -a "$REPORT_FILE"
ip addr show "$INTERFACE" | tee -a "$REPORT_FILE"
echo "" | tee -a "$REPORT_FILE"
# Extraer IPs configuradas
IPS=$(ip addr show "$INTERFACE" | awk '/inet / {print $2}')
if [ -z "$IPS" ]; then
warning "No hay IPs configuradas en $INTERFACE"
else
success "IPs configuradas:"
echo "$IPS" | while read -r ip; do
echo " - $ip"
done | tee -a "$REPORT_FILE"
fi
}
get_routing_info() {
log "Obteniendo información de enrutamiento..."
echo "=== TABLA DE RUTAS ===" | tee -a "$REPORT_FILE"
ip route show | tee -a "$REPORT_FILE"
echo "" | tee -a "$REPORT_FILE"
# Detectar gateway predeterminado
DEFAULT_GW=$(ip route show default | awk '/default/ {print $3}')
if [ -n "$DEFAULT_GW" ]; then
success "Gateway predeterminado: $DEFAULT_GW"
echo "Gateway: $DEFAULT_GW" | tee -a "$REPORT_FILE"
# Probar conectividad al gateway
log "Probando conectividad al gateway $DEFAULT_GW..."
if ping -c 3 -W 2 "$DEFAULT_GW" &> /dev/null; then
success "Gateway alcanzable"
echo "Gateway alcanzable: Sí" | tee -a "$REPORT_FILE"
else
warning "Gateway no alcanzable"
echo "Gateway alcanzable: No" | tee -a "$REPORT_FILE"
fi
else
warning "No se encontró gateway predeterminado"
echo "Gateway: No encontrado" | tee -a "$REPORT_FILE"
fi
# Detectar subred local
LOCAL_SUBNET=$(ip route show | grep "link src" | awk '{print $1}' | head -1)
if [ -n "$LOCAL_SUBNET" ]; then
success "Subred local detectada: $LOCAL_SUBNET"
echo "Subred local: $LOCAL_SUBNET" | tee -a "$REPORT_FILE"
else
warning "No se pudo detectar subred local"
echo "Subred local: No detectada" | tee -a "$REPORT_FILE"
fi
}
check_dhcp_info() {
log "Verificando información DHCP..."
echo "=== INFORMACIÓN DHCP ===" | tee -a "$REPORT_FILE"
# Verificar archivos de lease DHCP
DHCP_FILES=("/var/lib/dhcp/dhclient.leases" "/var/lib/dhclient/dhclient.leases")
for file in "${DHCP_FILES[@]}"; do
if [ -f "$file" ]; then
log "Analizando $file..."
if grep -q "interface.*$INTERFACE" "$file" 2>/dev/null; then
success "Se encontraron leases DHCP para $INTERFACE"
echo "Archivo DHCP: $file" | tee -a "$REPORT_FILE"
# Extraer información relevante
grep -A10 -B2 "interface.*$INTERFACE" "$file" | \
grep -E "(lease|starts|ends|option|fixed-address)" | \
head -20 | tee -a "$REPORT_FILE"
break
fi
fi
done
if ! grep -q "Archivo DHCP:" "$REPORT_FILE"; then
warning "No se encontraron leases DHCP para $INTERFACE"
echo "DHCP: No se encontraron leases" | tee -a "$REPORT_FILE"
fi
echo "" | tee -a "$REPORT_FILE"
}
scan_local_network() {
if [ -z "$LOCAL_SUBNET" ]; then
warning "No se puede escanear red local (subred no detectada)"
return 1
fi
log "Escaneando red local $LOCAL_SUBNET..."
echo "=== ESCANEO DE RED LOCAL ===" | tee -a "$REPORT_FILE"
if [ "$HAS_NMAP" = true ]; then
# Escaneo rápido con nmap
log "Ejecutando escaneo rápido con nmap..."
nmap -sn "$LOCAL_SUBNET" 2>/dev/null | \
grep "Nmap scan report" | \
head -20 | \
tee -a "$REPORT_FILE"
# Contar dispositivos
DEVICE_COUNT=$(nmap -sn "$LOCAL_SUBNET" 2>/dev/null | grep "Nmap scan report" | wc -l)
success "Dispositivos detectados: $DEVICE_COUNT"
echo "Total dispositivos: $DEVICE_COUNT" | tee -a "$REPORT_FILE"
else
# Método alternativo usando ping y arp
warning "Usando método básico de detección (sin nmap)..."
# Ping a broadcast (puede no funcionar en todas las redes)
log "Probando detección básica..."
ping -c 2 -b "$(echo "$LOCAL_SUBNET" | cut -d'/' -f1 | sed 's/0$/255/')" &> /dev/null || true
# Mostrar tabla ARP
ip neigh show | grep -v "FAILED" | \
head -20 | \
tee -a "$REPORT_FILE"
DEVICE_COUNT=$(ip neigh show | grep -v "FAILED" | wc -l)
echo "Dispositivos en tabla ARP: $DEVICE_COUNT" | tee -a "$REPORT_FILE"
fi
echo "" | tee -a "$REPORT_FILE"
}
check_tailscale() {
log "Verificando estado de Tailscale..."
echo "=== ESTADO TAILSCALE ===" | tee -a "$REPORT_FILE"
if command -v tailscale &> /dev/null; then
tailscale status 2>/dev/null | tee -a "$REPORT_FILE"
# Extraer IP de Tailscale
TAILSCALE_IP=$(tailscale status --json 2>/dev/null | \
$([ "$HAS_JQ" = true ] && echo "jq -r '.Self.TailscaleIPs[0]'" || echo "grep -oE '100\.[0-9]+\.[0-9]+\.[0-9]+' | head -1"))
if [ -n "$TAILSCALE_IP" ]; then
success "Tailscale IP: $TAILSCALE_IP"
echo "IP Tailscale: $TAILSCALE_IP" | tee -a "$REPORT_FILE"
else
warning "Tailscale no parece estar conectado"
echo "Tailscale: No conectado" | tee -a "$REPORT_FILE"
fi
else
warning "Tailscale no está instalado"
echo "Tailscale: No instalado" | tee -a "$REPORT_FILE"
fi
echo "" | tee -a "$REPORT_FILE"
}
generate_recommendations() {
log "Generando recomendaciones..."
echo "=== RECOMENDACIONES ===" | tee -a "$REPORT_FILE"
# Recomendación de IP local
if [ -n "$LOCAL_SUBNET" ]; then
BASE_NET=$(echo "$LOCAL_SUBNET" | cut -d'/' -f1 | cut -d'.' -f1-3)
echo "Para configuración local entre srv-dasu y pc-dasu0:" | tee -a "$REPORT_FILE"
echo "" | tee -a "$REPORT_FILE"
echo "1. **IPs recomendadas (fuera de rango DHCP común):**" | tee -a "$REPORT_FILE"
echo " - srv-dasu: ${BASE_NET}.205/24" | tee -a "$REPORT_FILE"
echo " - pc-dasu0: ${BASE_NET}.100/24" | tee -a "$REPORT_FILE"
echo "" | tee -a "$REPORT_FILE"
echo "2. **Configuración de red:**" | tee -a "$REPORT_FILE"
echo " - Gateway: $(echo "$DEFAULT_GW" || echo "[gateway-del-router]")" | tee -a "$REPORT_FILE"
echo " - Máscara: 255.255.255.0 (/24)" | tee -a "$REPORT_FILE"
echo " - DNS Primario: 10.0.100.10 (dc-dasuten)" | tee -a "$REPORT_FILE"
echo " - DNS Secundario: 8.8.8.8" | tee -a "$REPORT_FILE"
echo "" | tee -a "$REPORT_FILE"
echo "3. **Verificaciones previas:**" | tee -a "$REPORT_FILE"
echo " - Confirmar que ${BASE_NET}.205 y ${BASE_NET}.100 no están en uso" | tee -a "$REPORT_FILE"
echo " - Verificar que el firewall permite ICMP y puertos necesarios" | tee -a "$REPORT_FILE"
echo " - Tailscale debe permanecer activo como respaldo" | tee -a "$REPORT_FILE"
else
echo "No se pudo generar recomendaciones específicas (subred no detectada)" | tee -a "$REPORT_FILE"
echo "" | tee -a "$REPORT_FILE"
echo "Recomendaciones generales:" | tee -a "$REPORT_FILE"
echo "1. Identificar manualmente la subred del router ISP" | tee -a "$REPORT_FILE"
echo "2. Usar IPs estáticas fuera del rango DHCP del router" | tee -a "$REPORT_FILE"
echo "3. Mantener Tailscale como ruta de failover" | tee -a "$REPORT_FILE"
fi
echo "" | tee -a "$REPORT_FILE"
}
generate_summary() {
echo "=== RESUMEN DEL DIAGNÓSTICO ===" | tee -a "$REPORT_FILE"
echo "Fecha: $(date)" | tee -a "$REPORT_FILE"
echo "Hostname: $(hostname)" | tee -a "$REPORT_FILE"
echo "Interfaz analizada: $INTERFACE" | tee -a "$REPORT_FILE"
echo "Estado interfaz: $(cat /sys/class/net/"$INTERFACE"/operstate 2>/dev/null || echo "desconocido")" | tee -a "$REPORT_FILE"
echo "Gateway: ${DEFAULT_GW:-No detectado}" | tee -a "$REPORT_FILE"
echo "Subred local: ${LOCAL_SUBNET:-No detectada}" | tee -a "$REPORT_FILE"
echo "Tailscale: $(if command -v tailscale &> /dev/null; then echo "Instalado"; else echo "No instalado"; fi)" | tee -a "$REPORT_FILE"
echo "" | tee -a "$REPORT_FILE"
echo "Archivos generados:" | tee -a "$REPORT_FILE"
echo " - Log detallado: $LOG_FILE" | tee -a "$REPORT_FILE"
echo " - Reporte completo: $REPORT_FILE" | tee -a "$REPORT_FILE"
}
main() {
echo "========================================="
echo " DIAGNÓSTICO DE RED LOCAL - srv-dasu"
echo "========================================="
echo ""
# Inicializar archivos
> "$LOG_FILE"
> "$REPORT_FILE"
# Verificar dependencias
if ! check_dependencies; then
exit 1
fi
# Verificar interfaz
if ! check_interface; then
exit 1
fi
# Ejecutar diagnósticos
get_interface_info
get_routing_info
check_dhcp_info
scan_local_network
check_tailscale
generate_recommendations
generate_summary
echo ""
success "Diagnóstico completado exitosamente"
echo ""
echo "Para configurar IP local en $INTERFACE, edite:"
echo " sudo nano /etc/network/interfaces"
echo ""
echo "Agregue las líneas (adaptando la IP según recomendaciones):"
echo " post-up ip addr add 192.168.1.205/24 dev $INTERFACE"
echo " pre-down ip addr del 192.168.1.205/24 dev $INTERFACE"
echo ""
echo "Luego reinicie el servicio de red:"
echo " sudo systemctl restart networking"
}
# Ejecutar script principal
main "$@"