Orleans Tableau de bord

Le Orleans tableau de bord est un outil de supervision web intégré qui offre une visibilité en temps réel sur votre Orleans cluster. Il vous permet de surveiller l’intégrité du silo, les activations des grains, les appels de méthode, les rappels et les métriques du système sans nécessiter d’infrastructure de surveillance externe.

Pour Orleans 10.0, utilisez les packages de tableau de bord officiels : Microsoft.Orleans.Dashboard et Microsoft.Orleans.Dashboard.Abstractions.

Important

Cette fonctionnalité est disponible à partir de Orleans la version 10.0. Il est actuellement en préversion et peut changer dans les versions ultérieures.

Fonctionnalités

Le Orleans tableau de bord fournit les fonctionnalités suivantes :

Vue d’ensemble du cluster : affichez tous les silos du cluster avec leur état, leur temps d’activité et leur utilisation des ressources.
Surveillance des grains : suivez les activations de grain, les appels de méthode et les métriques de performances par type de grain.
Profilage des méthodes : analyser la fréquence des appels de méthode de grain, la latence et les taux d’erreur.
Gestion des rappels : parcourez et surveillez tous les rappels inscrits sur le cluster.
Diffusion en continu des journaux en direct : affichez la sortie du journal en temps réel à partir du cluster.
Détails du silo : inspectez les propriétés, compteurs et distributions de grain individuelles.
Inspection de l’état du grain : affichez l’état actuel des instances de grain individuelles.

Installation

Le Orleans tableau de bord est distribué dans deux packages NuGet :

Package	Descriptif
Microsoft.Orleans.Tableau de bord	Package de tableau de bord principal avec des points de terminaison d’interface utilisateur et d’API
Microsoft.Orleans.Dashboard.Abstractions	Abstractions pour l’intégration du tableau de bord (par exemple, `NoProfilingAttribute`)

Configuration de base

Pour ajouter le Orleans tableau de bord à votre application, appelez AddDashboard() sur votre générateur de silo et configurez les points de terminaison du tableau de bord avec MapOrleansDashboard() :

using Orleans.Dashboard;

var builder = WebApplication.CreateBuilder(args);

// Configure Orleans with the dashboard
builder.UseOrleans(siloBuilder =>
{
    siloBuilder.UseLocalhostClustering();
    siloBuilder.AddMemoryGrainStorageAsDefault();

    // Add the dashboard services
    siloBuilder.AddDashboard();
});

var app = builder.Build();

// Map dashboard endpoints at the root path
app.MapOrleansDashboard();

app.Run();

Après avoir démarré votre application, accédez à http://localhost:5000/ (ou votre URL configurée) pour accéder au tableau de bord.

Préfixe d’itinéraire personnalisé

Vous pouvez héberger le tableau de bord sur un chemin personnalisé en spécifiant un préfixe d’itinéraire :

// Map dashboard endpoints at /dashboard
app.MapOrleansDashboard(routePrefix: "/dashboard");

Avec cette configuration, accédez au tableau de bord à l’adresse http://localhost:5000/dashboard/.

Paramétrage

Options du tableau de bord

Configurer le comportement du tableau de bord à l’aide de DashboardOptions:

siloBuilder.AddDashboard(options =>
{
    // Disable the live log streaming endpoint
    options.HideTrace = true;

    // Set the counter update interval (minimum 1000ms)
    options.CounterUpdateIntervalMs = 2000;

    // Set the history buffer length for metrics
    options.HistoryLength = 200;
});

Choix	Type	Par défaut	Descriptif
`HideTrace`	`bool`	`false`	Quand `true`, désactive le point de terminaison de diffusion en continu du journal en direct.
`CounterUpdateIntervalMs`	`int`	`1000`	Milliseconds entre les échantillons de compteur. Doit être >= 1 000.
`HistoryLength`	`int`	`100`	Nombre de points de données historiques à conserver pour les métriques.

Options du profileur de grain

Le profileur de grain collecte les données de performances au niveau de la méthode. Configurez-le à l’aide de GrainProfilerOptions:

builder.Services.Configure<GrainProfilerOptions>(options =>
{
    // Always collect profiling data, even when dashboard is inactive
    options.TraceAlways = true;

    // Time after which profiling stops if dashboard is inactive
    options.DeactivationTime = TimeSpan.FromMinutes(5);
});

Choix	Type	Par défaut	Descriptif
`TraceAlways`	`bool`	`false`	Quand `true`, les données de profilage sont collectées en permanence même lorsque le tableau de bord n’est pas interrogé.
`DeactivationTime`	TimeSpan	Une minute	Durée de l’inactivité après laquelle le profilage s’arrête automatiquement. S’applique uniquement quand `TraceAlways` est `false`.

Exclusion des grains du profilage

Utilisez l’attribut [NoProfiling] pour exclure des grains spécifiques du profilage des performances :

using Orleans.Dashboard;

[NoProfiling]
public class HighFrequencyGrain : Grain, IHighFrequencyGrain
{
    // This grain won't be included in profiling data
}

Modèles de déploiement

Hébergement conjoint avec silo (recommandé)

Le modèle de déploiement le plus simple consiste à héberger le tableau de bord directement avec votre Orleans silo. Il s’agit de l’approche recommandée pour la plupart des scénarios :

