Desplegá un entorno AI privado seguro: guía práctica de networking y tenencia profunda

Introducción

Integrar modelos de IA en entornos empresariales sin exponer a la organización a riesgos de seguridad, privacidad o cumplimiento es un desafío técnico concreto. La diferencia entre un sandbox de pruebas y un entorno de producción AI seguro no radica solo en el firewall corporativo, sino en cómo estructurás la red, la asignación de recursos GPU y los límites de tenencia desde el nivel organizacional hasta el silicio.

En esta guía, te mostramos cómo construir un entorno AI privado seguro desde la infraestructura, enfocándonos en dos pilares críticos antes de implementar políticas de seguridad avanzadas:

1. Networking segmentado y dinámico usando VMware Cloud Foundation (VCF) y NSX.
2. Tenencia GPU profunda con aislamiento lógico y físico, incluyendo cuotas y control de acceso basado en roles (RBAC).

El resultado es un entorno donde los workloads AI están aislados por diseño, con recursos GPU garantizados por tenant y una red diseñada para contener ataques desde su origen.

Qué es y para qué sirve

Esta configuración es útil cuando:

• Necesitás desplegar modelos de IA en producción sin compartir recursos GPU entre departamentos o equipos de forma insegura.
• Querés evitar que un workload comprometido (por ejemplo, mediante prompt injection o data poisoning) acceda a otros modelos, datos sensibles o infraestructura compartida.
• Buscás maximizar la utilización de GPUs físicas mediante perfiles vGPU compartidos y reservados, con aislamiento de memoria garantizado.

Prerequisitos

Para seguir esta guía necesitás:

• La infraestructura debe incluir un clúster vSphere con GPUs físicas compatibles (ej: NVIDIA A100, H100 o L40S).
• Las GPUs deben estar configuradas con DirectPath I/O o vGPU (recomendado para aislamiento de memoria).
• Si usás un entorno en cloud público (ej: AWS con GPUs), adaptá los conceptos a tu proveedor, pero tené en cuenta que VMware Private AI Foundation está diseñado para entornos on-prem.

Guía paso a paso

Paso 1: Configurar tenencia organizacional con VCF y Private AI Services

El primer nivel de aislamiento es organizacional: cada departamento (o tenant) debe tener su propio espacio de recursos GPU, cuotas y políticas de acceso.

1. Crear un tenant en VMware Private AI Services:

   # Accedé al portal de administración de VCF (https://<vcf-manager-fqdn>/ui)
   # Navegá a: Private AI Services > Tenants > Create Tenant
   # Completá los campos:
   - Tenant Name: "finanzas-ai"
   - Description: "Tenancy para modelos de riesgo y fraude"
   - GPU Classes: Seleccioná "A100-40GB-Reserved" (para workloads críticos) y "A100-40GB-Shared" (para experimentación).
   

– El tenant finanzas-ai aparece en la lista con estado Active.

– Las GPU clases asignadas están visibles en el dashboard de tenencia.

1. Configurar cuotas de GPU por tenant:

   # Archivo de ejemplo para política de cuotas (aplicado via IaC o CLI de VCF)
   apiVersion: v1
   kind: GPUQuota
   metadata:
     name: finanzas-ai-gpu-quota
     namespace: finanzas-ai
   spec:
     tenant: finanzas-ai
     limits:
       - resource: nvidia.com/gpu
         max: "4"  # Máximo 4 GPUs por tenant
         shared: false
       - resource: nvidia.com/gpu.shared
         max: "8"  # Máximo 8 GPUs compartidas
   

   kubectl apply -f finanzas-ai-gpu-quota.yaml
   

– Las cuotas aparecen en el dashboard de VKS como Enforced.

– Si un equipo intenta exceder el límite, los pods se quedarán en estado Pending.

1. Asignar roles RBAC por tenant:

   # Crear rol personalizado en VKS para el tenant
   kubectl apply -f - <<EOF
   apiVersion: rbac.authorization.k8s.io/v1
   kind: Role
   metadata:
     namespace: finanzas-ai
     name: ai-developer
   rules:
   - apiGroups: [""]
     resources: ["pods", "services"]
     verbs: ["create", "get", "list", "watch"]
   - apiGroups: ["apps"]
     resources: ["deployments"]
     verbs: ["create"]
   EOF

   # Asignar rol al grupo de usuarios del tenant
   kubectl create rolebinding finanzas-ai-developers \
     --role=ai-developer \
     --group=cn=ai-finanzas-users,ou=groups,dc=empresa,dc=com \
     --namespace=finanzas-ai
   

