Rutas y capa de red: Responsabilidades y límites

Clase 15 de 33 • Curso de Node.js: Base de Datos con MongoDB y WebSockets

Contenido del curso

Conocer y comprender cómo se realizan las conexiones hacia los servidores a través de internet y sus implicaciones en el desarrollo de servidores

Crear un servidor HTTP en Javascript, y comenzar a escuchar y responder peticiones desde un cliente .

Comprender y desarrollar la arquitectura básica de un backend en NodeJS, y comunicarse entre módulos

Utilizar una base de datos para definir, modelar, almacenar y recuperar la información de nuestra aplicación

Uso de entidades para crear aplicaciones escalables

Conocer el protocolo de websockets, e implementar comunicación cliente/servidor con SocketIO.

Revisión de lo aprendido, y próximos pasos

Tomar examen

Comentarios

Estefany Minerva Camarena Gordillo

student•

Hola, Sergio, . Cualquier aplicación va a tener tres puntos de responsabilidad, que deben responder a tres preguntas:

¿Cómo me comunico con ella? ¿Qué hace? ¿Dónde y cómo se guardan los resultados? . La respuesta a estos tres puntos, corresponden a las tres capas que vamos a generar: Capa de red (en inglés “network”) Capa controladora (en inglés, “controller”) Capa de almacenamiento (en inglés, “store”) . De esto hablo en profundidad en la clase anterior. . La primera capa es una capa de red, porque la conexión con la aplicación se hace a través del protocolo de comunicación en red HTTP. Es la responsable de comunicar al cliente HTTP con nuestro código del controlador. . Si recuerdas las primeras clases, verás que el protocolo HTTP construye una petición con una dirección (route), un verbo (method), unas cabeceras (headers) y un mensaje (body). . Por esto, cada uno de nuestros componentes, tendrá un archivo “network.js” encargado de traducir la petición del cliente HTTP a la acción que queremos realizar en nuestro controlador. . Así, lo que hace nuestro código (la funcionalidad) no está acoplado a unos requisitos de red, y puede ser reutilizado con otras fuentes de entrada (colas MQTT, una biblioteca externa, microservicios…). . La opción que planteas, llamarlo “interface” en lugar de network es también una opción válida. En caso de que tu carpeta se llame interface (o, quizá mejor, “interfaces”), llama a tu archivo “http-response.js” para poder generar nuevas interfaces de escucha o/y respuesta no HTTP. . ¡Gracias!

Alex Eugenio Gavidia Donayre

student•

Gracias!

Sergio Bernal

student•

No puedo responder a tu mensaje. Quería agradecer tu dedicación y tiempo tanto del curso como de las respuestas. Un saludo.

Carlos Hernández

teacher•

Gracias a ti por el tiempo, por la motivación y por el feedback. De verdad, es muy valioso.

Fernando Cordero

student•

Clase que vale la pena repetir para estar claro de todo el proceso de conexion de la app...

Seba Cardoso

student•

Al aprender esto siento algo como lo que sentí con Redux en el Frontend. Una manera compleja de organización los datos que cuando la terminas integrando se transforma en una forma mas fácil de organizar el flujo de información. Y mas fácil para escalar.

Carlos Delgado

student•

Personalmente prefiero agrupar todo por componente entonces tendría /message -/routes -/controller -/bd

para así encontrar fácilmente lo que necesite de algún componente

Daniela Alejandra Arrieta Lucena

company_admin•

Me gusta más esta manera 👍👍

William Leonardo Torres Toloza

student•

Buscar arquitectura hexagonal. Me parece que es súper funcional

Deyvis Neyser Valdez Gavilan

student•

Hola, solo como aporte:

En la carpeta --> network/routes.js no fue necesario requerir a express, al menos por el momento.
otra forma de recibir el app desde server.js

module.exports = server => {
    server.use("/message", message);
}

Saludos!

Deyvis Neyser Valdez Gavilan

student•

Hola, exacto; lo que hice fue aplicar un arrowFunction o función flecha pero puedes hacerlo también aplicando como función anónima de la siguiente forma:

module.exports = function (server) {
    server.use("/message", message);
}

Puedes recibir el server de muchas formas, como por ejemplo: 1.

function routes(server) {
	server.use("/message", message);
}

module.exports = routes;

const routes = function (server) {
	server.use("/message", message);
}

module.exports = routes;

