Como personalizar como os trabalhadores são classificados para o melhor modo de distribuição de trabalhadores

  • Artigo

O best-worker modo de distribuição seleciona os trabalhadores mais capazes de lidar com o trabalho primeiro. A lógica para classificar Trabalhadores pode ser personalizada, com uma expressão ou função do Azure para comparar dois trabalhadores. O exemplo a seguir mostra como personalizar essa lógica com sua própria Função do Azure.

Cenário: Regra de pontuação personalizada no melhor modo de distribuição de trabalho

Queremos distribuir ofertas entre os seus trabalhadores associadas a uma fila. Os trabalhadores receberão uma pontuação com base em seus rótulos e conjunto de habilidades. O trabalhador com a pontuação mais alta deve receber a primeira oferta (Modo de Distribuição BestWorker).

Diagram showing Best Worker Distribution Mode problem statement

Situação

  • Foi criado e classificado um emprego.
    • Job tem os seguintes rótulos associados a ele:
      • ["CommunicationType"] = "Bate-papo"
      • ["IssueType"] = "XboxSupport"
      • ["Língua"] = "en"
      • ["HighPriority"] = verdadeiro
      • ["SubIssueType"] = "ConsoleMalfunction"
      • ["ConsoleType"] = "XBOX_SERIES_X"
      • ["Modelo"] = "XBOX_SERIES_X_1TB"
    • Job tem os seguintes WorkerSelectors associados a ele
      • ["Inglês"] >= 7
      • ["ChatSupport"] = verdadeiro
      • ["XboxSupport"] = verdadeiro
  • O trabalho atualmente está em um estado de 'Fila', enfileirado na Fila de Suporte de Hardware do Xbox aguardando para ser correspondido a um trabalhador.
  • Vários trabalhadores ficam disponíveis simultaneamente.
    • O Trabalhador 1 foi criado com os seguintes rótulos
      • ["HighPrioritySupport"] = verdadeiro
      • ["HardwareSupport"] = verdadeiro
      • ["Support_XBOX_SERIES_X"] = verdadeiro
      • ["Inglês"] = 10
      • ["ChatSupport"] = verdadeiro
      • ["XboxSupport"] = verdadeiro
    • O Worker 2 foi criado com os seguintes rótulos
      • ["HighPrioritySupport"] = verdadeiro
      • ["HardwareSupport"] = verdadeiro
      • ["Support_XBOX_SERIES_X"] = verdadeiro
      • ["Support_XBOX_SERIES_S"] = verdadeiro
      • ["Inglês"] = 8
      • ["ChatSupport"] = verdadeiro
      • ["XboxSupport"] = verdadeiro
    • O Worker 3 foi criado com os seguintes rótulos
      • ["HighPrioritySupport"] = falso
      • ["HardwareSupport"] = verdadeiro
      • ["Support_XBOX"] = verdadeiro
      • ["Inglês"] = 7
      • ["ChatSupport"] = verdadeiro
      • ["XboxSupport"] = verdadeiro

Expetativa

Gostaríamos que o seguinte comportamento ao pontuar os trabalhadores selecionasse qual trabalhador recebe a primeira oferta.

Decision flow diagram for scoring worker

O fluxo de decisão (como mostrado acima) é o seguinte:

  • Se um trabalho NÃO for HighPriority:

    • Trabalhadores com rótulo: ["Support_XBOX"] = verdadeiro; obter uma pontuação de 100
    • Caso contrário, obtenha uma pontuação de 1

  • Se um trabalho for HighPriority:

    • Trabalhadores com rótulo: ["HighPrioritySupport"] = false; obtenha uma pontuação de 1
    • Caso contrário, se ["HighPrioritySupport"] = true:
      • O Worker é especializado em tipo de console -> O trabalhador tem rótulo: ["Support_<jobLabels.ConsoleType>"] = true? Se verdadeiro, trabalhador obtém pontuação de 200
      • Caso contrário, obtenha uma pontuação de 100

Criando uma função do Azure

Antes de avançar no processo, vamos primeiro definir uma função do Azure que pontua trabalhador.

Nota

A seguinte função do Azure está usando JavaScript. Para obter mais informações, consulte Guia de início rápido: criar uma função JavaScript no Azure usando o Visual Studio Code

Entrada de amostra para o Trabalhador 1

{
  "job": {
    "CommunicationType": "Chat",
    "IssueType": "XboxSupport",
    "Language": "en",
    "HighPriority": true,
    "SubIssueType": "ConsoleMalfunction",
    "ConsoleType": "XBOX_SERIES_X",
    "Model": "XBOX_SERIES_X_1TB"
  },
  "selectors": [
    {
      "key": "English",
      "operator": "GreaterThanEqual",
      "value": 7,
      "expiresAfterSeconds": null
    },
    {
      "key": "ChatSupport",
      "operator": "Equal",
      "value": true,
      "expiresAfterSeconds": null
    },
    {
      "key": "XboxSupport",
      "operator": "Equal",
      "value": true,
      "expiresAfterSeconds": null
    }
  ],
  "worker": {
    "Id": "e3a3f2f9-3582-4bfe-9c5a-aa57831a0f88",
    "HighPrioritySupport": true,
    "HardwareSupport": true,
    "Support_XBOX_SERIES_X": true,
    "English": 10,
    "ChatSupport": true,
    "XboxSupport": true
  }
}

Exemplo de implementação:

module.exports = async function (context, req) {
    context.log('Best Worker Distribution Mode using Azure Function');

    let score = 0;
    const jobLabels = req.body.job;
    const workerLabels = req.body.worker;

    const isHighPriority = !!jobLabels["HighPriority"];
    context.log('Job is high priority? Status: ' + isHighPriority);

    if(!isHighPriority) {
        const isGenericXboxSupportWorker = !!workerLabels["Support_XBOX"];
        context.log('Worker provides general xbox support? Status: ' + isGenericXboxSupportWorker);

        score = isGenericXboxSupportWorker ? 100 : 1;

    } else {
        const workerSupportsHighPriorityJob = !!workerLabels["HighPrioritySupport"];
        context.log('Worker provides high priority support? Status: ' + workerSupportsHighPriorityJob);

        if(!workerSupportsHighPriorityJob) {
            score = 1;
        } else {
            const key = `Support_${jobLabels["ConsoleType"]}`;
            
            const workerSpecializeInConsoleType = !!workerLabels[key];
            context.log(`Worker specializes in consoleType: ${jobLabels["ConsoleType"]} ? Status: ${workerSpecializeInConsoleType}`);

            score = workerSpecializeInConsoleType ? 200 : 100;
        }
    }
    context.log('Final score of worker: ' + score);

    context.res = {
        // status: 200, /* Defaults to 200 */
        body: score
    };
}

Saída para o trabalhador 1

200

Com a implementação acima mencionada, para o trabalho dado, obteremos as seguintes pontuações para os trabalhadores:

Trabalhador Pontuação
Trabalhador 1 200
Trabalhador 2 200
Trabalhador 3 1

Distribuir ofertas com base no melhor modo de trabalho

Agora que o aplicativo de função do Azure está pronto, vamos criar uma instância do modo BestWorkerDistribution usando o SDK do Roteador.

var administrationClient = new JobRouterAdministrationClient("<YOUR_ACS_CONNECTION_STRING>");

// Setup Distribution Policy
var distributionPolicy = await administrationClient.CreateDistributionPolicyAsync(
    new CreateDistributionPolicyOptions(
        distributionPolicyId: "BestWorkerDistributionMode",
        offerExpiresAfter: TimeSpan.FromMinutes(5),
        mode: new BestWorkerMode(scoringRule: new FunctionRouterRule(new Uri("<insert function url>")))
    ) { Name = "XBox hardware support distribution" });

