🚀 Potencia tu NodeJS con Rust

Hola, mi nombre es Dmitry Kudravtsev, soy un ingeniero de software senior y estoy muy apasionado por dos cosas, JavaScript y Rust. Y hoy quiero hablar contigo sobre cómo puedes potenciar tu experiencia con JavaScript y Node.js utilizando el lenguaje de programación Rust. Así que vamos a sumergirnos.

Todos sabemos que Node.js es genial. Tiene un gran ecosistema de paquetes. Creo que es el ecosistema más grande de paquetes entre todos los lenguajes de programación. Tiene una experiencia de desarrollo muy agradable. Puedes escribir y reiniciar el servidor en pocas líneas de código. TypeScript está haciendo la experiencia aún mejor. Así que puedes obtener verificación de tipos en un lenguaje que no es de tipado estático, pero aún así la verificación de tipos, lo cual es agradable.

Pero Node.js también es lento a veces, especialmente si estás realizando tareas de CPU. Digamos, la generación, tal vez el procesamiento de imágenes. He visto a personas encontrar soluciones muy creativas a estos problemas, como externalizar tareas de CPU a otro proceso que puede trabajar en eso. Y algunas personas utilizan servidores Lambda que se pueden llamar bajo demanda si tienes alguna computación pesada. Pero también hay otra solución. Y la solución es escribir módulos nativos en C o C++ o Rust. Ahora probablemente te preguntes por qué Rust, o qué es Rust, por qué no simplemente usar C o C++. Así que intentemos responder a esta pregunta primero.

Y como probablemente sabes, C y C++ son bastante antiguos, ya han mostrado su edad. Aún están en desarrollo. Creo que C++ ya tiene la versión 21. No estoy muy seguro, no lo sigo mucho, pero de todos modos, son antiguos, son un poco desordenados. Carecen de herramientas modernas. No hay un administrador de dependencias decente y tienen una biblioteca estándar relativamente pobre. La mayoría de las veces, cuando necesitas contenedores o iteradores pesados, tienes que usar una biblioteca llamada Boost. Muchas cosas de Boost se incorporan a la especificación de C++, pero aún faltan muchas cosas. La mayor desventaja, en mi opinión, es que no son seguros en cuanto a la memoria. Probablemente hayas visto este mensaje que todos odiamos, volcados de memoria, fallas de implementación, porque en algún lugar olvidaste detener tu bucle for y has iterado demasiado en tu matriz o accediste a la memoria que ya no es propiedad de la aplicación. Esto hace que el desarrollo en C y C++ sea muy difícil. Rust, por otro lado, es un lenguaje fuertemente tipado y compilado, al igual que C y C++.

Rust tiene una biblioteca estándar rica, por lo que obtienes llamadas inteligentes, iteradores, todo está integrado en el propio lenguaje. No necesitas paquetes de terceros para agregar soporte para estas cosas. Tiene un modelo de herramientas, por lo que tienes Cargo, que es equivalente a NPM, y puedes ejecutar tareas con él, puedes instalar paquetes con Cargo.

La mayor ventaja, en mi opinión, es que Rust es seguro en cuanto a la memoria. La forma en que logran la seguridad de la memoria es muy interesante, no voy a profundizar en ello, puedes leer al respecto si estás interesado. La idea con Rust es que si compila, se ejecutará, por lo que no habrá errores de memoria. La memoria se verifica en tiempo de compilación, es una gran ventaja en comparación con C o C++. Aún puedes escribir SafeRust, es posible, pero por defecto, todo el Rust que escribas es SafeRust y se verifica en tiempo de compilación.

Bien, es genial saberlo, pero tú y yo, todos escribimos JavaScript, ¿cómo podemos integrar entre los dos? Ahí es donde entra NEON. NEON es una biblioteca en la cadena para incrustar Rust en Node.js. Es un proyecto de código abierto y muy interesante, te sugiero que lo revises. Veamos la función Fibonacci que escribimos en Rust y la exportamos al mundo de JavaScript. A continuación se muestra el código. No te preocupes, más adelante en la presentación tendré enlaces a mi Github para que puedas encontrar ejemplos ejecutables. Pero por ahora, centrémonos en este ejemplo y dividiéndolo en algunos bloques para que sea más fácil de analizar.

