BakgrundsjobbBackground jobs

Många typer av program kräver bakgrundsaktiviteter som körs oberoende av användargränssnittet (UI).Many types of applications require background tasks that run independently of the user interface (UI). Det kan vara batchjobb, beräkningsintensiva bearbetningar och tidskrävande processer, till exempel arbetsflöden.Examples include batch jobs, intensive processing tasks, and long-running processes such as workflows. Bakgrundsjobb kan köras utan användaråtgärder – programmet kan starta jobbet och sedan fortsätta att bearbeta interaktiva begäranden från användarna.Background jobs can be executed without requiring user interaction--the application can start the job and then continue to process interactive requests from users. Det kan hjälpa dig för att minimera belastningen på programmets användargränssnitt, vilket kan förbättra tillgängligheten och minska interaktiva svarstider.This can help to minimize the load on the application UI, which can improve availability and reduce interactive response times.

Om ett program krävs för att generera miniatyrer av bilder som har laddats upp av användare, kan det göra detta i bakgrunden och spara miniatyren när den är klar – utan att användaren behöver vänta tills processen har slutförts.For example, if an application is required to generate thumbnails of images that are uploaded by users, it can do this as a background job and save the thumbnail to storage when it is complete--without the user needing to wait for the process to be completed. På samma sätt kan en användare som lägger en order starta ett arbetsflöde i bakgrunden som bearbetar ordern, medan användaren kan fortsätta bläddra i webbprogrammet med användargränssnittet.In the same way, a user placing an order can initiate a background workflow that processes the order, while the UI allows the user to continue browsing the web app. När bakgrundsjobbet har slutförts kan det uppdatera lagrade orderdata och skicka ett e-postmeddelande med orderbekräftelse till användaren.When the background job is complete, it can update the stored orders data and send an email to the user that confirms the order.

Om du funderar på att implementera en uppgift som en bakgrundsaktivitet är det viktigaste kriteriet huruvida uppgiften kan köras utan användarinteraktion och utan att användargränssnittet behöver vänta tills jobbet har slutförts.When you consider whether to implement a task as a background job, the main criteria is whether the task can run without user interaction and without the UI needing to wait for the job to be completed. Uppgifter som kräver att användaren eller användargränssnittet väntar medan de slutförs kanske inte är så lämpliga som bakgrundsaktiviteter.Tasks that require the user or the UI to wait while they are completed might not be appropriate as background jobs.

Typer av bakgrundsjobbTypes of background jobs

Bakgrundsjobb är vanligtvis en eller flera av följande typer av jobb:Background jobs typically include one or more of the following types of jobs:

  • Processorintensiva jobb, t.ex matematiska beräkningar eller strukturella modellanalyser.CPU-intensive jobs, such as mathematical calculations or structural model analysis.
  • I/O-intensiva jobb, till exempel att köra en serie lagringstransaktioner eller indexering av filer.I/O-intensive jobs, such as executing a series of storage transactions or indexing files.
  • Batchjobb, till exempel datauppdateringar under natten eller schemalagd bearbetning.Batch jobs, such as nightly data updates or scheduled processing.
  • Långvariga arbetsflöden, till exempel orderhantering eller att tillhandahålla tjänster och system.Long-running workflows, such as order fulfillment, or provisioning services and systems.
  • Bearbetning av känsliga data där uppgiften skickas till en säkrare plats för bearbetning.Sensitive-data processing where the task is handed off to a more secure location for processing. Till exempel kanske du inte vill bearbeta känsliga data i en webbapp.For example, you might not want to process sensitive data within a web app. I stället kan du använda ett mönster som Gatekeeper- mönstret för att överföra data till en isolerad bakgrunds process som har åtkomst till skyddad lagring.Instead, you might use a pattern such as the Gatekeeper pattern to transfer the data to an isolated background process that has access to protected storage.

UtlösareTriggers

Bakgrundsjobb kan initieras på flera olika sätt.Background jobs can be initiated in several different ways. De delas in i följande kategorier:They fall into one of the following categories:

  • Händelse drivna utlösare.Event-driven triggers. Uppgiften startats när en händelse inträffar, vanligtvis en åtgärd av en användare eller ett steg i ett arbetsflöde.The task is started in response to an event, typically an action taken by a user or a step in a workflow.
  • Schemadrivna utlösare.Schedule-driven triggers. Uppgiften anropas enligt ett schema som baseras på en timer.The task is invoked on a schedule based on a timer. Det kan vara ett återkommande schema eller ett engångsanrop som har angetts för ett senare tillfälle.This might be a recurring schedule or a one-off invocation that is specified for a later time.

Händelsedrivna utlösareEvent-driven triggers

Händelsedrivet anrop använder en utlösare för att starta bakgrundsaktiviteten.Event-driven invocation uses a trigger to start the background task. Några exempel på händelsedrivna utlösare:Examples of using event-driven triggers include:

  • Användargränssnittet eller ett annat jobb placerar ett meddelande i en kö.The UI or another job places a message in a queue. Meddelandet innehåller data om en åtgärd som har utförts, till exempel att användaren har lagt en order.The message contains data about an action that has taken place, such as the user placing an order. Bakgrundsaktiviteten lyssnar i den här kön och känner av att nytt meddelande har kommit.The background task listens on this queue and detects the arrival of a new message. Den läser meddelandet och använder data i det som indata för bakgrundsjobbet.It reads the message and uses the data in it as the input to the background job.
  • Användargränssnittet eller ett annat jobb sparar eller uppdaterar ett värde i minnet.The UI or another job saves or updates a value in storage. Bakgrundsaktiviteten övervakar lagringsutrymmet och identifierar ändringar.The background task monitors the storage and detects changes. Den läser dessa data och använder dem som indata för bakgrundsjobbet.It reads the data and uses it as the input to the background job.
  • Användargränssnittet eller ett annat jobb skickar en förfrågan till en slutpunkt, till exempel en HTTPS-URI eller ett API som visas som en webbtjänst.The UI or another job makes a request to an endpoint, such as an HTTPS URI, or an API that is exposed as a web service. Det skickar data som krävs för att slutföra bakgrundsaktiviteten som en del av förfrågan.It passes the data that is required to complete the background task as part of the request. Slutpunkten eller webbtjänsten anropar bakgrundsaktiviteten, som använder dessa data som indata.The endpoint or web service invokes the background task, which uses the data as its input.

Typexempel på uppgifter som passar bra för händelsedrivna anrop är bildbearbetning, arbetsflöden, att skicka information till fjärrtjänster, skicka e-postmeddelanden och etablera nya användare i program med flera organisationer i samma installation.Typical examples of tasks that are suited to event-driven invocation include image processing, workflows, sending information to remote services, sending email messages, and provisioning new users in multitenant applications.

Schemadrivna utlösareSchedule-driven triggers

Schemadrivet anrop använder en timer för att starta bakgrundsaktiviteten.Schedule-driven invocation uses a timer to start the background task. Några exempel på schemadrivna utlösare:Examples of using schedule-driven triggers include:

  • En timer som körs lokalt inom programmet eller som en del av programmets operativ system anropar en bakgrunds aktivitet regelbundet.A timer that is running locally within the application or as part of the application's operating system invokes a background task on a regular basis.
  • En timer som körs i ett annat program, till exempel Azure Logic Apps, skickar en begäran till ett API eller en webb tjänst med jämna mellanrum.A timer that is running in a different application, such as Azure Logic Apps, sends a request to an API or web service on a regular basis. API:et eller webbtjänsten anropar bakgrundsaktiviteten.The API or web service invokes the background task.
  • En separat process eller program startar en timer som anropar bakgrundsaktiviteten en gång efter en angiven tidsfördröjning eller vid en viss tidpunkt.A separate process or application starts a timer that causes the background task to be invoked once after a specified time delay, or at a specific time.

Typexempel på uppgifter som passar bra för schemadrivna anrop är batchbearbetningar (till exempel att uppdatera listor över relaterade produkter för användare baserat på deras senaste beteende), rutinuppgifter av databearbetning (till exempel att uppdatera index eller generera ackumulerat resultat), dataanalys för dagliga rapporter, rensning av datakvarhållning och kontroller av datakonsekvens.Typical examples of tasks that are suited to schedule-driven invocation include batch-processing routines (such as updating related-products lists for users based on their recent behavior), routine data processing tasks (such as updating indexes or generating accumulated results), data analysis for daily reports, data retention cleanup, and data consistency checks.

Om du använder en schemadriven uppgift som måste köras som en enskild instans ska du tänka på följande:If you use a schedule-driven task that must run as a single instance, be aware of the following:

  • Om beräkningsinstansen som kör i schemaläggaren (till exempel en virtuell dator med Windows-schemalagda aktiviteter) skalas upp, kommer du att köra flera instanser av schemaläggaren.If the compute instance that is running the scheduler (such as a virtual machine using Windows scheduled tasks) is scaled, you will have multiple instances of the scheduler running. Dessa kan starta flera instanser av uppgiften.These could start multiple instances of the task.
  • Om uppgifter körs under en längre tid än perioden mellan schemalagda händelser kan det hända att schemaläggaren startar en till instans av aktiviteten medan den föregående fortfarande körs.If tasks run for longer than the period between scheduler events, the scheduler may start another instance of the task while the previous one is still running.

Returnerade resultatReturning results

Bakgrundsjobb utföras asynkront i en separat process, eller till och med på en annan plats, än användargränssnittet eller den process som anropade bakgrundsaktiviteten.Background jobs execute asynchronously in a separate process, or even in a separate location, from the UI or the process that invoked the background task. Vi rekommenderar att bakgrunds aktiviteterna är "Fire and glömma"-åtgärder och att deras körnings förlopp inte påverkar användar gränssnittet eller anrops processen.Ideally, background tasks are "fire and forget" operations, and their execution progress has no impact on the UI or the calling process. Det innebär att den anropsprocessen inte väntar på att uppgifterna ska slutföras.This means that the calling process does not wait for completion of the tasks. Därför kan den inte automatiskt känna av när uppgiften avslutas.Therefore, it cannot automatically detect when the task ends.

Om du vill att en bakgrundsaktivitet ska kommunicera förlopp eller slutförande till den anropande uppgiften måste du implementera en mekanism för detta.If you require a background task to communicate with the calling task to indicate progress or completion, you must implement a mechanism for this. Några exempel är:Some examples are:

  • Skriva ett statusvärde i lagringsutrymmet som är tillgängligt för användargränssnittet eller den anropande uppgiften som kan övervaka eller kontrollera det här värdet vid behov.Write a status indicator value to storage that is accessible to the UI or caller task, which can monitor or check this value when required. Andra data som bakgrundsaktiviteten måste returnera till anroparen kan placeras i samma lagringsutrymme.Other data that the background task must return to the caller can be placed into the same storage.
  • Upprätta en svarskö som användargränssnittet eller anroparen lyssnar på.Establish a reply queue that the UI or caller listens on. Bakgrundsaktiviteten kan skicka meddelanden till kön som anger status och slutförande.The background task can send messages to the queue that indicate status and completion. Data som bakgrundsaktiviteten måste returnera till anroparen kan också placeras i meddelandena.Data that the background task must return to the caller can be placed into the messages. Om du använder Azure Service Bus kan du använda egenskaperna ReplyTo och CorrelationId för att implementera den här funktionen.If you are using Azure Service Bus, you can use the ReplyTo and CorrelationId properties to implement this capability.
  • Exponera ett API eller en slutpunkt från bakgrundsaktiviteten som användargränssnittet eller anroparen kan komma åt för att hämta statusinformation.Expose an API or endpoint from the background task that the UI or caller can access to obtain status information. Data som bakgrundsaktiviteten måste returnera till anroparen kan infogas i svaret.Data that the background task must return to the caller can be included in the response.
  • Låt bakgrundsaktivitet anropa användargränssnittet eller anroparen via ett API för att ange status vid fördefinierade punkter eller vid slutförande.Have the background task call back to the UI or caller through an API to indicate status at predefined points or on completion. Det kan göras via händelser som inträffar lokalt eller via en publicera–prenumerera-mekanism.This might be through events raised locally or through a publish-and-subscribe mechanism. Data som bakgrundsaktiviteten måste returnera till anroparen kan infogas i förfrågan eller händelsens nyttolast.Data that the background task must return to the caller can be included in the request or event payload.

VärdmiljöHosting environment

Du kan använda en mängd olika tjänster på Azure-plattformen som värd för bakgrundsaktiviteter:You can host background tasks by using a range of different Azure platform services:

  • Azure Web Apps och WebJobs.Azure Web Apps and WebJobs. Du kan använda webbjobb för att köra anpassade jobb baserat på en mängd olika typer av skript eller körbara program inom kontexten för en webbapp.You can use WebJobs to execute custom jobs based on a range of different types of scripts or executable programs within the context of a web app.
  • Azure Functions.Azure Functions. Du kan använda funktioner för bakgrunds jobb som inte körs under en längre tid.You can use functions for background jobs that don't run for a long time. Ett annat användnings fall är om din arbets belastning redan finns på App Service plan och underutnyttjas.Another use case is if your workload is already hosted on App Service plan and is underutilized.
  • Azure-Virtual Machines.Azure Virtual Machines. Om du har en Windows-tjänst eller om du vill använda Schemaläggaren i Windows är det vanligt att använda en dedikerad virtuell dator som värd för bakgrundsaktiviteterna.If you have a Windows service or want to use the Windows Task Scheduler, it is common to host your background tasks within a dedicated virtual machine.
  • Azure Batch.Azure Batch. Batch är en plattformstjänst som schemalägger beräkningsintensiva arbeten att köras på en hanterad samling av virtuella datorer.Batch is a platform service that schedules compute-intensive work to run on a managed collection of virtual machines. Den kan automatiskt skala beräkningsresurserna.It can automatically scale compute resources.
  • Azure Kubernetes service (AKS).Azure Kubernetes Service (AKS). Azure Kubernetes-tjänsten tillhandahåller en hanterad värd miljö för Kubernetes på Azure.Azure Kubernetes Service provides a managed hosting environment for Kubernetes on Azure.

