Trabajar con variables de entorno en Node.js

Tiempo de lectura: 7 minutos

February 10, 2022

Redactado por

Dominik Kundel

Twilion

Darragh O'Connor

Twilion

Revisado por

Ayanna Julien

Twilion

Con solo algunas líneas de código, puedes ejecutar una aplicación Node.js directamente desde la terminal y utilizar Twilio para enviar y recibir mensajes de texto con SMS programable de Twilio.

Aspectos básicos de las variables de entorno en Node.js

Node.js es una de las estructuras más populares en la comunidad de desarrollo web desde hace años. Aunque aún es muy joven, Node.js ha demostrado ser rápida, altamente escalable y eficiente. El motivo de esto se debe a su estructura de entrada/salida impulsada por eventos y sin bloqueo.

Combinarla con Twilio lo ayuda a crear apps de telefonía en pocos pasos. Sin embargo, si deseas enviar un SMS, por ejemplo, deberás instalar Node.js y el módulo Twilio Node.js.

Otra gran característica del lenguaje Node.js (y sus módulos) es que tiene una forma de trabajar con variables de entorno, que utilizan muchos hosts en la nube (como Heroku, Azure, AWS, Now.sh, etc.). Esto abre una variedad de formas de configurar diferentes aspectos de tu aplicación Node.js. Por lo tanto, si bien los hosts establecen una variable PORT que especifica en qué puerto debe escuchar el servidor, los módulos podrían tener comportamientos diferentes (como iniciar sesión) según el valor de la variable NODE_ENV .

En este blog, revisaremos algunos trucos y herramientas para trabajar con variables de entorno en Node.js.

En primer lugar, debemos asegurarnos de que tenemos un entorno Node.js. A continuación, te guiaremos por los conceptos básicos de configuración de Node.js para su uso con Twilio en una Mac. Esto incluirá la instalación de npm en una Mac y la preparación del entorno para un proyecto de Twilio.

Cómo verificar si Node.js está instalado

Puedes verificar si ya tienes Node.js instalado en tu máquina al abrir una terminal y ejecutar lo siguiente:

node -v

Si no tienes Node.js instalado, los siguientes pasos te mostrarán cómo hacerlo

Ve a la página de descargas de Node.js.
Descarga Node.js para macOS al hacer clic en la opción Macintosh Installer (Instalador de Macintosh).
Ejecuta el instalador descargado Node.js .pkg.
Ejecuta el instalador, incluidas la aceptación de la licencia, la selección del destino y la autenticación para la instalación.

Una vez que la instalación esté completa, puedes asegurarte de que Node.js ejecutará “node -v” en tu terminal; debes obtener el número de versión actual como se muestra anteriormente.

Si no ves la versión de Node.js instalada, es posible que debas reiniciar tu terminal.

Para asegurarte de que la instalación esté correcta y se ejecute “node -v”, busca una confirmación de la instalación a través de su versión.

Ahora, tu entorno Mac está listo para instalar el módulo Twilio, de modo que los scripts Node.js en el directorio actual puedan utilizarlo.

Cargar explícitamente variables desde archivos .env

Puedes acceder a las variables del entorno en Node.js directamente desde el cuadro. Cuando el proceso Node.js se inicia, proporciona automáticamente acceso a todas las variables de entorno existentes mediante la creación de un objeto env dentro del objeto global del proceso.

Si deseas echar un vistazo al objeto, ejecuta el REPL de Node.js con “node” en tu línea de comandos y escribe:

console.log(process.env);

Este código debe emitir todas las variables de entorno que este proceso Node.js puede recoger. Para acceder a una variable específica, accede a ella como lo haría cualquier propiedad de un objeto:

console.log('The value of PORT is:', process.env.PORT);

Aquí, notarás que el valor de PORT no está definido en tu computadora. Sin embargo, los hosts en la nube como Heroku o Azure utilizan la variable PORT para indicarte a qué puerto debe escuchar el servidor para que el enrutamiento funcione correctamente. Por lo tanto, la próxima vez que configures un servidor web, puedes determinar el puerto que deseas que se escuche mediante la verificación del PORT primero y darle un valor predeterminado después:

const app = require('http').createServer((req, res) => res.send('Ahoy!'));
const PORT = process.env.PORT || 3000;

app.listen(PORT, () => {
  console.log(`Server is listening on port ${PORT}`);
});

La línea resaltada tomará el valor del PORT si está disponible o de forma predeterminada para escuchar 3000 como un puerto de respaldo. Prueba ejecutar el código al guardarlo en un archivo como server.js y ejecuta lo siguiente:

node server.js

El resultado debe ser un mensaje que diga: "Server is listening on port 3000." Detén el servidor con Ctrl+C y reinícialo con el siguiente comando:

PORT=9999 node server.js

El mensaje ahora debe decir “Server is listening on port 9999” (El servidor está escuchando en el puerto 9999). Esto significa que la variable PORT se ha establecido temporalmente frente al nodo para esta ejecución por el PORT=9999.

