Szybki start: przesyłanie zadania do kolejkowania i routingu

Wymagania wstępne

• Konto platformy Azure z aktywną subskrypcją. Utwórz konto bezpłatnie.
• Aktywny zasób usług komunikacyjnych i parametry połączenia. Utwórz zasób usług komunikacyjnych.
• Najnowsza wersja biblioteki klienta .NET dla systemu operacyjnego.

Przykładowy kod

Możesz przejrzeć i pobrać przykładowy kod do tego przewodnika Szybki start w serwisie GitHub.

Konfigurowanie

Tworzenie nowej aplikacji w języku C#

W oknie konsoli (takim jak cmd, PowerShell lub Bash) użyj dotnet new polecenia , aby utworzyć nową aplikację konsolową o nazwie JobRouterQuickstart. To polecenie tworzy prosty projekt języka C# "Hello world" z jednym plikiem źródłowym: Program.cs.

dotnet new console -o JobRouterQuickstart

Zmień katalog na nowo utworzony folder aplikacji i użyj dotnet build polecenia , aby skompilować aplikację.

cd JobRouterQuickstart
dotnet build

Instalowanie pakietu

Zainstaluj bibliotekę klienta Azure Communication Job Router dla platformy .NET za pomocą narzędzia NuGet:

dotnet add package Azure.Communication.JobRouter

Musisz użyć biblioteki klienckiej usługi Azure Communication Job Router dla platformy .NET w wersji 1.0.0 lub nowszej.

Dodaj następujące dyrektywy using na górze pliku Program.cs, aby dołączyć przestrzenie nazw JobRouter.

using Azure.Communication.JobRouter;

Zainicjuj klienta Job Router i klienta administracyjnego

Klientów usługi Job Router można uwierzytelniać za pomocą parametrów połączenia uzyskanych z zasobu Azure Communication Services w portalu Azure. Generujemy zarówno klienta, jak i klienta administracyjnego do komunikacji z usługą Job Router. Klient administracyjny służy do aprowizowania kolejek i zasad, podczas gdy klient jest używany do przesyłania zadań i rejestrowania procesów roboczych. Aby uzyskać więcej informacji o parametrach połączenia, zobacz access-your-connection-strings-and-service-endpoints.

// Get a connection string to our Azure Communication Services resource.
var routerAdminClient = new JobRouterAdministrationClient("your_connection_string");
var routerClient = new JobRouterClient("your_connection_string");

Tworzenie zasad dystrybucji

Router zadań używa polityki dystrybucji, aby określić, w jaki sposób Pracownicy będą powiadamiani o dostępnych zadaniach oraz jaki będzie czas ważności tych powiadomień, zwanych Ofertami. Utwórz zasadę, podając ID, nazwę, wartość offerExpiresAfter oraz tryb dystrybucji.

var distributionPolicy = await routerAdminClient.CreateDistributionPolicyAsync(
    new CreateDistributionPolicyOptions(
        distributionPolicyId: "distribution-policy-1",
        offerExpiresAfter: TimeSpan.FromMinutes(1),
        mode: new LongestIdleMode())
    {
        Name = "My distribution policy"
    }
);

Utwórz kolejkę

Utwórz kolejkę, określając identyfikator, nazwę i podaj identyfikator obiektu zasad dystrybucji utworzony powyżej.

var queue = await routerAdminClient.CreateQueueAsync(
    new CreateQueueOptions(queueId: "queue-1", distributionPolicyId: distributionPolicy.Value.Id)
    {
        Name = "My Queue" 
    });

Przesyłanie zadania

Teraz możemy wysłać zadanie bezpośrednio do tej kolejki, z selektorem workera, który wymaga, aby worker miał etykietę Some-Skill o wartości większej niż 10.

var job = await routerClient.CreateJobAsync(
    new CreateJobOptions(jobId: "job-1", channelId: "voice", queueId: queue.Value.Id)
    {
        Priority = 1,
        RequestedWorkerSelectors =
        {
            new RouterWorkerSelector(key: "Some-Skill", labelOperator: LabelOperator.GreaterThan, value: new RouterValue(10))
        }
    });

Tworzenie procesu roboczego

Teraz tworzymy proces roboczy do odbierania zadań z tej kolejki, z etykietą Some-Skill równą 11 i pojemnością ustawioną w my-channel.

var worker = await routerClient.CreateWorkerAsync(
    new CreateWorkerOptions(workerId: "worker-1", capacity: 1)
    {
        Queues = { queue.Value.Id },
        Labels = { ["Some-Skill"] = new RouterValue(11) },
        Channels = { new RouterChannel(channelId: "voice", capacityCostPerJob: 1) },
        AvailableForOffers = true
    });

Otrzymywanie oferty

Powinniśmy uzyskać routerWorkerOfferIssued z naszej subskrypcji usługi Event Grid. Możemy jednak również poczekać kilka sekund, a następnie sprawdzić bezpośrednio za pomocą interfejsu API JobRouter, czy temu workerowi została złożona oferta.

await Task.Delay(TimeSpan.FromSeconds(10));
worker = await routerClient.GetWorkerAsync(worker.Value.Id);
foreach (var offer in worker.Value.Offers)
{
    Console.WriteLine($"Worker {worker.Value.Id} has an active offer for job {offer.JobId}");
}

Zaakceptuj ofertę zadania

Następnie pracownik może zaakceptować ofertę zadania za pomocą zestawu SDK, co spowoduje przypisanie zadania do tego pracownika.

var accept = await routerClient.AcceptJobOfferAsync(workerId: worker.Value.Id, offerId: worker.Value.Offers.FirstOrDefault().OfferId);
Console.WriteLine($"Worker {worker.Value.Id} is assigned job {accept.Value.JobId}");

Ukończenie zadania

Gdy pracownik zakończy pracę związaną z zadaniem (na przykład zakończy połączenie), zamykamy zadanie.

await routerClient.CompleteJobAsync(new CompleteJobOptions(jobId: accept.Value.JobId, assignmentId: accept.Value.AssignmentId));
Console.WriteLine($"Worker {worker.Value.Id} has completed job {accept.Value.JobId}");

Zamykanie zadania

Gdy proces roboczy będzie gotowy do podjęcia nowych zadań, pracownik powinien zamknąć zadanie. Opcjonalnie moduł wykonawczy może podać kod wyniku, aby określić wynik zadania.

await routerClient.CloseJobAsync(new CloseJobOptions(jobId: accept.Value.JobId, assignmentId: accept.Value.AssignmentId) {
    DispositionCode = "Resolved"
});
Console.WriteLine($"Worker {worker.Value.Id} has closed job {accept.Value.JobId}");

Usuń zadanie

Po zamknięciu zadania możemy usunąć zadanie, aby umożliwić ponowne utworzenie zadania przy użyciu tego samego identyfikatora, jeśli uruchomimy ponownie ten przykład

await routerClient.DeleteJobAsync(accept.Value.JobId);
Console.WriteLine($"Deleting job {accept.Value.JobId}");

Uruchamianie kodu

Uruchom aplikację przy użyciu polecenia dotnet run i obserwuj wyniki.

dotnet run

Azure Communication Services - Job Router Quickstart
Worker worker-1 has an active offer for job job-1
Worker worker-1 is assigned job job-1
Worker worker-1 has completed job job-1
Worker worker-1 has closed job job-1
Deleting job job-1

Dokumentacja referencyjna

Dowiedz się więcej o pełnym zakresie możliwości usługi Job Router w Azure Communication Services w dokumentacji referencyjnej zestawu SDK platformy .NET lub dokumentacji referencyjnej interfejsu API REST.

Wymagania wstępne

