Akka.Remote.Hosting 1.5.0-beta3

Prefix Reserved
This is a prerelease version of Akka.Remote.Hosting.
There is a newer version of this package available.
See the version list below for details.
dotnet add package Akka.Remote.Hosting --version 1.5.0-beta3                
NuGet\Install-Package Akka.Remote.Hosting -Version 1.5.0-beta3                
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package.
<PackageReference Include="Akka.Remote.Hosting" Version="1.5.0-beta3" />                
For projects that support PackageReference, copy this XML node into the project file to reference the package.
paket add Akka.Remote.Hosting --version 1.5.0-beta3                
#r "nuget: Akka.Remote.Hosting, 1.5.0-beta3"                
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package.
// Install Akka.Remote.Hosting as a Cake Addin
#addin nuget:?package=Akka.Remote.Hosting&version=1.5.0-beta3&prerelease

// Install Akka.Remote.Hosting as a Cake Tool
#tool nuget:?package=Akka.Remote.Hosting&version=1.5.0-beta3&prerelease                

Akka.Hosting

This package is now stable.

HOCON-less configuration, application lifecycle management, ActorSystem startup, and actor instantiation for Akka.NET.

Supported Packages

Consists of the following packages:

  1. Akka.Hosting - the core Akka.Hosting package, needed for everything
  2. Akka.Remote.Hosting - enables Akka.Remote configuration. Documentation can be read here
  3. Akka.Cluster.Hosting - used for Akka.Cluster, Akka.Cluster.Sharding, and Akka.Cluster.Tools. Documentation can be read here
  4. Akka.Persistence.Hosting - used for adding persistence functionality to perform local database-less testing. Documentation can be read here
  5. Akka.Persistence.SqlServer.Hosting - used for Akka.Persistence.SqlServer support. Documentation can be read here
  6. Akka.Persistence.PostgreSql.Hosting - used for Akka.Persistence.PostgreSql support. Documentation can be read here
  7. Akka.Persistence.Azure.Hosting - used for Akka.Persistence.Azure support. Documentation can be read here
  8. Akka.HealthCheck - Embed health check functionality for environments such as Kubernetes, ASP.NET, AWS, Azure, Pivotal Cloud Foundry, and more. Documentation can be read here
  9. The Akka.Management Project Repository - useful tools for managing Akka.NET clusters running inside containerized or cloud based environment. Akka.Hosting is embedded in each of its packages:

See the "Introduction to Akka.Hosting - HOCONless, "Pit of Success" Akka.NET Runtime and Configuration" video for a walkthrough of the library and how it can save you a tremendous amount of time and trouble.

Summary

We want to make Akka.NET something that can be instantiated more typically per the patterns often used with the Microsoft.Extensions.Hosting APIs that are common throughout .NET.

using Akka.Hosting;
using Akka.Actor;
using Akka.Actor.Dsl;
using Akka.Cluster.Hosting;
using Akka.Remote.Hosting;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddAkka("MyActorSystem", configurationBuilder =>
{
    configurationBuilder
        .WithRemoting("localhost", 8110)
        .WithClustering(new ClusterOptions(){ Roles = new[]{ "myRole" },
            SeedNodes = new[]{ Address.Parse("akka.tcp://MyActorSystem@localhost:8110")}})
        .WithActors((system, registry) =>
    {
        var echo = system.ActorOf(act =>
        {
            act.ReceiveAny((o, context) =>
            {
                context.Sender.Tell($"{context.Self} rcv {o}");
            });
        }, "echo");
        registry.TryRegister<Echo>(echo); // register for DI
    });
});

var app = builder.Build();

app.MapGet("/", async (context) =>
{
    var echo = context.RequestServices.GetRequiredService<ActorRegistry>().Get<Echo>();
    var body = await echo.Ask<string>(context.TraceIdentifier, context.RequestAborted).ConfigureAwait(false);
    await context.Response.WriteAsync(body);
});

app.Run();

No HOCON. Automatically runs all Akka.NET application lifecycle best practices behind the scene. Automatically binds the ActorSystem and the ActorRegistry, another new 1.5 feature, to the IServiceCollection so they can be safely consumed via both actors and non-Akka.NET parts of users' .NET applications.

This should be open to extension in other child plugins, such as Akka.Persistence.SqlServer:

builder.Services.AddAkka("MyActorSystem", configurationBuilder =>
{
    configurationBuilder
        .WithRemoting("localhost", 8110)
        .WithClustering(new ClusterOptions()
        {
            Roles = new[] { "myRole" },
            SeedNodes = new[] { Address.Parse("akka.tcp://MyActorSystem@localhost:8110") }
        })
        .WithSqlServerPersistence(builder.Configuration.GetConnectionString("sqlServerLocal"))
        .WithShardRegion<UserActionsEntity>("userActions", s => UserActionsEntity.Props(s),
            new UserMessageExtractor(),
            new ShardOptions(){ StateStoreMode = StateStoreMode.DData, Role = "myRole"})
        .WithActors((system, registry) =>
        {
            var userActionsShard = registry.Get<UserActionsEntity>();
            var indexer = system.ActorOf(Props.Create(() => new Indexer(userActionsShard)), "index");
            registry.TryRegister<Index>(indexer); // register for DI
        });
})

Dependency Injection Outside and Inside Akka.NET

One of the other design goals of Akka.Hosting is to make the dependency injection experience with Akka.NET as seamless as any other .NET technology. We accomplish this through two new APIs:

  • The ActorRegistry, a DI container that is designed to be populated with Types for keys and IActorRefs for values, just like the IServiceCollection does for ASP.NET services.
  • The IRequiredActor<TKey> - you can place this type the constructor of any DI'd resource and it will automatically resolve a reference to the actor stored inside the ActorRegistry with TKey. This is how we inject actors into ASP.NET, SignalR, gRPC, and other Akka.NET actors!

N.B. The ActorRegistry and the ActorSystem are automatically registered with the IServiceCollection / IServiceProvider associated with your application.

Registering Actors with the ActorRegistry

As part of Akka.Hosting, we need to provide a means of making it easy to pass around top-level IActorRefs via dependency injection both within the ActorSystem and outside of it.

The ActorRegistry will fulfill this role through a set of generic, typed methods that make storage and retrieval of long-lived IActorRefs easy and coherent:

  • Fetch ActorRegistry from ActorSystem manually
var registry = ActorRegistry.For(myActorSystem); 
  • Provided by the actor builder
builder.Services.AddAkka("MyActorSystem", configurationBuilder =>
{
    configurationBuilder
        .WithActors((system, actorRegistry) =>
        {
            var actor = system.ActorOf(Props.Create(() => new MyActor));
            actorRegistry.TryRegister<MyActor>(actor); // register actor for DI
        });
});
  • Obtaining the IActorRef manually
var registry = ActorRegistry.For(myActorSystem); 
registry.Get<Index>(); // use in DI

Injecting Actors with IRequiredActor<TKey>

Suppose we have a class that depends on having a reference to a top-level actor, a router, a ShardRegion, or perhaps a ClusterSingleton (common types of actors that often interface with non-Akka.NET parts of a .NET application):

public sealed class MyConsumer
{
    private readonly IActorRef _actor;

    public MyConsumer(IRequiredActor<MyActorType> actor)
    {
        _actor = actor.ActorRef;
    }

    public async Task<string> Say(string word)
    {
        return await _actor.Ask<string>(word, TimeSpan.FromSeconds(3));
    }
}

The IRequiredActor<MyActorType> will cause the Microsoft.Extensions.DependencyInjection mechanism to resolve MyActorType from the ActorRegistry and inject it into the IRequired<Actor<MyActorType> instance passed into MyConsumer.

The IRequiredActor<TActor> exposes a single property:

public interface IRequiredActor<TActor>
{
    /// <summary>
    /// The underlying actor resolved via <see cref="ActorRegistry"/> using the given <see cref="TActor"/> key.
    /// </summary>
    IActorRef ActorRef { get; }
}

By default, you can automatically resolve any actors registered with the ActorRegistry without having to declare anything special on your IServiceCollection:

using var host = new HostBuilder()
  .ConfigureServices(services =>
  {
      services.AddAkka("MySys", (builder, provider) =>
      {
          builder.WithActors((system, registry) =>
          {
              var actor = system.ActorOf(Props.Create(() => new MyActorType()), "myactor");
              registry.Register<MyActorType>(actor);
          });
      });
      services.AddScoped<MyConsumer>();
  })
  .Build();
  await host.StartAsync();

Adding your actor and your type key into the ActorRegistry is sufficient - no additional DI registration is required to access the IRequiredActor<TActor> for that type.

Resolving IRequiredActor<TKey> within Akka.NET