Dado que process.env es un objeto normal, podemos establecer/anular los valores:

process.env.MY_VARIABLE = 'ahoy';

El código anterior establecerá o anulará el valor de MY_VARIABLE. Sin embargo, ten en cuenta que este valor solo se establece durante la ejecución de este proceso Node.js y solo está disponible en procesos secundarios generados en este proceso. En general, debes evitar anular las variables de entorno tanto como sea posible e inicializar una variable de configuración, como se muestra en el ejemplo de PORT.

Si desarrollas varios proyectos Node.js en una computadora, es posible que tengas nombres de variables de entorno superpuestos. Por ejemplo, diferentes apps de mensajería podrían necesitar diferentes SID del servicio de mensajería de Twilio, pero ambos se llamarían TWILIO_MESSAGE_SERVICE_SID. Una excelente manera de lograr una configuración específica del proyecto es mediante el uso de archivos .env. Estos archivos te permiten especificar varias variables de entorno y valores asociados.

Normalmente, no deseas verificar estos archivos en el control de origen. Por lo tanto, cuando creas uno, solo agrega .env a tu archivo .gideore. Con una gran cantidad de archivos .env.example de aplicaciones de demostración de Twilio , puedes copiarlos en archivos .env y configurar los valores por tu cuenta. Tener un archivo .env.example o similar es una práctica habitual si deseas compartir un archivo de plantilla con otras personas del proyecto.

¿Cómo cargamos los valores de este archivo? La forma más rápida es utilizando un módulo de npm llamado dotenv. Instala el módulo a través de npm:

npm install dotenv --save

Luego, agrega la siguiente línea a la parte superior de tu archivo de entrada:

require('dotenv').config();

Este código cargará automáticamente el archivo .env en la raíz de tu proyecto e inicializará los valores, ignorando cualquier variable ya predeterminada. Sin embargo, ten cuidado de no utilizar archivos .env en tu entorno de producción. En cambio, establece los valores directamente en el host correspondiente. Por lo tanto, es posible que desees envolver tu declaración de carga en una declaración “if”:

if (process.env.NODE_ENV !== 'production') {
  require('dotenv').config();
}

Con este código, solo cargaremos el archivo .env si el servidor aún no está en modo de producción.

Veamos esto en acción. Instala dotenv en un directorio, como se muestra anteriormente. A continuación, crea un archivo dotenv-example.js en el mismo directorio y coloca las siguientes líneas en él:

console.log('No value for FOO yet:', process.env.FOO);

if (process.env.NODE_ENV !== 'production') {
  require('dotenv').config();
}

console.log('Now the value for FOO is:', process.env.FOO);

Después, crea un archivo llamado .env en el mismo directorio con este contenido:

FOO=bar

Ejecuta el script:

node dotenv-example.js

La salida debe tener el siguiente aspecto:

No value for FOO yet: undefined
Now the value for FOO is: bar

Como puedes ver, el valor se cargó y se definió usando dotenv. Si vuelves a ejecutar el mismo comando con NODE_ENV establecido en producción, verás que permanecerá indefinido.

NODE_ENV=production node dotenv-example.js

Ahora, la salida debe ser la siguiente:

No value for FOO yet: undefined
Now the value for FOO is: undefined

Si no deseas modificar tu código real, también puedes utilizar el argumento -r de Node para cargar dotenv al ejecutar el script. Para hacerlo, cambia tu archivo dotenv-example.js a lo siguiente:

console.log('The value for FOO is:', process.env.FOO);

Ahora ejecuta el archivo como lo harías normalmente:

node dotenv-example.js

El script debe indicar que el valor actual de FOO es undefined. Ahora, ejecútalo con el indicador adecuado que requiera dotenv:

node -r dotenv/config dotenv-example.js

El resultado es que FOO ahora está establecido como bar , ya que se cargó el archivo .env. Si deseas obtener más información sobre dotenv, consulta su documentación.

Una forma alternativa de cargar archivos .env

También existe un módulo alternativo basado en dotenv para hacer que las variables de entorno de carga sean más convenientes. El resultado es nodenv-run o nodenv. Esta herramienta de línea de comandos cargará un archivo .env, inicializará los valores con dotenv y ejecutará tu script.

Puedes instalarlo a nivel mundial, pero esto se recomienda solo para fines de desarrollo y de forma local para el proyecto. Instálalo ejecutando lo siguiente:

npm install node-env-run --save-dev

Después, crea un archivo nodenv-example.js y coloca este código en él:

console.log('The value for FOO is:', process.env.FOO);

Como puedes ver, no necesitamos nada aquí porque es solo la lógica de la aplicación. Para intentar ejecutarlo, utiliza el siguiente nodo:

node nodenv-example.js

Este código ejecutado debe emitir “The value for FOO is: undefined” (El valor de FOO es: no definido). Ahora, intenta utilizar node-env-run ejecutando lo siguiente:

