Clase 14.

Programación Backend

Proceso principal del servidor

 ● Conocer el pasaje de parámetros al servidor
y sus funciones.
● Pasar argumentos en la línea de comandos
en Node mediante las librerías Minimist y
Yargs.
● Presentar las variables de entorno y su uso.
OBJETIVOS DE LA ● Aplicar la librería Dotenv.

CLASE ● Conocer acerca del objeto process.

● Aplicar child_process y sus métodos.
● Comprender los procesos en NodeJS.
 CRONOGRAMA DEL CURSO
Clase 13 Clase 14 Clase 15

Autorización y Proceso principal del Clusters y Proxys

Autenticación servidor
PASAJE DE PARÁMETROS
AL SERVIDOR
ARGUMENTOS DE LA LÍNEA
DE COMANDOS EN NODE
 ¿De qué se trata?
● Los argumentos de la línea de comandos son cadenas de texto que se utilizan para pasar
información adicional a un programa, cuando se ejecuta una aplicación a través del
interfaz de línea de comandos (CLI) de un sistema operativo.

● Suelen incluir información que se utiliza para establecer la configuración o los valores
de propiedad de una aplicación.

● En la mayoría de los casos, los argumentos se pasan después del nombre del programa
en su indicador. Un ejemplo de la sintaxis de los argumentos de la línea de comandos se
ve así:

● El tiempo de ejecución (runtime), en nuestro caso es Node.

 Ventajas
● Puede pasar información a una aplicación antes de que comience. Esto es útil si
deseamos realizar ajustes de configuración de gran número.

● Los argumentos de la línea de comandos se pasan como cadenas al programa. Los tipos
de datos de cadena se pueden convertir fácilmente a otros tipos de datos dentro de una
aplicación, lo que hace que los argumentos sean muy flexibles.

● Puede pasar un número ilimitado de argumentos a través de la línea de comando.

● Los argumentos de la línea de comandos se utilizan junto con scripts y archivos por
lotes, lo que es útil para las pruebas automatizadas.
 Desventajas
● La mayor desventaja de pasar información a través de la línea de comandos es que la
interfaz tiene una curva de aprendizaje pronunciada, por lo que es difícil de usar para la
mayoría de las personas a menos que tengan mucha experiencia en el uso de
herramientas CLI.

● Las aplicaciones de línea de comandos pueden ser difíciles de usar a menos que esté
usando una computadora de escritorio o portátil, por lo que normalmente no se usan en
dispositivos más pequeños como teléfonos o tabletas.
PROCESS.ARGV
 Uso de process.argv

● La forma más sencilla de recuperar argumentos en Node es a través del

process.argv. Este es un objeto global que podemos usar sin importar
bibliotecas adicionales.

● Simplemente necesitamos pasar argumentos a una aplicación Node, tal como

mostramos anteriormente, y se puede acceder a estos argumentos dentro de la
aplicación a través del process.argv.
 ¿Cómo se usa process.argv?

1 2 3

El primer elemento del El segundo elemento es el el tercer elemento es el primer

process.argv, el array, siempre será nombre del archivo JavaScript argumento que realmente pasó
una ruta del sistema de archivos que se está ejecutando. el usuario.
que apunta al Node ejecutable.
 Usando process.argv
● Vemos un script de Node simple que imprima todos los argumentos de la línea de
comando pasados ​a la aplicación, junto con su índice. En el archivo “processargv.js”

● Lo que hace este script es recorrer el process.argv array e imprime los índices, junto con
los elementos almacenados en esos índices. Es muy útil para depurar si alguna vez nos
preguntamos qué argumentos estamos recibiendo y en qué orden.
 Usando process.argv
● Para ejecutar el script, en la terminal nos
posicionamos sobre el directorio de ese
archivo y ejecutamos el comando:

● Acá estamos pasando tres argumentos al programa

“processargv.js”. El argumento “tom” se
almacenará en el segundo índice, mientras que
“jack” y “43” se almacenarán en el tercer y cuarto
índice, respectivamente. La salida será:

El primer índice contiene la ruta a nuestro node ejecutable y

el segundo índice contiene la ruta al archivo de script.
MINIMIST
 Usando minimist
● Otra forma de recuperar argumentos de línea de comando en una aplicación Node es
usando el módulo minimist.

