Feladatütemező ügynök felügyeleti mintájaScheduler Agent Supervisor pattern

Elosztott műveleteket egyetlen műveletként koordinálhat.Coordinate a set of distributed actions as a single operation. Ha a műveletek bármelyike sikertelen, próbálja átlátható módon kezelni a hibákat, különben elképzelhető, hogy az elvégzett munkát vissza kell vonni, így a teljes művelet egészében lesz sikeres vagy sikertelen.If any of the actions fail, try to handle the failures transparently, or else undo the work that was performed, so the entire operation succeeds or fails as a whole. Ez rugalmasságot nyújthat az elosztott rendszereknek azáltal, hogy lehetővé teszi a helyreállítást és az újrapróbálkozást az átmeneti kivételek, a hosszan tartó hibák és a folyamathibák következtében sikertelen műveletek esetében.This can add resiliency to a distributed system, by enabling it to recover and retry actions that fail due to transient exceptions, long-lasting faults, and process failures.

Kontextus és problémaContext and problem

Egy alkalmazás több lépésből álló feladatokat hajt végre – a lépések némelyike esetleg távoli szolgáltatásokat hív meg vagy távoli erőforrásokhoz fér hozzá.An application performs tasks that include a number of steps, some of which might invoke remote services or access remote resources. Az egyes lépések egymástól függetlenek is lehetnek, de azokat a feladatot megvalósító alkalmazáslogika vezényli.The individual steps might be independent of each other, but they are orchestrated by the application logic that implements the task.

Amikor csak lehetséges, az alkalmazásnak biztosítania kell, hogy a feladat befejeződjön, valamint a távoli szolgáltatásokhoz vagy erőforrásokhoz való hozzáférés során esetlegesen fellépő hibákat el kell hárítania.Whenever possible, the application should ensure that the task runs to completion and resolve any failures that might occur when accessing remote services or resources. A hibáknak számos oka lehet.Failures can occur for many reasons. Előfordulhat, hogy a hálózat nem működik, a kommunikáció megszakadt, egy távoli szolgáltatás nem válaszol vagy instabil, vagy egy távoli erőforrás átmenetileg nem érhető el, például erőforrás-korlátozás miatt.For example, the network might be down, communications could be interrupted, a remote service might be unresponsive or in an unstable state, or a remote resource might be temporarily inaccessible, perhaps due to resource constraints. A hibák sok esetben átmenetiek, és elháríthatók az újrapróbálkozási minta segítségével.In many cases the failures will be transient and can be handled by using the Retry pattern.

Ha az alkalmazás nem könnyen helyreállítható állandó hibát észlel, a teljes művelet integritásának biztosítása érdekében képesnek kell lennie visszaállítani a rendszert egy konzisztens állapotba.If the application detects a more permanent fault it can't easily recover from, it must be able to restore the system to a consistent state and ensure integrity of the entire operation.

MegoldásSolution