• Konto platformy Azure z aktywną subskrypcją. Utwórz konto bezpłatnie.
• Aktywny zasób usług komunikacyjnych i parametry połączenia. Utwórz zasób usług komunikacyjnych.
• Najnowsze wersje programu Node.js Active LTS i Maintenance LTS.

Przykładowy kod

Możesz przejrzeć i pobrać przykładowy kod do tego przewodnika Szybki start w serwisie GitHub.

Konfigurowanie

Tworzenie nowej aplikacji internetowej

W oknie terminalu lub konsoli utwórz nowy folder dla aplikacji i przejdź do niego.

mkdir acs-router-quickstart && cd acs-router-quickstart

Uruchom polecenie npm init , aby utworzyć plik package.json z ustawieniami domyślnymi.

npm init -y

Utwórz nowy plik index.js, do którego dodasz kod z tego przewodnika Szybki start.

Instalowanie pakietów

Należy użyć biblioteki klienta routera zadań komunikacji platformy Azure dla języka JavaScript w wersji 1.0.0 lub nowszej.

Użyj polecenia , npm install aby zainstalować poniższe zestawy SDK usług Communication Services dla języka JavaScript.

npm install @azure-rest/communication-job-router --save

Konfigurowanie struktury aplikacji

index.js W pliku dodaj następujący kod. Dodamy kod z przewodnika Szybki start do funkcji main.

const JobRouterClient = require('@azure-rest/communication-job-router').default;

const main = async () => {
  console.log("Azure Communication Services - Job Router Quickstart")

  // Quickstart code goes here

};

main().catch((error) => {
  console.log("Encountered an error");
  console.log(error);
})

Zainicjuj klienta Job Router

Klientów usługi Job Router można uwierzytelniać za pomocą parametrów połączenia uzyskanych z zasobu Azure Communication Services w portalu Azure. Generujemy klienta do komunikacji z usługą Job Router. Aby uzyskać więcej informacji o parametrach połączenia, zobacz access-your-connection-strings-and-service-endpoints.

Dodaj następujący kod w elemencie index.js wewnątrz funkcji main.

const connectionString = process.env["COMMUNICATION_CONNECTION_STRING"] ||
    "endpoint=https://<resource-name>.communication.azure.com/;<access-key>";
const client = JobRouterClient(connectionString);

Tworzenie zasad dystrybucji

Job Router używa zasad dystrybucji do określania, w jaki sposób pracownicy są powiadamiani o dostępnych zadaniach oraz jaki jest czas życia tych powiadomień, zwanych ofertami. Utwórz zasadę, określając Id, nazwę, parametr offerExpiresAfterSeconds oraz tryb dystrybucji.

const distributionPolicy = await client.path("/routing/distributionPolicies/{distributionPolicyId}", "distribution-policy-1").patch({
    body: {
        offerExpiresAfterSeconds: 60,
        mode: { kind: "longest-idle" },
        name: "My distribution policy"
    },
    contentType: "application/merge-patch+json"
});

Utwórz kolejkę

Utwórz kolejkę, określając identyfikator, nazwę i podaj identyfikator obiektu zasad dystrybucji utworzony powyżej.

const queue = await client.path("/routing/queues/{queueId}", "queue-1").patch({
    body: {
        name: "My Queue",
        distributionPolicyId: distributionPolicy.body.id
    },
    contentType: "application/merge-patch+json"
});

Przesyłanie zadania

Teraz możemy wysłać zadanie bezpośrednio do tej kolejki, z selektorem workera, który wymaga, aby worker miał etykietę Some-Skill o wartości większej niż 10.

const job = await client.path("/routing/jobs/{jobId}", "job-1").patch({
    body: {
        channelId: "voice",
        queueId: queue.body.id,
        priority: 1,
        requestedWorkerSelectors: [{ key: "Some-Skill", labelOperator: "greaterThan", value: 10 }]
    },
    contentType: "application/merge-patch+json"
});

