Microsoft Orleans #10: Testing y Monitoreo

En esta clase aprenderemos cómo realizar pruebas unitarias en Orleans y monitorear el estado de los Granos y Silos en tiempo real.

Objetivos de la Clase

• Comprender cómo realizar pruebas unitarias en Granos Orleans.
• Implementar pruebas de integración con Orleans.
• Configurar Orleans Dashboard para monitorear el estado del sistema.
• Integrar logs y métricas para obtener visibilidad del rendimiento de Orleans.

Testing en Orleans

Las pruebas en Orleans deben considerar que los Granos se activan dinámicamente y su estado puede ser persistente. Existen dos enfoques principales:

1. Pruebas unitarias con Orleans.TestingHost: Permiten probar un Grano en un ambiente controlado.
2. Pruebas de integración con un Silo en memoria: Simulan un entorno Orleans real.

1. Instalar Dependencias

Ejecuta en OrleansDemo.Tests:

dotnet add package Microsoft.Orleans.TestingHost
dotnet add package xunit
dotnet add package Moq

2. Crear una Prueba Unitaria para un Grano

Crea CounterGrainTests.cs en OrleansDemo.Tests:

using System;
using System.Threading.Tasks;
using Orleans;
using Orleans.TestingHost;
using Xunit;

public class CounterGrainTests : IClassFixture<TestClusterFixture>
{
    private readonly TestCluster _cluster;

    public CounterGrainTests(TestClusterFixture fixture)
    {
        _cluster = fixture.Cluster;
    }

    [Fact]
    public async Task CounterGrain_Increment_ShouldIncreaseValue()
    {
        var grain = _cluster.GrainFactory.GetGrain<ICounterGrain>(Guid.NewGuid());

        await grain.Increment();
        int value = await grain.GetValue();

        Assert.Equal(1, value);
    }
}

Explicación del Código

• Se usa TestClusterFixture para simular un Silo Orleans en memoria.
• Se obtiene un Grano CounterGrain y se prueba que el valor se incremente correctamente.
• Se usa xUnit para ejecutar la prueba.

3. Configurar un Silo en Memoria para Pruebas

Crea TestClusterFixture.cs en OrleansDemo.Tests:

using Orleans.TestingHost;
using Xunit;

public class TestClusterFixture : IDisposable
{
    public TestCluster Cluster { get; }

    public TestClusterFixture()
    {
        var builder = new TestClusterBuilder();
        Cluster = builder.Build();
        Cluster.Deploy();
    }

    public void Dispose()
    {
        Cluster.StopAllSilos();
    }
}

Esto inicia un Silo Orleans en memoria para ejecutar pruebas sin necesidad de una base de datos o infraestructura externa.

4. Ejecutar las Pruebas

Ejecuta en la terminal:

dotnet test

Si todo funciona correctamente, las pruebas deberían pasar sin errores.

Monitoreo con Orleans Dashboard

Orleans incluye Orleans Dashboard, una herramienta que permite ver el estado de los Granos y Silos en una interfaz web.

1. Instalar Orleans Dashboard

Ejecuta en OrleansDemo:

dotnet add package OrleansDashboard

2. Configurar Orleans Dashboard en Program.cs

Edita Program.cs en OrleansDemo:

using OrleansDashboard;

builder.UseOrleans(siloBuilder =>
{
    siloBuilder.UseLocalhostClustering();
    siloBuilder.UseDashboard(options => { options.Port = 8081; });
});

3. Iniciar Orleans Dashboard

Ejecuta el Silo Orleans y accede a http://localhost:8081 para ver:

• Número de Granos activos.
• Métricas de rendimiento.
• Estado del Clúster Orleans.

Integración de Logs y Métricas

Para monitorear Orleans en producción, es recomendable integrar:

• Serilog para logs estructurados.
• Prometheus y Grafana para métricas avanzadas.

1. Instalar Serilog

Ejecuta en OrleansDemo:

dotnet add package Serilog.AspNetCore
dotnet add package Serilog.Sinks.Console

2. Configurar Serilog en Program.cs

using Serilog;

Log.Logger = new LoggerConfiguration()
    .WriteTo.Console()
    .CreateLogger();

builder.Host.UseSerilog();

Esto permitirá visualizar logs Orleans en la consola del servidor.

3. Configurar Métricas con Prometheus

Ejecuta en OrleansDemo:

dotnet add package Prometheus.Client.AspNetCore

Edita Program.cs:

using Prometheus;

app.UseHttpMetrics();
app.MapMetrics();

Ejecuta:

curl http://localhost:5000/metrics

Esto devolverá métricas Orleans en formato Prometheus, listas para ser analizadas en Grafana.

Cuestionario de Autoevaluación

1. ¿Cuál es la diferencia entre una prueba unitaria y una prueba de integración en Orleans?
2. ¿Qué función cumple TestClusterFixture en las pruebas de Orleans?
3. ¿Cómo Orleans Dashboard ayuda a monitorear el estado de un sistema Orleans?
4. ¿Por qué es útil usar Serilog y Prometheus en Orleans?
5. ¿Cómo ejecutar Orleans Dashboard y qué información muestra?

Resumen de la Clase

• Implementamos pruebas unitarias e integración en Orleans con Orleans.TestingHost.
• Configuramos Orleans Dashboard para visualizar el estado de los Granos y Silos.
• Integramos logs estructurados con Serilog.
• Configuramos métricas con Prometheus para monitorear Orleans en producción.

Próxima Clase: Uso de Transacciones

En la siguiente clase, aprenderemos cómo gestionar transacciones en Orleans, asegurando consistencia de datos en Granos.