Ler em inglês

Compartilhar via


Streaming com Orleans

O Orleans v.1.0.0 adicionou suporte para extensões de streaming ao modelo de programação. As extensões de streaming fornecem um conjunto de abstrações e APIs que tornam pensar e trabalhar com fluxos algo mais simples e robustos. As extensões de streaming permitem que os desenvolvedores escrevam aplicativos reativos que operam em uma sequência de eventos de maneira estruturada. O modelo de extensibilidade de provedores de fluxo torna o modelo de programação compatível e portátil em uma ampla gama de tecnologias de enfileiramento, como Hubs de Eventos, ServiceBus, Filas do Azure e Apache Kafka. Não é necessário escrever código especial nem executar processos dedicados para interagir com essas filas.

Por que eu deveria me importar?

Se você já sabe tudo sobre Processamento de Fluxo e está familiarizado com tecnologias como Hubs de Eventos, Kafka, Azure Stream Analytics, Apache Storm, Streaming do Apache Spark e Extensões Reativas (Rx) no .NET, talvez esteja perguntando por que você deve se importar. Por que precisamos de mais um sistema de processamento de fluxo e como os atores estão relacionados ao Streams?"Por que usar fluxos do Orleans?" é destinado a responder a essa pergunta.

Modelo de programação

Há vários princípios por trás do Modelo de programação de fluxos do Orleans:

  1. Os fluxos do Orleans são virtuais. Ou seja, um fluxo sempre existe. Ele não é explicitamente criado nem destruído e nunca pode falhar.
  2. Os fluxos são identificados por IDs de fluxo, que são apenas nomes lógicos compostos por GUIDs e cadeias de caracteres.
  3. Os fluxos do Orleans permitem que você desacople a geração de dados de seu processamento, tanto no tempo quanto no espaço. Isso significa que o produtor de fluxo e o consumidor de fluxo podem estar em servidores diferentes ou em fusos horários diferentes e suportarão falhas.
  4. Os fluxos do Orleans são leves e dinâmicos. O Orleans Streaming Runtime foi projetado para lidar com um grande número de fluxos que vêm e vão a uma taxa alta.
  5. As associações de fluxo do Orleans são dinâmicas. O Orleans Streaming Runtime foi projetado para lidar com casos em que a granularidade se conecta e se desconecta de fluxos a uma taxa alta.
  6. O Orleans Streaming Runtime gerencia de maneira transparente o ciclo de vida do consumo de fluxo. Depois que um aplicativo assina um fluxo, ele recebe os eventos do fluxo, mesmo na presença de falhas.
  7. Os fluxos do Orleans funcionam uniformemente em grãos e em clientes do Orleans.

APIs de programação

Os aplicativos interagem com fluxos usando Orleans.Streams.IAsyncStream<T>, o que implementa as interfaces Orleans.Streams.IAsyncObserver<T> e Orleans.Streams.IAsyncObservable<T>. Essas APIS são semelhantes às conhecidas Rx (Extensões Reativas) no .NET.

Em um exemplo típico abaixo, um dispositivo gera alguns dados, que são enviados como uma solicitação HTTP para o serviço em execução na nuvem. O cliente Orleans em execução no servidor front-end recebe essa chamada HTTP e publica os dados em um fluxo de dispositivos correspondente:

C#
public async Task OnHttpCall(DeviceEvent deviceEvent)
{
     // Post data directly into the device's stream.
     IStreamProvider streamProvider =
        GrainClient.GetStreamProvider("MyStreamProvider");

    IAsyncStream<DeviceEventData> deviceStream =
        streamProvider.GetStream<DeviceEventData>(
            deviceEvent.DeviceId, "MyNamespace");

     await deviceStream.OnNextAsync(deviceEvent.Data);
}

Em outro exemplo abaixo, um usuário de chat (implementado como Granularidade do Orleans) ingressa em uma sala de chat, obtém um identificador para um fluxo de mensagens de chat gerado por todos os outros usuários nesta sala e o assina. Observe que o usuário de chat não precisa saber sobre a granularidade da sala de chat em si (pode não haver tal granularidade em nosso sistema) ou sobre outros usuários nesse grupo que produzem mensagens. Nem é preciso dizer que, para publicar no fluxo de chat, os usuários não precisam saber quem está inscrito no fluxo no momento. Isso demonstra como os usuários de chat podem estar completamente desacoplados no tempo e no espaço.

C#
public class ChatUser: Grain
{
    public async Task JoinChat(Guid chatGroupId)
    {
        IStreamProvider streamProvider =
            base.GetStreamProvider("MyStreamProvider");

        IAsyncStream<string> chatStream =
            streamProvider.GetStream<string>(chatGroupId, "MyNamespace");

        await chatStream.SubscribeAsync(
            async (message, token) => Console.WriteLine(message))
    }
}

Exemplo de início rápido

O Exemplo de Início Rápido é uma boa visão geral rápida do fluxo de trabalho geral de usar de fluxos no aplicativo. Depois de lê-lo, você deve ler as APIs de programação de fluxos para obter uma compreensão mais profunda dos conceitos.

APIs de programação de fluxos

APIs de programação de fluxos descreve em detalhes as APIs de programação.

Provedores de fluxo

Os fluxos podem vir de canais físicos de várias formas e maneiras e podem ter semântica diferente. O Orleans Streaming foi projetado para dar suporte a essa diversidade por meio do conceito de Provedores de Fluxo, que é um ponto de extensibilidade no sistema. Atualmente, o Orleans tem implementações de provedores de dois fluxos: Provedor de Fluxo de Mensagens Simples baseado em TCP e Provedor de Fluxo de Fila do Azure baseado em Fila do Azure. Mais detalhes sobre provedores de fluxo podem ser encontrados em Provedores de Fluxo.

Semântica de fluxo

Semântica de assinatura de fluxo:

Os fluxos do Orleans garantem consistência sequencial para operações de Assinatura de fluxo. Especificamente, quando um consumidor assina um fluxo, uma vez que a operação Task de representação da assinatura foi resolvida com êxito, o consumidor vê todos os eventos gerados após a assinatura. Além disso, fluxos Retrocedíveis permitem que você assine de um ponto arbitrário no tempo no passado usando StreamSequenceToken. Para mais informações, confira Provedores de fluxo do Orleans.

Garantias de entrega de eventos de fluxo individuais:

As garantias de entrega de eventos individuais dependem de provedores de fluxo individuais. Alguns fornecem apenas entregas de melhor esforço no máximo uma vez (como SMS (Fluxos de Mensagens Simples)), enquanto outros fornecem entrega pelo menos uma vez (como fluxos de fila do Azure). É possível, inclusive, criar um provedor de streaming que garanta entrega exatamente uma vez (ainda não temos esse provedor, mas é possível criar um).

Ordem de entrega de eventos:

A ordem dos eventos também depende de um provedor de fluxo específico. Em fluxos de SMS, o produtor controla explicitamente a ordem dos eventos vistos pelo consumidor controlando a forma como os publica. Os fluxos da Fila do Azure não garantem a ordem PEPS, pois as Filas do Azure subjacentes não garantem a ordem em casos de falha. Os aplicativos também podem controlar a ordenação de entrega de fluxo usando StreamSequenceToken.

Implementação de fluxos

A Implementação de fluxos do Orleans apresenta uma visão geral de alto nível da implementação interna.

Exemplos de código

Mais exemplos de como usar APIs de streaming em uma granularidade podem ser encontrados aqui. Planejamos criar mais amostras no futuro.

Confira também