A feladatütemező ügynök felügyeleti mintája az alábbi aktorokat határozza meg.The Scheduler Agent Supervisor pattern defines the following actors. Ezek az aktorok szervezik meg a teljes feladat részeként végrehajtandó lépéseket.These actors orchestrate the steps to be performed as part of the overall task.

  • Az ütemező gondoskodik a feladat lépéseinek végrehajtásáról, és összehangolja a működésüket.The Scheduler arranges for the steps that make up the task to be executed and orchestrates their operation. Ezek a lépések folyamattá vagy munkafolyamattá egyesíthetők.These steps can be combined into a pipeline or workflow. Az ütemező felelős azért, hogy a munkafolyamat lépései a helyes sorrendben kövessék egymást.The Scheduler is responsible for ensuring that the steps in this workflow are performed in the right order. Ahogy az egyes lépések végbemennek, az ütemező rögzíti a munkafolyamat állapotát, például: „a lépés még nem kezdődött el”, „a lépés fut”, vagy a „lépés befejeződött”.As each step is performed, the Scheduler records the state of the workflow, such as "step not yet started," "step running," or "step completed." Az állapotot leíró információnak tartalmaznia kell a lépés befejezéséhez engedélyezett idő felső határát („befejezési idő”).The state information should also include an upper limit of the time allowed for the step to finish, called the complete-by time. Ha egy lépéshez szükség van távoli szolgáltatáshoz vagy erőforráshoz való hozzáférésre, az ütemező meghívja a megfelelő ügynököt, és átadja neki az elvégzendő munka részleteit.If a step requires access to a remote service or resource, the Scheduler invokes the appropriate Agent, passing it the details of the work to be performed. Az ütemező általában aszinkron kérés/válasz típusú üzenetküldés formájában kommunikál az ügynökökkel.The Scheduler typically communicates with an Agent using asynchronous request/response messaging. Ez üzenetsorok segítségével valósítható meg, bár egyéb elosztott üzenetkezelési technológiák is használhatók.This can be implemented using queues, although other distributed messaging technologies could be used instead.

    Az ütemező a folyamatkezelő mintájában található folyamatkezelőhöz hasonló funkciót tölt be.The Scheduler performs a similar function to the Process Manager in the Process Manager pattern. A tényleges munkafolyamatot általában egy munkafolyamat-motor definiálja és implementálja, amelyet az ütemező irányít.The actual workflow is typically defined and implemented by a workflow engine that's controlled by the Scheduler. Ez a megközelítés leválasztja a munkafolyamat üzleti logikáját az ütemezőről.This approach decouples the business logic in the workflow from the Scheduler.

  • Az ügynök olyan logikát tartalmaz, amely magában foglalja a feladat lépéseiben hivatkozott távoli szolgáltatások hívását vagy távoli erőforrásokhoz való hozzáférést.The Agent contains logic that encapsulates a call to a remote service, or access to a remote resource referenced by a step in a task. Általában minden ügynök egyetlen szolgáltatáshoz vagy erőforráshoz csomagolja a hívásokat, és alkalmazza a megfelelő hibakezelést és újrapróbálkozási logikát (időtúllépési megkötés függvényében, amelyről a későbbiekben olvashat).Each Agent typically wraps calls to a single service or resource, implementing the appropriate error handling and retry logic (subject to a timeout constraint, described later). Ha az ütemező által futtatott munkafolyamat lépései több szolgáltatást és erőforrást használnak különböző lépéseken keresztül, minden lépés hivatkozhat más ügynökre (ez a minta egy implementálási részlete).If the steps in the workflow being run by the Scheduler use several services and resources across different steps, each step might reference a different Agent (this is an implementation detail of the pattern).

  • A felügyelő figyeli az ütemező által végrehajtott feladat lépéseinek állapotát.The Supervisor monitors the status of the steps in the task being performed by the Scheduler. Rendszeresen fut (a gyakoriság rendszerspecifikus lesz), és megvizsgálja az ütemező által karbantartott lépések állapotát.It runs periodically (the frequency will be system-specific), and examines the status of steps maintained by the Scheduler. Ha időtúllépést vagy sikertelen lépést észlel, a megfelelő ügynökkel helyreállíttatja a lépést, vagy elvégezteti a megfelelő helyreigazító műveletet (ez egyes lépések állapotának módosításával járhat).If it detects any that have timed out or failed, it arranges for the appropriate Agent to recover the step or execute the appropriate remedial action (this might involve modifying the status of a step). Vegye figyelembe, hogy a helyreállítási vagy helyreigazító műveleteket az ütemező és az ügynökök végzik.Note that the recovery or remedial actions are implemented by the Scheduler and Agents. A felügyelő csupán kérést küld a műveletek elvégzésére.The Supervisor should simply request that these actions be performed.

Az ütemező, az ügynök és a felügyelő logikai összetevők, amelyek fizikai implementálása a használt technológiától függ.The Scheduler, Agent, and Supervisor are logical components and their physical implementation depends on the technology being used. Például számos logikai ügynök implementálható egyetlen webszolgáltatás részeként.For example, several logical agents might be implemented as part of a single web service.

Az ütemező az állapottároló elnevezésű tartós adattárban információkat tárol a feladat és az egyes lépések állapotáról.The Scheduler maintains information about the progress of the task and the state of each step in a durable data store, called the state store. A felügyelő az információk alapján segítséget nyújt annak meghatározásában, meghiúsult-e egy lépés, vagy sem.The Supervisor can use this information to help determine whether a step has failed. Az ábra bemutatja az ütemező, az ügynökök, a felügyelő és az állapottároló közötti kapcsolatot.The figure illustrates the relationship between the Scheduler, the Agents, the Supervisor, and the state store.

1. ábra – Az aktorok a Feladatütemező ügynök felügyeleti mintájában

Megjegyzés

Ezen az ábrán a minta egyszerűsített változata látható.This diagram shows a simplified version of the pattern. Valós alkalmazáskor az ütemező több példánya is futhat párhuzamosan, mindegyik feladatok alegységeként.In a real implementation, there might be many instances of the Scheduler running concurrently, each a subset of tasks. A rendszer futtathat több példányt minden ügynökből, vagy akár több felügyelőt is.Similarly, the system could run multiple instances of each Agent, or even multiple Supervisors. Ebben az esetben a felügyelőknek koordinálniuk kell egymással a munkájukat, hogy ne ugyanazokat a sikertelen lépéseket és feladatokat próbálják helyreállítani.In this case, Supervisors must coordinate their work with each other carefully to ensure that they don’t compete to recover the same failed steps and tasks. A vezetőválasztási minta egy lehetséges megoldást jelent erre a problémára.The Leader Election pattern provides one possible solution to this problem.

