Zuordnung von Aufträgen zu Workern

Artikel
11/16/2023

In diesem Dokument werden die Registrierung von Workern, die Einreichung von Aufträgen und deren Abgleich beschrieben.

Workerregistrierung

Bevor ein Arbeitnehmer Angebote für einen Job erhalten kann, muss er zuerst registriert werden, indem er auf "true" festgelegt availableForOffers ist. Als Nächstes müssen wir angeben, welche Warteschlangen der Worker überwacht und welche Kanäle verarbeitet werden können. Nach der Registrierung erhalten Sie ein RouterWorkerRegistered-Ereignis aus dem Ereignisraster, und der Status des Mitarbeiters wird in " geändert active.

Im folgenden Beispiel registrieren wir einen Worker für:

Lauschen auf queue-1 und queue-2
Fähigkeit zur Verarbeitung sowohl der Sprach- als auch der Chatkanäle. In diesem Fall kann der Worker entweder jeweils einen einzelnen voice-Auftrag oder zwei chat-Aufträge zugleich übernehmen. Diese Einstellung wird konfiguriert, indem die Gesamtkapazität des Mitarbeiters angegeben und für jeden Kanal kosten pro Auftrag zugewiesen wird.
Verfügbarkeit einer Reihe von Bezeichnungen, die Aspekte des Worker beschreiben, mit denen bestimmt werden kann, ob er sich für einen bestimmten Auftrag eignet.

var worker = await client.CreateWorkerAsync(new CreateWorkerOptions(workerId: "worker-1", capacity: 2)
{
    AvailableForOffers = true,
    Queues = { "queue1", "queue2" },
    Channels =
    {
        new RouterChannel(channelId: "voice", capacityCostPerJob: 2),
        new RouterChannel(channelId: "chat", capacityCostPerJob: 1)
    },
    Labels =
    {
        ["Skill"] = new RouterValue(11),
        ["English"] = new RouterValue(true),
        ["French"] = new RouterValue(false),
        ["Vendor"] = new RouterValue("Acme")
    }
});

let worker = await client.path("/routing/workers/{workerId}", "worker-1").patch({
    body: {
        availableForOffers: true,
        capacity: 2,
        queues: ["queue1", "queue2"],
        channels: [
            { channelId: "voice", capacityCostPerJob: 2 },
            { channelId: "chat", capacityCostPerJob: 1 }
        ],
        labels: {
            Skill: 11,
            English: true,
            French: false,
            Vendor: "Acme"
        }
    },
    contentType: "application/merge-patch+json"
});

worker = client.upsert_worker(
    worker_id = "worker-1",
    available_for_offers = True,
    capacity = 2,
    queues = ["queue1", "queue2"],
    channels = [
        RouterChannel(channel_id = "voice", capacity_cost_per_job = 2),
        RouterChannel(channel_id = "chat", capacity_cost_per_job = 1)
    ],
    labels = {
        "Skill": 11,
        "English": True,
        "French": False,
        "Vendor": "Acme"
    }
)

RouterWorker worker = client.createWorker(new CreateWorkerOptions("worker-1", 2)
    .setAvailableForOffers(true)
    .setQueues(List.of("queue1", "queue2"))
    .setChannels(List.of(
        new RouterChannel("voice", 2),
        new RouterChannel("chat", 1)))
    .setLabels(Map.of(
        "Skill", new RouterValue(11),
        "English", new RouterValue(true),
        "French", new RouterValue(false),
        "Vendor", new RouterValue("Acme"))));

Auftragseinreichung

Im folgenden Beispiel übermitteln wir einen Auftrag, der

Er gelangt direkt in queue1.
Er ist für den chat-Kanal bestimmt.
Mit einer Arbeitsauswahl, die angibt, dass alle Mitarbeiter, die diesen Auftrag warten, über eine Bezeichnung verfügen müssen, auf die Englishtruefestgelegt ist.
Mit einer Arbeitsauswahl, die angibt, dass jeder Mitarbeiter, der diesen Auftrag bedient, über eine Bezeichnung von Skill größer als 10 verfügen muss, und diese Bedingung läuft nach einer Minute ab.
Die Bezeichnung name ist auf John festgelegt.

await client.CreateJobAsync(new CreateJobOptions("job1", "chat", "queue1")
{
    RequestedWorkerSelectors =
    {
        new RouterWorkerSelector(key: "English", labelOperator: LabelOperator.Equal, value: new RouterValue(true)),
        new RouterWorkerSelector(key: "Skill", labelOperator: LabelOperator.GreaterThan, value: new RouterValue(10))
            { ExpiresAfter = TimeSpan.FromMinutes(5) }
    },
    Labels = { ["name"] = new RouterValue("John") }
});

