Communitygithub.com

Segmentación de VLAN en Homelab

Segmenta tu red doméstica en VLANs para IoT, invitados, dispositivos de confianza y servidores, usando UniFi, pfSense/OPNsense y MikroTik — incluyendo configuración de puertos trunk, reglas de firewall y mapeo de SSID. Útil al separar una red doméstica en VLANs de IoT, invitados, confianza y servidores en UniFi, pfSense/OPNsense o MikroTik.

¿Qué es Segmentación de VLAN en Homelab?

Esta habilidad proporciona una guía completa y detallada para implementar segmentación de VLAN en redes domésticas, enfocándose en la seguridad mediante el aislamiento de diferentes tipos de dispositivos. Es ideal para entornos homelab con equipos de redes como UniFi, pfSense/OPNsense y MikroTik. El documento cubre desde la creación de las VLANs y la configuración de puertos trunk/access hasta el mapeo de SSIDs inalámbricos y la aplicación de reglas de firewall. La guía sigue un enfoque práctico, ofreciendo plantillas de diseño, ejemplos reales y mejores prácticas, además de destacar antpatrones comunes. Esto permite a cualquier usuario, incluso sin experiencia previa en VLANs, implementar una red segmentada de forma segura y eficaz en su homelab.

Compatible con~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/affaan-m/ECC/tree/main/skills/homelab-vlan-segmentation

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

¿Qué hace Segmentación de VLAN en Homelab?

Cómo dividir una red doméstica en VLANs aisladas para que los dispositivos IoT, invitados y tus PCs principales no puedan comunicarse entre sí. La mejora de seguridad más impactante para una red doméstica.

Todas las reglas de firewall mostradas aquí añaden aislamiento entre segmentos — no eliminan protecciones existentes. Aplica los cambios en una ventana de mantenimiento y verifica la conectividad entre segmentos después de cada paso antes de continuar.

Cuándo Usarlo

  • Configurando VLANs en una red doméstica por primera vez
  • Aislando dispositivos IoT (bombillas inteligentes, cámaras, TVs) de dispositivos de confianza
  • Creando una red Wi-Fi para invitados que no pueda alcanzar los dispositivos del hogar
  • Explicar cómo funcionan las VLANs a alguien no familiarizado con el concepto
  • Configurar puertos trunk, puertos access y el mapeo SSID-a-VLAN
  • Solucionar problemas de enrutamiento entre VLANs o reglas de firewall en pfSense/OPNsense/UniFi

Cómo Funciona

Sin VLANs — red plana:
  Todos los dispositivos en 192.168.1.0/24
  Smart TV (potencial malware) → puede acceder a tu NAS, PCs, todo

Con VLANs:
  VLAN 10 — Confianza   192.168.10.0/24  (PCs, teléfonos, laptops)
  VLAN 20 — IoT         192.168.20.0/24  (Smart TV, bombillas, cámaras)
  VLAN 30 — Servidores  192.168.30.0/24  (NAS, Pi, VMs)
  VLAN 40 — Invitados   192.168.40.0/24  (Wi-Fi de visitantes)
  VLAN 99 — Gestión     192.168.99.0/24  (interfaces web del switch/AP)

  Smart TV → bloqueado para acceder a 192.168.10.0/24 y 192.168.30.0/24
  Invitados → solo internet, no pueden ver ningún dispositivo del hogar

Plantilla de Diseño de VLAN

VLAN  Nombre        Subred              Gateway         Propósito
10    confianza     192.168.10.0/24     192.168.10.1    PCs, teléfonos, laptops
20    iot           192.168.20.0/24     192.168.20.1    Dispositivos inteligentes del hogar
30    servidores    192.168.30.0/24     192.168.30.1    NAS, Pi, auto-alojado
40    invitados     192.168.40.0/24     192.168.40.1    Wi-Fi para visitantes
99    gestión       192.168.99.0/24     192.168.99.1    Interfaces web del equipo de red

