Distribution utan driftstopp för Durable Functions
Den tillförlitliga körningsmodellen för Durable Functions kräver att orkestreringarna är deterministiska, vilket skapar ytterligare en utmaning att tänka på när du distribuerar uppdateringar. När en distribution innehåller ändringar i aktivitetsfunktionens signaturer eller orkestreringslogik misslyckas orkestreringsinstanserna under flygning. Den här situationen är särskilt ett problem för instanser av långvariga orkestreringar, som kan representera timmar eller dagar av arbete.
För att förhindra att dessa fel inträffar har du två alternativ:
- Fördröj distributionen tills alla orkestreringsinstanser som körs har slutförts.
- Kontrollera att alla orkestreringsinstanser som körs använder de befintliga versionerna av dina funktioner.
I följande diagram jämförs de tre huvudstrategierna för att uppnå en distribution utan driftstopp för Durable Functions:
| Strategi | När du ska använda detta | Fördelar | Nackdelar |
|---|---|---|---|
| Versionshantering | Program som inte upplever frekventa icke-bakåtkompatibla ändringar. | Enkelt att implementera. | Ökad storlek på funktionsappen i minnet och antalet funktioner. Kodduplicering. |
| Statuskontroll med fack | Ett system som inte har långvariga orkestreringar som varar längre än 24 timmar eller ofta överlappar orkestreringar. | Enkel kodbas. Kräver inte ytterligare hantering av funktionsappar. |
Kräver ytterligare hantering av lagringskonto eller aktivitetshubben. Kräver tidsperioder när inga orkestreringar körs. |
| Programroutning | Ett system som inte har tidsperioder när orkestreringar inte körs, till exempel de tidsperioder med orkestreringar som varar mer än 24 timmar eller med ofta överlappande orkestreringar. | Hanterar nya versioner av system med kontinuerligt aktiva orkestreringar som har icke-bakåtkompatibla ändringar. | Kräver en intelligent programrouter. Kan maximalt antal funktionsappar som tillåts av din prenumeration. Standardvärdet är 100. |
I resten av det här dokumentet beskrivs dessa strategier mer detaljerat.
Anteckning
Beskrivningarna för dessa strategier för distribution utan avbrott förutsätter att du använder Azure Storage-standardprovidern för Durable Functions. Vägledningen kanske inte är lämplig om du använder en annan lagringsprovider än Azure Storage-standardprovidern. Mer information om de olika alternativen för lagringsprovidern och hur de jämför finns i dokumentationen om Durable Functions lagringsproviders.
Versionshantering
Definiera nya versioner av dina funktioner och lämna de gamla versionerna i funktionsappen. Som du ser i diagrammet blir en funktions version en del av dess namn. Eftersom tidigare versioner av funktioner bevaras kan orkestreringsinstanser under flygning fortsätta att referera till dem. Samtidigt anropar begäranden om nya orkestreringsinstanser den senaste versionen, som orkestreringsklientfunktionen kan referera till från en appinställning.
I den här strategin måste varje funktion kopieras och dess referenser till andra funktioner måste uppdateras. Du kan göra det enklare genom att skriva ett skript. Här är ett exempelprojekt med ett migreringsskript.
Anteckning
Den här strategin använder distributionsfack för att undvika driftstopp under distributionen. Mer detaljerad information om hur du skapar och använder nya distributionsplatser finns i Azure Functions distributionsplatser.
Statuskontroll med fack
Medan den aktuella versionen av funktionsappen körs i produktionsplatsen distribuerar du den nya versionen av funktionsappen till mellanlagringsplatsen. Innan du växlar dina produktions- och mellanlagringsplatser kontrollerar du om det finns några orkestreringsinstanser som körs. När alla orkestreringsinstanser har slutförts kan du göra växlingen. Den här strategin fungerar när du har förutsägbara perioder när inga orkestreringsinstanser är på gång. Det här är den bästa metoden när orkestreringarna inte körs länge och orkestreringskörningarna inte ofta överlappar varandra.
Konfiguration av funktionsapp
Använd följande procedur för att konfigurera det här scenariot.
Lägg till distributionsfack i funktionsappen för mellanlagring och produktion.
För varje fack anger du programinställningen AzureWebJobsStorage till anslutningssträngen för ett delat lagringskonto. Anslutningssträngen för det här lagringskontot används av Azure Functions-körningen för att lagra funktionernas åtkomstnycklar på ett säkert sätt.
För varje fack skapar du en ny appinställning,
DurableManagementStoragetill exempel . Ange dess värde till anslutningssträngen för olika lagringskonton. Dessa lagringskonton används av tillägget Durable Functions för tillförlitlig körning. Använd ett separat lagringskonto för varje fack. Markera inte den här inställningen som en distributionsfackinställning.I funktionsappens host.json-fils durableTask-avsnitt anger du
connectionStringName(Durable 2.x) ellerazureStorageConnectionStringName(Durable 1.x) som namn på den appinställning som du skapade i steg 3.
Följande diagram visar den beskrivna konfigurationen av distributionsfack och lagringskonton. I det här potentiella fördistributionsscenariot körs version 2 av en funktionsapp på produktionsplatsen, medan version 1 finns kvar på mellanlagringsplatsen.
host.json-exempel
Följande JSON-fragment är exempel på inställningen för anslutningssträngen i filen host.json .
Functions 2.0
{
"version": 2.0,
"extensions": {
"durableTask": {
"hubName": "MyTaskHub",
"storageProvider": {
"connectionStringName": "DurableManagementStorage"
}
}
}
}
Functions 1.x
{
"durableTask": {
"azureStorageConnectionStringName": "DurableManagementStorage"
}
}
Konfiguration av CI/CD-pipeline
Konfigurera ci/CD-pipelinen så att den endast distribueras när funktionsappen inte har några väntande eller pågående orkestreringsinstanser. När du använder Azure Pipelines kan du skapa en funktion som söker efter dessa villkor, som i följande exempel:
[FunctionName("StatusCheck")]
public static async Task<IActionResult> StatusCheck(
[HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequestMessage req,
[DurableClient] IDurableOrchestrationClient client,
ILogger log)
{
var runtimeStatus = new List<OrchestrationRuntimeStatus>();
runtimeStatus.Add(OrchestrationRuntimeStatus.Pending);
runtimeStatus.Add(OrchestrationRuntimeStatus.Running);
var result = await client.ListInstancesAsync(new OrchestrationStatusQueryCondition() { RuntimeStatus = runtimeStatus }, CancellationToken.None);
return (ActionResult)new OkObjectResult(new { HasRunning = result.DurableOrchestrationState.Any() });
}
Konfigurera sedan mellanlagringsporten så att den väntar tills inga orkestreringar körs. Mer information finns i Release deployment control using gates (Släppa distributionskontroll med portar)
Azure Pipelines kontrollerar att funktionsappen kör orkestreringsinstanser innan distributionen startar.
Nu ska den nya versionen av funktionsappen distribueras till mellanlagringsplatsen.
Slutligen växlar du fack.
Programinställningar som inte är markerade som inställningar för distributionsfack växlas också, så version 2-appen behåller sin referens till lagringskonto A. Eftersom orkestreringstillståndet spåras i lagringskontot fortsätter alla orkestreringar som körs i version 2-appen att köras i det nya facket utan avbrott.
Om du vill använda samma lagringskonto för båda platserna kan du ändra namnen på dina aktivitetshubbar. I det här fallet måste du hantera tillståndet för dina platser och appens HubName-inställningar. Mer information finns i Uppgiftshubbar i Durable Functions.
Programroutning
Den här strategin är den mest komplexa. Den kan dock användas för funktionsappar som inte har tid mellan att köra orkestreringar.
För den här strategin måste du skapa en programrouter framför Durable Functions. Den här routern kan implementeras med Durable Functions. Routern har ansvaret att:
- Distribuera funktionsappen.
- Hantera versionen av Durable Functions.
- Dirigera orkestreringsbegäranden till funktionsappar.
Första gången en orkestreringsbegäran tas emot utför routern följande uppgifter:
- Skapar en ny funktionsapp i Azure.
- Distribuerar funktionsappens kod till den nya funktionsappen i Azure.
- Vidarebefordrar orkestreringsbegäran till den nya appen.
Routern hanterar tillståndet för vilken version av appens kod som distribueras till vilken funktionsapp i Azure.
Routern dirigerar distributions- och orkestreringsbegäranden till lämplig funktionsapp baserat på den version som skickas med begäran. Korrigeringsversionen ignoreras.
När du distribuerar en ny version av din app utan en icke-bakåtkompatibel ändring kan du öka korrigeringsversionen. Routern distribuerar till din befintliga funktionsapp och skickar begäranden för de gamla och nya versionerna av koden, som dirigeras till samma funktionsapp.
När du distribuerar en ny version av din app med en icke-bakåtkompatibel ändring kan du öka huvud- eller delversionen. Sedan skapar programroutern en ny funktionsapp i Azure, distribuerar till den och dirigerar begäranden för den nya versionen av appen till den. I följande diagram fortsätter orkestreringarna på 1.0.1-versionen av appen att köras, men begäranden för versionen 1.1.0 dirigeras till den nya funktionsappen.
Routern övervakar orkestreringsstatusen på 1.0.1-versionen och tar bort appar när alla orkestreringar har slutförts.
Inställningar för spårningsarkiv
Varje funktionsapp bör använda separata schemaläggningsköer, eventuellt i separata lagringskonton. Om du vill köra frågor mot alla orkestreringsinstanser i alla versioner av ditt program kan du dela instans- och historiktabeller i dina funktionsappar. Du kan dela tabeller genom att trackingStoreConnectionStringName konfigurera inställningarna och trackingStoreNamePrefix i inställningsfilen host.json så att alla använder samma värden.
Mer information finns i Hantera instanser i Durable Functions i Azure.