await client.path("/routing/jobs/{jobId}", "job1").patch({
    body: {
        channelId: "chat",
        queueId: "queue1",
        requestedWorkerSelectors: [
            { key: "English", labelOperator: "equal", value: true },
            { key: "Skill", labelOperator: "greaterThan", value: 10, expiresAfterSeconds: 300 },
        ],
        labels: { name: "John" }
    },
    contentType: "application/merge-patch+json"
})

client.upsert_job(
    job_id = "job1",
    channel_id = "chat",
    queue_id = "queue1",
    requested_worker_selectors = [
        RouterWorkerSelector(
          key = "English",
          label_operator = LabelOperator.EQUAL,
          value = True
        ),
        RouterWorkerSelector(
          key = "Skill",
          label_operator = LabelOperator.GREATER_THAN,
          value = True,
          expires_after_seconds = 300
        )
    ],
    labels = { "name": "John" }
)

client.createJob(new CreateJobOptions("job1", "chat", "queue1")
    .setRequestedWorkerSelectors(List.of(
        new RouterWorkerSelector("English", LabelOperator.EQUAL, new RouterValue(true)),
        new RouterWorkerSelector("Skill", LabelOperator.GREATER_THAN, new RouterValue(10))
            .setExpiresAfter(Duration.ofMinutes(5))))
    .setLabels(Map.of("name", new RouterValue("John"))));

Auftragsrouter versucht, diesen Auftrag mit einem verfügbaren Worker abzugleichen, der auf den Kanal lauschtqueue1, wobei English er auf true und Skill größer als festgelegt 10ist.chat Sobald eine Zuordnung erfolgt ist, wird ein Angebot erstellt. Die Verteilungsrichtlinie, die an die Warteschlange angefügt ist, steuert, wie viele aktive Angebote für einen Auftrag vorhanden sein können und wie lange jedes Angebot gültig ist. Sie erhalten ein OfferIssued-Ereignis , das wie folgt aussieht:

{
    "workerId": "worker-1",
    "jobId": "7f1df17b-570b-4ae5-9cf5-fe6ff64cc712",
    "channelId": "chat",
    "queueId": "queue1",
    "offerId": "525fec06-ab81-4e60-b780-f364ed96ade1",
    "offerTimeUtc": "2021-06-23T02:43:30.3847144Z",
    "expiryTimeUtc": "2021-06-23T02:44:30.3847674Z",
    "jobPriority": 1,
    "jobLabels": {
        "name": "John"
    }
}

Das OfferIssued-Ereignis enthält Details über den Job, den Arbeitnehmer, wie lange das Angebot gültig ist, und die offerId , die Sie annehmen oder ablehnen müssen.

Hinweis

Die maximale Lebensdauer eines Auftrags beträgt 90 Tage. Danach läuft er automatisch ab.

Deregistration von Arbeitnehmern

Wenn ein Mitarbeiter das Empfangen von Angeboten beenden möchte, kann die Registrierung aufgehoben werden, indem er beim Aktualisieren des Workers auf " AvailableForOffersfalse RouterWorkerDeregistered" festgelegt ist und sie ein RouterWorkerDeregistered-Ereignis aus dem Event Grid erhalten. Alle vorhandenen Angebote für den Mitarbeiter werden widerrufen und Sie erhalten für jedes Angebot ein RouterWorkerOfferRevoked-Ereignis .

worker.AvailableForOffers = false;
worker = await client.UpdateWorkerAsync(worker);

worker = await client.path("/routing/workers/{workerId}", worker.body.id).patch({
    body: { availableForOffers: false },
    contentType: "application/merge-patch+json"
});

worker = client.upsert_worker(worker_id = worker.id, available_for_offers = False)

client.updateWorker(worker.getId(), BinaryData.fromObject(worker.setAvailableForOffers(false)), null);

Hinweis

Wenn ein Mitarbeiter länger als 7 Tage im Leerlauf registriert ist, wird er automatisch registriert. Nach der Registrierung ist draining der Status des Arbeitnehmers, wenn noch mindestens ein Auftrag zugewiesen ist oder inactive keine Aufträge zugewiesen sind.

Freigeben über

Zuordnung von Aufträgen zu Workern

Workerregistrierung

Auftragseinreichung

Deregistration von Arbeitnehmern

Zusätzliche Ressourcen