// Setup Queue
var queue = await administrationClient.CreateQueueAsync(
    new CreateQueueOptions(
        queueId: "XBox_Hardware_Support_Q",
        distributionPolicyId: distributionPolicy.Value.Id
    ) { Name = "XBox Hardware Support Queue" });

// Create workers
var worker1 = await client.CreateWorkerAsync(new CreateWorkerOptions(workerId: "Worker_1", capacity: 100)
    {
        Queues = { queue.Value.Id },
        Channels = { new RouterChannel(channelId: "Xbox_Chat_Channel", capacityCostPerJob: 10) },
        Labels =
        {
            ["English"] = new RouterValue(10),
            ["HighPrioritySupport"] = new RouterValue(true),
            ["HardwareSupport"] = new RouterValue(true),
            ["Support_XBOX_SERIES_X"] = new RouterValue(true),
            ["ChatSupport"] = new RouterValue(true),
            ["XboxSupport"] = new RouterValue(true)
        }
    });

var worker2 = await client.CreateWorkerAsync(new CreateWorkerOptions(workerId: "Worker_2", capacity: 100)
    {
        Queues = { queue.Value.Id },
        Channels = { new RouterChannel(channelId: "Xbox_Chat_Channel", capacityCostPerJob: 10) },
        Labels =
        {
            ["English"] = new RouterValue(8),
            ["HighPrioritySupport"] = new RouterValue(true),
            ["HardwareSupport"] = new RouterValue(true),
            ["Support_XBOX_SERIES_X"] = new RouterValue(true),
            ["ChatSupport"] = new RouterValue(true),
            ["XboxSupport"] = new RouterValue(true)
        }
    });

var worker3 = await client.CreateWorkerAsync(new CreateWorkerOptions(workerId: "Worker_3", capacity: 100)
    {
        Queues = { queue.Value.Id },
        Channels = { new RouterChannel(channelId: "Xbox_Chat_Channel", capacityCostPerJob: 10) },
        Labels =
        {
            ["English"] = new RouterValue(7),
            ["HighPrioritySupport"] = new RouterValue(true),
            ["HardwareSupport"] = new RouterValue(true),
            ["Support_XBOX_SERIES_X"] = new RouterValue(true),
            ["ChatSupport"] = new RouterValue(true),
            ["XboxSupport"] = new RouterValue(true)
        }
    });

// Create Job
var job = await client.CreateJobAsync(
    new CreateJobOptions(jobId: "job1", channelId: "Xbox_Chat_Channel", queueId: queue.Value.Id)
    {
        Priority = 100,
        ChannelReference = "ChatChannel",
        RequestedWorkerSelectors =
        {
            new RouterWorkerSelector(key: "English", labelOperator: LabelOperator.GreaterThanEqual, value: new RouterValue(7)),
            new RouterWorkerSelector(key: "ChatSupport", labelOperator: LabelOperator.Equal, value: new RouterValue(true)),
            new RouterWorkerSelector(key: "XboxSupport", labelOperator: LabelOperator.Equal, value: new RouterValue(true))
        },
        Labels =
        {
            ["CommunicationType"] = new RouterValue("Chat"),
            ["IssueType"] = new RouterValue("XboxSupport"),
            ["Language"] = new RouterValue("en"),
            ["HighPriority"] = new RouterValue(true),
            ["SubIssueType"] = new RouterValue("ConsoleMalfunction"),
            ["ConsoleType"] = new RouterValue("XBOX_SERIES_X"),
            ["Model"] = new RouterValue("XBOX_SERIES_X_1TB")
        }
    });

// Wait a few seconds and see which worker was matched
await Task.Delay(TimeSpan.FromSeconds(5));
var getJob = await client.GetJobAsync(job.Value.Id);
Console.WriteLine(getJob.Value.Assignments.Select(assignment => assignment.Value.WorkerId).First());

Saída

Worker_1 // or Worker_2

Since both workers, Worker_1 and Worker_2, get the same score of 200,
the worker who has been idle the longest will get the first offer.