En las líneas 1-4, tenemos las declaraciones de importación y requerimiento equivalentes de Node.js. Traemos algunas cosas de la biblioteca NEON. Las líneas 6-12 son la función Fibonacci real. No hay nada especial aquí, es una función recursiva que busca el número de Fibonacci requerido. Ahora, las líneas 14-18 son lo que llamo una capa de enlace entre el mundo de JavaScript y el mundo de Rust, y dado que los dos lenguajes son diferentes y tienen una arquitectura diferente, necesitamos una forma de convertir los tipos de JavaScript en tipos de Rust. Siempre tienes que escribir una capa de enlace en NEON que convertirá tu JavaScript en llamadas a Rust, y eso es lo que estamos haciendo en esas cinco líneas. Convertimos la llamada de JavaScript en una llamada a Rust, y realmente llamamos a una función Fibonacci, devolvemos el resultado a JavaScript y, como en cualquier ejecutable, necesitamos tener una función principal. En el caso de NEON, la función principal es una declaración de exportación y, por lo tanto, puedes exportar funciones de Rust de vuelta al mundo de JavaScript. En este caso, exportamos la función de la API de Fibonacci como Fibonacci-rhs, por lo que en JavaScript podemos acceder a ella como Fibonacci-rhs. Para construir esto, hay otra herramienta que mantiene el equipo de NEON. Se llama Cargo-cprtfacts. Copia el artefacto que produce Cargobuild y lo que hace detrás de escena es generar una biblioteca dinámica, por lo que tiene el equivalente de DLL o SOA, si estás en Windows o Unix, pero tiene todos los envoltorios de NEON y las API de Node.js, porque Node.js no admite una interfaz de funciones externas. En realidad, JavaScript no admite una interfaz de funciones externas, pero Node.js sí lo admite, por lo que podemos escribir bibliotecas nativas para Node.js. Para llamar a la biblioteca nativa, la requerimos como un módulo regular de Node.js. Podemos ver en la línea 1, el índice de nodo que hemos generado anteriormente.

Lo requerimos como una función regular y luego lo llamamos como una función regular. Lo interesante es que esto también generará definiciones de TypeScript para que puedas escribir código nativo de Rust y tener las definiciones de TypeScript en tu código JavaScript.

El proceso de integración es bastante fácil, en mi opinión. Y es genial. Te sugiero que revises NEON, es una gran biblioteca. Y nos permite incrustar Rust en el código JavaScript.

Ahora, si estás familiarizado con WebAssembly, probablemente te preguntes, ¿por qué no WebAssembly? Antes de responder a esta pregunta, comprendamos qué es WebAssembly. WebAssembly es un formato binario portátil y el formato de texto correspondiente. Puedes pensar en ello como el ensamblador de la arquitectura X86. Es un poco diferente, es una versión web y se ejecuta en una máquina virtual, por lo que el binario compilado no es nativo. Es nativo para la máquina virtual y es importante recordarlo. Es compatible con todos los principales navegadores, por lo que puedes usarlo en Firefox, Edge, Safari.

Lo interesante de WebAssembly es que puede ser un objetivo de compilación para otros lenguajes y Rust está entre ellos. Por lo tanto, puedes tomar un código escrito en Rust y compilarlo a WebAssembly, lo cual es bastante interesante. Pero si no quieres hacer eso, también hay un lenguaje especial llamado AssemblyScript, que es una versión limitada de TypeScript, diría yo, que puedes escribir y se compilará a WebAssembly.

Echemos un vistazo a un ejemplo de cómo podemos escribir la misma función Fibonacci, pero esta vez se compilará a WebAssembly. Es mucho más corto. Además de la función en sí, solo necesitamos dos cosas, la declaración de uso y la macro que hacemos en la línea 3. Dado que WebAssembly es tipado, tienes tipos, entonces Wasm-bind, que es el paquete que convierte el código Rust a WebAssembly, hará toda la magia necesaria para convertir este código a WebAssembly. Ten en cuenta que si tienes estructuras complejas como una estructura personalizada y funcionalidad personalizada, necesitarás tener un mapeo personalizado para ello. Wasm-bind no sabe cómo convertir tipos no primitivos como enteros, flotantes y cadenas a WebAssembly. Pero si tienes funciones simples como esta Fibonacci, la conversión es sencilla porque WebAssembly admite enteros y flotantes de forma nativa. Por lo tanto, Wasm-bind es capaz de convertir este código a WebAssembly nativo.

Ahora, te mostré dos formas de escribir módulos nativos en JavaScript y probablemente te preguntes cuál es más rápido. Así que, benchmarks. Realicé pruebas de rendimiento en cuatro números Fibonacci diferentes. Lo que ves aquí es el tiempo de ejecución promedio que obtuve de Hyperfine, que es una herramienta de benchmarking. El color verde indica el rendimiento mejorado en comparación con JavaScript.

Se puede observar una anomalía aquí en el número de Fibonacci más pequeño. Se puede ver que la mejora de rendimiento es bastante insignificante, y esto es un buen recordatorio para todos los que están trabajando en el rendimiento y desean mejorar algo. Siempre, siempre realiza pruebas de rendimiento, porque si necesitas calcular números de Fibonacci bajos, por ejemplo, la mejora de rendimiento que obtienes de los módulos nativos no vale la pena el esfuerzo. Pero si avanzas en los números de Fibonacci, puedes ver que obtenemos un impulso tremendo en la mejora de rendimiento, que es aproximadamente del 60% si usas Rust y alrededor del 45% si usas WebAssembly, lo cual es mucho. Es el doble de rápido en comparación con JavaScript. También podemos sacar una segunda conclusión, Rust es aproximadamente un 45% más rápido que Wasm. Y también hay una nota de que siempre debes ejecutar tus propias pruebas de rendimiento para asegurarte de que lo que estás evaluando, el rendimiento que estás obteniendo de ello, valga la pena el esfuerzo. Porque, como dije, puedes ver que en el número de Fibonacci más lejano, las ganancias de rendimiento no son tan espectaculares en comparación con los números 44 o 45 de Fibonacci.

Entonces, hemos visto dos formas de escribir módulos nativos. Podemos hacer módulos nativos directamente o podemos usar Rust que se compila a WebAssembly y probablemente te preguntes, ¿cuál deberías usar y cuándo? Así que veamos algunos ejemplos, algunas categorías que he delineado para ayudarte a tomar una mejor decisión sobre cuándo usar módulos nativos y cuándo usar WebAssembly.

Si hablamos de rendimiento, creo que está bastante claro que los módulos nativos de Rust serán más rápidos, ya que lo nativo siempre será más rápido que cualquier cosa ejecutada en la máquina virtual, porque no tenemos una capa de conversión, que es la propia máquina virtual. Mira C o C++ en comparación con Java, obviamente puedes escribir código no eficiente en cualquier lenguaje de programación, pero si hablamos del lenguaje, si sabes cómo escribir código eficiente, siempre lograrás un mejor rendimiento si evitas la máquina virtual, pero también vale la pena señalar que WebAssembly es muy rápido. Me sorprendió saber que, aunque se ejecuta en una máquina virtual, es bastante genial saber que WebAssembly está a nuestra disposición y es compatible con todos los principales navegadores, así como con Node.js.

Hablemos de reutilización. Cuando hablo de reutilización, me refiero a tomar el mismo código y ejecutarlo en diferentes plataformas. En ese caso, es un poco complicado porque las bibliotecas nativas se pueden reutilizar en otros lenguajes a través de algo llamado interfaz de funciones externas, que es una FFI. Por ejemplo, puedes tener tu lógica de negocio escrita en Rust y puedes usarla en Node.js, puedes usarla en Java y puedes usarla en tu aplicación de iOS escrita en Swift. En cambio, WebAssembly solo es portátil en diferentes máquinas virtuales de WebAssembly. Entonces, tu código de WebAssembly se ejecutará en Edge, en Firefox, en Safari, en Node.js, pero no podrás ejecutarlo en Android, por ejemplo, a menos que tengas una máquina virtual que pueda ejecutar WebAssembly.

Si hablamos de ergonomía, estoy bastante seguro de que está claro que WebAssembly tiene una ergonomía mucho mejor. El código es mucho más corto y el ejemplo de enlace que te mostré prácticamente no requiere nada para convertir la función nativa de Rust en WebAssembly. Es capaz de convertir tipos básicos como enteros y flotantes. Neon, por otro lado, necesita una capa de enlace para convertir tu código de Rust y JavaScript en Rust. Por lo tanto, la ergonomía sufre un poco en el ejemplo nativo en comparación con el de WebAssembly.

Si hablamos de stdlib, que es todo, la red del sistema, si quieres acceder al sistema operativo, entonces tu única opción es usar módulos nativos de Rust. Porque WebAssembly no puede acceder a las bibliotecas estándar, por lo que no puedes acceder al sistema de archivos, no puedes acceder a la red, a menos que estés dispuesto a esperar una interfaz de sistema de WebAssembly, que aún está en desarrollo, pero están trabajando en hacerla accesible también para WebAssembly.