Amikor az alkalmazás készen áll egy feladat futtatására, kérést küld az ütemezőnek.When the application is ready to run a task, it submits a request to the Scheduler. Az ütemező információkat rögzít az állapottárolóba a feladat és a lépések kezdeti állapotáról (például: meg nem kezdett lépés), majd elkezdi végrehajtani a munkafolyamat által meghatározott műveleteket.The Scheduler records initial state information about the task and its steps (for example, step not yet started) in the state store and then starts performing the operations defined by the workflow. Egy-egy lépés megkezdésekor az ütemező frissíti az adattárolóban az adott lépés állapotával kapcsolatos információt (például: a lépés fut).As the Scheduler starts each step, it updates the information about the state of that step in the state store (for example, step running).

Ha egy lépés egy távoli szolgáltatásra vagy erőforrásra hivatkozik, az ütemező üzenetet küld a megfelelő ügynöknek.If a step references a remote service or resource, the Scheduler sends a message to the appropriate Agent. Az üzenet tartalmazza azt az információt, amelyet az ügynöknek továbbítania kell a szolgáltatásnak, vagy amellyel hozzáférhet az erőforráshoz, valamint tartalmazza a művelet befejezési idejét is.The message contains the information that the Agent needs to pass to the service or access the resource, in addition to the complete-by time for the operation. Ha az ügynök sikeresen teljesíti a műveletet, választ küld az ütemezőnek.If the Agent completes its operation successfully, it returns a response to the Scheduler. Az ütemező így frissítheti az állapotinformációt az állapottárolóban (például: lépés befejezve), és végrehajthatja a következő lépést.The Scheduler can then update the state information in the state store (for example, step completed) and perform the next step. Ez a folyamat folytatódik a teljes feladat befejezéséig.This process continues until the entire task is complete.

Egy ügynök bármilyen újrapróbálkozási logikát alkalmazhat, amely a feladatának teljesítéséhez szükséges.An Agent can implement any retry logic that's necessary to perform its work. Ha azonban az ügynök nem teljesíti a feladatot a befejezési idő lejárta előtt, az ütemező a műveletet sikertelenként fogja kezelni.However, if the Agent doesn't complete its work before the complete-by period expires, the Scheduler will assume that the operation has failed. Ebben az esetben az ügynöknek be kell fejeznie a tevékenységét, és nem szabad visszaküldenie semmit az ütemezőnek (még hibaüzenetet sem), valamint nem szabad helyreállítással próbálkoznia.In this case, the Agent should stop its work and not try to return anything to the Scheduler (not even an error message), or try any form of recovery. A korlátozás oka, hogy miután egy lépés túllépte az időkorlátot vagy meghiúsult, az ügynök egy másik példánya ütemezve lehet a sikertelen lépés futtatására (erről a folyamatról a későbbiekben olvashat).The reason for this restriction is that, after a step has timed out or failed, another instance of the Agent might be scheduled to run the failing step (this process is described later).

Ha az ügynök nem tudja végrehajtani a feladatát, az ütemező nem kap választ.If the Agent fails, the Scheduler won't receive a response. A minta nem tesz különbséget az időkorlátot túllépő és a valóban sikertelen lépések között.The pattern doesn't make a distinction between a step that has timed out and one that has genuinely failed.

Ha egy lépés túllépi az időkorlátot vagy meghiúsul, az állapottárolóba bekerül egy rekord arról, hogy a lépés fut, de a befejezési idő lejárt.If a step times out or fails, the state store will contain a record that indicates that the step is running, but the complete-by time will have passed. A felügyelő ehhez hasonló lépéseket keres, és megpróbálja helyreállítani őket.The Supervisor looks for steps like this and tries to recover them. Az egyik lehetséges stratégia az, hogy a felügyelő frissíti a teljes értékű értéket a lépés befejezéséhez rendelkezésre álló idő meghosszabbításához, majd üzenetet küld az ütemező számára, amely az időtúllépést okozó lépést azonosítja. Ezután az ütemező megpróbálhatja megismételni ezt a lépést.One possible strategy is for the Supervisor to update the complete-by value to extend the time available to complete the step, and then send a message to the Scheduler identifying the step that has timed out. The Scheduler can then try to repeat this step. Ehhez a kialakításhoz azonban szükséges, hogy a feladatok idempotensek legyenek.However, this design requires the tasks to be idempotent.

