Scénáře testovatelnosti

  • Článek

Velké distribuované systémy, jako jsou cloudové infrastruktury, jsou ze své podstaty nespolehlivé. Azure Service Fabric umožňuje vývojářům psát služby, které poběží nad nespolehlivými infrastrukturami. Aby vývojáři mohli psát vysoce kvalitní služby, musí být schopni vyvolat takovou nespolehlivou infrastrukturu, aby mohli otestovat stabilitu svých služeb.

Služba Fault Analysis Service umožňuje vývojářům indukovat akce selhání k testování služeb v případě selhání. Cílené simulované chyby vás ale dostanou jenom doposud. Pokud chcete testování posunout dál, můžete použít testovací scénáře v Service Fabric: test chaosu a test převzetí služeb při selhání. Tyto scénáře simulují průběžné prokládání chyb, jak řádné, tak nevracené, v celém clusteru v delších časových obdobích. Jakmile je test nakonfigurovaný s četností a druhem chyb, je možné ho spustit prostřednictvím rozhraní API jazyka C# nebo PowerShellu a generovat chyby v clusteru a ve vaší službě.

Upozornění

ChaosTestScenario je nahrazen odolnějším chaosem založeným na službách. Další podrobnosti najdete v novém článku Řízený chaos .

Test chaosu

Scénář chaosu generuje chyby v celém clusteru Service Fabric. Tento scénář zkomprimuje chyby, ke které obvykle dochází v měsících nebo letech, na několik hodin. Kombinace prokládaných chyb s vysokou chybovou frekvencí najde rohové případy, které jsou jinak vynechány. To vede k výraznému zlepšení kvality kódu služby.

Chyby simulované v testu chaosu

  • Restartování uzlu
  • Restartování nasazeného balíčku kódu
  • Odebrání repliky
  • Restartování repliky
  • Přesunutí primární repliky (volitelné)
  • Přesunutí sekundární repliky (volitelné)

Test chaosu spustí několik iterací chyb a ověření clusteru po zadanou dobu. Čas strávený stabilizací clusteru a úspěšným ověřením je také konfigurovatelný. Scénář selže, když při ověřování clusteru dojde k jednomu selhání.

Zvažte například testovací sadu, která bude běžet po dobu jedné hodiny s maximálně třemi souběžnými chybami. Test vyvolá tři chyby a pak ověří stav clusteru. Test bude iterovat předchozím krokem, dokud cluster nebude v pořádku nebo uplyne jedna hodina. Pokud cluster přestane být v pořádku při jakékoli iteraci, tj. během nakonfigurované doby se nestabiluje, test selže s výjimkou. Tato výjimka značí, že se něco nepovedlo a vyžaduje další šetření.

Ve své současné podobě modul generování chyb v testu chaosu vyvolává pouze bezpečné chyby. To znamená, že při absenci externích chyb nedojde k kvoru nebo ztrátě dat.

Důležité možnosti konfigurace

  • TimeToRun: Celková doba, po kterou se test spustí, než se úspěšně dokončí. Test může být dokončen dříve namísto selhání ověření.
  • MaxClusterStabilizationTimeout: Maximální doba čekání na v pořádku clusteru před selháním testu. Provádí se kontrola, jestli je stav clusteru v pořádku, jestli je stav služby v pořádku, jestli se pro oddíl služby dosáhne cílové sady replik a neexistují žádné repliky InBuild.
  • MaxConcurrentFaults: Maximální počet souběžných chyb vyvolaných v každé iteraci. Čím vyšší je číslo, tím agresivnější test, což vede ke složitějším kombinacím převzetí služeb při selhání a přechodů. Test zaručuje, že při absenci externích chyb nedojde ke ztrátě kvora nebo dat bez ohledu na to, jak vysoká je tato konfigurace.
  • EnableMoveReplicaFaults: Povolí nebo zakáže chyby, které způsobují přesun primární nebo sekundární repliky. Tyto chyby jsou ve výchozím nastavení zakázané.
  • WaitTimeBetweenIterations: Doba čekání mezi iteracemi, tj. po kole chyb a odpovídajícím ověření.

Jak spustit test chaosu

Ukázka v jazyce 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";

        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

Modul Service Fabric PowerShell obsahuje dva způsoby, jak začít scénář chaosu. Invoke-ServiceFabricChaosTestScenario je založený na klientovi, a pokud se klientský počítač vypne v polovině testu, nebudou zavedeny žádné další chyby. Případně existuje sada příkazů, které mají v případě vypnutí počítače ponechat test spuštěný. Start-ServiceFabricChaos používá stavovou a spolehlivou systémovou službu s názvem FaultAnalysisService, která zajišťuje, aby chyby zůstaly zavedeny, dokud nebude spuštěný TimeToRun. Stop-ServiceFabricChaos lze použít k ručnímu zastavení scénáře a Get-ServiceFabricChaosReport získá sestavu. Další informace najdete v referenčních informacích k Azure Service Fabric PowerShellu a Nasměrování řízeného chaosu v clusterech Service Fabric.

$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

Test převzetí služeb při selhání

Scénář testu převzetí služeb při selhání je verze scénáře testu chaosu, která cílí na konkrétní oddíl služby. Testuje účinek převzetí služeb při selhání na konkrétní oddíl služby, zatímco ostatní služby nejsou ovlivněné. Jakmile je nakonfigurovaný s informacemi o cílovém oddílu a dalšími parametry, spustí se jako nástroj na straně klienta, který pomocí rozhraní API jazyka C# nebo PowerShellu generuje chyby pro oddíl služby. Scénář iteruje posloupnost simulovaných chyb a ověřování služeb, zatímco obchodní logika běží na straně, aby poskytovala úlohu. Selhání při ověřování služby značí problém, který vyžaduje další šetření.

Chyby simulované v testu převzetí služeb při selhání

  • Restartování nasazeného balíčku kódu, ve kterém je oddíl hostovaný
  • Odebrání primární/sekundární repliky nebo bezstavové instance
  • Restartování primární sekundární repliky (pokud je trvalá služba)
  • Přesunutí primární repliky
  • Přesunutí sekundární repliky
  • Restartujte oddíl.

Test převzetí služeb při selhání vyvolá zvolenou chybu a pak ve službě spustí ověření, aby se zajistila její stabilita. Test převzetí služeb při selhání indukuje najednou pouze jednu chybu, na rozdíl od možných více chyb v testu chaosu. Pokud se oddíl služby nestabiluje v rámci nakonfigurovaného časového limitu po každé chybě, test selže. Test indukuje pouze bezpečné chyby. To znamená, že pokud nedojde k externím selháním, nedojde ke ztrátě kvora nebo dat.

Důležité možnosti konfigurace

  • PartitionSelector: Selektor objektu, který určuje oddíl, na který se má cílit.
  • TimeToRun: Celková doba, po kterou se test spustí před dokončením.
  • MaxServiceStabilizationTimeout: Maximální doba čekání na v pořádku clusteru před selháním testu. Provádí se kontrola, jestli je stav služby v pořádku, jestli je dosažena velikost cílové sady replik pro všechny oddíly a neexistují žádné repliky InBuild.
  • WaitTimeBetweenFaults: Doba čekání mezi každou chybou a ověřovacím cyklem.

Jak spustit test převzetí služeb při selhání

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