Tworzenie procesu roboczego

Teraz tworzymy proces roboczy do odbierania zadań z tej kolejki, z etykietą Some-Skill równą 11 i pojemnością ustawioną w my-channel.

let worker = await client.path("/routing/workers/{workerId}", "worker-1").patch({
    body:  {
        capacity: 1,
        queues: [queue.body.id],
        labels: { "Some-Skill": 11 },
        channels: [{ channelId: "voice", capacityCostPerJob: 1 }],
        availableForOffers: true
    },
    contentType: "application/merge-patch+json"
});

Otrzymywanie oferty

Powinniśmy uzyskać routerWorkerOfferIssued z naszej subskrypcji usługi Event Grid. Możemy jednak również poczekać kilka sekund, a następnie sprawdzić bezpośrednio za pomocą interfejsu API JobRouter, czy temu workerowi została złożona oferta.

await new Promise(r => setTimeout(r, 10000));
worker = await client.path("/routing/workers/{workerId}", worker.body.id).get();
for (const offer of worker.body.offers) {
    console.log(`Worker ${worker.body.id} has an active offer for job ${offer.jobId}`);
}

Zaakceptuj ofertę zadania

Następnie pracownik może zaakceptować ofertę zadania za pomocą zestawu SDK, co spowoduje przypisanie zadania do tego pracownika.

const accept = await client.path("/routing/workers/{workerId}/offers/{offerId}:accept", worker.body.id, worker.body.offers[0].offerId).post();
console.log(`Worker ${worker.body.id} is assigned job ${accept.body.jobId}`);

Ukończenie zadania

Gdy pracownik zakończy pracę związaną z zadaniem (na przykład zakończy połączenie), zamykamy zadanie.

await client.path("/routing/jobs/{jobId}/assignments/{assignmentId}:complete", accept.body.jobId, accept.body.assignmentId).post();
console.log(`Worker ${worker.body.id} has completed job ${accept.body.jobId}`);

Zamykanie zadania

Gdy proces roboczy będzie gotowy do podjęcia nowych zadań, pracownik powinien zamknąć zadanie. Opcjonalnie moduł wykonawczy może podać kod wyniku, aby określić wynik zadania.

await client.path("/routing/jobs/{jobId}/assignments/{assignmentId}:close", accept.body.jobId, accept.body.assignmentId).post({
    body: { dispositionCode: "Resolved" }
});
console.log(`Worker ${worker.body.id} has closed job ${accept.body.jobId}`);

Usuń zadanie

Po zamknięciu zadania możemy usunąć zadanie, aby umożliwić ponowne utworzenie zadania przy użyciu tego samego identyfikatora, jeśli uruchomimy ponownie ten przykład

await client.path("/routing/jobs/{jobId}", accept.body.jobId).delete();
console.log(`Deleting job ${accept.body.jobId}`);

Uruchamianie kodu

Aby uruchomić kod, upewnij się, że znajdujesz się w katalogu, w którym index.js znajduje się plik.

node index.js

Azure Communication Services - Job Router Quickstart
Worker worker-1 has an active offer for job job-1
Worker worker-1 is assigned job job-1
Worker worker-1 has completed job job-1
Worker worker-1 has closed job job-1
Deleting job job-1

Dokumentacja referencyjna

Dowiedz się więcej o pełnym zestawie możliwości usługi Job Router w Azure Communication Services w dokumentacji referencyjnej zestawu JavaScript SDK lub dokumentacji referencyjnej interfejsu API REST.

Wymagania wstępne

• Konto platformy Azure z aktywną subskrypcją. Utwórz konto bezpłatnie.
• Aktywny zasób usług komunikacyjnych i parametry połączenia. Utwórz zasób usług komunikacyjnych.
• Python 3.7+ dla Twojego systemu operacyjnego.

Przykładowy kod