En cuanto a la portabilidad, funciona en mi máquina, así que siempre debes recordar que el código nativo depende de la máquina, por lo que si lo compilas en macOS, no podrás ejecutarlo en Windows. Entonces, si estás desarrollando en macOS y tu entorno de producción es Linux sin contenedores, debes compilarlo para Linux sin contenedores, por lo que puedes usar Docker para eso. Por otro lado, si compilo mi código en WebAssembly y te doy el ejecutable, podrás ejecutarlo en tu navegador siempre que sea compatible con WebAssembly, lo cual no es cierto para los modelos nativos que compilo en mi máquina. Es muy probable que no puedas hacerlo si tu máquina es diferente. Por ejemplo, si tienes una Mac con procesador Intel y yo tengo una Mac con procesador ARM, entonces necesita ser recompilado, especialmente si tienes una máquina con Windows o Linux, también necesita ser compilado.

Y si hablamos de la barrera de entrada para nuevos desarrolladores, creo que WebAssembly es más fácil. Si quieres introducir código de rendimiento en tu ecosistema de Node.js, te sugiero que uses WebAssembly porque los modelos nativos solo se pueden escribir en C, C++ o Rust. Esos son lenguajes bastante complejos de entender para principiantes, para personas junior. No digo que sea imposible, pero la inversión será bastante grande si solo quieres reescribir una o dos funciones en código nativo de rendimiento. WebAssembly, aunque se puede compilar desde C, C++ o Rust, también tiene soporte parcial para Python, Ruby y Go. Además, existe un lenguaje especializado llamado AssemblyScript que está dedicado a WebAssembly, por lo que siempre puedes comenzar con AssemblyScript y obtener tu versión de WebAssembly, y si necesitas exprimir hasta el último ápice de rendimiento, siempre puedes introducir Rust.

Si pensamos en Node.js o en el navegador, aunque aquí nos centramos más en Node.js, JavaScript sigue siendo el rey en el navegador, y a veces necesitamos ejecutar cosas en el navegador. También debemos recordar que los modelos nativos no se pueden usar en los navegadores, porque JavaScript no tiene soporte para la interfaz de funciones externas. Por lo tanto, los modelos nativos solo se pueden usar en Node.js pero no en el navegador. Por otro lado, WebAssembly se puede utilizar en cualquier lugar donde haya una máquina virtual de WebAssembly disponible. Esto incluye todas las versiones de Node.js, además de todos los navegadores, excepto Internet Explorer. Lamento si necesitas trabajar con Internet Explorer, pero aparte de Internet Explorer, el soporte de WebAssembly abarca toda la pila, incluidos los navegadores móviles. Entonces, si tienes un código que compartes entre el backend y el frontend, tu solución es usar WebAssembly. Si quieres exprimir el rendimiento solo de tu código backend, puedes considerar los modelos nativos de Rust.

Aquí tenemos el resumen, te dejo que lo leas, y solo quiero resaltar dos puntos principales. En mi opinión, los modelos nativos están destinados a extender Node.js con código de rendimiento. Entonces, si quieres mejorar el rendimiento en tu ecosistema de Node.js, los modelos nativos son la forma de hacerlo. Y WebAssembly, en mi opinión, es una forma de reemplazar piezas de código JavaScript que no son eficientes. Entonces, si tienes una función que no es eficiente, te sugiero que intentes reescribirla en WebAssembly, ya sea a través de Rust que se compila a WebAssembly o mediante el uso de AssemblyScript. Y si quieres agregar código de rendimiento a tu Node.js, si quieres ampliar tu ecosistema de Node.js, entonces puedes considerar los modelos nativos con Rust, por ejemplo. Muchas gracias. Puedes encontrarme en Twitter, GitHub, LinkedIn y puedes escanear el código QR para ir a mi blog. Puedes encontrar enlaces a dos artículos en los que se basa esta charla. En mi GitHub, puedes encontrar un enlace a los repositorios de GitHub tanto para las versiones de Rust como para las de WebAssembly, que puedes clonar, ejecutar, jugar con ellos, experimentar. Gracias por escuchar. Espero que hayas aprendido algo nuevo. Puede ser eficiente, no por sí mismo, sino con la ayuda de Rust. Espero que encuentres utilidad para tus nuevos conocimientos. Gracias.