No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Configuración de base de datos

8/25
Recursos

Por el momento nuestra API maneja pura información estática, vamos a cambiar esto pasando la información a una base de datos, en este caso usaremos MongoDB.

Es recomendable almacenar las credenciales de conexión a la base de datos como variables de entorno del sistema y utilizar dotenv para la lectura de dichas credenciales. Para su instalación vamos a correr el comando

npm i dotenv

Aportes 52

Preguntas 6

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

  1. Creen una cuenta en MongoDB Atlas
  2. Creen un nuevo cluster
  3. En el nuevo cluster, hagan click en Connect
    3.1) Coloquen en lista blanca su IP
    3.2) Creen un usuario para la BD con su contraseña
    3.3) Creen un nuevo enlace de conexión
  4. En robot3t hagan click en Create en la ventana MongoDB Connections
    4.1) Peguen el enlace de conexión generado en (3.2)
    4.2) Hagan click en From SRV
  5. Hagan click en Connect en la ventana MongoDB Connections

Para las versiones actuales se instala es mongodb

npm install mongodb

Luego el archivo de conexión queda de la siguiente manera:

const { MongoClient } = require('mongodb');

const { DB_USER, DB_PASSWORD, DB_HOST, DB_NAME } = process.env;

const mongoUrl = `mongodb+srv://${DB_USER}:${DB_PASSWORD}@${DB_HOST}/${DB_NAME}?retryWrites=true&w=majority`;
let connection;

async function connectDB() {
  if (connection) return connection;

  let client;
  try {
    client = new MongoClient(mongoUrl, {
      useNewUrlParser: true,
      useUnifiedTopology: true,
    });
    connection = await client.connect();
  } catch (error) {
    console.error('Could not connect to db', mongoUrl, error);
    process.exit(1);
  }

  return connection;
}

module.exports = connectDB;

MLAB ya no esta disponible, ahora se usa Mongo Atlas

aqui el codigo de db.js para atlas

'use strict'

const MongoClient = require('mongodb').MongoClient

const {
    DB_USER,
    DB_PASSWD,
    DB_HOST,
    DB_PORT,
    DB_NAME
} = process.env

const uri = `mongodb+srv://${DB_USER}:${DB_PASSWD}@test-qgluq.mongodb.net/test?retryWhites=true&w=majority`


let connection

async function connectDB() {
    if (connection) return connection
    let client
    
    try {
        client = await MongoClient.connect(uri, { useNewUrlParser: true, useUnifiedTopology: true })
        connection = client.db(DB_NAME)
    } catch (error) {
        console.log('No se pudo conectar a la base de datos de mongo', uri, error)
        process.exit(1)        
    }
    return connection
}

module.exports = connectDB

De esta clase en adelante empiezan los problemas por usar tecnologías obsoletas. Ojalá cambien este curso para Mongo Atlas y poderlo seguir sin problemas.

Para los que estan viendo este curso en este año 2020, EFECTIVAMENTE tienes que crear una cuenta con atlas y el administrador cambia, solo deben de crear un user, en la parte de connect te da la liga de como conectarte desde node.js.
NOTA: deben de agregar su IP en network access, o pueden poner publica su base de datos, poniendole IP 0.0.0.0 para tener acceso desde cualquier lado.

hubo una confusión por parte del profesor, se debe utilizar mongodb para acceder a MongoClient:

npm i mongodb

En este curso se explica tambien como conectarse a mongo desde node

https://platzi.com/clases/1646-backend-nodejs/22033-creacion-de-una-bd-en-mongoatlas/

gracias @EPadronu23 dejo los pasos para ubuntu.


1 -Creen una cuenta en MongoDB Atlashttps://cloud.mongodb.com/ y generen un nuevo cluster
2- En el nuevo cluster, hagan click en Connect
3- Coloquen en lista blanca su IP
5- Creen un usuario para la BD con su contraseña
5- Seleccionen la opcion "connect your aplication"
6- Copien la cadena de conexion
7- Vayan a collections y agreguen una base de datos
name: platzi
collection: courses

