Microsoft Orleans #08: Implementación de Microservicios

En esta clase aprenderemos cómo usar Orleans en una arquitectura de microservicios, integrándolo con APIs REST en ASP.NET Core para exponer los Granos Orleans como servicios accesibles externamente.

Objetivos de la Clase

• Comprender cómo Orleans se integra en una arquitectura de microservicios.
• Exponer Granos Orleans a través de APIs REST en ASP.NET Core.
• Implementar una API que utiliza Granos Orleans como backend.
• Probar la comunicación entre la API y Orleans.

¿Cómo Orleans se Adapta a los Microservicios?

Orleans permite construir backends escalables dentro de una arquitectura de microservicios, ya que:

• Cada Grano actúa como un microservicio con estado y lógica propia.
• Orleans maneja la concurrencia y escalabilidad, ideal para entornos distribuidos.
• La API REST sirve como puerta de entrada, permitiendo a clientes externos acceder a los Granos Orleans.

Flujo de trabajo en una arquitectura con Orleans y ASP.NET Core

1. Un cliente (Web, Mobile, otro servicio) realiza una petición a la API REST.
2. La API REST se comunica con Orleans llamando a los Granos.
3. Los Granos procesan la solicitud y devuelven la respuesta a la API.
4. La API REST responde al cliente con el resultado.

Configurar Orleans en ASP.NET Core

1. Crear un Nuevo Proyecto ASP.NET Core

Ejecuta en la terminal:

dotnet new webapi -n OrleansApi
cd OrleansApi
dotnet add package Microsoft.Orleans.AspNetCore

Esto crea un proyecto ASP.NET Core Web API e instala Orleans en él.

2. Configurar Orleans en Program.cs

Edita Program.cs en OrleansApi y agrega:

using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using Orleans;
using Orleans.Hosting;

var builder = WebApplication.CreateBuilder(args);

builder.Host.UseOrleans(siloBuilder =>
{
    siloBuilder.UseLocalhostClustering();
});

builder.Services.AddControllers();
var app = builder.Build();

app.MapControllers();
app.Run();

Explicación del Código

• UseOrleans(...): Inicia un Silo Orleans dentro de la API.
• AddControllers(): Agrega soporte para controladores REST.
• app.MapControllers(): Habilita rutas para la API.

Implementar Granos en la API

1. Definir la Interfaz del Grano

Crea IUsuarioGrain.cs en la carpeta Granos:

using System.Threading.Tasks;
using Orleans;

public interface IUsuarioGrain : IGrainWithStringKey
{
    Task SetNombre(string nombre);
    Task<string> GetNombre();
}

2. Implementar el Grano

Crea UsuarioGrain.cs en Granos:

using System.Threading.Tasks;
using Orleans;

public class UsuarioGrain : Grain, IUsuarioGrain
{
    private string _nombre = "Desconocido";

    public Task SetNombre(string nombre)
    {
        _nombre = nombre;
        return Task.CompletedTask;
    }

    public Task<string> GetNombre()
    {
        return Task.FromResult(_nombre);
    }
}

Crear un Controlador REST en ASP.NET Core

1. Crear UsuarioController.cs en Controllers

using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Orleans;

[ApiController]
[Route("api/usuarios")]
public class UsuarioController : ControllerBase
{
    private readonly IGrainFactory _grainFactory;

    public UsuarioController(IGrainFactory grainFactory)
    {
        _grainFactory = grainFactory;
    }

    [HttpPost("{id}/nombre")]
    public async Task<IActionResult> SetNombre(string id, [FromBody] string nombre)
    {
        var usuarioGrain = _grainFactory.GetGrain<IUsuarioGrain>(id);
        await usuarioGrain.SetNombre(nombre);
        return Ok("Nombre actualizado");
    }

    [HttpGet("{id}/nombre")]
    public async Task<IActionResult> GetNombre(string id)
    {
        var usuarioGrain = _grainFactory.GetGrain<IUsuarioGrain>(id);
        var nombre = await usuarioGrain.GetNombre();
        return Ok(nombre);
    }
}

Explicación del Código

• IGrainFactory: Permite acceder a los Granos desde la API.
• SetNombre(): Llama al Grano y actualiza el nombre.
• GetNombre(): Llama al Grano y obtiene el nombre almacenado.

Probar la API REST con Orleans

1. Iniciar la API

Ejecuta:

dotnet run

Debería mostrar un mensaje indicando que la API se ejecuta en http://localhost:5000.

2. Probar con Postman o cURL

a) Guardar un nombre en Orleans

curl -X POST "http://localhost:5000/api/usuarios/user123/nombre" -H "Content-Type: application/json" -d "\"Carlos\""

Salida esperada:

"Nombre actualizado"

b) Obtener el nombre desde Orleans

curl -X GET "http://localhost:5000/api/usuarios/user123/nombre"

Salida esperada:

"Carlos"

Cuestionario de Autoevaluación

1. ¿Cómo Orleans puede integrarse en una arquitectura de microservicios?
2. ¿Qué función cumple ASP.NET Core en una API basada en Orleans?
3. ¿Cómo un controlador REST accede a un Grano Orleans?
4. ¿Por qué Orleans es útil en un sistema distribuido basado en microservicios?
5. ¿Qué sucede si la API REST se reinicia? ¿Se pierden los datos almacenados en Orleans?

Resumen de la Clase

• Orleans permite construir microservicios escalables gestionando la concurrencia automáticamente.
• ASP.NET Core se usa como puerta de entrada, permitiendo a clientes externos llamar a los Granos.
• Implementamos una API REST que se comunica con Granos Orleans.
• Probamos la API con cURL y Postman, verificando que los datos persisten correctamente.

Próxima Clase: Despliegue de Orleans en Producción (Docker, Kubernetes, Azure)

En la siguiente clase, aprenderemos cómo desplegar Orleans en entornos de producción, usando Docker, Kubernetes y Azure para alta disponibilidad.