– Los usuarios del grupo ai-finanzas-users solo pueden crear/modificar recursos dentro del namespace finanzas-ai.

– Intentar crear un pod en otro namespace fallará con Error from server (Forbidden).

Paso 2: Configurar perfiles vGPU para aislamiento de memoria

Las GPUs físicas deben dividirse en perfiles vGPU con límites de memoria estrictos para evitar side-channel attacks o data leakage.

1. Crear perfiles vGPU en vCenter:

   # Accedé a vCenter > Hosts and Clusters > <tu-cluster> > Configure > vGPU
   # Hacé clic en "Add vGPU Profile":
   - Profile Name: "A100-Reserved-10GB"
   - GPU Type: NVIDIA A100-40GB
   - Framebuffer: 10GB
   - Max Resolutions: 1x1
   - Enable: Time-sliced (pero con prioridad alta para workloads reservados)
   - Assign to: Solo al tenant "finanzas-ai" (en el paso anterior).
   

– El perfil aparece en la lista con estado OK.

– En el dashboard de vGPU, verás que solo 4 GPUs están asignadas a este perfil (según la cuota).

1. Mapear perfiles vGPU a vSphere Namespaces:

   # Crear un namespace en VKS para el tenant
   kubectl create namespace finanzas-ai

   # Configurar el namespace para usar el perfil vGPU
   kubectl apply -f - <<EOF
   apiVersion: v1
   kind: LimitRange
   metadata:
     name: gpu-limits
     namespace: finanzas-ai
   spec:
     limits:
     - default:
         nvidia.com/gpu: "1"
       defaultRequest:
         nvidia.com/gpu: "1"
       type: Container
   EOF

   # Configurar el *vmclass* para pods con GPU
   kubectl apply -f - <<EOF
   apiVersion: vmoperator.vmware.com/v1alpha1
   kind: VirtualMachineClass
   metadata:
     name: a100-reserved-10gb
     namespace: finanzas-ai
   spec:
     hardware:
       cpus: 8
       memory: 32Gi
       devices:
       - name: nvidia.com/A100-Reserved-10GB
         limits:
           nvidia.com/gpu: 1
   EOF
   

– Un pod que solicite nvidia.com/gpu: 1 en el namespace finanzas-ai usará automáticamente el perfil vGPU A100-Reserved-10GB.

– Verificá con:

     kubectl describe limits gpu-limits -n finanzas-ai
     

Paso 3: Implementar networking segmentado con NSX-T

La red es el principal vector de ataque en entornos AI. Configurá segmentación L3 y micro-segmentación para aislar workloads.

1. Crear un Transport Zone dedicado para AI:

   # En NSX Manager: Networking > Transport Zones > Add Transport Zone
   - Name: "ai-tz-overlay"
   - Type: Overlay
   - Traffic Types: "Overlay"
   - Host Switches: Seleccioná los hosts con GPUs.
   

– El Transport Zone aparece con estado Up.

– Solo los hosts con GPUs deben estar asociados.

1. Configurar un Segment para el tenant finanzas-ai:

   # En NSX Manager: Networking > Segments > Add Segment
   - Name: "finanzas-ai-segment"
   - Transport Zone: "ai-tz-overlay"
   - Subnet: 10.100.0.0/24
   - Connected Gateway: Creá un *Tier-1 Gateway* si no existe (ej: `ai-t1-gw`).
   

– El segmento aparece con estado Success y una IP de gateway (ej: 10.100.0.1).

– Los pods en el namespace finanzas-ai deben poder comunicarse solo dentro de este segmento.

