Alternativas a AWS IoT TwinMaker: crea gemelos digitales 3D sin dependencia de la nube

Una alternativa a AWS IoT TwinMaker tiene sentido cuando quieres gemelos digitales 3D interactivos pero prefieres formatos abiertos, protocolos estándar y la libertad de ejecutarlos en cualquier parte. Esta guía compara las alternativas realistas, desde otras plataformas hasta stacks web totalmente abiertos, y después muestra la técnica central: vincular datos MQTT en vivo a nodos de un modelo glTF en el navegador. Terminarás con un patrón funcional que puedes ampliar hasta un gemelo 3D completo.

Para el contexto general sobre gemelos, consulta la guía de tecnología de gemelo digital.

Qué reúne TwinMaker

AWS IoT TwinMaker combina varias piezas que necesita un gemelo 3D:

• Entidades y componentes que modelan tus activos y los enlazan con fuentes de datos.
• Conectores con otros servicios de datos de AWS para series temporales, vídeo y documentos.
• Un compositor de escenas para colocar modelos 3D y asociarles etiquetas y reglas de color basadas en datos.
• Visualización mediante un plugin de Grafana o un kit de aplicación para apps web a medida.

Cuando tus datos ya están en esos servicios de AWS, resulta cómodo. El inconveniente es que el gemelo, sus escenas y sus vinculaciones de datos se expresan con conceptos específicos del servicio. Pasar a otra nube, o a la red local de una planta, implica reconstruirlos. Además, las hojas de ruta de las plataformas cambian con el tiempo, así que comprueba el estado actual de cualquier servicio gestionado de gemelos antes de comprometer con él un proyecto de larga duración.

Qué necesita un gemelo 3D portable

Si quitas las marcas, todo gemelo 3D tiene las mismas cinco capas:

Cada capa tiene opciones abiertas y maduras, y cada una puede sustituirse sin tocar las demás. Esa independencia es la verdadera respuesta a la dependencia de un proveedor.

Comparativa de alternativas

Los motores de videojuegos destacan en formación fotorrealista y realidad virtual; consulta la guía de gemelo digital con Unity. Para dashboards de operaciones que cualquiera pueda abrir en un navegador, las librerías web suelen encajar mejor. La guía de gemelo digital 3D en la web compara Three.js y Babylon.js con más detalle.

Vincular datos MQTT a un modelo glTF

El corazón de cualquier sustituto de TwinMaker es la capa de vinculación: "cuando cambie este topic, actualiza ese nodo 3D". Mantén la vinculación en datos, no en código, para que la puedan mantener personas que no son desarrolladoras.

Este es un archivo de mapeo. Cada entrada enlaza un topic y un campo del payload con un nodo con nombre de la escena glTF e indica qué hacer con el valor:

[
  { "topic": "furnace1/state", "field": "temp_c", "node": "Furnace_Body",
    "action": "color", "ranges": [[0, 600, "#4caf50"], [600, 900, "#ff9800"], [900, 2000, "#f44336"]] },
  { "topic": "conveyor1/state", "field": "running", "node": "Conveyor_Belt",
    "action": "visible-flag" },
  { "topic": "tank3/state", "field": "level_pct", "node": "Tank3_Liquid",
    "action": "scale-y", "max": 100 }
]

Y el módulo de navegador que lo aplica. Instala three y mqtt con npm y empaqueta con Vite o similar. El modelo plant.glb debe contener nodos con los nombres usados en el mapeo.

import * as THREE from "three";
import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
import { OrbitControls } from "three/examples/jsm/controls/OrbitControls.js";
import mqtt from "mqtt";
import bindings from "./bindings.json";

const PREFIX = "connectmq/demo/tm-alt-2h7/site1";
const scene = new THREE.Scene();
const camera = new THREE.PerspectiveCamera(45, innerWidth / innerHeight, 0.1, 500);
camera.position.set(20, 15, 20);
const renderer = new THREE.WebGLRenderer({ antialias: true });
renderer.setSize(innerWidth, innerHeight);
document.body.appendChild(renderer.domElement);
new OrbitControls(camera, renderer.domElement);
scene.add(new THREE.HemisphereLight(0xffffff, 0x404040, 3));

const nodes = {};
new GLTFLoader().load("/plant.glb", (gltf) => {
  scene.add(gltf.scene);
  for (const b of bindings) {
    const obj = gltf.scene.getObjectByName(b.node);
    if (!obj) { console.warn("Missing node", b.node); continue; }
    obj.traverse((o) => { if (o.isMesh) o.material = o.material.clone(); });
    nodes[b.node] = obj;
  }
});

function apply(b, value) {
  const obj = nodes[b.node];
  if (!obj) return;
  if (b.action === "color") {
    const hit = b.ranges.find(([lo, hi]) => value >= lo && value < hi);
    if (hit) obj.traverse((o) => o.isMesh && o.material.color.set(hit[2]));
  } else if (b.action === "visible-flag") {
    obj.traverse((o) => o.isMesh && o.material.emissive?.set(value ? 0x224422 : 0x000000));
  } else if (b.action === "scale-y") {
    obj.scale.y = Math.max(0.01, value / b.max);
  }
}

const client = mqtt.connect("wss://broker.connectmq.com:8084/mqtt", {
  clientId: "tm-alt-2h7-view-" + Math.random().toString(16).slice(2, 8),
  protocolVersion: 5,
});
client.on("connect", () => client.subscribe(`${PREFIX}/+/state`));
client.on("message", (topic, payload) => {
  const rel = topic.slice(PREFIX.length + 1);
  const data = JSON.parse(payload.toString());
  for (const b of bindings) if (b.topic === rel && b.field in data) apply(b, data[b.field]);
});

