Számításierőforrás-konszolidálási mintaCompute Resource Consolidation pattern

Egyetlen számítási egységbe konszolidálhat több feladatot vagy műveletet.Consolidate multiple tasks or operations into a single computational unit. Ez megnövelheti a számítási erőforrások kihasználtságát, valamint csökkentheti a felhőben üzemeltetett alkalmazásokban végzett számítási feldolgozások végrehajtásához kapcsolódó költségeket és munkaterhelést.This can increase compute resource utilization, and reduce the costs and management overhead associated with performing compute processing in cloud-hosted applications.

Kontextus és problémaContext and problem

A felhőalkalmazások gyakran számos különböző műveletet végeznek.A cloud application often implements a variety of operations. Néhány megoldásban eleinte érdemes a kockázatok elkülönítésének tervezési alapelvét követni, és felosztani ezeket a műveleteket különálló számítási egységekre, amelyek üzembe helyezése és üzemeltetése egymástól független (például különálló App Service webalkalmazások, különálló virtuális gépek vagy különálló Cloud Service szerepkörök).In some solutions it makes sense to follow the design principle of separation of concerns initially, and divide these operations into separate computational units that are hosted and deployed individually (for example, as separate App Service web apps, separate Virtual Machines, or separate Cloud Service roles). Bár ez a stratégia segíthet leegyszerűsíteni a megoldás logikai kialakítását, ha több számítási egységet helyez üzembe ugyanannak az alkalmazásnak a részeként, az megnövelheti a futtatókörnyezet üzemeltetési költségeit, illetve a rendszer kezelését bonyolultabbá teheti.However, although this strategy can help simplify the logical design of the solution, deploying a large number of computational units as part of the same application can increase runtime hosting costs and make management of the system more complex.

Például az ábrán egy olyan, felhőben üzemeltetett megoldás egyszerűsített struktúrája látható, amely több mint egy számítási egység használatával lett megvalósítva.As an example, the figure shows the simplified structure of a cloud-hosted solution that is implemented using more than one computational unit. Mindegyik számítási egység a saját virtuális környezetét futtatja.Each computational unit runs in its own virtual environment. Mindegyik funkció külön feladatként lett megvalósítva (A–E feladat), amely a saját számítási egységét futtatja.Each function has been implemented as a separate task (labeled Task A through Task E) running in its own computational unit.

Feladatok futtatása egy felhőkörnyezetben dedikált számítási egységek készletének használatával

Mindegyik számítási egység felszámítható erőforrásokat használ, akkor is, ha tétlen vagy kisebb terhelésű.Each computational unit consumes chargeable resources, even when it's idle or lightly used. Ezért ez nem mindig a legköltséghatékonyabb megoldás.Therefore, this isn't always the most cost-effective solution.

Az Azure-ban ez a probléma a Cloud Service, az App Services és a Virtual Machines szerepköreire vonatkozik.In Azure, this concern applies to roles in a Cloud Service, App Services, and Virtual Machines. Ezek az elemek a saját virtuális környezetükben futnak.These items run in their own virtual environment. Ha olyan különálló szerepkörök, webhelyek vagy virtuális gépek összességét futtatja, amelyek jól körülírt műveletek egy készletének végrehajtására lettek tervezve, azonban egy megoldás részeiként kell kommunikálniuk és együttműködniük, lehetséges, hogy erőforrásait nem hatékonyan használja fel.Running a collection of separate roles, websites, or virtual machines that are designed to perform a set of well-defined operations, but that need to communicate and cooperate as part of a single solution, can be an inefficient use of resources.

MegoldásSolution

A költségek csökkentése, a kihasználtság optimalizálása, a kommunikációs sebesség javítása és a kezelési szükségletek csökkentése érdekében egyetlen számítási egységbe konszolidálhat több feladatot vagy műveletet.To help reduce costs, increase utilization, improve communication speed, and reduce management it's possible to consolidate multiple tasks or operations into a single computational unit.

