Azure Service Fabric Sc​​aling

时间:2016-07-11 13:00:02

标签: c# azure azure-service-fabric

我有一个在Azure Service Fabric上运行计划任务的应用程序。我的应用程序必须同时运行三十到四十个任务,所以我使用异步编程。我有一些问题:

您是否建议异步运行任务?如果没有,我应该同步运行任务并扩大规模吗?我该如何扩大规模?我不需要运行任务的返回信息。

我应该将排队和出队分离成单独的有状态服务吗?如果是这样,这些服务将如何相互通信?

这是我的代码:

internal sealed class JMATaskRunner : StatefulService
   {
    public JMATaskRunner(StatefulServiceContext context)
        : base(context)
    { }

    /// <summary>
    /// Optional override to create listeners (e.g., HTTP, Service Remoting, WCF, etc.) for this service replica to handle client or user requests.
    /// </summary>
    /// <remarks>
    /// For more information on service communication, see http://aka.ms/servicefabricservicecommunication
    /// </remarks>
    /// <returns>A collection of listeners.</returns>
    protected override IEnumerable<ServiceReplicaListener> CreateServiceReplicaListeners()
    {
        return new ServiceReplicaListener[0];
    }


    public async Task<List<JMATask>> GetMessagesAsync()
    {
        await AddTasks();

        List<JMATask> ts = new List<JMATask>();

        IReliableQueue<JMATask> tasks =
            await this.StateManager.GetOrAddAsync<IReliableQueue<JMATask>>("JMATasks");

        using (ITransaction tx = this.StateManager.CreateTransaction())
        {
            var messagesEnumerable = await tasks.CreateEnumerableAsync(tx);

            using (var enumerator = messagesEnumerable.GetAsyncEnumerator())
            {
                while (await enumerator.MoveNextAsync(CancellationToken.None))
                {
                    ts.Add(enumerator.Current);
                }
            }
        }

        return ts;
        //return messagesEnumerable.ToList();
    }

    public async Task AddMessageAsync(JMATask task)
    {
        IReliableQueue<JMATask> tasks =
            await this.StateManager.GetOrAddAsync<IReliableQueue<JMATask>>("JMATasks");

        using (ITransaction tx = this.StateManager.CreateTransaction())
        {
            await tasks.EnqueueAsync(tx, task);
            await tx.CommitAsync();
        }
    }

    /// <summary>
    /// This is the main entry point for your service replica.
    /// This method executes when this replica of your service becomes primary and has write status.
    /// </summary>
    /// <param name="cancellationToken">Canceled when Service Fabric needs to shut down this service replica.</param>
    protected override async Task RunAsync(CancellationToken cancellationToken)
    {
        // TODO: Replace the following sample code with your own logic 
        //       or remove this RunAsync override if it's not needed in your service.

        IReliableQueue<JMATask> tasks =
            await this.StateManager.GetOrAddAsync<IReliableQueue<JMATask>>("JMATasks");

        while (true)
        {
            cancellationToken.ThrowIfCancellationRequested();

            var messagesEnumerable = await GetMessagesAsync();

            using (ITransaction tx = this.StateManager.CreateTransaction())
            {
                foreach (var message in messagesEnumerable)
                {
                    var result = await tasks.TryDequeueAsync(tx);
                    await PerformTask(result.Value);
                }

                await tx.CommitAsync();
                await Task.Delay(TimeSpan.FromSeconds(2), cancellationToken);
            }
        }


    }

    async Task<JMATask> PerformTask(JMATask task)
    {
        await Task.Run(() => Perform(task));
        return task;
    }

    void Perform(JMATask task)
    {
        Thread.Sleep(50000);
    }

    async Task<JMATask> AddTasks()
    {
        m_TaskProvider = JMATaskFactory.Get(conString);

        //List<JMATask> tasks = m_TaskProvider.GetAllTasks();

        //foreach(JMATask task in tasks)
        //{
        //    await AddMessageAsync(task);
        //}

        JMATask task = m_TaskProvider.GetJMATask(80);
        JMATask task2 = m_TaskProvider.GetJMATask(97);

        await AddMessageAsync(task);
        await AddMessageAsync(task2);
        return new JMATask();
    }
}

3 个答案:

答案 0 :(得分:1)

对于服务结构(以及其他基于actor的系统),您通常希望向外扩展,而不是向上扩展 [向上扩展与向外扩展],请参阅({ {3}})

http://www.vtagion.com/scalability-scale-up-scale-out-care/关于放大和缩小(略有误称)。

基本上,服务结构可以解决大多数关于故障转移,负载平衡等问题。

有关如何扩展群集的文档非常值得一读。

Azure Article上的文档也进入了系统的“线程”模型,因为它基于actor是基本上是异步的。

答案 1 :(得分:1)

您当然可以执行异步任务,但是当您创建的任务多于机器上可用的物理线程时,您将开始看到收益递减。

Service Fabric允许您非常轻松地在多台计算机上扩展此类工作负载 - 将您的计算机视为资源池。如果每个VM有4个物理线程,那么使用5个机器,您可以拥有20个物理线程池。

执行此操作的方法是使用分区有状态服务。服务的每个分区处理总工作负载的子集,该子集基于您创建的每个工作单元的分区键进行分配。请参阅此处以开始分区:https://azure.microsoft.com/en-us/documentation/articles/service-fabric-concepts-partitioning/

答案 2 :(得分:0)

我会尝试使用actor模型并远离可靠队列。每当需要添加任务时,它都会要求服务结构运行时给出一个代表任务逻辑的新actor实例。服务结构将处理角色及其生命周期的分布。如果将来需要返回值,可以使用有状态服务或其他聚合actor来获取它。此外,您还可以更好地控制任务。