Lezen in het Engels

Delen via


Streamen met Orleans

Orleans v.1.0.0 heeft ondersteuning toegevoegd voor streaming-extensies voor het programmeermodel. Streaming-extensies bieden een set abstracties en API's die het denken over en werken met streams eenvoudiger en robuuster maken. Met streaming-extensies kunnen ontwikkelaars reactieve toepassingen schrijven die op een gestructureerde manier op een reeks gebeurtenissen werken. Het uitbreidbaarheidsmodel van streamproviders maakt het programmeermodel compatibel met en draagbaar voor een breed scala aan bestaande wachtrijtechnologieën, zoals Event Hubs, ServiceBus, Azure Queues en Apache Kafka. U hoeft geen speciale code te schrijven of speciale processen uit te voeren om met dergelijke wachtrijen te communiceren.

Waarom zou het me schelen?

Als u al alles weet over Stream Processing en bekend bent met technologieën zoals Event Hubs, Kafka, Azure Stream Analytics, Apache Storm, Apache Spark Streaming en Reactive Extensions (Rx) in .NET, vraagt u misschien waarom het u moet schelen. Waarom hebben we nog een Stream Processing System nodig en hoe Actors zijn gerelateerd aan Streams?"Waarom Orleans Streams?" is bedoeld om die vraag te beantwoorden.

Programmeermodel

Er zijn verschillende principes achter Orleans Streams Programming Model:

  1. Orleans streams zijn virtueel. Dat wil gezegd, er bestaat altijd een stroom. Het wordt niet expliciet gemaakt of vernietigd en kan nooit mislukken.
  2. Streams worden geïdentificeerd door stroom-id's. Dit zijn alleen logische namen die bestaan uit GUID's en tekenreeksen.
  3. Orleans Streams u de mogelijkheid geven om de generatie van gegevens los te koppelen van de verwerking, zowel in tijd als ruimte. Dit betekent dat de streamproducent en de streamgebruiker zich op verschillende servers of in verschillende tijdzones bevinden en bestand zijn tegen storingen.
  4. Orleans streams zijn lichtgewicht en dynamisch. Orleans Streaming Runtime is ontworpen voor het verwerken van een groot aantal streams die komen en gaan met een hoge snelheid.
  5. Orleans-stroombindingen zijn dynamisch. Orleans Streaming Runtime is ontworpen voor het afhandelen van gevallen waarbij korrels verbinding maken met en de verbinding met streams met een hoge snelheid verbreken.
  6. Orleans Streaming Runtime beheert transparant de levenscyclus van streamverbruik. Nadat een toepassing zich op een stream heeft geabonneerd, ontvangt deze de gebeurtenissen van de stream, zelfs in de aanwezigheid van fouten.
  7. Orleans streams werken uniform over korrels en Orleans clients.

Programmeer-API's

Toepassingen communiceren met streams met behulp van Orleans.Streams.IAsyncStream<T>, waarmee de Orleans.Streams.IAsyncObserver<T> en Orleans.Streams.IAsyncObservable<T> interfaces worden geïmplementeerd. Deze API's zijn vergelijkbaar met de bekende reactieve extensies (Rx) in .NET.

In een typisch voorbeeld hieronder genereert een apparaat enkele gegevens, die worden verzonden als een HTTP-aanvraag naar de service die wordt uitgevoerd in de cloud. De Orleans-client die wordt uitgevoerd op de front-endserver ontvangt deze HTTP-aanroep en publiceert de gegevens in een overeenkomende apparaatstroom:

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);
}

In een ander voorbeeld hieronder neemt een chatgebruiker (geïmplementeerd als Orleans Grain) deel aan een chatruimte, krijgt een ingang tot een stroom chatberichten die door alle andere gebruikers in deze ruimte worden gegenereerd en zich hierop abonneert. U ziet dat de chatgebruiker niet hoeft te weten over het graan van de chatruimte zelf (er is mogelijk niet zo'n korrel in ons systeem) of over andere gebruikers in die groep die berichten produceren. Om te publiceren naar de chatstream hoeven gebruikers niet te weten wie er momenteel is geabonneerd op de stream. Dit laat zien hoe chatgebruikers volledig kunnen worden losgekoppeld in tijd en ruimte.

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))
    }
}

Quickstart-voorbeeld

Het quick Startmenu sample is een goed overzicht van de algemene werkstroom voor het gebruik van streams in de toepassing. Nadat u deze hebt gelezen, moet u de Streams Programmeer-API's lezen om meer inzicht te krijgen in de concepten.

Streams programmeer-API's

Een Streams Programmeer-API's biedt een gedetailleerde beschrijving van de programmeer-API's.

Stream-providers

Streams kunnen komen via fysieke kanalen van verschillende vormen en vormen en kunnen verschillende semantiek hebben. Orleans Streaming is ontworpen om deze diversiteit te ondersteunen via het concept van Stream Providers, dat een uitbreidbaarheidspunt in het systeem is. Orleans heeft momenteel implementaties van twee streamproviders: TCP-gebaseerde Simple Message Stream Provider en Azure Queue Stream Provider. Meer informatie over Stream-providers vindt u op Stream-providers.

Semantiek streamen

Semantiek van abonnement streamen:

Orleans Streams sequentiële consistentie garanderen voor Stream-abonnementsbewerkingen. Wanneer een consument zich abonneert op een stream, ziet de consument, zodra de Task weergave van de abonnementsbewerking is opgelost, alle gebeurtenissen die zijn gegenereerd nadat deze zich heeft geabonneerd. Bovendien kunt u met behulp van StreamSequenceTokenrewindable streams zich abonneren vanaf een willekeurig tijdstip in het verleden. Zie Orleans Stream Providers voor meer informatie.

Leveringsgaranties voor afzonderlijke Stream-gebeurtenissen:

Garanties voor de levering van afzonderlijke gebeurtenissen zijn afhankelijk van afzonderlijke streamproviders. Sommige bieden slechts best-effort voor maximaal één levering (zoals Simple Message Streams (Sms)), terwijl andere ten minste één keer leveren (zoals Azure Queue Streams). Het is zelfs mogelijk om een streamingprovider te bouwen die precies één levering garandeert (we hebben nog geen dergelijke provider, maar het is mogelijk om er een te bouwen).

Leveringsorder voor gebeurtenissen:

Gebeurtenisvolgorde is ook afhankelijk van een bepaalde streamprovider. In Sms streams bepaalt de producent expliciet de volgorde van gebeurtenissen die door de consument worden gezien door de manier waarop deze worden gepubliceerd. Azure Queue-streams garanderen geen FIFO-volgorde, omdat de onderliggende Azure-wachtrijen de volgorde niet garanderen in mislukte gevallen. Toepassingen kunnen ook de volgorde van de levering van stromen beheren met behulp van StreamSequenceToken.

Streams implementatie

De Orleans Streams Implementatie biedt een algemeen overzicht van de interne implementatie.

Codevoorbeelden

Meer voorbeelden van het gebruik van streaming-API's binnen een graan vindt u hier. We zijn van plan om in de toekomst meer voorbeelden te maken.

Zie ook