Scénáře testování

Rozsáhlé 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é se mají spouštět nad nespolehlivou infrastrukturou. Aby mohli psát vysoce kvalitní služby, musí být vývojáři schopni vyvolat takovou nespolehlivý infrastrukturu, aby otestovali stabilitu svých služeb.

Služba Analýza chyb poskytuje vývojářům možnost vyvolat akce selhání k testování služeb v přítomnosti selhání. Cílené simulované chyby vás ale doposud dostanou jenom vy. K dalšímu testování můžete použít testovací scénáře v Service Fabric: chaosový test a test převzetí služeb při selhání. Tyto scénáře simulují souvislé prokládání chyb, a to jak elegantně, tak i nevděčné, v průběhu delších časových období. Jakmile je test nakonfigurovaný s rychlostí a druhem chyb, můžete ho spustit prostřednictvím rozhraní API jazyka C# nebo PowerShellu, aby se vygenerovaly chyby v clusteru a ve vaší službě.

Upozorňující

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

Chaos test

Scénář chaosu generuje chyby v celém clusteru Service Fabric. Scénář komprimuje chyby obvykle v měsících nebo letech na několik hodin. Kombinace prokládání chyb s vysokou mírou selhání najde rohové případy, které by jinak chyběly. To vede k významné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 spouští několik iterací chyb a ověření clusteru po zadanou dobu. Čas strávený pro stabilizaci clusteru a úspěšné ověření je také možné konfigurovat. Scénář selže, když v ověření clusteru dojde k jediné chybě.

Představte si například testovací sadu, která se má spustit 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 v předchozím kroku, dokud cluster nebude v pořádku, nebo jednu hodinu projde. Pokud cluster není v pořádku v jakékoli iteraci, tj. ne stabilizuje se v nakonfigurované době, test selže s výjimkou. Tato výjimka značí, že se něco nepovedlo a vyžaduje další šetření.

V současné podobě modul generování chyb v chaosovém testu vyvolává pouze bezpečné chyby. To znamená, že v případě absence externích chyb nedojde kvorum nebo ztráta dat.

Důležité možnosti konfigurace

• TimeToRun: Celkový čas, po který se test spustí před dokončením úspěšného dokončení. Test může dokončit dříve místo selhání ověření.
• MaxClusterStabilizationTimeout: Maximální doba čekání na to, aby se cluster před selháním testu v pořádku. Provedené kontroly jsou to, jestli je stav clusteru v pořádku, stav služby je v pořádku, velikost sady cílových replik se dosahuje pro oddíl služby a neexistují žádné repliky InBuildu.
• 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 převzetí služeb při selhání a kombinacím přechodů. Test zaručuje, že bez 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ích nebo sekundárních replik. Tyto chyby jsou ve výchozím nastavení zakázané.
• WaitTimeBetweenIterations: Doba čekání mezi iteracemi, tj. po zaokrouhlení chyb a odpovídajících 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 zahájení scénáře chaosu. Invoke-ServiceFabricChaosTestScenario je založená na klientech a pokud je klientský počítač v polovině testu vypnutý, nebudou se zavádět žádné další chyby. Alternativně existuje sada příkazů, které mají test běžet v případě vypnutí počítače. Start-ServiceFabricChaos používá stavovou a spolehlivou systémovou službu s názvem FaultAnalysisService a zajišťuje, aby chyby zůstaly zavedeny, dokud se timeToRun nesvolí. Stop-ServiceFabricChaos lze použít k ručnímu zastavení scénáře a Get-ServiceFabricChaosReport získání sestavy. Další informace najdete v referenčních informacích k Azure Service Fabric PowerShellu a inducing ří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 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 a přitom ponechá ostatní služby nedotčené. Po nakonfigurování s informacemi o cílovém oddílu a dalšími parametry se spustí jako nástroj na straně klienta, který k vygenerování chyb pro oddíl služby používá rozhraní API jazyka C# nebo PowerShell. 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í v ověření služby značí problém, který vyžaduje další šetření.

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

• Restartujte nasazený balíček kódu, ve kterém je oddíl hostovaný.
• Odebrání primární/sekundární repliky nebo bezstavové instance
• Restartujte primární sekundární repliku (pokud 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 jeho stabilita. Test převzetí služeb při selhání vyvolá současně pouze jednu chybu, na rozdíl od možných více chyb v testu chaosu. Pokud se oddíl služby po každé chybě nestabiluje v rámci nakonfigurovaného časového limitu, test selže. Test indukuje pouze bezpečné chyby. To znamená, že bez externích selhání nedojde ke ztrátě kvora nebo dat.

Důležité možnosti konfigurace

• PartitionSelector: Objekt selectoru, který určuje oddíl, na který se má cílit.
• TimeToRun: Celkový čas, po který se test spustí před dokončením.
• MaxService StabilizTimeout: Maximální doba čekání na to, aby se cluster před selháním testu v pořádku. Provedené kontroly jsou, zda je stav služby v pořádku, cílová velikost sady replik se dosahuje pro všechny oddíly a neexistují žádné repliky inbuildu.
• WaitTimeBetweenFaults: Doba čekání mezi každou chybou a ověřovacím cyklem.

Spuštění testu 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