DEV Community: Bryan Elias Herrera

Escalado de aplicaciones Node.js con Redis

Bryan Elias Herrera — Sat, 05 Aug 2023 17:33:44 +0000

Redis, un almacén de datos en memoria, te permite escalar tu aplicación Node.js al brindar una forma ágil de almacenar datos en caché y manejar la mensajería pub/sub 📩. ¡Descubre cómo hacerlo en este post! 📘

1. Caché de datos 💽:

¿Quieres un acceso rápido 🚀 a datos frecuentemente usados? ¡El almacenamiento en caché es tu solución! Redis, con su alta velocidad ⚡ y bajo tiempo de respuesta, es perfecto para esta tarea. Aquí te mostramos cómo usar Redis con Node.js para almacenar datos:

const redis = require('redis');  
const client = redis.createClient();  

// Set data en el cache de redis
client.set('key', 'value', (err, result) => {  
  if (err) {  
    console.error(err);  
  } else {  
    console.log('Data cached successfully in Redis 🎉');  
  }  
});  

// Get data desde el cache de redis
client.get('key', (err, result) => {  
  if (err) {  
    console.error(err);  
  } else {  
    console.log(`Data from Redis: ${result} 🎈`);  
  }  
});

2. Mensajería Pub/Sub 📬:

Las aplicaciones en tiempo real 🕐, como chats 💬 y feeds en vivo 📺, requieren una excelente gestión de mensajes. Redis con su sistema pub/sub es ideal para esto. Mira cómo hacerlo:

const redis = require('redis');  
const client = redis.createClient();  

// Suscribirse a un canal Redis  
client.subscribe('channel');  

// Recibir Mensajes de un canal
client.on('message', (channel, message) => {  
  console.log(`From ${channel}: ${message} 💌`);  
});  

// Publicar un mensaje  
client.publish('channel', 'Hello World! 🌍');

3. Almacén de sesiones 🛒:

¿Quieres mantener la información de tus usuarios de manera eficiente? Usa Redis para guardar sesiones 👥. Aquí te mostramos cómo:

const express = require('express');  
const session = require('express-session');  
const redis = require('redis');  
const redisStore = require('connect-redis')(session);  
const client = redis.createClient();  

const app = express();  

// Usando redis para las sesiones
app.use(session({  
  store: new redisStore({ client }),  
  secret: 'your-secret-key',  
  resave: false,  
  saveUninitialized: true  
}));  

// Set & Get session data  
app.get('/', (req, res) => {  
  req.session.username = 'john';  
  res.send('Session data set 🌟');  
});  
app.get('/user', (req, res) => {  
  res.send(`Welcome back ${req.session.username}! 🎈`);  
});  
app.listen(3000, () => {  
  console.log('Server up and running 🚀');  
});

En resumen 📝:

Redis no sólo mejora la velocidad ⚡ y eficiencia de tu aplicación Node.js, sino que también abre un mundo 🌍 de posibilidades como colas de trabajo, limitaciones de velocidad y tablas de clasificación. Es, sin duda, un aliado esencial para toda aplicación Node.js que aspire a escalar.

🚀 Descifrando el Enigma de la Memoria en Programación con python

Bryan Elias Herrera — Sun, 02 Jul 2023 22:36:49 +0000

¡Hola de nuevo, amantes de la programación! 🎉

Hoy, vamos a adentrarnos en el fascinante mundo de la memoria en la programación. Te sorprendería cuánto podemos optimizar nuestros programas simplemente comprendiendo cómo funcionan las cosas bajo el capó.

La memoria en una computadora es donde se almacenan todos los datos mientras tu programa se está ejecutando. Cuando creas una variable en tu código, estás solicitando un pequeño espacio en la memoria para almacenar un valor.

Variables y Asignaciones

Comenzaremos con lo básico. Mira el siguiente código en Python:

a = 10
b = a

Aquí, cuando decimos a = 10, estamos almacenando el valor 10 en la memoria y a es básicamente una referencia a ese lugar en la memoria. Cuando decimos b = a, b ahora apunta al mismo lugar que a. Así que, si cambiamos el valor de a, b permanecerá como está, porque estamos creando un nuevo espacio en la memoria para el nuevo valor de a.

a = 20
print(a) # Imprime: 20
print(b) # Imprime: 10

Listas

Las cosas se ponen más interesantes con las estructuras de datos como las listas. Mira el siguiente código:

lista1 = [1, 2, 3, 4, 5]
lista2 = lista1

Aquí, lista1 y lista2 apuntan a la misma lista en la memoria. Así que, si cambias un elemento de lista1, ese cambio se verá reflejado en lista2 también.

lista1[0] = 10
print(lista1) # Imprime: [10, 2, 3, 4, 5]
print(lista2) # Imprime: [10, 2, 3, 4, 5]

Si quieres que lista2 sea una copia de lista1 pero no apunte al mismo objeto, necesitas crear una copia de la lista, lo cual puedes hacer con el método .copy() o cortando la lista ([:]).

lista2 = lista1.copy()
# o
lista2 = lista1[:]

Funciones y memoria

Cuando pasas una variable a una función, Python pasará ese valor, creando una nueva referencia a ese lugar en la memoria. Para variables simples como enteros o flotantes, esto no tiene mucho efecto. Pero para las listas, si modificas la lista dentro de la función, esos cambios se verán reflejados en la lista original.

def agregar_elemento(lista):
    lista.append(6)

lista1 = [1, 2, 3, 4, 5]
agregar_elemento(lista1)
print(lista1) # Imprime: [1, 2, 3, 4, 5, 6]

Entender cómo funciona la memoria puede ayudarte a escribir código más limpio y eficiente. Te permite prever cómo se comportarán tus variables y funciones, especialmente cuando trabajas con estructuras de datos más grandes. Recuerda, un buen programador no solo hace que las cosas funcionen, sino que también se esfuerza por hacer que su código sea fácil de leer y eficiente.