● Nos permite analizar un array de strings (usualmente obtenido de los argumentos

ingresados por línea de comando) y lo transformará en un objeto más fácil de usar,
ya que nos permite acceder acceder a los elementos mediante su nombre.

● Lo instalamos como:

● Lo podemos requerir en nuestros archivos como:

 Usando minimist
Primero, usamos el método slice sobre el array de argumentos del objeto global process: argv. En este caso,
el método elimina todos los elementos del array anteriores a partir del índice que se le pasa como
parámetro. Como sabemos que los argumentos que pasamos manualmente se almacenan a partir del
segundo índice, pasamos como argumento un 2.

const parseArgs = require('minimist');

const args = parseArgs(process.argv.slice(2));

 Usando minimist
Veamos algunos ejemplos de lo que obtenemos con minimist al recibir diferentes entradas:

console.log(parseArgs(['1', '2', '3', '4']));

// { _: [ 1, 2, 3, 4 ] }

console.log(parseArgs(['-a', '1', '-b', '2', '3', '4']));

// { _: [ 3, 4 ], a: 1, b: 2 }

console.log(parseArgs(['--n1', '1', '--n2', '2', '3', '4']));

// { _: [ 3, 4 ], n1: 1, n2: 2 }

console.log(parseArgs(['-a', '1', '-b', '2', '--colores', '--cursiva']));

// { _: [], a: 1, b: 2, colores: true, cursiva: true }

console.log(parseArgs(['-a', '1', '-b', '2', '-c', '-x']));

// { _: [], a: 1, b: 2, c: true, x: true }
 Usando minimist
● Ante un argumento que comienza con un guión solo, crea un atributo cuyo nombre será la
primera letra dsp del guión, y cuyo valor será todo lo restante hasta el próximo argumento

● Si queremos usar palabras como nombres de atributos, debemos anteponerle un doble guión, y su
valor será el argumento siguiente.

● Si luego de un argumento guionado (simple o doble), no se encuentra ningún otro argumento, o

el argumento siguiente también es guionado, el primero se interpreta como un valor booleano
con valor true.

● Si existen valores sueltos que no vienen precedidos por ningún argumento guionado, todos ellos
se agrupan en un array bajo el nombre _ (guión bajo).
 Usando minimist
Además también podemos agregar algunas opciones adicionales. Entre ellas, podemos definir algunos
valores por defecto para argumentos que no estén presentes:

const options = { default: { nombre: 'pepe', apellido: 'copado' }}

console.log(parseArgs(['-a', '1', '-b', '2', 'un-valor-suelto', '--nombre', 'juanita'], options));

// { _: [ 'un-valor-suelto' ], a: 1, b: 2, nombre: 'juanita', apellido: 'copado' }

Y podemos agregarle algunos alias para renombrar los valores ingresados como argumentos, dándoles
nombres más descriptivos

const options = { alias: { a: 'campoA', b: 'campoB', } }

console.log(parseArgs(['-a', '1', '-b', '2'], options));

// { _: [], a: 1, campoA: 1, b: 2, campoB: 2 }
ARGUMENTOS POR LÍNEA DE
COMANDOS
Tiempo: 5 minutos
ARGUMENTOS POR LÍNEA DE
COMANDOS
Tiempo: 5 minutos

Realizar una aplicación en Javascript ejecutada a través de Node.JS que al ejecutarse de la siguiente manera:

node main.js 1 2 3 -m dev -p 8080 -d

Construya y muestre por pantalla el siguiente objeto:

{ modo: 'dev', puerto: 8080, debug: true, otros: [ 1, 2, 3 ] }

Y con el siguiente llamado:

node main.js 1 2 3

Construya y muestre por pantalla el siguiente objeto:

{ modo: 'prod', puerto: 0, debug: false, otros: [ 1, 2, 3 ] }

YARGS
 Usando yargs
● Otro módulo que nos ayudará a analizar los argumentos de la línea de comandos pasados ​a los
programas de Node es el módulo yargs. Inicialmente funciona de igual manera que Minimist,
con algunas modificaciones y en su sintaxis. Sin embargo, esta librería posee muchísimas más
funcionalidades.

● Lo instalamos con npm (npm i yargs) y lo utilizamos de la siguiente manera:

const yargs = require('yargs/yargs')(process.argv.slice(2))

const args = yargs.argv
 Usando yargs
● Si queremos agregar valores por defecto, lo hacemos de la siguiente manera:

const yargs = require('yargs/yargs')(process.argv.slice(2))

const args = yargs
.default({
nombre: 'pepe',
apellido: 'copado'
})
.argv
 Usando yargs
● Si queremos agregar alias, lo hacemos de la siguiente manera:

const yargs = require('yargs/yargs')(process.argv.slice(2))

const args = yargs
.alias({
n: 'nombre',
a: 'apellido'
})
.argv
 Usando yargs
● Si queremos que algún argumento sea interpretado como un valor booleano, lo hacemos de la
siguiente manera:

const yargs = require('yargs/yargs')(process.argv.slice(2))

const args = yargs
.boolean('vivo')
.argv

● Para ver el resto de las (innumerables!) funcionalidades, se puede consultar la documentación

oficial:

○ https://github.com/yargs/yargs/blob/HEAD/docs/api.md
USANDO YARGS
Tiempo: 5 minutos
USANDO YARGS
Tiempo: 5 minutos

Realizar la operación del desafío anterior, esta vez usando la dependencia YARGS en lugar
de minimist.
 ☕
BREAK
¡5/10 MINUTOS Y
VOLVEMOS!
VARIABLES DE ENTORNO
 ¿De qué se trata?
● Las variables de entorno son variables externas a nuestra aplicación que residen en el
sistema operativo o en el contenedor de la aplicación que se está ejecutando. Una
variable de entorno es simplemente un nombre asignado a un valor.

● Nos permiten administrar la configuración de nuestras aplicaciones por separado de

nuestro código base.

● Las configuraciones separadas facilitan la implementación de nuestra aplicación en

diferentes entornos (desarrollo, test, producción, etc).

● Por convención, el nombre se escribe con mayúscula y los valores son cadenas de texto,
por ejemplo: PORT=8080.
 ¿De qué se trata?
● Normalmente, nuestras aplicaciones requieren que se establezcan muchas variables de entorno
para que funcionen. Al confiar en configuraciones externas, nuestra aplicación se puede
implementar fácilmente en diferentes entornos. Estos cambios son independientes de los cambios
en el código, por lo que no requieren que nuestra aplicación sea reconstruida.

● Los datos que cambian según el entorno en el que se ejecuta su aplicación deben configurarse
como variables de entorno. Algunos ejemplos comunes son:

➔ Dirección y Puerto HTTP. ➔ Ubicación de archivos y carpetas

estáticos.
➔ Credenciales de Base de Datos.
➔ Credenciales de API's externas.
 Usando variables de entorno
● En primer lugar, en nuestro proyecto, creamos un archivo llamado config.js que
centralizará nuestras variables de entorno.
Usando variables de entorno
● Luego, en el archivo
server.js requerimos el
archivo de config.

● Creamos un servidor con

Express usando las variable
de entorno definidas.
 Usando variables de entorno

● Ejecutamos como:

● En este ejemplo, llamamos a una operación GET que enviará el

mensaje “Hello world” en nuestro navegador. Las variables HOST y
PORT están definidas en nuestro código. Además ejecutará la
aplicación en la dirección 127.0.0.1:3000
 Usando variables de entorno
● El acceso a las variables de entorno en Node es compatible desde que inicia nuestra
aplicación.

● Cuando el proceso Node se inicia, proporciona automáticamente el acceso a todas

las variables de entorno existentes mediante el objeto process.env. En el archivo
config.js, la variable HOST estará definida por la variable process.env.HOST, si no
se encuentra definida esta variable, será reemplazada por el valor 127.0.0.1. (puesto
por default).

● Hasta este punto nuestra aplicación se inicializará en función de las variables de

entorno que se definan.
AGREGANDO VARIABLES DE
ENTORNO
Tiempo: 5 minutos
AGREGANDO VARIABLES DE
ENTORNO
Tiempo: 5 minutos

Realizar una aplicación en nodeJS que al pasar las siguientes variables de entorno:

MODO=dev PUERTO=8080 DEBUG=true

Construya y muestre por pantalla el siguiente objeto:

{ modo: 'dev', puerto: 8080, debug: true }

