Sdílet prostřednictvím


Odstupňované služby

Služby zajisťující zrno jsou vzdáleně přístupné a dělené služby pro podporu funkce zrno. Každá instance služby pro obsluhu grainů je zodpovědná za určitou skupinu grainů. Tato zrnka mohou získat odkaz na obilnou službu, která je v současné době zodpovědná za jejich servis pomocí GrainServiceClient.

Existují služby pro obsluhu zrn, které mají podporovat případy, kdy by se odpovědnost za obsluhu zrn měla distribuovat po clusteru Orleans. Připomenutí se například Orleans implementují pomocí služeb Grain: každé silo zpracovává operace připomenutí pro podmnožinu zrn a upozorní je, když se jejich připomenutí aktivují.

Nakonfigurujete služby zpracování zrní na silech. Inicializují se především při spuštění sila, před dokončením jeho inicializace. Neshromažďují se při nečinnosti; naopak, jejich délka životnosti se prodlužuje po dobu, po kterou existuje samotné silo.

Vytvořit obilnou službu

A GrainService je speciální jednotka: nemá žádnou stabilní identitu a funguje ve všech silech od spuštění do vypnutí. IGrainService Implementace rozhraní zahrnuje několik kroků.

  1. Definujte komunikační rozhraní odstupňované služby. Sestavte rozhraní GrainService pomocí stejných principů, které používáte k vytvoření rozhraní zrna.

    public interface IDataService : IGrainService
    {
        Task MyMethod();
    }
    
  2. Vytvořte odstupňovanou DataService službu. Je užitečné vědět, že můžete také vložit IGrainFactory, abyste mohli provádět grainové volání ze svého GrainService.

    [Reentrant]
    public class DataService : GrainService, IDataService
    {
        readonly IGrainFactory _grainFactory;
    
        public DataService(
            IServiceProvider services,
            GrainId id,
            Silo silo,
            ILoggerFactory loggerFactory,
            IGrainFactory grainFactory)
            : base(id, silo, loggerFactory)
        {
            _grainFactory = grainFactory;
        }
    
        public override Task Init(IServiceProvider serviceProvider) =>
            base.Init(serviceProvider);
    
        public override Task Start() => base.Start();
    
        public override Task Stop() => base.Stop();
    
        public Task MyMethod()
        {
            // TODO: custom logic here.
            return Task.CompletedTask;
        }
    }
    
    [Reentrant]
    public class DataService : GrainService, IDataService
    {
        readonly IGrainFactory _grainFactory;
    
        public DataService(
            IServiceProvider services,
            IGrainIdentity id,
            Silo silo,
            ILoggerFactory loggerFactory,
            IGrainFactory grainFactory)
            : base(id, silo, loggerFactory)
        {
            _grainFactory = grainFactory;
        }
    
        public override Task Init(IServiceProvider serviceProvider) =>
            base.Init(serviceProvider);
    
        public override Task Start() => base.Start();
    
        public override Task Stop() => base.Stop();
    
        public Task MyMethod()
        {
            // TODO: custom logic here.
            return Task.CompletedTask;
        }
    }
    
  3. Vytvořte rozhraní pro ostatní GrainServiceClient<TGrainService>GrainServiceClient zrnka, které se budou používat pro připojení k objektu GrainService.

    public interface IDataServiceClient : IGrainServiceClient<IDataService>, IDataService
    {
    }
    
  4. Vytvořte klienta odstupňované služby. Klienti obvykle fungují jako zástupci služeb, které jsou cílem, takže obvykle přidáte odpovídající metodu pro každou metodu v cílové službě. Tyto metody musí získat odkaz na cílovou grain službu, aby do ní mohly volat. Základní GrainServiceClient<T> třída poskytuje několik přetížení metody GetGrainService, které mohou vracet odkaz na zrno odpovídající GrainId, číselné hash (uint) nebo SiloAddress. Druhá dvě přetížení jsou určena pro pokročilé případy, kdy chcete použít jiný mechanismus k přiřazení odpovědnosti hostitelům nebo k přímému adresování hostitele. Ve vzorovém kódu níže definujeme vlastnost, GrainService, která vrátí IDataService pro grain, který volá DataServiceClient. K tomu použijeme GetGrainService(GrainId) přetížení ve spojení s CurrentGrainReference vlastností.

    public class DataServiceClient : GrainServiceClient<IDataService>, IDataServiceClient
    {
        public DataServiceClient(IServiceProvider serviceProvider)
            : base(serviceProvider)
        {
        }
    
        // For convenience when implementing methods, you can define a property which gets the IDataService
        // corresponding to the grain which is calling the DataServiceClient.
        private IDataService GrainService => GetGrainService(CurrentGrainReference.GrainId);
    
        public Task MyMethod() => GrainService.MyMethod();
    }
    
  5. Vložte klienta služby zrnitosti do ostatních zrn, která ho potřebují. Není zaručeno, že GrainServiceClient bude mít přístup k místnímu silu GrainService. Váš příkaz může být potenciálně odeslán do libovolného GrainService sil v clusteru.

    public class MyNormalGrain: Grain<NormalGrainState>, INormalGrain
    {
        readonly IDataServiceClient _dataServiceClient;
    
        public MyNormalGrain(
            IGrainActivationContext grainActivationContext,
            IDataServiceClient dataServiceClient) =>
                _dataServiceClient = dataServiceClient;
    }
    
  6. Nakonfigurujte klienta služby agregační a odstupňované služby v silu. Musíte to udělat, aby silo spustilo GrainService.

    (ISiloHostBuilder builder) =>
        builder.ConfigureServices(
            services => services.AddGrainService<DataService>()
                                .AddSingleton<IDataServiceClient, DataServiceClient>());
    

Další poznámky

Existuje metoda rozšíření, GrainServicesSiloBuilderExtensions.AddGrainService, která se používá k registraci služeb grain.

services.AddSingleton<IGrainService>(
    serviceProvider => GrainServiceFactory(grainServiceType, serviceProvider));

Silo načte IGrainService typy od poskytovatele služeb při spuštění (viz orleans/src/Orleans.Runtime/Silo/Silo.cs):

var grainServices = this.Services.GetServices<IGrainService>();

MicrosoftOrleans by měl projekt odkazovat.

Microsoft .Orleans. Na balíček NuGet OrleansRuntime by měl projekt odkazovat GrainService .

Aby to fungovalo, musíte zaregistrovat službu i jeho klienta. Kód vypadá přibližně takto:

var builder = new HostBuilder()
    .UseOrleans(c =>
    {
        c.AddGrainService<DataService>()  // Register GrainService
        .ConfigureServices(services =>
        {
            // Register Client of GrainService
            services.AddSingleton<IDataServiceClient, DataServiceClient>();
        });
    })