A feladatokat a környezet által biztosított funkciók és a funkciókhoz kapcsolódó költségek szerint megállapított kritériumok alapján csoportosíthatja.Tasks can be grouped according to criteria based on the features provided by the environment and the costs associated with these features. Általánosan használt megközelítés olyan feladatok keresése, amelyek hasonló profillal rendelkeznek a skálázhatóságuk, élettartamuk és feldolgozási követelményeik szempontjából.A common approach is to look for tasks that have a similar profile concerning their scalability, lifetime, and processing requirements. A csoportosításukkal egy egységként skálázhatja őket.Grouping these together allows them to scale as a unit. A több felhőkörnyezet által nyújtott rugalmasság lehetővé teszi, hogy a számítási feladattól függően egy számítási egység további példányait indítsa el vagy állítsa le.The elasticity provided by many cloud environments enables additional instances of a computational unit to be started and stopped according to the workload. Például az Azure használatával automatikusan skálázhatja a Cloud Service, az App Services vagy a Virtual Machines szerepköreit.For example, Azure provides autoscaling that you can apply to roles in a Cloud Service, App Services, and Virtual Machines. További információért lásd az automatikus skálázás útmutatóját.For more information, see Autoscaling Guidance.

Az alábbi két feladat segítségével ellenpéldaként bemutatjuk, hogyan állapítható meg a skálázhatósággal, hogy mely műveleteket nem érdemes csoportosítanunk:As a counter example to show how scalability can be used to determine which operations shouldn't be grouped together, consider the following two tasks:

  • Az 1. feladat az üzenetsorba küldött ritka, nem időérzékeny üzeneteket kérdezi le.Task 1 polls for infrequent, time-insensitive messages sent to a queue.
  • A 2. feladat a hálózati forgalom csúcsterheléseit kezeli.Task 2 handles high-volume bursts of network traffic.

A második feladathoz rugalmasság szükséges, amelyhez hozzátartozik a számítási egység számos példányának elindítása és leállítása is.The second task requires elasticity that can involve starting and stopping a large number of instances of the computational unit. Amennyiben ugyanezt a skálázást alkalmazná az első feladatra, az egyszerűen azt eredményezné, hogy több feladat figyelne ritka üzenetekre ugyanabban az üzenetsorban, így feleslegesen használna erőforrásokat.Applying the same scaling to the first task would simply result in more tasks listening for infrequent messages on the same queue, and is a waste of resources.

Számos felhőkörnyezetben a számítási egységek számára elérhető erőforrások meghatározhatók a processzormagok számával, a memória és a lemezterület méretével, illetve egyéb értékekkel.In many cloud environments it's possible to specify the resources available to a computational unit in terms of the number of CPU cores, memory, disk space, and so on. Általában minél több erőforrás van meghatározva, annál nagyobb a költség is.Generally, the more resources specified, the greater the cost. Pénz megtakarításához fontos maximalizálni a költséges számítási egységek által végrehajtott munkát, illetve biztosítani, hogy ne legyen hosszabb időre inaktív.To save money, it's important to maximize the work an expensive computational unit performs, and not let it become inactive for an extended period.

Ha előfordulnak olyan feladatok, amelyeknek jelentős processzorteljesítményre van szükségük rövidebb időintervallumokban, fontolja meg ezek konszolidálását egy számítási egységbe, amely biztosítja a szükséges teljesítményt.If there are tasks that require a great deal of CPU power in short bursts, consider consolidating these into a single computational unit that provides the necessary power. Fontos azonban megtalálni az egyensúlyt a költséges erőforrások folyamatos működtetése és a túlterhelés által előidézett versengés között.However, it's important to balance this need to keep expensive resources busy against the contention that could occur if they are over stressed. A hosszan futó, nagy számítási igényű feladatok például ne osztozzanak ugyanazon a számítási egységen.Long-running, compute-intensive tasks shouldn't share the same computational unit, for example.

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

Vegye figyelembe az alábbi pontokat a minta megvalósításakor:Consider the following points when implementing this pattern:

Méretezhetőség és rugalmasság.Scalability and elasticity. Számos felhőalapú megoldás a számítási egység szintjén a skálázhatóságot és a rugalmasságot az egységek példányainak elindításával és leállításával valósítja meg.Many cloud solutions implement scalability and elasticity at the level of the computational unit by starting and stopping instances of units. Ne csoportosítsa azokat a feladatokat egy számítási egységbe, amelyek skálázási követelményei ütköznek.Avoid grouping tasks that have conflicting scalability requirements in the same computational unit.

Élettartam.Lifetime. A felhőalapú infrastruktúra rendszeres időközönként újraindítja a számítási egységeket üzemeltető virtuális környezeteket.The cloud infrastructure periodically recycles the virtual environment that hosts a computational unit. Ha számos hosszú lefutású feladat található egy számítási egységben, szükséges lehet úgy konfigurálni az egységet, hogy megakadályozza az újraindítását, míg ezek a feladatok be nem fejeződnek.When there are many long-running tasks inside a computational unit, it might be necessary to configure the unit to prevent it from being recycled until these tasks have finished. Másik megoldásként a feladatokat ellenőrzőpontos megközelítéssel is megtervezheti, amely lehetővé teszi, hogy megfelelően leálljanak, majd arról a pontról folytatódjanak, ahol az adott folyamat megszakadt a számítási egység újraindításakor.Alternatively, design the tasks by using a check-pointing approach that enables them to stop cleanly, and continue at the point they were interrupted when the computational unit is restarted.

Kiadási ütem.Release cadence. Ha egy feladat megvalósítása vagy konfigurációja gyakran változik, szükséges lehet a frissített kódot üzemeltető számítási egység leállítása, az egység újrakonfigurálása és újbóli üzembe helyezése, majd újraindítása.If the implementation or configuration of a task changes frequently, it might be necessary to stop the computational unit hosting the updated code, reconfigure and redeploy the unit, and then restart it. Ehhez a folyamathoz a számítási egységben futtatott összes egyéb feladatot is le kell állítani, újból üzembe kell helyezni, majd újra kell indítani.This process will also require that all other tasks within the same computational unit are stopped, redeployed, and restarted.

Biztonság.Security. Az azonos számítási egységekben futtatott feladatok közös biztonsági környezettel rendelkezhetnek, illetve ugyanazokhoz az erőforrásokhoz férhetnek hozzá.Tasks in the same computational unit might share the same security context and be able to access the same resources. A feladatoknak magas szintű megbízhatósági kapcsolatban kell lenniük, valamint meg kell bizonyosodniuk arról, hogy az egyik feladat nem fogja károsítani vagy negatívan befolyásolni a másikat.There must be a high degree of trust between the tasks, and confidence that one task isn't going to corrupt or adversely affect another. Emellett egy adott számítási egységben futtatott feladatok számának emelése megnöveli az egység támadható felületét.Additionally, increasing the number of tasks running in a computational unit increases the attack surface of the unit. Ha egy feladat nem biztonságos, az a többi feladat biztonságát is rontja.Each task is only as secure as the one with the most vulnerabilities.

Hibatűrés.Fault tolerance. Ha egy feladat a számítási egységben meghibásodik vagy rendellenesen viselkedik, az befolyásolhatja az azonos egységen futtatott egyéb feladatokat is.If one task in a computational unit fails or behaves abnormally, it can affect the other tasks running within the same unit. Ha például egy feladat képtelen megfelelően elindulni, az a számítási egység teljes indítási logikájának meghibásodásához vezethet, megakadályozva az egységen a többi feladat futtatását is.For example, if one task fails to start correctly it can cause the entire startup logic for the computational unit to fail, and prevent other tasks in the same unit from running.

Versengés.Contention. Ne idézzen elő versengést olyan feladatok létrehozásával, amelyek egy adott számítási egységben osztoznak az erőforrásokon.Avoid introducing contention between tasks that compete for resources in the same computational unit. Ideális esetben az egy számítási egységben futtatott feladatok különböző erőforrás-felhasználási jellemzőkkel rendelkeznek.Ideally, tasks that share the same computational unit should exhibit different resource utilization characteristics. Ne futtasson például két nagy számítási igényű feladatot ugyanabban a számítási egységben, valamint két sok memóriát felhasználó feladatot se.For example, two compute-intensive tasks should probably not reside in the same computational unit, and neither should two tasks that consume large amounts of memory. Azonban egy nagy mennyiségű memóriát igénylő feladattal rendelkező, nagy számítási igényű feladat felkeverése egy működőképes kombináció.However, mixing a compute-intensive task with a task that requires a large amount of memory is a workable combination.

Megjegyzés

A számítási erőforrások csak olyan rendszerek esetében vonhatók össze, amelyek egy adott időszakban már éles környezetben üzemelnek, így a kezelők és a fejlesztők nyomon tudják követni a rendszert, és létrehozhatnak egy hő-térképet , amely meghatározza, hogy az egyes feladatok hogyan használják a különböző erőforrásokat.Consider consolidating compute resources only for a system that's been in production for a period of time so that operators and developers can monitor the system and create a heat map that identifies how each task uses differing resources. A térkép segítségével megállapíthatja, hogy mely feladatok között érdemes megosztani a számítási egységeket.This map can be used to determine which tasks are good candidates for sharing compute resources.

Összetettség.Complexity. Amennyiben több feladatot kombinál egy számítási egységben, az megnöveli a kód összetettségét, ami esetleg megnehezítheti a tesztelést, a hibakeresést és a karbantartást.Combining multiple tasks into a single computational unit adds complexity to the code in the unit, possibly making it more difficult to test, debug, and maintain.

Stabil logikai architektúra.Stable logical architecture. A kódot úgy tervezze és valósítsa meg az egyes feladatokban, hogy akkor se kelljen módosítani, ha a feladatot futtató fizikai környezet megváltozik.Design and implement the code in each task so that it shouldn't need to change, even if the physical environment the task runs in does change.

Egyéb stratégiák.Other strategies. A számítási erőforrások konszolidálása csak egy módja a több feladat egyidejű futtatásával járó költségek csökkentésének.Consolidating compute resources is only one way to help reduce costs associated with running multiple tasks concurrently. Csak gondos tervezéssel és monitorozással biztosítható, hogy hatékony megközelítés maradjon.It requires careful planning and monitoring to ensure that it remains an effective approach. A munka természetétől és a feladatokat futtató felhasználók tartózkodási helyétől függően egyéb stratégiák megfelelőbbek lehetnek.Other strategies might be more appropriate, depending on the nature of the work and where the users these tasks are running are located. A számítási feladatok funkcionális felbontása (a Compute-particionálási útmutatónak megfelelően) például jobb megoldás lehet.For example, functional decomposition of the workload (as described by the Compute Partitioning Guidance) might be a better option.

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

Ezt a mintát olyan feladatok esetében alkalmazza, amelyek nem költséghatékonyak, ha a saját számítási egységeikben futnak.Use this pattern for tasks that are not cost effective if they run in their own computational units. Ha egy feladat az idő nagy részében tétlen, a feladat futtatása egy dedikált egységen költséges lehet.If a task spends much of its time idle, running this task in a dedicated unit can be expensive.

Ez a minta lehet, hogy nem megfelelő olyan feladatokhoz, amelyek kritikus hibatűrő műveleteket hajtanak végre, illetve rendkívül bizalmas vagy személyes adatokat dolgoznak fel, és saját biztonsági környezetre van szükségük.This pattern might not be suitable for tasks that perform critical fault-tolerant operations, or tasks that process highly sensitive or private data and require their own security context. Ezeket a feladatokat a saját elkülönített környezetükben érdemes futtatni, különálló számítási egységben.These tasks should run in their own isolated environment, in a separate computational unit.

PéldaExample

Amikor felhőszolgáltatást fejleszt az Azure-ban, a több feladat által végzett feldolgozást egyetlen szerepkörbe konszolidálhatja.When building a cloud service on Azure, it’s possible to consolidate the processing performed by multiple tasks into a single role. Általában ez egy feldolgozói szerepkör, amely háttérben történő vagy aszinkron feldolgozási feladatokat végez.Typically this is a worker role that performs background or asynchronous processing tasks.

Néhány esetben a háttérben történő vagy aszinkron feldolgozási feladatokat belefoglalhatja a webes szerepkörbe.In some cases it's possible to include background or asynchronous processing tasks in the web role. Ezzel a módszerrel csökkentheti a költségeket és egyszerűsítheti az üzembe helyezést, azonban ez befolyásolhatja a webes szerepkör által biztosított nyilvános felület skálázhatóságát és válaszképességét.This technique helps to reduce costs and simplify deployment, although it can impact the scalability and responsiveness of the public-facing interface provided by the web role.

Ez a szerepkör felelős a feladatok indításáért és leállításáért.The role is responsible for starting and stopping the tasks. Amikor az Azure Fabric Controller betölt egy szerepkört, kiváltja a szerepkör Start eseményét.When the Azure fabric controller loads a role, it raises the Start event for the role. Felülírhatja a WebRole vagy WorkerRole osztály OnStart metódusát, hogy kezelje az eseményt, például azoknak az adatoknak és egyéb erőforrásoknak az inicializálásával, amelyektől a metódus feladatai függnek.You can override the OnStart method of the WebRole or WorkerRole class to handle this event, perhaps to initialize the data and other resources the tasks in this method depend on.

A OnStart metódus befejeződése után a szerepkör válaszolhat a kérelmekre.When the OnStart method completes, the role can start responding to requests. Az OnStart és a Run metódus szerepkörben történő használatáról további információkat és útmutatást az alkalmazások felhőbe való áthelyezését tárgyaló minta- és gyakorlati útmutató alkalmazásindítási folyamatokról szóló szakaszában talál.You can find more information and guidance about using the OnStart and Run methods in a role in the Application Startup Processes section in the patterns & practices guide Moving Applications to the Cloud.

Az OnStart metódus kódja legyen a lehető legtömörebb.Keep the code in the OnStart method as concise as possible. Az Azure nem határoz meg küszöbértéket a metódus befejezésére engedélyezett időtartamnak, azonban a szerepkör nem kezdi megválaszolni az elküldött hálózati kéréseket, amíg a metódus be nem fejeződik.Azure doesn't impose any limit on the time taken for this method to complete, but the role won't be able to start responding to network requests sent to it until this method completes.

Ha az OnStart metódus befejeződött, a szerepkör végrehajtja a Run metódust.When the OnStart method has finished, the role executes the Run method. Ekkor a hálóvezérlő megkezdi a kérések küldését a szerepkörnek.At this point, the fabric controller can start sending requests to the role.

Helyezze a feladatokat ténylegesen létrehozó kódot a Run metódusba.Place the code that actually creates the tasks in the Run method. Vegye figyelembe, hogy a Run metódus határozza meg a szerepkörpéldány élettartamát.Note that the Run method defines the lifetime of the role instance. A metódus befejezésekor a hálóvezérlő kezdeményezi a szerepkör leállítását.When this method completes, the fabric controller will arrange for the role to be shut down.

Amikor egy szerepkör leáll vagy újraindul, a hálóvezérlő megakadályozza, hogy további bejövő kérések érkezzenek a terheléselosztóból, és kiváltja a Stop eseményt.When a role shuts down or is recycled, the fabric controller prevents any more incoming requests being received from the load balancer and raises the Stop event. Ezt az eseményt a szerepkör OnStop metódusának felülbírálásával rögzítheti, majd hajtsa végre a szükséges tisztítási műveleteket a szerepkör leállítása előtt.You can capture this event by overriding the OnStop method of the role and perform any tidying up required before the role terminates.

Az OnStop metódusban végrehajtott összes műveletet öt percen belül be kell fejezni (vagy 30 másodpercen belül, ha Azure emulátort használt helyi számítógépen).Any actions performed in the OnStop method must be completed within five minutes (or 30 seconds if you are using the Azure emulator on a local computer). Ellenkező esetben az Azure Fabric Controller azt feltételezi, hogy a szerepkör elakadt, és leállásra kényszeríti.Otherwise the Azure fabric controller assumes that the role has stalled and will force it to stop.

A feladatokat a Run metódus indítja el, amely megvárja a feladatok befejezését.The tasks are started by the Run method that waits for the tasks to complete. A feladatok megvalósítják a felhőszolgáltatás üzleti logikáját, és a szerepkörnek küldött üzeneteket az Azure Load Balanceren keresztül válaszolják meg.The tasks implement the business logic of the cloud service, and can respond to messages posted to the role through the Azure load balancer. Az ábrán egy Azure-felhőszolgáltatás szerepköréhez tartozó feladatok és erőforrások életciklusa látható.The figure shows the lifecycle of tasks and resources in a role in an Azure cloud service.

Egy Azure-felhőszolgáltatás szerepköréhez tartozó feladatok és erőforrások életciklusa

A WorkerRole.cs fájl a ComputeResourceConsolidation.Worker projektben arra mutat be egy példát, hogyan valósíthatja meg ezt a mintát egy Azure felhőszolgáltatásban.The WorkerRole.cs file in the ComputeResourceConsolidation.Worker project shows an example of how you might implement this pattern in an Azure cloud service.

A ComputeResourceConsolidation.Worker projekt a ComputeResourceConsolidation megoldás része, amely letölthető a GitHubról.The ComputeResourceConsolidation.Worker project is part of the ComputeResourceConsolidation solution available for download from GitHub.

A MyWorkerTask1 és a MyWorkerTask2 metódus bemutatja, hogyan hajthat végre különböző feladatokat ugyanabban a feldolgozói szerepkörben.The MyWorkerTask1 and the MyWorkerTask2 methods illustrate how to perform different tasks within the same worker role. Az alábbi kódban a MyWorkerTask1 látható.The following code shows MyWorkerTask1. Ez egy egyszerű feladat, amely 30 másodpercig alvó állapotba lép, majd elküld egy nyomkövetési üzenetet.This is a simple task that sleeps for 30 seconds and then outputs a trace message. Ez a folyamat a feladat megszakításáig ismétlődik.It repeats this process until the task is canceled. A MyWorkerTask2 kódja hasonló.The code in MyWorkerTask2 is similar.

// A sample worker role task.
private static async Task MyWorkerTask1(CancellationToken ct)
{
  // Fixed interval to wake up and check for work and/or do work.
  var interval = TimeSpan.FromSeconds(30);

  try
  {
    while (!ct.IsCancellationRequested)
    {
      // Wake up and do some background processing if not canceled.
      // TASK PROCESSING CODE HERE
      Trace.TraceInformation("Doing Worker Task 1 Work");

      // Go back to sleep for a period of time unless asked to cancel.
      // Task.Delay will throw an OperationCanceledException when canceled.
      await Task.Delay(interval, ct);
    }
  }
  catch (OperationCanceledException)
  {
    // Expect this exception to be thrown in normal circumstances or check
    // the cancellation token. If the role instances are shutting down, a
    // cancellation request will be signaled.
    Trace.TraceInformation("Stopping service, cancellation requested");

    // Rethrow the exception.
    throw;
  }
}

A mintakód a háttérfolyamatok egy gyakori megvalósítását mutatja be.The sample code shows a common implementation of a background process. Egy valós alkalmazásban követheti ugyanezt a struktúrát, azonban helyezze a saját feldolgozási logikáját a megszakítási kérelemre váró hurok törzsébe.In a real world application you can follow this same structure, except that you should place your own processing logic in the body of the loop that waits for the cancellation request.

Miután a feldolgozói szerepkör inicializálta a felhasználni kívánt erőforrásokat, a Run metódus egyszerre elindítja a két feladatot az itt látható módon.After the worker role has initialized the resources it uses, the Run method starts the two tasks concurrently, as shown here.

/// <summary>
/// The cancellation token source use to cooperatively cancel running tasks
/// </summary>
private readonly CancellationTokenSource cts = new CancellationTokenSource();

/// <summary>
/// List of running tasks on the role instance
/// </summary>
private readonly List<Task> tasks = new List<Task>();

// RoleEntry Run() is called after OnStart().
// Returning from Run() will cause a role instance to recycle.
public override void Run()
{
  // Start worker tasks and add to the task list
  tasks.Add(MyWorkerTask1(cts.Token));
  tasks.Add(MyWorkerTask2(cts.Token));

  foreach (var worker in this.workerTasks)
  {
      this.tasks.Add(worker);
  }

  Trace.TraceInformation("Worker host tasks started");
  // The assumption is that all tasks should remain running and not return,
  // similar to role entry Run() behavior.
  try
  {
    Task.WaitAll(tasks.ToArray());
  }
  catch (AggregateException ex)
  {
    Trace.TraceError(ex.Message);

    // If any of the inner exceptions in the aggregate exception
    // are not cancellation exceptions then re-throw the exception.
    ex.Handle(innerEx => (innerEx is OperationCanceledException));
  }

  // If there wasn't a cancellation request, stop all tasks and return from Run()
  // An alternative to canceling and returning when a task exits would be to
  // restart the task.
  if (!cts.IsCancellationRequested)
  {
    Trace.TraceInformation("Task returned without cancellation request");
    Stop(TimeSpan.FromMinutes(5));
  }
}
...

