Pasos para un servidor NodeJS en Ubuntu

Esto es con el fin de tener lo indispensable para poder levantar un proceso en un servidor que contenga un código que requiere de algunos módulos.

Paso 1 – Instalar NodeJS en linux

Yo uso linux, el procedimiento está es esta página.

Con esto se instala NodeJS y npm. Luego de corroborar que se hayan instalado correctamente verificando las versiones, pasamos al siguiente paso.

Paso 2 – Crear la carpeta del proyecto

Esta carpeta se crea como cualquier otra en donde quieras. Yo las estoy creando en un directorio que he destinado para colocar todas estas carpetas, Server, de proyectos que serán manejadas por el servidor. Macedonia dentro del directorio Server.

Paso 3 – Crear el archivo package.json

Esto se hace por medio de la terminal con el comando npm init. Este comando, como el resto de comandos específicos para un proyecto determinado, se ejecutan desde el directorio específico de ese proyecto o desarrollo. En mi caso me traslado al directorio macedonia dentro del directorio Server.

brigzen@brigzen-ASUS:~$ 
brigzen@brigzen-ASUS:~$ ls
Code  Desktop  Documents  Downloads  Dropbox  fastboot  Music  Pictures  Public  Server  snap  Templates  Videos
brigzen@brigzen-ASUS:~$ cd Server
brigzen@brigzen-ASUS:~/Server$ ls
macedonia
brigzen@brigzen-ASUS:~/Server$ cd macedonia
brigzen@brigzen-ASUS:~/Server/macedonia$ npm init
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.

See `npm help init` for definitive documentation on these fields
and exactly what they do.

Use `npm install <pkg>` afterwards to install a package and
save it as a dependency in the package.json file.

Press ^C at any time to quit.
package name: (macedonia) 
version: (1.0.0) 
description: Primer proyecto para arbitraje de criptomonedas en diferenes exchanges.
entry point: (index.js) 
test command: 
git repository: 
keywords: 
author: Brigzen Coronado
license: (ISC) 
About to write to /home/brigzen/Server/macedonia/package.json:

{
  "name": "macedonia",
  "version": "1.0.0",
  "description": "Primer proyecto para arbitraje de criptomonedas en diferentes exchanges.",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "Brigzen Coronado",
  "license": "ISC"
}


Is this OK? (yes) 
brigzen@brigzen-ASUS:~/Server/macedonia$ 

El texto dentro del archivo package.json:

{
  "name": "macedonia",
  "version": "1.0.0",
  "description": "Primer proyecto para arbitraje de criptomonedas en diferenes exchanges.",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "Brigzen Coronado",
  "license": "ISC",
}

Instalación de dependencias

En Node.js, la utilidad en si no tiene muchas funcionalidades, las dependencias son códigos extras que proporcionan las funcionalidades de Node.js, incluso, por lo que puedo ver, hasta las funcionalidades más básicas.

Tipos de dependencias

Se suele distinguir entre dependencias de producción y de desarrollo.

De Producción

Las primeras se usarán siempre en el funcionamiento de lo que se está haciendo, es decir, son parte del desarrollo. Para instalarlas se usa el comando: npm install dependencia.

De Desarrollo

Las segundas son dependencias que solo serán útiles mientras se esté trabajando en el desarrollo del proyecto. Para instalarlas se usa el comando: npm install –save-dev dependencia.

Paso 4 – Express, la primera dependencia a instalar

Según el tutorial, la primera dependencia a instalar es Express. Esta dependencia es un módulo que instala el código para que se ejecute el servidor. Según el instructor, es análogo a lo que sería Apache para PHP.

Para ello se ejecuta el comando: npm install express. También puede ser: npm i express.

brigzen@brigzen-ASUS:~/Server/macedonia$ npm install express

added 57 packages, and audited 58 packages in 3s

7 packages are looking for funding
  run `npm fund` for details

found 0 vulnerabilities
brigzen@brigzen-ASUS:~/Server/macedonia$

Luego de ello la dependencia aparece listada en el archivo package.json. También se crea un archivo llamado package-lock.json que no se toca. Finalmente también crea un directorio llamado node_module, que es donde se va a instalar archivos y directorios que Express o cualquier módulo npm necesite.

{
  "name": "macedonia",
  "version": "1.0.0",
  "description": "Primer proyecto para arbitraje de criptomonedas en diferenes exchanges.",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "Brigzen Coronado",
  "license": "ISC",
  "dependencies": {
    "express": "^4.18.1"
  }
}

Nodemon

Esta es una dependencia de desarrollo que nos permite reiniciar el servidor cuando hagamos cambios.

Se usa npm install –save-dev nodemon.

{
  "name": "macedonia",
  "version": "1.0.0",
  "description": "Primer proyecto para arbitraje de criptomonedas en diferentes exchanges.",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "Brigzen Coronado",
  "license": "ISC",
  "dependencies": {
    "express": "^4.18.1",
  },
  "devDependencies": {
    "nodemon": "^2.0.16"
  }
}

Paso 5 – Crear el archivo index.js

Este es el archivo donde se va a configurar el servidor Express para correr determinada aplicación. Este archivo está especificado en el código del archivo package.json en el objeto main.

Ya no estoy usando la carpeta macedonia.

Llamar las dependencias

Lo de abajo es el código inicial que se usó en el curso. Se llama al módulo express con require (más adelante se explica un detalle en esta parte). Se crea una variable con ese módulo en modo de función, algo no muy bien entendido.

Definición de puerto

Se define un puerto que por los momentos va a ser 4000 ya que es en producción cuando tome un puerto específico. Pero sea cual sea el puerto con el que salga una vez en producción, el mismo quedará guardado en la variable port.