1. Aplicar políticas de micro-segmentación:

   # Crear políticas para bloquear tráfico entre tenants
   nsxcli -c "create security-policy ai-isolation-policy"
   nsxcli -c "create rule ai-isolation-policy deny-cross-tenant \
     --source-tag tenant:finanzas-ai \
     --destination-tag tenant:* \
     --action drop"
   nsxcli -c "create rule ai-isolation-policy allow-internal \
     --source-tag tenant:finanzas-ai \
     --destination-tag tenant:finanzas-ai \
     --action allow"
   

– Verificá con:

     nsxcli -c "get security-policy ai-isolation-policy"
     

– Un pod en finanzas-ai no deberá poder hacer ping a un pod en otro tenant (ej: marketing-ai).

Paso 4: Configurar air-gap opcional (si aplica)

Si tenés requisitos de máxima seguridad (ej: modelos con datos confidenciales), implementá un air-gap lógico.

1. Crear un Tier-0 Gateway aislado:

   # En NSX Manager: Networking > Tier-0 Gateways > Add Gateway
   - Name: "ai-airgap-t0"
   - High Availability Mode: Active-Standby
   - Edge Cluster: Seleccioná un clúster de *Edges* dedicado.
   - Enable: "Route Advertisement" (solo rutas necesarias).
   

– El gateway aparece con estado Up.

– Ningún tráfico debe salir del segmento finanzas-ai-segment hacia otros segmentos o internet.

1. Bloquear rutas no autorizadas:

   nsxcli -c "create static-route ai-airgap-t0 \
     --network 0.0.0.0/0 \
     --next-hop <tu-proxy-o-firewall-interno> \
     --admin-distance 100"
   nsxcli -c "create firewall-rule ai-airgap-block-outbound \
     --source any \
     --destination any \
     --action drop \
     --direction out"
   

– Solo el tráfico explícitamente permitido (ej: hacia un proxy de actualización de modelos) pasará.

– Todos los demás intentos de salida serán bloqueados.

Consideraciones y buenas prácticas

1. Limitaciones de vGPU:

– Overhead de performance: Time-sliced puede reducir hasta un 15% el rendimiento en cargas intensivas. Usá reserved profiles para workloads críticos.

1. Alternativas si no tenés VCF:

– NVIDIA MIG (Multi-Instance GPU) para particionar GPUs físicas sin hipervisor.

– Kubernetes Device Plugins + ResourceQuota para límites de GPU.

– Calico o Cilium para micro-segmentación de red.

– Desventaja: Perderás aislamiento de memoria garantizado y gestión centralizada de cuotas.

1. Monitorización:

– Uso de GPUs por tenant (umbral: 90%).

– Violaciones de políticas de red (ej: tráfico entre tenants).

– Ejemplo de alerta para cuotas:

     # Alerta en vROps para exceder cuota de GPU
     apiVersion: v1
     kind: AlertDefinition
     metadata:
       name: gpu-quota-exceeded
     spec:
       adapterKind: "vSphere"
       resourceKind: "VirtualMachine"
       condition:
         - metric: "nvidia_gpu_utilization"
           operator: ">"
           value: "90"
           occurrences: 5
     

1. Errores comunes:

     kubectl get pods -n finanzas-ai -o wide | grep "gpu"
     # Si no ves pods, revisá los logs de VKS:
     kubectl logs -n vmware-system-vks <pod-de-vks> | grep "gpu"
     

– Tráfico bloqueado entre pods: Asegurate de que el Segment de NSX esté conectado al Tier-1 Gateway correcto y que las políticas de firewall no estén en modo Strict.

Conclusión

Configuraste un entorno AI privado seguro desde la infraestructura, con:

✅ Tenencia GPU profunda (aislamiento organizacional + vGPU).

✅ Networking segmentado con NSX-T (micro-segmentación y air-gap opcional).

✅ Cuotas y RBAC para evitar noisy neighbors o accesos no autorizados.

Este es el primer paso crítico antes de implementar capas superiores como Istio (mTLS), WAF (Avi) o políticas de admission control. En la Parte 2 de esta serie, cubriremos cómo desplegar VMware vDefend para firewalling L3 en VMs y pods.

Fuentes

• Guía oficial de VMware: Secure Private AI with Broadcom (Parte 1)
• Documentación de NVIDIA vGPU
• VMware NSX-T Data Center: Micro-segmentación
• Kubernetes Device Plugins para GPUs