(De igual manera el mismo sistema los va guiando)


Por otro lado descarguen robot3t https://angelcruz.dev/post/instalar-robo-3t-formerly-robomongo-en-ubuntu-1804
1- En robot3t hagan click en Create en la ventana MongoDB Connections
2- Peguen la cadena de conexion copiada anteriormente (reemplacen las variables <>) en el input al lado de FROM SRV
3) Hagan click en From SRV
4) Click en test connection
5) Si todo salio bien click en Save

Listo!

No se puede seguir !!! Debe existir actualización del curso o mas bien quitarla.
Las personas necesitan aprender no perder su tiempo.

Yo preferí crearme un archivo llamado config.js mismo que accede a mis variables de entorno:

require('dotenv').config()

const db = {
  port: process.env.DB_PORT || 27017,
  username: process.env.DB_USERNAME,
  password: process.env.DB_PASSWORD,
  cluster: process.env.DB_CLUSTER,
  name: process.env.DB_NAME
}

module.exports = {
  db
}

Una consulta no es mejor utilizar Compas para usar MongoDB??

Sin miedo a equivocarme, creo que sin duda alguna podría decir que este es uno de los mejores profesores que tiene Platzi.

Otra forma de conectarse a mongo con la libreria mongoose
.
Visto en el curso de NodeJS

const mongoose = require('mongoose');
const { DB_USER, DB_PASS, DB_NAME } = process.env;

const uri = `mongodb+srv://${DB_USER}:${DB_PASS}@cluster0.pjeso.mongodb.net/${DB_NAME}?retryWrites=true&w=majority`;
mongoose.Promise = global.Promise;

async function connectDB() {
    await mongoose.connect(uri, { useNewUrlParser: true, useUnifiedTopology: true})
        .then(() => {
            console.log('[database] conectada con exito')
        }).catch((e) => {
            console.error('Hubo un error al conectarse con la DB');
            console.error(e);
        });
}

module.exports = connectDB;```

El metodo connect no se encuentra en el paquete de mongo, es de mongodb asi que deben instalarlo para que funcione

Al momento de estrenarse el curso ya no se encuentra disponible el registro directo para mLab, ya que este fue adquirido por MongoDB y por lo tanto toca usar MongoDB Atlas, funciona muy bien y sirve de igual manera para seguir el curso, si tienes alguna problema al configurarlo coméntalo y te podemos ayudar.

Muchachos les recomiendo que sigan este video para la creacion de la base de datos en mongo atlas https://www.youtube.com/watch?v=_irNiugD180

Yo tuve que hacerlo así

Enero de 2022

'use strict'
const { config } = require('dotenv');
// Recordar instalar MongoDB
// npm i mongodb
// para poder utilizar MongoClient
const { MongoClient } = require('mongodb');

const {
    DB_URL
} = process.env

let connection;

async function connectDB(){
    if(connection){
        return connection;
    }        

    connection = new Promise(async(resolve,reject) => {
        
        try {
            let dbConnection;
            let courses;

            // Creo un new MongoClient
            const client = new MongoClient(`${DB_URL}`);
            // Conecto el client al server
            await client.connect();
            // Establesco la conexión a la base de datos
            dbConnection = await client.db("node_graphql_course_db");
	    // Resuelvo con la dbConnection
            resolve(dbConnection);
        } catch (error) {
            reject(error);
        }
    });

   // Regreso la Promise que emplearé para conectar mi DB
    return connection;
}

module.exports = connectDB;

para los que trabajen con github, obviamente el archivo .env hay que ignorarlo, pero es bueno siempre tener un archivo .env.example donde copiar los nombres de las variables de entorno, para tener una guía o en el caso de que alguien vea el proyecto sepa de donde surgen esas variables. Mi archivo .env.example quedó así:

DB_USER=
DB_PASSWD=
DB_HOST=
DB_PORT=
DB_NAME

Saludos.

hasta acá llegue en el curso, muy regular.

Es bastante necesaria una actualizacion del curso

Para quién esté aprendiendo los patrones de diseño el modulo de DB que implementamos aquí es un singleton

Buenos dias profesor para poder conectarme a una base de dos de POSTGRESS ???

Para que puedan continuar con el curso

Es necesario registrarse desde mongo atlas igual y crear su base de datos igual , la url de conexión debería de hacer algo como esta

mongodb+srv://user:[email protected]/databasename?retryWrites=true&w=majority

Mongodb para node ya esta en desuso instalen mongoose
npm i mongoose

Y la función que deben usar para retornar la conexión es esta

async function connectDB() {
  await db
    .connect(mongoUrl, { useNewUrlParser: true, useUnifiedTopology: true })
    .then(() => console.log("[db] Conectada con éxito"))
    .catch(err => console.error("[db] Error", err));
}

module.exports = connectDB;

dos formas de conectarse a mongo Atlas o Compass: solo hay que el npm imongoose

'use strict'
// Using Node.js `require()`
const mongoose = require('mongoose');

const mongoUrl = `mongodb://localhost:27017/myappnode` //URL de mongocompass o cluster de mongo atlas

