Tutoriales

Las variables de entorno 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 (development, test, production, etc).

KASPERSKY ANTI-VIRUS 2020 1AÑO 1PC
Publicidad
KASPERSKY ANTI-VIRUS 2020 1AÑO 1PC by KASPERSKY LABS

Tabla de contenido

Introducción

La implementación de una aplicación requiere que los desarrolladores pongan atención y consideración en cómo se configura. Todas las aplicaciones se implementan en un entorno de desarrollo (development) antes de implementarse en el entorno de producción (production). Necesitamos asegurarnos de que cada entorno esté correctamente configurado, podría ser desastroso si nuestra aplicación de producción estuviera utilizando nuestra base de datos de desarrollo, por mencionar un ejemplo.

Muchos proveedores de servicios en la nube (Heroku, Azure, AWS, etc.) y además de los módulos de Node.js utilizan variables de entorno. Los proveedores, por ejemplo, establecerán una variable PORT que especifica en qué puerto del servidor debe ubicarse para que funcione correctamente. Los módulos pueden tener diferentes comportamientos en función del valor de la variable NODE_ENV.

¿Qué son las variables de entorno?

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.

Por convención, el nombre se escribe con mayúscula y los valores son cadenas de texto, por ejemplo: PORT=8080.

Normalmente, nuestras aplicaciones requieren que se establezcan muchas variables de entorno para que funcionen. Al confiar en configuraciones externas, su 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 su 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.
  • Credenciales de Base de Datos.
  • Ubicación de archivos y carpetas estáticos.
  • Credenciales de API's externas.

En este tutorial crearemos un simple servidor en Node.js utilizando Express.js, el cuál lo dejaremos listo para que funcione en 2 entornos diferentes (development y production) utilizando la librería DotEnv.

Architecture Patterns with Python: Enabling Test-Driven Development, Domain-Driven Design, and Event-Driven Microservices
Publicidad
Architecture Patterns with Python: Enabling Test-Driven Development, Domain-Driven Design, and Event-Driven Microservices by Harry Percival

Requerimientos

Únicamente necesitamos la previa instalación de Node.js, junto con el gestor de paquetes npm para descargar los paquetes necesarios para realizar este ejemplo:

node >= 8.0 o mayor

$ node --version

npm >= 5.0 o mayor

$ npm --version

Ejemplo Inicial

Para iniciar, creamos el archivo package.json de la siguiente manera, o bien ingresando los datos con el comando npm init:


// package.json
{
  "name": "nodejs-env",
  "version": "0.0.1",
  "description": "Tutorial: Variables de entorno con Node.js",
  "main": "index.js",
  "scripts": {
    "test": "set HOST=localhost&& set PORT=8000&& node server.js"
  },
  "author": "Víctor Valencia Rico",
  "license": "ISC"  
}
  

Ahora, necesitamos instalar Express.js con el paquete express:

$ npm i express --save

Crearemos un archivo llamado config.js el cual centralizará nuestras variables de entorno:


// config.js
module.exports = {
  NODE_ENV: process.env.NODE_ENV || 'development',
  HOST: process.env.HOST || '127.0.0.1',
  PORT: process.env.PORT || 3000
}
  

A continuación crearemos nuestro archivo server.js el cual contedrá el siguiente código:


// server.js
const config = require('./config.js');
const express = require('express');
const app = express();

console.log(`NODE_ENV=${config.NODE_ENV}`);

app.get('/', (req, res) => {  
  res.send('Hello world');
});

app.listen(config.PORT, config.HOST, function () {  
  console.log(`App listening on http://${config.HOST}:${config.PORT}`);
});
  

Ahora, ejecutamos nuestra aplicación:


$ node server.js
# NODE_ENV=development
# App listening on http://127.0.0.1:3000
  

Abrimos http://127.0.0.1:3000 en el navegador para ver el resultado de nuestra aplicación.

En el ejemplo anterior, llamamos a una operación GET que enviará el mensaje Hello world en nuestro navegador, como se muestra en la imagen anterior. La variable HOST y PORT estan definidas en nuestro código. Además ejecutará la aplicación en la dirección 127.0.0.1:3000.

El acceso a las variables de entorno en Node.js es compatible desde que inicia nuestra aplicación. Cuando el proceso Node.js se inicia, proporcionará 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.

Hasta este punto nuestra aplicación se inicializará en función de las variables de entorno que se definan.

Veamos otro ejemplo, ahora, ejecutamos la tarea test que fue definida dentro de nuestro archivo package.json con el siguiente comando:


$ npm run test
# > nodejs-env@0.0.1 prod C:\server.js  
# > set HOST=localhost&& set PORT=8000&& node server.js

# NODE_ENV=development
# App listening on http://localhost:8000
  

Abrimos http://localhost:8000 en el navegador para ver el resultado de nuestra aplicación.

Ejecutará nuestra aplicación en la dirección localhost:8000, ya que fueron definidas en la tarea las variables de entorno: HOST=localhost y PORT=8000.

