¿Cómo implementar una aplicación Node.js?

En este artículo, explicaremos cómo implementar una aplicación Node JS. Hablaremos sobre las ventajas y desventajas de Node y las opciones de implementación, incluidas IaaS, PaaS y BaaS. Por último, implementaremos una aplicación Node en Back4app.

¿Qué es Node.js?

Node.js es un tiempo de ejecución de JavaScript multiplataforma y de código abierto creado en el motor de JavaScript V8 de Chrome. Node tiene como objetivo permitir que los desarrolladores de JavaScript utilicen la pila completa al permitirles codificar operaciones del lado del servidor. Sus casos de uso incluyen secuencias de comandos del lado del servidor, aplicaciones en tiempo real, aplicaciones web de streaming, aplicaciones de una sola página (SPA, del inglés “Single-Page Applications”), herramientas de colaboración y juegos web.

Node tiene una arquitectura basada en eventos capaz de E/S asincrónica. Es increíblemente rápido, debido a su capacidad para compilar JavaScript en código de máquina nativo. Puede manejar una enorme cantidad de conexiones activas y permite a los desarrolladores crear aplicaciones escalables de alto rendimiento fácilmente.

La tecnología fue presentada por primera vez en 2009 por su creador Ryan Dahl en la JSConf europea que se realiza cada año. Inmediatamente se convirtió en una de las piezas de software más interesantes en el ecosistema de JavaScript.

La popularidad de Node alcanzó su punto máximo en 2017 y sigue siendo alta. Es una de las herramientas de desarrollo más populares utilizadas por muchas empresas multimillonarias como IBM, LinkedIn, Microsoft, Netflix, etc. Su simplicidad y capacidad de escalar lo hacen ideal para empresas de todos los tamaños, incluidas las nuevas empresas.

En las próximas dos secciones, profundizaremos en las ventajas y desventajas de Node.

Ventajas de Node.js

Alto rendimiento

Como se mencionó en la introducción, Node funciona con el motor JavaScript de alto rendimiento de Google. V8 puede compilar y ejecutar JavaScript a una velocidad ultrarrápida, principalmente porque compila JavaScript en código de máquina nativo.

Node también utiliza un bucle de eventos que le permite realizar operaciones de E/S sin bloqueo, a pesar de que JavaScript es un lenguaje de programación de un solo subproceso. Esto lo convierte en una de las opciones más rápidas del mercado.

Escalabilidad

Uno de los beneficios clave de Node.js es su capacidad de escalar. Las aplicaciones de Node pueden escalar tanto horizontal como verticalmente. El escalado horizontal se logra agregando nodos adicionales a un sistema existente, mientras que el escalado vertical significa agregar recursos adicionales a un nodo específico. Las excelentes opciones de escalado de la plataforma la hacen apropiada tanto para empresas emergentes como para grandes empresas con decenas de millones de usuarios diarios como LinkedIn, Netflix y PayPal.

Node también es adecuado para la arquitectura de microservicios, lo que permite a los desarrolladores crear pequeños componentes que encajan en una canalización de entrega continua y que pueden escalar fácilmente según la demanda.

Fácil de aprender

La base de Node en JavaScript hace que sea extremadamente fácil de aprender para los desarrolladores que ya conocen los conceptos básicos de JavaScript. No es demasiado difícil de aprender y se puede dominar en tan solo unas pocas semanas. La simplicidad de Node lo hace ideal para todo tipo de proyectos.

Tiempo de comercialización más rápido

El tiempo de comercialización es uno de los puntos de referencia esenciales de muchos equipos de desarrollo. Todo el mundo quiere sacar su producto al mercado lo antes posible y Node le permite hacer precisamente eso.

La simplicidad de Node y la gran cantidad de paquetes npm reducen drásticamente el tiempo de comercialización. Hay un montón de proyectos de código abierto en GitHub y otras plataformas que se pueden usar como plantillas para poner en marcha su proyecto lo más rápido posible.

Herramienta probada en batalla