Możesz przejrzeć i pobrać przykładowy kod do tego przewodnika Szybki start w serwisie GitHub.

Konfigurowanie

Tworzenie nowej aplikacji w języku Python

W oknie terminalu lub konsoli utwórz nowy folder dla aplikacji i przejdź do niego.

mkdir jobrouter-quickstart && cd jobrouter-quickstart

Instalowanie pakietu

Należy użyć biblioteki klienta routera zadań komunikacji platformy Azure dla języka Python w wersji 1.0.0 lub nowszej.

W wierszu polecenia konsoli wykonaj następujące polecenie:

pip install azure-communication-jobrouter

Konfigurowanie struktury aplikacji

Utwórz nowy plik o nazwie router-quickstart.py i dodaj podstawową strukturę programu.

import time
from azure.communication.jobrouter import (
    JobRouterClient,
    JobRouterAdministrationClient
)
from azure.communication.jobrouter.models import (
    LongestIdleMode,
    RouterWorkerSelector,
    LabelOperator,
    RouterChannel,
    CloseJobOptions
)

class RouterQuickstart(object):
    print("Azure Communication Services - Job Router Quickstart")
    #Job Router method implementations goes here

if __name__ == '__main__':
    router = RouterQuickstart()

Zainicjuj klienta Job Router i klienta administracyjnego

Klientów usługi Job Router można uwierzytelniać za pomocą parametrów połączenia uzyskanych z zasobu Azure Communication Services w portalu Azure. Generujemy zarówno klienta, jak i klienta administracyjnego do komunikacji z usługą Job Router. Klient administracyjny służy do aprowizowania kolejek i zasad, podczas gdy klient jest używany do przesyłania zadań i rejestrowania procesów roboczych. Aby uzyskać więcej informacji o parametrach połączenia, zobacz access-your-connection-strings-and-service-endpoints.

# Get a connection string to our Azure Communication Services resource.
router_admin_client = JobRouterAdministrationClient.from_connection_string(conn_str = "your_connection_string")
router_client = JobRouterClient.from_connection_string(conn_str = "your_connection_string")

Tworzenie zasad dystrybucji

Router zadań używa polityki dystrybucji, aby określić, w jaki sposób Pracownicy będą powiadamiani o dostępnych zadaniach oraz jaki będzie czas ważności tych powiadomień, zwanych Ofertami. Utwórz zasadę, określając distribution_policy_id, nazwę, wartość offer_expires_after_seconds oraz tryb dystrybucji.

distribution_policy = router_admin_client.upsert_distribution_policy(
    distribution_policy_id ="distribution-policy-1",
    offer_expires_after_seconds = 60,
    mode = LongestIdleMode(),
    name = "My distribution policy")

Utwórz kolejkę

Utwórz kolejkę, określając identyfikator, nazwę i podaj identyfikator obiektu zasad dystrybucji utworzony powyżej.

queue = router_admin_client.upsert_queue(
    queue_id = "queue-1",
    name = "My Queue",
    distribution_policy_id = distribution_policy.id)

Przesyłanie zadania

Teraz możemy wysłać zadanie bezpośrednio do tej kolejki, z selektorem workera, który wymaga, aby worker miał etykietę Some-Skill o wartości większej niż 10.

job = router_client.upsert_job(
    job_id = "job-1",
    channel_id = "voice",
    queue_id = queue.id,
    priority = 1,
    requested_worker_selectors = [
        RouterWorkerSelector(
            key = "Some-Skill",
            label_operator = LabelOperator.GREATER_THAN,
            value = 10
        )
    ])

Tworzenie procesu roboczego

Teraz tworzymy proces roboczy do odbierania zadań z tej kolejki, z etykietą Some-Skill równą 11 i pojemnością ustawioną w my-channel.

worker = router_client.upsert_worker(
    worker_id = "worker-1",
    capacity = 1,
    queues = ["queue-1"],
    labels = {
        "Some-Skill": 11
    },
    channels = [RouterChannel(channel_id = "voice", capacity_cost_per_job = 1)],
    available_for_offers = True
)

Otrzymywanie oferty

Powinniśmy uzyskać routerWorkerOfferIssued z naszej subskrypcji usługi Event Grid. Możemy jednak również poczekać kilka sekund, a następnie sprawdzić bezpośrednio za pomocą interfejsu API JobRouter, czy temu workerowi została złożona oferta.

time.sleep(10)
worker = router_client.get_worker(worker_id = worker.id)
for offer in worker.offers:
    print(f"Worker {worker.id} has an active offer for job {offer.job_id}")

Zaakceptuj ofertę zadania

Następnie pracownik może zaakceptować ofertę zadania za pomocą zestawu SDK, co spowoduje przypisanie zadania do tego pracownika.

accept = router_client.accept_job_offer(worker_id = worker.id, offer_id = worker.offers[0].offer_id)
print(f"Worker {worker.id} is assigned job {accept.job_id}")

Ukończenie zadania

Gdy pracownik zakończy pracę związaną z zadaniem (na przykład zakończy połączenie), zamykamy zadanie.

router_client.complete_job(job_id = job.id, assignment_id = accept.assignment_id)
print(f"Worker {worker.id} has completed job {accept.job_id}")

Zamykanie zadania

Gdy proces roboczy będzie gotowy do podjęcia nowych zadań, pracownik powinien zamknąć zadanie. Opcjonalnie moduł wykonawczy może podać kod wyniku, aby określić wynik zadania.

router_client.close_job(job_id = job.id, assignment_id = accept.assignment_id, options = CloseJobOptions(disposition_code = "Resolved"))
print(f"Worker {worker.id} has closed job {accept.job_id}")

Usuń zadanie

Po zamknięciu zadania możemy usunąć zadanie, aby umożliwić ponowne utworzenie zadania przy użyciu tego samego identyfikatora, jeśli uruchomimy ponownie ten przykład

router_client.delete_job(accept.job_id)
print(f"Deleting {accept.job_id}")

Uruchamianie kodu

Aby uruchomić kod, upewnij się, że znajdujesz się w katalogu, w którym router-quickstart.py znajduje się plik.

python router-quickstart.py

Azure Communication Services - Job Router Quickstart
Worker worker-1 has an active offer for job job-1
Worker worker-1 is assigned job job-1
Worker worker-1 has completed job job-1
Worker worker-1 has closed job job-1
Deleting job job-1

Dokumentacja referencyjna

Dowiedz się więcej o pełnym zakresie możliwości routera zadań usługi Azure Communication Services w dokumentacji referencyjnej zestawu SDK języka Python lub dokumentacji referencyjnej interfejsu API REST.

Wymagania wstępne

• Konto platformy Azure z aktywną subskrypcją. Utwórz konto bezpłatnie.
• Aktywny zasób usług komunikacyjnych i parametry połączenia. Utwórz zasób usług komunikacyjnych.
• Zestaw Java Development Kit (JDK) w wersji 8 lub nowszej.
• Apache Maven

Przykładowy kod

Możesz przejrzeć i pobrać przykładowy kod do tego przewodnika Szybki start w serwisie GitHub.

Konfigurowanie

Tworzenie nowej aplikacji Java

W oknie konsoli (takim jak cmd, PowerShell lub Bash) użyj poniższego mvn polecenia, aby utworzyć nową aplikację konsolową o nazwie router-quickstart. To polecenie tworzy prosty projekt Java "Hello world" z jednym plikiem źródłowym: App.java.

mvn archetype:generate -DgroupId=com.communication.jobrouter.quickstart -DartifactId=jobrouter-quickstart-java -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4 -DinteractiveMode=false

Uwzględnij pakiet