module.exports = server => {
    server.use("/message", message);
}

Espero te haya sido de ayuda. Saludos.

Max Andy Diaz Neyra

student•

Código escrito en ES:

server.js

import express from "express";
import { routes } from "./network/routes.js";

const app = express();

app.use(express.json());
app.use(express.urlencoded({extended : false}));
routes(app);

app.use('/app', express.static('public'));

app.listen(3000);

console.info('La app esta escuchando en http://localhost:3000');

network/routes.js

import message from "../components/message/network.js";

const routes = function (server) {
    server.use('/message', message);
}

export { routes }

components/message/network

import express from "express";
import { success, error } from "../../network/response.js";

const router = express.Router();

router.get('/',(req,res)=>{
    console.log(req.headers)
    res.header({
        "Custom-header":"Nuevo valor personalizado"
    });
    success(req, res, 'Lista de mensajes');
});

router.post('/',(req,res)=>{
    console.log(req.query);
    if(req.query.error == 'ok'){
        error(req, res, 'Error inesperado', 500, 'Es una simulación de errores');
    } else{
        success(req, res, 'Creado correctamente', 201);
    }
});

export default router

Jhon Arcila Castaño

student•

Muchas Gracias

Sebastian Otero Cruz

student•

Gracias me fue de mucha ayuda

Sergio Bernal

student•

No entiendo la estructura de network que estás planteando. Entiendo que lo único que puede ser considerado como "red" o "capa de red" es el app.listen y el socket.io que forman parte de la infraestructura.

No entiendo que tienen que ver las rutas HTTP con "network".

El protocolo HTTP es un protocolo de la capa de aplicación, entendería que lo modularizaras en algo como "interface > response.js" para reutilizar con otras infraestructuras como Websockets, porque al final es parte de la interfaz hacia el cliente (humano o máquina). En el examen me ha llevado a la confusión.

Carlos Hernández

teacher•

Hola, Sergio, . Cualquier aplicación va a tener tres puntos de responsabilidad, que deben responder a tres preguntas:

¿Cómo me comunico con ella?
¿Qué hace?
¿Dónde y cómo se guardan los resultados? . La respuesta a estos tres puntos, corresponden a las tres capas que vamos a generar:
Capa de red (en inglés "network")
Capa controladora (en inglés, "controller")
Capa de almacenamiento (en inglés, "store") . De esto hablo en profundidad en la clase anterior. . La primera capa es una capa de red, porque la conexión con la aplicación se hace a través del protocolo de comunicación en red HTTP. Es la responsable de comunicar al cliente HTTP con nuestro código del controlador. . Si recuerdas las primeras clases, verás que el protocolo HTTP construye una petición con una dirección (route), un verbo (method), unas cabeceras (headers) y un mensaje (body). . Por esto, cada uno de nuestros componentes, tendrá un archivo "network.js" encargado de traducir la petición del cliente HTTP a la acción que queremos realizar en nuestro controlador. . Así, lo que hace nuestro código (la funcionalidad) no está acoplado a unos requisitos de red, y puede ser reutilizado con otras fuentes de entrada (colas MQTT, una biblioteca externa, microservicios...). . La opción que planteas, llamarlo "interface" en lugar de network es también una opción válida. En caso de que tu carpeta se llame interface (o, quizá mejor, "interfaces"), llama a tu archivo "http-response.js" para poder generar nuevas interfaces de escucha o/y respuesta no HTTP. . ¡Gracias!

Xavier Alberto Garcia Navarro

student•

Si alguien por aquí no entiende la diferencia de usar router o no, aquí les doy un enlace donde se explica a detalle y de forma sencilla: Learn to use router

Khevin Efraín

student•

Muy bueno el enlace

Alonso Fabricio Samanez Nuñez

student•

Gracias

Johan Avila

student•

Compañeros les dejo mi repositorio del curso, por si quieren ver la app terminada y sobre todo si quieren copiar algo de código, tiene unos ligeros cambios en los nombre de variables solamente. (Se los dejo porque en las clases que ya me sabia solo quería copiar código y avanzar)

https://github.com/johan-avila/chat-backend

Héctor Gabriel Neuvirt

student•

muchas gracias

Jairo Daniel Samaniego Villacres

student•

es curioso que Github Copilot sugiere exactamente lo del curso, imagino que lo tomará de tu repo

Jorge Iván Durango Acosta

student•