¡Hasta la próxima, y feliz codificación! 👩‍💻👨‍💻💻`

gRPC - Microservicios en Lenguajes Diferentes [JS y PY]

Bryan Elias Herrera — Sat, 24 Jun 2023 22:59:51 +0000

¡Hola, Jóvenes Coder! 🚀 ¿Listos para un nuevo viaje a través del emocionante mundo del desarrollo? Hoy, nos sumergiremos en gRPC, una tecnología muy poderosa para la comunicación entre servicios. Vamos a aprender qué es, cómo se aplica con Node.js y Python y cómo puede hacer que tu código sea más limpio y eficiente.

Si quieres ver un ejemplo de esta implementacion te recomeindo mi repositorio: python-javascript-backend-microservice

¿Qué es gRPC? 🤔

gRPC es un marco de comunicación remota de alto rendimiento desarrollado por Google. gRPC utiliza HTTP/2 para la transferencia de datos y Protocol Buffers (también conocido como Protobuf) como lenguaje de interfaz. Es ideal para aplicaciones de microservicios debido a su eficiencia y capacidad para generar clientes y servidores en una variedad de idiomas.

¿Cómo se ve gRPC? 👀

Imagina que tienes dos amigos 🤖🤖 en diferentes ciudades que necesitan comunicarse. Un amigo (llamémoslo NodeBot) vive en NodeCity y el otro (PythonBot) vive en PythonTown. Ambos hablan diferentes idiomas, pero necesitan compartir información entre ellos.

Para solucionar esto, gRPC actúa como un intérprete que les permite comunicarse de manera efectiva, sin importar en qué idioma estén hablando.

Configuración básica en Node.js y Python

1. Instalación de gRPC y Protobuf

En Node.js, instala gRPC usando npm:

npm install grpc @grpc/proto-loader

En Python, instala gRPC usando pip:

pip install grpcio grpcio-tools

2. Creando el archivo Protobuf

Supongamos que NodeBot y PythonBot quieren intercambiar un mensaje simple "Hola". Creamos un archivo Protobuf (.proto) para definir el servicio y el mensaje:

syntax = "proto3";

service BotService {
    rpc DecirHola (HolaRequest) returns (HolaResponse) {}
}

message HolaRequest {
    string nombre = 1;
}

message HolaResponse {
    string mensaje = 1;
}

3. Generando código a partir de .proto

En Node.js, puedes generar código dinámicamente en tiempo de ejecución:

const PROTO_PATH = './path/to/your/proto/file';
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const packageDefinition = protoLoader.loadSync(PROTO_PATH);
const botProto = grpc.loadPackageDefinition(packageDefinition).botpackage;

En Python, debes generar el código usando grpcio-tools antes de ejecutar el script:

python -m grpc_tools.protoc -I./ --python_out=./ --grpc_python_out=./ ./path/to/your/proto/file

4. Creando el servidor y el cliente

En Node.js, para el servidor:

const server = new grpc.Server();
server.addService(botProto.BotService.service, { DecirHola: decirHola });
server.bind('0.0.0.0:50051', grpc.ServerCredentials.createInsecure());
server.start();

Para el cliente:

const client = new botProto.BotService('localhost:50051', grpc.credentials.createInsecure());
client.DecirHola({ nombre: 'NodeBot' }, (error, response) => {
    console.log(response.mensaje);
});

En Python, para el servidor:

from concurrent import futures
import grpc

import bot_pb2
import bot_pb2_grpc

class BotServiceServicer(bot_pb2_grpc.BotServiceServicer):
    def DecirHola(self, request, context):
        return bot_pb2.HolaResponse(mensaje='¡Hola, {}!'.format(request.nombre))

server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
bot_pb2_grpc.add_BotServiceServicer_to_server(BotServiceServicer(), server)
server.add_insecure_port('[::]:50051')
server.start()

Para el cliente:

import grpc

import bot_pb2
import bot_pb2_grpc

channel = grpc.insecure_channel('localhost:50051')
stub = bot_pb2_grpc.BotServiceStub(channel)
response = stub.DecirHola(bot_pb2.HolaRequest(nombre='PythonBot'))
print(response.mensaje)

Conclusión 😎

gRPC es una forma poderosa de hacer que los servicios en diferentes lenguajes se comuniquen entre sí de manera eficiente. A través de la definición de Protocol Buffers y el uso de HTTP/2, gRPC permite que los servicios de gran escala se comuniquen sin problemas.

Asegúrate de explorar más sobre gRPC y sus características, como los streams y la autenticación. Recuerda, sigue codificando, sigue aprendiendo y sigue construyendo! 🚀💻

¿Cómo arreglar el CallBack Hell en JavaScript?

Bryan Elias Herrera — Sun, 18 Jun 2023 20:39:15 +0000

¡Hola! 🚀 Si has estado programando en JavaScript y te has encontrado con el famoso "Callback Hell", ¡no te preocupes! Estamos aquí para ayudarte a entender cómo puedes resolverlo y hacer que tu código sea más limpio y mantenible.

¿Qué es el Callback Hell? 💀

En JavaScript, a veces anidamos callbacks dentro de callbacks, lo que puede llevar a un código difícil de leer y mantener. Esto se conoce como Callback Hell. ¡Pero no temas! Hay formas de lidiar con esto.

¿Cómo se ve el Callback Hell? 🤔

Un ejemplo típico de Callback Hell se vería así:

hacerAlgo(function(resultado) {
    hacerAlgoMas(resultado, function(nuevoResultado) {
        hacerAlgoAunMas(nuevoResultado, function(resultadoFinal) {
            console.log('Terminamos con:', resultadoFinal);
        }, manejoError);
    }, manejoError);
}, manejoError);

Como puedes ver, este código es difícil de leer y entender.

Solución 1: Modularización

Una forma sencilla de lidiar con el Callback Hell es dividir tu código en funciones más pequeñas y reutilizables. En lugar de tener un gran bloque de código, podrías tener algo así:

function mostrarResultadoFinal(resultadoFinal) {
    console.log('Terminamos con:', resultadoFinal);
}

function hacerAlgoAunMasCallback(nuevoResultado) {
    hacerAlgoAunMas(nuevoResultado, mostrarResultadoFinal, manejoError);
}

function hacerAlgoMasCallback(resultado) {
    hacerAlgoMas(resultado, hacerAlgoAunMasCallback, manejoError);
}

hacerAlgo(hacerAlgoMasCallback, manejoError);

Solución 2: Promesas

Las Promesas son una característica incorporada en JavaScript que nos permite manejar operaciones asíncronas de manera más elegante. Aquí te dejo el mismo ejemplo anterior, pero usando Promesas:

hacerAlgo()
    .then(resultado => hacerAlgoMas(resultado))
    .then(nuevoResultado => hacerAlgoAunMas(nuevoResultado))
    .then(resultadoFinal => {
        console.log('Terminamos con:', resultadoFinal);
    })
    .catch(manejoError);

Solución 3: Async/Await

Finalmente, JavaScript introdujo la sintaxis async/await, que nos permite escribir código asíncrono que parece sincrónico. Mira cómo el código anterior se simplifica aún más con async/await:

async function realizarTareas() {
    try {
        const resultado = await hacerAlgo();
        const nuevoResultado = await hacerAlgoMas(resultado);
        const resultadoFinal = await hacerAlgoAunMas(nuevoResultado);
        console.log('Terminamos con:', resultadoFinal);
    } catch (error) {
        manejoError(error);
    }
}

realizarTareas();

Conclusión 🧏‍♂️

El Callback Hell puede ser intimidante al principio, pero hay varias soluciones para evitar caer en él. Ya sea que elijas la modularización, las Promesas o async/await, el objetivo es hacer que tu código sea más legible y fácil de mantener. Recuerda que lo más importante es que tu código sea claro para ti y para los demás. ¡Sigue experimentando y mejorando tus habilidades de codificación! 🚀💻

La locura de los Callbacks en javascript [JS]

Bryan Elias Herrera — Sun, 11 Jun 2023 02:59:19 +0000

¡Hola! Joven Padawan 🚀. Acompáñame a entender uno de los conceptos mas confusos cuando inicias en el mundo de Javascript. Los Callbacks 🤓. Si eres un joven programador, este post es para ti.

¿Qué es un Callback? 🤔

Un callback en JavaScript es una función que se pasa como argumento a otra función. Es una forma de asegurar que ciertas partes del código no se ejecutan hasta que otras partes ya se han completado.

¿Cómo se ve un Callback? 👁️

Imagina que tienes un amigo robot 🤖 que está aprendiendo a hacer un sandwich. Podrías darle las instrucciones paso a paso de la siguiente manera:

function hacerSandwich() {
    conseguirPan();
    agregarRelleno();
    servir();
}

Estas funciones se ejecutan una después de la otra, pero, ¿qué pasaría si conseguirPan() toma mucho tiempo? Tal vez el robot comenzaría a agregarRelleno() incluso antes de tener el pan, lo que resultaría en un desastre en la cocina 🤡. Yo no quiero un sandwich que no tenga pan.

Para evitar esto, puedes decirle al robot que solo empiece a agregarRelleno() después de que conseguirPan() se haya completado, utilizando un callback.

function conseguirPan(callback) {
    // Imagina que este proceso toma algún tiempo
    console.log('Consiguiendo el pan...');

    // Después de que se haya conseguido el pan
    callback();
}

function hacerSandwich() {
    conseguirPan(function() {
        agregarRelleno();
        servir();
    });
}

Ahora, el robot solo comenzará a agregarRelleno() después de que conseguirPan() se haya completado gracias a la función callback 🥪.

Un Ejemplo de la Vida Real 👌

Poniendonos mas serios veamos un ejemplo de la vida real. Imagina que tienes una aplicación para manejar una tienda en línea 🛒. Un usuario puede hacer clic en un botón para comprar un producto, pero no quieres que se le cobre hasta que hayas comprobado que el producto está en stock.

function revisarInventario(callback) {
    // Comprobar el inventario podría llevar algún tiempo
    console.log('Revisando inventario...');

    // Después de comprobar el inventario
    callback();
}

function comprarProducto() {
    revisarInventario(function() {
        cobrarAlUsuario();
        enviarProducto();
    });
}

En este ejemplo, cobrarAlUsuario() y enviarProducto() solo se ejecutan después de que revisarInventario() se haya completado.

Conclusión 🧏‍♂️

Los callbacks en JavaScript son una herramienta esencial para controlar el flujo de nuestras operaciones, especialmente cuando hay procesos que pueden tomar tiempo para completarse. Como vimos en nuestros ejemplos, desde un robot haciendo un sandwich hasta el manejo de un inventario de tienda en línea, los callbacks nos permiten asegurar que ciertas partes de nuestro código no se ejecuten hasta que otras hayan terminado.

Pero recuerda, mientras que los callbacks pueden ser increíblemente útiles, a veces pueden resultar en lo que se llama "callback hell" - un montón de funciones anidadas que son difíciles de leer y mantener. Por eso, aunque son una parte fundamental de JavaScript, es importante conocer otras formas de manejar el código asíncrono, como las Promesas y async/await.

Por último, nunca olvides que el objetivo es escribir código que sea fácil de leer y mantener. A medida que ganas experiencia, aprenderás cuándo y dónde usar cada herramienta. ¡Sigue codificando, sigue aprendiendo y sigue construyendo! 💻🚀