Előfordulhat, hogy a felügyelőnek meg kell akadályoznia az újrapróbálkozást, ha az folyamatosan leáll vagy időtúllépést okoz. Ennek elvégzéséhez a felügyelő megtarthatja az egyes lépésekhez tartozó újrapróbálkozások számait, valamint az állapotadatok állapotát az állapot-tárolóban.The Supervisor might need to prevent the same step from being retried if it continually fails or times out. To do this, the Supervisor could maintain a retry count for each step, along with the state information, in the state store. Ha ez a szám túllép egy előre meghatározott küszöbértéket, a felügyelő másik stratégiaként hosszabb ideig várhat, mielőtt értesítené az ütemezőt, hogy az próbálja újra a lépést, annak reményében, hogy a várakozás alatt a probléma megoldódik.If this count exceeds a predefined threshold the Supervisor can adopt a strategy of waiting for an extended period before notifying the Scheduler that it should retry the step, in the expectation that the fault will be resolved during this period. A felügyelő másik megoldásként kérést küldhet az ütemezőnek a teljes feladat visszavonására egy kompenzáló tranzakciós minta alkalmazásával.Alternatively, the Supervisor can send a message to the Scheduler to request the entire task be undone by implementing a Compensating Transaction pattern. Ennek a megközelítésnek a sikeressége azon múlik, biztosítják-e az ügynökök és az ütemező a sikeresen befejeződött lépések kompenzáló műveleteinek implementálásához szükséges információkat.This approach will depend on the Scheduler and Agents providing the information necessary to implement the compensating operations for each step that completed successfully.

A felügyelőnek nem célja sem az ütemező és az ügynökök monitorozása, sem hiba esetén az újraindításuk.It isn't the purpose of the Supervisor to monitor the Scheduler and Agents, and restart them if they fail. A rendszer e részét az ezeket az összetevőket futtató infrastruktúrának kell kezelnie.This aspect of the system should be handled by the infrastructure these components are running in. A felügyelőnek szintén nem feladata ismerni a tényleges üzleti műveleteket, amelyeket az ütemező által végzett feladatok futtatnak (beleértve a sikertelen feladatok esetében történő kompenzálás módját).Similarly, the Supervisor shouldn't have knowledge of the actual business operations that the tasks being performed by the Scheduler are running (including how to compensate should these tasks fail). Ez az ütemező által alkalmazott munkafolyamat-logika feladata.This is the purpose of the workflow logic implemented by the Scheduler. A felügyelő egyetlen felelőssége, hogy meghatározza, meghiúsult-e egy lépés, és megszervezze a megismétlését vagy a sikertelen lépést tartalmazó teljes feladat visszavonását.The sole responsibility of the Supervisor is to determine whether a step has failed and arrange either for it to be repeated or for the entire task containing the failed step to be undone.

Ha az ütemező hiba után indult újra, vagy az ütemező által végzett munkafolyamat váratlanul leállt, az ütemező képes meghatározni a hiba beálltakor végzett feladatok állapotát, és kész folytatni őket attól a ponttól.If the Scheduler is restarted after a failure, or the workflow being performed by the Scheduler terminates unexpectedly, the Scheduler should be able to determine the status of any inflight task that it was handling when it failed, and be prepared to resume this task from that point. Ennek a folyamatnak a megvalósítási részletei valószínűleg rendszerspecifikusak.The implementation details of this process are likely to be system-specific. Ha a feladat nem helyreállítható, szükség lehet a feladat által már elvégzett munka visszavonására.If the task can't be recovered, it might be necessary to undo the work already performed by the task. Ehhez szükséges lehet egy kompenzáló tranzakció implementálása.This might also require implementing a compensating transaction.

Ennek a mintának az egyik legfontosabb előnye a váratlan ideiglenes vagy nem helyreállítható hibák esetén biztosított rugalmasság.The key advantage of this pattern is that the system is resilient in the event of unexpected temporary or unrecoverable failures. A rendszerek önjavító kialakításra is használhatók.The system can be constructed to be self-healing. Például ha hiba lép fel egy ügynök vagy az ütemező működésében, elindíthat egy új példányt, és a felügyelő segítségével folytathatja a feladatokat.For example, if an Agent or the Scheduler fails, a new one can be started and the Supervisor can arrange for a task to be resumed. Ha a felügyelő működésében lép fel hiba, elindíthat egy másik példányt, amellyel onnan folytathatja a munkát, ahol a hiba történt.If the Supervisor fails, another instance can be started and can take over from where the failure occurred. Ha a felügyelő rendszeres időközönként ütemezve fut, automatikusan indítható új példány egy előre meghatározott időszak után.If the Supervisor is scheduled to run periodically, a new instance can be automatically started after a predefined interval. Az állapottároló replikálható a még nagyobb fokú rugalmasság elérése érdekében.The state store can be replicated to reach an even greater degree of resiliency.

Problémák és megfontolandó szempontokIssues and considerations