Node es una herramienta madura y probada que existe desde 2009. Su estabilidad ha sido probada por grandes compañías como eBay, Netflix y LinkedIn, que tienen millones de usuarios diarios.

Debido a sus increíbles ventajas, Node se incluye en una serie de pilas tecnológicas (generalmente en combinación con Express y una base de datos NoSQL). Algunas de las pilas de tecnología con Node incluyen:

• MERN
• MEAN
• DERN

Gran comunidad

Node.js tiene una comunidad robusta y activa de desarrolladores y entusiastas que siguen contribuyendo a Node para mejorarlo cada vez más. En caso de que alguna vez se quede atascado en un problema o tenga una pregunta, hay varios lugares diferentes donde puede buscar ayuda. Debido a la popularidad de Node, no es difícil encontrar soluciones y códigos ya creados en GitHub.

Otra gran cosa acerca de Node.js es su administrador de paquetes llamado npm (Node Package Manager). Npm permite a los desarrolladores impulsar y utilizar paquetes de JavaScript listos para usar en lugar de reinventar la rueda. Los paquetes pueden reducir significativamente el costo de desarrollo y la complejidad de las aplicaciones. En el momento de escribir este artículo, hay más de 1,3 millones de paquetes alojados en npm.

Limitaciones de Node.js

Disminución del rendimiento para tareas complejas

El mayor inconveniente de Node.js es su incapacidad para realizar tareas que requieren una gran capacidad de cómputo. En estos días, muchos programas y algoritmos requieren paralelización para obtener resultados óptimos. Como ya sabe, Node.js se basa en JavaScript, que fue diseñado para ser un lenguaje de interfaz de un solo subproceso y no admite múltiples subprocesos.

Con la actualización 10.5, el equipo de Node.js implementó la compatibilidad con subprocesos múltiples en forma de subprocesos de trabajo. Este módulo permite a los desarrolladores aprovechar subprocesos adicionales de un grupo de subprocesos. Incluso con los subprocesos de trabajo, Node todavía no es apropiado para procesos que demandan una gran capacidad computacional. Si los requisitos de su proyecto incluyen cálculos complejos, computación pesada o paralelización, es posible que le vaya mejor con otro lenguaje de programación.

Modelo de programación asincrónica

Node.js utiliza el modelo de programación asincrónica. Debido a esto, depende en gran medida del uso de devoluciones de llamada. Las devoluciones de llamada son funciones que se ejecutan en segundo plano y (en algún momento) devuelven un resultado. Al usar devoluciones de llamada, su código puede volverse más complicado y más difícil de depurar. Además, si anida las devoluciones de llamada en varios niveles de profundidad, podría terminar con el llamado “infierno de devolución de llamadas”.

El infierno de devolución de llamadas y otros problemas de la programación asincrónica se pueden evitar fácilmente siguiendo los principios del código limpio.

API inestable

Otro gran problema con Node.js es la inestabilidad de su interfaz de programación de aplicaciones (API). La API de Node cambia con frecuencia con cambios incompatibles con versiones anteriores que pueden romper fragmentos de código. Como consecuencia, los desarrolladores de Node deben estar atentos a los cambios y asegurarse de que sus bases de código sean compatibles con las últimas versiones de la API de Node.js.

Falta de un fuerte sistema de soporte de bibliotecas

JavaScript no viene con un buen sistema de bibliotecas en comparación con otros lenguajes de programación. Esto obliga a muchos desarrolladores a asumir el soporte de varias tareas comunes como el procesamiento de imágenes, el análisis de XML, el mapeo relacional de objetos (ORM, del inglés “Object-Relational Mapping”), el manejo de bases de datos y más.

Un registro de módulo demasiado grande e inmaduro

Node tiene una gran comunidad de desarrolladores que producen miles de módulos de código abierto que se publican en npm. El problema con esto es que npm no implementa ninguna verificación que asegure que el código del módulo funcione y esté bien escrito.

Muchos módulos dejan de ser compatibles aleatoriamente o se rompen con las versiones más nuevas de Node y luego los desarrolladores se ven obligados a buscar una alternativa. En el pasado, algunos de los módulos npm también fueron pirateados e inyectados con virus y criptomineros. Debido a esto, es difícil encontrar módulos que puedan usarse en un entorno empresarial.

No me malinterprete, creo que npm es excelente, pero aún debe tener cuidado al instalar módulos aleatorios.

Opciones de implementación de Node.js

Hay varias formas de implementar una aplicación Node.js. En términos generales, podemos dividirlos en los siguientes cuatro grupos:

1. Alojamiento convencional
2. Infraestructura como servicio (IaaS)
3. Plataforma como servicio (PaaS)
4. Backend como servicio (BaaS)

Podemos mostrarlos en un gráfico piramidal en función de su nivel de abstracción:

Las opciones de implementación se encargan de las siguientes capas de abstracción:

Echemos un vistazo a cada uno de los grupos. Omitiremos el alojamiento convencional, ya que estoy seguro de que sabe cómo funciona.

Servicios IaaS como AWS

La infraestructura como servicio (IaaS) es un modelo de servicio de computación en la nube que proporciona recursos informáticos como servidores, redes, sistemas operativos y almacenamiento en un entorno virtualizado. Estos servidores en la nube generalmente se proporcionan a la organización a través de API de alto nivel o paneles avanzados que brindan a los clientes un control total sobre toda la infraestructura.

La IaaS es altamente escalable. Permite a los clientes escalar fácilmente tanto vertical como horizontalmente según la demanda. Los proveedores de IaaS suelen seguir un modelo de pago por uso, lo que significa que solo paga por los recursos que consume.

IaaS salió a la luz a principios de la década de 2010 y desde entonces se convirtió en el modelo de abstracción estándar para muchos tipos de cargas de trabajo. Incluso con el surgimiento de nuevas tecnologías como microservicios y sin servidor, IaaS sigue siendo la opción más popular.

A diferencia de PaaS y BaaS, IaaS proporciona el control de recursos de nivel más bajo en la nube. Esto lo convierte en el modelo de computación en la nube más flexible. La desventaja es que el cliente es completamente responsable de administrar aspectos como aplicaciones, sistemas operativos, middleware y datos, lo que generalmente lleva mucho tiempo.

Algunos ejemplos típicos de IaaS son:

• Amazon Web Services (AWS)
• Google Compute Engine (GCE)
• Microsoft Azure
• DigitalOcean
• Linode
• Rackspace

Servicios PaaS como Heroku

La Plataforma como Servicio (PaaS) es un modelo de servicio de computación en la nube que brinda a los usuarios un entorno en la nube en el que pueden desarrollar, administrar y entregar aplicaciones. Además de proporcionar recursos informáticos, PaaS viene con muchas herramientas prediseñadas para desarrollar, personalizar y probar aplicaciones. ¡La mayoría de los proveedores de PaaS le permiten poner en marcha su aplicación con unos pocos clics!

PaaS permite a los usuarios concentrarse en su aplicación en lugar de administrar la infraestructura subyacente. Los proveedores de PaaS hacen mucho trabajo pesado por usted, como administrar sus servidores, sistemas operativos, software de servidor, copias de seguridad y más.

Algunas de las ventajas de PaaS son:

• Mayor velocidad de comercialización
• Seguridad incrementada
• Rentabilidad
• Escalabilidad
• Alta disponibilidad
• Requiere menos código 

Las desventajas de PaaS son que lo más probable es que dependa de las capacidades del proveedor, existe el riesgo de dependencia y falta de flexibilidad y control. Sin embargo, PaaS aún permite a los usuarios crear aplicaciones más rápido y es menos complicado de administrar.

Los servicios PaaS incluyen:

• Heroku
• AWS Elastic Beanstalk
• DigitalOcean App Platform
• Microsoft Azure App Service
• The Fly Platform (Fly.io)
• Render

Servicios BaaS como Back4app

El Backend como Servicio (BaaS) es una plataforma que automatiza el desarrollo del backend y se encarga de la infraestructura de la nube. Además de eso, proporciona funciones como administración de usuarios, notificaciones por correo electrónico, notificaciones automáticas, funciones de código en la nube, integraciones de redes sociales, almacenamiento de archivos y pagos.

