Share via

Testbarhetsscenarier

  • Artikel

Stora distribuerade system som molninfrastrukturer är otillförlitliga. Azure Service Fabric ger utvecklare möjlighet att skriva tjänster som kan köras ovanpå otillförlitliga infrastrukturer. För att kunna skriva tjänster av hög kvalitet måste utvecklare kunna inducera en sådan otillförlitlig infrastruktur för att testa stabiliteten i sina tjänster.

Felanalystjänsten ger utvecklare möjlighet att inducera felåtgärder för att testa tjänster i händelse av fel. Riktade simulerade fel tar dig dock bara så långt. Om du vill fortsätta testningen kan du använda testscenarierna i Service Fabric: ett kaostest och ett redundanstest. Dessa scenarier simulerar kontinuerliga interfolierade fel, både graciösa och felaktiga, i hela klustret under längre tidsperioder. När ett test har konfigurerats med hastighet och typ av fel kan det startas via antingen C#-API:er eller PowerShell för att generera fel i klustret och din tjänst.

Varning

ChaosTestScenario ersätts av ett mer motståndskraftigt, tjänstbaserat kaos. Se den nya artikeln Controlled Chaos (Kontrollerat kaos) för mer information.

Kaostest

Kaosscenariot genererar fel i hela Service Fabric-klustret. Scenariot komprimerar fel som vanligtvis visas i månader eller år till några timmar. Kombinationen av interfolierade fel med den höga felfrekvensen hittar hörnfall som annars missas. Detta leder till en betydande förbättring av tjänstens kodkvalitet.

Fel simulerade i kaostestet

  • Starta om en nod
  • Starta om ett distribuerat kodpaket
  • Ta bort en replik
  • Starta om en replik
  • Flytta en primär replik (valfritt)
  • Flytta en sekundär replik (valfritt)

Kaostestet kör flera iterationer av fel och klustervalidering under den angivna tidsperioden. Den tid som krävs för att klustret ska stabiliseras och för att verifieringen ska lyckas kan också konfigureras. Scenariot misslyckas när du stöter på ett enskilt fel i klusterverifieringen.

Anta till exempel att en testuppsättning körs i en timme med högst tre samtidiga fel. Testet inducerar tre fel och validerar sedan klustrets hälsa. Testet itererar genom föregående steg tills klustret blir felfritt eller en timme passerar. Om klustret blir felfritt i en iteration, dvs. det inte stabiliseras inom en konfigurerad tid, misslyckas testet med ett undantag. Det här undantaget anger att något har gått fel och behöver undersökas ytterligare.

I sin nuvarande form inducerar felgenereringsmotorn i kaostestet endast säkra fel. Det innebär att om det inte finns några externa fel uppstår aldrig ett kvorum eller dataförlust.

Viktiga konfigurationsalternativ

  • TimeToRun: Total tid som testet körs innan det slutförs. Testet kan slutföras tidigare i stället för ett valideringsfel.
  • MaxClusterStabilizationTimeout: Maximal tid att vänta tills klustret blir felfritt innan testet misslyckas. Kontrollerna som utförs är om klustrets hälsa är OK, tjänstens hälsa är OK, målreplikuppsättningens storlek uppnås för tjänstpartitionen och inga InBuild-repliker finns.
  • MaxConcurrentFaults: Maximalt antal samtidiga fel som induceras i varje iteration. Ju högre tal, desto aggressivare blir testet, vilket resulterar i mer komplexa redundansväxlingar och övergångskombinationer. Testet garanterar att om det inte finns externa fel kommer det inte att uppstå kvorum eller dataförlust, oavsett hur hög den här konfigurationen är.
  • EnableMoveReplicaFaults: Aktiverar eller inaktiverar de fel som orsakar flytten av de primära eller sekundära replikerna. Dessa fel är inaktiverade som standard.
  • WaitTimeBetweenIterations: Hur lång tid det tar att vänta mellan iterationer, d.v.s. efter en felrunda och motsvarande verifiering.

Så här kör du kaostestet

C#-exempel

using System;
using System.Fabric;
using System.Fabric.Testability.Scenario;
using System.Threading;
using System.Threading.Tasks;

class Test
{
    public static int Main(string[] args)
    {
        string clusterConnection = "localhost:19000";

        Console.WriteLine("Starting Chaos Test Scenario...");
        try
        {
            RunChaosTestScenarioAsync(clusterConnection).Wait();
        }
        catch (AggregateException ae)
        {
            Console.WriteLine("Chaos Test Scenario did not complete: ");
            foreach (Exception ex in ae.InnerExceptions)
            {
                if (ex is FabricException)
                {
                    Console.WriteLine("HResult: {0} Message: {1}", ex.HResult, ex.Message);
                }
            }
            return -1;
        }

        Console.WriteLine("Chaos Test Scenario completed.");
        return 0;
    }

    static async Task RunChaosTestScenarioAsync(string clusterConnection)
    {
        TimeSpan maxClusterStabilizationTimeout = TimeSpan.FromSeconds(180);
        uint maxConcurrentFaults = 3;
        bool enableMoveReplicaFaults = true;

        // Create FabricClient with connection and security information here.
        FabricClient fabricClient = new FabricClient(clusterConnection);

        // The chaos test scenario should run at least 60 minutes or until it fails.
        TimeSpan timeToRun = TimeSpan.FromMinutes(60);
        ChaosTestScenarioParameters scenarioParameters = new ChaosTestScenarioParameters(
          maxClusterStabilizationTimeout,
          maxConcurrentFaults,
          enableMoveReplicaFaults,
          timeToRun);

        // Other related parameters:
        // Pause between two iterations for a random duration bound by this value.
        // scenarioParameters.WaitTimeBetweenIterations = TimeSpan.FromSeconds(30);
        // Pause between concurrent actions for a random duration bound by this value.
        // scenarioParameters.WaitTimeBetweenFaults = TimeSpan.FromSeconds(10);

        // Create the scenario class and execute it asynchronously.
        ChaosTestScenario chaosScenario = new ChaosTestScenario(fabricClient, scenarioParameters);

        try
        {
            await chaosScenario.ExecuteAsync(CancellationToken.None);
        }
        catch (AggregateException ae)
        {
            throw ae.InnerException;
        }
    }
}

PowerShell

Service Fabric PowerShell-modulen innehåller två sätt att påbörja ett kaosscenario. Invoke-ServiceFabricChaosTestScenario är klientbaserad och om klientdatorn stängs av halvvägs genom testet introduceras inga ytterligare fel. Det finns också en uppsättning kommandon som är avsedda att hålla testet igång om datorn stängs av. Start-ServiceFabricChaos använder en tillståndskänslig och tillförlitlig systemtjänst som kallas FaultAnalysisService, vilket säkerställer att fel förblir introducerade tills TimeToRun är igång. Stop-ServiceFabricChaos kan användas för att stoppa scenariot manuellt och Get-ServiceFabricChaosReport hämtar en rapport. Mer information finns i Referens för Azure Service Fabric PowerShell och Inducera kontrollerat kaos i Service Fabric-kluster.

$connection = "localhost:19000"
$timeToRun = 60
$maxStabilizationTimeSecs = 180
$concurrentFaults = 3
$waitTimeBetweenIterationsSec = 60

Connect-ServiceFabricCluster $connection

Invoke-ServiceFabricChaosTestScenario -TimeToRunMinute $timeToRun -MaxClusterStabilizationTimeoutSec $maxStabilizationTimeSecs -MaxConcurrentFaults $concurrentFaults -EnableMoveReplicaFaults -WaitTimeBetweenIterationsSec $waitTimeBetweenIterationsSec

Redundanstest

Redundanstestscenariot är en version av scenariot med kaostest som är avsedd för en specifik tjänstpartition. Den testar effekten av redundansväxling på en specifik tjänstpartition samtidigt som de andra tjänsterna inte påverkas. När den har konfigurerats med målpartitionsinformationen och andra parametrar körs den som ett verktyg på klientsidan som använder antingen C#-API:er eller PowerShell för att generera fel för en tjänstpartition. Scenariot itererar genom en sekvens med simulerade fel och tjänstvalidering medan din affärslogik körs på sidan för att tillhandahålla en arbetsbelastning. Ett fel i tjänstverifieringen indikerar ett problem som behöver undersökas ytterligare.

Simulerade fel i redundanstestet

  • Starta om ett distribuerat kodpaket där partitionen finns
  • Ta bort en primär/sekundär replik eller tillståndslös instans
  • Starta om en primär sekundär replik (om en beständig tjänst)
  • Flytta en primär replik
  • Flytta en sekundär replik
  • Starta om partitionen

Redundanstestet inducerar ett valt fel och kör sedan validering på tjänsten för att säkerställa dess stabilitet. Redundanstestet inducerar bara ett fel i taget, till skillnad från eventuella flera fel i kaostestet. Om tjänstpartitionen inte stabiliseras inom den konfigurerade tidsgränsen efter varje fel misslyckas testet. Testet inducerar endast säkra fel. Det innebär att om det inte uppstår externa fel uppstår inte ett kvorum eller dataförlust.

Viktiga konfigurationsalternativ

  • PartitionSelector: Selector-objekt som anger den partition som ska vara mål.
  • TimeToRun: Total tid som testet körs innan det slutförs.
  • MaxServiceStabilizationTimeout: Maximal väntetid för att klustret ska bli felfritt innan testet misslyckas. Kontrollerna som utförs är om tjänstens hälsotillstånd är OK, målreplikuppsättningens storlek uppnås för alla partitioner och att det inte finns några InBuild-repliker.
  • WaitTimeBetweenFaults: Väntetid mellan varje fel- och valideringscykel.

Så här kör du redundanstestet

C#

using System;
using System.Fabric;
using System.Fabric.Testability.Scenario;
using System.Threading;
using System.Threading.Tasks;

class Test
{
    public static int Main(string[] args)
    {
        string clusterConnection = "localhost:19000";
        Uri serviceName = new Uri("fabric:/samples/PersistentToDoListApp/PersistentToDoListService");

        Console.WriteLine("Starting Chaos Test Scenario...");
        try
        {
            RunFailoverTestScenarioAsync(clusterConnection, serviceName).Wait();
        }
        catch (AggregateException ae)
        {
            Console.WriteLine("Chaos Test Scenario did not complete: ");
            foreach (Exception ex in ae.InnerExceptions)
            {
                if (ex is FabricException)
                {
                    Console.WriteLine("HResult: {0} Message: {1}", ex.HResult, ex.Message);
                }
            }
            return -1;
        }

        Console.WriteLine("Chaos Test Scenario completed.");
        return 0;
    }

    static async Task RunFailoverTestScenarioAsync(string clusterConnection, Uri serviceName)
    {
        TimeSpan maxServiceStabilizationTimeout = TimeSpan.FromSeconds(180);
        PartitionSelector randomPartitionSelector = PartitionSelector.RandomOf(serviceName);

        // Create FabricClient with connection and security information here.
        FabricClient fabricClient = new FabricClient(clusterConnection);

        // The chaos test scenario should run at least 60 minutes or until it fails.
        TimeSpan timeToRun = TimeSpan.FromMinutes(60);
        FailoverTestScenarioParameters scenarioParameters = new FailoverTestScenarioParameters(
          randomPartitionSelector,
          timeToRun,
          maxServiceStabilizationTimeout);

        // Other related parameters:
        // Pause between two iterations for a random duration bound by this value.
        // scenarioParameters.WaitTimeBetweenIterations = TimeSpan.FromSeconds(30);
        // Pause between concurrent actions for a random duration bound by this value.
        // scenarioParameters.WaitTimeBetweenFaults = TimeSpan.FromSeconds(10);

        // Create the scenario class and execute it asynchronously.
        FailoverTestScenario failoverScenario = new FailoverTestScenario(fabricClient, scenarioParameters);

        try
        {
            await failoverScenario.ExecuteAsync(CancellationToken.None);
        }
        catch (AggregateException ae)
        {
            throw ae.InnerException;
        }
    }
}

PowerShell

$connection = "localhost:19000"
$timeToRun = 60
$maxStabilizationTimeSecs = 180
$waitTimeBetweenFaultsSec = 10
$serviceName = "fabric:/SampleApp/SampleService"

Connect-ServiceFabricCluster $connection

Invoke-ServiceFabricFailoverTestScenario -TimeToRunMinute $timeToRun -MaxServiceStabilizationTimeoutSec $maxStabilizationTimeSecs -WaitTimeBetweenFaultsSec $waitTimeBetweenFaultsSec -ServiceName $serviceName -PartitionKindSingleton