A minta megvalósítása során az alábbi pontokat vegye figyelembe:You should consider the following points when deciding how to implement this pattern:

  • Ez a minta nehezebben implementálható, és szükséges hozzá a rendszer minden lehetséges hibaállapotának alapos tesztelése.This pattern can be difficult to implement and requires thorough testing of each possible failure mode of the system.

  • Az ütemező által implementált helyreállítási/újrapróbálkozási logika összetett, és függ az állapottárolóban tárolt állapotinformációtól.The recovery/retry logic implemented by the Scheduler is complex and dependent on state information held in the state store. Előfordulhat, hogy rögzíteni kell a kompenzáló tranzakció implementálásához szükséges információt egy tartós adattárban.It might also be necessary to record the information required to implement a compensating transaction in a durable data store.

  • Fontos, milyen gyakran fut a felügyelő.How often the Supervisor runs will be important. Elég gyakran kell futnia annak megakadályozásához, hogy a hibás lépések hosszú ideig blokkoljanak egy alkalmazást, de nem olyan gyakran, hogy többletterheléssé váljon.It should run often enough to prevent any failed steps from blocking an application for an extended period, but it shouldn't run so often that it becomes an overhead.

  • Az ügynökök által végzett lépések többször is futtathatók.The steps performed by an Agent could be run more than once. Az ezeket a lépéseket implementáló logikának idempotensnek kell lennie.The logic that implements these steps should be idempotent.

Mikor érdemes ezt a mintát használni?When to use this pattern

Használja ezt a mintát, ha egy elosztott környezetben, például felhőben futó folyamatnak rugalmasnak kell lennie a kommunikációs és/vagy működési hibákkal szemben.Use this pattern when a process that runs in a distributed environment, such as the cloud, must be resilient to communications failure and/or operational failure.

Nem érdemes ezt a mintát használni olyan feladatok esetében, amelyek nem hívnak meg távoli szolgáltatásokat vagy nem férnek hozzá távoli erőforrásokhoz.This pattern might not be suitable for tasks that don't invoke remote services or access remote resources.

PéldaExample

Egy elektronikus kereskedelmi rendszert implementáló webalkalmazás lett üzembe helyezve a Microsoft Azure-ban.A web application that implements an ecommerce system has been deployed on Microsoft Azure. Az alkalmazás segítségével a felhasználók böngészhetnek az elérhető termékek között, és rendeléseket adhatnak le.Users can run this application to browse the available products and to place orders. A felhasználói felület webes szerepkörként fut, az alkalmazás rendelésfeldolgozó elemei pedig feldolgozói szerepkörökként vannak implementálva.The user interface runs as a web role, and the order processing elements of the application are implemented as a set of worker roles. A rendelésfeldolgozó logika egy része magában foglalja a távoli szolgáltatásokhoz való hozzáférést. A rendszer ezen aspektusában gyakrabban előfordulhatnak átmeneti vagy hosszan tartó hibák.Part of the order processing logic involves accessing a remote service, and this aspect of the system could be prone to transient or more long-lasting faults. Ezért a tervezők a Feladatütemező ügynök felügyeleti mintáját használták a rendszer rendelésfeldolgozó elemeinek implementálásához.For this reason, the designers used the Scheduler Agent Supervisor pattern to implement the order processing elements of the system.

Amikor az ügyfél lead egy rendelést, az alkalmazás összeállít egy üzenetet, amelyben leírja a rendelést, majd egy üzenetsorba küldi.When a customer places an order, the application constructs a message that describes the order and posts this message to a queue. Az üzenetet egy feldolgozói szerepkörben futó külön beküldési folyamat olvassa be, beszúrja a rendelés részleteit a rendelési adatbázisba, és rögzíti a rendelési folyamatot az állapottárolóban.A separate submission process, running in a worker role, retrieves the message, inserts the order details into the orders database, and creates a record for the order process in the state store. Vegye figyelembe, hogy a rendelési adatbázisba és az állapottárolóba történő beszúrások ugyanazon művelet részeként történnek.Note that the inserts into the orders database and the state store are performed as part of the same operation. A beküldési folyamat célja a két beszúrás együttes befejezésének biztosítása.The submission process is designed to ensure that both inserts complete together.

A beküldési folyamat által a rendeléshez létrehozott állapotinformáció az alábbiakat tartalmazza:The state information that the submission process creates for the order includes:

  • Rendeléskód.OrderID. A rendelési adatbázisban található rendelés azonosítója.The ID of the order in the orders database.

  • LockedBy.LockedBy. A rendelést kezelő feldolgozói szerepkör példányazonosítója.The instance ID of the worker role handling the order. Előfordulhat, hogy a feldolgozói szerepkör több aktuális példánya futtatja az ütemezőt, de az egyes rendeléseket csak egy példánynak kell kezelnie.There might be multiple current instances of the worker role running the Scheduler, but each order should only be handled by a single instance.

  • CompleteBy.CompleteBy. Az az időpont, ameddig a rendelés feldolgozásának meg kell történnie.The time the order should be processed by.

  • ProcessState.ProcessState. A rendelést kezelő feladat jelenlegi állapota.The current state of the task handling the order. A lehetséges állapotok a következők:The possible states are:

    • Függőben.Pending. A rendelés létrejött, de a feldolgozása még nem kezdődött el.The order has been created but processing hasn't yet been started.
    • Feldolgozás.Processing. A rendelés feldolgozása folyamatban van.The order is currently being processed.
    • Processed.Processed. A rendelés feldolgozása sikeresen megtörtént.The order has been processed successfully.
    • Hiba történt.Error. A rendelés feldolgozása nem sikerült.The order processing has failed.
  • FailureCount.FailureCount. A rendelés feldolgozására tett kísérletek száma.The number of times that processing has been tried for the order.

