C贸mo iniciar un servidor de node: ejemplos con los marcos m谩s populares

     

    Hola mundo con un servidor Node.js

    驴Sab铆as que hay varias formas de iniciar un servidor Node.js y mantenerlo en funcionamiento? En esta publicaci贸n, exploraremos varias formas de iniciar un servidor de node HTTP.

    Un servidor Node.js hace que su aplicaci贸n est茅 disponible para atender solicitudes HTTP. Proporciona la interacci贸n entre los usuarios y su aplicaci贸n.

    Crear e iniciar un servidor es f谩cil con el software integrado de Node.js http m贸dulo.

    En un archivo app.js, cree y guarde el siguiente c贸digo de creaci贸n de servidor:

    // app.js
    
    const http = require('http');
    
    // Create an instance of the http server to handle HTTP requests
    let app = http.createServer((req, res) => {
        // Set a response type of plain text for the response
        res.writeHead(200, {'Content-Type': 'text/plain'});
    
        // Send back a response and end the connection
        res.end('Hello World!n');
    });
    
    // Start the server on port 3000
    app.listen(3000, '127.0.0.1');
    console.log('Node server running on port 3000');
    

    En su terminal, ejecute el comando:

    $ node app.js
    

    y visita http://localhost:3000 en su navegador.

    Deber铆a ver que nuestro servidor se est谩 ejecutando y se le saluda con el texto “隆Hola, mundo!” en su navegador. Creamos una instancia de un servidor HTTP usando el incorporado http m贸dulo. Este es un servidor simple pero muy poderoso que puede manejar solicitudes, emitir respuestas y mucho m谩s.

    Podemos ver el poder adicional del servidor HTTP b谩sico extendi茅ndolo de la siguiente manera para transmitir un archivo de video. Primero, en el mismo directorio con su app.js archivo, cree un nuevo directorio llamado bienes. Dentro bienes, coloque un mp4 archivo de video de su elecci贸n. Luego, ajuste la nueva lista de c贸digos a continuaci贸n para reemplazar el nombre de mi video con el nombre exacto de su video.

    // app.js
    
    const http = require('http');
    const fs = require('fs');     // to help serve a local video file
    
    // Create an instance of the http server to handle HTTP requests
    let app = http.createServer((req, res) => {
        // Set a response type of mp4 video for the response
        res.writeHead(200, {'Content-Type': 'video/mp4'});
    
        // Read the video into a stream
        let vidstream = fs.createReadStream('assets/Yngwie_Malmsteen_interview.mp4');
    
        // Pipe our stream into the response
        vidstream.pipe(res);
    });
    
    // Start the server on port 3000
    app.listen(3000, '127.0.0.1');
    console.log('Node server running on port 3000');
    

    Ahora, cuando reinicie el servidor y visite la aplicaci贸n en el navegador, ver谩 que nuestro servidor ahora est谩 transmitiendo un archivo de video.

    Otras opciones para iniciar un servidor con Node.js

    Uso de otros m贸dulos de servidor

    Tambi茅n podemos iniciar un servidor Node usando el servidor m贸dulo npm. Tenga en cuenta que este m贸dulo requiere Node versi贸n 7.6.0 o posterior.

    En un proyecto nuevo, instale el m贸dulo con el comando npm install server --save. Luego crea un archivo app.js con el siguiente contenido:

    // app.js
    
    const server = require('server');
    
    const { get, post } = server.router;
    
    // Launch server
    server({ port: 3000 }, [
        get("https://Pharos.sh.com/", ctx => 'Hello world!')
    ]);
    

    Ejecute el servidor con

    $ node app.js
    

    En su navegador, deber铆a ver el mensaje “隆Hola, mundo!” texto.

    Si todo lo que desea es un servidor Node.js para servir HTML y entregar archivos est谩ticos sin tener que codificar nada para el servidor, Node tambi茅n tiene una soluci贸n para eso. En este caso, debe instalar el servidor http servidor de l铆nea de comandos sin configuraci贸n para servir sus archivos.

    Usar http-server, inst谩lalo con el comando npm install http-server -g.

    En un directorio nuevo, cree un directorio secundario llamado p煤blico en el que colocaremos archivos est谩ticos para http-server servir. Crea un archivo HTML est谩tico dentro de este p煤blico directorio llamado index.html con el siguiente contenido:

    <!-- public/index.html -->
    <html>
      <head>
        <title>Hello from http-server</title>
      </head>
      <body>
    
        <h1>Hello, World!</h1>
    
       </body>
    </html>
    

    Entonces puedes ejecutar el http-server usando el comando:

    $ http-server ./public
    

    Visitar http: // localhost: 8081 para verificar que el servidor se est茅 ejecutando y sirva nuestro archivo con el mensaje “Hello World”. Esta opci贸n de publicaci贸n de Node.js es 煤til para brindar una aplicaci贸n simple que realiza principalmente trabajos de front-end.

    Mantener los servidores funcionando para siempre

    Otro escenario surge cuando tiene un servidor Node.js en ejecuci贸n que desea que siga ejecut谩ndose autom谩ticamente. Siempre le ayudar谩 a mantener los servidores de node en funcionamiento incluso despu茅s de reiniciar el sistema operativo. Tambi茅n reinicia su aplicaci贸n despu茅s de una falla, lo que la hace 煤til para monitorear y reiniciar los servidores de Node.

    Mantenga los servidores funcionando con PM2

    PM2 es una alternativa a forever que mantiene las aplicaciones ejecut谩ndose entre reinicios del servidor. Tambi茅n tiene un equilibrador de carga integrado para mejorar el tiempo de actividad. Es un poco m谩s potente, pero tambi茅n complicado, por lo que puede que no sea adecuado para principiantes.

    C贸mo ayudan los Frameworks a iniciar un servidor de node

    Adem谩s de las opciones para ejecutar servidores que discutimos anteriormente, tambi茅n puede ejecutar un servidor utilizando el c贸digo proporcionado por el propio marco. Los marcos brindan ventajas como buenas convenciones predeterminadas y la capacidad de desarrollarse r谩pidamente sin escribir rutinas de software comunes desde cero.

    UN lista de los frameworks de Node m谩s populares basado en estrellas de GitHub incluye lo siguiente:

    En las siguientes secciones, mostraremos c贸mo iniciar un servidor Node usando algunas de estas opciones populares.

    Marco 1: iniciar un servidor de node con Express

    R谩pido es el framework web minimalista m谩s conocido para Node.js. Es adecuado para todo tipo de aplicaciones, desde peque帽as hasta grandes. Debido a que deja la mayor铆a de las opciones al desarrollador, es bueno para los desarrolladores experimentados.

    Para comenzar, cree una nueva carpeta de proyecto con un archivo dentro de ella llamado app.js.

    A continuaci贸n, instale Express con lo siguiente:

    $ npm install express
    

    Ahora actualiza app.js de la siguiente manera para iniciar un servidor Node utilizando Express.

    // app.js
    const express = require('express')
    
    // Create Express app
    const app = express()
    
    // A sample route
    app.get("https://Pharos.sh.com/", (req, res) => res.send('Hello World!'))
    
    // Start the Express server
    app.listen(3000, () => console.log('Server running on port 3000!'))
    

    Ejecute el servidor con el comando:

    $ node app.js
    

    y visita http://localhost:3000 para ver el servidor Express en acci贸n.

    Marco 2: iniciar un servidor de node con Koa.js

    Koa es un marco minimalista de los creadores de Express. Su objetivo es ser m谩s simple, incluso menos obstinado y m谩s expresivo. Como tal, se recomienda para desarrolladores que desean un enfoque m谩s purista del que ofrece Express.

    Instale Koa con:

    $ npm i koa
    

    Cree la siguiente aplicaci贸n Koa m铆nima dentro de un nuevo archivo, app.js.

    // app.js
    const Koa = require('koa');
    
    // Create Koa app
    const app = new Koa();
    
    // Serve requests, here, printing out a simple greeting
    app.use(async ctx => {
        ctx.body = 'Hello World';
    });
    
    // Start the server
    app.listen(3000);
    

    Ejecute este servidor ejecutando:

    $ node app.js
    

    Entonces visita http: // localhost: 3000 en su navegador para ver el servidor en ejecuci贸n. Ser谩 recibido por el mismo texto de respuesta que vimos al ejecutar el servidor Express.

    Framework 3: Node un servidor con Socket.io

    Socket.io es un marco de Node en tiempo real. Es particularmente ventajoso cuando est谩 desarrollando aplicaciones de mensajer铆a y chat. La plataforma funciona igualmente bien para otras aplicaciones que involucran llamadas bidireccionales basadas en eventos.

    Cree un nuevo proyecto e instale Socket.io con el comando:

    $ npm install --save socket.io
    

    Tambi茅n instale Express, que usaremos para integrar con Socket.io, usando el comando:

    $ npm install --save [email聽protected]
    

    Luego crea un archivo index.js con lo siguiente:

    // index.js
    // Require and create our server packages
    let app = require('express')();
    let http = require('http').Server(app);
    let io = require('socket.io')(http);
    
    // Send socket initialization scripts to the client
    app.get("https://Pharos.sh.com/", function(req, res){
        res.send(`
    <script src="/socket.io/socket.io.js"></script>
    <script>
        let socket = io();
        socket.on('text', (txt) => {
            let textp = document.createElement("h1");
            let t = document.createTextNode(txt);
            textp.appendChild
            document.body.appendChild(textp);
        });
    </script>`);
    });
    
    // Respond to socket connections with a Hello World text
    io.on('connection', (socket) => {
        console.log('User connected');
        io.emit('text', 'Hello, World!');
    });
    
    // Run our socket-enabled server
    http.listen(3000, function() {
        console.log('listening on *:3000');
    });
    

    Lo que hace es crear una instancia de socket.io adjunta a nuestro servidor Express. Cuando los clientes se conectan al socket, nuestro servidor socket.io env铆a un saludo “Hola, mundo” a trav茅s de la conexi贸n del socket. Para ver los resultados, ejecute el siguiente comando:

    $ node index.js
    

    Marco 4: servidor con Diet.js

    Diet.js es un micro-marco para escribir aplicaciones y API modulares de Node.js. Permite la creaci贸n de hosts virtuales y otras caracter铆sticas interesantes. Querr谩 considerarlo como una alternativa a los marcos minimalistas como Express. El n煤cleo del marco es solo 450 SLOC. Se integra con una amplia variedad de middleware que se ejecuta en Node.js.

    Para iniciar un servidor usando Diet.js, cree un nuevo proyecto e instale Diet.js con:

    $ npm install diet
    

    Luego, crea un archivo fuente index.js con el siguiente c贸digo:

    // index.js
    const server = require('diet');
    
    // Create a diet server
    let app = server();
    
    // Start the server on port 3000
    app.listen('http://localhost:3000');
    
    // Serve the home route
    app.get("https://Pharos.sh.com/", ($) => {
        // Respond with a greeting and end the request
        $.end('Hello, World!');
    });
    

    Inicie el servidor con el comando:

    $ node index.js
    

    Y luego visita http: // localhost: 3000 para ver el servidor en ejecuci贸n.

    Diet.js tiene una API simple, que combina muchos conceptos de Express en una API e implementaci贸n m谩s simples. Esto reduce la curva de aprendizaje para desarrollar una aplicaci贸n simple. Si tiene una aplicaci贸n m谩s grande en mente, los marcos m谩s estructurados como Sails.js podr铆an adaptarse mejor a sus necesidades.

    Marco 5: iniciar un servidor de node con Sails.js

    Pa帽o es la respuesta de Node.js a frameworks MVC con todas las funciones como Ruby on Rails. Su uso de las capacidades en tiempo real de Node.js lo hace adecuado para aplicaciones que usan websockets y mensajer铆a. Viene con planos que facilitan la creaci贸n r谩pida de prototipos de un backend con muy poco c贸digo.

    Creemos un directorio nuevo e instale Sails con lo siguiente:

    $ npm install sails -g
    

    Esto instala Sails globalmente en su sistema. Luego, crea una aplicaci贸n Sails con el comando $ sails new helloapp. Dentro del reci茅n creado helloapp carpeta, ejecute el servidor Sails con el comando:

    $ sails lift
    

    Visitar http: // localhost: 1337 para ver la aplicaci贸n servida localmente.

    Sails gener贸 una aplicaci贸n completa con el sails new mando. La aplicaci贸n se inicializa en el archivo. app.js, que tiene los siguientes contenidos generados:

    /**
     * app.js
     *
     * Use `app.js` to run your app without `sails lift`.
     * To start the server, run: `node app.js`.
     *
     * This is handy in situations where the sails CLI is not relevant or useful.
     *
     * For example:
     *   => `node app.js`
     *   => `forever start app.js`
     *   => `node debug app.js`
     *   => `modulus deploy`
     *   => `heroku scale`
     *
     *
     * The same command-line arguments are supported, e.g.:
     * `node app.js --silent --port=80 --prod`
     */
    
    
    // Ensure we're in the project directory, so cwd-relative paths work as expected
    // no matter where we actually lift from.
    // > Note: This is not required in order to lift, but it is a convenient default.
    process.chdir(__dirname);
    
    // Attempt to import `sails`.
    var sails;
    try {
      sails = require('sails');
    } catch (e) {
      console.error('To run an app using `node app.js`, you usually need to have a version of `sails` installed in the same directory as your app.');
      console.error('To do that, run `npm install sails`');
      console.error('');
      console.error('Alternatively, if you have sails installed globally (i.e. you did `npm install -g sails`), you can use `sails lift`.');
      console.error('When you run `sails lift`, your app will still use a local `./node_modules/sails` dependency if it exists,');
      console.error('but if it doesn't, the app will run with the global sails instead!');
      return;
    }
    
    // --鈥
    // Try to get `rc` dependency (for loading `.sailsrc` files).
    var rc;
    try {
      rc = require('rc');
    } catch (e0) {
      try {
        rc = require('sails/node_modules/rc');
      } catch (e1) {
        console.error('Could not find dependency: `rc`.');
        console.error('Your `.sailsrc` file(s) will be ignored.');
        console.error('To resolve this, run:');
        console.error('npm install rc --save');
        rc = function () { return {}; };
      }
    }
    
    
    // Start server
    sails.lift(rc('sails'));
    

    El c贸digo de inicializaci贸n importa Sails, luego carga la aplicaci贸n e inicia el servidor de Sails.

    Sails tiene la ventaja de ser especialmente r谩pido y escalable. En esto punto de referencia contra Rails, Sails rindi贸 hasta 3x-4x m谩s r谩pido. La parte cr铆tica para el rendimiento de Sails para aplicaciones a escala tiende a ser la base de datos, donde la paginaci贸n y los 铆ndices se pueden utilizar para acelerar las cosas.

    Framework 6: uso de MEAN.io para un servidor de node

    MEAN.io es uno de los frameworks JavaScript de pila completa m谩s conocidos. Es una variante del llamado “MEAN Stack”, siendo MEAN.js otra variante. MEAN usa MongoDB, Express, Angular y Node.js.

    Para iniciar una aplicaci贸n MEAN.io, clone la implementaci贸n de referencia de la aplicaci贸n del modelo MEAN.io usando el comando:

    $ git clone https://github.com/linnovate/mean.git  
    

    Curso sugerido:

    Domina la pila MEAN: aprende con el ejemplo

    Alternativamente, puede clonar en otro directorio de su elecci贸n. Entonces c谩mbiate al nuevo media directorio o su directorio elegido, e instale dependencias con:

    $ npm install
    

    Ejecute la aplicaci贸n con npm start y visita http: // localhost: 4040 para verlo en acci贸n.

    El c贸digo para configurar el servidor se encuentra en el archivo server\config\express.js que contiene lo siguiente:

    import express from 'express';
    import logger from 'morgan';
    import bodyParser from 'body-parser';
    import cookieParser from 'cookie-parser';
    import compress from 'compression';
    import methodOverride from 'method-override';
    import cors from 'cors';
    import httpStatus from 'http-status';
    import expressWinston from 'express-winston';
    import expressValidation from 'express-validation';
    import helmet from 'helmet';
    import winstonInstance from './winston';
    import routes from '../routes/index.route';
    import config from './config';
    import APIError from '../helpers/APIError';
    import path from 'path';
    import appRoot from 'app-root-path';
    import innograph from 'innograph'
    import postCtrl from '../controllers/post.controller';
    
    
    const app = express();
    
    if (config.env === 'development') {
      app.use(logger('dev'));
    }
    
    // parse body params and attache them to req.body
    app.use(bodyParser.json());
    app.use(bodyParser.urlencoded({ extended: true }));
    
    app.use(cookieParser());
    app.use(compress());
    app.use(methodOverride());
    
    // secure apps by setting various HTTP headers
    app.use(helmet());
    
    // enable CORS - Cross Origin Resource Sharing
    app.use(cors());
    
    // enable detailed API logging in dev env
    if (config.env === 'development') {
      expressWinston.requestWhitelist.push('body');
      expressWinston.responseWhitelist.push('body');
      // app.use(expressWinston.logger({
      //   winstonInstance,
      //   meta: true, // optional: log meta data about request (defaults to true)
      //   msg: 'HTTP {{req.method}} {{req.url}} {{res.statusCode}} {{res.responseTime}}ms',
      //   colorStatus: true // Color the status code (default green, 3XX cyan, 4XX yellow, 5XX red).
      // }));
    }
    app.use(express.static(path.join(appRoot.path, 'dist')));
    
    app.use('/api', routes);
    
    innograph.init('/api/graphql', app, {post: postCtrl});
    
    app.get('*', (req, res) => {
      res.sendFile(path.join(appRoot.path, 'dist/index.html'));
    });
    
    // if error is not an instanceOf APIError, convert it.
    app.use((err, req, res, next) => {
      if (err instanceof expressValidation.ValidationError) {
        // validation error contains errors which is an array of error each containing message[]
        const unifiedErrorMessage = err.errors.map(error => error.messages.join('. ')).join(' and ');
        const error = new APIError(unifiedErrorMessage, err.status, true);
        return next(error);
      } else if (!(err instanceof APIError)) {
        const apiError = new APIError(err.message, err.status, err.isPublic);
        return next(apiError);
      }
      return next(err);
    });
    
    // catch 404 and forward to error handler
    app.use((req, res, next) => {
      const err = new APIError('API not found', httpStatus.NOT_FOUND);
      return next(err);
    });
    
    // log error in winston transports except when executing test suite
    if (config.env !== 'test') {
      app.use(expressWinston.errorLogger({
        winstonInstance
      }));
    }
    
    // error handler, send stacktrace only during development
    app.use((err, req, res, next) => // eslint-disable-line no-unused-vars
      res.status(err.status).json({
        message: err.isPublic ? err.message : httpStatus[err.status],
        stack: config.env === 'development' ? err.stack : {}
      })
    );
    
    export default app;
    

    En el coraz贸n de la pila MEAN se encuentra un servidor Express que utiliza middleware Node como bodyParser para procesar cargas 煤tiles de solicitudes, Winston para el registro de solicitudes y casco para proteger las solicitudes HTTP.

    Las ventajas de MEAN incluyen estar basado en tecnolog铆as robustas que han demostrado su capacidad para impulsar aplicaciones de alto tr谩fico. La aplicaci贸n de referencia integra MongoDB, Angular y React. Tambi茅n usa Typecript, junto con algunos componentes de ejemplo para que pueda usarlos como punto de partida. Si no necesita una biblioteca determinada, puede eliminarla de las dependencias en el archivo package.json.

    Framework 7: Inicie un servidor de node con LoopBack, el marco de API

    Loopback es un marco de Node que le permite crear r谩pidamente aplicaciones enfocadas en API. Tiene partes automatizadas del proceso de creaci贸n de API, lo que permite generar API RESTful con poca o ninguna codificaci贸n. Loopback combina un conjunto de m贸dulos que puede integrar a medida que crecen los requisitos de su aplicaci贸n. Esto le permite crear aplicaciones de forma modular utilizando m贸dulos Loopback est谩ndar.

    Puede instalar Loopback globalmente con el comando:

    $ npm install -g loopback-cli
    

    Para crear un proyecto, ejecute lb, que lo guiar谩 a trav茅s de la creaci贸n de una aplicaci贸n Loopback b谩sica.

    Elige el hello-world aplicaci贸n, para incluir un mensaje simple y un controlador. Las otras opciones son crear una API o un proyecto que contenga un ejemplo de trabajo b谩sico con una base de datos de memoria.

    Yendo con el hello-world tipo de aplicaci贸n genera una aplicaci贸n b谩sica. Dentro del archivo “server / server.js” encontrar谩 el siguiente c贸digo generado:

    'use strict';
    
    var loopback = require('loopback');
    var boot = require('loopback-boot');
    
    var app = module.exports = loopback();
    
    app.start = function() {
      // start the web server
      return app.listen(function() {
        app.emit('started');
        var baseUrl = app.get('url').replace(//$/, '');
        console.log('Web server listening at: %s', baseUrl);
        if (app.get('loopback-component-explorer')) {
          var explorerPath = app.get('loopback-component-explorer').mountPath;
          console.log('Browse your REST API at %s%s', baseUrl, explorerPath);
        }
      });
    };
    
    // Bootstrap the application, configure models, datasources and middleware.
    // Sub-apps like REST API are mounted via boot scripts.
    boot(app, __dirname, function(err) {
      if (err) throw err;
    
      // start the server if `$ node server.js`
      if (require.main === module)
        app.start();
    });
    

    Este c贸digo inicializa el servidor Loopback, que puede comenzar con el comando node. Visitar http: // localhost: 3000 para verificar que el servidor est茅 funcionando. Tambi茅n puedes mirar http: // localhost: 3000 / explorer para ver la interfaz de API Loopback.

    Nuestra API est谩 vac铆a para empezar. La creaci贸n de un nuevo modelo y puntos finales REST es f谩cil con la CLI de Loopback. Ejecuta el comando lb model y escriba un nombre de modelo como “pel铆cula”, pero sin las comillas.

    Luego, ajuste los valores de persistencia y otras configuraciones de acuerdo con la solicitud o acepte los valores predeterminados.

    Cree algunas propiedades del modelo y defina los tipos de datos. Por ejemplo, una pel铆cula puede tener un t铆tulo que ser谩 una cadena. Ingrese tantas propiedades como desee y luego finalice.

    Ahora tenemos una API para pel铆culas, a la que puede acceder con una solicitud GET para http: // localhost: 3000 / api / movies. Esto devolver谩 una matriz JSON vac铆a. Puede explorar la API con el explorador de API en http: // localhost: 3000 / explorer.

    Cree algunas pel铆culas y luego interact煤e con la API en el navegador para ver el servidor Loopback en acci贸n. Adem谩s, mire el c贸digo fuente generado para la API. Loopback hace que desarrollar API sea realmente f谩cil.

    Elegir el mejor servidor de node para su aplicaci贸n

    Elegir la mejor manera de servir su aplicaci贸n Node.js implica una serie de compensaciones. Desarrollando su propio marco basado en el http El m贸dulo es pr谩ctico, dada la amplia gama de middleware que puede integrar con una aplicaci贸n Node. Esta ruta le brinda la posibilidad de tomar todas las decisiones usted mismo sobre c贸mo funcionar谩 su aplicaci贸n.

    Ir con un marco como Socket.io o Sails le permite construir sobre una base probada que otros han utilizado con 茅xito. La amplia gama de marcos tambi茅n le permite reutilizar el c贸digo de estas bibliotecas para comenzar un poco m谩s r谩pido.

    La compensaci贸n con los marcos, en particular con los obstinados como Sails, es que algunas de las decisiones t茅cnicas ya est谩n hechas para usted. Si desea algo fuera de la norma para lo que est谩 optimizado el marco, podr铆a tener dificultades. Koa y Express ofrecen un t茅rmino medio seguro donde se han hecho muy pocas elecciones o suposiciones sobre su aplicaci贸n.

    Aqu铆 hay una gu铆a r谩pida para seleccionar el marco que le permite construir de manera efectiva seg煤n las necesidades de su aplicaci贸n:

    Descripci贸n de la aplicaci贸n Marco sugerido

    Sin suposiciones, enfoque minimalista, modularDiet.js, Koa, Express
    Base de c贸digo grande, se ajusta a ciertas convenciones, escalableMEAN.io
    Chat, mensajer铆aSocket.io
    Planos listos para usar y convenciones muy s贸lidas, centrados en API, algo de “magia”Sails.js, Loopback

     

    Deja una respuesta

    Tu direcci贸n de correo electr贸nico no ser谩 publicada. Los campos obligatorios est谩n marcados con *