El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

RPC y RMI

Siguiente ►
►

Introducción

En los sistemas distribuidos, la comunicación entre diferentes componentes es crucial. Dos de los métodos más comunes para facilitar esta comunicación son RPC (Remote Procedure Call) y RMI (Remote Method Invocation). Ambos permiten que un programa ejecute procedimientos o métodos en otro espacio de direcciones, ya sea en la misma máquina o en una máquina remota.

Conceptos Básicos

RPC (Remote Procedure Call)

RPC es un protocolo que permite a un programa ejecutar una función o procedimiento en otra máquina como si fuera una llamada local. La idea principal es ocultar la complejidad de la comunicación en red, proporcionando una interfaz simple para el desarrollador.

Características de RPC:

  • Transparencia: El desarrollador no necesita preocuparse por los detalles de la red.
  • Sincronización: La llamada RPC es generalmente sincrónica, lo que significa que el cliente espera a que el servidor complete la operación.
  • Interoperabilidad: Puede ser utilizado entre diferentes sistemas operativos y lenguajes de programación.

RMI (Remote Method Invocation)

RMI es una implementación específica de RPC para el lenguaje de programación Java. Permite que un objeto en una máquina virtual Java invoque métodos en un objeto en otra máquina virtual Java.

Características de RMI:

  • Orientado a objetos: A diferencia de RPC, que se basa en procedimientos, RMI se basa en la invocación de métodos de objetos.
  • Transparencia: Similar a RPC, RMI oculta la complejidad de la comunicación en red.
  • Java-centric: Diseñado específicamente para aplicaciones Java, lo que facilita la integración con otras tecnologías Java.

Ejemplo Práctico de RPC

A continuación, se presenta un ejemplo básico de cómo implementar RPC utilizando Python y el módulo xmlrpc.

Servidor RPC en Python

from xmlrpc.server import SimpleXMLRPCServer

def add(x, y):
    return x + y

server = SimpleXMLRPCServer(("localhost", 8000))
print("Listening on port 8000...")
server.register_function(add, "add")
server.serve_forever()

Cliente RPC en Python

import xmlrpc.client

proxy = xmlrpc.client.ServerProxy("http://localhost:8000/")
result = proxy.add(5, 3)
print("5 + 3 =", result)

Explicación:

  • Servidor: Define una función add que suma dos números. Luego, crea un servidor RPC que escucha en el puerto 8000 y registra la función add.
  • Cliente: Crea un proxy para el servidor RPC y llama a la función add de manera remota.

Ejemplo Práctico de RMI

A continuación, se presenta un ejemplo básico de cómo implementar RMI en Java.

Servidor RMI en Java

import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;

public interface Calculator extends Remote {
    int add(int x, int y) throws RemoteException;
}

public class CalculatorImpl extends UnicastRemoteObject implements Calculator {
    protected CalculatorImpl() throws RemoteException {
        super();
    }

    public int add(int x, int y) throws RemoteException {
        return x + y;
    }

    public static void main(String[] args) {
        try {
            CalculatorImpl obj = new CalculatorImpl();
            Registry registry = LocateRegistry.createRegistry(1099);
            registry.bind("Calculator", obj);
            System.out.println("Calculator bound in registry");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Cliente RMI en Java

import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;

public class Client {
    public static void main(String[] args) {
        try {
            Registry registry = LocateRegistry.getRegistry("localhost");
            Calculator stub = (Calculator) registry.lookup("Calculator");
            int result = stub.add(5, 3);
            System.out.println("5 + 3 = " + result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Explicación:

  • Servidor: Define una interfaz Calculator que extiende Remote y declara el método add. La clase CalculatorImpl implementa esta interfaz. El servidor crea una instancia de CalculatorImpl y la registra en el registro RMI.
  • Cliente: Busca el objeto remoto en el registro RMI y llama al método add de manera remota.

Ejercicios Prácticos

Ejercicio 1: Implementar un Servidor y Cliente RPC

Tarea: Implementa un servidor y un cliente RPC en Python que realicen operaciones básicas de multiplicación y división.

Solución:

Servidor RPC en Python

from xmlrpc.server import SimpleXMLRPCServer

def multiply(x, y):
    return x * y

def divide(x, y):
    if y == 0:
        return "Error: Division by zero"
    return x / y

server = SimpleXMLRPCServer(("localhost", 8000))
print("Listening on port 8000...")
server.register_function(multiply, "multiply")
server.register_function(divide, "divide")
server.serve_forever()

Cliente RPC en Python

import xmlrpc.client

proxy = xmlrpc.client.ServerProxy("http://localhost:8000/")
result_multiply = proxy.multiply(5, 3)
result_divide = proxy.divide(10, 2)
print("5 * 3 =", result_multiply)
print("10 / 2 =", result_divide)

Ejercicio 2: Implementar un Servidor y Cliente RMI

Tarea: Implementa un servidor y un cliente RMI en Java que realicen operaciones básicas de resta y multiplicación.

Solución:

Servidor RMI en Java

import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;

public interface Calculator extends Remote {
    int subtract(int x, int y) throws RemoteException;
    int multiply(int x, int y) throws RemoteException;
}

public class CalculatorImpl extends UnicastRemoteObject implements Calculator {
    protected CalculatorImpl() throws RemoteException {
        super();
    }

    public int subtract(int x, int y) throws RemoteException {
        return x - y;
    }

    public int multiply(int x, int y) throws RemoteException {
        return x * y;
    }

    public static void main(String[] args) {
        try {
            CalculatorImpl obj = new CalculatorImpl();
            Registry registry = LocateRegistry.createRegistry(1099);
            registry.bind("Calculator", obj);
            System.out.println("Calculator bound in registry");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Cliente RMI en Java

import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;

public class Client {
    public static void main(String[] args) {
        try {
            Registry registry = LocateRegistry.getRegistry("localhost");
            Calculator stub = (Calculator) registry.lookup("Calculator");
            int result_subtract = stub.subtract(10, 5);
            int result_multiply = stub.multiply(5, 3);
            System.out.println("10 - 5 = " + result_subtract);
            System.out.println("5 * 3 = " + result_multiply);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Conclusión

En esta sección, hemos explorado los conceptos básicos de RPC y RMI, dos métodos esenciales para la comunicación en sistemas distribuidos. Hemos visto ejemplos prácticos de cómo implementar servidores y clientes utilizando ambos métodos y hemos proporcionado ejercicios para reforzar el aprendizaje. Con estos conocimientos, estarás mejor preparado para diseñar y desarrollar sistemas distribuidos eficientes y robustos.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados