Orleans 知多少 | 3. Hello Orleans

最新推荐文章于 2024-08-21 09:29:08 发布
最新推荐文章于 2024-08-21 09:29:08 发布
阅读量308 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ysj1163620987/article/details/105852714
版权

1. 引言

是的，Orleans v3.0.0 已经发布了，并已经完全支持 .NET Core 3.0。所以，Orleans 系列是时候继续了，抱歉，让大家久等了。万丈高楼平地起，这一节我们就先来了解下Orleans的基本使用。

2. 模板项目讲解

在上一篇文章中，我们了解到Orleans 作为.NET 分布式框架，其主要包括三个部分：Client、Grains、Silo Host（Server）。因此，为了方便讲解，创建如下的项目结构进行演示：

这里有几点需要说明：

  1. Orleans.Grains：类库项目，用于定义Grain的接口以及实现，需要引用 Microsoft.Orleans.CodeGenerator.MSBuild和 Microsoft.Orleans.Core.Abstractions NuGet包。

  2. Orleans.Server：控制台项目，为 Silo 宿主提供宿主环境，需要引用 Microsoft.Orleans.Server 和 Microsoft.Extensions.Hosting NuGet包，以及 Orleans.Grains 项目。

  3. Orleans.Client：控制台项目，用于演示如何借助Orleans Client建立与Orleans Server的连接，需要引用 Microsoft.Orleans.Client 和 Microsoft.Extensions.Hosting NuGet包，同时添加 Orleans.Grains项目引用。

3. 第一个Grain

Grain作为Orleans的第一公民，以及Virtual Actor的实际代言人，想吃透Orleans，那Grain就是第一道坎。先看一个简单的Demo，我们来模拟统计网站的实时在线用户。在 Orleans.Grains添加 ISessionControl接口，主要用户登录状态的管理。

public interface ISessionControlGrain : IGrainWithStringKey
{
    Task Login(string userId);
    Task Logout(string userId);
    Task<int> GetActiveUserCount();
}

可以看见Grain的定义很简单，只需要指定继承自IGrain的接口就好。这里面继承自 IGrainWithStringKey，说明该Grain 的Identity Key(身份标识)为 string类型。同时需要注意的是Grain 的方法申明，返回值必须是：Task、Task、ValueTask。紧接着定义 SessionControlGrain来实现 ISessionControlGrain接口。

public class SessionControlGrain : Grain, ISessionControlGrain
{
    private List<string> LoginUsers { get; set; } = new List<string>();
    public Task Login(string userId)
    {
        //获取当前Grain的身份标识(因为ISessionControlGrain身份标识为string类型，GetPrimaryKeyString());
        var appName = this.GetPrimaryKeyString();
        LoginUsers.Add(userId);
        Console.WriteLine($"Current active users count of {appName} is {LoginUsers.Count}");
        return Task.CompletedTask;
    }
    public Task Logout(string userId)
    {
        //获取当前Grain的身份标识
        var appName = this.GetPrimaryKey();
        LoginUsers.Remove(userId);
        Console.WriteLine($"Current active users count of {appName} is {LoginUsers.Count}");
        return Task.CompletedTask;
    }
    public Task<int> GetActiveUserCount()
    {
        return Task.FromResult(LoginUsers.Count);
    }
}

实现也很简单，Grain的实现要继承自 Grain基类。代码中我们定义了一个 List<string>集合用于保存登录用户。

4. 第一个Silo Host（Server）

定义一个Silo用于暴露Grain提供的服务，在 Orleans.Server.Program中添加以下代码用于启动Silo Host。

static Task Main(string[] args)
{
    Console.Title = typeof(Program).Namespace;
    // define the cluster configuration
    return Host.CreateDefaultBuilder()
        .UseOrleans((builder) =>
            {
                builder.UseLocalhostClustering()
                    .AddMemoryGrainStorageAsDefault()
                    .Configure<ClusterOptions>(options =>
                    {
                        options.ClusterId = "Hello.Orleans";
                        options.ServiceId = "Hello.Orleans";
                    })
                    .Configure<EndpointOptions>(options => options.AdvertisedIPAddress = IPAddress.Loopback)
                    .ConfigureApplicationParts(parts =>
                        parts.AddApplicationPart(typeof(ISessionControlGrain).Assembly).WithReferences());
            }
        )
        .ConfigureServices(services =>
        {
            services.Configure<ConsoleLifetimeOptions>(options =>
            {
                options.SuppressStatusMessages = true;
            });
        })
        .ConfigureLogging(builder => { builder.AddConsole(); })
        .RunConsoleAsync();
}

  1. Host.CreateDefaultBuilder()：创建泛型主机提供宿主环境。

  2. UseOrleans：用来配置Oleans。

  3. UseLocalhostClustering() ：用于在开发环境下指定连接到本地集群。

  4. Configure<ClusterOptions>：用于指定连接到那个集群。

  5. Configure<EndpointOptions>：用于配置silo与silo、silo与client之间的通信端点。开发环境下可仅指定回环地址作为集群间通信的IP地址。

  6. ConfigureApplicationParts()：用于指定暴露哪些Grain服务。