Akka.NET does not use dependency injection to start actors by default primarily because actor lifetime is unbounded by default - this means reasoning about the scope of injected dependencies isn't trivial. ASP.NET, by contrast, is trivial: all HTTP requests are request-scoped and all web socket connections are connection-scoped - these are objects have bounded and typically short lifetimes.

Therefore, users have to explicitly signal when they want to use Microsoft.Extensions.DependencyInjection via the IDependencyResolver interface in Akka.DependencyInjection - which is easy to do in most of the Akka.Hosting APIs for starting actors:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddScoped<IReplyGenerator, DefaultReplyGenerator>();
builder.Services.AddAkka("MyActorSystem", configurationBuilder =>
{
    configurationBuilder
        .WithRemoting(hostname: "localhost", port: 8110)
        .WithClustering(new ClusterOptions{SeedNodes = new []{ "akka.tcp://MyActorSystem@localhost:8110", }})
        .WithShardRegion<Echo>(
            typeName: "myRegion",
            entityPropsFactory: (_, _, resolver) =>
            {
                // uses DI to inject `IReplyGenerator` into EchoActor
                return s => resolver.Props<EchoActor>(s);
            },
            extractEntityId: ExtractEntityId,
            extractShardId: ExtractShardId,
            shardOptions: new ShardOptions());
});

The dependencyResolver.Props<MySingletonDiActor>() call will leverage the ActorSystem's built-in IDependencyResolver to instantiate the MySingletonDiActor and inject it with all of the necessary dependences, including IRequiredActor<TKey>.

Microsoft.Extensions.Configuration Integration

IConfiguration To HOCON Adapter

The AddHocon extension method can convert Microsoft.Extensions.Configuration IConfiguration into HOCON Config instance and adds it to the ActorSystem being configured.

  • All variable name are automatically converted to lower case.
  • All "." (period) in the IConfiguration key will be treated as a HOCON object key separator
  • For environment variable configuration provider:
    • "__" (double underline) will be converted to "." (period).
    • "_" (single underline) will be converted to "-" (dash).
    • If all keys are composed of integer parseable keys, the whole object is treated as an array

Example:

appsettings.json:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "akka": {
    "cluster": {
      "roles": [ "front-end", "back-end" ],
      "min-nr-of-members": 3,
      "log-info": true
    }
  }    
}

Environment variables:

AKKA__ACTOR__TELEMETRY__ENABLED=true
AKKA__CLUSTER__SEED_NODES__0=akka.tcp//mySystem@localhost:4055
AKKA__CLUSTER__SEED_NODES__1=akka.tcp//mySystem@localhost:4056
AKKA__CLUSTER__SEED_NODE_TIMEOUT=00:00:05

Example code:

/*
Both appsettings.json and environment variables are combined
into HOCON configuration:

akka {
  actor.telemetry.enabled: on
  cluster {
    roles: [ "front-end", "back-end" ]
    seed-nodes: [ 
      "akka.tcp//mySystem@localhost:4055",
      "akka.tcp//mySystem@localhost:4056" 
    ]
    min-nr-of-members: 3
    seed-node-timeout: 5s
    log-info: true
  }
}
*/
var host = new HostBuilder()
    .ConfigureHostConfiguration(builder =>
    {
        // Setup IConfiguration to load from appsettings.json and
        // environment variables
        builder
            .AddJsonFile("appsettings.json")
            .AddEnvironmentVariables();
    })
    .ConfigureServices((context, services) =>
    {
        services.AddAkka("mySystem", (builder, provider) =>
            {
                // convert IConfiguration to HOCON
                var akkaConfig = context.Configuration.GetSection("akka");
                builder.AddHocon(akkaConfig, HoconAddMode.Prepend); 
            });
    });

Microsoft.Extensions.Logging Integration

Logger Configuration Support

You can use AkkaConfigurationBuilder extension method called ConfigureLoggers(Action<LoggerConfigBuilder>) to configure how Akka.NET logger behave.

Example:

builder.Services.AddAkka("MyActorSystem", configurationBuilder =>
{
    configurationBuilder
        .ConfigureLoggers(setup =>
        {
            // Example: This sets the minimum log level
            setup.LogLevel = LogLevel.DebugLevel;
            
            // Example: Clear all loggers
            setup.ClearLoggers();
            
            // Example: Add the default logger
            // NOTE: You can also use setup.AddLogger<DefaultLogger>();
            setup.AddDefaultLogger();
            
            // Example: Add the ILoggerFactory logger
            // NOTE:
            //   - You can also use setup.AddLogger<LoggerFactoryLogger>();
            //   - To use a specific ILoggerFactory instance, you can use setup.AddLoggerFactory(myILoggerFactory);
            setup.AddLoggerFactory();
            
            // Example: Adding a serilog logger
            setup.AddLogger<SerilogLogger>();
        })
        .WithActors((system, registry) =>
        {
            var echo = system.ActorOf(act =>
            {
                act.ReceiveAny((o, context) =>
                {
                    Logging.GetLogger(context.System, "echo").Info($"Actor received {o}");
                    context.Sender.Tell($"{context.Self} rcv {o}");
                });
            }, "echo");
            registry.TryRegister<Echo>(echo); // register for DI
        });
});

A complete code sample can be viewed here.

Exposed properties are:

  • LogLevel: Configure the Akka.NET minimum log level filter, defaults to InfoLevel
  • LogConfigOnStart: When set to true, Akka.NET will log the complete HOCON settings it is using at start up, this can then be used for debugging purposes.

Currently supported logger methods:

  • ClearLoggers(): Clear all registered logger types.
  • AddLogger<TLogger>(): Add a logger type by providing its class type.
  • AddDefaultLogger(): Add the default Akka.NET console logger.
  • AddLoggerFactory(): Add the new ILoggerFactory logger.

Microsoft.Extensions.Logging.ILoggerFactory Logging Support

You can now use ILoggerFactory from Microsoft.Extensions.Logging as one of the sinks for Akka.NET logger. This logger will use the ILoggerFactory service set up inside the dependency injection ServiceProvider as its sink.

Microsoft.Extensions.Logging Log Event Filtering

There will be two log event filters acting on the final log input, the Akka.NET akka.loglevel setting and the Microsoft.Extensions.Logging settings, make sure that both are set correctly or some log messages will be missing.

To set up the Microsoft.Extensions.Logging log filtering, you will need to edit the appsettings.json file. Note that we also set the Akka namespace to be filtered at debug level in the example below.

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information",
      "Akka": "Debug"
    }
  }
}
Product Compatible and additional computed target framework versions.
.NET net5.0 was computed.  net5.0-windows was computed.  net6.0 was computed.  net6.0-android was computed.  net6.0-ios was computed.  net6.0-maccatalyst was computed.  net6.0-macos was computed.  net6.0-tvos was computed.  net6.0-windows was computed.  net7.0 was computed.  net7.0-android was computed.  net7.0-ios was computed.  net7.0-maccatalyst was computed.  net7.0-macos was computed.  net7.0-tvos was computed.  net7.0-windows was computed.  net8.0 was computed.  net8.0-android was computed.  net8.0-browser was computed.  net8.0-ios was computed.  net8.0-maccatalyst was computed.  net8.0-macos was computed.  net8.0-tvos was computed.  net8.0-windows was computed. 
.NET Core netcoreapp2.0 was computed.  netcoreapp2.1 was computed.  netcoreapp2.2 was computed.  netcoreapp3.0 was computed.  netcoreapp3.1 was computed. 
.NET Standard netstandard2.0 is compatible.  netstandard2.1 was computed. 
.NET Framework net461 was computed.  net462 was computed.  net463 was computed.  net47 was computed.  net471 was computed.  net472 was computed.  net48 was computed.  net481 was computed. 
MonoAndroid monoandroid was computed. 
MonoMac monomac was computed. 
MonoTouch monotouch was computed. 
Tizen tizen40 was computed.  tizen60 was computed. 
Xamarin.iOS xamarinios was computed. 
Xamarin.Mac xamarinmac was computed. 
Xamarin.TVOS xamarintvos was computed. 
Xamarin.WatchOS xamarinwatchos was computed. 
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.

NuGet packages (5)

Showing the top 5 NuGet packages that depend on Akka.Remote.Hosting:

Package Downloads
Akka.Cluster.Hosting

Akka.Cluster and Akka.Cluster.Sharding Microsoft.Extensions.Hosting support.

FAkka.Shared

Package Description

FAkka.Server.Linux

Package Description

Moin.Core

Moin!

FAkka.Shared.Linux

Package Description

GitHub repositories

This package is not used by any popular GitHub repositories.