//lo que este aqui adentro lo vamos a exportar

/**first example conection */
module.exports = () => {
    const connect = ()=> {
        mongoose.connect(
            mongoUrl,
            {//objecto con configuracion
                keepAlive: true,
                useNewUrlParser: true,
                useUnifiedTopology: true
            },
            (err) => {
                if(err){
                    console.log('DB: ERROR !!')
                }else{
                    console.log('Conexion correcta')
                }
            }
        )
    }
    connect();  
/**Two example conection */
async function connectDB() {
    await mongoose.connect(mongoUrl, { useNewUrlParser: true, useUnifiedTopology: true})
        .then(() => {
            console.log('[database] conectada con exito')
        }).catch((e) => {
            console.error('Hubo un error al conectarse con la DB');
            console.error(e);
        });
}

module.exports = connectDB;

Solo de forma local

Si tienen docker instalado y no quieren crearse otra cuenta les puedo recomendar

  1. En la raíz de su proyecto le dan a crear archivo este se debe llamar docker-compose.yml

  2. Copien este contenido dentro

version: '3.7'
services:
  mongodb_container:
    image: mongo:latest
    environment:
      MONGO_INITDB_ROOT_USERNAME: root
      MONGO_INITDB_ROOT_PASSWORD: rootpassword
    ports:
      - 27017:27017
    volumes:
      - mongodb_data_container:/data/db

volumes:
  mongodb_data_container:

  1. En su terminal ir a donde este creado el nuevo archivo EJ:
C:\Users\Asus\platzi-courses\graphql\platzi-graphql
  1. Ejecutar el comando
docker-compose up -d

esto les va a generar una instancia docker con mongodb

  • Cadena de conexion: mongodb://localhost:27017/test
  • user: root
  • password: rootpassword
    La ventaja es que para otro proyecto pueden usar lo mismo y cuando dejen de usar solo van y borran el contenedor

Creo que un mejor nombre para la funcion podría ser getDbInstance, ya que solo debería hacer la conexion una vez y siempre devuelve la instancia de la conexion.

Nota: para la conexion de la base de datos el profesor está utilizando un patron llamado Singleton, que como menciona en la clase se usa para compartir una instancia de manera transversal en la aplicacion.

Para aquellos que esten presentando el error **MongoServerSelectionError: getaddrinfo ENOTFOUND **

Pueden seguir los siguientes pasos:

  1. Iniciar sesión en https://cloud.mongodb.com/
  2. Ir a tu cluster0 o el cluster que hayan configurado,
  3. Clic en connect… selecciona connect your application
  4. Seleciona node.js y versión 2.2.12 or later

Allí veras el string de conexión iniciando con mongodb://

Pienso que cada uno de nosotros puede encaminar este curso en una maravillosa practica, aborde el tema de la base de datos con una oracle para ver como lo implemento en mí organización

Wow, la clase anterior estuvo interesante, esta va a estar mucho mejor

Para los dockeristas, usuario: root, password: example, no es bueno usar esa clase de credenciales, pero como es un ambiente local puede resultar práctico.

version: '3'

services:
  db:
    image: mongo
    restart: always
    environment:
      MONGO_INITDB_ROOT_USERNAME: root
      MONGO_INITDB_ROOT_PASSWORD: example
    ports:
      - 27017:27017
    volumes:
      - mongodb_2:/data/db

volumes:
  mongodb_2:

Otra opcion para trabajar con mongo, es usar docker y docker-compose

Dockerfile

FROM mohitdhingra01/node15

WORKDIR /usr/path

COPY package.json .

RUN npm i

COPY . .

docker-compose.yml

version: '3'

services:
  db:
    image: mongo
    environment:
      MONGO_INITDB_ROOT_ADMINUSERNAME: root
      MONGO_INITDB_ROOT_ADMINPASSWORD: holahola
    ports:
      - 27017:27017
    volumes:
      - mongodb:/data/db
      - mongodb_conf:/data/configdb

  app:
    build:
      context: .
    depends_on:
      - db
    environment:
      db_url: mongodb://mongo:27017/courses
      port: 3000
    ports:
      - 3000:3000
    command: npm run dev

volumes:
  mongodb:
  mongodb_conf:

por que no se utiliza monngose?

Aca les dejo unos comandos para la instalacion de Mongo en WSL con Ubuntu

https://github.com/microsoft/WSL/issues/796

Muchachos les recomiendo seguir este video para la creacion del mongo atlas.

https://www.youtube.com/watch?v=_irNiugD180

En que parte encuentro mi host y el port?

Esta es una muy buena guia:
https://docs.mongodb.com/guides/

Hola buen día,
¿Es posible conectar GraphQL con una Base de Datos relacional?

Necesito ayuda, use la cedena de conexión que me da Atlas para conectar mi aplicacion

<h4>Cadena de conexion original de proporcionada por Atlas</h4>
mongodb+srv://AlanVazquez:<password>@cluster0-q7onz.mongodb.net/test?retryWrites=true&w=majority

Replace <password> with the password for the AlanVazquez user.
When entering your password, make sure that any special characters are URL encoded.

<h4>Conexion a DB</h4>
/* eslint-disable no-console */
const { MongoClient } = require('mongodb');

const {
  DB_USER,
  DB_PASSWORD,
  DB_CLUSTER,
  DB_NAME,
} = process.env;

const mongoUrl = `mongodb+srv://${DB_USER}:${DB_PASSWORD}@${DB_CLUSTER}.mongodb.net/${DB_NAME}?retryWrites=true&w=majority
`;
let connection;

async function connectDb() {
  if (connection) return connection;

  let client;

  try {
    client = await MongoClient.connect(mongoUrl, { useNewUrlParser: true });
    connection = client.db(DB_NAME);
  } catch (error) {
    console.error('No se pudo conectar a: ', mongoUrl, error);
    process.exit(1);
  }

  return connection;
}

module.exports = connectDb();

<h4>Shell</h4>
PS C:\Users\Alan Vazquez\OneDrive - Centro de Enseñanza Técnica Industrial\APLICACIONES\PERSONAL\NodeJS\GraphQL> node src/index
Server is lstening on
 localhost:3000/api
No se pudo conectar a:  mongodb+srv://AlanVazquez:{PASSWORD}@cluster0-q7onz.mongodb.net/prueba?retryWrites=true&w=majority
Error: querySrv ESERVFAIL _mongodb._tcp.cluster0-q7onz.mongodb.net
    at QueryReqWrap.onresolve [as oncomplete] (dns.js:203:19) {
  errno: 'ESERVFAIL',
  code: 'ESERVFAIL',
  syscall: 'querySrv',
  hostname: '_mongodb._tcp.cluster0-q7onz.mongodb.net'
}

No se si el problema sea de alguna configuracion de Atlas
Ya intente con:

  • Permitir accros a todas las IPs
  • Quitar el sring que esta despues del nombre de la Base de datos
  • Usar la Base de datos test
<h4>Nota</h4>
  Si me puedo conectar con la Cadema de conexion que me da para conexion desde el Shell

como debuggear y como realizar test?

Segun entendi, no es obligatorio realizar el proceso de mLab si tengo instalado MongoDB o me equivoco?

si quieren creen una cuenta en https://console.clever-cloud.com/ en donde pueden crear una base de datos mongo y listo.

DB_USER=udkxlpdonnmwuaoaxqjg
DB_PASSWORD=vIckFrnY0puDBQHh1PDQ
DB_HOST=bbctdlzykngllor-mongodb.services.clever-cloud.com
DB_PORT=27017
DB_NAME=bbctdlzykngllor

Para los que no quieran usar el ratón pueden crear los archivos desde la consola de vs :
1 crrl + j
2 touch .env o por el contrario touch lib/db.js
y listo de esta manera lo pueden hacer sin el ratón es más bacano

Cada cual usa la herramienta que quiere xD. Hace poco termine el curso de mongodb y ahi te piden crear una cuenta en Atlas y se usan mongodb shell y mongodb compass xD. Quien les entiende.

Me salio este error y no he podido conectarme alguien puede ayudarme

Esto es un patrón de Diseño conocido como singleton

Lo pueden hacer tambien con mongoose:
npm i mongoose

'use strict'
const db = require('mongoose');

const {
    DB_USER,
    DB_PASSWD,
    DB_NAME
} = process.env

const mongoURL = `mongodb+srv://${DB_USER}:${DB_PASSWD}@cluster0.zptt6.mongodb.net/${DB_NAME}?retryWrites=true&w=majority`;


async function connect() {

    await db.connect(mongoURL, {
        useUnifiedTopology: true,
        useNewUrlParser: true
    })
    console.log('[db] conectada con exito')
}


module.exports = connect

Usando mongo Atlas, al conectar con la DB, en la opción connect with native drivers, mongo te muestra la URL exacta y no hay que construirla a mano. (Se puede conectar la db con mongoose también)

conexión con mongoose:

'use strict'

const db = require('mongoose');

db.Promise = global.Promise;

async function connect(url){
    await db.connect(
        url,
        {
            useNewUrlParser: true,
            useUnifiedTopology: true, 
        }
    );
    console.log('[db] conectada con exito');
}

module.exports = connect;

como se la va a salir el gallo clauido al principio? 😝

Por las actualizaciones tanto de mongoDB y el uso de MongoDBAtlas, le scomparto el código que estoy utilizando para conectarme a Mongo

'use strict'

const { MongoClient } = require('mongodb');

// Variables de entorno
const {
    DB_USER = "platzi123",
    DB_PASSWORD= "oJqEhghO4uJ6thBO",
    DB_HOST = "cluster0.eke4y.mongodb.net",
    DB_NAME = "cursoGQL",
} = process.env;

const MONGO_HOST = `mongodb+srv://${DB_USER}:${DB_PASSWORD}@${DB_HOST}/${DB_NAME}?retryWrites=true&useUnifiedTopology=true&w=majority`;
let connection = null;

const ODBC = async () => {
    if (connection) return connection;
    await MongoClient.connect(MONGO_HOST, (error, client) => {
        if (error) {
            console.error(`Problemas para conectarnos a ${MONGO_HOST}`);
            console.error(error)
            process.exit(1);
        }
        connection = await client.db(DB_NAME);
    });
    return connection;
};

module.exports = ODBC;

hace tiempo genere una documentación sobre el manejo de MongoDBAltas y como se configura desde una Aplicación puede que les funcione

https://medium.com/@jmz12/mongodbatlas-y-javascript-9cc251013e8a

les dejo este link del curso de node js de Guillermo Rodas, donde se explica a detalle como conectarse con Robot3T y MongoDB Compass a una BD.

https://platzi.com/clases/1646-backend-nodejs/22034-conexion-con-robot3t-y-mongodb-compass-a-una-bd/