Esto permite a los desarrolladores centrarse en el negocio principal y construir la interfaz sin preocuparse por la infraestructura y el backend subyacente. La interfaz generalmente se desarrolla a través de API y SDK especializados ofrecidos por el proveedor de BaaS. Esto hace que las aplicaciones sean menos complejas y más fáciles de mantener.

BaaS brinda todos los beneficios de IaaS y PaaS a la vez que incluye la abstracción del backend. Los equipos que aprovechan BaaS reducen en gran medida el tiempo de comercialización, reducen los costos de ingeniería y requieren menos ingenieros.

BaaS se puede usar para muchos tipos de proyectos, incluida la creación de un MVP (Producto Mínimo Viable, o “Minimum Viable Product”), aplicaciones independientes o aplicaciones que requieren una pequeña cantidad de integraciones y aplicaciones empresariales que no son de misión crítica.

Las desventajas de BaaS son que es menos flexible que IaaS y PaaS, brinda un nivel más bajo de control y personalización, y existe la posibilidad de dependencia para plataformas que no son de código abierto.

Algunos ejemplos de BaaS:

• Back4app
• AWS Amplify
• Firebase
• Parse
• Cloudkit
• Backendless

Proceso de implementación de Node.js

En esta parte del artículo, echaremos un vistazo a Back4app y aprenderemos cómo construir e implementar la aplicación Node JS.

¿Qué es Back4app?

Back4app es una de las mejores soluciones Backend como Servicio (BaaS) de código abierto del mercado. Ofrece una amplia gama de funciones y beneficios a sus usuarios, lo que permite a los desarrolladores crear rápidamente aplicaciones web y móviles. Al usar Back4app, podrá concentrarse en el negocio principal en lugar de preocuparse por el backend o la infraestructura subyacente.

La solución viene con un panel rico en funciones y fácil de usar y una interfaz de línea de comandos (CLI). ¡También proporcionan SDK para todas sus herramientas favoritas como Flutter, React Native, Node.js, Angular, Android, iOS y más!

Las características clave de Back4app incluyen:

• Base de datos tipo hoja de cálculo
• API REST y GraphQL
• Consultas en vivo
• Autenticación (incluida la autenticación social)
• Alojamiento escalable
• Notificaciones push y por correo electrónico

Para obtener más información sobre sus características, consulte las características de Back4app.

Back4app sigue un modelo de precios simple y directo que puede adaptarse a una aplicación de cualquier tamaño. Ofrece un generoso plan gratuito (no se requiere tarjeta de crédito) que es excelente para crear prototipos y probar la plataforma. Incluye:

• 25k solicitudes
• Almacenamiento de datos de 250 MB
• Transferencia de 1GB
• 1 GB de almacenamiento de archivos

Para obtener más información sobre los precios de Back4app, consulte la página Precios.

Introducción al proyecto

Vamos a codificar e implementar una aplicación web TODO simple. La aplicación web admitirá operaciones CRUD (del inglés “Create, Retrieve, Update, and Delete”) básicas: crear, recuperar, actualizar y eliminar. Lo codificaremos en Node.js usando el marco web Express, Parse se encargará del almacenamiento de datos y usaremos Twig como motor de plantillas.

¡Haga clic aquí para ver la aplicación implementada en acción!

Requisitos previos:

• Comprensión básica de Node.js
• Comprensión básica de Express
• Experiencia con un motor de plantillas.
• Comprensión básica de bases de datos y ParseJS.

CLI de Back4app

Los siguientes pasos requerirán que tenga una cuenta Back4app. Si ya la tiene, inicie sesión; de lo contrario, regístrese para obtener la cuenta gratuita.

Back4app CLI es una interfaz de línea de comandos que le permite interactuar con la plataforma Back4app.

Para instalarla en Mac/Linux ejecute:

$ curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash

El comando descargará el último binario CLI y lo almacenará en /usr/local/bin/b4a .