Ejemplos

Homelab típico con AP UniFi y switch gestionado:

Escenario: Casa de 3 dormitorios, UniFi Dream Machine + switch UniFi de 8 puertos + 2 APs

VLAN 10 — Confianza   192.168.10.0/24   MacBook, iPhones, iPad
VLAN 20 — IoT         192.168.20.0/24   Termostato Nest, Philips Hue, Ring doorbell, Smart TVs
VLAN 30 — Servidores  192.168.30.0/24   Synology NAS (192.168.30.10), Pi-hole (192.168.30.2)
VLAN 40 — Invitados   192.168.40.0/24   Wi-Fi para visitantes — solo internet

Mapeo SSID → VLAN:
  "Home"      → VLAN 10 (WPA2, contraseña fuerte, solo dispositivos de confianza)
  "IoT"       → VLAN 20 (WPA2, contraseña separada, impresa en el router para configuración)
  "Guest"     → VLAN 40 (WPA2, contraseña simple que puedes compartir libremente)

Comportamiento de puertos del switch:
  Puerto 1 → trunk al router (VLANs etiquetadas 10,20,30,40,99)
  Puerto 2 → trunk a los APs (VLANs etiquetadas 10,20,40; el AP maneja el etiquetado por SSID)
  Puerto 3 → access VLAN 30 (NAS — sin etiquetar, no necesita conocimiento de VLAN)
  Puerto 4 → access VLAN 30 (Pi-hole — sin etiquetar)
  Puerto 5–8 → access VLAN 10 (estaciones de trabajo cableadas)

Reglas de firewall aplicadas (todas las reglas añaden aislamiento, ninguna elimina protecciones existentes):
  IoT → Confianza: BLOQUEAR
  IoT → Servidores: BLOQUEAR excepto 192.168.30.2:53 (DNS de Pi-hole permitido)
  IoT → Internet: PERMITIR
  Invitados → Redes locales: BLOQUEAR
  Invitados → Internet: PERMITIR
  Confianza → en todas partes: PERMITIR

Configuración de UniFi

Crear Redes en el Controlador UniFi

Configuración → Redes → Crear Nueva Red

Para cada VLAN:
  Nombre: IoT
  Propósito: Corporativo (proporciona DHCP + enrutamiento)
  ID de VLAN: 20
  Red: 192.168.20.0/24
  IP de Puerta de Enlace: 192.168.20.1
  DHCP: Habilitar
  Rango DHCP: 192.168.20.100 – 192.168.20.254

Mapear SSIDs a VLANs (UniFi)

Configuración → WiFi → Crear Nuevo WiFi

  Nombre: IoT-Network
  Contraseña: <contraseña separada>
  Red: IoT  ← selecciona tu VLAN aquí
  # Todos los dispositivos que se conecten a este SSID caen en la VLAN 20

  Nombre: Invitados
  Contraseña: <contraseña de invitado>
  Red: Invitados
  Política de Invitados: Habilitar  ← también aísla a los invitados entre sí

Reglas de Firewall de UniFi (Reglas de Tráfico)

Configuración → Tráfico y Seguridad → Reglas de Tráfico

# Bloquear IoT para que no acceda a la VLAN de Confianza
  Acción: Bloquear
  Categoría: Red Local
  Origen: IoT (192.168.20.0/24)
  Destino: Confianza (192.168.10.0/24)

# Permitir que IoT solo acceda a internet
  Acción: Permitir
  Origen: IoT
  Destino: Internet

# Bloquear Invitados de todas las redes locales
  Acción: Bloquear
  Origen: Invitados
  Destino: Redes Locales

Configuración de pfSense / OPNsense

Crear VLANs

Interfaces → Asignaciones → VLANs → Agregar

  Interfaz Padre: em1  (tu NIC de LAN)
  Etiqueta VLAN: 20
  Descripción: IoT