Version Downloads Last updated
1.5.32 4,272 12/5/2024
1.5.31.1 5,669 11/15/2024
1.5.31 2,971 11/11/2024
1.5.30.1 7,628 10/18/2024
1.5.30 7,825 10/3/2024
1.5.29 1,877 10/1/2024
1.5.28 7,585 9/4/2024
1.5.27 37,893 7/29/2024
1.5.25 50,387 6/17/2024
1.5.24 4,939 6/10/2024
1.5.22 1,773 6/4/2024
1.5.20 12,962 4/30/2024
1.5.19 11,677 4/17/2024
1.5.18 24,074 3/14/2024
1.5.17.1 6,935 3/4/2024
1.5.16 6,963 2/23/2024
1.5.15 21,313 1/10/2024
1.5.14 3,305 1/9/2024
1.5.13 28,808 9/27/2023
1.5.12.1 12,964 8/31/2023
1.5.12 10,097 8/3/2023
1.5.8.1 9,492 7/12/2023
1.5.8 7,077 6/21/2023
1.5.7 15,966 5/23/2023
1.5.6.1 2,632 5/17/2023
1.5.6 6,366 5/10/2023
1.5.5 3,304 5/4/2023
1.5.4.1 2,711 5/1/2023
1.5.4 4,487 4/25/2023
1.5.3 1,115 4/25/2023
1.5.2 5,130 4/6/2023
1.5.1.1 1,428 4/4/2023
1.5.1 7,271 3/16/2023
1.5.0 6,083 3/2/2023
1.5.0-beta6 465 3/1/2023
1.5.0-beta4 203 3/1/2023
1.5.0-beta3 277 2/28/2023
1.5.0-alpha4 448 2/17/2023
1.0.3 9,178 2/8/2023
1.0.2 2,332 1/31/2023
1.0.1 5,126 1/6/2023
1.0.0 3,171 12/28/2022
0.5.2-beta1 1,212 11/28/2022
0.5.1 10,563 10/20/2022
0.5.0 4,363 10/4/2022
0.4.3 8,614 9/10/2022
0.4.2 6,544 8/12/2022
0.4.1 4,894 7/21/2022
0.4.0 2,854 7/18/2022
0.3.4 4,240 6/23/2022
0.3.3 1,888 6/16/2022
0.3.2 1,700 6/13/2022
0.3.1 54,705 6/9/2022
0.3.0 10,707 5/24/2022
0.2.2 4,682 4/10/2022
0.2.1 1,741 4/9/2022
0.2.0 1,677 4/9/2022
0.1.5 1,715 4/6/2022
0.1.4 2,016 4/2/2022
0.1.3 1,684 4/1/2022
0.1.2 1,653 3/31/2022
0.1.1 1,862 3/18/2022
0.1.0 2,205 3/10/2022

Version 1.5.0-beta3 integrates Akka.NET v1.5 into Akka.Hosting
• [Update Akka.NET to 1.5.0-beta3](https://github.com/akkadotnet/akka.net/releases/tag/1.5.0-beta3)
#### Upgrading From v1.4 To v1.5
As noted in [the upgrade advisories](https://github.com/akkadotnet/akka.net/blob/c9ccc25207b5a4cfa963a5a23f96c0676fbbef10/docs/community/whats-new/akkadotnet-v1.5-upgrade-advisories.md), there was a major change in Akka.Cluster.Sharding state storage. These notes contains the same documentation, but tailored for Akka.Hosting users
The recommended settings for maximum ease-of-use for Akka.Cluster.Sharding in new applications going forward will be:
csharp
var options = new ShardOptions
{
   StateStoreMode = StateStoreMode.DData,
   RememberEntitiesStore = RememberEntitiesStore.Eventsourced
};

You will need to set these options manually because the default settings are set for backward compatibility.
#### Migrating to New Sharding Storage From Akka.Persistence
> **NOTE**
>
> This section applies only to users who were using StateStoreMode = StateStoreMode.Persistence.
Switching over to using RememberEntitiesStore = RememberEntitiesStore.Eventsourced will cause an initial migration of data from the ShardCoordinator's journal into separate event journals going forward.
Upgrading to Akka.NET v1.5 will **cause an irreversible migration of Akka.Cluster.Sharding data*• for users who were previously running StateStoreMode = StateStoreMode.Persistence, so follow the steps below carefully:
##### Step 1 • Upgrade to Akka.NET v1.5 With New Options Setup
Update your Akka.Cluster.Sharding options to look like the following (adjust as necessary for your custom settings):
csharp
hostBuilder.Services.AddAkka(MyActorSystem, builder =>
{
   var shardOptions = new ShardOptions
   {
       // If you don't run Akka.Cluster.Sharding with RememberEntities = true,
       // then set this to false
       RememberEntities = true,
       RememberEntitiesStore = RememberEntitiesStore.Eventsourced,
       StateStoreMode = StateStoreMode.Persistence,
       //fail if upgrade doesn't succeed
       FailOnInvalidEntityStateTransition = true
   };
   // Modify these two options to suit your application, SqlServer used
   // only as an illustration
   var journalOptions = new SqlServerJournalOptions();
   var snapshotOptions = new SqlServerSnapshotOptions();
   builder
       .WithClustering()
       .WithSqlServerPersistence(journalOptions, snapshotOptions)
       .WithShardRegion<UserActionsEntity>(
           userActions,
           s => UserActionsEntity.Props(s),
           new UserMessageExtractor(),
           // shardOptions is being used here
           shardOptions);
   // Add the Akka.Cluster.Sharding migration journal event adapter
   builder.WithClusterShardingJournalMigrationAdapter(journalOptions);
   // you can also declare the adapter by referencing the journal ID directly
   builder.WithClusterShardingJournalMigrationAdapter(akka.persistence.journal.sql-server);
})

With these HOCON settings in-place the following will happen:
1. The old PersitentShardCoordinator state will be broken up • Remember entities data will be distributed to each of the PersistentShard actors, who will now use the new RememberEntitiesStore = RememberEntitiesStore.Eventsourced setting going forward;
2. Old Akka.Cluster.Sharding.ShardCoordinator.IDomainEvent events will be upgraded to a new storage format via the injected Akka.Persistence event adapter; and
3. The PersistentShardCoordinator will migrate its journal to the new format as well.
##### Step 2 • Migrating Away From Persistence to DData
Once your cluster has successfully booted up with these settings, you can now optionally move to using distributed data to store sharding state by changing StateStoreMode = StateStoreMode.DData and deploying a second time:
csharp
hostBuilder.Services.AddAkka(MyActorSystem, builder =>
{
   var shardOptions = new ShardOptions
   {
       RememberEntities = true,
       RememberEntitiesStore = RememberEntitiesStore.Eventsourced,
       // Change this line of code
       StateStoreMode = StateStoreMode.DData,
       FailOnInvalidEntityStateTransition = true
   };
   var journalOptions = new SqlServerJournalOptions();
   var snapshotOptions = new SqlServerSnapshotOptions();
   builder
       .WithClustering()
       .WithSqlServerPersistence(journalOptions, snapshotOptions)
       .WithShardRegion<UserActionsEntity>(
           userActions,
           s => UserActionsEntity.Props(s),
           new UserMessageExtractor(),
           shardOptions);
   builder.WithClusterShardingJournalMigrationAdapter(journalOptions);
})

Now you'll be running Akka.Cluster.Sharding with the recommended settings.
#### Migrating to New Sharding Storage From Akka.DistributedData
The migration process onto Akka.NET v1.5's new Cluster.Sharding storage system is less involved for users who were already using StateStoreMode = StateStoreMode.DData. All these users need to do is change the RememberEntitiesStore option to RememberEntitiesStore.Eventsourced
csharp
hostBuilder.Services.AddAkka(MyActorSystem, builder =>
{
   var shardOptions = new ShardOptions
   {
       RememberEntities = true,
       // Use this option setting
       RememberEntitiesStore = RememberEntitiesStore.Eventsourced,
       StateStoreMode = StateStoreMode.DData,
       FailOnInvalidEntityStateTransition = true
   };
   var journalOptions = new SqlServerJournalOptions();
   var snapshotOptions = new SqlServerSnapshotOptions();
   builder
       .WithClustering()
       .WithSqlServerPersistence(journalOptions, snapshotOptions)
       .WithShardRegion<UserActionsEntity>(
           userActions,
           s => UserActionsEntity.Props(s),
           new UserMessageExtractor(),
           shardOptions);
   builder.WithClusterShardingJournalMigrationAdapter(journalOptions);
})


Full changelog at https://github.com/akkadotnet/Akka.Hosting/blob/refs/tags/1.5.0-beta3/RELEASE_NOTES.md