Y que al ejecutarlo sin pasar ninguna variable de entorno construya y muestre por pantalla el siguiente objeto:

{ modo: 'prod', puerto: 0, debug: false }

DOTENV
 ¿De qué se trata?

● Dotenv es un módulo de Node que carga variables de entorno desde un archivo

.env a process.env.
● El desarrollo con múltiples variables de entorno se vuelve rápidamente difícil
de mantener. Entonces, utilizamos dotenv para que las variables de entorno
queden almacenadas todas juntas en el archivo .env.
 Usando dotenv

● En primer lugar, instalamos el módulo con el comando: npm i dotenv

● Luego, creamos el archivo .env, con las variables de entorno que queremos
definir. Por ejemplo:

FONDO=blanco
FRENTE=negro
 Usando dotenv
● Ahora, creamos el archivo config.js, similar al del ejemplo anterior, con el
siguiente código:

require('dotenv').config()

const fondo = process.env.FONDO

const frente = process.env.FRENTE

console.log({
fondo,
frente
})

● Veremos que las variables se encuentran cargadas correctamente al momento

de la ejecución del programa!
 Múltiples entornos con dotenv
● Si deseamos configurar nuestra aplicación en diferentes entornos, dotenv nos permite definir
tantos entornos como necesitemos.

● Supongamos que necesitamos configurar 2 entornos básicos: a color (colores) y en blanco y

negro (byn). Entonces crearemos 2 archivos nuevos colores.env y byn.env, uno para cada
entorno, los cuales contendrán la siguiente configuración:

# byn # colores
FONDO=blanco FONDO=verde
FRENTE=negro FRENTE=violeta
 Múltiples entornos con dotenv
const path = require('path')
const dotenv = require('dotenv')
● Dotenv nos permite cargar a
traves del método config() y dotenv.config({
path:
el objeto path, el process.env.MODO == 'byn'

archivo .env que necesitemos ? path.resolve(__dirname, 'byn.env')

: path.resolve(__dirname, 'colores.env')
de acuerdo al entorno })
deseado.
const fondo = process.env.FONDO
const frente = process.env.FRENTE

console.log({
fondo,
frente
})
IMPLEMENTANDO DOTENV
Tiempo: 5 minutos
IMPLEMENTANDO DOTENV
Tiempo: 5 minutos

Realizar el desafío anterior utilizando la librería dotenv.

 ☕
BREAK
¡20/25 MINUTOS Y
VOLVEMOS!
GLOBAL PROCESS
OBJETO PROCESS
 Objeto Process
● Como ya hemos visto, el objeto process es una variable global disponible
en NodeJS que nos ofrece diversas informaciones y utilidades acerca del
proceso que está ejecutando un script Node.
● Contiene diversos métodos, eventos y propiedades que nos sirven no solo
para obtener datos del proceso actual, sino también para controlarlo.
● Al ser un objeto global quiere decir que lo puedes usar en cualquier
localización de tu código NodeJS, sin tener que hacer el correspondiente
require().
 Datos del proceso
Algunos ejemplos de los datos del proceso que se pueden consultar con el
objeto process.
 Salir de la ejecución
● A veces, se necesita salir de la ejecución de un programa en Node. Esto lo
podemos conseguir mediante el método exit del objeto process.

● Provocará que el programa acabe, incluso en el caso que haya operaciones

asíncronas que no se hayan completado o que se esté escuchando eventos
diversos en el programa.

👉 El método exit puede recibir opcionalmente un código de salida. Si no indicamos nada se

entiende "0" como código de salida.
 Función ‘.on( )’
● La mayor funcionalidad de process está contenida en la función ‘.on()’.
● Dicha función está escuchando durante todo el proceso que se ejecuta, es
por eso que solo se puede actuar sobre su callback.
● Se define como se definen los eventos en Javascript. En el método on,
indicando el tipo de evento que queremos escuchar y un callback que se
ejecutará cuando ese evento se dispare.
 Evento ‘beforeExit’
● Normalmente, el proceso de Node se cerrará cuando no haya trabajo
programado, pero un oyente registrado en el evento beforeExit puede
realizar llamadas asincrónicas y, por lo tanto, hacer que el proceso de
Node continúe.
● No debe usarse como una alternativa al evento de exit a menos que la
intención sea programar trabajo adicional.
 Evento ‘exit’
● El evento exit se emite cuando el proceso de Node está a punto de salir como
resultado de que:
○ El método process.exit( ) se llama explícitamente.
○ El ciclo de eventos de Node ya no tiene ningún trabajo adicional que
realizar.
● No hay forma de evitar la salida del bucle de eventos en este punto, y una vez
que todos los oyentes de 'salida' hayan terminado de ejecutar, el proceso de
Node terminará.
 Evento ‘uncaughtException’
● Se emite cuando una excepción es
devuelta hacia el bucle de evento.
● Si se agregó un listener a esta
excepción, no se producirá la
acción por defecto (imprimir una
traza del stack y salir).
● Es un mecanismo muy básico para
manejar excepciones.
 ‘process.execPath’

● Esta propiedad devuelve el nombre de la ruta absoluta del ejecutable

que inició el proceso Node. Los enlaces simbólicos, si los hay, se
resuelven.

● Ejemplo de ruta:
 ‘process.stdout.write’
● La propiedad process.stdout devuelve una secuencia conectada a
stdout.
● Es un stream de escritura para stdout.

● Ejemplo de la definición de console.log:

USO DEL OBJETO PROCESS
Tiempo: 10 minutos
Uso del objeto Process
Tiempo: 10 minutos
Realizar una aplicación en Node.js que permita recibir como parámetros una cantidad
ilimitada de números, con los cuales debe confeccionar el siguiente objeto (se imprimirá
por consola):
Uso del objeto Process
Tiempo: 10 minutos
En el caso de ingresar un número no válido, se creará un objeto de error con el siguiente
formato (se imprimirá por consola):

En este caso de error, la aplicación saldrá con código de error -5

Uso del objeto Process
Tiempo: 10 minutos
Si no ingresó ningún número, el objeto de error será:

En este caso de error, la aplicación saldrá con código de error -4

En los casos de error, se representará en consola el código antes de finalizar.

 ☕
BREAK
¡5/10 MINUTOS Y
VOLVEMOS!
CHILD PROCESS
 Single Thread (único hilo)
● Cuando ponemos en marcha un programa escrito en NodeJS se dispone de un único
hilo de ejecución.

● Una ventaja de esto es que permite atender mayor demanda con menos recursos.

● Todas las operaciones que NodeJS no puede realizar al instante (operaciones no

bloqueantes), liberan el proceso, es decir, se libera para atender otras solicitudes.

● El hilo principal podrá estar atento a solicitudes, pero una vez que se atiendan, Node
podrá levantar de manera interna otros procesos para realizar todo tipo de acciones que
se deban producir como respuesta a esas solicitudes. Estos procesos secundarios
pueden crearse con el módulo child_process.
 Proceso hijo
● Un proceso hijo es un proceso creado por un proceso padre.
● Node nos permite ejecutar un comando del sistema dentro de un proceso hijo
y escuchar su entrada / salida.
● Los desarrolladores crean de forma habitual procesos secundarios para
ejecutar comandos sobre su sistema operativo cuando necesitan manipular el
resultado de sus programas Node con un shell.
● Podemos crear procesos hijo de 4 formas diferentes:

exec( ) spawn( )
execFile( ) fork( )
FORMAS DE CREAR
PROCESOS HIJO
 Proceso secundario con ‘exec( )’.
● Requerimos el comando exec del
módulo child_process.
● En la ejecución de la función exec, el
primer argumento es el comando ls-lh.
Este, enumera todos los archivos y
carpetas del directorio actual en formato
largo, con un tamaño total de archivo en
unidades legibles por el ser humano en
la parte superior del resultado.
 Proceso secundario con ‘exec( )’.
● El segundo argumento es el callback, el
cual a su vez tiene 3 parámetros.
● Si el comando no se ejecuta, se imprime
el motivo en error.
● Si el comando se ejecutó
correctamente, cualquier dato que
escriba al flujo de resultado estándar se
captura en stdout y cualquier dato que
escriba al flujo error estándar se captura
en stderr.
 Proceso secundario con ‘exec( )’.
● Al ejecutar el archivo en la terminal el output será como el que se muestra en
la imagen.

● Esto enumera el contenido del directorio child-processes en formato largo,

