Condividi tramite

Modalità di corrispondenza dei processi con i lavoratori

  • Articolo

Questo documento descrive la registrazione dei lavoratori, l'invio di posti di lavoro e il modo in cui corrispondono tra loro.

Registrazione del ruolo di lavoro

Prima che un lavoratore possa ricevere offerte per il servizio di un processo, deve essere registrato prima impostando su availableForOffers true. Successivamente, è necessario specificare le code su cui il ruolo di lavoro è in ascolto e sui canali che può gestire. Dopo la registrazione, si riceve un evento RouterWorkerRegistered da Griglia di eventi e lo stato del ruolo di lavoro viene modificato in active.

Nell'esempio seguente viene registrato un ruolo di lavoro per:

  • Ascolta e queue-1queue-2
  • Essere in grado di gestire sia i canali vocali che i canali di chat. In questo caso, il ruolo di lavoro potrebbe assumere un singolo voice processo contemporaneamente o due chat processi. Questa impostazione viene configurata specificando la capacità totale del ruolo di lavoro e assegnando un costo per processo per ogni canale.
  • Disporre di un set di etichette che descrivono gli elementi relativi al ruolo di lavoro che potrebbero aiutare a determinare se si tratta di una corrispondenza per un determinato processo.
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"))));

Invio di processi

Nell'esempio seguente viene inviato un processo che

  • Passa direttamente a queue1.
  • Per il chat canale.
  • Con un selettore di lavoro che specifica che qualsiasi ruolo di lavoro che esegue la manutenzione di questo processo deve avere un'etichetta English impostata su true.
  • Con un selettore di lavoro che specifica che qualsiasi ruolo di lavoro che esegue la manutenzione di questo processo deve avere un'etichetta maggiore di Skill 10 e questa condizione scadrà dopo un minuto.
  • Con un'etichetta impostata name su John.
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"))));

Il router processo tenta di associare questo processo a un ruolo di lavoro disponibile in queue1 ascolto per il chat canale, con English impostato su true e Skill maggiore di 10. Una volta effettuata una corrispondenza, viene creata un'offerta. I criteri di distribuzione associati alla coda controllano il numero di offerte attive che possono esistere per un processo e per quanto tempo ogni offerta è valida. Si riceve un evento OfferIssued simile al seguente:

{
    "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"
    }
}

L'evento OfferIssued include dettagli sul processo, sul ruolo di lavoro, sul periodo di validità dell'offerta e sull'elemento offerId che è necessario accettare o rifiutare il processo.

Nota

La durata massima di un processo è di 90 giorni, dopo la quale scadrà automaticamente.

Annullamento della registrazione del ruolo di lavoro

Se un ruolo di lavoro vuole interrompere la ricezione di offerte, può essere annullata la registrazione impostando AvailableForOffers su false quando si aggiorna il ruolo di lavoro e si riceve un evento RouterWorkerDeregistered da Griglia di eventi. Tutte le offerte esistenti per il ruolo di lavoro vengono revocate e si riceve un evento RouterWorkerOfferRevoked per ogni offerta.

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

Nota

Se un ruolo di lavoro è registrato e inattiva per più di 7 giorni, verrà annullata automaticamente la registrazione. Una volta annullata la registrazione, lo stato del ruolo di lavoro è draining se uno o più processi sono ancora assegnati o inactive se non vengono assegnati processi.