Escalader un travail
Ce guide vous montre comment escalader un travail dans une file d’attente en utilisant une stratégie d’exception.
Prérequis
- Compte Azure avec un abonnement actif. Créez un compte gratuitement.
- Une ressource Communication Services déployée. Créez une ressource Communication Services.
- Facultatif : suivez le Guide de démarrage rapide pour commencer à utiliser le routeur de travaux
- Facultatif : passez en revue le guide pratique en matière de classification des travaux.
Vue d’ensemble de l’escalade
L’escalade peut prendre plusieurs formes, comme le déplacement d’un travail dans une file d’attente différente et/ou la spécification d’une priorité plus élevée. Les travaux avec une priorité plus élevée sont distribués aux travailleurs avant les travaux avec une priorité inférieure. Pour ce guide pratique, nous utilisons une stratégie de classification et une stratégie d’exception et pour atteindre cet objectif.
Configuration de la stratégie de classification
Créez une stratégie de classification pour gérer la nouvelle étiquette ajoutée au travail. Cette stratégie évalue l’étiquette Escalated et affecte le travail à l’une ou l’autre file d’attente. La stratégie utilise également le moteur de règles pour augmenter la priorité du travail à 10partir de 1 .
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)")));
Configuration d’une stratégie d’exception
Créez une stratégie d’exception attachée à la file d’attente, qui est déclenchée au moment du déclenchement et prend l’action du travail en cours de reclassement.
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"));
Configuration de la file d’attente
Créez les files d’attente nécessaires pour les travaux réguliers et réaffectés et attribuez la stratégie d’exception à la file d’attente normale.
Remarque
Cette étape part du principe que vous avez déjà créé une stratégie de distribution nommée 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"));
Cycle de vie de tâche
Lorsque vous envoyez le travail, il est ajouté à la file d’attente XBOX_Queue avec le voice canal. Pour cet exemple particulier, l’exigence est de rechercher un worker avec une étiquette appelée XBOX_Hardware, qui a une valeur supérieure ou égale au nombre 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)))));
Les étapes de cycle de vie suivantes se produisent une fois la configuration terminée et le travail est envoyé :
- Le travail est envoyé au routeur de travaux et produit les événements et
RouterJobQueuedlesRouterJobReceivedévénements. - Ensuite, le minuteur de 5 minutes commence et se déclenche si aucun worker correspondant n’est affecté. Après 5 minutes, Job Router émet un et un
RouterJobExceptionTriggeredautreRouterJobQueuedévénement. - À ce stade, le travail passe à la
XBOX_Escalation_Queuepriorité et la priorité est définie10sur .