Ebben a példában a Run metódus a feladatok befejezésére vár.In this example, the Run method waits for tasks to be completed. Ha a feladat meg lett szakítva, a Run metódus azt feltételezi, hogy a szerepkör leáll, és megvárja a hátralévő feladatok megszakítását a befejezés előtt (legfeljebb öt percet vár a leállításra).If a task is canceled, the Run method assumes that the role is being shut down and waits for the remaining tasks to be canceled before finishing (it waits for a maximum of five minutes before terminating). Ha a feladat egy várt kivétel miatt hiúsul meg, a Run metódus megszakítja a feladatot.If a task fails due to an expected exception, the Run method cancels the task.

Olyan átfogóbb monitorozási és kivételkezelési stratégiákat is megvalósíthat a Run metódusban, mint például a meghiúsult feladatok újraindítása, illetve olyan kód beillesztése, amely engedélyezi a szerepkör számára egyes feladatok leállítását és elindítását.You could implement more comprehensive monitoring and exception handling strategies in the Run method such as restarting tasks that have failed, or including code that enables the role to stop and start individual tasks.

A következő kódban látható Stop metódust a rendszer akkor hívja meg, amikor a hálóvezérlő leállítja a szerepkörpéldányt (az OnStop metódusból indítva).The Stop method shown in the following code is called when the fabric controller shuts down the role instance (it's invoked from the OnStop method). A kód minden feladatot szabályosan állít le azok megszakításával.The code stops each task gracefully by canceling it. Ha a feladat befejezése több mint öt percet vesz igénybe, a Stop metódus megszakítási feldolgozása nem vár tovább, és a szerepkört leállítja.If any task takes more than five minutes to complete, the cancellation processing in the Stop method ceases waiting and the role is terminated.

// Stop running tasks and wait for tasks to complete before returning
// unless the timeout expires.
private void Stop(TimeSpan timeout)
{
  Trace.TraceInformation("Stop called. Canceling tasks.");
  // Cancel running tasks.
  cts.Cancel();

  Trace.TraceInformation("Waiting for canceled tasks to finish and return");

  // Wait for all the tasks to complete before returning. Note that the
  // emulator currently allows 30 seconds and Azure allows five
  // minutes for processing to complete.
  try
  {
    Task.WaitAll(tasks.ToArray(), timeout);
  }
  catch (AggregateException ex)
  {
    Trace.TraceError(ex.Message);

    // If any of the inner exceptions in the aggregate exception
    // are not cancellation exceptions then rethrow the exception.
    ex.Handle(innerEx => (innerEx is OperationCanceledException));
  }
}

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:

  • Útmutató az automatikus skálázáshoz.Autoscaling Guidance. Az automatikus skálázás használatával szolgáltatásokat üzemeltető számítási erőforrásokat indíthat el vagy állíthat le a várható feldolgozási igényektől függően.Autoscaling can be used to start and stop instances of service hosting computational resources, depending on the anticipated demand for processing.

  • Számítási particionálási útmutató.Compute Partitioning Guidance. Bemutatja, hogyan foglalhat le szolgáltatásokat és összetevőket egy felhőszolgáltatásban olyan módon, hogy az segítsen minimalizálni a futtatási költségeket a szolgáltatás skálázhatóságának, teljesítményének, rendelkezésre állásának és biztonságának megőrzése mellett.Describes how to allocate the services and components in a cloud service in a way that helps to minimize running costs while maintaining the scalability, performance, availability, and security of the service.

  • Ez a minta egy letölthető mintaalkalmazást tartalmaz.This pattern includes a downloadable sample application.