Używaj kolejek zadań w Durable Task Scheduler (podgląd)

Kolejki zadań grupują pracę orkiestracji i działań w centrum zadań roboczych, a Ty możesz kontrolować tempo, z jakim harmonogram dostarcza tę pracę procesom roboczym. Używaj kolejek zadań do regulowania tempa obciążenia, na przykład workflow przetwarzania wsadowego, który wywołuje usługę podrzędną z ograniczeniem liczby żądań, bez tworzenia osobnego huba zadań.

Aby użyć kolejki zadań, najpierw stwórz zasób kolejki w swoim hubie zadań. Następnie ustaw tag DTS_TaskQueue, gdy planujesz orkiestrację lub aktywność. Tag wybiera istniejącą kolejkę; nie tworzy jej.

Note

Kolejki zadań wymagają wersji 2026-07-01-preview API zarządzania lub nowszej. Przykłady w tym artykule używają 2026-07-01-preview. Dla schematu zasobów zobacz odniesienie do kolejki zadań ARM i Bicep.

Jak działają kolejki zadań

Kolejka zadań należy do jednego centrum zadań. Opcjonalne ustawienie properties.throughput.actionsPerSecond kontroluje stałe tempo przydzielania elementów roboczych: przekazywania elementów roboczych z harmonogramu do procesów roboczych.

Elementy orkiestracji i pracy aktywności w tej samej kolejce dzielą skonfigurowany limit.
Każda tura orkiestracji dostarczona pracownikowi liczy się jako jeden przydział. Orkiestracja może wymagać kilku tur, zanim się zakończy.
Każdy element roboczy działania dostarczony pracownikowi liczy się jako jeden przydział. Ponowne dostawy także się liczą.
Aktywności i suborkiestracje dziedziczą wybór kolejki elementu nadrzędnego, chyba że wyraźnie nadpiszesz ten wybór za pomocą ich własnego tagu DTS_TaskQueue.
Elementy pracy encji nie używają kolejek zadań.

Na przykład actionsPerSecond: 20 konfiguruje stałą szybkość 20 wydań na sekundę, współdzieloną przez orkiestrację i działania aktywności w tej kolejce. Nie oznacza to 20 na sekundę: ukończonych orkiestracji, zakończeń aktywności czy podrzędnych żądań API. Krótkie skoki mogą przekroczyć utrzymane tempo, a rzeczywista przepustowość może być niższa ze względu na rozkład pracy, pojemność pracowników lub wydajność harmonogramu.

Jeśli pominiesz przepływność podczas tworzenia kolejki, kolejka nie ma specyficznego dla kolejki limitu szybkości przetwarzania. Limity pojemności planisty i procesów roboczych nadal obowiązują. Kolejki zadań nie rezerwują zasobów obliczeniowych, nie zapewniają fizycznej izolacji ani nie ustalają priorytetu między nazwanymi kolejkami. Dla ścisłych limitów żądań downstream zastosuj także ograniczanie liczby żądań tam, gdzie twoja aktywność wywołuje usługę downstream.

Prerequisites

Subskrypcja Azure z istniejącym harmonogramem i centrum zadań. Aby zobaczyć lokalizacje harmonogramu, zobacz obsługiwane regiony.
Uprawnienia do zarządzania zasobami kolejki zadań w centrum zadań, takie jak rola Współautor odziedziczona z harmonogramu lub grupy zasobów. Role na płaszczyźnie danych same w sobie nie dają uprawnień do zarządzania zasobami.
Azure CLI w przykładach az rest lub uwierzytelniony klient REST usługi Azure Resource Manager. Przykłady CLI wykorzystują składnię Bash i nie wymagają dedykowanego rozszerzenia CLI do kolejki zadań.
Aplikacja skonfigurowana do korzystania z Durable Task Scheduler, z dostępem opartym na tożsamości i SDK obsługującym tagi. Zobacz wsparcie SDK.
Procesy robocze łączące się bez filtrów elementów roboczych. Zobacz temat Konfigurowanie uprawnionych pracowników.

Konfiguruj uprawnionych pracowników

Tylko połączenia pracowników bez filtrów elementów pracy mogą otrzymywać pracę z zdefiniowanych kolejek zadań. Połączenie procesu roboczego z jakimikolwiek filtrami, w tym filtrami wieloznacznymi, nie kwalifikuje się. Upewnij się, że procesy robocze bez filtrowania rejestrują wszystkie aranżacje i działania, które kierujesz do kolejek.

Pakiet SDK .NET Durable Task automatycznie generuje filtry ze swojego rejestru zadań. Wyraźnie rezygnuj z filtrowania podczas konfiguracji pracownika dla kolejek zadań:

builder.Services.AddDurableTaskWorker()
    .AddTasks(registry =>
    {
        registry.AddAllGeneratedTasks();
    })
    .UseDurableTaskScheduler(connectionString)
    .UseWorkItemFilters(null);

W SDK Java, Python i Go nie wybieraj filtrowania elementów pracy dla tych workerów. Jeśli twoja aplikacja już konfiguruje filtry, usuń tę konfigurację. Aby uzyskać opcje filtrowania specyficzne dla SDK, zobacz Włącz filtrowanie elementów roboczych.

Important

Zadanie w określonej kolejce czeka, aż uprawniony pracownik się połączy. Nie przełącza się na filtrowanego workera. Z kolei, jeśli nazwana kolejka nie istnieje lub została usunięta, zadanie używa zwykłego routingu w centrum zadań i nie jest stosowany limit szybkości żądanej kolejki. Utwórz kolejkę i poczekaj, aż aprowizacja zakończy się pomyślnie, zanim zaplanujesz oznakowaną pracę.

Konfigurowanie Azure CLI

Zaloguj się i wybierz subskrypcję, która zawiera harmonogram:

az login
az account set --subscription SUBSCRIPTION_ID

Ustaw następujące zmienne powłoki Bash. Zamień nazwy grup zasobów, harmonogramu i hubu zadań nazwami istniejących zasobów. Przykłady tworzą kolejkę o nazwie orders.

subscriptionId=$(az account show --query id --output tsv)
resourceGroup="RESOURCE_GROUP"
schedulerName="SCHEDULER_NAME"
taskHubName="TASK_HUB_NAME"
queueName="orders"
apiVersion="2026-07-01-preview"

taskHubResourceId="/subscriptions/$subscriptionId/resourceGroups/$resourceGroup/providers/Microsoft.DurableTask/schedulers/$schedulerName/taskHubs/$taskHubName"
queueResourceId="$taskHubResourceId/taskQueues/$queueName"
queueUrl="https://management.azure.com$queueResourceId?api-version=$apiVersion"

Utwórz kolejkę zadań

Nazwa kolejki musi zawierać od 3 do 64 liter, cyfr lub łączników, zgodnych z ^[a-zA-Z0-9-]{3,64}$. Kolejka to zasób potomny huba zadań; nie ma własnych właściwości location ani właściwości zasobu platformy Azure tags.

Poniższe przykłady tworzą kolejkę orders ze stałą szybkością 20 przydziałów elementów pracy na sekundę. Ustaw actionsPerSecond na dodatnią liczbę całkowitą lub pomiń throughput, aby utworzyć kolejkę bez limitu szybkości specyficznego dla kolejki.

Użyj az rest, aby wywołać interfejs API Azure Resource Manager:

az rest --method put \
  --url "$queueUrl" \
  --body '{"properties":{"throughput":{"actionsPerSecond":20}}}'

Zamień symbole zastępcze w identyfikatorze zasobu. Wyślij żądanie za pomocą tokena dostępu Azure Resource Manager.

PUT https://management.azure.com/subscriptions/SUBSCRIPTION_ID/resourceGroups/RESOURCE_GROUP/providers/Microsoft.DurableTask/schedulers/SCHEDULER_NAME/taskHubs/TASK_HUB_NAME/taskQueues/orders?api-version=2026-07-01-preview
Authorization: Bearer ACCESS_TOKEN
Content-Type: application/json

{
  "properties": {
    "throughput": {
      "actionsPerSecond": 20
    }
  }
}

Zapisz następujący szablon jako task-queue.bicep. Odwołuje się do istniejącego harmonogramu i centrum zadań, tworząc jedynie kolejkę zadań.

Note

Niektóre wersje Bicep mogą raportować BCP081, ponieważ definicje typów dla zasobu kolejki zadań w wersji zapoznawczej nie są dostępne. To ostrzeżenie nie uniemożliwia kompilacji ani wdrożenia. Użyj odniesienia do zasobów , aby sprawdzić właściwości.

param schedulerName string
param taskHubName string

@minLength(3)
@maxLength(64)
param queueName string = 'orders'

@minValue(1)
param actionsPerSecond int = 20

resource scheduler 'Microsoft.DurableTask/schedulers@2026-02-01' existing = {
  name: schedulerName
}

resource taskHub 'Microsoft.DurableTask/schedulers/taskHubs@2026-02-01' existing = {
  parent: scheduler
  name: taskHubName
}

resource taskQueue 'Microsoft.DurableTask/schedulers/taskHubs/taskQueues@2026-07-01-preview' = {
  parent: taskHub
  name: queueName
  properties: {
    throughput: {
      actionsPerSecond: actionsPerSecond
    }
  }
}

Wdróż do grupy zasobów zawierającej harmonogram:

az deployment group create \
  --resource-group "$resourceGroup" \
  --template-file task-queue.bicep \
  --parameters schedulerName="$schedulerName" taskHubName="$taskHubName" \
    queueName="$queueName" actionsPerSecond=20

Poczekaj na zakończenie aprowizacji

Operacje zarządzania zasobami są asynchroniczne. Po utworzeniu lub aktualizacji kolejki pobierz ją i sprawdź properties.provisioningState:

az rest --method get --url "$queueUrl" \
  --query properties.provisioningState --output tsv

Powtarzaj zapytanie, aż stan będzie Succeeded, przed wysłaniem oznaczonego zadania. Zatrzymaj się, jeśli stan to Failed, wystąpi błąd lub wygaśnie limit czasu odpytywania. Rozwiąż błąd zarządzania zasobami przed użyciem tej kolejki. Samo zaakceptowane żądanie zarządzania nie oznacza, że kolejka jest gotowa. W przypadku przedziałów pollingu i śledzenia operacji zobacz Śledzenie asynchronicznych operacji platformy Azure.

Obsługa zestawu SDK

Wybór kolejki wykorzystuje tagi orkiestracji i aktywności, a nie tagi zasobów platformy Azure. Poniższa tabela pokazuje, gdzie można jawnie ustawić DTS_TaskQueue.

SDK lub rozszerzenie	Rozpocznij orkiestrację	Zaplanuj aktywność	Zaplanuj podorkiestrację
Trwały zestaw SDK platformy .NET	Yes	Yes	Yes
Durable Task JavaScript/TypeScript SDK	Yes	Yes	Yes
Durable Task Python SDK	Yes	Yes	No
Durable Task Java SDK (v1.6.0+)	Yes	No	No
Durable Task Go SDK (beta)	Yes	Yes	Yes
Durable Functions: .NET w modelu izolowanym	Yes	Yes	Yes
Durable Functions: Java	Yes	No	No

Powiązania Durable Functions .NET in-process, JavaScript i Python nie udostępniają tych jawnych opcji tagów. Nie zakładaj, że samodzielne wsparcie dla Durable Task SDK w języku dotyczy także jego powiązania Durable Functions. W każdym przypadku połączenie workera musi również spełniać wymóg dotyczący niefiltrowanego workera.

Przekieruj orkiestrację do kolejki

Ustaw literał klucza tagu DTS_TaskQueue na nazwę kolejki w tym samym hubie zadań. Poniższe fragmenty zakładają, że już skonfigurowałeś klienta i zarejestrowałeś orkiestrację. Użyj kolejki orders utworzonej wcześniej.

var options = new StartOrchestrationOptions
{
    Tags = new Dictionary<string, string>
    {
        { "DTS_TaskQueue", "orders" },
    },
};

string instanceId = await client.ScheduleNewOrchestrationInstanceAsync(
    "ProcessOrderOrchestration", input: order, options: options);

const instanceId = await client.scheduleNewOrchestration(
    "ProcessOrderOrchestration",
    order,
    {
        tags: {
            DTS_TaskQueue: "orders",
        },
    }
);

instance_id = client.schedule_new_orchestration(
    "process_order_orchestration",
    input=order,
    tags={"DTS_TaskQueue": "orders"},
)

NewOrchestrationInstanceOptions options = new NewOrchestrationInstanceOptions()
    .setTags(Map.of("DTS_TaskQueue", "orders"));

String instanceId = client.scheduleNewOrchestrationInstance(
    "ProcessOrderOrchestration", order, options);

Użyj api z github.com/microsoft/durabletask-go/api. Ten fragment działa w funkcji, która zwraca błąd.

instanceID, err := client.ScheduleNewOrchestration(
	ctx,
	"ProcessOrderOrchestration",
	api.WithTags(map[string]string{"DTS_TaskQueue": "orders"}),
)
if err != nil {
	return err
}

Użyj instanceID do śledzenia orkiestracji. Informacje o konfiguracji klienta i workera znajdziesz w przewodniku po SDK Go.

Działania i podorkiestracje orkiestracji dziedziczą wybór kolejki. Nie musisz powtarzać tagu przy każdym wywołaniu. Ustaw tag kolejki podczas planowania pracy; aktualizacja tempa kolejki nie wymaga zmiany tagu.

Zastąp kolejkę dla aktywności lub podaranżacji

Aby samodzielnie sterować tempem przetwarzania podzbioru przepływu pracy, utwórz kolejną kolejkę, taką jak partner-api, i jawnie ustaw DTS_TaskQueue w wywołaniu aktywności lub podorkiestracji. Poczekaj, aż aprowizacja tej kolejki zakończy się powodzeniem.

Na przykład możesz pozostawić koordynację orkiestracji w orders i kierować wywołania do usługi podrzędnej przez partner-api. Nadpisanie ustawień aktywności wybiera kolejkę danej aktywności; nie przesuwa orkiestracji nadrzędnej.

var activityOptions = new TaskOptions(tags: new Dictionary<string, string>
{
    { "DTS_TaskQueue", "partner-api" },
});

await context.CallActivityAsync(
    "CallPartnerApi", input: order, options: activityOptions);

var childOptions = new SubOrchestrationOptions
{
    Tags = new Dictionary<string, string>
    {
        { "DTS_TaskQueue", "partner-api" },
    },
};

await context.CallSubOrchestratorAsync(
    "ValidateOrderOrchestration", input: order, options: childOptions);

const result = yield ctx.callActivity(callPartnerApi, order, {
    tags: { DTS_TaskQueue: "partner-api" },
});

const childResult = yield ctx.callSubOrchestrator(validateOrderOrchestration, order, {
    tags: { DTS_TaskQueue: "partner-api" },
});

result = yield ctx.call_activity(
    "call_partner_api",
    input=order,
    tags={"DTS_TaskQueue": "partner-api"},
)

Python SDK nie obsługuje jawnych tagów podrzędnej orkiestracji. Suborkiestracja dziedziczy wybór kolejki po elemencie nadrzędnym.

Przeglądaj i aktualizuj kolejki

Poniższe przykłady zarządzania wykorzystują zmienne Bash z Set up Azure CLI.

Pobierz konfigurację kolejki:

az rest --method get --url "$queueUrl"

Wymień kolejki w hubie zadań:

az rest --method get \
  --url "https://management.azure.com$taskHubResourceId/taskQueues?api-version=$apiVersion"

Zaktualizuj szybkość kolejki do 10 przydziałów na sekundę:

az rest --method patch \
  --url "$queueUrl" \
  --body '{"properties":{"throughput":{"actionsPerSecond":10}}}'

Aby usunąć limit szybkości specyficzny dla kolejki, jednocześnie zachowując kolejkę, należy jawnie ustawić throughput na null:

az rest --method patch \
  --url "$queueUrl" \
  --body '{"properties":{"throughput":null}}'

Pominięcie limitu przepływności w żądaniu PATCH pozostawia istniejącą szybkość bez zmian. Żądanie PUT zastępuje konfigurację; pominięcie throughput z PUT usuwa limit szybkości specyficzny dla kolejki. Po aktualizacji poczekaj, aż prowizjonowanie zakończy się powodzeniem i zweryfikuj zwróconą konfigurację.

Usuń kolejkę zadań

Warning

Usunięcie kolejki usuwa jej limit szybkości żądań. Element pracy oznaczony usuniętą nazwą kolejki korzysta zamiast tego ze zwykłego routingu huba zadań. Nie używaj usuwania kolejki do wstrzymania obciążenia.

Usuń zasób kolejki:

az rest --method delete --url "$queueUrl"

Usuwanie jest asynchroniczne. Śledź asynchroniczną operację Azure Resource Manager aż do zakończenia lub zapytuj GET z limitem czasu, aż kolejka zwróci 404 Not Found. Nie traktuj błędów autoryzacji ani innych nieudanych żądań jako potwierdzenia usunięcia. Usunięcie kolejki nie kończy aranżacji, które z niej korzystały.

Rozwiązywanie problemów z kierowaniem kolejką

Jeśli praca w kolejce nie postępuje, weryfikuj, że kolejka istnieje i wdrożenie się powiodło, tag identyfikuje zamierzoną kolejkę w tym samym hubie zadań, a zdrowy pracownik łączy się bez filtrów. Zdefiniowana kolejka bez uprawnionych pracowników zachowuje swoją pracę, zamiast dostarczać ją pracownikowi wykluczonemu przez filtrowanie.

Jeśli zadanie działa bez oczekiwanego limitu szybkości żądań, sprawdź, czy kolejka nie została usunięta lub czy jej nie brakuje. W takim przypadku harmonogram korzysta ze zwykłego trasowania Task Hub. Uwzględnij też krótkie skoki i różnicę między materiałami informacyjnymi a ukończonymi procesami. Użyj panelu kontrolnego harmonogramu, aby sprawdzić status orkiestracji i tagi.

Opinia

Czy ta strona była pomocna?

Ostatnia aktualizacja o 2026-11-07