Testbaarheidsscenario's
Grote gedistribueerde systemen zoals cloudinfrastructuren zijn inherent onbetrouwbaar. Azure Service Fabric biedt ontwikkelaars de mogelijkheid om services te schrijven die worden uitgevoerd op onbetrouwbare infrastructuren. Om services van hoge kwaliteit 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 activeren om services te testen in de aanwezigheid van fouten. Gerichte gesimuleerde fouten krijgen u echter alleen tot nu toe. Als u verder wilt gaan met het testen, kunt u de testscenario's in Service Fabric gebruiken: een chaostest en een failovertest. Deze scenario's simuleren continue interleaved fouten, zowel gracieuze als ondankbaar, gedurende langere perioden in het 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, servicegebaseerde Chaos. Raadpleeg het nieuwe artikel Gecontroleerde chaos voor meer informatie.
Chaostest
Het chaosscenario genereert fouten in het hele Service Fabric-cluster. In het scenario worden fouten die over het algemeen in maanden of jaren worden weergegeven, gecomprimeerd tot enkele uren. De combinatie van interleaved fouten met het hoge foutpercentage vindt hoekgevallen 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 starten
- Een primaire replica verplaatsen (optioneel)
- Een secundaire replica verplaatsen (optioneel)
De chaostest voert meerdere iteraties van fouten en clustervalidaties uit 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 een enkele fout in de clustervalidatie tegenkomt.
Stel dat een testset één uur wordt uitgevoerd met maximaal drie gelijktijdige fouten. De test veroorzaakt drie fouten en valideert vervolgens de clusterstatus. De test doorloopt de vorige stap totdat het cluster beschadigd raakt of een uur is verstreken. Als het cluster beschadigd raakt in een iteratie, dat wil zeggen dat het niet binnen een geconfigureerde tijd stabiliseert, mislukt de test met een uitzondering. Deze uitzondering geeft aan dat er iets is misgegaan en verder moet worden onderzocht.
In zijn huidige vorm veroorzaakt de foutgeneratie-engine in de chaostest alleen veilige fouten. Dit betekent dat als er geen externe fouten optreden, er nooit een quorum of gegevensverlies zal optreden.
Belangrijke configuratieopties
- TimeToRun: totale tijd die de test uitvoert voordat de test succesvol wordt voltooid. De test kan eerder worden voltooid in plaats van een validatiefout.
- MaxClusterStabilizationTimeout: Maximale tijd die moet worden gewacht totdat het cluster in orde is voordat de test wordt uitgevoerd. De uitgevoerde controles zijn of de clusterstatus in orde is, of de servicestatus OK is, de grootte van de doelreplicaset wordt bereikt voor de servicepartitie en of er geen InBuild-replica's bestaan.
- MaxConcurrentFaults: Maximum aantal gelijktijdige fouten dat in elke iteratie wordt veroorzaakt. Hoe hoger het getal, hoe agressiever de test, wat resulteert in complexere failovers en overgangscombinaties. De test garandeert dat er bij afwezigheid van externe fouten geen quorum of gegevensverlies is, ongeacht hoe hoog deze configuratie is.
- EnableMoveReplicaFaults: hiermee worden de fouten die de verplaatsing van de primaire of secundaire replica's veroorzaken, in- of uitgeschakeld. Deze fouten zijn standaard uitgeschakeld.
- WaitTimeBetweenIterations: de hoeveelheid tijd die moet worden gewacht tussen iteraties, dat wil zeggen 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 gebaseerd op de client 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 actief te houden in het geval de computer wordt afgesloten. Start-ServiceFabricChaos maakt gebruik van een stateful en betrouwbare systeemservice met de naam FaultAnalysisService, die ervoor zorgt dat fouten worden geïntroduceerd totdat timetorun actief is. Stop-ServiceFabricChaos kan worden gebruikt om het scenario handmatig te stoppen en Get-ServiceFabricChaosReport krijgt een rapport. Zie de Azure Service Fabric PowerShell-naslaginformatie en Gecontroleerde chaos in Service Fabric-clusters veroorzaken 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. Hiermee wordt het effect van failover op een specifieke servicepartitie getest, terwijl de andere services niet worden beïnvloed. Zodra het is geconfigureerd met de doelpartitiegegevens en andere parameters, wordt het uitgevoerd als een hulpprogramma aan de clientzijde dat C#-API's of PowerShell gebruikt 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 duidt op een probleem dat verder moet worden onderzocht.
Fouten die zijn gesimuleerd in de failovertest
- Een geïmplementeerd codepakket opnieuw starten waarin de partitie wordt gehost
- Een primaire/secundaire replica of staatloze instantie verwijderen
- Een primaire secundaire replica opnieuw starten (als er een permanente service is)
- Een primaire replica verplaatsen
- Een secundaire replica verplaatsen
- De partitie opnieuw starten
De failovertest veroorzaakt een gekozen fout en voert vervolgens validatie uit op de service om de stabiliteit te garanderen. De failovertest veroorzaakt slechts één fout tegelijk, in tegenstelling tot mogelijke meerdere fouten in de chaostest. Als de servicepartitie zich na elke fout niet binnen de geconfigureerde time-out stabiliseert, mislukt de test. De test veroorzaakt alleen veilige fouten. Dit betekent dat als er geen externe fouten optreden, er geen quorum of gegevensverlies zal optreden.
Belangrijke configuratieopties
- PartitionSelector: Selector-object dat de partitie aangeeft die moet worden gericht.
- TimeToRun: de totale tijd die de test uitvoert voordat de test wordt uitgevoerd.
- MaxServiceStabilizationTimeout: Maximale tijd die moet worden gewacht totdat het cluster in orde is voordat de test mislukt. De uitgevoerde controles zijn of de servicestatus in orde is, of de grootte van de doelreplicaset wordt bereikt voor alle partities en of er geen InBuild-replica's bestaan.
- 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