# Repite para cada VLAN, luego asigna cada VLAN a una interfaz:
Interfaces → Asignaciones → Agregar
  Selecciona la VLAN que creaste → Haz clic en Agregar
  Habilita la interfaz, establece la IP a la dirección de puerta de enlace (192.168.20.1/24)

DHCP para Cada VLAN

Servicios → Servidor DHCP → Selecciona tu interfaz VLAN

  Habilitar DHCP
  Rango: 192.168.20.100 a 192.168.20.254
  Servidores DNS: 192.168.30.2  ← IP del Pi-hole si lo tienes

Reglas de Firewall (pfSense/OPNsense)

# Las reglas se procesan de arriba a abajo, la primera coincidencia gana.

# En la interfaz IoT (VLAN 20):
  Regla 1: Permitir IoT → DNS de Pi-hole  ← DEBE ir antes de la regla de bloqueo RFC1918
    Protocolo: UDP/TCP
    Origen: Red IoT
    Destino: 192.168.30.2 puerto 53
    Acción: Permitir

  Regla 2: Bloquear IoT → RFC1918 (todos los rangos IP privados)
    Protocolo: cualquiera
    Origen: Red IoT
    Destino: RFC1918 (192.168.0.0/16, 10.0.0.0/8, 172.16.0.0/12)
    Acción: Bloquear

  Regla 3: Permitir IoT → internet
    Protocolo: cualquiera
    Origen: Red IoT
    Destino: cualquiera
    Acción: Permitir

# En la interfaz de Confianza (VLAN 10):
  Permitir todo (los dispositivos de confianza pueden acceder a todo)
    Origen: Red de Confianza
    Destino: cualquiera
    Acción: Permitir

# Excepciones adicionales para dispositivos IoT que necesitan servicios locales específicos:
  Insertar antes de la Regla 2 (el bloqueo RFC1918):
    Protocolo: TCP
    Origen: Red IoT
    Destino: 192.168.30.x puerto 8123  ← Home Assistant
    Acción: Permitir

Configuración de MikroTik

# Paso 1: Crear un bridge con filtrado de VLAN habilitado
/interface bridge
add name=bridge vlan-filtering=yes

# Paso 2: Agregar puertos físicos al bridge
# Puerto trunk al router/enlace ascendente (etiquetado para todas las VLANs)
/interface bridge port
add bridge=bridge interface=ether1 frame-types=admit-only-vlan-tagged

# Puerto access para dispositivos de confianza (VLAN 10 sin etiquetar)
/interface bridge port
add bridge=bridge interface=ether2 pvid=10 frame-types=admit-only-untagged-and-priority-tagged

# Puerto access para dispositivos IoT (VLAN 20 sin etiquetar)
/interface bridge port
add bridge=bridge interface=ether3 pvid=20 frame-types=admit-only-untagged-and-priority-tagged

# Paso 3: Definir qué VLANs están permitidas en qué puertos
/interface bridge vlan
add bridge=bridge tagged=ether1 untagged=ether2 vlan-ids=10
add bridge=bridge tagged=ether1 untagged=ether3 vlan-ids=20

# Paso 4: Crear interfaces VLAN en el bridge (IPs de puerta de enlace)
/interface vlan
add interface=bridge name=vlan10 vlan-id=10
add interface=bridge name=vlan20 vlan-id=20

# Paso 5: Asignar IPs de puerta de enlace
/ip address
add interface=vlan10 address=192.168.10.1/24
add interface=vlan20 address=192.168.20.1/24

# Paso 6: Pools y servidores DHCP
/ip pool
add name=pool-conftrust ranges=192.168.10.100-192.168.10.254
add name=pool-iot ranges=192.168.20.100-192.168.20.254

/ip dhcp-server
add interface=vlan10 address-pool=pool-conftrust name=dhcp-conftrust
add interface=vlan20 address-pool=pool-iot name=dhcp-iot

/ip dhcp-server network
add address=192.168.10.0/24 gateway=192.168.10.1
add address=192.168.20.0/24 gateway=192.168.20.1