Należy użyć biblioteki klienckiej Azure Communication Job Router dla języka Java w wersji 1.0.0 lub nowszej.

Dołącz plik BOM

Dołącz element azure-sdk-bom do projektu, aby mieć zależność od wersji ogólnie dostępnej biblioteki. W poniższym fragmencie kodu zastąp symbol zastępczy {bom_version_to_target} numerem wersji. Aby dowiedzieć się więcej o BOM, zobacz plik readme dotyczący Azure SDK BOM.

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.azure</groupId>
            <artifactId>azure-sdk-bom</artifactId>
            <version>{bom_version_to_target}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

a następnie uwzględnij bezpośrednią zależność w sekcji zależności bez tagu wersji.

<dependencies>
  <dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-communication-jobrouter</artifactId>
  </dependency>
</dependencies>

Uwzględnij zależność bezpośrednią

Jeśli chcesz podjąć zależność od określonej wersji biblioteki, która nie znajduje się w modelu BOM, dodaj bezpośrednią zależność do projektu w następujący sposób.

<dependency>
  <groupId>com.azure</groupId>
  <artifactId>azure-communication-jobrouter</artifactId>
  <version>1.0.0</version>
</dependency>

Konfigurowanie platformy aplikacji

Przejdź do katalogu /src/main/java/com/communication/quickstart i otwórz App.java plik. Dodaj następujący kod:

package com.communication.quickstart;

import com.azure.communication.jobrouter.JobRouterAdministrationClient;
import com.azure.communication.jobrouter.JobRouterAdministrationClientBuilder;
import com.azure.communication.jobrouter.JobRouterClient;
import com.azure.communication.jobrouter.JobRouterClientBuilder;
import com.azure.communication.jobrouter.*;
import com.azure.communication.jobrouter.models.*;

import java.time.Duration;
import java.util.List;
import java.util.Map;

public class App
{
    public static void main(String[] args) throws IOException
    {
        System.out.println("Azure Communication Services - Job Router Quickstart");
        // Quickstart code goes here
    }
}

Zainicjuj klienta Job Router i klienta administracyjnego

Klientów usługi Job Router można uwierzytelniać za pomocą parametrów połączenia uzyskanych z zasobu Azure Communication Services w portalu Azure. Generujemy zarówno klienta, jak i klienta administracyjnego do komunikacji z usługą Job Router. Klient administracyjny służy do aprowizowania kolejek i zasad, podczas gdy klient jest używany do przesyłania zadań i rejestrowania procesów roboczych. Aby uzyskać więcej informacji o parametrach połączenia, zobacz access-your-connection-strings-and-service-endpoints.

// Get a connection string to our Azure Communication Services resource.
JobRouterAdministrationClient routerAdminClient = new JobRouterAdministrationClientBuilder().connectionString("your_connection_string").buildClient();
JobRouterClient routerClient = new JobRouterClientBuilder().connectionString("your_connection_string").buildClient();

Tworzenie zasad dystrybucji

Router zadań używa polityki dystrybucji, aby określić, w jaki sposób Pracownicy będą powiadamiani o dostępnych zadaniach oraz jaki będzie czas ważności tych powiadomień, zwanych Ofertami. Utwórz zasadę, podając ID, nazwę, wartość offerExpiresAfter oraz tryb dystrybucji.

DistributionPolicy distributionPolicy = routerAdminClient.createDistributionPolicy(
    new CreateDistributionPolicyOptions("distribution-policy-1", Duration.ofMinutes(1), new LongestIdleMode())
        .setName("My distribution policy"));

Utwórz kolejkę

Utwórz kolejkę, określając identyfikator, nazwę i podaj identyfikator obiektu zasad dystrybucji utworzony powyżej.

RouterQueue queue = routerAdminClient.createQueue(
    new CreateQueueOptions("queue-1", distributionPolicy.getId()).setName("My queue")
);

Przesyłanie zadania

