Udostępnij za pośrednictwem

Jak dostosować sposób klasyfikacji procesów roboczych dla najlepszego trybu dystrybucji procesów roboczych

  • Artykuł

Tryb best-worker dystrybucji wybiera procesy robocze, które najlepiej obsługują zadanie jako pierwsze. Logika klasyfikacji procesów roboczych można dostosować przy użyciu wyrażenia lub funkcji platformy Azure w celu porównania dwóch procesów roboczych. W poniższym przykładzie pokazano, jak dostosować tę logikę przy użyciu własnej funkcji platformy Azure.

Scenariusz: Niestandardowa reguła oceniania w najlepszym trybie dystrybucji procesów roboczych

Chcemy dystrybuować oferty wśród swoich pracowników skojarzonych z kolejką. Pracownicy otrzymają ocenę na podstawie ich etykiet i zestawu umiejętności. Proces roboczy o najwyższym wyniku powinien otrzymać pierwszą ofertę (tryb dystrybucji BestWorker).

Diagram showing Best Worker Distribution Mode problem statement

Sytuacja

  • Zadanie zostało utworzone i sklasyfikowane.
    • Zadanie ma skojarzone z nim następujące etykiety
      • ["CommunicationType"] = "Chat"
      • ["IssueType"] = "XboxSupport"
      • ["Language"] = "en"
      • ["HighPriority"] = true
      • ["SubIssueType"] = "ConsoleMalfunction"
      • ["ConsoleType"] = "XBOX_SERIES_X"
      • ["Model"] = "XBOX_SERIES_X_1TB"
    • Zadanie ma skojarzone następujące elementy WorkerSelectors
      • ["English"] >= 7
      • ["ChatSupport"] = true
      • ["XboxSupport"] = true
  • Zadanie jest obecnie w stanie "W kolejce"; w kolejce kolejki pomocy technicznej konsoli Xbox czeka na dopasowanie do procesu roboczego.
  • Wiele procesów roboczych staje się dostępnych jednocześnie.
    • Proces roboczy 1 został utworzony przy użyciu następujących etykiet
      • ["HighPrioritySupport"] = true
      • ["HardwareSupport"] = true
      • ["Support_XBOX_SERIES_X"] = true
      • ["English"] = 10
      • ["ChatSupport"] = true
      • ["XboxSupport"] = true
    • Proces roboczy 2 został utworzony z następującymi etykietami
      • ["HighPrioritySupport"] = true
      • ["HardwareSupport"] = true
      • ["Support_XBOX_SERIES_X"] = true
      • ["Support_XBOX_SERIES_S"] = true
      • ["English"] = 8
      • ["ChatSupport"] = true
      • ["XboxSupport"] = true
    • Proces roboczy 3 został utworzony przy użyciu następujących etykiet
      • ["HighPrioritySupport"] = false
      • ["HardwareSupport"] = true
      • ["Support_XBOX"] = true
      • ["English"] = 7
      • ["ChatSupport"] = true
      • ["XboxSupport"] = true

Oczekiwania

Chcemy, aby następujące zachowanie podczas oceniania pracowników wybierało, który pracownik otrzymuje pierwszą ofertę.

Decision flow diagram for scoring worker

Przepływ decyzji (jak pokazano powyżej) jest następujący:

  • Jeśli zadanie nie ma wartości HighPriority:

    • Pracownicy z etykietą: ["Support_XBOX"] = true; uzyskaj wynik 100
    • W przeciwnym razie uzyskaj wynik 1

  • Jeśli zadanie ma wartość HighPriority:

    • Pracownicy z etykietą: ["HighPrioritySupport"] = false; uzyskaj wynik 1
    • W przeciwnym razie, jeśli ["HighPrioritySupport"] = true:
      • Czy proces roboczy specjalizuje się w typie konsoli —> czy proces roboczy ma etykietę [ "Support_<jobLabels.ConsoleType>"] = true? Jeśli wartość true, proces roboczy otrzymuje wynik 200
      • W przeciwnym razie uzyskaj wynik 100

Tworzenie funkcji platformy Azure

Zanim przejdziesz dalej w procesie, najpierw zdefiniujmy funkcję platformy Azure, która ocenia proces roboczy.

Uwaga

Poniższa funkcja platformy Azure używa języka JavaScript. Aby uzyskać więcej informacji, zobacz Szybki start: tworzenie funkcji JavaScript na platformie Azure przy użyciu programu Visual Studio Code

Przykładowe dane wejściowe dla procesu roboczego 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
  }
}

Przykładowa implementacja:

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
    };
}

Dane wyjściowe dla procesu roboczego 1

200

W przypadku wyżej wymienionej implementacji dla danego zadania uzyskamy następujące wyniki dla pracowników:

Pracownik Ocena
Proces roboczy 1 200
Proces roboczy 2 200
Proces roboczy 3 1

Dystrybuowanie ofert na podstawie najlepszego trybu roboczego

Teraz, gdy aplikacja funkcji platformy Azure jest gotowa, utwórzmy wystąpienie trybu BestWorkerDistribution przy użyciu zestawu SDK routera.

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());

Dane wyjściowe

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.