Conexión y Configuración de Microservicios de Bases de Datos Remotas

Curso de Node.js: Autenticación, Microservicios y Redis

Contenido del curso

Introducción al proyecto del curso y su arquitectura

Creando la estructura principal

Autenticación basada en tokens

Almacenando datos: MySql

Microservicios en Node

Puesta en producción serverless

Cacheando nuestra aplicación

Puesta en producción en virtual machine

28
Instalación y Configuración de Microservicios en Máquinas Virtuales
07:45 min
29
Configuración de Nginx como proxy para microservicios en producción
06:40 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0012:04

Conexión y Configuración de Microservicios de Bases de Datos Remotas

Curso de Node.js: Autenticación, Microservicios y Redis

Clase 20 de 29

Clase 20 / 29

Recursos

¿Cómo crear un archivo para una base de datos remota?

Para empezar, es crucial crear un sistema que sea lo más genérico y reutilizable posible para poder conectar diferentes bases de datos a través de microservicios. Esto nos permitirá no exponer la base de datos directamente, manteniendo así la seguridad y modularidad del sistema.

¿Qué es un constructor de base de datos remotas?

La clave está en desarrollar un "constructor de base de datos remotas" que nos permita generar nuestra base de datos de manera remota y utilizarla con las mismas funciones, sin necesidad de modificar nuestro código continuamente. Este patrón es escalable y nos permite trabajar con múltiples bases de datos o microservicios.

¿Cómo configurar la base de datos remota?

Primero, debemos asegurarnos de que tenemos nuestra base de datos bien configurada y abierta para seguir trabajando con ella. Seguidamente:

Crear un archivo, por ejemplo, Remote.js, para gestionar la conexión remota.
Importar un módulo llamado request para simplificar las peticiones HTTP.
```
const request = require('request');
```
Definir la URL base que usaremos para hacer las peticiones HTTP al microservicio:
```
const baseURL = `${host}:${port}`;
```

¿Cómo implementar las funciones de acceso remoto?

Implementar funciones que manejen las operaciones comunes de la base de datos, como listar, agregar, modificar, y eliminar datos.

Función para listar datos:

function list(table) {
    return requestPromise('GET', table);
}

Función para manejar peticiones:

function requestPromise(method, table) {
    const url = `${baseURL}/${table}`;
    return new Promise((resolve, reject) => {
        request({ method: method, url: url, json: true },
        (error, response, body) => {
            if (error) {
                console.error('Error:', error);
                return reject(error);
            }
            resolve(body);
        });
    });
}

¿Cómo conectar y probar nuestra API?

Finalmente, integrémoslo al componente de usuarios para verificar su correcto funcionamiento:

En el index del componente, importa y utiliza Remote.js:

const remote = require('./remote');
// Verificar funcionalidad de listar usuarios
remote.list('users').then(data => console.log(data));

Ejecutar los servicios con nodemon para facilitar el desarrollo en ambos terminales:
```
nodemon mysql/index.js
nodemon api/index.js
```

¿Notas cómo la abstracción nos permite trabajar a nivel de API sin preocuparnos por detalles de implementación de base de datos? Este modelo no solo simplifica el manejo de bases de datos múltiples, sino que también mejora la escalabilidad y seguridad de tu aplicación al encapsular y aislar cada servicio individualmente.

Recuerda, la modularidad y reutilización son principios fundamentales cuando trabajamos en proyectos de software a gran escala. ¡Aprende, experimenta y sigue creciendo en el mundo del desarrollo!

Andrés Muñoz

Hace 4 años

Excelente clase muchas gracias a toda la gente de platzi !! remote.js

const axios = require('axios');

function CreateRemoteDataBaseApi (host, port) {
  const remoteDataBaseCall = axios.create({
    baseURL: `${host}:${port}`,
    headers: {
      'Content-Type': 'application/json',
      'Accept': 'application/json'
    }
  })

  async function request({method, url, data}) {
    const reponse = await remoteDataBaseCall({
      method: method,
      url: url,
      data: data
    });
    return reponse.data.body;
  }

  function list(table) {
    return request({
      method: 'GET',
      url: `/${table}`,
    })
  }

  function get(tabla, id) {
    return request({
      method: 'GET',
      url: `/${tabla}/${id}`,
    })
  }

  function query(tabla, query, join = '') {
    return request({
      method: 'GET',
      url: `/query/${tabla}`,
      data: {
        "query": query,
        "join": join
      }
    })
  }

  function create(table, data) {
    return request({
      method: 'POST',
      url: `/${table}`,
      data
    })
  }

  function update(table, data_id, data) {
    throw new Error('Not implemented');
  }

  async function upsert(tabla, data) {
    return request({
      method: 'PUT',
      url: `upsert/${tabla}`,
      data
    })
  }

  async function remove(tabla, id) {
    return request({
      method: 'DELETE',
      url: `/${tabla}/${id}`
    })
  }

  return {
    list,
    get,
    query,
    create,
    update,
    upsert,
    remove,
  };
}