Teraz możemy wysłać zadanie bezpośrednio do tej kolejki, z selektorem workera, który wymaga, aby worker miał etykietę Some-Skill o wartości większej niż 10.

RouterJob job = routerClient.createJob(new CreateJobOptions("job-1", "voice", queue.getId())
    .setPriority(1)
    .setRequestedWorkerSelectors(List.of(
        new RouterWorkerSelector("Some-Skill", LabelOperator.GREATER_THAN, new RouterValue(10)))));

Tworzenie procesu roboczego

Teraz tworzymy proces roboczy do odbierania zadań z tej kolejki, z etykietą Some-Skill równą 11 i pojemnością ustawioną w my-channel.

RouterWorker worker = routerClient.createWorker(
    new CreateWorkerOptions("worker-1", 1)
        .setQueues(List.of(queue.getId()))
        .setLabels(Map.of("Some-Skill", new RouterValue(11)))
        .setChannels(List.of(new RouterChannel("voice", 1))));

Otrzymywanie oferty

Powinniśmy uzyskać routerWorkerOfferIssued z naszej subskrypcji usługi Event Grid. Możemy jednak również poczekać kilka sekund, a następnie sprawdzić bezpośrednio za pomocą interfejsu API JobRouter, czy temu workerowi została złożona oferta.

Thread.sleep(10000);
worker = routerClient.getWorker(worker.getId());
for (RouterJobOffer offer : worker.getOffers()) {
    System.out.printf("Worker %s has an active offer for job %s\n", worker.getId(), offer.getJobId());
}

Zaakceptuj ofertę zadania

Następnie pracownik może zaakceptować ofertę zadania za pomocą zestawu SDK, co spowoduje przypisanie zadania do tego pracownika.

AcceptJobOfferResult accept = routerClient.acceptJobOffer(worker.getId(), worker.getOffers().get(0).getOfferId());
System.out.printf("Worker %s is assigned job %s\n", worker.getId(), accept.getJobId());

Ukończenie zadania

Gdy pracownik zakończy pracę związaną z zadaniem (na przykład zakończy połączenie), zamykamy zadanie.

routerClient.completeJobWithResponse(accept.getJobId(), accept.getAssignmentId(), null);
System.out.printf("Worker %s has completed job %s\n", worker.getId(), accept.getJobId());

Zamykanie zadania

Gdy proces roboczy będzie gotowy do podjęcia nowych zadań, pracownik powinien zamknąć zadanie.

routerClient.closeJobWithResponse(accept.getJobId(), accept.getAssignmentId(), null);
System.out.printf("Worker %s has closed job %s\n", worker.getId(), accept.getJobId());

Usuń zadanie

Po zamknięciu zadania możemy usunąć zadanie, aby umożliwić ponowne utworzenie zadania przy użyciu tego samego identyfikatora, jeśli uruchomimy ponownie ten przykład

routerClient.deleteJob(accept.getJobId());
System.out.printf("Deleting job %s\n", accept.getJobId());

Uruchamianie kodu

Aby uruchomić kod, przejdź do katalogu zawierającego pom.xml plik i skompiluj program.

mvn compile

Następnie skompiluj pakiet:

mvn package

Uruchom aplikację

mvn exec:java -Dexec.mainClass="com.communication.jobrouter.quickstart.App" -Dexec.cleanupDaemonThreads=false

Oczekiwane dane wyjściowe opisują każdą ukończoną akcję:

Azure Communication Services - Job Router Quickstart
Worker worker-1 has an active offer for job job-1
Worker worker-1 is assigned job job-1
Worker worker-1 has completed job job-1
Worker worker-1 has closed job job-1
Deleting job job-1

Dokumentacja referencyjna

Zapoznaj się z pełnym zestawem możliwości usługi Job Router w Azure Communication Services w dokumentacji referencyjnej zestawu Java SDK lub dokumentacji referencyjnej interfejsu API REST.