using Orleans.Dashboard;

var builder = WebApplication.CreateBuilder(args);

builder.UseOrleans(siloBuilder =>
{
    siloBuilder.UseLocalhostClustering();
    siloBuilder.UseInMemoryReminderService();
    siloBuilder.AddMemoryGrainStorageAsDefault();
    siloBuilder.AddDashboard();
});

var app = builder.Build();

app.MapOrleansDashboard();

app.Run();

Hôte de tableau de bord distinct

Pour les scénarios où vous souhaitez exécuter le tableau de bord séparément de vos silos (par exemple, pour fournir un point de terminaison de supervision dédié), vous pouvez héberger le tableau de bord sur un Orleans client :

using Orleans.Configuration;
using Orleans.Dashboard;
using System.Net;

// Start the silo host
var siloHostBuilder = Host.CreateApplicationBuilder(args);
siloHostBuilder.UseOrleans(builder =>
{
    builder.UseDevelopmentClustering(options => 
        options.PrimarySiloEndpoint = new IPEndPoint(IPAddress.Loopback, 11111));
    builder.UseInMemoryReminderService();
    builder.AddMemoryGrainStorageAsDefault();
    builder.ConfigureEndpoints(IPAddress.Loopback, 11111, 30000);

    // Dashboard must also be added to silos
    builder.AddDashboard();
});
using var siloHost = siloHostBuilder.Build();
await siloHost.StartAsync();

// Create a separate web application for the dashboard
var dashboardBuilder = WebApplication.CreateBuilder(args);

// Configure Orleans client
dashboardBuilder.UseOrleansClient(clientBuilder =>
{
    clientBuilder.UseStaticClustering(options => 
        options.Gateways.Add(new IPEndPoint(IPAddress.Loopback, 30000).ToGatewayUri()));

    // Add dashboard services to the client
    clientBuilder.AddDashboard();
});

var dashboardApp = dashboardBuilder.Build();

// Map dashboard endpoints on the client
dashboardApp.MapOrleansDashboard();

await dashboardApp.RunAsync();

await siloHost.StopAsync();

Important

Lorsque vous utilisez un hôte de tableau de bord distinct, vous devez toujours appeler AddDashboard() dans le créateur de silo. Les silos ont besoin des services de tableau de bord pour collecter et fournir des données de métriques.

Authorization

Les points de terminaison du tableau de bord prennent en charge l'autorisation ASP.NET Core. Utilisez la méthode d’extension RequireAuthorization() pour protéger l’accès :

// Require authentication for dashboard access
app.MapOrleansDashboard()
   .RequireAuthorization();

Vous pouvez également appliquer des stratégies d’autorisation spécifiques :

// Configure authorization
builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("DashboardAccess", policy =>
        policy.RequireRole("Admin", "Operator"));
});

builder.Services.AddAuthentication(/* your auth configuration */);

var app = builder.Build();

app.UseAuthentication();
app.UseAuthorization();

// Apply the policy to dashboard endpoints
app.MapOrleansDashboard()
   .RequireAuthorization("DashboardAccess");

Résolution des problèmes

Le tableau de bord affiche le message « connectivité perdue »

Cette erreur se produit lorsque le tableau de bord ne peut pas communiquer avec le Orleans cluster. Causes courantes :

Silo n’a pas démarré : vérifiez que votre Orleans silo est en cours d’exécution avant d’accéder au tableau de bord.
Problèmes réseau : vérifiez la connectivité réseau entre l’hôte du tableau de bord et les silos.
Configuration incorrecte du cluster : vérifiez que le clustering est correctement configuré.

Données de profilage qui n’apparaissent pas

Si les données de profilage des méthodes de granulométrie sont vides :

Effectuer des appels de grain : le profilage affiche uniquement les données après l’appel des méthodes de grain.
Vérifier TraceAlways: par défaut, le profilage s’arrête après 1 minute d’inactivité du tableau de bord. Définir TraceAlways = true pour le profilage continu.
Vérifier [NoProfiling]: vérifiez que le grain n’est pas marqué avec l’attribut [NoProfiling] .

Le point de terminaison de trace dynamique est désactivé

Si l'endpoint /Trace retourne 403 Interdit :

Vérifiez que DashboardOptions.HideTrace n’est pas défini sur true.

Voir aussi

Le Orleans tableau de bord est un outil de supervision intégré introduit dans Orleans la version 10.0. Pour Orleans 9.0, 8.0 et 7.0, utilisez le package de tableau de bord de la communauté non officiel :

OrléansSDashboard (communauté) : package de tableau de bord géré par la communauté pour les Orleans versions antérieures à 10.0.
Intégration d’OpenTelemetry : les fonctionnalités d’observabilité intégrées sont disponibles dans Orleans la version 7.0 et ultérieures. Voir Observabilité en Orleans.

Le Orleans tableau de bord est un outil de supervision intégré introduit dans Orleans la version 10.0. Pour Orleans la version 3.x, utilisez le package de tableau de bord de la communauté non officiel :

OrléansSDashboard (communauté) : package de tableau de bord géré par la communauté pour les Orleans versions antérieures à 10.0.

Rétroaction

Cette page a-t-elle été utile ?

Last updated on 2026-02-24