Método .listen

Luego a esa solicitud se le aplica un método .listen para arrancar el servidor. El código inicial va quedando así como se ve abajo, pero ahora se puede usar el import en vez de require. Por lo que de abajo no es el código definitivo.

const express = require('express');
const app = express();
//Definir puerto
const port = process.env.PORT || 4000;
app.listen( () => {
    console.log(`El servidor está funcionando en el puerto ${port}`);
})

Nueva sintaxis para incorporar las dependencias

En un principio hicimos requerimiento de las dependencias usando, por ejemplo, const express = require(‘express’);. Esto incluso está así en algunos códigos de ejemplo para conexiones API. Pero ahora el instructor indica que esto es una herencia de una forma no correcta de hacerlo que terminó adoptándose. Pero que la forma correcta, que es con import ya la tenemos incorporada y que debería ser la correcta.

import express from 'express';

Paso 6 – Código inicial en el archivo index.js

Lo de abajo es un ejemplo del código inicial del archivo index.js de mi proyecto inicial donde se observa que:

  • Llamo a las dependencias de producción con import.
  • Creo la variable de la función express() para hacer uso de métodos del servidor.
  • Guardo el puerto en una variable o si no es el caso le he asignado el 4000
  • He creado el método .listen de express.
import express from 'express';

const app = express();
const port = process.env.PORT || 4000;
app.listen( port, ()  =>  console.log(`El servidor está funcionando en el puerto ${port}`));

El método .listen(), en un momento lo eliminé a ver qué pasaba, pero efectivamente el script dejó de funcionar, es por ello que lo coloco como algo indispensable. Pero que luego debería de saber más sobre ello.

Paso 7 – Ajustes del archivo package.json

Hay que indicar en el archivo package.json que estamos usando módulos para el tema de los imports y que por medio de la dependencia nodemon, que script vamos a arrancar.

type: module

Se debe incluir “type”: “module” en el objeto de script en el archivo package.json para que se puedan exportar las dependencias. Lo más probable es que en el futuro no sea necesario este último paso pero por los momentos hay que colocar esa bandera para poder usar los imports.

dev: nodemon index.js

Este código es el que reconoce el sistema para ejecutar cuando se arranca al servidor. En este caso cuando el servidor arranque, lo que hace es ejecutar el código en index.js. Con la ayuda de la dependencia de nodemon, este archivo se va a ejecutar cada vez que se modifique el archivo.

{
  "name": "agenciaviajesnode",
  "version": "1.0.0",
  "description": "Proyecto del curso de JavaScript",
  "main": "index.js",
  "scripts": {
    "dev": "nodemon index.js"
  },
  "type": "module",
  "author": "Brigzen Coronado",
  "license": "ISC",
  "dependencies": {
    "express": "^4.18.1"
  },
  "devDependencies": {
    "nodemon": "^2.0.16"
  }
}

Enrutamiento

Aquí vamos a definir el enrutamiento de las diferentes url.

Paso 8 – Crear archivo index.js en un directorio para las rutas

Es recomendable que las url, así se use una sola vista, estén colocadas en un archivo aparte y a su vez en un directorio aparte. Para ello se crea un directorio, preferencia de nombre routes y dentro, un archivo index.js.

Paso 9 – Código en el archivo index.js del directorio routes

Lo siguiente es un ejemplo del código dentro del archivo de las rutas.

import express from 'express';
const router = express.Router();
router.get('/', (req, res) => {
    res.render('inicio');
});
router.get('/nosotros', (req, res) => {
    res.render('nosotros');
});
export default router;
  • Llamamos el módulo dependencia servidor (como lo quieras llamar) con import.
  • Creamos las rutas con esa instancia con el método .get.
  • Exportamos la instancia router con export.
  • Importamos router en el archivo de configuración principal index.js.
  • Y finalmente le decimos en el mismo index.js que para determinar todas las rutas use router para ello. Esto se hace colocando el código app.use(‘/’, router); en el index.js.
import express from 'express';
import router from './routes/index.js'
const app = express();
const port = process.env.PORT || 4000;
app.use('/', router);
app.listen(port);

El template Engine

Esto es para poder mostrar código html y css.

Paso 10 – Instalar el engine PUG

Se instala PUG normalmente como ya se ha aprendido a hacer mediante linea de comandos en la terminal. Es conveniente que antes de instalar una nueva dependencia, detener el servidor y luego de instalada, volverlo a arrancar.

Paso 11 – Configurar PUG en el servidor

Esto se hace agregando el código app.set(‘view engine’, ‘pug’); en el archivo index.js.

import express from 'express';
import router from './routes/index.js'
const app = express();
const port = process.env.PORT || 4000;
app.use('/', router);
app.set('view engine', 'pug');
app.listen(port);

Paso 12 – Archivos .pug

Crear un directorio que puede ser llamado views. Y allí se colocan las diferentes vistas html. Pero usando archivos .pug.

Llamar el script y arrancar el servidor

Finalmente se usa una terminal para llamar el script anterior para que arranque el servidor. Esto se hace con el comando npm run dev. Claro está, desde la carpeta donde está la instalación.

brigzen@brigzen-ASUS:~/Server/macedonia$ npm run dev

> macedonia@1.0.0 dev
> nodemon index.js

[nodemon] 2.0.16
[nodemon] to restart at any time, enter `rs`
[nodemon] watching path(s): *.*
[nodemon] watching extensions: js,mjs,json
[nodemon] starting `node index.js`
El servidor está funcionando en el puerto 4000

Lo anterior ejecuta cualquier script especificado en package.json, en este caso parece que le estamos diciendo el que está especificado por dev.

Para detener el servidor se usa Ctrl + C.

Leave a Comment