La función "use" de express me parece ambigua, me cuesta saber qué hace exactamente.

Andrés Muñoz

student•

Es para aplicar middlewares a la app:

Sí se usa sola app.use(midware()) por midware pasan todas las rutas todos los métodos,
app.use('ruta_especifica', midware()), si se le da una ruta_especifica, midware solo se aplica a esa ruta_especifica.

tienes que ponerte hacer miniExprimentos y leer los docs para terminar de entender...

Ivo Facundo Chayle

student•

yo lo ordené como

/messages -/routes/index.js -/controller/index.js -/store/index.js entonces al llamarlo con un require no es necesario hacer ‘…/components/messages/routes/index.js’ ya que por defecto toma el index.js de la carpeta y solo se lo llamaría como '…/components/messages/routes’ tambien funciona para las demas carpetas, por ahora me sirve.

Gera Meraki

student•

Hola chicos llevo varios dias con un mismo problema, al momento de separar las rutas (segunda mitad del video) mi programa compila y todo pero al momento de abrirlo en el navegador y hacer el POST/GET con insomia me marca un " Cannot GET / ".

Ya revise que todo este exportado de la manera correcta y no lo puedo hacer funcionar, revise los demás problemas de mis compañeros y tampoco. Recurro a su sabiduría. les comparto captura de mi código

Lalo Díaz

student•

Tengo el mismo problema. Pudiste resolverlo?

Sebastian Mendoza

student•

Me paso lo mismo, revisa insomnia para ver que estas usando la direccion correcta.

Ángel David Roque Ayala

student•

Resumen

Rutas y capa de red: Responsabilidades y límites

En el archivo components/message/network.js

const express = require('express')
const router = express.Router();

const response = require('./../../network/response');
const controller = require('./controller');

router.get('/', function (req, res) {
    console.log(req.headers);
    res.header({
        "custom-header":"myheader"
    });
    response.success(req, res, 'Lista de mensajes')
});

router.post('/', function (req, res) {
    const { user, message } = req.body; 
    controller.addMessage(user, message);
    
    res.send('hola')
});

module.exports = router;

Despues, debemos concentrar todas las rutas en un unico archivo

network/routes.js

const message = require('./../components/message/network')

const routes = function (server) {
    server.use('/message', message)
}

module.exports = routes;

Y el archivo server, queda asi

const express = require('express');
// Importar la funcion router
const router = require('./network/routes');


var app = express();
var port = 3000;

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

router(app); // Uso de la funcion principal

app.use('/app',express.static(__dirname + '/public'));


app.listen(port, ()=> { console.log(`Servidor corriendo en el puerto ${port}`); })

Angel Raúl Acosta Rojas

student•

Siento que el archivo network.js debería llamarse más bien "specificResponse.js" o algo así, pues se confunde la carpeta network con el archivo, y ya es de por sí complejo y confuso de entender

Andrés Muñoz

student•

yo le puse componente_route.js

Usuario anónimo

user•

No me quedó clara la parte donde crea el archivo routes.js, ¿cómo hace para que funcione el enrutamiento desde el archivo network.js si en los métodos get y post está especificada la misma ruta "/"? Ahí me perdí.

Fabrizzio De Bracamonte

student•

En el archivo routes.js, hay una funcion llamada routes que ejecuta: server.use("/message", message) Ese "/message" es la ruta con la que trabajaremos y message es un llamado al componente network. Dentro de network, get y post tambien tienen su propia ruta, la cual se pondría después de la ruta que de la que hablamos hace un momento. Entonces, si esa ruta (la de post y get) fuera "/message" nos estaríamos refiriendo a "/message/message", pero como lo que queremos es trabajar con "/message" le damos la ruta de "/" quedando: "/message/" No sé si se entendió 😅

Javier Alejandro Flores Gomez

student•

Alguie sabe a que se refiere el error

TypeError: app.use() requires a middleware function?

Omar Daniel Centeno

student•

¡Hola! :D

Si pudieras compartirnos tu código sería más sencillo encontrar el problema. Puedes copiar y pegar utilizando el botón de </> código.

A lo mejor debes de revisar que estés utilizando:

module.exports = router;

var mainRoutes = require('./Routes.js')
app.use(mainRoutes)

¡Saludos!

Jose Daniel Molina

student•

Que arquitectura es esta?

Daniel Meza

student•

