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

Gestionar conexiones a la base de datos desde la API

24/33
Recursos

En esta clase vamos a refactorizar nuestro c贸digo para tener todo organizado de una mejor manera, crearemos un archivo db.js donde tendremos todos los datos de nuestra conexi贸n a la base de datos.

Aportes 28

Preguntas 8

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸n.

Hola devs. Yo lo implement茅 de esta manera, eleg铆 usar dotenv. Dotenv es una librer铆a muy sencilla de implementar y garantiza una seguridad absoluta a la hora de trabajar con informaci贸n sensible implementando variables de entorno. S贸lo tienen que crear el archivo .env en la ra铆z del proyecto y a帽adir ah铆 sus variables de entorno, luego en el archivo server.js realizan la siguiente configuraci贸n y ya est谩. Luego a帽aden el archivo .env al gitignore y dejan un .env.example como buena pr谩tica


root/.env

DB_CONNECT = "mongodb+srv://<username>:<password>@cluster0.s5abe.mongodb.net/telegrom?retryWrites=true&w=majority"


root/server.js

const express = require("express");
const router = require("./network/routes");
const db = require("./db");
require("dotenv").config({ path: ".env" });

// conexion a la base de datos
db(process.env.DB_CONNECT);

const app = express();
const PORT = 3000;

//codificaci贸n
app.use(express.json());
app.use(express.urlencoded({ extended: false }));

//cargamos el servidor a las rutas para que "prenda"
router(app);

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

app.listen(PORT, () => {
  console.log(`La app est谩 escuchando en http://localhost:${PORT}`);
});

驴Cu谩l es la ventaja de tener la URL de conexi贸n de base de datos como par谩metro? Quiz谩s es mejor dejarla como variable de entorno. Pensando en qu茅 tanto podr铆a cambiar la URL de conexi贸n entre m茅todos, es casi nunca. Sin embargo entre ambientes si cambia

Lo que hicimos en esta clase fue conectarnos a nuestra base de datos una vez se haya iniciado el servidor? antes se iniciaba la base de datos solo cuando nos ubic谩bamos en el componente 鈥渕essage鈥. Correcto? gracias.

No entiendo muy bien por qu茅 basta con hacer db(鈥榗redencialesDeMongo鈥); y no llamar a la funci贸n connect 馃槙

yo modifiqu茅 un poco el c贸digo para que si la conexi贸n falla el servicio no se levante

const db = require('mongoose');
db.Promise = global.Promise;

const connect = async (url) => {
      await db.connect(url,{
            useNewUrlParser:true,
            useUnifiedTopology: true
      })
            .then(() => {
                  console.log('[Date Base Connect] DB conectada con 茅xito');
            })
            .catch(err => {
                  console.error('[Date Base Connect] Error al conectar a la base de datoss'+err);
                  return process.exit(22);
            });
}

opcional mente tambi茅n cambie server.js

db(uri2)
      .then(()=>{
            let app = express();

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

            router(app);
            app.listen(port);

            console.log('La aplicacion esta escuchando en el puerto: '+ port);
      })
      .catch(err => console.error(err));

esto a diferencia de lo que tiene el profesor en la clase es que primero da la conexi贸n a la BD y luego levanta el servicio, y si la conexi贸n falla el servicio no se levanta eso para prevenir que el servicio se levante y no tenga donde guardar. No se que tan bueno es mi c贸digo fue por practica ojala me puedan dar su opini贸n.

muy buen curso 馃槈

Todo esto est谩 muy bien, espero que node tenga un framework con una estructura de trabajo ya m谩s estructurada como Laravel en PHP.

Esta clase esta en una posici贸n que no es correcta, por favor corrijan el orden de las clases.

As铆 lo implemente yo, aclaro que estoy usando mongo en local.
db/mongo.js

const db = require("mongoose");

let uri = "mongodb://localhost:27017/Message";
db.Promise = global.Promise;

db.connect(uri, { useNewUrlParser: true, useUnifiedTopology: true })
  .then(() => console.log("[db] Conectada con 茅xito"))
  .catch((err) => console.error("[db]", err));

server.js

const express = require("express")
const route = require("./network/routes")
const bodyParser = require("body-parser")
const morgan = require("morgan")

//db
require("./db/mongo")

No entiendo a qu茅 se refiere cuando dice 鈥渃ompartir al conexi贸n鈥 para evitar llenar el pool de conexiones鈥 馃槮

Otra manera para mayor orden es lo siguiente, (ya que no me hab铆a quedado claro que el db(鈥榩arm鈥) de server.js se asociaba con la 煤nica funci贸n existente en db.js)