I följande avsnitt beskrivs dessa alternativ i detalj och tar upp viktiga aspekter att tänka på som hjälper dig att välja rätt alternativ.The following sections describe each of these options in more detail, and include considerations to help you choose the appropriate option.

Azure Web Apps och WebJobsAzure Web Apps and WebJobs

Du kan använda Azure WebJobs för att köra anpassade jobb som bakgrundsaktiviteter i en Azure-webbapp.You can use Azure WebJobs to execute custom jobs as background tasks within an Azure Web App. Webbjobb körs inom webbappens kontext som en kontinuerlig process.WebJobs run within the context of your web app as a continuous process. WebJobs körs också som svar på en Utlös ande händelse från Azure Logic Apps eller externa faktorer, t. ex. ändringar i Storage-blobbar och meddelande köer.WebJobs also run in response to a trigger event from Azure Logic Apps or external factors, such as changes to storage blobs and message queues. Jobb kan startas och stoppas på begäran och avslutas på vanligt sätt.Jobs can be started and stopped on demand, and shut down gracefully. Om ett webbjobb som körs kontinuerligt misslyckas startas det om automatiskt.If a continuously running WebJob fails, it is automatically restarted. Åtgärder vid nya försök och fel kan konfigureras.Retry and error actions are configurable.

När du konfigurerar ett webbjobb:When you configure a WebJob:

  • Om du vill att jobbet ska svara på en händelsedriven utlösare ska du konfigurera det som Kör kontinuerligt.If you want the job to respond to an event-driven trigger, you should configure it as Run continuously. Skriptet eller programmet lagras i mappen med namnet site/wwwroot/app_data/jobs/continuous.The script or program is stored in the folder named site/wwwroot/app_data/jobs/continuous.
  • Om du vill att jobbet ska svara på en schemadriven utlösare ska du konfigurera det som Kör enligt schema.If you want the job to respond to a schedule-driven trigger, you should configure it as Run on a schedule. Skriptet eller programmet lagras i mappen med namnet site/wwwroot/app_data/jobs/triggered.The script or program is stored in the folder named site/wwwroot/app_data/jobs/triggered.
  • Om du väljer alternativet Kör på begäran när du konfigurerar ett jobb, körs samma kod som för alternativet Kör enligt schema när det startas.If you choose the Run on demand option when you configure a job, it will execute the same code as the Run on a schedule option when you start it.

Azure WebJobs körs i webbappens sandbox-miljö.Azure WebJobs run within the sandbox of the web app. Det innebär att de kan få åtkomst till miljövariabler och dela information, som anslutningssträngar, med webbappen.This means that they can access environment variables and share information, such as connection strings, with the web app. Jobbet har åtkomst till den unika identifieraren för den dator som kör jobbet.The job has access to the unique identifier of the machine that is running the job. Anslutningssträngen med namnet AzureWebJobsStorage ger åtkomst till Azure-lagringsköer, blobar och tabeller för programdata samt åtkomst till Service Bus för meddelanden och kommunikation.The connection string named AzureWebJobsStorage provides access to Azure storage queues, blobs, and tables for application data, and access to Service Bus for messaging and communication. Anslutningssträngen med namnet AzureWebJobsDashboard ger åtkomst till loggfiler för jobbåtgärder.The connection string named AzureWebJobsDashboard provides access to the job action log files.

Azure WebJobs har följande egenskaper:Azure WebJobs have the following characteristics:

  • Säkerhet: WebJobs skyddas av webbappens autentiseringsuppgifter för distribution.Security: WebJobs are protected by the deployment credentials of the web app.
  • Filtyper som stöds: Du kan definiera webbjobb med kommandoskript (.cmd), batchfiler (.bat), PowerShell-skript (.ps1), bash shell-skript (.sh), PHP-skript (.php), Python-skript (.py), JavaScript-kod (.js) och körbara program (.exe, .jar med flera).Supported file types: You can define WebJobs by using command scripts (.cmd), batch files (.bat), PowerShell scripts (.ps1), bash shell scripts (.sh), PHP scripts (.php), Python scripts (.py), JavaScript code (.js), and executable programs (.exe, .jar, and more).
  • Distribution: Du kan distribuera skript och körbara filer med hjälp av Azure Portal, med hjälp av Visual Studio, med hjälp av den Azure WebJobs SDK eller genom att kopiera dem direkt till följande platser:Deployment: You can deploy scripts and executables by using the Azure portal, by using Visual Studio, by using the Azure WebJobs SDK, or by copying them directly to the following locations:
    • För utlöst körning: site/wwwroot/app_data/jobs/triggered/{jobbnamn}For triggered execution: site/wwwroot/app_data/jobs/triggered/{job name}
    • För kontinuerlig körning: site/wwwroot/app_data/jobs/continuous/{jobbnamn}For continuous execution: site/wwwroot/app_data/jobs/continuous/{job name}
  • Loggning: Console.Out behandlas (markeras) som information.Logging: Console.Out is treated (marked) as INFO. Console.Error behandlas som fel.Console.Error is treated as ERROR. Du kan komma åt övervaknings- och diagnostikinformation via Azure Portal.You can access monitoring and diagnostics information by using the Azure portal. Du kan ladda ned loggfiler direkt från webbplatsen.You can download log files directly from the site. De sparas på följande platser:They are saved in the following locations:
    • För utlöst körning: Vfs/data/jobs/triggered/jobNameFor triggered execution: Vfs/data/jobs/triggered/jobName
    • För kontinuerlig körning: Vfs/data/jobs/continuous/jobNameFor continuous execution: Vfs/data/jobs/continuous/jobName
  • Konfiguration: Du kan konfigurera webbjobb med hjälp av portalen, REST-API och PowerShell.Configuration: You can configure WebJobs by using the portal, the REST API, and PowerShell. Du kan använda en konfigurationsfil med namnet settings.job i samma rotkatalog som jobbskriptet för att tillhandahålla konfigurationsinformation för ett jobb.You can use a configuration file named settings.job in the same root directory as the job script to provide configuration information for a job. Exempel:For example:
    • { "stopping_wait_time": 60 }{ "stopping_wait_time": 60 }
    • { "is_singleton": true }{ "is_singleton": true }

ÖvervägandenConsiderations

  • Som standard skalas webbjobb med webbappen.By default, WebJobs scale with the web app. Men du kan konfigurera jobb att köra på en enskild instans genom att ange konfigurationsegenskapen is_singleton till true.However, you can configure jobs to run on single instance by setting the is_singleton configuration property to true. Webbjobb för enskilda instanser är användbara för uppgifter som du inte vill skala eller köra som flera samtidiga instanser, som omindexering, dataanalyser och liknande uppgifter.Single instance WebJobs are useful for tasks that you do not want to scale or run as simultaneous multiple instances, such as reindexing, data analysis, and similar tasks.
  • För att minimera effekten av jobb på webbappens prestanda kan du överväga att skapa en tom Azure Web App-instans i en ny App Service plan för att vara värd för långvariga eller resurs intensiva WebJobs.To minimize the impact of jobs on the performance of the web app, consider creating an empty Azure Web App instance in a new App Service plan to host long-running or resource-intensive WebJobs.

Azure FunctionsAzure Functions

Ett alternativ som liknar WebJobs är Azure Functions.An option that is similar to WebJobs is Azure Functions. Den här tjänsten är Server lös som är mest lämplig för händelse drivna utlösare som körs under en kort period.This service is serverless that is most suitable for event-driven triggers that run for a short period. En funktion kan också användas för att köra schemalagda jobb via timer-utlösare, när de konfigureras att köras vid angivna tidpunkter.A function can also be used to run scheduled jobs through timer triggers, when configured to run at set times.

Azure Functions är inte ett rekommenderat alternativ för stora, långvariga aktiviteter eftersom de kan orsaka oväntade timeout-problem.Azure Functions is not a recommended option for large, long-running tasks because they can cause unexpected timeout issues. Beroende på värd planen kan de dock övervägas för schema drivna utlösare.However, depending on the hosting plan, they can be considered for schedule-driven triggers.

ÖvervägandenConsiderations

Om bakgrunds aktiviteten förväntas köras under en kort varaktighet som svar på en händelse, kan du överväga att köra aktiviteten i en förbruknings plan.If the background task is expected to run for a short duration in response to an event, consider running the task in a Consumption plan. Körnings tiden kan konfigureras upp till en maximal tid.The execution time is configurable up to a maximum time. En funktion som körs för längre kostnader.A function that runs for longer costs more. Även processor intensiva jobb som använder mer minne kan vara dyrare.Also CPU-intensive jobs that consume more memory can be more expensive. Om du använder ytterligare utlösare för tjänster som en del av din uppgift faktureras de separat.If you use additional triggers for services as part of your task, those are billed separately.

Premium-planen är lämpligare om du har ett stort antal uppgifter som är korta men förväntas köras kontinuerligt.The Premium plan is more suitable if you have a high number of tasks that are short but expected to run continuously. Den här planen är dyrare eftersom det behöver mer minne och CPU.This plan is more expensive because it needs more memory and CPU. Fördelen är att du kan använda funktioner som virtuell nätverks integrering.The benefit is that you can use features such as virtual network integration.

Den dedikerade planen är lämplig för bakgrunds jobb om din arbets belastning redan körs på den.The Dedicated plan is most suitable for background jobs if your workload already runs on it. Om du har underutnyttjat virtuella datorer kan du köra det på samma virtuella dator och dela beräknings kostnader.If you have underutilized VMs, you can run it on the same VM and share compute costs.

Mer information finns i de här artiklarna:For more information, see these articles:

Azure Virtual MachinesAzure Virtual Machines

Bakgrunds aktiviteter kan implementeras på ett sätt som hindrar dem från att distribueras till Azure Web Apps, eller så kanske de här alternativen inte är praktiska.Background tasks might be implemented in a way that prevents them from being deployed to Azure Web Apps, or these options might not be convenient. Vanliga exempel är Windows-tjänster och verktyg och körbara program från tredje part.Typical examples are Windows services, and third-party utilities and executable programs. Ett annat exempel kan vara program som är skrivna för en annan körningsmiljö än den som är värd för programmet.Another example might be programs written for an execution environment that is different than that hosting the application. Du kanske vill köra ett Unix- eller Linux-program från en Windows- eller .NET-program.For example, it might be a Unix or Linux program that you want to execute from a Windows or .NET application. Du kan välja mellan olika operativsystem för en virtuell Azure-dator och köra din tjänst eller körbara fil på den virtuella datorn.You can choose from a range of operating systems for an Azure virtual machine, and run your service or executable on that virtual machine.

Information om hur du väljer när du ska använda virtuella datorer finns i jämförelsen mellan Azure App Services, Cloud Services och Virtual Machines.To help you choose when to use Virtual Machines, see Azure App Services, Cloud Services and Virtual Machines comparison. Information om alternativen för Virtual Machines finns i storlekar för virtuella Windows-datorer i Azure.For information about the options for Virtual Machines, see Sizes for Windows virtual machines in Azure. Mer information om vilka operativsystem och färdiga avbildningar som är tillgängliga för Virtual Machines finns under virtuella datorer på Azure Marketplace.For more information about the operating systems and prebuilt images that are available for Virtual Machines, see Azure Virtual Machines Marketplace.

Om du vill initiera bakgrundsaktiviteten i en separat, virtuell dator har en rad alternativ:To initiate the background task in a separate virtual machine, you have a range of options:

  • Du kan köra uppgiften på begäran direkt från ditt program genom att skicka en begäran till en slutpunkt som aktiviteten exponerar.You can execute the task on demand directly from your application by sending a request to an endpoint that the task exposes. Detta skickar alla data som krävs.This passes in any data that the task requires. Slutpunkten anropar uppgiften.This endpoint invokes the task.
  • Du kan konfigurera att uppgiften ska köras enligt ett schema genom att använda en schemaläggare eller timer i operativsystemet.You can configure the task to run on a schedule by using a scheduler or timer that is available in your chosen operating system. I Windows kan du till exempel använda Schemaläggaren för att köra skript och uppgifter.For example, on Windows you can use Windows Task Scheduler to execute scripts and tasks. Om du har installerat SQL Server på den virtuella datorn kan du använda SQL Server Agent för att köra skript och uppgifter.Or, if you have SQL Server installed on the virtual machine, you can use the SQL Server Agent to execute scripts and tasks.
  • Du kan använda Azure Logic Apps för att initiera uppgiften genom att lägga till ett meddelande i en kö som aktiviteten lyssnar på, eller genom att skicka en begäran till ett API som aktiviteten visar.You can use Azure Logic Apps to initiate the task by adding a message to a queue that the task listens on, or by sending a request to an API that the task exposes.

Se det tidigare avsnittet om utlösare för mer information om hur du kan starta bakgrundsaktiviteter.See the earlier section Triggers for more information about how you can initiate background tasks.

ÖvervägandenConsiderations

Tänk på följande när du bestämmer om du vill distribuera bakgrundsaktiviteter på en virtuell Azure-dator:Consider the following points when you are deciding whether to deploy background tasks in an Azure virtual machine:

  • Att köra bakgrundsaktiviteter med en separat virtuell Azure-dator som värd ger flexibilitet och tillåter fullständig kontroll över inledande, körning, schemaläggning och resursallokering.Hosting background tasks in a separate Azure virtual machine provides flexibility and allows precise control over initiation, execution, scheduling, and resource allocation. Men körningskostnaden ökar om en virtuell dator måste distribueras bara för att köra bakgrundsaktiviteter.However, it will increase runtime cost if a virtual machine must be deployed just to run background tasks.
  • Det finns ingen möjlighet att övervaka aktiviteterna i Azure-portalen och ingen automatisk omstart vid misslyckade aktiviteter – men du kan övervaka grundläggande status för den virtuella datorn och hantera den med hjälp av Azure Resource Manager-Cmdletar.There is no facility to monitor the tasks in the Azure portal and no automated restart capability for failed tasks--although you can monitor the basic status of the virtual machine and manage it by using the Azure Resource Manager Cmdlets. Det finns dock inga resurser för att styra processer och trådar i beräkningsnoder.However, there are no facilities to control processes and threads in compute nodes. Normalt kräver användning av en virtuell dator extra arbete för att implementera en mekanism som samlar in data från instrumentation i aktiviteten och från operativsystemet på den virtuella datorn.Typically, using a virtual machine will require additional effort to implement a mechanism that collects data from instrumentation in the task, and from the operating system in the virtual machine. En lösning som kan vara lämplig är att använda System Center Management Pack för Azure.One solution that might be appropriate is to use the System Center Management Pack for Azure.
  • Du kanske ska fundera på att skapa övervakningsavsökning som är tillgänglig via HTTP-slutpunkter.You might consider creating monitoring probes that are exposed through HTTP endpoints. Koden för dessa avsökningar kan utföra hälsokontroller, samla in driftinformation och statistik – eller samla felinformation och returnera den till ett hanteringsprogram.The code for these probes could perform health checks, collect operational information and statistics--or collate error information and return it to a management application. Mer information finns i övervaknings mönstret för hälso slut punkt.For more information, see the Health Endpoint Monitoring pattern.

Mer information finns i:For more information, see:

Azure BatchAzure Batch

Azure Batch kan vara en lösning om du behöver köra arbetsbelastningar med stora, parallella databehandlingar med höga prestanda (HPC) över tiotals, hundratals eller tusentals virtuella datorer.Consider Azure Batch if you need to run large, parallel high-performance computing (HPC) workloads across tens, hundreds, or thousands of VMs.

Batch-tjänsten tillhandahåller de virtuella datorerna, tilldelar uppgifter till de virtuella datorerna, kör uppgifterna och övervakar förloppet.The Batch service provisions the VMs, assign tasks to the VMs, runs the tasks, and monitors the progress. Batch kan automatiskt skala ut de virtuella datorerna som svar på arbetsbelastningen.Batch can automatically scale out the VMs in response to the workload. Batch tillhandahåller också jobbschemaläggning.Batch also provides job scheduling. Azure Batch stöder både virtuella Linux- och Windows-datorer.Azure Batch supports both Linux and Windows VMs.

ÖvervägandenConsiderations

Batch fungerar bra med verkligt parallella arbetsbelastningar.Batch works well with intrinsically parallel workloads. Det kan också utföra parallella beräkningar med ett minskningssteg i slutet eller köra MPI-program (Message Passing Interface) för parallella åtgärder som kräver meddelandehantering mellan noder.It can also perform parallel calculations with a reduce step at the end, or run Message Passing Interface (MPI) applications for parallel tasks that require message passing between nodes.

Ett Azure Batch-jobb körs i en pool av noder (virtuella datorer).An Azure Batch job runs on a pool of nodes (VMs). En metod är att allokera en pool vid behov och sedan ta bort den när jobbet har slutförts.One approach is to allocate a pool only when needed and then delete it after the job completes. Detta maximerar användningen eftersom noderna inte är inaktiva, men jobbet måste vänta tills noderna har allokerats.This maximizes utilization, because nodes are not idle, but the job must wait for nodes to be allocated. Du kan också skapa en pool i förväg.Alternatively, you can create a pool ahead of time. Denna metod minimerar den tid det tar för ett jobb för att starta, men kan leda till att noder är inaktiva.That approach minimizes the time that it takes for a job to start, but can result in having nodes that sit idle. Läs mer i Livslängd för pooler och beräkningsnoder.For more information, see Pool and compute node lifetime.

Mer information finns i:For more information, see:

Azure Kubernetes ServiceAzure Kubernetes Service

Azure Kubernetes service (AKS) hanterar din värdbaserade Kubernetes-miljö, vilket gör det enkelt att distribuera och hantera program i behållare.Azure Kubernetes Service (AKS) manages your hosted Kubernetes environment, which makes it easy to deploy and manage containerized applications.

Containrar kan vara användbara för att köra bakgrundsjobb.Containers can be useful for running background jobs. Några av fördelarna är:Some of the benefits include:

  • Containrar stöder värdar med hög densitet.Containers support high-density hosting. Du kan isolera en bakgrundsaktivitet i en container och placera flera containrar på varje virtuell dator.You can isolate a background task in a container, while placing multiple containers in each VM.
  • Containerinitieraren hanterar intern belastningsutjämning, konfigurerar det interna nätverket och andra konfigurationsåtgärder.The container orchestrator handles internal load balancing, configuring the internal network, and other configuration tasks.
  • Containrar kan startas och stoppas efter behov.Containers can be started and stopped as needed.
  • Med Azure Container Registry kan du registrera dina behållare inom Azure-gränser.Azure Container Registry allows you to register your containers inside Azure boundaries. Det innebär säkerhets-, sekretess- och närhetsfördelar.This comes with security, privacy, and proximity benefits.

ÖvervägandenConsiderations

  • Kräver kunskap om hur du använder en containerinitierare.Requires an understanding of how to use a container orchestrator. Detta kan vara ett problem, beroende på kompetens uppsättningen för ditt DevOps-team.Depending on the skill set of your DevOps team, this may or may not be an issue.

Mer information finns i:For more information, see:

PartitioneringPartitioning

Om du bestämmer dig för att inkludera bakgrunds aktiviteter i en befintlig beräknings instans måste du överväga hur detta kommer att påverka Quality-attributen för beräknings instansen och själva bakgrunds aktiviteten.If you decide to include background tasks within an existing compute instance, you must consider how this will affect the quality attributes of the compute instance and the background task itself. Dessa faktorer hjälper dig att bestämma om du vill samordna aktiviteterna med den befintliga beräkningsinstansen eller dela upp dem på en separat beräkningsinstans:These factors will help you to decide whether to colocate the tasks with the existing compute instance or separate them out into a separate compute instance:

  • Tillgänglighet: Bakgrundsaktiviteter kanske inte behöver ha samma nivå av tillgänglighet som andra delar av programmet, i synnerhet användargränssnittet och andra delar som är direkt inblandade i användarinteraktion.Availability: Background tasks might not need to have the same level of availability as other parts of the application, in particular the UI and other parts that are directly involved in user interaction. Bakgrundsaktiviteter kan vara mer toleranta för svarstider, nya försök vid anslutningsfel och andra faktorer som påverkar tillgängligheten eftersom åtgärderna som kan köas.Background tasks might be more tolerant of latency, retried connection failures, and other factors that affect availability because the operations can be queued. Men det måste finnas tillräckligt med kapacitet för att förhindra en för lång kö av begäranden som kan blockera köer och påverka programmet i helhet.However, there must be sufficient capacity to prevent the backup of requests that could block queues and affect the application as a whole.

  • Skalbarhet: Bakgrundsaktiviteter har sannolikt andra krav på skalbarhet än användargränssnittet och interaktiva delar av programmet.Scalability: Background tasks are likely to have a different scalability requirement than the UI and the interactive parts of the application. Skalning av användar gränssnittet kan vara nödvändigt för att möta toppar i efter frågan, medan utestående bakgrunds aktiviteter kan utföras under mindre upptagna tider av färre beräknings instanser.Scaling the UI might be necessary to meet peaks in demand, while outstanding background tasks might be completed during less busy times by fewer compute instances.

  • Återhämtning: Om det blir fel i en beräkningsinstans som endast är värd för bakgrundsaktiviteter kanske det inte påverkar programmet i sin helhet om begäranden för dessa aktiviteter kan sättas i kö eller skjutas upp tills aktiviteten är tillgänglig igen.Resiliency: Failure of a compute instance that just hosts background tasks might not fatally affect the application as a whole if the requests for these tasks can be queued or postponed until the task is available again. Om beräkningsinstansen och/eller aktiviteterna kan startas om inom ett lämpligt tidsintervall behöver användare av programmet inte påverkas.If the compute instance and/or tasks can be restarted within an appropriate interval, users of the application might not be affected.

  • Säkerhet: Bakgrundsaktiviteter kan ha andra säkerhetskrav eller -begränsningar än användargränssnittet eller andra delar av programmet.Security: Background tasks might have different security requirements or restrictions than the UI or other parts of the application. Genom att använda en separat beräkningsinstans kan du ange en annan säkerhetsmiljö för aktiviteterna.By using a separate compute instance, you can specify a different security environment for the tasks. Du kan också använda mönster, till exempel Gatekeeper, för att isolera bakgrundberäkningsinstanserna från användargränssnittet för att maximera säkerhet och uppdelning.You can also use patterns such as Gatekeeper to isolate the background compute instances from the UI in order to maximize security and separation.

  • Prestanda: Du kan välja typ av beräkningsinstans för bakgrundsaktiviteterna för att specifikt matcha aktiviteternas prestandakrav.Performance: You can choose the type of compute instance for background tasks to specifically match the performance requirements of the tasks. Detta kan innebära att du använder ett billigare beräkningsalternativ om aktiviteterna inte kräver samma bearbetningsfunktioner som användargränssnittet, eller en större instans om de kräver ytterligare kapacitet och resurser.This might mean using a less expensive compute option if the tasks do not require the same processing capabilities as the UI, or a larger instance if they require additional capacity and resources.

  • Hanterbarhet: Bakgrundsaktiviteter kan ha en annan utvecklings- och distributionstakt än den huvudsakliga programkoden eller användargränssnittet.Manageability: Background tasks might have a different development and deployment rhythm from the main application code or the UI. Att distribuera dem i en separat beräkningsinstans kan förenkla uppdateringar och versionshantering.Deploying them to a separate compute instance can simplify updates and versioning.

  • Kostnad: Att lägga till beräkningsinstanser för att köra bakgrundsaktiviteter ökar värdkostnaderna.Cost: Adding compute instances to execute background tasks increases hosting costs. Du bör noggrant väga den ytterligare kapacitet mot dessa extra kostnader.You should carefully consider the trade-off between additional capacity and these extra costs.

Mer information finns i mönster för Val av ledare och för konkurrerande konsumenter.For more information, see the Leader Election pattern and the Competing Consumers pattern.

KonflikterConflicts

Om du har flera instanser av ett bakgrundsjobb, är det möjligt att de kommer att konkurrera om åtkomsten till resurser och tjänster, till exempel databaser och lagringsutrymme.If you have multiple instances of a background job, it is possible that they will compete for access to resources and services, such as databases and storage. Samtidig åtkomst kan leda till resurskonkurrens vilket kan orsaka konflikter i tillgängligheten för tjänsterna och integriteten hos data i lagring.This concurrent access can result in resource contention, which might cause conflicts in availability of the services and in the integrity of data in storage. Du kan lösa resurskonkurrensen med pessimistisk låsning.You can resolve resource contention by using a pessimistic locking approach. Detta förhindrar konkurrerande instanser av en aktivitet från att samtidigt få åtkomst till en tjänst eller skada data.This prevents competing instances of a task from concurrently accessing a service or corrupting data.

En annan metod för att lösa konflikter är att definiera bakgrundsaktiviteter som singleton, så att endast en enda instans körs.Another approach to resolve conflicts is to define background tasks as a singleton, so that there is only ever one instance running. Detta eliminerar dock tillförlitlighets- och prestandafördelarna som finns i en konfiguration med flera instanser.However, this eliminates the reliability and performance benefits that a multiple-instance configuration can provide. Detta gäller särskilt om användargränssnittet kan tillhandahålla tillräckligt med arbete för att hålla mer än en bakgrundsaktivitet upptagen.This is especially true if the UI can supply sufficient work to keep more than one background task busy.

Det är viktigt att se till att bakgrundsaktiviteten kan startas om automatiskt och att det finns tillräckligt med kapacitet för att hantera toppar i efterfrågan.It is vital to ensure that the background task can automatically restart and that it has sufficient capacity to cope with peaks in demand. Du kan åstadkomma detta genom att allokera en beräkningsinstans med tillräckliga resurser, genom att implementera en kömekanism som kan lagra begäranden för senare körning när efterfrågan minskar eller genom att använda en kombination av dessa metoder.You can achieve this by allocating a compute instance with sufficient resources, by implementing a queueing mechanism that can store requests for later execution when demand decreases, or by using a combination of these techniques.

SamordningCoordination

Bakgrunds aktiviteterna kan vara komplexa och kan kräva att flera enskilda aktiviteter körs för att skapa ett resultat eller uppfylla alla krav.The background tasks might be complex and might require multiple individual tasks to execute to produce a result or to fulfill all the requirements. Det är i dessa scenarier vanligt att dela upp aktiviteten i kortare steg eller underaktiviteter som kan utföras av flera användare.It is common in these scenarios to divide the task into smaller discreet steps or subtasks that can be executed by multiple consumers. Flerstegsjobb kan vara effektivare och mer flexibel eftersom enskilda steg kan återanvändas i flera jobb.Multistep jobs can be more efficient and more flexible because individual steps might be reusable in multiple jobs. Det är också lätt att lägga till, ta bort eller ändra ordningen på stegen.It is also easy to add, remove, or modify the order of the steps.

