Conectando el microservicio a Redis

No recuerdo otro curso en que se hayan visto tantos temas en el desarrollo del proyecto y tan bien explicados.

Muy curiosos como se tomaron la molestia de editar el video para cubrir la contraseña y otros datos de acceso y luego los dejan expuestos en el código XD

Para los que estamos viendo este curso en 2022, les dejo la forma en la que el codigo me funciono, al parecer redis ha cambiado mucho desde que se realizo este video

NOTA: tuve que crear un usuario y un rol en el portal de redis porque no supe como fabricar el url con el usuario por defecto

const client = redis.createClient({
  // host: config.cacheService.dbHost,
  // port: config.cacheService.dbPort,
  // password: config.cacheService.dbPass
  url: `redis://${config.cacheService.dbUser}:${config.cacheService.dbPass}@${config.cacheService.dbHost}:${config.cacheService.dbPort}`
});

(async () => {
  await client.connect();
  console.log('Conectado a REDIS');
})();

export default {
  async list(table) {
    const value = await client.get(table);
    return JSON.parse(value);
  },

  async get(table, id) {
    const value = await client.get(`${table}_${id}`);
    return JSON.parse(value);
  },

  async upsert(table, data) {
    let key = table;
    if (data && data.id) {
      key += '_' + data.id;
    }
    await client.set(key, JSON.stringify(data));
    return true;
  }
};

Lo que vamos hacer es traer data de mysql, guardarla en redis. Pero cada vez que mi API solicite data, primero revisa en redis, si está allí la trae, si no entonces va y la trae de mysql. Estoy bien?

A alguien más le esta saliendo este error a la hora de generar el redis client?

Ready check failed: NOAUTH Authentication required

la gran incertidumbre que siempre tuve es: que pasa si tengo una base de 20 millones de clientes… todos los 20 millones tengo que traerlos al redis?? la memoria tendra suficiente espacio para almacenar tanta data?

En el metodo list, en caso de existir data, no deberia ser JSON.parse(data) en lugar de de stringify?, es decir, si lo que esta almacenado es una cadena de texto, no deberiamos convertir esa cadena a json al retornarlo?

const redis = require('redis');

const config = require('../config');

const client = redis.createClient({
    host: config.redis.host,
    port: config.redis.port,
    password: config.redis.password,
});

function list(table) {
    return new Promise( (resolve, reject) => {
        client.get(table, (err, data) => {
            if (err) return reject(err);

            let res = data || null
            if (res)
                res = JSON.stringify(res);
            
            resolve(res);
        })
    })
}

function get(table, id) {
    const search = `${table}_${id}`;
    returnlist(search);
}

function upsert(table, data, action) {
    action = action || 'insert'
    let key = table;
    if (action !== 'insert')
        key = key + '_' + data.id;
    
    client.setex(key,10, JSON.stringify(data));
    return true;
}


module.exports = {
    list,
    get,
    upsert,
};```

Reto resuelto:

const redis = require('redis');
const config = require('../config');

const client = redis.createClient({
    host: config.redis.host,
    port: config.redis.port,
    password: config.redis.password
});

function list(table) {
    return new Promise((resolve, reject) => {
        client.get(table, (error, result) => {
            if(error) return Promise.reject(error);
            const resp = JSON.parse(result);
            resolve(resp);
        })
    }); 
}

function get(table, id) {
    const key = `${table}_${id}`;
    return list(key);
}

async function upsert(table, data) {
    let key = table;
    if(data && data.id) {
        key += `_${data.id}`;
    }
    client.setex(key, 60, JSON.stringify(data));
    return true;
}

module.exports = {
    list,
    get,
    upsert
};

Excelente ejercicio

Creo que en la función list, si nos llega la data de Redis deberíamos usar:

JSON.parse(data)

Para convertir el JSON a un objeto (estoy suponiendo que Redis nos envía la información en a formato JSON)

Tip util para node:

Con el módulo Util de Node podemos convertir una función con callbacks en una promesa.

const { promisify } = require("util");
const getAsync = promisify(client.get).bind(client);

getAsync.then(console.log).catch(console.error);

O también podemos implementar async await.

✌

Boooom! Muy buena esta clase! 😄

Alguien sabe de alguna herramienta gratuita o plugin para Webstorm (por ejemplo) para visualizar tus datos de la DB Redis?

Tengo un projecto en una maquina virtual ubuntu y pues no estoy usando ese redislab sino que me instale la plataforma de Redis y pues le Cambie el password (requirepass) del archivo /etc/redis/redis.conf teniendo en cuenta un tutorial de un blog de digitalOcean, asi mismo hago ese archivo de configuracion del client en node como esta clase o que le hago de diferencia?

No sabía que en un solo proyecto se podían usar bases de datos relacionales y no relacionales al mismo tiempo (de distintas formas claro), es genial este curso.