# Paso 7: Firewall — bloquear IoT para que no acceda a la VLAN de confianza
/ip firewall filter
add chain=forward src-address=192.168.20.0/24 dst-address=192.168.10.0/24 \
    action=drop comment="Bloquear IoT a Confianza"

Puertos Trunk vs Access en el Switch

# Puerto trunk: transporta múltiples VLANs (etiquetadas) — conecta switch-a-switch, switch-a-router, switch-a-AP
# Puerto access: transporta una VLAN (sin etiquetar) — conecta a dispositivos finales (PC, cámara, NAS)

# Un puerto de switch gestionado conectado a tu router debe ser un trunk:
  VLANs permitidas: 10, 20, 30, 40, 99

# Un puerto que conecta a una PC debe ser un puerto access:
  VLAN: 10 (confianza)
  Sin etiquetar — la PC no sabe ni le importan las VLANs

# Un puerto que conecta a un AP debe ser un trunk:
  El AP etiqueta el tráfico de cada SSID con el ID de VLAN correcto
  VLANs permitidas: 10, 20, 40  (cualesquiera SSIDs que sirva el AP)

Antipatrones

# MALO: Crear VLANs sin añadir reglas de firewall
# Las VLANs sin reglas de firewall no proporcionan seguridad — el enrutamiento entre VLANs está abierto por defecto
# BIEN: Agregar reglas de bloqueo explícitas inmediatamente después de crear las VLANs

# MALO: Poner el Pi-hole en la VLAN de IoT
# Los dispositivos IoT pueden alcanzarlo pero los de confianza no (sin reglas adicionales)
# BIEN: Pi-hole en la VLAN de Servidores con una regla que permita a todas las VLANs acceder al puerto 53

# MALO: VLAN nativa igual a VLAN de gestión
# El tráfico sin etiquetar que llega a tu VLAN de gestión permite ataques de salto de VLAN
# BIEN: Usar una VLAN dedicada no utilizada como nativa (ej. VLAN 999), mantener el tráfico de gestión etiquetado

# MALO: Misma contraseña Wi-Fi para SSID de IoT y SSID de confianza
# Cualquiera que aprenda la contraseña puede conectar dispositivos IoT al segmento incorrecto

Mejores Prácticas

  • Comienza con 4 VLANs: Confianza, IoT, Servidores, Invitados — añade más según sea necesario
  • Coloca el Pi-hole en la VLAN de Servidores (192.168.30.x)
  • Agrega una regla de firewall que permita DNS (puerto 53) desde todas las VLANs a la IP del Pi-hole — antes de cualquier regla de bloqueo RFC1918
  • Prueba el aislamiento después de cada cambio de regla: desde la VLAN de IoT, intenta hacer ping a un dispositivo de confianza — debe fallar
  • Usa una VLAN de gestión para las interfaces web del switch y AP y restringe el acceso solo a la VLAN de Confianza
  • Documenta tu diseño de VLAN en una tabla (ID de VLAN, nombre, subred, propósito)

Habilidades Relacionadas

  • homelab-network-setup
  • homelab-pihole-dns
  • homelab-wireguard-vpn

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

accessibility

Design, implement, and audit inclusive digital products using WCAG 2.2 Level AA. Use when building or auditing UI that must meet WCAG 2.2 Level AA, or when reviewing a change for keyboard, contrast, or screen-reader support.

affaan-m/content-engine

Create platform-native content systems for X, LinkedIn, TikTok, YouTube, newsletters, and repurposed multi-platform campaigns. Use when the user wants social posts, threads, scripts, content calendars, or one source asset adapted cleanly across platforms.

affaan-m/ECC

Multi-platform content distribution across X, LinkedIn, Threads, and Bluesky. Adapts content per platform using content-engine patterns. Never posts identical content cross-platform. Use when the user wants to distribute content across social platforms.

affaan-m/fal-ai-media