Ebben az állapotinformációban az OrderID mező az új rendelés rendelésazonosítójából lett kimásolva.In this state information, the OrderID field is copied from the order ID of the new order. A LockedBy és CompleteBy mező értéke null, a ProcessState mező értéke Pending, a FailureCount mező értéke pedig 0.The LockedBy and CompleteBy fields are set to null, the ProcessState field is set to Pending, and the FailureCount field is set to 0.

Megjegyzés

Ebben a példában a rendeléskezelő logika viszonylag egyszerű, és csak egyetlen lépése van, amely távoli szolgáltatást hív meg.In this example, the order handling logic is relatively simple and only has a single step that invokes a remote service. Összetettebb többlépéses forgatókönyv esetén a beküldési folyamat valószínűleg több lépést is magában foglal, így több rekord jön létre az egyes lépések — állapotának leírásával.In a more complex multistep scenario, the submission process would likely involve several steps, and so several records would be created in the state store — each one describing the state of an individual step.

Az ütemező szintén a feldolgozói szerepkör részeként fut, és implementálja a rendelést kezelő üzleti logikát.The Scheduler also runs as part of a worker role and implements the business logic that handles the order. Az ütemező egy új rendeléseket kereső példánya olyan rekordokat vizsgál az állapottárolóban, amelyekben a LockedBy mező értéke null, a ProcessState mezőé pedig „Pending”.An instance of the Scheduler polling for new orders examines the state store for records where the LockedBy field is null and the ProcessState field is pending. Amikor az ütemező új rendelést talál, azonnal kitölti a LockedBy mezőt a saját példányazonosítójával, a CompleteBy mezőt egy megfelelő időpontra állítja be, a ProcessState mezőt pedig „Processing” értékre állítja.When the Scheduler finds a new order, it immediately populates the LockedBy field with its own instance ID, sets the CompleteBy field to an appropriate time, and sets the ProcessState field to processing. A kód kizárólagos és atomi tervezése biztosítja, hogy az ütemező két párhuzamosan futó példánya ne kezelhesse egyszerre ugyanazt a rendelést.The code is designed to be exclusive and atomic to ensure that two concurrent instances of the Scheduler can't try to handle the same order simultaneously.

Az ütemező ezután futtatja az üzleti munkafolyamatot a rendelés aszinkron módon történő feldolgozásához, és átadja a rendelésnek az állapottárolóban található OrderID mezőben lévő értéket.The Scheduler then runs the business workflow to process the order asynchronously, passing it the value in the OrderID field from the state store. A rendelést kezelő munkafolyamat lekéri a rendelés részleteit a rendelési adatbázisból, és elvégzi a feladatát.The workflow handling the order retrieves the details of the order from the orders database and performs its work. Ha a rendelésfeldolgozási munkafolyamatban egy lépésnek távoli szolgáltatást kell meghívnia, erre ügynököt használ.When a step in the order processing workflow needs to invoke the remote service, it uses an Agent. A munkafolyamat-lépés egy kérés/válasz típusú csatornaként működő Azure Service Bus-üzenetsorpárt használ az ügynökkel folytatott kommunikációhoz.The workflow step communicates with the Agent using a pair of Azure Service Bus message queues acting as a request/response channel. Az ábra a megoldás magas szintű nézetét jeleníti meg.The figure shows a high-level view of the solution.

2. ábra – az ütemező ügynök felügyeleti mintájának használata a megrendelések kezeléséhez egy Azure-megoldásban

Az ügynöknek egy munkafolyamat-lépés által küldött üzenet leírja a rendelést, és tartalmazza a befejezési időt.The message sent to the Agent from a workflow step describes the order and includes the complete-by time. Ha az ügynök választ kap a távoli szolgáltatástól a befejezési idő lejárta előtt, válaszüzenetet küld abba a Service Bus-üzenetsorba, amelyet a munkafolyamat figyel.If the Agent receives a response from the remote service before the complete-by time expires, it posts a reply message on the Service Bus queue on which the workflow is listening. Amikor a munkafolyamat-lépés megkapja az érvényes válaszüzenetet, befejezi a feldolgozást, és az ütemező beállítja a ProcessState rendelés állapotának feldolgozni kívánt mezőjét.When the workflow step receives the valid reply message, it completes its processing and the Scheduler sets the ProcessState field of the order state to processed. Ezen a ponton a rendelés feldolgozása sikeresen befejeződött.At this point, the order processing has completed successfully.