module.exports = CreateRemoteDataBaseApi;

Mauricio Parada G

Hace 4 años

Simplemente algo más nuevo ES6+ con try y catch y imports más normales para 2022

import axios from 'axios';

function createRemoteDB(host, port) {
  const URL = `${host}:${port}`;

  async function list(table) {
    try {
      const response = await axios.get(`${URL}/${table}`);
      console.log(response);
      return response.data.body;
    } catch (e) {
      console.error("list ->", e);
      return [];
    }
  }

  return {
    list,
  };
}

export { createRemoteDB };

Comentarios (33)33 comentarios

Jesús Rubén Esparza Soto

Hace 6 años

Bryan Estiven Silva Mercado

Hace 5 años

Wilson Fernando Antury Torres

Yilmer Ramiro Guativa Rincón

Ramón José París González

Byron Mesias Cueva Cabrera

Hace 7 años

Tomas Goldenberg

Alonso Fabricio Samanez Nuñez

José Armando Gutiérrez Araujo

Sergio Andres Villagran

Francisco Garcia [C6]

Jose Luis Rodriguez

José Pach Delgado

RUBÉN HERNÁNDEZ PUERTA

Eduardo Guarnizo

Luis Andrade

Alver Alexander Grisales Ortega

Eric Rodríguez Gallegos

alberto ayala rodriguez

Matias Niz

Carlos Hernández

Profesor

Andres FR

Naldo Duran

Armando Rivera

Angel Bulnes

Mario Alberto Chico Sanchez

Hace 3 años

Emilio Sala

Hace un año

Juan Hurtado

Introducción al proyecto del curso y su arquitectura

Creación de Backend Complejo con Microservicios y Arquitectura Escalable

Modelado de Datos para una Red Social Básica en SQL

Creando la estructura principal

Configuración de un Servidor API con Express y Node.js

Estructuración de API y Gestión de Datos en JavaScript

Controladores con Inyección de Dependencias en Node.js

Documentación de APIs con Swagger en Node.js

Autenticación basada en tokens

Autenticación y Seguridad con Tokens JWT en Aplicaciones Web

Autenticación de Usuarios con JWT y Gestión de Contraseñas Seguras

Implementación de Login Seguro con JWT y Cifrado de Contraseñas

Cifrado de Contraseñas con Bcrypt en Aplicaciones Node.js

Autenticación y Autorización con JWT en Node.js

Implementación de Autenticación y Autorización en Aplicaciones Web

Manejo de Errores y Seguridad en Aplicaciones Node.js

Almacenando datos: MySql

Almacenamiento de Datos con MySQL en Node.js

Funciones CRUD en Base de Datos con Node.js

Creación de Tabla Intermedia para Relaciones de Seguimiento de Usuarios

Gestión de Seguidores y Publicaciones en Redes Sociales

Microservicios en Node

Arquitectura de Microservicios: Separación y Gestión Eficiente

Creación de Microservicios para Bases de Datos con Node.js

Conexión y Configuración de Microservicios de Bases de Datos Remotas

Separación Horizontal de Microservicios: Implementación y Beneficios

Gestión de Microservicios en Producción con PM2

Puesta en producción serverless

Despliegue de Aplicaciones Serverless con Vercel y AWS

Variables de Entorno y Despliegue Local con Node.js

Cacheando nuestra aplicación

Implementación de Caché con Redis para Microservicios

Conexión de Microservicios a Redis y Gestión de Caché

Cacheo y Optimización de Consultas en Microservicios

Puesta en producción en virtual machine

Instalación y Configuración de Microservicios en Máquinas Virtuales

Configuración de Nginx como proxy para microservicios en producción

Conexión y Configuración de Microservicios de Bases de Datos Remotas