Unified media generation via fal.ai MCP — image, video, and audio. Covers text-to-image (Nano Banana), text/image-to-video (Seedance, Kling, Veo 3), text-to-speech (CSM-1B), and video-to-audio (ThinkSound). Use when the user wants to generate images, videos, or audio with AI.

affaan-m/manim-video

日本語翻訳:このファイルは manim-video 用の日本語翻訳が必要です

affaan-m/remotion-video-creation

Remotion のベストプラクティス - React で動画を作成する。3D、アニメーション、音声、字幕、チャート、トランジションなどをカバーするドメイン固有の29のルール。

affaan-m/video-editing

AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content.

agent-architecture-audit

Full-stack diagnostic for agent and LLM applications. Audits the 12-layer agent stack for wrapper regression, memory pollution, tool discipline failures, hidden repair loops, and rendering corruption. Produces severity-ranked findings with code-first fixes. Essential for developers building agent applications, autonomous loops, or any LLM-powered feature. Use when an agent or LLM feature misbehaves and the failing layer is unknown, or before shipping an agent stack.

agent-eval

Head-to-head comparison of coding agents (Claude Code, Aider, Codex, etc.) on custom tasks with pass rate, cost, time, and consistency metrics. Use when choosing between coding agents, or when a change to an agent setup needs measured pass rate, cost, and time rather than an impression.

agent-harness-construction

Design and optimize AI agent action spaces, tool definitions, and observation formatting for higher completion rates. Use when defining or revising an agent

agentic-engineering

Operate as an agentic engineer using eval-first execution, decomposition, and cost-aware model routing. Use when planning or executing engineering work that agents will carry out end to end.

agentic-os

Build persistent multi-agent operating systems on Claude Code. Covers kernel architecture, specialist agents, slash commands, file-based memory, scheduled automation, and state management without external databases. Use when building a persistent multi-agent system on Claude Code with its own memory, commands, and scheduling.

agent-introspection-debugging

Structured self-debugging workflow for AI agent failures using capture, diagnosis, contained recovery, and introspection reports. Use when an agent run fails and you need a reproducible diagnosis instead of a retry.

agent-payment-x402

Add x402 payment execution to AI agents with per-task budgets, spending controls, and non-custodial wallets. Supports Base through agentwallet-sdk and X Layer through OKX Payments / OKX Agent Payments Protocol. Use when an agent must pay for something itself and needs per-task budgets, spending controls, and a non-custodial wallet.

agent-self-evaluation

Use after completing any non-trivial task. The agent self-rates its output on 5 axes — accuracy, completeness, clarity, actionability, conciseness — with concrete evidence per criterion. Produces a structured 1-5 scorecard with specific improvement suggestions.

agent-sort

Build an evidence-backed ECC install plan for a specific repo by sorting skills, commands, rules, hooks, and extras into DAILY vs LIBRARY buckets using parallel repo-aware review passes. Use when ECC should be trimmed to what a project actually needs instead of loading the full bundle.

ai-first-engineering

Engineering operating model for teams where AI agents generate a large share of implementation output. Use when setting team process, review gates, or ownership rules for a codebase largely written by agents.

ai-regression-testing

Regression testing strategies for AI-assisted development. Sandbox-mode API testing without database dependencies, automated bug-check workflows, and patterns to catch AI blind spots where the same model writes and reviews code. Use when adding regression coverage to AI-assisted code, or when the same model both wrote and reviewed a change.

android-clean-architecture

Clean Architecture patterns for Android and Kotlin Multiplatform projects — module structure, dependency rules, UseCases, Repositories, and data layer patterns. Use when structuring modules, layers, or data flow in an Android or KMP project.

angular-developer

Generates Angular code and provides architectural guidance. Trigger when creating projects, components, or services, or for best practices on reactivity (signals, linkedSignal, resource), forms, dependency injection, routing, SSR, accessibility (ARIA), animations, styling (component styles, Tailwind CSS), testing, or CLI tooling.

Skills relacionados