Ha a befejezési idő lejár, mielőtt az ügynök választ kap a távoli szolgáltatástól, az ügynök egyszerűen abbahagyja a feldolgozást, és leállítja a rendelés kezelését.If the complete-by time expires before the Agent receives a response from the remote service, the Agent simply halts its processing and terminates handling the order. Ha a rendelést kezelő munkafolyamat túllépi a befejezési időt, hasonlóképpen leáll.Similarly, if the workflow handling the order exceeds the complete-by time, it also terminates. A rendelés állapota az állapottárolóban mindkét esetben „Processing” marad, de a befejezési idő alapján látható, hogy a rendelés feldolgozására szánt idő letelt, és a folyamat sikertelennek lett nyilvánítva.In both cases, the state of the order in the state store remains set to processing, but the complete-by time indicates that the time for processing the order has passed and the process is deemed to have failed. Vegye figyelembe, hogy ha a távoli szolgáltatáshoz hozzáférő ügynök vagy a rendelést kezelő munkafolyamat (vagy mindkettő) váratlanul leáll, az állapottárolóban található információ szintén „Processing” értékre állítva marad, majd idővel lejárt befejezési idővel rendelkezik.Note that if the Agent that's accessing the remote service, or the workflow that's handling the order (or both) terminate unexpectedly, the information in the state store will again remain set to processing and eventually will have an expired complete-by value.

Ha az ügynök helyreállíthatatlan, nem átmeneti hibát észlel a távoli szolgáltatással való kapcsolatfelvételre tett kísérlet közben, hibaüzenetet küldhet vissza a munkafolyamatnak.If the Agent detects an unrecoverable, nontransient fault while it's trying to contact the remote service, it can send an error response back to the workflow. Az ütemező a rendelési állapotot „Error” értékre állíthatja, és elindíthat egy eseményt, amely riaszt egy operátort.The Scheduler can set the status of the order to error and raise an event that alerts an operator. Az operátor ekkor megpróbálja manuálisan elhárítani a hibát, és újraküldeni a sikertelen feldolgozási lépést.The operator can then try to resolve the reason for the failure manually and resubmit the failed processing step.

A felügyelő rendszeres időközönként átvizsgálja az állapottárolót lejárt befejezési időértékű rendeléseket keresve.The Supervisor periodically examines the state store looking for orders with an expired complete-by value. Ha talál ilyen rekordot, növeli a FailureCount mező értékét.If the Supervisor finds a record, it increments the FailureCount field. Ha a hibaszám értéke egy meghatározott küszöbérték alatt van, a felügyelő visszaállítja a LockedBy mezőt nullértékre, új lejárati időre frissíti a CompleteBy mezőt, és beállítja a ProcessState mező állapotát „Pending” értékre.If the failure count value is below a specified threshold value, the Supervisor resets the LockedBy field to null, updates the CompleteBy field with a new expiration time, and sets the ProcessState field to pending. Az ütemező egy példánya átveheti ezt a rendelést, és az eddigiekhez hasonlóan elvégezheti a feldolgozását.An instance of the Scheduler can pick up this order and perform its processing as before. Ha a hibaszám értéke meghaladja a meghatározott küszöbértéket, a rendszer a hiba okát nem átmenetinek tekinti.If the failure count value exceeds a specified threshold, the reason for the failure is assumed to be nontransient. A felügyelő a rendelési állapotot „Error” értékre állítja, és elindít egy eseményt, amely riaszt egy operátort.The Supervisor sets the status of the order to error and raises an event that alerts an operator.

Ebben a példában a felügyelő egy külön feldolgozói szerepkörben van implementálva.In this example, the Supervisor is implemented in a separate worker role. Számos stratégiát használhat a felügyelői feladat futtatására, beleértve az Azure Scheduler-szolgáltatás használatát (nem összetévesztendő az ebben a mintában használt ütemező összetevővel).You can use a variety of strategies to arrange for the Supervisor task to be run, including using the Azure Scheduler service (not to be confused with the Scheduler component in this pattern). Az Azure Scheduler-szolgáltatással kapcsolatos további információért látogasson el a Scheduler oldalára.For more information about the Azure Scheduler service, visit the Scheduler page.

Bár ebben a példában nem mutattuk be, előfordulhat, hogy az ütemezőnek folyamatosan tájékoztatnia kell a rendelést beküldő alkalmazást a rendelés folyamatáról és állapotáról.Although it isn't shown in this example, the Scheduler might need to keep the application that submitted the order informed about the progress and status of the order. Az alkalmazás és az ütemező az egymás közötti függőségek elkerülése érdekében el van különítve egymástól.The application and the Scheduler are isolated from each other to eliminate any dependencies between them. Az alkalmazás nem rendelkezik információval arról, hogy az ütemező melyik példánya kezeli a rendelést, ahogyan az ütemező sem tud arról, pontosan melyik alkalmazáspéldány adta le a rendelést.The application has no knowledge of which instance of the Scheduler is handling the order, and the Scheduler is unaware of which specific application instance posted the order.