以上就是开发环境下，Orleans Server的基本配置。对于详细的配置也可以先参考Orleans Server Configuration。后续也会有专门的一篇文章来详解。

5. 第一个Client

客户端的定义也很简单，主要是创建 IClusterClient对象建立于Orleans Server的连接。因为 IClusterClient最好能在程序启动之时就建立连接，所以可以通过继承 IHostedService来实现。在 Orleans.Client中定义 ClusterClientHostedService继承自 IHostedService。

public class ClusterClientHostedService : IHostedService
{
    public IClusterClient Client { get; }
    private readonly ILogger<ClusterClientHostedService> _logger;
    public ClusterClientHostedService(ILogger<ClusterClientHostedService> logger, ILoggerProvider loggerProvider)
    {
        _logger = logger;
        Client = new ClientBuilder()
            .UseLocalhostClustering()
            .Configure<ClusterOptions>(options =>
            {
                options.ClusterId = "Hello.Orleans";
                options.ServiceId = "Hello.Orleans";
            })
            .ConfigureLogging(builder => builder.AddProvider(loggerProvider))
            .Build();
    }
    public Task StartAsync(CancellationToken cancellationToken)
    {
        var attempt = 0;
        var maxAttempts = 100;
        var delay = TimeSpan.FromSeconds(1);
        return Client.Connect(async error =>
        {
            if (cancellationToken.IsCancellationRequested)
            {
                return false;
            }
            if (++attempt < maxAttempts)
            {
                _logger.LogWarning(error,
                    "Failed to connect to Orleans cluster on attempt {@Attempt} of {@MaxAttempts}.",
                    attempt, maxAttempts);
                try
                {
                    await Task.Delay(delay, cancellationToken);
                }
                catch (OperationCanceledException)
                {
                    return false;
                }
                return true;
            }
            else
            {
                _logger.LogError(error,
                    "Failed to connect to Orleans cluster on attempt {@Attempt} of {@MaxAttempts}.",
                    attempt, maxAttempts);
                return false;
            }
        });
    }
    public async Task StopAsync(CancellationToken cancellationToken)
    {
        try
        {
            await Client.Close();
        }
        catch (OrleansException error)
        {
            _logger.LogWarning(error, "Error while gracefully disconnecting from Orleans cluster. Will ignore and continue to shutdown.");
        }
    }
}

代码讲解：

1.构造函数中通过借助 ClientBuilder() 来初始化 IClusterClient。其中 UseLocalhostClustering()用于连接到开发环境中的localhost 集群。并通过 Configure<ClusterOptions>指定连接到哪个集群。（需要注意的是，这里的ClusterId必须与Orleans.Server中配置的保持一致。

Client = new ClientBuilder()
    .UseLocalhostClustering()
    .Configure<ClusterOptions>(options =>
    {
        options.ClusterId = "Hello.Orleans";
        options.ServiceId = "Hello.Orleans";
    })
    .ConfigureLogging(builder => builder.AddProvider(loggerProvider))
    .Build();

2. 在 StartAsync方法中通过调用 Client.Connect建立与Orleans Server的连接。同时定义了一个重试机制。

紧接着我们需要将 ClusterClientHostedService添加到Ioc容器，添加以下代码到 Orleans.Client.Program中：

static Task Main(string[] args)
{
    Console.Title = typeof(Program).Namespace;
    return Host.CreateDefaultBuilder()
        .ConfigureServices(services =>
        {
            services.AddSingleton<ClusterClientHostedService>();
            services.AddSingleton<IHostedService>(_ => _.GetService<ClusterClientHostedService>());
            services.AddSingleton(_ => _.GetService<ClusterClientHostedService>().Client);
            services.AddHostedService<HelloOrleansClientHostedService>();
            services.Configure<ConsoleLifetimeOptions>(options =>
            {
                options.SuppressStatusMessages = true;
            });
        })
        .ConfigureLogging(builder =>
        {
            builder.AddConsole();
        })
        .RunConsoleAsync();
}

