Testbaarheidsscenario's
Grote gedistribueerde systemen zoals cloudinfrastructuren zijn inherent onbetrouwbaar. Azure Service Fabric biedt ontwikkelaars de mogelijkheid om services te schrijven die kunnen worden uitgevoerd op onbetrouwbare infrastructuren. Om hoogwaardige services te kunnen schrijven, moeten ontwikkelaars een dergelijke onbetrouwbare infrastructuur kunnen veroorzaken om de stabiliteit van hun services te testen.
De Foutanalyseservice biedt ontwikkelaars de mogelijkheid om foutacties te veroorzaken om services te testen in aanwezigheid van fouten. Gerichte gesimuleerde fouten krijgen u echter alleen tot nu toe. Als u de test verder wilt uitvoeren, kunt u de testscenario's in Service Fabric gebruiken: een chaostest en een failovertest. Deze scenario's simuleren doorlopende interleaved fouten, zowel sierlijk als ondankbaar, gedurende langere tijd in het hele cluster. Zodra een test is geconfigureerd met de snelheid en het soort fouten, kan deze worden gestart via C#-API's of PowerShell om fouten in het cluster en uw service te genereren.
Waarschuwing
ChaosTestScenario wordt vervangen door een tolerantere chaos op basis van een service. Raadpleeg het nieuwe artikel Controlled Chaos voor meer informatie.
Chaostest
Het chaosscenario genereert fouten in het hele Service Fabric-cluster. In het scenario worden fouten over het algemeen gecomprimeerd in maanden of jaren tot een paar uur. De combinatie van interleaved fouten met het hoge foutpercentage vindt hoekcases die anders worden gemist. Dit leidt tot een aanzienlijke verbetering van de codekwaliteit van de service.
Fouten gesimuleerd in de chaostest
- Een knooppunt opnieuw opstarten
- Een geïmplementeerd codepakket opnieuw starten
- Een replica verwijderen
- Een replica opnieuw opstarten
- Een primaire replica verplaatsen (optioneel)
- Een secundaire replica verplaatsen (optioneel)
Tijdens de chaostest worden meerdere iteraties van fouten en clustervalidaties uitgevoerd voor de opgegeven periode. De tijd die nodig is om het cluster te stabiliseren en de validatie te laten slagen, kan ook worden geconfigureerd. Het scenario mislukt wanneer u één fout hebt bereikt bij clustervalidatie.
Denk bijvoorbeeld aan een test die is ingesteld om één uur uit te voeren met maximaal drie gelijktijdige fouten. De test veroorzaakt drie fouten en valideert vervolgens de clusterstatus. De test wordt door de vorige stap herhaald totdat het cluster beschadigd raakt of één uur is verstreken. Als het cluster beschadigd raakt in een iteratie, dat wil bijvoorbeeld dat het binnen een geconfigureerde tijd niet stabiel is, mislukt de test met een uitzondering. Deze uitzondering geeft aan dat er iets mis is gegaan en verder moet worden onderzocht.
In zijn huidige vorm veroorzaakt de motor voor het genereren van fouten in de chaostest alleen veilige fouten. Dit betekent dat bij afwezigheid van externe fouten nooit een quorum of gegevensverlies zal optreden.
Belangrijke configuratieopties
- TimeToRun: Totale tijd die de test uitvoert voordat de test is voltooid. De test kan eerder worden voltooid in plaats van een validatiefout.
- MaxClusterStabilizationTimeout: Maximale tijdsduur om te wachten totdat het cluster in orde is voordat de test mislukt. De uitgevoerde controles zijn of de clusterstatus OK is, de servicestatus ok is, de grootte van de doelreplicaset wordt bereikt voor de servicepartitie en er zijn geen InBuild-replica's.
- MaxConcurrentFaults: Maximum aantal gelijktijdige fouten dat in elke iteratie is geïnduceerd. Hoe hoger het getal, hoe agressiever de test, waardoor er complexere failovers en overgangscombinaties ontstaan. De test garandeert dat er bij afwezigheid van externe fouten geen quorum of gegevensverlies is, ongeacht hoe hoog deze configuratie is.
- EnableMoveReplicaFaults: schakelt de fouten in of uit die de verplaatsing van de primaire of secundaire replica's veroorzaken. Deze fouten zijn standaard uitgeschakeld.
- WaitTimeBetweenIterations: De hoeveelheid tijd die moet worden gewacht tussen iteraties, bijvoorbeeld na een ronde van fouten en de bijbehorende validatie.
De chaostest uitvoeren
C#-voorbeeld
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
De Service Fabric PowerShell-module bevat twee manieren om een chaosscenario te starten. Invoke-ServiceFabricChaosTestScenario is clientgebaseerd en als de clientcomputer halverwege de test wordt afgesloten, worden er geen verdere fouten geïntroduceerd. Er is ook een reeks opdrachten die bedoeld zijn om de test in het geval van het afsluiten van de machine actief te houden. Start-ServiceFabricChaos maakt gebruik van een stateful en betrouwbare systeemservice met de naam FaultAnalysisService, waardoor fouten worden geïntroduceerd totdat TimeToRun actief is. Stop-ServiceFabricChaos kan worden gebruikt om het scenario handmatig te stoppen en Get-ServiceFabricChaosReport een rapport te verkrijgen. Zie de Naslaginformatie over Azure Service Fabric PowerShell en het veroorzaken van gecontroleerde chaos in Service Fabric-clusters voor meer informatie.
$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
Failovertest
Het failovertestscenario is een versie van het chaostestscenario dat is gericht op een specifieke servicepartitie. Het test het effect van failover op een specifieke servicepartitie terwijl de andere services niet worden beïnvloed. Zodra deze is geconfigureerd met de doelpartitiegegevens en andere parameters, wordt het uitgevoerd als een hulpprogramma aan de clientzijde dat gebruikmaakt van C#-API's of PowerShell om fouten voor een servicepartitie te genereren. Het scenario doorloopt een reeks gesimuleerde fouten en servicevalidatie terwijl uw bedrijfslogica aan de zijkant wordt uitgevoerd om een workload te bieden. Een fout in de servicevalidatie geeft een probleem aan dat verder moet worden onderzocht.
Fouten die zijn gesimuleerd in de failovertest
- Start een geïmplementeerd codepakket opnieuw op waar de partitie wordt gehost
- Een primaire/secundaire replica of staatloze instantie verwijderen
- Een primaire secundaire replica opnieuw opstarten (als er een persistente service is)
- Een primaire replica verplaatsen
- Een secundaire replica verplaatsen
- Start de partitie opnieuw op
De failovertest veroorzaakt een gekozen fout en voert vervolgens validatie uit op de service om de stabiliteit ervan te garanderen. De failovertest veroorzaakt slechts één fout tegelijk, in tegenstelling tot mogelijke meerdere fouten in de chaostest. Als de servicepartitie na elke fout niet wordt gestabiliseerd binnen de geconfigureerde time-out, mislukt de test. De test veroorzaakt alleen veilige fouten. Dit betekent dat bij afwezigheid van externe fouten geen quorum of gegevensverlies plaatsvindt.
Belangrijke configuratieopties
- PartitionSelector: Selector-object waarmee de partitie wordt opgegeven waarop moet worden gericht.
- TimeToRun: Totale tijd die de test uitvoert voordat de test wordt uitgevoerd.
- MaxServiceStabilizationTimeout: Maximale tijdsduur om te wachten totdat het cluster in orde is voordat de test mislukt. De uitgevoerde controles zijn of de servicestatus OK is, de grootte van de doelreplicaset wordt bereikt voor alle partities en er bestaan geen InBuild-replica's.
- WaitTimeBetweenFaults: De hoeveelheid tijd die moet worden gewacht tussen elke fout en validatiecyclus.
De failovertest uitvoeren
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