Python for Everybody: Exploring Data in Python 3
Publicidad
Python for Everybody: Exploring Data in Python 3 by Charles Severance

Ejemplo con DotEnv

En el ejemplo anterior, ejecutamos la tarea definida npm run test, la cual se definió de la siguiente manera en nuestro archivo package.json:


set HOST=localhost&& set PORT=8000&& node server.js
  

El desarrollo con múltiples variables de entorno se vuelve rápidamente dificil de mantener. Sería mejor si las variables de entorno que deberiamos de configurar estuvieran almacenadas en un lugar central para la aplicación, como un archivo.

Es aqui donde entra la función principal de la librería dotenv. El cual nos permitirá leer estas variables desde un archivo llamado .env, para posteriormente cargar las variables de entorno en la variable process.env.

Para comenzar a usar la librerá dotenv en su aplicación Node.js, necesitamos instalar el paquete de la siguiente manera:

$ npm i dotenv --save

Luego, modificamos nuestro archivo config.js de la siguiente manera:


// config.js
const dotenv = require('dotenv').config();

module.exports = {

  NODE_ENV: process.env.NODE_ENV || 'development',
  HOST: process.env.HOST || '127.0.0.1',
  PORT: process.env.PORT || 3000

}
  

A continuación crearemos un nuevo archivo llamado .env el cual contedrá nuestras variables de entorno:


// .env
NODE_ENV=development
HOST=127.0.0.1
PORT=5000
  

Ahora, ejecutamos nuestra aplicación:


$ node server.js
# NODE_ENV=development
# App listening on http://127.0.0.1:5000

Abrimos http://127.0.0.1:5000/ en el navegador para ver el resultado de nuestra aplicación.

En el ejemplo anterior, el método config() cargará las variables de entorno definidas en nuestro archivo .env, para posteriormente cargar la variable process.env con todas las variables de entorno, un ejemplo es la variable process.env.PORT, será inicializada con el valor 5000.

Múltiples Entornos con DotEnv

Si deseamos configurar nuestra aplicación en diferentes entornos, dotenv nos permite definir tantos entornos necesitemos. Supongamos que necesitamos configurar 2 entornos básicos: development y production.

Entonces crearemos 2 archivos nuevos development.env y production.env, uno para cada entorno, los cuales contendrán la siguiente configuración:


// development.env
NODE_ENV=development
HOST=127.0.0.1
PORT=5000
  

// production.env
NODE_ENV=production
HOST=localhost
PORT=8000
  

Luego, modificamos nuestro archivo config.js de la siguiente manera:


// config.js
const dotenv = require('dotenv');
const path = require('path');

dotenv.config({
  path: path.resolve(__dirname, process.env.NODE_ENV + '.env')
});

module.exports = {
  NODE_ENV: process.env.NODE_ENV || 'development',
  HOST: process.env.HOST || '127.0.0.1',
  PORT: process.env.PORT || 3000
}
  

La librería dotenv nos permitirá cargar a traves del método config() y el objecto path, el archivo .env que necesitemos de acuerdo al entorno deseado.

Agregamos 2 nuevas tareas en nuestro archivo package.json, una para cada entorno, de la siguiete manera:


// package.json
{
  ...
  "scripts": {
    ...
    "dev": "set NODE_ENV=development&& node server.js",
    "prod": "set NODE_ENV=production&& node server.js"
  },
  ...
}
  

Listo, ahora ejecutamos nuestra tarea npm run dev para el entorno development:


$ npm run dev
# > nodejs-env@0.0.1 prod C:\server.js  
# > set NODE_ENV=development&& node server.js

# NODE_ENV=development
# App listening on http://127.0.0.1:5000
  

Abrimos http://127.0.0.1:5000 en el navegador para ver el resultado de nuestra aplicación.

Por último, ejecutamos nuestra tarea npm run prod para el entorno production:


$ npm run prod
# > nodejs-env@0.0.1 prod C:\server.js  
# > set NODE_ENV=production&& node server.js

# NODE_ENV=production
# App listening on http://localhost:8000
  

Abrimos http://localhost:8000 en el navegador para ver el resultado de nuestra aplicación.

Microsoft Office 365 Home Mac/Win 2019
Publicidad
Microsoft Office 365 Home Mac/Win 2019 by Microsoft

Conclusión

Trabajar con múltiples entornos te facilita el desarrollo de tu aplicación, ya que si tienen pensado pasar su aplicación a un entono de producción, esta configuración les facilitará el trabajo, por ejemplo, si trabajan con el proveedor de Heroku o Azure, estos utilizan la variable PORT para definir en qué puerto deben colocar su servidor para que el enrutamiento funcione correctamente.

Espero que este tutorial les sirva, si ya tenias nociones de este tema, espero que te sirva como referencia y reforces tus conocimientos. Si les ha gustado el tutorial valoren el esfuerzo y compartan en sus redes sociales. No duden en comentar dudas, aportes o sugerencias, estaré encantado de responderles.