Ahhoz, hogy a rendelés állapota jelenthető legyen, az alkalmazás használhatja a saját személyes válaszvárólistáját.To allow the order status to be reported, the application could use its own private response queue. A válaszvárólista részleteit tartalmazza a kérés, amelyet a beküldési folyamat kap meg, amely hozzáadja ezt az információt az állapottárhoz.The details of this response queue would be included as part of the request sent to the submission process, which would include this information in the state store. Ezután az ütemező üzeneteket küld ebbe az üzenetsorba a rendelés állapotáról (kérés megérkezett, rendelés befejezve, rendelés sikertelen stb.).The Scheduler would then post messages to this queue indicating the status of the order (request received, order completed, order failed, and so on). Az üzeneteknek tartalmazniuk kell a rendelési azonosítót, hogy összekapcsolhatók legyenek az alkalmazás által küldött eredeti kéréssel.It should include the order ID in these messages so they can be correlated with the original request by the application.

Az alábbi minták és útmutatók szintén hasznosak lehetnek a minta megvalósításakor:The following patterns and guidance might also be relevant when implementing this pattern:

  • Újrapróbálkozási minta.Retry pattern. Ügynökök használhatják ezt a mintát egy olyan művelet átlátható módon történő megismétléséhez, amely korábban hibás állapotú távoli szolgáltatáshoz vagy erőforráshoz fér hozzá.An Agent can use this pattern to transparently retry an operation that accesses a remote service or resource that has previously failed. Akkor használja, ha a hiba oka valószínűsíthetően átmeneti és elhárítható.Use when the expectation is that the cause of the failure is transient and can be corrected.
  • Áramkör-megszakító minta.Circuit Breaker pattern. Ügynökök használhatják ezt a mintát olyan hibák kezelésére, amelyek elhárítása távoli szolgáltatáshoz vagy erőforráshoz való csatlakozáskor változó mennyiségű időt vesz igénybe.An Agent can use this pattern to handle faults that take a variable amount of time to correct when connecting to a remote service or resource.
  • Kompenzáló tranzakció mintája.Compensating Transaction pattern. Ha az ütemező által végzett munkafolyamatot nem lehet sikeresen befejezni, szükséges lehet az addig elvégzett munka visszavonása.If the workflow being performed by a Scheduler can't be completed successfully, it might be necessary to undo any work it's previously performed. A Kompenzáló tranzakció mintája leírja, hogyan valósítható ez meg olyan műveletek esetében, amelyek a végleges konzisztenciájú modellt követik.The Compensating Transaction pattern describes how this can be achieved for operations that follow the eventual consistency model. Az ilyen típusú műveleteket általában egy összetett üzleti folyamatokat és munkafolyamatokat végző ütemező implementálja.These types of operations are commonly implemented by a Scheduler that performs complex business processes and workflows.
  • Az aszinkron üzenetkezelés ismertetése.Asynchronous Messaging Primer. A Feladatütemező ügynök felügyeleti mintájának összetevői általában egymástól elválasztva futnak, és aszinkron módon kommunikálnak.The components in the Scheduler Agent Supervisor pattern typically run decoupled from each other and communicate asynchronously. Itt néhány, aszinkron módon történő kommunikáció implementálására használt, üzenetsorokon alapuló megközelítés leírását olvashatja.Describes some of the approaches that can be used to implement asynchronous communication based on message queues.
  • Vezető választási minta.Leader Election pattern. Szükséges lehet koordinálni egy felügyelő több példányának műveleteit annak megakadályozása érdekében, hogy a példányok ugyanazt a sikertelen folyamatot próbálják meg helyreállítani.It might be necessary to coordinate the actions of multiple instances of a Supervisor to prevent them from attempting to recover the same failed process. A Vezetőválasztási minta ismerteti, hogyan teheti meg ezt.The Leader Election pattern describes how to do this.
  • Felhőarchitektúra: A Feladatütemező ügynök felügyeleti minta Clemens Vasters blogjánCloud Architecture: The Scheduler-Agent-Supervisor Pattern on Clemens Vasters' blog
  • Folyamatkezelő mintaProcess Manager pattern
  • 6. hivatkozás: Egy saga a sagákról.Reference 6: A Saga on Sagas. Egy példa arra, hogyan használja a CQRS mintája a folyamatkezelőt (a CQRS-út útmutatásának része).An example showing how the CQRS pattern uses a process manager (part of the CQRS Journey guidance).
  • Microsoft Azure SchedulerMicrosoft Azure Scheduler