Para otros sistemas operativos, por favor, consulte los documentos oficiales.

Para usar la CLI, deberá autenticarse con su cuenta. Para hacerlo, primero debe generar una clave de cuenta. Navegue a su panel de Back4app y haga clic en su nombre de usuario (parte superior derecha de la pantalla) y luego en “Claves de cuenta”:

Para agregar una nueva clave de cuenta, ingrese un nombre de clave personalizado y luego presione “+”. Anote la clave ya que la necesitaremos en el siguiente paso:

Una vez que haya creado correctamente la clave, vuelva a la terminal y ejecute:

$ b4a configure accountkey

Input your account key or press ENTER to generate a new one.       
NOTE: on pressing ENTER we'll try to open the url:                 
        "http://dashboard.back4app.com/classic#/wizard/account-key"
in default browser.
Account Key: <YOUR_GENERATED_ACCOUNT_KEY>
Successfully stored account key for: "<YOUR_EMAIL>".

Para asegurarse de que la autenticación funcionó, intente listar sus aplicaciones:

$ b4a list

These are the apps you currently have access to:

Si su cuenta es nueva como la mía, no aparecerá ninguna aplicación en la lista.

Crear aplicación

Avanzando, creemos una aplicación de Back4app.

Ejecute:

$ b4a nueva

¿Le gustaría crear una nueva aplicación o agregar código de la nube a una aplicación existente?
Escriba “(n)nuevo” o “(e)existente”: n
Elija un nombre para su aplicación Parse.
Tenga en cuenta que este nombre aparecerá en el sitio web de Back4App,
pero no tiene que ser el mismo que el nombre público de su aplicación móvil.
Nombre: nodejs-back4app
¡Impresionante! Ahora es el momento de configurar un código de nube para la aplicación: “nodejs-back4app”,
A continuación, crearemos un directorio para guardar su código de nube.
Por favor, ingrese el nombre a usar para este directorio,
o presione ENTER para usar “nodejs-back4app” como el nombre del directorio.

Nombre del directorio:
Puede configurar un proyecto en blanco o crear un proyecto de código en la nube de muestra
Escriba “(b)lank” si desea configurar un proyecto en blanco; de lo contrario, presione ENTER:
Correo electrónico configurado correctamente para el proyecto actual a: “<YOUR_EMAIL>”
Su código de nube se ha creado en /dev/nodejs-back4app.

1. Cree una aplicación nueva o existente: nueva
2. Elija un nombre de aplicación: elija un nombre personalizado
3. Nombre del directorio: presione ENTER
4. Proyecto de código en la nube en blanco o de muestra: presione ENTER

El comando va a crear un directorio con la siguiente estructura:

nodejs-back4app/
├── cloud/
│   └── main.js
├── public/
│   └── index.html
├── .parse.local
└── .parse.project

1. nube es un directorio para todo el código y las funciones de la nube
2. público es un directorio para archivos públicos como imágenes, hojas de estilo y más
3. .parse.local y .parse.proyecto se utilizan para almacenar la configuración de Parse

Elimine el archivo principal.js e índice.html ya que no los vamos a necesitar.

Alojamiento web

Dado que estamos creando una aplicación Node.js, debemos habilitar el alojamiento web para que Back4app aloje nuestra aplicación y la haga accesible públicamente en Internet.

Para habilitar la función de alojamiento web, vaya a su panel de Back4app, seleccione su aplicación, haga clic en “Configuración de la aplicación” en el lado izquierdo de la pantalla y luego en “Configuración del servidor”. Busque “Alojamiento web y dominios personalizados” y haga clic en “Configuración” nuevamente.

Haga clic en “Activar alojamiento Back4app” y elija un nombre de subdominio. Yo usaré nodejsback4app:

Por último, haga clic en “Guardar”.

Su aplicación será entonces accesible en:

https://<your_subdomain>.b4a.app/

¡Siéntase libre de también vincular un dominio personalizado a su aplicación web!

Express con funciones de código en la nube

A continuación, comencemos a trabajar en el código real.

Cambie su directorio a la nube y cree un archivo paquete.json dentro de él:

// cloud/package.json

{
  "dependencies": {
    "body-parser": "*"
  }
}

Back4app usa este archivo para descargar módulos a través de npm. Agregamos body-parser ya que lo necesitaremos más adelante para analizar las solicitudes.

A continuación, cree otro archivo en la carpeta de nubes llamado app.js :

// cloud/app.js

const bodyParser = require("body-parser");

app.use(bodyParser.json());
app.use(bodyParser.urlencoded({extended: true}));

app.get("/", async (req, res) => {
    res.json({
        "message": "Hello world!",
    });
});

Este archivo se utiliza para inicializar y configurar Express. También definimos un punto final que se utilizará como control de cordura en el siguiente paso. Como puede ver, no necesitamos definir la aplicación ni ninguna dependencia, ya que Back4app lo hace por nosotros automáticamente.

A continuación, implemente la aplicación:

$ b4a deploy

Uploading source files
Uploading recent changes to scripts...
Finished uploading files
New release is named v1 (using Parse JavaScript SDK v2.2.25)

El comando cargará sus archivos fuente en Back4app, configurará todo y hará que su aplicación esté disponible en el subdominio que eligió en la sección anterior.

Para asegurarse de que funciona, abra su navegador web favorito y navegue hasta su aplicación:

https://<your_subdomain>.b4a.app/

# Example
https://nodejsback4app.b4a.app/

Debería obtener la siguiente respuesta:

{
   "message": "Hello world!"
}

¡Buen trabajo!

En las siguientes secciones, comenzaremos a trabajar en la aplicación TODO real.

Base de datos con ParseJS

Definamos los modelos de base de datos para la aplicación TODO.

Navegue hasta el panel de Back4app y seleccione “Base de datos” en el lado izquierdo de la pantalla. Después de eso, haga clic en “Crear una nueva clase”, asígnele el nombre Tarea y asegúrese de marcar “Lectura y escritura públicas habilitadas”:

A continuación, agregue las siguientes columnas:

+-----------+-------------+---------------+----------+
| Data type | Name        | Default value | Required |
+-----------+-------------+---------------+----------+
| String    | name        | <leave blank> | yes      |
+-----------+-------------+---------------+----------+
| String    | description | <leave blank> | no       |
+-----------+-------------+---------------+----------+
| Boolean   | isDone      | false         | yes      |
+-----------+-------------+---------------+----------+

Lógica de la aplicación

La aplicación tendrá los siguientes puntos finales:

1. / mostrar la lista de tareas
2. /create crea una tarea
3. /<ID> muestra los detalles de la tarea
4. /<ID>/delete elimina una tarea
5. /<ID>/toggle alterna el estado de la tarea — hecho/nohecho

Vamos a crearlos.

Para que nuestro código en la nube sea más fácil de mantener, lo dividiremos en dos archivos.

1. app.js: inicializa y configura el servidor Express
2. route.js: define puntos finales y su lógica

Un enfoque aún mejor para crear aplicaciones web modernas es usar un patrón arquitectónico Modelo-Vista-Controlador (MVC). Un buen comienzo con Express es usar express-generator.

Reemplace el contenido de app.js con lo siguiente:

// cloud/app.js

const express = require("express");
const bodyParser = require("body-parser");
const path = require("path");

app.set("views", __dirname + "/views");
app.set("view engine", "twig");

app.use(bodyParser.json());
app.use(bodyParser.urlencoded({extended: true}));
app.use(express.static(path.join(__dirname, "public")));

require("./routes");

1. Configuramos Twig como el motor de visualización predeterminado.
2. Las rutas ya no se definen en este archivo, sino en rutas.js.

A continuación, cree rutas.js y coloque el siguiente código:

// cloud/routes.js

const {TwingEnvironment, TwingLoaderFilesystem} = require("twing");
let loader = new TwingLoaderFilesystem(__dirname + "/views");
let twing = new TwingEnvironment(loader);