renderer.setAnimationLoop(() => renderer.render(scene, camera));

Pruébalo publicando estados retenidos en el servidor MQTT público gratuito de broker.connectmq.com, pensado solo para pruebas y prototipos, no para datos de producción:

mosquitto_pub -h broker.connectmq.com -p 1883 -i tm-alt-2h7-pub -r \
  -t "connectmq/demo/tm-alt-2h7/site1/furnace1/state" -m '{"temp_c":935}'
mosquitto_pub -h broker.connectmq.com -p 1883 -i tm-alt-2h7-pub2 -r \
  -t "connectmq/demo/tm-alt-2h7/site1/tank3/state" -m '{"level_pct":62}'

Como los estados son retenidos, la escena muestra los colores y niveles correctos en cuanto se carga, y después se actualiza en vivo. Es la misma experiencia que ofrece un compositor de escenas gestionado, construida con piezas abiertas. La guía para vincular datos IoT a un modelo 3D cubre más acciones, como animaciones, etiquetas y parpadeo de alarmas, y la documentación de Three.js es la referencia para la parte de renderizado.

Errores habituales al abandonar un servicio de gemelos gestionado

• Los nombres de los nodos cambian. Volver a exportar un modelo CAD puede renombrar nodos y romper las vinculaciones sin avisar. Registra los nodos que faltan al cargar, como hace el código anterior, y mantén estables los nombres en tu proceso de exportación.
• Materiales compartidos. En glTF, muchas mallas suelen compartir un mismo material, así que colorear un nodo los colorea todos. Clona los materiales de los nodos vinculados.
• Modelos pesados. Las exportaciones CAD pueden ser enormes. Reduce la geometría, fusiona las mallas estáticas y usa glTF comprimido para mantener tiempos de carga razonables.
• El historial va aparte. Los datos MQTT en vivo controlan la escena, pero las tendencias y la reproducción necesitan una base de datos. Suscribe a los mismos topics un servicio escritor o Telegraf.
• Credenciales en el navegador. Todo lo que se entrega a un navegador lo puede leer su usuario. Da a los visores credenciales orientadas a la lectura, separadas de las de los gateways que publican.
• Estado ausente en la primera carga. Si los gateways solo publican cambios, una escena recién abierta se queda vacía hasta que algo cambia. Publica mensajes de estado completo con el flag retain para que cada visor empiece con la imagen actual.
• Renderizar cada mensaje. La telemetría de alta frecuencia puede provocar más actualizaciones de escena de las que la pantalla puede mostrar. Guarda los últimos valores cuando llegan los mensajes y aplícalos una vez por fotograma de animación.

Una ruta de migración en cuatro pasos

Si vas a sustituir un gemelo gestionado existente en lugar de empezar de cero, avanza con pasos pequeños y reversibles:

1. Exporta tus activos 3D a glTF y confirma los nombres de nodo que necesitas para las vinculaciones.
2. Haz que los gateways publiquen en un broker MQTT en paralelo con la ruta de datos existente.
3. Reconstruye las vinculaciones de la escena como un archivo de mapeo y compara el nuevo visor con el antiguo lado a lado.
4. Traslada el historial a una base de datos de series temporales alimentada desde los mismos topics y después retira la ruta antigua.

Alojar la capa de datos

La capa de datos en vivo es la única pieza que debe estar siempre activa y ser accesible tanto desde la planta como desde el navegador. Un broker MQTT gestionado compatible con WebSocket seguro lo resuelve sin abrir puertos en la planta: los gateways se conectan hacia fuera por TLS y los navegadores por WSS.

ConnectMQ ofrece exactamente eso: TLS en el 8883 para los gateways, WebSocket seguro en el 8084 con la ruta /mqtt para los navegadores, compatibilidad con MQTT 5 y un portal con explorador de topics en vivo. ConnectMQ también mantiene una demo web pública de gemelo digital 3D, una fábrica con máquina CNC, brazo robótico, horno, tanque, cinta transportadora y bomba actualizados en vivo por WSS, construida con este mismo patrón de navegador más MQTT. Para producción, sustituye el endpoint público por las credenciales de tu broker privado obtenidas en el portal: YOUR_USERNAME, YOUR_PASSWORD y YOUR_CLIENT_ID.

Construye tu gemelo 3D en ConnectMQ

Las librerías 3D web abiertas más un broker MQTT estándar te dan un gemelo interactivo que controlas por completo. Empieza con un broker Serverless gratuito de ConnectMQ, sin tarjeta de crédito, y conecta hoy tu primera escena glTF a datos en vivo.

Preguntas frecuentes

¿Cuál es una buena alternativa a AWS IoT TwinMaker para 3D?

Para gemelos de operaciones en el navegador, Three.js o Babylon.js con modelos glTF y MQTT sobre WebSocket seguro es una opción flexible y portable. Los motores de videojuegos como Unity encajan con experiencias fotorrealistas o de realidad virtual.

¿Puedo reutilizar mis modelos 3D de TwinMaker?

Normalmente sí, si están en formato glTF o GLB. Tendrás que recrear las vinculaciones de datos y la colocación de etiquetas, algo más sencillo si las mantienes en un archivo de mapeo como el mostrado arriba.

¿Los navegadores se conectan directamente a MQTT?

Sí. MQTT.js se conecta por WebSocket o WebSocket seguro, así que una página web puede suscribirse a topics sin un backend intermediario. En producción, usa TLS y credenciales independientes para los visores.

¿Adónde van los datos históricos sin TwinMaker?

Usa una base de datos de series temporales alimentada por un suscriptor MQTT, como Telegraf o un pequeño script, y visualízala en Grafana o en gráficos dentro de la propia página del gemelo.