对于 ClusterClientHostedService，并没有选择直接通过 services.AddHostedService<T>的方式注入，是因为我们需要注入该服务中提供的 IClusterClient（单例），以供其他类去消费。

紧接着，定义一个 HelloOrleansClientHostedService用来消费定义的 ISessionControlGrain。

public class HelloOrleansClientHostedService : IHostedService
{
    private readonly IClusterClient _client;
    private readonly ILogger<HelloOrleansClientHostedService> _logger;
    public HelloOrleansClientHostedService(IClusterClient client, ILogger<HelloOrleansClientHostedService> logger)
    {
        _client = client;
        _logger = logger;
    }
    public async Task StartAsync(CancellationToken cancellationToken)
    {
        // 模拟控制台终端用户登录
       await MockLogin("Hello.Orleans.Console");
       // 模拟网页终端用户登录
       await MockLogin("Hello.Orleans.Web");
    }
    /// <summary>
    /// 模拟指定应用的登录
    /// </summary>
    /// <param name="appName"></param>
    /// <returns></returns>
    public async Task MockLogin(string appName)
    {
        //假设我们需要支持不同端登录用户，则只需要将项目名称作为身份标识。
        //即可获取一个代表用来维护当前项目登录状态的的单例Grain。
        var sessionControl = _client.GetGrain<ISessionControlGrain>(appName);
        ParallelLoopResult result = Parallel.For(0, 10000, (index) =>
        {
            var userId = $"User-{index}";
            sessionControl.Login(userId);
        });
        if (result.IsCompleted)
        {
            //ParallelLoopResult.IsCompleted 只是返回所有循环创建完毕，并不保证循环的内部任务创建并执行完毕
            //所以，此处手动延迟5秒后再去读取活动用户数。
            await Task.Delay(TimeSpan.FromSeconds(5));
            var activeUserCount = await sessionControl.GetActiveUserCount();
            _logger.LogInformation($"The Active Users Count of {appName} is {activeUserCount}");
        }
    }
    public Task StopAsync(CancellationToken cancellationToken)
    {
        _logger.LogInformation("Closed!");
        return Task.CompletedTask; ;
    }
}

代码讲解：这里定义了一个 MockLogin用于模拟不同终端10000个用户的并发登录。

  1. 通过构造函数注入需要的 IClusterClient。

  2. 通过指定Grain接口以及身份标识，就可以通过Client 获取对应的Grain，进而消费Grain中暴露的方法。 varsessionControl=_client.GetGrain<ISessionControlGrain>(appName); 这里需要注意的是，指定的身份标识为终端应用的名称，那么在整个应用生命周期内，将有且仅有一个代表这个终端应用的Grain。

  3. 使用 Parallel.For 模拟并发

  4. ParallelLoopResult.IsCompleted 只是返回所有循环任务创建完毕，并不代表循环的内部任务执行完毕。

6. 启动第一个 Orleans 应用

先启动 Orleans.Server：再启动 Orleans.Client：

从上面的运行结果来看，模拟两个终端10000个用户的并发登录，最终输出的活动用户数量均为10000个。回顾整个实现，并没有用到诸如锁、并发集合等避免并发导致的线程安全问题，但却输出正确的期望结果，这就正好说明了Orleans强大的并发控制特性。

public class SessionControlGrain : Grain, ISessionControlGrain
{
    // 未使用并发集合
    private List<string> LoginUsers { get; set; } = new List<string>(); 
    public Task Login(string userId)
    {
        //获取当前Grain的身份标识(因为ISessionControlGrain身份标识为string类型，GetPrimaryKeyString());
        var appName = this.GetPrimaryKeyString();
        LoginUsers.Add(userId);//未加锁
        Console.WriteLine($"Current active users count of {appName} is {LoginUsers.Count}");
        return Task.CompletedTask;
    }
    ....
}

7. 小结

通过简单的演示，想必你对Orleans的编程实现有了基本的认知，并体会到其并发控制的强大之处。这只是简单的入门演练，Orleans很多强大的特性，后续再结合具体场景进行详细阐述。源码已上传至GitHub：Hello.Orleans

