Eskalace úlohy
V tomto průvodci se dozvíte, jak eskalovat úlohu ve frontě pomocí zásad výjimek.
Požadavky
- Účet Azure s aktivním předplatným. Vytvoření účtu zdarma
- Nasazený prostředek komunikační služby. Vytvořte prostředek komunikační služby.
- Volitelné: Dokončení rychlého startu pro zahájení práce se směrovačem úloh
- Volitelné: Projděte si průvodce postupy klasifikace úloh.
Přehled eskalace
Eskalace může mít podobu několika různých chování, včetně přesunutí úlohy do jiné fronty nebo určení vyšší priority. Úlohy s vyšší prioritou se před úlohami s nižší prioritou distribuují do pracovních procesů. Pro účely tohoto návodu používáme zásady klasifikace a zásady výjimek a k dosažení tohoto cíle.
Konfigurace zásad klasifikace
Vytvořte zásadu klasifikace pro zpracování nového popisku přidaného do úlohy. Tato zásada vyhodnotí Escalated popisek a přiřadí úlohu do jedné fronty. Zásada také používá modul pravidel ke zvýšení priority úlohy z 1 na 10.
var classificationPolicy = await administrationClient.CreateClassificationPolicyAsync(
new CreateClassificationPolicyOptions(classificationPolicyId: "Classify_XBOX_Voice_Jobs")
{
Name = "Classify XBOX Voice Jobs",
QueueSelectorAttachments =
{
new ConditionalQueueSelectorAttachment(
condition: new ExpressionRouterRule("job.Escalated = true"),
queueSelectors: new List<RouterQueueSelector>
{
new (key: "Id", labelOperator: LabelOperator.Equal, value: new RouterValue("XBOX_Escalation_Queue"))
})
},
PrioritizationRule = new ExpressionRouterRule("If(job.Escalated = true, 10, 1)"),
});
var classificationPolicy = await client.path("/routing/classificationPolicies/{classificationPolicyId}", "Classify_XBOX_Voice_Jobs").patch({
body: {
name: "Classify XBOX Voice Jobs",
queueSelectorAttachments: [{
kind: "conditional",
condition: {
kind: "expression",
expression: 'job.Escalated = true'
},
queueSelectors: [{
key: "Id",
labelOperator: "equal",
value: "XBOX_Escalation_Queue"
}]
}],
prioritizationRule: {
kind: "expression",
expression: "If(job.Escalated = true, 10, 1)"
}
},
contentType: "application/merge-patch+json"
});
classification_policy: ClassificationPolicy = administration_client.upsert_classification_policy(
classification_policy_id = "Classify_XBOX_Voice_Jobs",
name = "Classify XBOX Voice Jobs",
queue_selector_attachments = [
ConditionalQueueSelectorAttachment(
condition = ExpressionRouterRule(expression = 'job.Escalated = true'),
queue_selectors = [
RouterQueueSelector(key = "Id", label_operator = LabelOperator.EQUAL, value = "XBOX_Escalation_Queue")
]
)
],
prioritization_rule = ExpressionRouterRule(expression = "If(job.Escalated = true, 10, 1)")))
ClassificationPolicy classificationPolicy = administrationClient.createClassificationPolicy(
new CreateClassificationPolicyOptions("Classify_XBOX_Voice_Jobs")
.setName("Classify XBOX Voice Jobs")
.setQueueSelectorAttachments(List.of(new ConditionalQueueSelectorAttachment(
new ExpressionRouterRule("job.Escalated = true"),
List.of(new RouterQueueSelector("Id", LabelOperator.EQUAL, new RouterValue("XBOX_Escalation_Queue"))))))
.setPrioritizationRule(new ExpressionRouterRule("If(job.Escalated = true, 10, 1)")));
Konfigurace zásad výjimek
Vytvořte zásadu výjimky připojenou k frontě, která se aktivuje v čase a provede akci přetřídění úlohy.
var exceptionPolicy = await administrationClient.CreateExceptionPolicyAsync(new CreateExceptionPolicyOptions(
exceptionPolicyId: "Escalate_XBOX_Policy",
exceptionRules: new List<ExceptionRule>
{
new(
id: "Escalated_Rule",
trigger: new WaitTimeExceptionTrigger(TimeSpan.FromMinutes(5)),
actions: new List<ExceptionAction>
{
new ReclassifyExceptionAction(classificationPolicyId: classificationPolicy.Value.Id)
{
LabelsToUpsert = { ["Escalated"] = new RouterValue(true) }
}
}
)
}) { Name = "Add escalated label and reclassify XBOX Job requests after 5 minutes" });
await client.path("/routing/exceptionPolicies/{exceptionPolicyId}", "Escalate_XBOX_Policy").patch({
body: {
name: "Add escalated label and reclassify XBOX Job requests after 5 minutes",
exceptionRules: [
{
id: "Escalated_Rule",
trigger: { kind: "waitTime", thresholdSeconds: 5 * 60 },
actions: [{ kind: "reclassify", classificationPolicyId: classificationPolicy.body.id, labelsToUpsert: { Escalated: true }}]
}]
},
contentType: "application/merge-patch+json"
});
administration_client.upsert_exception_policy(
exception_policy_id = "Escalate_XBOX_Policy",
name = "Add escalated label and reclassify XBOX Job requests after 5 minutes",
exception_rules = [
ExceptionRule(
id = "Escalated_Rule",
trigger = WaitTimeExceptionTrigger(threshold_seconds = 5 * 60),
actions = [ReclassifyExceptionAction(
classification_policy_id = classification_policy.id,
labels_to_upsert = { "Escalated": True }
)]
)
]
)
administrationClient.createExceptionPolicy(new CreateExceptionPolicyOptions("Escalate_XBOX_Policy",
List.of(new ExceptionAction("Escalated_Rule", new WaitTimeExceptionTrigger(5 * 60),
List.of(new ReclassifyExceptionAction()
.setClassificationPolicyId(classificationPolicy.getId())
.setLabelsToUpsert(Map.of("Escalated", new RouterValue(true))))))
).setName("Add escalated label and reclassify XBOX Job requests after 5 minutes"));
Konfigurace fronty
Vytvořte potřebné fronty pro běžné a eskalované úlohy a přiřaďte zásady výjimek k běžné frontě.
Poznámka:
Tento krok předpokládá, že jste už vytvořili distribuční zásadu s názvem Round_Robin_Policy.
var defaultQueue = await administrationClient.CreateQueueAsync(
new CreateQueueOptions(queueId: "XBOX_Queue", distributionPolicyId: "Round_Robin_Policy")
{
Name = "XBOX Queue",
ExceptionPolicyId = exceptionPolicy.Value.Id
});
var escalationQueue = await administrationClient.CreateQueueAsync(
new CreateQueueOptions(queueId: "XBOX_Escalation_Queue", distributionPolicyId: "Round_Robin_Policy")
{
Name = "XBOX Escalation Queue"
});
await administrationClient.path("/routing/queues/{queueId}", "XBOX_Queue").patch({
body: {
distributionPolicyId: "Round_Robin_Policy",
exceptionPolicyId: exceptionPolicy.body.id,
name: "XBOX Queue"
},
contentType: "application/merge-patch+json"
});
await administrationClient.path("/routing/queues/{queueId}", "XBOX_Escalation_Queue").patch({
body: {
distributionPolicyId: "Round_Robin_Policy",
name: "XBOX Escalation Queue"
},
contentType: "application/merge-patch+json"
});
administration_client.upsert_queue(
queue_id = "XBOX_Queue",
distribution_policy_id = "Round_Robin_Policy",
exception_policy_id = exception_policy.id,
name = "XBOX Queue")
administration_client.upsert_queue(
queue_id = "XBOX_Escalation_Queue",
distribution_policy_id = "Round_Robin_Policy",
name = "XBOX Escalation Queue")
administrationClient.createQueue(new CreateQueueOptions("XBOX_Queue", "Round_Robin_Policy")
.setExceptionPolicyId(exceptionPolicy.getId())
.setName("XBOX Queue"));
administrationClient.createQueue(new CreateQueueOptions("XBOX_Escalation_Queue", "Round_Robin_Policy")
.setName("XBOX Escalation Queue"));
Životní cyklus úlohy
Když úlohu odešlete, přidá se do fronty XBOX_Queue s kanálem voice . V tomto konkrétním příkladu je požadavkem najít pracovníka s názvem XBOX_Hardware, který má hodnotu větší nebo rovnou číslu 7.
await client.CreateJobAsync(new CreateJobOptions(jobId: "job1", channelId: "voice", queueId: defaultQueue.Value.Id)
{
RequestedWorkerSelectors =
{
new RouterWorkerSelector(key: "XBOX_Hardware", labelOperator: LabelOperator.GreaterThanOrEqual, value: new RouterValue(7))
}
});
var job = await client.path("/routing/jobs/{jobId}", "job1").patch({
body: {
channelId: "voice",
queueId: defaultQueue.body.id,
requestedWorkerSelectors: [{ key: "XBOX_Hardware", labelOperator: "GreaterThanOrEqual", value: 7 }]
},
contentType: "application/merge-patch+json"
});
administration_client.upsert_job(
job_id = "job1",
channel_id = "voice",
queue_id = default_queue.id,
requested_worker_selectors = [
RouterWorkerSelector(key = "XBOX_Hardware", label_operator = LabelOperator.GreaterThanOrEqual, value = 7)
])
administrationClient.createJob(new CreateJobOptions("job1", "voice", defaultQueue.getId())
.setRequestedWorkerSelectors(List.of(
new RouterWorkerSelector("XBOX_Hardware", LabelOperator.GREATER_THAN_OR_EQUAL, new RouterValue(7)))));
Po dokončení konfigurace a odeslání úlohy dojde k následujícím krokům životního cyklu:
- Úloha se odešle do směrovače úloh a vytvoří
RouterJobReceivedudálosti.RouterJobQueued - Dále se spustí 5minutový časovač a aktivuje se, pokud není přiřazen žádný odpovídající pracovní proces. Po 5 minutách vygeneruje
RouterJobExceptionTriggeredsměrovač úloh a dalšíRouterJobQueuedudálost. - V tomto okamžiku se úloha přesune na
XBOX_Escalation_Queuehodnotu a priorita je nastavena na10hodnotu .