En server.js
db.connect(鈥渕ongodb+srv://user:[email protected]/Chat鈥)

En db.js
async function conectar(url){
await db.connect(url,{
useNewUrlParser: true,
useUnifiedTopology: true
})

console.log([db] conectada con 茅xito)
}

async function desconectar(url){
C贸digo para desconectar
console.log([db] Desconectada con 茅xito)
}

module.exports = {
connect : conectar,
disconect : desconectar
}

Me encanta como se emociona el profesor, asi mismo te transmite la emocion. Por eso es importante dedicarse a un oficio que amemmos

Este curso me gusta mucho aqu铆 les dejo la manera en como lo estoy hasta ahora haciendo, saludos鈥
https://github.com/luislozad/app-socket

C贸digo ES

import db from "mongoose";

db.Promise = global.Promise;

async function connect(url) {
    try {
        await db.connect(url,{
            useNewUrlParser:true,
            useUnifiedTopology:true,
        });
        console.log('[db connection] Conectada con 茅xito');
    } catch (e) {
        console.error('[db connection] Connection failed', e.message)
    }
}

export default connect;

Este curso esta resolviendo demasiadas duda que tenia. En serio, muchas gracias

Pueden trabajar con las variables de entorno para hacer de la url de la base de datos mas segura. Es decir, hacer un archivo . env y ah铆 agregar la URL, luego hacer el llamado en db.js. Se puede usar el operador ternario 鈥?:鈥 para darle una condici贸n y ya se hace un poco m谩s seguro

Primero agregar en el archivo .env lo siguiente:

MONGODB_URL='mongodb+srv://usuario:RFabcdefghijklmnopq5@cluster0.h6s7a.mongodb.net/prueba'

Luego hacen el llamado en la base de datos: (Lo bueno de esto es que si existe, pues la va a usar y si no la crea ya que es la manera que trabaja una db no relacional, por eso es bueno el mongoose)

const URL = process.env.MONGODB_URL 
? process.env.MONGODB_URI
: 'mongodb://localhost/databasetest';

Espero darme a entender. 脡xitos a [email protected]!!

Hola alguien tendr谩 los pasos de la creaci贸n de conexi贸n,no esta el v铆deo 馃槮

Tengo una app realizada en Next.js en localhost:300/ no habr谩 ning煤n problema si tengo las rutas de node de la api en el mismo server es decir. localhost:300/usuarios

db.js

const db = require('mongoose')

db.Promise = global.Promise
//mongodb+srv://db_user_backend_node:<password>@cluster0-icc7n.mongodb.net/backendnode_db?retryWrites=true&w=majority

async function connect(url) {
    await db.connect(url, {
        useNewUrlParser: true,
        useUnifiedTopology: true,
    }).then(() => {
        console.log(' [db] Conectada con exito')
    }).catch( error => console.error(error))
}

module.exports = connect;```

server.js

const express = require('express')
const bodyParser = require('body-parser')

const db = require('./db')

const router = require('./network/routes')

db('mongodb+srv://db_user_backend_node:<password>@cluster0-icc7n.mongodb.net/backendnode_db?retryWrites=true&w=majority')
var app = express()
app.use(bodyParser.json()) 
app.use(bodyParser.urlencoded({extended: false}))


router(app)



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

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

store.js

const Model = require('./model')

function addMessage(message) {
    const myMessage = new Model(message)
    myMessage.save()
    
}

async function getMessages(filterUser) {
    let filter = {}
    if (filterUser !== null) {
        filter = { user: filterUser }
    }
    const messages = await Model.find(filter)
    return messages  
}

function removeMessage(id) {
    return Model.deleteOne({
        _id: id
    })
}

async function updateText(id, message) {
    const foundMessage = await Model.findOne({
        _id: id
    })
    foundMessage.message = message
    const newMessage = await foundMessage.save()
    return newMessage
}

module.exports = {
    add: addMessage,
    list: getMessages,
    updateText: updateText,
    remove: removeMessage,
}```

Compartir la conexi贸n

Disculpen por la pregunta 驴Qu茅 es una API? A veces creo saber pero no estoy seguro 馃

creo que por seguridad deberiamos usar un archivo .env para las credenciales de la conexion a mongo

sip 馃槂 nos vemos

Antes de escalar nuestra arquitectura debemos observar la manera en que realizamos la conexion a la base de datos(DB).

Hay varias formas de gestionar las conexiones a la DB:
1-Crear una conexion que se abre y se cierra en cada peticion: Es una buena idea si tenemos muy pocas peticiones y no sabemos cuando llegaran.
2-Compartir la conexion:Cuando sabemos que tendremos una api donde haremos peticiones constantes.

Hola Devs:
-Aca les traigo mi solucion usando TypeScript:
Conexion a la base de datos de MongoDB:

-Aqui tienen el commit exacto de esta clase: Click Aqui
Recuerda, #NuncaParesDeAprender 馃挌

Pr谩ctica:
No me funciona correctamente, pero al menos lo intento. :p