聖傑
关注
Orleans 知多少 | Orleans 中文文档上线
圣杰
08-29 4214
Orleans 简介Orleans是一个跨平台框架，用于构建健壮，可扩展的分布式应用程序Orleans建立在.NET开发人员生产力的基础上，并将其带入了分布式应用程序的世界，例如云服务。...
Orleans解决并发之痛（四）：Streams
dotNET跨平台
09-07 1086
Orleans 提供了 Stream扩展编程模型。此模型提供了一套API，使处理流更简单和更健壮。Stream默认提供了两种Provider，不同的流类型可能使用不同的Provider来处理，Simple Message Stream Provider 和 Azure Queue Stream Provider。Stream Providers兼容现有的队列技术，比如： Event Hubs、Se
.NET Orleans 开源项目指南
最新发布
gitblog_00244的博客
08-21 382
.NET Orleans 开源项目指南 orleansdotnet/orleans: Orleans是由微软研究团队创建的面向云应用和服务的分布式计算框架，特别适合构建虚拟 actor模型的服务端应用。Orleans通过管理actors生命周期和透明地处理网络通信，简化了构建高度可扩展、容错的云服务的过程。项目地址:https://gitcode.com/gh_mirrors/or/orlean...
Orleans 知多少 | 2. 核心概念一览
weixin_30614587的博客
07-22 157
Orleans 术语解读 上面这张图中包含了Orleans中的几个核心概念： Grain Silo Orleans Cluster Orleans Client 从这张图，我们应该能理清他们之间的关系。 Grain作为最小的执行单元 Silo 是 Grain 的宿主运行环境，用来暴露具体的服务 Orleans Server 提供Silo的运行环境 一个Server可以运行多个Si...
.NET分布式框架 | Orleans 知多少
dotNET跨平台
07-07 1713
引言公司物联网项目集成Orleans以支持高并发的分布式业务，对于Orleans也是第一次接触，本文就分享下个人对Orleans的理解。这里先抛出自己的观点：Orlean...
Orleans 知多少 | .NET Core 分布式云计算框架（转）
phenixヾ的专栏
05-10 806
作者：『圣杰』 出处：http://www.cnblogs.com/sheng-jie/ Orleans 知多少| .NET Core 分布式框架 引言 公司物联网项目集成Orleans以支持高并发的分布式业务，对于Orleans也是第一次接触，本文就分享下个人对Orleans的理解。 这里先抛出自己的观点：Orleans 是一个支持有状态云生应用/服务水平伸缩的基于Virtual Actor 模型的.NET分布式框架。 下面我会从以下几个关键点，进行阐述： 云生应用的挑战 何为..
Orleans.Redis刚才翻看Orleans的官方网站，发现除了大家关注比较多的"Step-by-step Tutorial
06-24
Orleans.Redis结合redis使用方法。 HelloWorld.Grains HelloWorld.Interfaces RedisClient RedisGatewayHost RedisSiloHost 示例源代码，期望能够帮助用到的同学。
Orleans解决并发之痛（二）：Grain状态
dotNET跨平台
09-05 1175
Grains是Orleans应用程序的构建块，它们是彼此孤立的原子单位，分布的，持久的， 一个典型的Grain是有状态和行为的一个单实例，每个Grain实例的在单线程内执行，Grain之间共享数据通过消息传递，Grains是由Silo自动化管理。 Grain之间传递消息过程中也可能出现死锁的情况，如：Grain A发送消息给Grain B，并等待它的完成，此时Grain B发送一个消息给Grai
Orleans入门例子
dotNET跨平台
08-22 1550
Orleans是微软开源的分布式actor模型框架.actor模型的原理网络上有很多文章.有许多理论性的文章,深刻地我都不知道怎么应用.在这里我就不赘述了.既然是博客,就说说自己的理解。 对于编程来说，不管是前台还是后台，在现在的计算机环境下，多线程编程是不可避免的。多线程带来的很多好处，也带来的很多编程上的“坏处”。好处就是，什么并发、高效，高资源利用率等等高大上的词语。这些就不详细说了。就说
Orleans解决并发之痛（三）：集群
dotNET跨平台
09-06 1439
Orleans本身的设计是一个分布式的框架，多个Silo构成集群，Grains分布在多个Silo中。一旦一个Silo挂了，原来归属这个Silo的Grains会自动在其他Silo中激活。生产环境下还是需要以集群方式来部署。 cluster 在Orleans解决并发之痛（二）：Grain状态文章中提到内存存储State是不靠谱的，同样，以内存方式存储集群中Silo的成员关系也是不靠谱的，所以本
orleans：Orleans是一个跨平台框架，用于使用.NET构建分布式应用程序
02-08
Orleans是用于构建健壮，可扩展的分布式应用程序的跨平台框架 Orleans建立在.NET开发人员生产力的基础上，并将其带入了分布式应用程序的世界，例如云服务。 Orleans可从单个本地服务器扩展到云中全局分布的高可用性应用程序。 奥尔良采用了对象，接口，异步/等待和尝试/捕获等熟悉的概念，并将其扩展到多服务器环境。 这样，它可以帮助具有单服务器应用程序经验的开发人员过渡到构建弹性，可扩展的云服务和其他分布式应用程序。 因此，奥尔良通常被称为“分布式.NET”。 它是由创建的，并介绍了，这是为Cloud时代构建新一代分布式系统的一种新颖方法。 Orleans的核心贡献在于其编程模型，该模型驯服了高度并行的分布式系统固有的复杂性，而不会限制功能或对开发人员施加繁重的约束。 谷物 在任何奥尔良应用中，基本要素都是谷物。 谷物是包含用户定义的身份，行为和状态的实体。 谷物标识是用户定
ASP.NET CORE API 使用Orleans
Accpdaiyekun的专栏
03-09 935
asp.net core 添加orleans 使用内存以及数据库持久化配置。
.NET分布式大规模计算利器-Orleans(一)
FK2015139136的博客
09-23 961
写在前面 Orleans是基于Actor模型思想的.NET领域的框架，它提供了一种直接而简单的方法来构建分布式大规模计算应用程序，而无需学习和应用复杂的并发或其他扩展模式。我在2015年下半年开始应用Orleans，当时公司的交易系统采用的架构就是基于Orleans框架的，其展现出来的高性能、高并发以及惊人的稳定性深深地吸引了我，也让我认识到了传统三层无状态架构的缺陷。本文主要关...
Orleans 微软基于 Actor 的分布式框架
热门推荐
zhujisoft的专栏
07-15 2万+
Orleans是微软开源的分布式基于Actor的模型框架。Orleans 是一个跨平台框架，用于构建可靠且可缩放的分布式应用程序。分布式应用程序定义为跨多个进程的应用，通常使用对等通信来超越硬件边界。Orleans 从单个本地服务器扩展到了云中成百上千的分布式、高度可用的应用程序。Orleans 将熟悉的概念和 C# 习语扩展到了多服务器环境。Orleans 在设计上可弹性缩放。当主机加入群集时，它可以接受新的激活。
.NET 牛逼的分布式框架Orleans介绍
weixin_68436326的博客
04-02 247
介绍 Orleans 是一个基于虚拟 Actor 模型的 .NET 分布式框架，用于构建高性能、可扩展的云应用程序。它由Microsoft Research开发，并已在多个大型项目中使用，例如 Xbox Live 和 Azure。背景云应用程序和服务本质上是并行和分布式的。它们也具有互动性和动态性; 通常需要云实体之间的近实时直接交互。今天很难建立这样的应用程序。开发过程需要专家级程序员...
Orleans 2.0 官方文档 —— 2.2 入门教程与示例 -> 入门教程1：Orleans基础
uddiqpl的专栏
01-06 4336
教程1—— 创建一个极小的Orleans应用程序 本教程提供了有关创建基本功能的Orleans应用程序的分步说明。它被设计为自包含且极尽简约，具有以下特征： 它仅依赖于NuGet包 它已在使用Orleans 2.2.0的Visual Studio 2017中进行了测试 它不依赖于外部存储 请记住，这只是一个教程，缺少适当的错误处理和其他对生产环境有用的好东西。但是，它应该有助于读者真实地了...
Orleans框架------基于Actor模型生成分布式Id
weixin_34392843的博客
06-26 260
一、Actor简介 actor模型是一种并行计算的数学模型。 响应于收到的消息，演员可以：做出决定，创建更多Actor，发送更多消息，并确定如何响应接收到的下一条消息。 演员可以修改自己的状态，但只能通过消息相互影响（避免需要任何锁）。 actor是一个计算实体，当其收到消息时，可以并发执行如下操作： 1. 发送有限数量的消息给其他actor 2. 创建有限数量的新a...
.NET Core 3与Orleans 3构建分布式服务架构实践
"Phenix7 是一个用于构建基于 .NET Core 3 和 Orleans 3 的分布式服务架构的框架，旨在解决高并发、大数据量以及大规模计算下的系统挑战。该框架利用了前后端分离技术，通过WebAPI服务进行数据交互，并通过Orleans...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值