Scenari di testabilitàTestability scenarios

Sistemi distribuiti di grandi dimensioni come le infrastrutture cloud sono intrinsecamente inaffidabili.Large distributed systems like cloud infrastructures are inherently unreliable. Azure Service Fabric offre agli sviluppatori la possibilità di scrivere servizi destinati ad essere eseguiti in infrastrutture inaffidabili.Azure Service Fabric gives developers the ability to write services to run on top of unreliable infrastructures. Per scrivere servizi di qualità elevata, gli sviluppatori devono essere in grado di mettere alla prova un'infrastruttura inaffidabile in modo da testarne la stabilità dei servizi.In order to write high-quality services, developers need to be able to induce such unreliable infrastructure to test the stability of their services.

Il servizio di analisi degli errori offre agli sviluppatori la possibilità di causare azioni di errore e testare i servizi in presenza di errori.The Fault Analysis Service gives developers the ability to induce fault actions to test services in the presence of failures. Gli errori simulati indotti, tuttavia, possono arrivare solo fino a un certo punto.However, targeted simulated faults will get you only so far. Per spingere il test oltre, è possibile usare gli scenari di testi disponibili in Service Fabric: test di chaos e test di failover.To take the testing further, you can use the test scenarios in Service Fabric: a chaos test and a failover test. Questi scenari simulano in tutto il cluster continui errori interfoliati, normali e anomali, per lunghi periodi di tempo.These scenarios simulate continuous interleaved faults, both graceful and ungraceful, throughout the cluster over extended periods of time. Dopo la configurazione con la frequenza e il tipo di errori, il test può essere avviato tramite le API C# o PowerShell, allo scopo di generare errori nel cluster e nel servizio.Once a test is configured with the rate and kind of faults, it can be started through either C# APIs or PowerShell, to generate faults in the cluster and your service.

Avviso

ChaosTestScenario è sostituito da un Chaos più resiliente, basato su servizi.ChaosTestScenario is being replaced by a more resilient, service-based Chaos. Consultare il nuovo articolo Chaos in ambiente controllato per ulteriori dettagli.Please refer to the new article Controlled Chaos for more details.

Test chaosChaos test

Lo scenario chaos genera errori nell’intero cluster dell’infrastruttura di servizi.The chaos scenario generates faults across the entire Service Fabric cluster. Lo scenario comprime in alcune ore gli errori che in genere si osservano in mesi o anni.The scenario compresses faults generally seen in months or years to a few hours. La combinazione di errori interfoliati con un'elevata frequenza di errori consente di trovare casi limite che altrimenti non verrebbero considerati.The combination of interleaved faults with the high fault rate finds corner cases that are otherwise missed. In tal modo è possibile ottenere un notevole miglioramento della qualità del codice del servizio.This leads to a significant improvement in the code quality of the service.

Errori simulati nel test chaosFaults simulated in the chaos test

  • Riavvio di un nodoRestart a node
  • Riavvio di un pacchetto di codice distribuitoRestart a deployed code package
  • Rimozione di una replicaRemove a replica
  • Riavvio di una replicaRestart a replica
  • Spostamento di una replica primaria (facoltativo)Move a primary replica (optional)
  • Spostamento di una replica secondaria (facoltativo)Move a secondary replica (optional)

Il test chaos esegue più iterazioni di errori e di convalide cluster per il periodo di tempo specificato.The chaos test runs multiple iterations of faults and cluster validations for the specified period of time. È possibile configurare anche il tempo impiegato per la stabilizzazione del cluster e il completamento della convalida.The time spent for the cluster to stabilize and for validation to succeed is also configurable. Lo scenario ha esito negativo anche se si verifica un singolo errore nella convalida del cluster.The scenario fails when you hit a single failure in cluster validation.

Si consideri, ad esempio, un test configurato per un'esecuzione della durata di un'ora e con un massimo di tre errori simultanei.For example, consider a test set to run for one hour with a maximum of three concurrent faults. Il test provocherà tre errori e quindi convaliderà l'integrità del cluster.The test will induce three faults, and then validate the cluster health. Il test ripeterà il passaggio precedente fino a quando non sarà trascorsa un'ora o lo stato del cluster diventerà non integro.The test will iterate through the previous step till the cluster becomes unhealthy or one hour passes. Se in una qualsiasi iterazione il cluster diventa non integro, ovvero non si stabilizza entro un tempo configurato, il test avrà esito negativo con un'eccezione.If the cluster becomes unhealthy in any iteration, i.e. it does not stabilize within a configured time, the test will fail with an exception. Questa eccezione indica che si è verificato un errore ed è necessaria un'ulteriore analisi.This exception indicates that something has gone wrong and needs further investigation.

Nella forma attuale, il motore di generazione di errori del test Chaos provoca solo errori sicuri.In its current form, the fault generation engine in the chaos test induces only safe faults. In assenza di errori esterni, quindi, non si verifica mai una perdita di quorum o di dati.This means that in the absence of external faults, a quorum or data loss will never occur.

Opzioni di configurazione importantiImportant configuration options

  • TimeToRun: tempo totale per il quale il test verrà eseguito prima del completamento con esito positivo.TimeToRun: Total time that the test will run before finishing with success. Il test può essere completato in anticipo anziché produrre un errore di convalida.The test can finish earlier in lieu of a validation failure.
  • MaxClusterStabilizationTimeout: tempo di attesa massimo perché il cluster diventi integro prima che ne venga dichiarato l'esito negativo.MaxClusterStabilizationTimeout: Maximum amount of time to wait for the cluster to become healthy before failing the test. I controlli eseguiti verificano che il cluster e il servizio siano integri, che la dimensione del set di repliche di destinazione sia stata raggiunta per la partizione di servizio e che non siano presenti repliche InBuild.The checks performed are whether cluster health is OK, service health is OK, the target replica set size is achieved for the service partition, and no InBuild replicas exist.
  • MaxConcurrentFaults: numero massimo di errori simultanei indotti in ogni iterazione.MaxConcurrentFaults: Maximum number of concurrent faults induced in each iteration. Maggiore è il numero, più aggressivo è il test e più complesse saranno le combinazioni di failover e transizioni.The higher the number, the more aggressive the test, hence resulting in more complex failovers and transition combinations. Il test garantisce che in assenza di errori esterni non si verificherà una perdita di quorum o di dati, a prescindere da quanto è elevata la configurazione.The test guarantees that in absence of external faults there will not be a quorum or data loss, irrespective of how high this configuration is.
  • EnableMoveReplicaFaults: abilita o disabilita gli errori che causano lo spostamento delle repliche primarie o secondarie.EnableMoveReplicaFaults: Enables or disables the faults that are causing the move of the primary or secondary replicas. Questi errori sono disabilitati per impostazione predefinita.These faults are disabled by default.
  • WaitTimeBetweenIterations: quantità di tempo di attesa tra due iterazioni, ad esempio dopo un ciclo di errori e la convalida corrispondente.WaitTimeBetweenIterations: Amount of time to wait between iterations, i.e. after a round of faults and corresponding validation.

Come eseguire il test chaosHow to run the chaos test

Esempio C#C# sample

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

PowerShellPowerShell

$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 di failoverFailover test

Lo scenario di test di failover è una versione dello scenario di test chaos destinata a una specifica partizione del servizio.The failover test scenario is a version of the chaos test scenario that targets a specific service partition. Verifica l'effetto del failover in una specifica partizione di servizio senza interessare gli altri servizi.It tests the effect of failover on a specific service partition while leaving the other services unaffected. Una volta configurato con informazioni sulla partizione di destinazione e altri parametri, il test viene eseguito come strumento lato client che usa API C# o PowerShell per generare errori per una partizione di servizio.Once it's configured with the target partition information and other parameters, it runs as a client-side tool that uses either C# APIs or PowerShell to generate faults for a service partition. Lo scenario ripete una sequenza di errori simulati e test di convalida del servizio, mentre viene eseguita la logica di business per fornire un carico di lavoro.The scenario iterates through a sequence of simulated faults and service validation while your business logic runs on the side to provide a workload. Un errore nella convalida del servizio indica un problema necessita di ulteriore analisi.A failure in service validation indicates an issue that needs further investigation.

Errori simulati nel test di failoverFaults simulated in the failover test

  • Riavvio di un pacchetto di codice distribuito in cui è ospitata la partizioneRestart a deployed code package where the partition is hosted
  • Rimozione di una replica primaria o secondaria o di un'istanza senza statoRemove a primary/secondary replica or stateless instance
  • Riavvio di una replica primaria o secondaria (in caso di servizio persistente)Restart a primary secondary replica (if a persisted service)
  • Spostamento di una replica primariaMove a primary replica
  • Spostamento di una replica secondariaMove a secondary replica
  • Riavvio della partizioneRestart the partition

Il test di failover provoca un errore scelto e quindi esegue la convalida del servizio per garantirne la stabilità.The failover test induces a chosen fault and then runs validation on the service to ensure its stability. Il test di failover provoca un solo errore per volta, anziché i possibili errori multipli generati dal test chaos.The failover test induces only one fault at a time, as opposed to possible multiple faults in the chaos test. Se dopo ogni errore la partizione di servizio non si stabilizza entro il timeout configurato, il test ha esito negativo.If the service partition does not stabilize within the configured timeout after each fault, the test fails. Il test provoca solo errori sicuri.The test induces only safe faults. In assenza di errori esterni, quindi, non si verifica una perdita di quorum o di dati.This means that in absence of external failures, a quorum or data loss will not occur.

Opzioni di configurazione importantiImportant configuration options

  • PartitionSelector: oggetto selettore che specifica la partizione che deve essere impostata come destinazione.PartitionSelector: Selector object that specifies the partition that needs to be targeted.
  • TimeToRun: tempo totale per il quale il test verrà eseguito prima del completamento.TimeToRun: Total time that the test will run before finishing.
  • MaxServiceStabilizationTimeout: tempo di attesa massimo perché il cluster diventi integro prima che ne venga dichiarato l'esito negativo.MaxServiceStabilizationTimeout: Maximum amount of time to wait for the cluster to become healthy before failing the test. I controlli eseguiti verificano che il cluster sia integro, che la dimensione del set di repliche di destinazione sia stata raggiunta per tutte le partizioni e che non siano presenti repliche InBuild.The checks performed are whether service health is OK, the target replica set size is achieved for all partitions, and no InBuild replicas exist.
  • WaitTimeBetweenFaults: tempo di attesa tra ogni ciclo di errore e di convalida.WaitTimeBetweenFaults: Amount of time to wait between every fault and validation cycle.

Come eseguire il test di failoverHow to run the failover test

C#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;
        }
    }
}

PowerShellPowerShell

$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