Entiendo que es MVC, donde en este momento estás trabajando con las partes de modelos y controladores (MC). Además de llevar buenas prácticas y separar responsabilidades como manejar un archivo para las conexiones, para rutas, etc...

Deleted .

student•

En teoría, el método use() se utiliza para ... ?

Juan Castro

teacher•

Se utiliza para interceptar las peticiones que llegan a nuestro servidor. Podemos analizarlas para decidir si las bloqueamos o las dejamos continuar su flujo. Por ejemplo, podemos verificar que el usuario esté autenticado antes de entregarlo a las funciones que responden con datos privados.

:point_right: https://expressjs.com/es/guide/writing-middleware.html :point_right: https://expressjs.com/es/api.html#app.use

Fernando Cordero

student•

Es un middleware

Jaime Navarro Rosales

student•

no estoy entendiendo porque en el archivo de routes.js despues de pasar la ruta '/message' se le pasa todo el archivo de network

Juan Carlos García Esquivel

student•

Que tal Jaime, el archivo routes.js contendra todas las rutas de nuestra aplicación mientras que la importancion const message = require("../components/messages/network"); contiene solo las rutas para los mensajes tal vez con un mejor uso de los nombres de las variables te quede mas claro :

const express = require("express");
const messagesRouter = require("../components/messages/network");

const routes = (server) => {
  server.use("/messages", messagesRouter);
};

module.exports = routes;

Jaime Navarro Rosales

student•

ok si entiendo que el archivo const messagesRouter = require("../components/messages/network"); contiene todas las rutas pero no entiendo como es que en la funcion de routes se le pasa directo el archivo completo y no las rutas especificamente es lo que me tiene un poco confundido

import express from "express";
import { routes } from "./network/routes.js";

const app = express();

app.use(express.json());
app.use(express.urlencoded({extended : false}));
routes(app);

app.use('/app', express.static('public'));

app.listen(3000);

console.info('La app esta escuchando en http://localhost:3000');

import express from "express";
import { success, error } from "../../network/response.js";

const router = express.Router();

router.get('/',(req,res)=>{
    console.log(req.headers)
    res.header({
        "Custom-header":"Nuevo valor personalizado"
    });
    success(req, res, 'Lista de mensajes');
});

router.post('/',(req,res)=>{
    console.log(req.query);
    if(req.query.error == 'ok'){
        error(req, res, 'Error inesperado', 500, 'Es una simulación de errores');
    } else{
        success(req, res, 'Creado correctamente', 201);
    }
});

export default router 

const express = require('express')
const router = express.Router();

const response = require('./../../network/response');
const controller = require('./controller');

router.get('/', function (req, res) {
    console.log(req.headers);
    res.header({
        "custom-header":"myheader"
    });
    response.success(req, res, 'Lista de mensajes')
});

router.post('/', function (req, res) {
    const { user, message } = req.body; 
    controller.addMessage(user, message);
    
    res.send('hola')
});

module.exports = router;

const express = require('express');
// Importar la funcion router
const router = require('./network/routes');

var app = express();
var port = 3000;

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

router(app); // Uso de la funcion principal

app.use('/app',express.static(__dirname + '/public'));

app.listen(port, ()=> { console.log(`Servidor corriendo en el puerto ${port}`); })

const express = require("express");
const messagesRouter = require("../components/messages/network");

const routes = (server) => {
  server.use("/messages", messagesRouter);
};

module.exports = routes;

Rutas y capa de red: Responsabilidades y límites

Conocer y comprender cómo se realizan las conexiones hacia los servidores a través de internet y sus implicaciones en el desarrollo de servidores

Bienvenida y presentación del curso

Qué es Node y cómo instalarlo

¿Qué son y cómo se usan las peticiones HTTP?

Métodos, cabeceras y estados

Cuerpo y query de la petición

Crear un servidor HTTP en Javascript, y comenzar a escuchar y responder peticiones desde un cliente .

Crear un servidor HTTP desde NodeJS

¿Cómo pueden venir las peticiones?

Recibir información desde el cliente: Body y Query

Información contextual: Leer las cabeceras

Tipos de respuesta: Vacía, plana, con datos y estructurada

Respuestas coherentes

Servir archivos estáticos

Errores: Cómo presentarlos e implicaciones en la seguridad

Comprender y desarrollar la arquitectura básica de un backend en NodeJS, y comunicarse entre módulos

Conceptualmente: Rutas, controladores y bases de datos