Samordning av flera aktiviteter och steg kan vara en utmaning, men det finns tre vanliga mönster som du kan använda som hjälp för att implementera en lösning:Coordinating multiple tasks and steps can be challenging, but there are three common patterns that you can use to guide your implementation of a solution:

  • Bryta ned en aktivitet i flera, återanvändbara steg.Decomposing a task into multiple reusable steps. Ett program kan behöva utföra olika uppgifter av varierande komplexitet på den information som bearbetas.An application might be required to perform a variety of tasks of varying complexity on the information that it processes. Ett enkelt men oflexibelt sätt att implementera det här programmet kan vara att utföra den här bearbetning som en monolitisk modul.A straightforward but inflexible approach to implementing this application might be to perform this processing as a monolithic module. Den här metoden minskar dock troligtvis möjligheterna att omstrukturera koden, optimera den eller återanvända den om delar av samma bearbetning behövs någon annanstans i programmet.However, this approach is likely to reduce the opportunities for refactoring the code, optimizing it, or reusing it if parts of the same processing are required elsewhere within the application. Mer information finns i mönster för rör och filter.For more information, see the Pipes and Filters pattern.

  • Hantera körningen av stegen för att en aktivitet.Managing execution of the steps for a task. Ett program kanske utför uppgifter som omfattar ett antal steg (varav en del kan anropa fjärrtjänster eller använda fjärranslutna resurser).An application might perform tasks that comprise a number of steps (some of which might invoke remote services or access remote resources). De enskilda stegen kan vara oberoende av varandra, men de orkestreras av den programlogik som implementerar aktiviteten.The individual steps might be independent of each other, but they are orchestrated by the application logic that implements the task. Mer information finns i mönster för Scheduler agent-ansvariga.For more information, see Scheduler Agent Supervisor pattern.

  • Hantera återställning för aktivitetssteg som misslyckas.Managing recovery for task steps that fail. Om ett eller flera av stegen misslyckas kanske ett program behöver ångra det arbete som utförts av en serie steg (som tillsammans definierar en så småningom konsekvent åtgärd).An application might need to undo the work that is performed by a series of steps (which together define an eventually consistent operation) if one or more of the steps fail. Mer information finns i mönstret kompenserande transaktion.For more information, see the Compensating Transaction pattern.

Att tänka på om återhämtningResiliency considerations

Bakgrundsaktiviteter måste vara elastiska för att tillhandahålla tillförlitliga tjänster för programmet.Background tasks must be resilient in order to provide reliable services to the application. När du planerar och utformar bakgrundsaktiviteter bör du tänka på följande:When you are planning and designing background tasks, consider the following points:

  • Bakgrunds aktiviteter måste kunna hantera omstarter korrekt utan att skada data eller införa inkonsekvens i programmet.Background tasks must be able to gracefully handle restarts without corrupting data or introducing inconsistency into the application. För långvariga aktiviteter eller aktiviteter med flera steg kanske du ska överväga att använda kontrollpunkter genom att spara status för jobben i permanent lagring eller som meddelanden i en kö om det är lämpligt.For long-running or multistep tasks, consider using check pointing by saving the state of jobs in persistent storage, or as messages in a queue if this is appropriate. Du kan till exempel bevara statusinformation i ett meddelande i en kö och stegvis uppdatera statusinformationen med aktivitetsförloppet så att aktiviteten kan bearbetas från den senaste kända godkända kontrollpunkten – i stället för att börja om från början.For example, you can persist state information in a message in a queue and incrementally update this state information with the task progress so that the task can be processed from the last known good checkpoint--instead of restarting from the beginning. När du använder Azure Service Bus-köer kan använda du meddelandesessioner för samma scenario.When using Azure Service Bus queues, you can use message sessions to enable the same scenario. Med sessioner kan du spara och hämta programmets bearbetningsstatus med hjälp av metoderna SetState och GetState.Sessions allow you to save and retrieve the application processing state by using the SetState and GetState methods. Mer information om hur du utformar tillförlitliga processer och arbets flöden i flera steg finns i mönstret för Schemaläggarens agent ansvarig.For more information about designing reliable multistep processes and workflows, see the Scheduler Agent Supervisor pattern.

  • När du använder köer för att kommunicera med bakgrundsaktiviteter kan köerna fungera som en buffert för att lagra förfrågningar som skickas till aktiviteterna när programmet är under högre belastningen än vanligt.When you use queues to communicate with background tasks, the queues can act as a buffer to store requests that are sent to the tasks while the application is under higher than usual load. På så sätt kan aktiviteterna komma ikapp användargränssnittet under perioder med mindre belastning.This allows the tasks to catch up with the UI during less busy periods. Det innebär också att omstarter inte blockerar användar gränssnittet.It also means that restarts will not block the UI. Mer information finns i mönstret för köat belastnings utjämning.For more information, see the Queue-Based Load Leveling pattern. Om vissa uppgifter är viktigare än andra kan du överväga att implementera mönstret för prioritets kön för att säkerställa att dessa aktiviteter körs före mindre viktiga.If some tasks are more important than others, consider implementing the Priority Queue pattern to ensure that these tasks run before less important ones.

  • Bakgrundsuppgifter som initieras av meddelanden eller processmeddelanden måste utformas för att hantera inkonsekvenser, som meddelanden som inkommer i fel ordning, meddelanden som upprepade gånger orsakar ett fel (skadliga meddelanden) och meddelanden som levereras mer än en gång.Background tasks that are initiated by messages or process messages must be designed to handle inconsistencies, such as messages arriving out of order, messages that repeatedly cause an error (often referred to as poison messages), and messages that are delivered more than once. Tänk också på följande:Consider the following:

    • Meddelanden som måste bearbetas i en viss ordning, som sådana som ändrar data utifrån befintligt datavärde (genom att till exempel lägga till ett värde på ett befintligt värde) kanske inte ankommer i den ursprungliga ordningen som de skickades i.Messages that must be processed in a specific order, such as those that change data based on the existing data value (for example, adding a value to an existing value), might not arrive in the original order in which they were sent. De kan också hanteras av olika instanser av en bakgrundsaktivitet i en annan ordning på grund av olika belastningar på varje instans.Alternatively, they might be handled by different instances of a background task in a different order due to varying loads on each instance. Meddelanden som måste bearbetas i en viss ordning bör innehålla ett sekvensnummer, nyckel eller någon annan indikator som bakgrundsaktiviteter kan använda för att säkerställa att de bearbetas i rätt ordning.Messages that must be processed in a specific order should include a sequence number, key, or some other indicator that background tasks can use to ensure that they are processed in the correct order. Om du använder Azure Service Bus kan du använda meddelandesessioner för att garantera leveransordningen.If you are using Azure Service Bus, you can use message sessions to guarantee the order of delivery. Det är emellertid oftast mer effektivt att, där det är möjligt, utforma processen så att meddelandeordningen inte är viktig.However, it is usually more efficient, where possible, to design the process so that the message order is not important.

    • En bakgrundsaktivitet granskar vanligtvis meddelandena i kön, som tillfälligt döljer dem från andra meddelandekonsumenter.Typically, a background task will peek at messages in the queue, which temporarily hides them from other message consumers. Sedan tar den bort meddelanden när de har behandlats.Then it deletes the messages after they have been successfully processed. Om en bakgrundsaktivitet misslyckas vid bearbetningen av ett meddelande visas meddelandet igen i kön när granskningstidsgränsen löper ut.If a background task fails when processing a message, that message will reappear on the queue after the peek time-out expires. Det behandlas av en annan instans av aktiviteten eller under nästa bearbetningscykel av den här instansen.It will be processed by another instance of the task or during the next processing cycle of this instance. Om meddelandet konsekvent orsakar ett fel hos konsumenten blockeras aktiviteten, kön, och slutligen själva programmet när kön är full.If the message consistently causes an error in the consumer, it will block the task, the queue, and eventually the application itself when the queue becomes full. Därför är det viktigt att identifiera och ta bort skadliga meddelanden från kön.Therefore, it is vital to detect and remove poison messages from the queue. Om du använder Azure Service Bus kan meddelanden som orsakar ett fel flyttas automatiskt eller manuellt till en associerad kö för obeställbara meddelanden.If you are using Azure Service Bus, messages that cause an error can be moved automatically or manually to an associated dead letter queue.

    • Köer har garanterat minst en leveransmekanismer, men de kan leverera samma meddelande flera gånger.Queues are guaranteed at least once delivery mechanisms, but they might deliver the same message more than once. Dessutom blir meddelandet tillgängligt för bearbetning igen om en bakgrundsaktivitet misslyckas efter det att meddelandet har bearbetats men innan det tas bort från kön.In addition, if a background task fails after processing a message but before deleting it from the queue, the message will become available for processing again. Bakgrunds aktiviteter ska vara idempotenta, vilket innebär att bearbetningen av samma meddelande mer än en gång inte orsakar fel eller inkonsekvens i programmets data.Background tasks should be idempotent, which means that processing the same message more than once does not cause an error or inconsistency in the application's data. Vissa åtgärder är naturligt idempotenta, till exempel att ange ett lagrat värdet till ett nytt värde.Some operations are naturally idempotent, such as setting a stored value to a specific new value. Åtgärder som att lägga till ett värde till ett befintligt lagrat värde utan att kontrollera att det lagrade värdet fortfarande är densamma som när meddelandet först skickades kommer att orsaka inkonsekvenser.However, operations such as adding a value to an existing stored value without checking that the stored value is still the same as when the message was originally sent will cause inconsistencies. Azure Service Bus-köer kan konfigureras för att automatiskt ta bort dubblettmeddelanden.Azure Service Bus queues can be configured to automatically remove duplicated messages.

    • Vissa meddelandesystem, till exempel Azure Storage-köer och Azure Service Bus-köer, har stöd för en egenskap som anger hur många gånger ett meddelande har lästs från kön.Some messaging systems, such as Azure storage queues and Azure Service Bus queues, support a de-queue count property that indicates the number of times a message has been read from the queue. Det kan vara användbart för att hantera upprepade och skadliga meddelanden.This can be useful in handling repeated and poison messages. Mer information finns i artiklarna om introduktion till asynkron meddelandehantering och idempotensmönster.For more information, see Asynchronous Messaging Primer and Idempotency Patterns.

Saker att tänka på gällande skalning och prestandaScaling and performance considerations

Bakgrundsaktiviteter måste ge tillräcklig prestanda så att de inte blockerar programmet eller orsakar inkonsekvenser på grund av fördröjningar när systemet är under belastning.Background tasks must offer sufficient performance to ensure they do not block the application, or cause inconsistencies due to delayed operation when the system is under load. Normalt förbättras prestanda genom att skalanpassa beräkningsinstanserna som är värdar för bakgrundsaktiviteter.Typically, performance is improved by scaling the compute instances that host the background tasks. När du planerar och utformar bakgrundsaktiviteter bör du tänka på följande angående skalbarhet och prestanda:When you are planning and designing background tasks, consider the following points around scalability and performance:

  • Azure stöder automatisk skalning (både skalar ut och skala tillbaka i) baserat på aktuell efter frågan och belastning eller enligt ett fördefinierat schema, för Web Apps och Virtual Machines värdbaserade distributioner.Azure supports autoscaling (both scaling out and scaling back in) based on current demand and load or on a predefined schedule, for Web Apps and Virtual Machines hosted deployments. Använd den här funktionen för att säkerställa att programmet i helhet har tillräckliga prestandafunktioner och ändå minimerar körningskostnader.Use this feature to ensure that the application as a whole has sufficient performance capabilities while minimizing runtime costs.

  • Om bakgrunds aktiviteter har en annan prestanda funktion än de andra delarna i ett program (till exempel användar gränssnittet eller komponenter som data åtkomst skiktet), är det enkelt att hantera bakgrunds aktiviteterna i en separat beräknings tjänst för att hantera belastningen med hjälp av informations-och bakgrunds aktiviteterna.Where background tasks have a different performance capability from the other parts of an application (for example, the UI or components such as the data access layer), hosting the background tasks together in a separate compute service allows the UI and background tasks to scale independently to manage the load. Om flera bakgrunds aktiviteter har avsevärt olika prestanda funktioner, bör du överväga att dela upp dem och skala varje typ oberoende.If multiple background tasks have significantly different performance capabilities from each other, consider dividing them and scaling each type independently. Observera dock att detta kan öka körnings kostnaderna.However, note that this might increase runtime costs.

  • Det kanske inte räcker att skala beräknings resurserna för att förhindra förlust av prestanda under belastning.Simply scaling the compute resources might not be sufficient to prevent loss of performance under load. Du kan också behöva skalanpassa lagringsköer och andra resurser för att förhindra att en viss punkt i kedjan blir en flaskhals.You might also need to scale storage queues and other resources to prevent a single point of the overall processing chain from becoming a bottleneck. Överväg även andra begränsningar, till exempel maximalt dataflöde för lagring och andra tjänster som programmet och bakgrundsaktiviteterna förlitar sig på.Also, consider other limitations, such as the maximum throughput of storage and other services that the application and the background tasks rely on.

  • Bakgrundsaktiviteter måste utformas för skalning.Background tasks must be designed for scaling. De måste till exempel kunna dynamiskt identifiera antalet lagringsköer som används för att lyssna på eller skicka meddelanden till lämplig kö.For example, they must be able to dynamically detect the number of storage queues in use in order to listen on or send messages to the appropriate queue.

  • Som standard skalanpassas webbjobb med den associerade Azure Web Apps-instansen.By default, WebJobs scale with their associated Azure Web Apps instance. Men om du vill att ett webbjobb ska köras som en enda instans måste du dock skapa filen Settings.job som innehåller JSON-data { "is_singleton": true }.However, if you want a WebJob to run as only a single instance, you can create a Settings.job file that contains the JSON data { "is_singleton": true }. Detta gör att Azure endast kör en enda instans av webbjobbet, även om det finns flera instanser av den associerade webbappen.This forces Azure to only run one instance of the WebJob, even if there are multiple instances of the associated web app. Det kan vara en användbar teknik för schemalagda jobb som måste köras som en enda instans.This can be a useful technique for scheduled jobs that must run as only a single instance.