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

1

Bienvenida y presentación del curso

2

Qué es Node y cómo instalarlo

3

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

4

Métodos, cabeceras y estados

5

Cuerpo y query de la petición

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

6

Crear un servidor HTTP desde NodeJS

7

¿Cómo pueden venir las peticiones?

8

Recibir información desde el cliente: Body y Query

9

Información contextual: Leer las cabeceras

10

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

11

Respuestas coherentes

12

Servir archivos estáticos

13

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

14

Conceptualmente: Rutas, controladores y bases de datos

15

Rutas y capa de red: Responsabilidades y límites

16

Controladores: Definiendo la lógica de negocio

17

Almacenando la información en una base de datos

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

18

Tipos de Bases de Datos: Relacionales y No Relacionales

19

Crear y Configurar tu Base de Datos con MongoDB

20

MongoDB: Almacenar y leer datos

21

MongoDB: Actualizar datos

22

MongoDB: Consultar datos

23

MongoDB: Eliminar Datos

24

Gestionar conexiones a la base de datos desde la API

Uso de entidades para crear aplicaciones escalables

25

Escalando la arquitectura: Múltiples entidades

26

Relacionando nuestras entidades

27

Cómo recibir ficheros desde NodeJS

28

Guardar el fichero en el servidor

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

29

WebSockets: Qué son, por qué son interesantes y cómo usarlos

30

Manejo de Websockets con NodeJS

31

Conectar la API al servidor de WebSockets

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

32

Revisión y próximos pasos

33

Tips para escalar nuestro proyecto

Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

¿Cómo pueden venir las peticiones?

7/33
Recursos

Aportes 69

Preguntas 13

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Para no tener que andar bajando y subiendo el server se puede instalar una librería que se llama nodemon, la cual detecta cambios en el file system del proyecto y hace el reload del proyecto automáticamente.
Para instalar nodemon ejecutar

npm i -g nodemon

Luego de tener instalado nodemon, hay que realizar un cambio en el package.json agregando lo siguiente en el apartado de scripts

    "server":"nodemon server.js",

Luego para levantar el server en vez de

node server.js

ejecutamos lo siguiente

npm run server

Este “server” coincide con la key que hemos agregado en el package.json en el apartado “scripts”

En el 2021 ya no es necesario usar router de express para crear rutas, ya esto viene por defecto en el elemento app. Lo puedes usar asi:

app.get("/", (req, res) => {
	res.send("Hola, mundo)
} 

Por si a alguien se le escapa el detalle, cuando dice “vamos a matar el servidor” lo hace con las teclas “Ctrl + C”

Insomnia me gusto mucho por que soporta graphQl, cosa que postman apenas lo tiene en beta

También podemos usar Postman o desde la terminal con curl

curl http://localhost:3000 // Petición GET
curl -X 'POST' http://localhost:3000 -d {} // Petición POST

Para los que se perdieron en como manejar insomnio, aquí hay un link que explica como abrir los proyectos, realmente me perdí en esta parte porque el profesor no explico como abrir el proyecto.
Link: https://support.insomnia.rest/article/11-getting-started
Gracias!!

Les aconsejo instalar nodemon ya que reinicia de forma automatica cuando detecta cambios en nuestros archivos y así no debemos volver a ejecutar el comando “node server.js” cada vez que hagamos un cambio y unicamente seria “nodemon server.js”.

Yo utilizo Postman para probar los endpoints de mi app. Lo recomiendo.

Recomiendo la extensión Node Snippets para VSCode

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

var app = express();
app.use(router);

/*
app.use('/', function(req, resp){
    resp.send("hola");
});
*/

router.get("/", function(req, res){
    res.send("peticion de get");
  });

router.post("/", function(req, res){
    res.send("peticion de post");
  });

router.patch("/",function(req, res){
    res.send("peticion de patch");
  });

router.delete("/",function(req, res){
    res.send("peticion de delete");
  });

app.listen(3000);
console.log(" la aplication esta escuchando en el port http://localhost::3000");

Igualmente, también se debió explicar qué es el parámetro “/”. Pésimo todo, no pueden dar por sentado de que el estudiante sabe estas cosas.

Hola, Que ventaja da usar express.Router()??
router.get(’/’ (req, res)=> res.send(‘Hola desde get’))
sobre
app.get(’/’ (req, res)=> res.send(‘Hola desde get’))
Saludos!!

en ves de insonia yo uso Postman y la verdad es muy similar y me gusta mas

me gusta mas postman

Hay un curso de Postman aquí mismo. Pero si tienen un entono de desarrollo en VSCode, y no quieren estar cambiando de ventana, les recomiendo Thuder Client.

Team postman :3

Yo utilizo, para hacer las peticiones, una extensión en Visual Studio Code llamada RESTClient.

Nombre: REST Client
ID: humao.rest-client
Descripción: REST Client for Visual Studio Code
Versión: 0.24.5
Editor: Huachao Mao
Vínculo de VS Marketplace: https://marketplace.visualstudio.com/items?itemName=humao.rest-client

Para crear una petición GET o POST, es tan sencillo como crear un archivo con extensión .http, después declarar la dirección de la API en una variable que estaremos utilizando a lo largo del archivo:

### API VARIABLE
@api = http://localhost:3000

Los “###” se utilizan para indicar un comentario.

Posteriormente hacemos las peticiones:

### GET
GET {{api}}/mensaje

### POST
POST {{api}}/mensaje

El resultado es como el siguiente:

He tenido un problema al utilizar el código que viene en este vídeo:

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

let port = 3000;

router.get("/", function (request, response) {
  response.send("Hola desde GET");
});

router.post("/", function (request, response) {
  response.send("Hola desde POST");
});

app.listen(port);
console.log(`La aplicacion esta escuchando en http://localhost:${port}`);

De esta manera mi daba el error al mandar una petición GET
Cannot GET /
y al mandar una petición POST
Cannot POST/

Así que investigando me encontré con la siguiente página:
https://expressjs.com/es/guide/routing.html

Al perecer ahora se hace de las peticiones se hacen de la siguiente manera:

const express = require("express");

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

// GET method route
app.get('/', function (request, response) {
  response.send('GET request to the homepage');
});

// POST method route
app.post('/', function (request, response) {
  response.send('POST request to the homepage');
});

app.listen(port);
console.log(`La aplicacion esta escuchando en http://localhost:${port}`);

Con esto mi error se ha solucionado

Apuntes de la clase:

Que herramienta considerarían mejor, Insomnia o Postman?

Enlace de descarga Insomnia Windows 👍👍👍

Yo utilizo normalmente Postman es una muy buena herramienta de igual forma probaré Insomnia a ver que tal me va.

llames donde llames o llames como llames

Pregunta de examen:
¿Cómo le indicamos a nuestra app que use el router?

Plus:
Para poder trabajar con EcmaScript 6+ y poder ver los cambios tienes que modificar tu package.json

{
  "name": "backendnode",
  "version": "1.0.0",
  "description": "Un chat como telegram",
  "main": "server.js",
  "type": "module",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "server": "nodemon server.js"
  },
  "author": "Max Diaz <[email protected]>",
  "license": "MIT",
  "dependencies": {
    "express": "^4.17.1"
  }
}

Luego en la consola escribes npm run serve y listo, a programar sin tener que volver a escribir node server.js

Me paso que deteniendo el servidor oprimí CTROL+Z y lo que hace es que suspende el servidor y lo deja en segundo plano. Si les llega a pasar deben escribir el comando “fg” y ahí sí oprimir CTROL+C.

Para los que no les gusta insomnia pueden utilizar postman para mí es mucho mejor.

también podrías usar postman en lugar de insomnia que a mi parecer es mejor

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

var app = express();

app.use(router);

router
  .get("/", function(req, res) {
    res.send("Traer");
  })

  .post("/", function(req, res) {
    res.send("Enviar");
  })
  .patch("/", (req, res) => {
    res.send("Cambiar");
  })
  .delete("/", (req, res) => {
    res.send("Borrar");
  });

app.listen(3002);

console.log("La aplicacion esta escuchando en el puerto http://localhost:3002");

Pueden usar Postman en vez de Insomnia, cuestión de gustos. 😃

Ya no es necesario usar aplicaciones, desde el mismo vs lo puedes hacer con la extension “Thunder Client” ! Es superior postman y a otras herramientas para realizar ejercicios de éste estilo

con una extensión de VSC llamda thunder client es más cómodo hacerlo ( en vez de insomnia)

Hay una extensión en vscode llamada Thunder Client, asi no tienen que descargar otra aplicación aparte para hacer peticiones

por que se añade el router a express, si ya viene el Router dentro de express ?

const express = require(“express”)
const router = express.Router() // nos permite seperar cabezeras o por metodos o por URL y separar nuestras peticiones al maximo.

let app = express()

app.use(router)

router.get("/message", function (req, res) {
res.send(“Lista de mensajes”)
})

router.post("/message", function (req, res) {
res.send(“mensaje añadido”)
})

router.delete("/message", function (req, res) {
res.send(“mensaje Eliminado”)
})

// app.use("/", function (req, res) {
// res.send(“Hola Mundo”)
// })

app.listen(3000)
console.log(“la aplicacion esta escuchando en http//localhost:3000”)

Este profesor explica demaciado bien

Buenisima la clase !!!

Mis aporte de como es que yo organice mi código.

En este archivo tengo todo lo que necesita express para poder ejecutar el servidor en la dirección y el puerto que se establece.

<h5>📄 server.js</h5>
const express = require('express');
const router = require('./router/index');
const PORT = process.env.PORT || 3000;
const app = express();

app.use('/api',router);

app.listen(PORT, () => {
  console.info(`La aplicación esta escuchando peticiones`);

});

Creo una carpeta 📂 router con un archivo llamado 📄 index,js, donde lo que hago es requerir el modulo de express y en especifico router y me creo las rutas que necesita mi servidor luego lo exporto mi variable router y asi puedo usarlo en mi archivo server.js

<h5>📄 router/index.js</h5>
const express = require("express");
const router = express.Router();
router.get('/message', (req, res) => {
  res.json({
    "method": "GET", 
    "Uso": "Se usa para listar datos, del servidor",
    "ejemplo": "Lista de Mensajes! 👀"
  })
})
router.post('/message', (req, res) => {
  res.json({
    "method": "POST", 
    "Uso": "Se usa para insertar datos, al servidor",
    "ejemplo": "Mensaje Agregado! 👍"
  })
})
router.put('/message', (req, res) => {
  res.json({
    "method": "PUT", 
    "Uso": "Se usa para remplazar datos, al servidor",
    "ejemplo": "Mensaje editado! 👌"
  })
})
router.delete('/message', (req, res) => {
  res.json({
    "method": "DELETE", 
    "Uso": "Se usa para eliminar datos, al servidor",
    "ejemplo": "Mensaje Eliminado! 🤷‍♂️"
  })
})

module.exports = router;

Veo y entiendo que Insomnia es similar a Postman para hacer este tipo de peticiones HTTP. Si quiere aprender más dejo el curso: https://platzi.com/clases/postman/

Para los que deseen instalar Insomia in ubuntu solo ejecuten el siguiente comando:

sudo snap install insomnia

Interesante

Yo utilizo ARC (Advanced REST Client) para hacer el seguimiento a las peticiones

excelente clase, llevo ya algunos meses usando node-express y nunca había usado router.

si quieren no estar parando y arrancando el sistema todo el tiempo, instalar npm install -g nodemon para que se guarde automáticamente

fue super facil , me encanta

Esta chido el cliente RES

Ohhh se esta poniendo bueno esto.
Me encanta NodeJs❤
Me agrada insomnia .

Insomnia buena herramienta para ser usada en linux 😃

Excelente clase !

como mata el servidor para volver a arrancarlo? es una combinacion de teclas?

This is my code

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

var app =  express();

app.use(router);

app.get('/', (req, res) => {
    res.send('Que ondas Soy tu primer petición con GET');
});
app.post('/', (req, res) => {
    res.send('Que ondas Soy tu primer petición con POST');
});
app.listen(3000);
console.log('La aplicación esta escuchando en pueto:3000');

//en consola se debe instalar el paquete de express con el siguiente comando
//npm i express
//una vez instalado debemos asignar a una constante el paquete instalado
const express = require("express");
var app = express();
//añadiremos router de express para poder utilizar los metodos http y controlar los mensajes a entregar en nuestras peticiones
const router = express.Router();

// app.use("/", function(req, res) {
//     res.send("Hola soy un server con express");
// });

//ahora indicamos que nuestra app utilizara las rutas entregadas por express
app.use(router);
//de esta forma podemos invocar los distintos metodos http con express
router.get("/mensaje", (req, res) => {
    res.send("Hola este metodo es get para listar los mensajes");
});
router.post("/mensaje", (req, res) => {
    res.send("hola este metodo invocado es post, gracias por añadir un mensaje");
});

app.listen(3002);
console.log("la aplicacion esta escuchando en http://localhost:3002");

Me siento hacker xdxd

Insomnia es similar a posman?

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

var app = express();

app.use(router);

router.get('/message', function(req, res){
    res.send('Hola desde get, Lista de mensajes');
})

router.post('/message', function(req, res){
    res.send('Hola desde post, mensaje añadido');
})

router.delete('/message', function(req, res){
    res.send('Hola desde delete, eliminar mensaje');
})

router.put('/message', function(req, res){
    res.send('Hola desde put, editar mensaje');
})

router.patch('/message', function(req, res){
    res.send('Hola desde patch, cambiar precio del mensaje');
})

router.options('/message', function(req, res){
    res.send('Hola desde options');
})

app.listen(3000);
console.log('La aplicación esta escuchando en http://localhost:3000')```

muy interesante,

const express = require('express');
//nos permite trabajar y gestionar nuestras peticiones
const router = express.Router();
const PUERTO = 3000;

var app = express();
//aqui añadinos router a la aplicacion de express
app.use(router);

router.get('/message', (req, res) => {
    res.send('Lista de mensajes');
});

router.post('/message', (req, res) => {
    res.send('Mensaje añadido');
});

// app.use('/', (req, res) => {
//     res.send('Hola');
// })

app.listen(PUERTO);
console.log(`La aplicacion esta escucando en http://localhost:${PUERTO}`);

entonces express sirve para administrar lo que el servidor devuelve?

![Por si tienen problemas con el puerto en linux pueden hacer esto para cerrar el puerto y que deje de dar problemas](

otro opción seria utilizar postman

<h1>¿Cómo pueden venir las peticiones?</h1>

Para gestionar el tipo de peticiones que realizamos a nuestro servidor utilizaremos el router de express.

<h3>Router</h3>

Nos va a permitir separar cabeceras ó por métodos ó por url

De esta manera lo que debemos hacer es cambiar el código para gestionar cada una de las rutas que vamos a crear con el método http que le indiquemos.

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

var app = express();

app.use(router);

router.get("/", function (req, res) {
  res.send("listando objetos");
});

router.post("/", function (req, res) {
    res.send("creando objeto");
  });

  router.delete("/", function (req, res) {
    res.send("borrando objeto");
  });

app.listen(3000);
console.log("La aplicación esta escuchando en http://localhost:3000");

Facinante cuestion we :v

Se debió explicar qué son los parámetros req y res. Si sí lo hicieron y yo no lo vi, por favor indíquenlo.

En postman, no me deja usar el Agent del Cloud. Asi que tuve que descargalo para desktop por que no me dejaba acceder al localhost desde el browser… Solo desde el desktop 😦

https://www.postman.com

Postman es otra buena herramienta para hacer peticiones http cuando desarrollas una API, es muy bueno como alternativa a Insomnia.

Recomiendo que usen Postman, es como Insomnia pero mucho más potente y tiene una interfaz muy similar

Práctica: