Kom igång med Reliable Services

Ett Azure Service Fabric-program innehåller en eller flera tjänster som kör koden. Den här guiden visar hur du skapar både tillståndslösa och tillståndskänsliga Service Fabric-program med Reliable Services.

På den här sidan finns en träningsvideo som också visar hur du skapar en tillståndslös Reliable-tjänst.

Grundläggande begrepp

För att komma igång med Reliable Services behöver du bara förstå några grundläggande begrepp:

• Tjänsttyp: Det här är din tjänstimplementering. Den definieras av den klass som du skriver som utökar StatelessService och andra kod- eller beroenden som används däri, tillsammans med ett namn och ett versionsnummer.
• Namngiven tjänstinstans: Om du vill köra tjänsten skapar du namngivna instanser av din tjänsttyp, ungefär som du skapar objektinstanser av en klasstyp. En tjänstinstans har ett namn i form av en URI med hjälp av schemat "fabric:/", till exempel "fabric:/MyApp/MyService".
• Tjänstvärd: De namngivna tjänstinstanser som du skapar måste köras i en värdprocess. Tjänstvärden är bara en process där instanser av tjänsten kan köras.
• Tjänstregistrering: Registreringen sammanför allt. Tjänsttypen måste registreras med Service Fabric-körningen i en tjänstvärd för att Service Fabric ska kunna skapa instanser av den.

Skapa en tillståndslös tjänst

En tillståndslös tjänst är en typ av tjänst som för närvarande är normen i molnprogram. Det anses vara tillståndslöst eftersom själva tjänsten inte innehåller data som behöver lagras på ett tillförlitligt sätt eller göras mycket tillgängliga. Om en instans av en tillståndslös tjänst stängs av går allt dess interna tillstånd förlorat. I den här typen av tjänst måste tillståndet bevaras i ett externt arkiv, till exempel Azure Tables eller SQL Database, för att det ska göras mycket tillgängligt och tillförlitligt.

Starta Visual Studio 2017 eller Visual Studio 2019 som administratör och skapa ett nytt Service Fabric-programprojekt med namnet HelloWorld:

Skapa sedan ett tillståndslöst tjänstprojekt med . NET Core 2.0 med namnet HelloWorldStateless:

Lösningen innehåller nu två projekt:

• HelloWorld. Det här är programprojektet som innehåller dina tjänster. Den innehåller också programmanifestet som beskriver programmet, samt ett antal PowerShell-skript som hjälper dig att distribuera ditt program.
• HelloWorldStateless. Det här är tjänstprojektet. Den innehåller den tillståndslösa tjänstimplementeringen.

Implementera tjänsten

Öppna filen HelloWorldStateless.cs i tjänstprojektet. I Service Fabric kan en tjänst köra vilken affärslogik som helst. Tjänst-API:et innehåller två startpunkter för din kod:

• En öppen startpunktsmetod med namnet RunAsync, där du kan börja köra alla arbetsbelastningar, inklusive långvariga beräkningsarbetsbelastningar.

protected override async Task RunAsync(CancellationToken cancellationToken)
{
    ...
}

• En kommunikationsinmatningspunkt där du kan ansluta din kommunikationsstack, till exempel ASP.NET Core. Det är här du kan börja ta emot begäranden från användare och andra tjänster.

protected override IEnumerable<ServiceInstanceListener> CreateServiceInstanceListeners()
{
    ...
}

I den här självstudien RunAsync() fokuserar vi på startpunktsmetoden. Det är här du omedelbart kan börja köra koden. Projektmallen innehåller en exempelimplementering av RunAsync() som ökar antalet rullande värden.

RunAsync

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.

    long iterations = 0;

    while (true)
    {
        cancellationToken.ThrowIfCancellationRequested();

        ServiceEventSource.Current.ServiceMessage(this.Context, "Working-{0}", ++iterations);

        await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken);
    }
}

Plattformen anropar den här metoden när en instans av en tjänst är placerad och redo att köras. För en tillståndslös tjänst innebär det bara när tjänstinstansen öppnas. En annulleringstoken tillhandahålls för att samordna när din tjänstinstans måste stängas. I Service Fabric kan den här öppna/stäng-cykeln för en tjänstinstans inträffa många gånger under hela tjänstens livslängd. Detta kan inträffa av olika orsaker, bland annat:

• Systemet flyttar dina tjänstinstanser för resursutjämning.
• Fel uppstår i koden.
• Programmet eller systemet uppgraderas.
• Den underliggande maskinvaran upplever ett avbrott.

Den här orkestreringen hanteras av systemet för att hålla tjänsten högtillgänglig och korrekt balanserad.

RunAsync() bör inte blockera synkront. Din implementering av RunAsync bör returnera en aktivitet eller vänta på långvariga eller blockerande åtgärder så att körningen kan fortsätta. Observera i loopen while(true) i föregående exempel att en uppgiftsretur await Task.Delay() används. Om din arbetsbelastning måste blockeras synkront bör du schemalägga en ny uppgift med Task.Run() i implementeringen RunAsync .

Annullering av din arbetsbelastning är en samarbetsinsats som samordnas av den angivna annulleringstoken. Systemet väntar tills aktiviteten har slutförts (genom slutförande, annullering eller fel) innan den går vidare. Det är viktigt att respektera annulleringstoken, slutföra allt arbete och avsluta RunAsync() så snabbt som möjligt när systemet begär annullering.

I det här tillståndslösa tjänstexemplet lagras antalet i en lokal variabel. Men eftersom det här är en tillståndslös tjänst finns värdet som lagras bara för den aktuella livscykeln för tjänstinstansen. När tjänsten flyttas eller startas om går värdet förlorat.

Skapa en tillståndskänslig tjänst

Service Fabric introducerar en ny typ av tjänst som är tillståndskänslig. En tillståndskänslig tjänst kan upprätthålla tillståndet på ett tillförlitligt sätt inom själva tjänsten, tillsammans med koden som använder den. Tillståndet är högtillgängligt av Service Fabric utan att behöva bevara tillståndet för ett externt arkiv.

Om du vill konvertera ett räknarvärde från tillståndslös till högtillgänglig och beständig, även när tjänsten flyttas eller startas om, behöver du en tillståndskänslig tjänst.

I samma HelloWorld-program kan du lägga till en ny tjänst genom att högerklicka på tjänstreferenserna i programprojektet och välja Lägg till –> ny Service Fabric Service.

Välj .NET Core 2.0 –> Tillståndskänslig tjänst och ge den namnet HelloWorldStateful. Klicka på OK.

Ditt program bör nu ha två tjänster: den tillståndslösa tjänsten HelloWorldStateless och den tillståndskänsliga tjänsten HelloWorldStateful.

En tillståndskänslig tjänst har samma startpunkter som en tillståndslös tjänst. Den största skillnaden är tillgängligheten för en tillståndsprovider som kan lagra tillståndet på ett tillförlitligt sätt. Service Fabric levereras med en implementering av tillståndsprovidern som kallas Reliable Collections, som gör att du kan skapa replikerade datastrukturer via Reliable State Manager. En tillståndskänslig tillförlitlig tjänst använder den här tillståndsprovidern som standard.

Öppna HelloWorldStateful.cs i HelloWorldStateful, som innehåller följande RunAsync-metod:

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.

    var myDictionary = await this.StateManager.GetOrAddAsync<IReliableDictionary<string, long>>("myDictionary");

    while (true)
    {
        cancellationToken.ThrowIfCancellationRequested();

        using (var tx = this.StateManager.CreateTransaction())
        {
            var result = await myDictionary.TryGetValueAsync(tx, "Counter");

            ServiceEventSource.Current.ServiceMessage(this.Context, "Current Counter Value: {0}",
                result.HasValue ? result.Value.ToString() : "Value does not exist.");

            await myDictionary.AddOrUpdateAsync(tx, "Counter", 0, (key, value) => ++value);

            // If an exception is thrown before calling CommitAsync, the transaction aborts, all changes are
            // discarded, and nothing is saved to the secondary replicas.
            await tx.CommitAsync();
        }

        await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken);
    }

RunAsync

RunAsync() fungerar på liknande sätt i tillståndskänsliga och tillståndslösa tjänster. Men i en tillståndskänslig tjänst utför plattformen ytterligare arbete åt dig innan den kör RunAsync(). Det här arbetet kan omfatta att se till att Reliable State Manager och Reliable Collections är redo att användas.

Tillförlitliga samlingar och Reliable State Manager

var myDictionary = await this.StateManager.GetOrAddAsync<IReliableDictionary<string, long>>("myDictionary");

IReliableDictionary är en ordlisteimplementering som du kan använda för att lagra tillståndet i tjänsten på ett tillförlitligt sätt. Med Service Fabric och Reliable Collections kan du lagra data direkt i din tjänst utan att behöva ett externt beständigt lager. Tillförlitliga samlingar gör dina data mycket tillgängliga. Service Fabric gör detta genom att skapa och hantera flera repliker av tjänsten åt dig. Det ger också ett API som abstraherar bort komplexiteten i att hantera dessa repliker och deras tillståndsövergångar.

Reliable Collections kan lagra valfri .NET-typ, inklusive dina anpassade typer, med några varningar:

• Service Fabric gör ditt tillstånd mycket tillgängligt genom att replikera tillstånd mellan noder och Reliable Collections lagrar dina data på en lokal disk på varje replik. Det innebär att allt som lagras i Reliable Collections måste vara serialiserbart. Som standard använder Reliable Collections DataContract för serialisering, så det är viktigt att se till att dina typer stöds av Data Contract Serializer när du använder standard serialiseraren.

• Objekt replikeras för hög tillgänglighet när du genomför transaktioner på Reliable Collections. Objekt som lagras i Reliable Collections lagras i lokalt minne i din tjänst. Det innebär att du har en lokal referens till objektet.

  Det är viktigt att du inte muterar lokala instanser av dessa objekt utan att utföra en uppdateringsåtgärd på den tillförlitliga samlingen i en transaktion. Det beror på att ändringar i lokala instanser av objekt inte replikeras automatiskt. Du måste infoga objektet i ordlistan igen eller använda någon av uppdateringsmetoderna i ordlistan.

Reliable State Manager hanterar Tillförlitliga samlingar åt dig. Du kan bara be Reliable State Manager om en tillförlitlig samling med namn när som helst och när som helst i din tjänst. Reliable State Manager ser till att du får tillbaka en referens. Vi rekommenderar inte att du sparar referenser till tillförlitliga insamlingsinstanser i klassmedlemsvariabler eller egenskaper. Särskild försiktighet måste iakttas för att säkerställa att referensen alltid anges till en instans i tjänstens livscykel. Reliable State Manager hanterar det här arbetet åt dig och är optimerat för upprepade besök.

Transaktionella och asynkrona åtgärder

using (ITransaction tx = this.StateManager.CreateTransaction())
{
    var result = await myDictionary.TryGetValueAsync(tx, "Counter-1");

    await myDictionary.AddOrUpdateAsync(tx, "Counter-1", 0, (k, v) => ++v);

    await tx.CommitAsync();
}

Reliable Collections har många av de åtgärder som deras System.Collections.Generic och System.Collections.Concurrent deras motsvarigheter gör, förutom LINQ (Language Integrated Query). Åtgärder på Reliable Collections är asynkrona. Det beror på att skrivåtgärder med Reliable Collections utför I/O-åtgärder för att replikera och spara data till disk.

Tillförlitliga insamlingsåtgärder är transaktionella, så att du kan hålla tillståndet konsekvent i flera tillförlitliga samlingar och åtgärder. Du kan till exempel ta bort ett arbetsobjekt från en tillförlitlig kö, utföra en åtgärd på den och spara resultatet i en tillförlitlig ordlista, allt inom en enda transaktion. Detta behandlas som en atomisk åtgärd och garanterar att hela åtgärden lyckas eller att hela åtgärden återställs. Om ett fel inträffar efter att du har avmarkerat objektet men innan du sparar resultatet återställs hela transaktionen och objektet finns kvar i kön för bearbetning.

Kör appen

Nu återgår vi till HelloWorld-programmet . Nu kan du skapa och distribuera dina tjänster. När du trycker på F5 skapas och distribueras programmet till ditt lokala kluster.

När tjänsterna har börjat köras kan du visa de genererade händelsespårningshändelserna för Windows (ETW) i ett fönster för diagnostikhändelser . Observera att händelserna som visas kommer från både den tillståndslösa tjänsten och den tillståndskänsliga tjänsten i programmet. Du kan pausa strömmen genom att klicka på knappen Pausa. Du kan sedan granska information om ett meddelande genom att expandera meddelandet.

Nästa steg

Felsöka ditt Service Fabric-program i Visual Studio

Kom igång: Service Fabric Web API-tjänster med självvärdar för OWIN

Läs mer om Reliable Collections

Distribuera ett program

Programuppgradering

Utvecklarreferens för Reliable Services