app.get("/", async (req, res) => {
    try {
        let tasks = [];
        const query = new Parse.Query("Task");
        await query.each(task => tasks.push(task.toJSON()), {});

        twing.render("index.twig", {
            "tasks": tasks,
        }).then(out => res.send(out));
    } catch (error) {
        twing.render("error.twig", {
            "error": error,
        }).then(out => res.send(out));
    }
})

app.get("/create", async (req, res) => {
    twing.render("create.twig").then(out => res.send(out));
});

app.post("/create", async (req, res) => {
    const name = req.body.name;
    const description = req.body.description;
    const isDone = !!req.body.isDone;

    try {
        const task = new Parse.Object("Task");
        task.set("name", name);
        task.set("description", description);
        task.set("isDone", isDone);
        await task.save();

        res.redirect("/" + task.id);
    } catch (error) {
        twing.render("error.twig", {
            "error": error,
        }).then(out => res.send(out));
    }
});

// Por favor, tome el resto del archivo *routes.js* de GitHub:
// https://github.com/duplxey/nodejs-back4app/blob/master/cloud/routes.js

Definimos todas las rutas mencionadas anteriormente y usamos Parse para manipular y almacenar los datos. Como puede ver, todas las rutas son asincrónicas, ya que tenemos que esperar a que Parse responda. Además, la mayor parte del código está envuelto en bloques try-catch en caso de que algo salga mal.

Para obtener información adicional sobre ParseJS, consulte la Guía de JavaScript.

A continuación, acompañemos los puntos finales con plantillas de vista.

Cree una carpeta de vistas dentro de la carpeta de nubes, descargue los archivos de plantilla del repositorio de GitHub y colóquelos en el directorio de vistas.

Su estructura de directorio final debería verse así:

nodejs-back4app/
├── cloud/
│   ├── views/
│   │   ├── base.twig
│   │   ├── create.twig
│   │   ├── error.twig
│   │   ├── index.twig
│   │   └── task.twig
│   ├── app.js
│   ├── routes.js
│   └── package.json
├── public
├── parse.local
└── parse.project

Por último, agregue twing a paquete.json para habilitar la compatibilidad con Twig:

{
  "dependencies": {
    "body-parser": "*",
    "twing": "*"
  }
}

Implemente la aplicación:

$ b4a deploy

Uploading source files
Uploading recent changes to scripts...
Finished uploading files
New release is named v2 (using Parse JavaScript SDK v2.2.25)

Y listo. Espere unos minutos y luego visite la aplicación web para asegurarse de que todo funcione.

Archivos Públicos

Como se mencionó en la sección anterior, Back4app sirve automáticamente los archivos ubicados en la carpeta “público”. Para usarlos en sus plantillas, tendrá que modificar ligeramente la configuración de Express.Vaya a app.js y agregue las siguientes líneas:

// app.js

const path = require('path');                             # new
const express = require('express');                       # new
const bodyParser = require('body-parser');

app.set('views', __dirname + '/views');
app.set('view engine', 'twig');

app.use(bodyParser.json());
app.use(bodyParser.urlencoded({extended: true}));
app.use(express.static(path.join(__dirname, 'public')));  # new

require('./routes');

Luego puede hacer referencia a archivos públicos en sus plantillas a través de la ruta relativa:

<img src="/back4app.png" alt="Back4app Logo">

Muestra la imagen ubicada en public/back4app.png.

Conclusión

Node ha estado creciendo y mejorando constantemente desde su lanzamiento en 2009. Es una de las mejores herramientas que permite a los desarrolladores crear fácilmente aplicaciones escalables de alto rendimiento. Las aplicaciones de nodo se pueden implementar en diferentes soluciones como IaaS, PaaS y SaaS. Cada uno tiene sus ventajas y desventajas que deben tenerse en cuenta al elegir la opción de implementación.

Una de las formas más fáciles de implementar aplicaciones de Node es usar Back4app, una solución BaaS de código abierto con muchas funciones. Back4app es excelente ya que le permite concentrarse en lo que es importante mientras subcontrata el backend y su implementación.

Obtenga el código fuente final del repositorio nodejs-back4app.

Preguntas frecuentes