Primeros pasos con Node.js

Servidor HTTP Hola Mundo

Primero, instale Node.js para su plataforma.

En este ejemplo, crearemos un servidor HTTP escuchando en el puerto 1337, que envía “¡Hola, mundo!” al navegador. Tenga en cuenta que, en lugar de usar el puerto 1337, puede usar cualquier número de puerto de su elección que actualmente no esté en uso por ningún otro servicio.

El módulo http es un Node.js [core module](https://www.wikiod.com/es/node-js/primeros-pasos-con-nodejs#Módulos centrales ) (un módulo incluido en el código fuente de Node.js, que no requiere la instalación de recursos adicionales). El módulo http proporciona la funcionalidad para crear un servidor HTTP utilizando el método http.createServer(). To create the application, create a file containing the siguiente código JavaScript.

const http = require('http'); // Loads the http module

http.createServer((request, response) => {

    // 1. Tell the browser everything is OK (Status code 200), and the data is in plain text
    response.writeHead(200, {
        'Content-Type': 'text/plain'
    });

    // 2. Write the announced text to the body of the page
    response.write('Hello, World!\n');

    // 3. Tell the server that all of the response headers and body have been sent
    response.end();

}).listen(1337); // 4. Tells the server what port to be on

Guarde el archivo con cualquier nombre de archivo. En este caso, si lo nombramos hello.js podemos ejecutar la aplicación yendo al directorio en el que se encuentra el archivo y usando el siguiente comando:

node hello.js

Se puede acceder al servidor creado con la URL http://localhost:1337 o http://127.0.0.1:1337 en el navegador.

Aparecerá una página web simple con un “¡Hola, mundo!” texto en la parte superior, como se muestra en la siguiente captura de pantalla.

Captura de pantalla

Ejemplo en línea editable.

Línea de comando Hola mundo

Node.js también se puede usar para crear utilidades de línea de comandos. El siguiente ejemplo lee el primer argumento de la línea de comando e imprime un mensaje de saludo.

Para ejecutar este código en un sistema Unix:

  1. Cree un nuevo archivo y pegue el código a continuación. El nombre del archivo es irrelevante.
  2. Haga que este archivo sea ejecutable con chmod 700 FILE_NAME
  3. Ejecute la aplicación con ./APP_NAME David

En Windows, realiza el paso 1 y ejecútelo con node APP_NAME David

#!/usr/bin/env node

'use strict';

/*
    The command line arguments are stored in the `process.argv` array, 
    which has the following structure:
    [0] The path of the executable that started the Node.js process
    [1] The path to this application
    [2-n] the command line arguments

    Example: [ '/bin/node', '/path/to/yourscript', 'arg1', 'arg2', ... ]
    src: https://nodejs.org/api/process.html#process_process_argv
 */

// Store the first argument as username.
var username = process.argv[2];

// Check if the username hasn't been provided.
if (!username) {

    // Extract the filename
    var appName = process.argv[1].split(require('path').sep).pop();

    //  Give the user an example on how to use the app.
    console.error('Missing argument! Example: %s YOUR_NAME', appName);

    // Exit the app (success: 0, error: 1). 
    // An error will stop the execution chain. For example:
    //   ./app.js && ls       -> won't execute ls
    //   ./app.js David && ls -> will execute ls
    process.exit(1);
}

// Print the message to the console.
console.log('Hello %s!', username);

Hola Mundo con Express

El siguiente ejemplo usa Express para crear un servidor HTTP escuchando en el puerto 3000, que responde con “¡Hola, mundo!”. Express es un marco web de uso común que es útil para crear API HTTP.

Primero, cree una nueva carpeta, p. miAplicación. Vaya a myApp y cree un nuevo archivo JavaScript que contenga el siguiente código (por ejemplo, llamémoslo hello.js). Luego instale el módulo express usando npm install --save express desde la línea de comando. Consulte esta documentación para obtener más información sobre cómo instalar paquetes.

// Import the top-level function of express
const express = require('express');

// Creates an Express application using the top-level function
const app = express();

// Define port number as 3000
const port = 3000;

// Routes HTTP GET requests to the specified path "/" with the specified callback function
app.get('/', function(request, response) {
  response.send('Hello, World!');
});

// Make the app listen on port 3000
app.listen(port, function() {
  console.log('Server listening on http://localhost:' + port);
});

Desde la línea de comando, ejecute el siguiente comando:

node hello.js

Abra su navegador y vaya a http://localhost:3000 o http://127.0.0.1:3000 para ver la respuesta.

Para obtener más información sobre el marco Express, puede consultar la sección [Aplicaciones web con Express] 2

1: https://www.wikiod.com/es/node-js/npm#Instalando paquetes 2: https://www.wikiod.com/es/node-js/aplicaciones-web-con-express

Instalar y ejecutar Node.js

Para comenzar, instale Node.js en su computadora de desarrollo.

Windows: Vaya a la página de descarga y descargue o ejecute el instalador.

Mac: Vaya a la página de descarga y descargue o ejecute el instalador. Alternativamente, puede instalar Node a través de Homebrew usando brew install node. Homebrew es un administrador de paquetes de línea de comandos para Macintosh, y se puede encontrar más información al respecto en el sitio web de Homebrew.

Linux: Siga las instrucciones para su distribución en la página de instalación de la línea de comandos.


Ejecutar un programa de nodo

Para ejecutar un programa Node.js, simplemente ejecute node app.js o nodejs app.js, donde app.js es el nombre de archivo del código fuente de su aplicación de nodo. No necesita incluir el sufijo .js para Node para encontrar el script que desea ejecutar.

Como alternativa, en los sistemas operativos basados ​​en UNIX, un programa Node puede ejecutarse como un script de terminal. Para hacerlo, debe comenzar con un shebang que apunte al intérprete de Node, como #!/usr/bin/env node. El archivo también debe configurarse como ejecutable, lo que se puede hacer usando chmod. Ahora el script se puede ejecutar directamente desde la línea de comandos.

Depuración de su aplicación NodeJS

Puede utilizar el inspector de nodos. Ejecute este comando para instalarlo a través de npm:

npm install -g node-inspector

Luego puede depurar su aplicación usando

node-debug app.js

El repositorio de Github se puede encontrar aquí: https://github.com/node-inspector/node-inspector


Depuración nativa

También puede depurar node.js de forma nativa si lo inicia así:

node debug your-script.js

Para interrumpir su depurador exactamente en una línea de código que desee, use esto:

debugger;

Para obtener más información, consulte aquí.

En node.js 8 use el siguiente comando:

node --inspect-brk your-script.js

Luego abra about://inspect en una versión reciente de Google Chrome y seleccione su secuencia de comandos de Node para obtener la experiencia de depuración de Chrome’s DevTools.

Enrutamiento básico de Hello World

Una vez que comprenda cómo crear un Servidor HTTP con un nodo, es importante comprender cómo hacer que “haga” cosas en función de la ruta a la que ha navegado un usuario. Este fenómeno se denomina “enrutamiento”.

El ejemplo más básico de esto sería verificar if (request.url === 'alguna/ruta/aquí'), y luego llamar a una función que responda con un nuevo archivo.

Un ejemplo de esto se puede ver aquí:

const http = require('http');

function index (request, response) {
    response.writeHead(200);
    response.end('Hello, World!');
}

http.createServer(function (request, response) {
    
    if (request.url === '/') {
        return index(request, response);
    }

    response.writeHead(404);
    response.end(http.STATUS_CODES[404]);

}).listen(1337);

Sin embargo, si continúa definiendo sus “rutas” de esta manera, terminará con una función de devolución de llamada masiva, y no queremos un lío gigante como ese, así que veamos si podemos arreglar esto.

Primero, almacenemos todas nuestras rutas en un objeto:

var routes = {
    '/': function index (request, response) {
        response.writeHead(200);
        response.end('Hello, World!');
    },
    '/foo': function foo (request, response) {
        response.writeHead(200);
        response.end('You are now viewing "foo"');
    }
}

Ahora que hemos almacenado 2 rutas en un objeto, ahora podemos verificarlas en nuestra devolución de llamada principal:

http.createServer(function (request, response) {
    
    if (request.url in routes) {
        return routes[request.url](request, response);
    }

    response.writeHead(404);
    response.end(http.STATUS_CODES[404]);

}).listen(1337);

Ahora, cada vez que intente navegar por su sitio web, verificará la existencia de esa ruta en sus rutas y llamará a la función respectiva. Si no se encuentra ninguna ruta, el servidor responderá con un 404 (No encontrado).

Y ahí lo tiene: el enrutamiento con la API del servidor HTTP es muy simple.

1: https://www.wikiod.com/es/node-js/primeros-pasos-con-nodejs#Servidor HTTP Hola Mundo

Hola Mundo en el REPL

Cuando se llama sin argumentos, Node.js inicia un REPL (Read-Eval-Print-Loop), también conocido como “Node shell”.

En un símbolo del sistema, escriba nodo.

$ node
>

En el indicador del shell de Node > escriba “¡Hola mundo!”

$ node
> "Hello World!"
'Hello World!'

Desplegando su aplicación en línea

Cuando implementa su aplicación en un entorno alojado (específico de Node.js), este entorno generalmente ofrece una variable de entorno PORT que puede usar para ejecutar su servidor. Cambiar el número de puerto a process.env.PORT le permite acceder a la aplicación.

Por ejemplo,

http.createServer(function(request, response) {
   // your server code
}).listen(process.env.PORT);

Además, si desea acceder a esto sin conexión durante la depuración, puede usar esto:

http.createServer(function(request, response) {
  // your server code
}).listen(process.env.PORT || 3000);

donde 3000 es el número de puerto fuera de línea.

Módulos centrales

Node.js es un motor Javascript (el motor V8 de Google para Chrome, escrito en C++) que permite ejecutar Javascript fuera del navegador. Si bien hay numerosas bibliotecas disponibles para ampliar las funcionalidades de Node, el motor viene con un conjunto de módulos principales que implementan funcionalidades básicas.

Actualmente hay 34 módulos principales incluidos en Node:

[ 'assert',
  'buffer',
  'c/c++_addons',
  'child_process',
  'cluster',
  'console',
  'crypto',
  'deprecated_apis',
  'dns',
  'domain',
  'Events',
  'fs',
  'http',
  'https',
  'module',
  'net',
  'os',
  'path',
  'punycode',
  'querystring',
  'readline',
  'repl',
  'stream',
  'string_decoder',
  'timers',
  'tls_(ssl)',
  'tracing',
  'tty',
  'dgram',
  'url',
  'util',
  'v8',
  'vm',
  'zlib' ]

Esta lista se obtuvo de la API de documentación de Node https://nodejs.org/api/all.html (archivo JSON: https://nodejs.org/api/all.json).

Todos los módulos principales de un vistazo

assert

El módulo assert proporciona un conjunto simple de pruebas de aserción que se pueden usar para probar invariantes.

búfer

Antes de la introducción de TypedArray en ECMAScript 2015 (ES6), el El lenguaje JavaScript no tenía ningún mecanismo para leer o manipular flujos de datos binarios. La clase Buffer se introdujo como parte de Node.js API para hacer posible interactuar con flujos de octetos en el contexto de las cosas como transmisiones TCP y operaciones del sistema de archivos.

Ahora que TypedArray se ha agregado en ES6, la clase Buffer implementa el Uin t8Array API de una manera más optimizada y adecuada para Node.js' casos de uso.

c/c++_addons

Los complementos de Node.js son objetos compartidos vinculados dinámicamente, escritos en C o C++, que se puede cargar en Node.js usando la función require() y usado como si fueran un módulo ordinario de Node.js. Se utilizan principalmente para proporcionar una interfaz entre JavaScript que se ejecuta en Node.js y bibliotecas C/C++.

child_process

El módulo child_process brinda la capacidad de generar procesos secundarios en una manera que es similar, pero no idéntica, a popen(3).

cluster

Una sola instancia de Node.js se ejecuta en un solo subproceso. Para aprovechar los sistemas multinúcleo, el usuario a veces querrá lanzar un clúster de Node.js procesos para manejar la carga. El módulo de clúster le permite crear fácilmente procesos secundarios que todos comparten puertos de servidor.

console

El módulo console proporciona una consola de depuración simple que es similar a la Mecanismo de consola de JavaScript proporcionado por los navegadores web.

crypto

El módulo crypto proporciona funcionalidad criptográfica que incluye un conjunto de envoltorios para las funciones hash, HMAC, cifrado, descifrado, firma y verificación de OpenSSL.

deprecated_apis

Node.js puede desaprobar las API cuando: (a) se considera que el uso de la API es inseguro, (b) se ha puesto a disposición una API alternativa mejorada, o (c) se esperan cambios importantes en la API en una versión importante futura.

dns

El módulo dns contiene funciones que pertenecen a dos categorías diferentes:

  1. Funciones que utilizan las instalaciones del sistema operativo subyacente para realizar resolución de nombres, y que no necesariamente realizan ninguna comunicación de red. Esta categoría contiene solo una función: dns.lookup().
  2. Funciones que se conectan a un servidor DNS real para realizar la resolución de nombres, y que siempre utilicen la red para realizar consultas de DNS. Esta categoría contiene todas las funciones del módulo dns excepto dns.lookup() .

dominio

Este módulo está pendiente de desaprobación. Una vez que una API de reemplazo ha sido finalizado, este módulo quedará completamente obsoleto. La mayoría de los usuarios finales deberían no tiene motivos para usar este módulo. Usuarios que absolutamente deben tener la funcionalidad que proporcionan los dominios puede depender de ella por el momento pero debe esperar tener que migrar a una solución diferente en el futuro.

Eventos

Gran parte de la API central de Node.js se basa en un lenguaje asíncrono idiomático arquitectura dirigida por eventos en la que ciertos tipos de objetos (llamados “emisores”) emiten periódicamente eventos con nombre que hacen que los objetos Function (“oyentes”) sean llamado.

fs

La E/S de archivos se proporciona mediante envoltorios simples alrededor de las funciones POSIX estándar. Para usar este módulo, require('fs'). Todos los métodos tienen formas asíncronas y síncronas.

http

Las interfaces HTTP en Node.js están diseñadas para admitir muchas funciones del protocolo que tradicionalmente han sido difíciles de utilizar. En particular, mensajes grandes, posiblemente codificados por fragmentos. la interfaz es tenga cuidado de nunca almacenar en búfer solicitudes o respuestas completas; el usuario puede transmitir datos.

https

HTTPS es el protocolo HTTP sobre TLS/SSL. En Node.js esto se implementa como un módulo separado.

módulo

Node.js tiene un sistema de carga de módulos simple. En Node.js, archivos y módulos están en correspondencia uno a uno (cada archivo se trata como un módulo separado).

net

El módulo net le proporciona una envoltura de red asíncrona. Contiene funciones para crear tanto servidores como clientes (llamados flujos). Puedes incluir este módulo con require('net');.

os

El módulo os proporciona una serie de métodos de utilidad relacionados con el sistema operativo.

ruta

El módulo path proporciona utilidades para trabajar con rutas de archivos y directorios.

punycode

La versión del módulo punycode incluido en Node.js está en desuso.

cadena de consulta

El módulo cadena de consulta proporciona utilidades para analizar y formatear cadenas de consulta de URL.

readline

El módulo readline proporciona una interfaz para leer datos de un Legible flujo (como process.stdin) una línea a la vez.

repl

El módulo repl proporciona una implementación Read-Eval-Print-Loop (REPL) que está disponible como un programa independiente o incluible en otras aplicaciones.

flujo

Un flujo es una interfaz abstracta para trabajar con transmisión de datos en Node.js. El módulo stream proporciona una API base que facilita la creación de objetos que implementan la interfaz de transmisión.

Hay muchos objetos de flujo proporcionados por Node.js. Por ejemplo, un solicitud a un servidor HTTP y proceso.stdout ambas son instancias de transmisión.

string_decoder

El módulo string_decoder proporciona una API para decodificar objetos Buffer en cadenas de una manera que conserva codificados multibyte UTF-8 y UTF-16 caracteres.

temporizadores

El módulo timer expone una API global para programar funciones para ser llamado en algún período de tiempo futuro. Debido a que las funciones del temporizador son globales, no es necesario llamar a require('timers') para usar la API.

Las funciones de temporizador dentro de Node.js implementan una API similar a la API de temporizadores proporcionada por los navegadores web, pero utiliza una implementación interna diferente que es construido alrededor de el bucle de eventos de Node.js.

tls_(ssl)

El módulo tls proporciona una implementación de la Seguridad de la capa de transporte (TLS) y Secure Socket Layer (SSL) que se basa en OpenSSL.

rastreo

Trace Event proporciona un mecanismo para centralizar la información de rastreo generada por V8, núcleo de nodo y código de espacio de usuario.

El seguimiento se puede habilitar pasando el indicador --trace-events-enabled al iniciar un Aplicación Node.js.

tty

El módulo tty proporciona las clases tty.ReadStream y tty.WriteStream. En la mayoría de los casos, no será necesario ni posible utilizar este módulo directamente.

dgram

El módulo dgram proporciona una implementación de sockets de datagramas UDP.

url

El módulo url proporciona utilidades para la resolución y análisis de URL.

util

El módulo util está diseñado principalmente para satisfacer las necesidades de Node.js' propias API internas. Sin embargo, muchas de las utilidades también son útiles para los desarrolladores de aplicaciones y módulos.

v8

El módulo v8 expone las API que son específicas de la versión de V8 integrado en el binario Node.js.

Nota: Las API y la implementación están sujetas a cambios en cualquier momento.

vm

El módulo vm proporciona API para compilar y ejecutar código dentro de contextos de máquinas virtuales V8. El código JavaScript puede compilarse y ejecutarse inmediatamente o compilarse, guardarse y ejecutarse más tarde.

Nota: El módulo vm no es un mecanismo de seguridad. No lo use para ejecutar código que no sea de confianza.

zlib

El módulo zlib proporciona funcionalidad de compresión implementada usando Gzip y Desinflar/Inflar.

Socket TLS: servidor y cliente

Las únicas diferencias importantes entre esto y una conexión TCP normal son la clave privada y el certificado público que deberá configurar en un objeto de opción.

Cómo crear una clave y un certificado

El primer paso en este proceso de seguridad es la creación de una clave privada. ¿Y qué es esta clave privada? Básicamente, es un conjunto de ruido aleatorio que se utiliza para cifrar información. En teoría, podría crear una clave y usarla para cifrar lo que quiera. Pero es una buena práctica tener diferentes claves para cosas específicas. Porque si alguien roba tu clave privada, es similar a que alguien robe las llaves de tu casa. Imagínese si usara la misma llave para cerrar su automóvil, garaje, oficina, etc.

openssl genrsa -out clave-privada.pem 1024

Una vez que tenemos nuestra clave privada, podemos crear una CSR (solicitud de firma de certificado), que es nuestra solicitud para que una autoridad elegante firme la clave privada. Es por eso que debe ingresar información relacionada con su empresa. Esta información será vista por la autoridad firmante y utilizada para verificarlo. En nuestro caso, da igual lo que escribas, ya que en el siguiente paso vamos a firmar nosotros mismos nuestro certificado.

openssl req -new -key clave-privada.pem -out csr.pem

Ahora que hemos completado nuestro papeleo, es hora de pretender que somos una autoridad de firma genial.

openssl x509 -req -in csr.pem -signkey clave-privada.pem -out public-cert.pem

Ahora que tiene la clave privada y el certificado público, puede establecer una conexión segura entre dos aplicaciones de NodeJS. Y, como puedes ver en el código de ejemplo, es un proceso muy simple.

¡Importante!

Dado que nosotros mismos creamos el certificado público, con toda honestidad, nuestro certificado no tiene valor, porque no somos nadie. El servidor NodeJS no confiará en dicho certificado de forma predeterminada, y es por eso que debemos decirle que realmente confíe en nuestro certificado con la siguiente opción rechazar no autorizado: falso. Muy importante: nunca establezca esta variable en verdadero en un entorno de producción.

Servidor de conexión TLS

'use strict';

var tls = require('tls');
var fs = require('fs');

const PORT = 1337;
const HOST = '127.0.0.1'

var options = {
    key: fs.readFileSync('private-key.pem'),
    cert: fs.readFileSync('public-cert.pem')
};

var server = tls.createServer(options, function(socket) {

    // Send a friendly message
    socket.write("I am the server sending you a message.");

    // Print the data that we received
    socket.on('data', function(data) {

        console.log('Received: %s [it is %d bytes long]',
            data.toString().replace(/(\n)/gm,""),
            data.length);

    });

    // Let us know when the transmission is over
    socket.on('end', function() {

        console.log('EOT (End Of Transmission)');

    });

});

// Start listening on a specific port and address
server.listen(PORT, HOST, function() {

    console.log("I'm listening at %s, on port %s", HOST, PORT);

});

// When an error occurs, show it.
server.on('error', function(error) {

    console.error(error);

    // Close the connection after the error occurred.
    server.destroy();

});

Cliente de conexión TLS

'use strict';

var tls = require('tls');
var fs = require('fs');

const PORT = 1337;
const HOST = '127.0.0.1'

// Pass the certs to the server and let it know to process even unauthorized certs.
var options = {
    key: fs.readFileSync('private-key.pem'),
    cert: fs.readFileSync('public-cert.pem'),
    rejectUnauthorized: false
};

var client = tls.connect(PORT, HOST, options, function() {

    // Check if the authorization worked
    if (client.authorized) {
        console.log("Connection authorized by a Certificate Authority.");
    } else {
        console.log("Connection not authorized: " + client.authorizationError)
    }

    // Send a friendly message
    client.write("I am the client sending you a message.");

});

client.on("data", function(data) {

    console.log('Received: %s [it is %d bytes long]',
        data.toString().replace(/(\n)/gm,""),
        data.length);

    // Close the connection after receiving the message
    client.end();

});

client.on('close', function() {

    console.log("Connection closed");

});

// When an error ocoures, show it.
client.on('error', function(error) {

    console.error(error);

    // Close the connection after the error occurred.
    client.destroy();

});

¡Cómo poner en funcionamiento un servidor web HTTPS básico!

Una vez que haya instalado node.js en su sistema, puede seguir el procedimiento a continuación para obtener un servidor web básico que funcione con soporte para HTTP y HTTPS.



Paso 1: crear una autoridad de certificación

  1. cree la carpeta donde desea almacenar su clave y certificado:

    mkdir conf


  1. vaya a ese directorio:

    cd conf


  1. Tome este archivo ca.cnf para usarlo como acceso directo de configuración:

    wget https://raw.githubusercontent.com/anders94/https-authorized-clients/master/keys/ca.cnf


  1. cree una nueva autoridad de certificación utilizando esta configuración:

    openssl req -new -x509 -days 9999 -config ca.cnf -keyout ca-key.pem -out ca-cert.pem


  1. ahora que tenemos nuestra autoridad de certificación en ca-key.pem y ca-cert.pem, generemos una clave privada para el servidor:

    openssl genrsa -out key.pem 4096


  1. tome este archivo server.cnf para usarlo como acceso directo de configuración:

    wget https://raw.githubusercontent.com/anders94/https-authorized-clients/master/keys/server.cnf


  1. genere la solicitud de firma del certificado utilizando esta configuración:

    openssl req -new -config server.cnf -key key.pem -out csr.pem


  1. firma la solicitud:

    openssl x509 -req -extfile server.cnf -days 999 -passin "pass:password" -in csr.pem -CA ca-cert.pem -CAkey ca-key.pem -CAcreateserial -out cert.pem



Paso 2: Instale su certificado como certificado raíz

  1. copie su certificado en la carpeta de sus certificados raíz:

    sudo cp ca-crt.pem /usr/local/share/ca-certificates/ca-crt.pem


  1. actualizar la tienda de CA:

    sudo update-ca-certificates



Paso 3: Iniciar su servidor de nodo

Primero, desea crear un archivo server.js que contenga su código de servidor real.

La configuración mínima para un servidor HTTPS en Node.js sería algo como esto:

var https = require('https');
var fs = require('fs');

var httpsOptions = {
    key: fs.readFileSync('path/to/server-key.pem'),
    cert: fs.readFileSync('path/to/server-crt.pem')
};

var app = function (req, res) {
  res.writeHead(200);
  res.end("hello world\n");
}

https.createServer(httpsOptions, app).listen(4433);

Si también desea admitir solicitudes http, solo debe realizar esta pequeña modificación:

var http = require('http');
var https = require('https');
var fs = require('fs');

var httpsOptions = {
    key: fs.readFileSync('path/to/server-key.pem'),
    cert: fs.readFileSync('path/to/server-crt.pem')
};

var app = function (req, res) {
  res.writeHead(200);
  res.end("hello world\n");
}

http.createServer(app).listen(8888);
https.createServer(httpsOptions, app).listen(4433);
  1. Vaya al directorio donde se encuentra su server.js:

    cd /path/to


  1. ejecuta server.js:

    node server.js