Iniciar sesión

Aplicaciones Node.js

Node.js, desarrollado y operado junto a tu PHP.

Desarrollamos en Node APIs, sitios renderizados en servidor, servicios en tiempo real y workers, y los ejecutamos en los mismos servidores que tus sitios PHP, detrás de un único Nginx.

Pide un presupuesto Servidores dedicados

Qué desarrollamos en Node

Cinco tipos de trabajo, cada uno aquí porque a Node le sienta bien.

01
Express

APIs y back-ends pequeños y directos: pocas rutas, middleware claro, nada oculto.
APIs y back-ends
02
NestJS

Servicios más grandes con módulos, inyección de dependencias y contratos tipados en TypeScript, para código que un equipo hará crecer durante años.
Servicios estructurados
03
Next.js · Nuxt

Renderizado en servidor para React y Vue: las páginas llegan listas para los buscadores y para una primera vista rápida, y luego se comportan como una app.
Sitios renderizados en servidor
04
Socket.IO · WebSockets

Chat, notificaciones, paneles en vivo y seguimiento que se actualizan en cuanto algo cambia, sobre una sola conexión abierta.
Tiempo real
05
Workers y colas

Trabajos en segundo plano, tareas programadas y consumidores de colas sobre Redis que mantienen el trabajo lento fuera de la petición.
Trabajo en segundo plano

Por qué Node sabe esperar

Un proceso de Node ejecuta tu JavaScript en un solo hilo y deja la espera - disco, red, base de datos - al sistema. Así un solo proceso mantiene muchas conexiones abiertas a la vez.

1Pila de llamadas

JSON.parse(body)
handler(req, res)
(main)

un hilo, una función cada vez

Bucle de eventoslibuv

5

4Cola de microtareas

promise.then()
await
queueMicrotask()

se vacía antes de la siguiente tarea

3Cola de tareas

setTimeout()
setImmediate()
socket.on('data')

callbacks esperando su turno

2Pool de hilos de libuvcuatro hilos por defecto

fs.readFile()
dns.lookup()
crypto.pbkdf2()
zlib.gzip()

Sistema operativo epoll · kqueue vigila cada socket de red

El bucle de eventos de Node.js, simplificado

Tu código se ejecuta en la pila de llamadas, una función cada vez.
El trabajo lento sale del hilo: archivos, DNS y hashing van al pool de libuv, y el sistema operativo vigila los sockets.
Cuando el trabajo termina, su callback espera en la cola de tareas.
Antes de la siguiente tarea se ejecutan todos los callbacks de promesas de la cola de microtareas.
El bucle recorre sus fases y toma la siguiente tarea.

PHP y Node en un solo servidor

Nginx atiende cada petición y envía cada ruta al proceso que le corresponde. Tu sitio PHP y tu servicio Node comparten la máquina, la base de datos y el certificado - no la memoria del otro.

https://example.com //checkout.php/api//socket.io/

Nginxuna sola entrada: TLS, enrutamiento, archivos estáticos

/css//images/sendfile
/*.phpphp-fpm
/api//socket.io/node :3000

server {
    listen 443 ssl;
    server_name example.com;

    location / {
        try_files $uri /index.php?$query_string;
    }
    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/run/php/php-fpm.sock;
    }
    location /api/ {
        proxy_pass http://127.0.0.1:3000;
    }
    location /socket.io/ {
        proxy_pass http://127.0.0.1:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

fastcgi

Lado PHP

php-fpm: pool www

Un pool de workers. Cada petición empieza limpia y termina limpia.

Laravel · WordPress · WooCommerce

proxy_pass :3000

Lado Node

pm2: app (cluster)

Procesos que corren de forma continua. Uno solo sostiene muchas conexiones abiertas.

Express · NestJS · Next.js · Socket.IO

Compartido por ambos

MySQL · PostgreSQL
Redis sesiones, caché, colas
un solo certificado TLS
un solo plan de copias de seguridad

Ejemplo de un servidor que ejecuta ambos

Cuál para cada trabajo

Desarrollamos con los dos, así que la respuesta sale del trabajo, no de una costumbre.

Elige PHP cuando

El sitio es sobre todo páginas, formularios y un panel de administración: tiendas, sitios de contenido, sistemas de gestión.
Quieres WordPress, WooCommerce o Laravel y todo lo que ya existe para ellos.
Cada petición es independiente y termina rápido.
Las personas que lo mantendrán ya conocen PHP.

Elige Node cuando

Las conexiones se quedan abiertas: chat, paneles en vivo, notificaciones, seguimiento.
Las páginas de React o Vue se renderizan en el servidor con Next.js o Nuxt.
El servicio pasa la mayor parte del tiempo esperando a otras APIs y dejando pasar flujos de datos.
Un solo lenguaje en el navegador y en el servidor ayuda a tu equipo.

A menudo la respuesta es: los dos

PHP se queda con el sitio, la tienda y el panel; un pequeño servicio Node se encarga de la parte en tiempo real a su lado. Los dos leen la misma base de datos y están detrás del mismo Nginx.

Despliegues sin huecos

Una nueva versión arranca junto a la anterior, demuestra que está sana y solo entonces toma el tráfico. Los workers anteriores terminan las peticiones que ya tienen antes de detenerse.

Visitantes atendidos
Versión actual
Nueva versión

01
Traer e instalar
git pull && npm ci
Las versiones exactas del lockfile, nada más nuevo por sorpresa.
02
Compilar
npm run build
TypeScript y los recursos se compilan antes de que nada se reinicie.
03
Arrancar junto a la anterior
pm2 reload app
La nueva versión arranca junto a la que sigue atendiendo.
04
Esperar a que esté lista
wait_ready: true
Debe responder a su comprobación de salud antes de recibir a un visitante.
05
Tomar el tráfico
cluster → new workers
Las conexiones nuevas van a la nueva versión.
06
Vaciar la anterior
SIGINT → server.close()
Los workers anteriores terminan las peticiones que tienen y después se cierran.

Si la nueva versión no supera su comprobación de salud, nunca recibe tráfico: la anterior simplemente sigue atendiendo.

El servidor alrededor del código

Lo que mantiene en pie un servicio Node está escrito en el servidor, en archivos que mantenemos y que tú puedes leer.

/etc/nginx/sites-enabled/app.conf

Proxy inverso

TLS, compresión, archivos estáticos en caché y actualización a WebSocket, delante de cada proceso.
/srv/app/ecosystem.config.js

Gestor de procesos

PM2 mantiene vivo el proceso, lo reinicia si se cae y usa cada núcleo en modo clúster. Donde basta un solo proceso, una unidad de systemd hace el mismo trabajo.
/srv/app/.env (0600)

Entorno y secretos

Las claves y contraseñas viven fuera del código y fuera de git, y solo puede leerlas el usuario propio de la aplicación.
/srv/app/package-lock.json

Auditoría de dependencias

npm audit en cada versión; las actualizaciones se leen y se prueban antes de llegar a producción.
/srv/app/.nvmrc

Actualizaciones entre versiones LTS de Node

La aplicación corre sobre una versión de soporte a largo plazo, y la pasamos a la siguiente antes de que la anterior se quede sin soporte.
/var/log/app/

Logs y monitorización

Logs estructurados y rotados, con una alerta cuando el proceso se reinicia, la memoria sube o aumentan los errores.

Cuéntanos qué tiene que hacer tu app Node

Un servicio nuevo, un sitio Next.js o una app que ya funciona en algún sitio y necesita un buen hogar. La revisamos y te damos presupuesto tras una conversación breve.

Pide un presupuesto Servidores dedicados