junto con el tamaño del contenido en la parte superior. Sus resultados tendrán
su propio usuario y grupo en lugar de sammy.
● Esto muestra que el programa listFiles.js ejecutó correctamente el comando
shell ls -lh.
 Proceso secundario con
‘execFile( )’.
● La diferencia principal entre las funciones execFile() y exec() es que el
primer argumento de execFile() es ahora una ruta a un archivo ejecutable
en vez de un comando.
● El resultado del archivo ejecutable se guarda en un búfer como exec(), al
que accedemos a través de una función callback con los parámetros error,
stdout y stderr.
 Proceso secundario con
● Ahora requerimos el método‘execFile( )’.
execFile del módulo
child_process.
● Como observamos en el código,
ahora el primer parámetro es la
ruta, en este caso, de una
imagen.
● Luego, el código funciona de
igual forma que con el comando
exec.
 Proceso secundario con ‘spawn( )’.
● La función spawn() ejecuta un comando en un proceso. Esta función devuelve
datos a través de la API del flujo. Por tanto, para obtener el resultado del
proceso secundario, debemos escuchar los eventos del flujo.
● Con exec() y execFile(), todos los datos procesados se guardan en la memoria
de la computadora. Para cantidades de datos más grandes, esto puede degradar
el rendimiento del sistema.
● En el caso de spawn(), con un flujo, los datos se procesan y transfieren en
pequeños trozos. Por lo tanto, puede procesar una gran cantidad de datos sin
usar demasiada memoria en un momento dado.
 Proceso secundario con ‘spawn( )’.
● Requerimos el método spawn del módulo child_process.
● El primer argumento de spawn es el comando find.
● El segundo argumento es un array que contiene los argumentos para el comando
ejecutado.
● Le estamos indicando a Node que ejecute el comando find con el argumento ‘.’, lo
que hace que el comando encuentre todos los activos en el directorio actual.
 Proceso secundario con ‘spawn( )’.
● Los comandos pueden devolver datos en el
flujo stdout o el flujo stderr.
● Puede añadir oyentes invocando el método
on() de cada objeto de los flujos.
● El evento datos de los flujos nos
proporciona el resultado de los comandos
para ese flujo. Siempre que obtengamos
datos sobre ese flujo, los registramos en la
consola.
 Proceso secundario con ‘spawn( )’.
● Escuchamos los dos otros eventos: el
evento error si el comando no se ejecuta o
se interrumpe y el evento close para
cuando el comando haya terminado la
ejecución, cerrando así el flujo.
● En estos casos, se configura directo en la
variable child.
 Proceso secundario con ‘fork( )’.
● La función fork() es una variación de spawn() que permite la comunicación
entre el proceso principal y el secundario.
● Además de recuperar datos desde el proceso secundario, un proceso principal
puede enviar mensajes al proceso secundario en ejecución. Del mismo modo,
el proceso secundario puede enviar mensajes al proceso principal.
● Si un servidor web está bloqueado, no puede procesar ninguna nueva solicitud
entrante hasta que el código de bloqueo haya completado su ejecución. Fork
evita el bloqueo corriendo el proceso secundario bloqueante en un hilo aparte.
Proceso secundario con ‘fork( )’.
● Creamos un servidor, que ejecuta la función
calculo().
● Se puede ver que se va a ejecutar de forma
muy lenta, ya que el bucle de la función va a
iterar hasta que el contador sea 6e9.
● Por lo tanto, este es un servidor bloqueante.
Es decir, que todos los otros procesos o
request se bloquean por el tiempo que tarda en
ejecutarse la función calcular.
Proceso secundario con ‘fork( )’.
● En este caso, tenemos un servidor no-bloqueante.
● La función calcular, ahora se encuentra en el
archivo computo.js.
● Cuando se quiere acceder a la ruta /calcular se
crea un proceso secundario con fork.
● De esta forma, cualquier otro request se atenderá
en forma correcta cuando se esté realizando la
operación de cálculo.
 Proceso secundario con ‘fork( )’.
En este ejemplo, tenemos un componente hijo, llamado child.js (primera imágen) el cual se va
a ejecutar en un proceso secundario conectado con el proceso principal (segunda imágen).
En la tercera imagen, podemos observar el intercambio de mensajes entre el proceso hijo y el
proceso padre al ejecutarlo en la terminal.
 Proceso secundario con ‘fork( )’.
