Enrutamiento de requests a través de Load Balancer

¿Qué son los balanceadores de carga?

En caso de que haya varios servidores presentes, la solicitud entrante que llega al sistema debe dirigirse a uno de los múltiples servidores. Debemos asegurarnos de que cada servidor reciba la misma cantidad de requests. Las requests deben distribuirse de manera uniforme en todos los servidores. El componente que se encarga de distribuir estas requests entrantes de manera uniforme entre los servidores se conoce como Load Balancer . Un Load Balancer actúa como una capa entre las requests entrantes provenientes del usuario y los múltiples servidores presentes en el sistema.

Deberíamos evitar los escenarios en los que un solo servidor recibe la mayoría de las requests mientras que el resto está inactivo. Existen varios algoritmos de equilibrio de carga que garantizan una distribución uniforme de las requests entre los servidores.

Enfoque hash para requests directas desde Load Balancer

Discutiremos el enfoque Hashing para dirigir las requests a múltiples servidores de manera uniforme.

Supongamos que tenemos server_count como el número total de servidores presentes en el sistema y un load_balancer para distribuir las requests entre esos servidores. Una solicitud con una identificación request_id ingresa al sistema. Antes de llegar al servidor de destino, se dirige a load_balancer desde donde se dirige a su servidor de destino.

Cuando la solicitud llega al equilibrador de carga, el método hash nos proporcionará el servidor de destino al que se dirigirá la solicitud.

Discutiendo el enfoque:

• request_id : ID de solicitud que se va a atender
• hash_func : función hash distribuida uniformemente
• hash_id : ID de solicitud con hash
• server_count : Número de servidores

class GFG {
    public static int hash_func(int request_id)
    {
        // Computing the hash request id
        int hashed_id = 112;
        return hashed_id;
    }
  
    public static void route_request_to_server(int dest_server)
    {
        System.out.println("Routing request to the Server ID : " + dest_server);
    }
  
    public static int request_id = 23; // Incoming Request ID
    public static int server_count = 10; // Total Number of Servers
  
    public static void main(String args[])
    {
        int hashed_id = hash_func(request_id); // Hashing the incoming request id
        int dest_server = hashed_id % server_count; // Computing the destination server id
  
        route_request_to_server(dest_server);
    }
}

Cálculo de la dirección del servidor de destino:

Si el valor de server_count es 10, es decir, tenemos diez servidores con los siguientes ID de servidor server_id_0, server_id_1, ………, server_id_9 .

Supongamos que el valor de request_id es 23

Cuando esta solicitud llega al Load Balancer, la función hash hash_func calcula el valor de la identificación de la solicitud entrante.

• hash_func(solicitud_d) = hash_func(23)

Supongamos que después de Hashing, el request_id se convierte aleatoriamente en un valor particular.

• hash_id = 112

Para llevar la identificación hash en el rango de la cantidad de servidores, podemos realizar un módulo de la identificación hash con el recuento de servidores.

• dest_server = hash_id % server_count
• servidor_destino = 112%10
• servidor_destino = 2

Entonces podemos enrutar esta solicitud al servidor server_id_2

De esta manera podemos distribuir todas las requests que llegan a nuestro Load Balancer de manera uniforme a todos los servidores. Pero, ¿es un enfoque óptimo? Sí, distribuye las requests de manera uniforme, pero ¿qué pasa si necesitamos aumentar la cantidad de nuestros servidores? Aumentar el servidor cambiará los servidores de destino de todas las requests entrantes. ¿Qué pasaría si estuviéramos almacenando el caché relacionado con esa solicitud en su servidor de destino? Ahora que esa solicitud ya no se enruta al servidor anterior, es probable que todo nuestro caché vaya a la basura. Pensar !