node_modules/.bin/nodenv nodenv-example.js

El resultado debe ser “The value for FOO is: bar” (El valor de FOO es: bar), ya que cargó el archivo .env.

El uso de node-env-run puede anular estos valores existentes. Para verlo en acción, primero ejecuta el siguiente comando:

FOO=foo node_modules/.bin/nodenv nodenv-example.js

El resultado de la línea de comandos debe decir “The value for FOO is: foo” (El valor de FOO es: foo). Si ahora habilitamos el modo de fuerza, podemos anular los valores existentes:

FOO=foo node_modules/.bin/nodenv --force nodenv.js

Como resultado, debemos volver al mensaje original “The value for FOO is: bar”.

Si deseas utilizar esta herramienta con regularidad, te recomiendo que la envuelvas en un script de npm agregándola a package.json como tal:

{
  "name": "twilio-blog",
  "version": "1.0.0",
  "description": "",
  "main": "nodenv-example.js",
  "scripts": {
    "start": "node .",
    "start:dev": "nodenv -f ."
  },
  "author": "",
  "license": "ISC",
  "devDependencies": {
    "node-env-run": "^2.0.1"
  }
}

De esta manera, puedes ejecutar lo siguiente:

npm run start:dev

Si deseas obtener más información sobre node-env-run, consulta su documentación.

Variables de entorno y scripts npm

También hay situaciones en las que resulta útil verificar el valor de una variable de entorno antes de ingresar a la aplicación Node.js en scripts npm. Por ejemplo, si deseas utilizar node-env-run cuando te encuentras en un entorno de desarrollo, utiliza el nodo cuando estés en modo de producción. Utiliza la herramienta if-env para esto. Instálalo ejecutando lo siguiente:

npm install if-env --save

Sin embargo, asegúrate de no instalarlo como una dependencia de desarrollo, ya que también lo solicitaremos en la producción.

Ahora, modifica tus scripts npm en tu package.json:

 "scripts": {
    "start": "if-env NODE_ENV=production ?? npm run start:prod || npm run start:dev",
    "start:dev": "nodenv -f .",
    "start:prod": "node ."
  }

Este script ahora ejecutará npm run start:prod y posteriormente el nodo. Si NODE_ENV tiene la producción de valor, entonces podrá ejecutar npm run start:dev y posteriormente nodenv -f. También puedes hacerlo con cualquier otra variable de entorno.

Prueba esto ejecutando lo siguiente:

# should output "The value of FOO is: bar"
npm start
# should output "The value of FOO is: undefined"
NODE_ENV=production npm start

Si deseas obtener más información sobre if-env, consulta su documentación.

Cómo instalar npm en una Mac

Por lo general, esto se instalará automáticamente como parte de la instalación anterior. Puedes comprobar esto ejecutando el comando npm en la terminal. Si se instaló, verás un listado de uso. Caso contrario, para instalar npm, ejecuta lo siguiente:

sudo apt install npm

Depuración en Node.js

Lo que sigue es el tiempo de depuración. Una estrategia que me ayudó mucho es utilizar la variable de entorno de DEBUG (depurar) para recibir registros más detallados para varios módulos. Por ejemplo, un servidor Express básico como el siguiente:

const app = require('express')();
const bodyParser = require('body-parser');
app.use(bodyParser.json()); // for parsing application/json
app.use(bodyParser.urlencoded({ extended: true })); // for parsing application/x-www-form-urlencoded

app.post('/', (req, res, next) => {
console.log(req);
});

app.listen(3000);

Inicia el servidor con la variable DEBUG establecida en *:

DEBUG=* node server.js

Recibirás un registro extensivo que se ve similar al siguiente:

La magia detrás de ella es un módulo ligero llamado debug. Cuando deseas utilizarlo, todo lo que tienes que hacer es inicializarlo con un espacio de nombre. Después, puedes registrarlo en ese espacio de nombre. Si alguien quiere ver la salida, todo lo que tiene que hacer es activar el espacio de nombre en la variable DEBUG. En este caso, Express utiliza un montón de subespacios de nombres. Por lo tanto, si deseas todo desde el enrutador Express, lo que debe hacer es configurar el DEBUG con el comodín correspondiente:

DEBUG=express:router* node server.js

Si deseas utilizar debug en tu módulo, primero debes instalarlo:

npm install debug --save

Después, aplícalo de la siguiente manera:

const debug = require('debug')('myApp:someComponent');

debug('Here is a pretty object %o', { someObject: true });

Si deseas obtener más información sobre debug, consulta su documentación.

Utiliza todas las variables de entorno Node.js en Node.js con Twilio

Estas son solo algunas de las cosas que puedes hacer con las variables de entorno y todas las herramientas que existen. Ahora que has aprendido un poco más acerca de las variables de entorno en Node.js, prueba los inicios rápidos de Node.js de Twilio, incluido nuestro inicio rápido de SMS. ¡Comienza de forma gratuita!