Cuando trabajamos con Módulos de ES6, debemos considerar que la carga de archivos es no-
bloqueante, por lo que debemos añadir un paso extra al cargar el nuevo proceso, que consiste
en hacer que el proceso cargado envíe un mensaje indicando que ya está listo, y recién ahí
podemos enviarle nosotros la indicación de que comience a procesar lo que le pasemos.
Ejemplo:

import { fork } from 'child_process' // child.js

process.on('message', msg => {
const forked = fork('child.js')
console.log(`mensaje del padre: ${msg}`)
process.send('mundo!')
forked.on('message', msg => {
process.exit()
if (msg == 'listo') {
forked.send('Hola, ') })
} else {
console.log(`Mensaje del hijo: ${msg}`) process.send('listo')
}
})
CHILD_PROCESS CON FORK
Tiempo: 15 minutos
Child_process con fork
Tiempo: 15 minutos

Realizar un servidor en express que contenga una ruta raíz '/' donde se represente la cantidad
de visitas totales a este endpoint (no usar session).
Se implementará otra ruta '/calculo-bloq', que permita realizar una suma incremental de los
números del 0 al 100000 con el siguiente algoritmo.
Child_process con fork
Tiempo: 15 minutos

Comprobar que al alcanzar esta ruta en una pestaña del navegador, el proceso queda en
espera del resultado. Constatar que durante dicha espera, la ruta de visitas no responde hasta
terminar este proceso.
Luego crear la ruta '/calculo-nobloq' que hará dicho cálculo forkeando el algoritmo en un
child_process, comprobando ahora que el request a esta ruta no bloquee la ruta de visitas.
Asegurarse de que una vez finalizado el proceso, el worker se cierra correctamente.
 1
4

USANDO EL OBJETO
PROCESS
AGREGAR DOTENV
Formato: link a un repositorio en Github con el proyecto cargado.
Sugerencia: no incluir los node_modules

>> Consigna:
Sobre el proyecto del último desafío entregable, mover todas las claves y credenciales utilizadas a un
archivo .env, y cargarlo mediante la librería dotenv.
La única configuración que no va a ser manejada con esta librería va a ser el puerto de escucha del servidor. Éste
deberá ser leído de los argumento pasados por línea de comando, usando alguna librería (minimist o yargs). En el
caso de no pasar este parámetro por línea de comandos, conectar por defecto al puerto 8080.
Observación: por el momento se puede dejar la elección de sesión y de persistencia explicitada en el código
mismo. Más adelante haremos también parametrizable esta configuración.
USANDO EL OBJETO PROCESS
Formato: link a un repositorio en Github con el proyecto cargado.
Sugerencia: no incluir los node_modules

>> Consigna:

Agregar una ruta '/info' que presente en una vista sencilla los siguientes datos:
- Argumentos de entrada - Path de ejecución
- Nombre de la plataforma (sistema operativo) - Process id
- Versión de node.js - Carpeta del proyecto
- Memoria total reservada (rss)
USANDO EL OBJETO PROCESS
Formato: link a un repositorio en Github con el proyecto cargado.
Sugerencia: no incluir los node_modules

>> Consigna:

Agregar otra ruta '/api/randoms' que permita calcular un cantidad de números aleatorios en el
rango del 1 al 1000 especificada por parámetros de consulta (query).
Por ej: /randoms?cant=20000.
Si dicho parámetro no se ingresa, calcular 100.000.000 números.
El dato devuelto al frontend será un objeto que contendrá como claves los números random
generados junto a la cantidad de veces que salió cada uno. Esta ruta no será bloqueante
(utilizar el método fork de child process). Comprobar el no bloqueo con una cantidad de
500.000.000 de randoms.

Observación: utilizar routers y apis separadas para esta funcionalidad.

¿PREGUNT
AS?
 ¡MUCHAS
ResumenGRACIAS!
de lo visto en clase hoy:
● Argumentos en la línea de comandos de Node
● Objeto process.
● Process.argv
● Minimist y Yargs
● Variables de entorno y Dotenv
● Global Process.
● Child-process.
OPINA Y VALORA ESTA
CLASE
#DEMOCRATIZANDOLAEDUC
ACIÓN