Schnellstart: Übermitteln eines Auftrags für Warteschlangen und Routing

  • Artikel

Beginnen Sie mit dem Azure Communication Services-Auftragsrouter, indem Sie Ihren Client einrichten und dann Kernfunktionen wie Warteschlangen, Richtlinien, Worker und Aufträge konfigurieren. Weitere Informationen zu Auftragsrouterkonzepten finden Sie in der konzeptionellen Dokumentation zu Auftragsroutern.

Voraussetzungen

Beispielcode

Sie können den Beispielcode für diesen Schnellstart auf GitHub überprüfen und herunterladen.

Einrichten

Erstellen einer neuen C#-Anwendung

Verwenden Sie in einem Konsolenfenster (z. B. cmd, PowerShell oder Bash) den Befehl dotnet new zum Erstellen einer neuen Konsolen-App mit dem Namen JobRouterQuickstart. Dieser Befehl erstellt ein einfaches „Hallo Welt“-C#-Projekt mit einer einzigen Quelldatei: Program.cs.

dotnet new console -o JobRouterQuickstart

Wechseln Sie zum neu erstellten App-Ordner, und verwenden Sie den Befehl dotnet build, um Ihre Anwendung zu kompilieren.

cd JobRouterQuickstart
dotnet build

Installieren des Pakets

Installieren der Azure Communication-Auftragsrouter-Clientbibliothek für .NET für mit NuGet:

dotnet add package Azure.Communication.JobRouter

Sie müssen die Azure Communication-Auftragsrouter-Clientbibliothek für .NET Version 1.0.0 oder höher verwenden.

Fügen Sie am Anfang von Program.cs die folgenden using-Anweisungen hinzu, um die JobRouter-Namespaces einzuschließen.

using Azure.Communication.JobRouter;

Initialisieren des Auftragsrouterclients und des Verwaltungsclients

Auftragsrouterclients können mithilfe Ihrer Verbindungszeichenfolge authentifiziert werden, die von einer Azure Communication Services-Ressource im Azure-Portal abgerufen wird. Wir generieren sowohl einen Client als auch einen Verwaltungsclient, der mit dem Auftragsrouterdienst interagiert. Der Administratorclient wird verwendet, um Warteschlangen und Richtlinien bereitzustellen, während der Client zum Übermitteln von Aufträgen und zum Registrieren von Workern verwendet wird. Weitere Informationen zu Verbindungszeichenfolgen finden Sie unter 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");

Erstellen einer Verteilungsrichtlinie

Der Auftragsrouter verwendet eine Verteilungsrichtlinie, um zu entscheiden, wie Worker über verfügbare Aufträge und die Gültigkeitsdauer für die Benachrichtigungen informiert werden. Dies wird als Angebote bezeichnet. Erstellen Sie die Richtlinie, indem Sie die ID, einen Namen, einen Wert für offerExpiresAfter und einen Verteilungsmodus angeben.

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

Erstellen einer Warteschlange

Erstellen Sie die Warteschlange, indem Sie eine ID, einen Namen und die ID des Objekts für die Verteilungsrichtlinie angeben, die Sie oben erstellt haben.

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

Übermitteln eines Auftrags

Jetzt können wir einen Auftrag direkt an diese Warteschlange mit einem Workerselektor übermitteln, der vorschreibt, dass die Bezeichnung Some-Skill des Workers größer als 10 ist.

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

Erstellen eines Workers

Nun erstellen wir einen Worker für den Empfang von Arbeit aus dieser Warteschlange, mit der Bezeichnung Some-Skill gleich 11 und Kapazität für 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
    });

Erhalten eines Angebots

Wir sollten RouterWorkerOfferIssued aus unserem Event Grid-Abonnement erhalten. Wir könnten jedoch auch einige Sekunden warten und dann den Worker direkt mit der JobRouter-API abfragen, um zu sehen, ob ein Angebot an ihn ausgegeben wurde.

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

Annehmen des Auftragsangebots

Anschließend kann der Worker das Auftragsangebot annehmen, indem er das SDK verwendet, das den Auftrag dem Worker zuweist.

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

Abschließen des Auftrags

Sobald der Worker die dem Auftrag zugeordnete Arbeit abgeschlossen hat (z. B. den Aufruf abgeschlossen), schließen wir den Auftrag ab.

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

Schließen des Auftrags

Sobald der Worker bereit ist, neue Aufträge zu übernehmen, sollte er den Auftrag schließen. Optional kann der Worker einen Dispositionscode bereitstellen, um das Ergebnis des Auftrags anzugeben.

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

Löschen des Auftrags

Nachdem der Auftrag geschlossen wurde, können wir ihn löschen, sodass der Auftrag mit derselben ID neu erstellt werden kann, wenn wir dieses Beispiel erneut ausführen.

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

Ausführen des Codes

Führen Sie die Anwendung mithilfe von dotnet run aus, und sehen Sie sich die Ergebnisse an.

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

Hinweis

Wenn Sie die Anwendung mehrmals ausführen, wird jedes Mal ein neuer Auftrag in die Warteschlange eingereiht. Dies kann dazu führen, dass dem Worker ein anderer Auftrag als der angeboten wird, der beim Ausführen des obigen Codes erstellt wurde. Da dies die Anforderung verzerren kann, sollten Sie Aufträge in der Warteschlange ggf. jedes Mal löschen. Informationen zum Verwalten einer Warteschlange oder eines Auftrags finden Sie in der SDK-Dokumentation.

Referenzdokumentation

Lesen Sie mehr zu den vollständigen Funktionen von Azure Communication Services-Auftragsroutern in der .NET SDK-Referenz oder REST-API-Referenz.

Voraussetzungen

Beispielcode

Sie können den Beispielcode für diesen Schnellstart auf GitHub überprüfen und herunterladen.

Einrichten

Erstellen einer neuen Webanwendung

Erstellen Sie in einem Terminal- oder Konsolenfenster einen neuen Ordner für Ihre Anwendung, und navigieren Sie zu diesem Verzeichnis.

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

Führen Sie npm init aus, um die Datei package.json mit den Standardeinstellungen zu erstellen.

npm init -y

Erstellen Sie eine neue index.js-Datei, in der Sie Code für diesen Schnellstart hinzufügen.

Installieren der Pakete

Sie müssen die Azure Communication-Auftragsrouter-Clientbibliothek für JavaScript Version 1.0.0 oder höher verwenden.

Verwenden Sie den Befehl npm install, um die unten angegebenen Communication Services-SDKs für JavaScript zu installieren.

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

Einrichten des App-Frameworks

Fügen Sie in der Datei index.js den folgenden Code hinzu. Wir fügen den Code für den Schnellstart in der main-Funktion hinzu.

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

Initialisieren des Auftragsrouterclients

Auftragsrouterclients können mithilfe Ihrer Verbindungszeichenfolge authentifiziert werden, die von einer Azure Communication Services-Ressource im Azure-Portal abgerufen wird. Wir generieren einen Client für die Interaktion mit dem Auftragsrouterdienst. Weitere Informationen zu Verbindungszeichenfolgen finden Sie unter access-your-connection-strings-and-service-endpoints.

Fügen Sie in index.js innerhalb der main-Funktion den folgenden Code hinzu.

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

Erstellen einer Verteilungsrichtlinie

Der Auftragsrouter verwendet eine Verteilungsrichtlinie, um zu entscheiden, wie Worker über verfügbare Aufträge und die Gültigkeitsdauer für die Benachrichtigungen informiert werden. Dies wird als Angebote bezeichnet. Erstellen Sie die Richtlinie, indem Sie die ID, einen Namen, einen Wert für offerExpiresAfterSeconds und einen Verteilungsmodus angeben.

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

Erstellen einer Warteschlange

Erstellen Sie die Warteschlange, indem Sie eine ID, einen Namen und die ID des Objekts für die Verteilungsrichtlinie angeben, die Sie oben erstellt haben.

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

Übermitteln eines Auftrags

Jetzt können wir einen Auftrag direkt an diese Warteschlange mit einem Workerselektor übermitteln, der vorschreibt, dass die Bezeichnung Some-Skill des Workers größer als 10 ist.

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

Erstellen eines Workers

Nun erstellen wir einen Worker für den Empfang von Arbeit aus dieser Warteschlange, mit der Bezeichnung Some-Skill gleich 11 und Kapazität für 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"
});

Erhalten eines Angebots

Wir sollten RouterWorkerOfferIssued aus unserem Event Grid-Abonnement erhalten. Wir könnten jedoch auch einige Sekunden warten und dann den Worker direkt mit der JobRouter-API abfragen, um zu sehen, ob ein Angebot an ihn ausgegeben wurde.

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

Annehmen des Auftragsangebots

Anschließend kann der Worker das Auftragsangebot annehmen, indem er das SDK verwendet, das den Auftrag dem Worker zuweist.

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

Abschließen des Auftrags

Sobald der Worker die dem Auftrag zugeordnete Arbeit abgeschlossen hat (z. B. den Aufruf abgeschlossen), schließen wir den Auftrag ab.

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

Schließen des Auftrags

Sobald der Worker bereit ist, neue Aufträge zu übernehmen, sollte er den Auftrag schließen. Optional kann der Worker einen Dispositionscode bereitstellen, um das Ergebnis des Auftrags anzugeben.

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

Löschen des Auftrags

Nachdem der Auftrag geschlossen wurde, können wir ihn löschen, sodass der Auftrag mit derselben ID neu erstellt werden kann, wenn wir dieses Beispiel erneut ausführen.

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

Ausführen des Codes

Vergewissern Sie sich, dass Sie sich in dem Verzeichnis befinden, in dem sich die index.js-Datei befindet, um den Code auszuführen.

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

Hinweis

Wenn Sie die Anwendung mehrmals ausführen, wird jedes Mal ein neuer Auftrag in die Warteschlange eingereiht. Dies kann dazu führen, dass dem Worker ein anderer Auftrag als der angeboten wird, der beim Ausführen des obigen Codes erstellt wurde. Da dies die Anforderung verzerren kann, sollten Sie Aufträge in der Warteschlange ggf. jedes Mal löschen. Informationen zum Verwalten einer Warteschlange oder eines Auftrags finden Sie in der SDK-Dokumentation.

Referenzdokumentation

Lesen Sie mehr zu den vollständigen Funktionen von Azure Communication Services-Auftragsroutern in der JavaScript SDK-Referenz oder REST-API-Referenz.

Voraussetzungen

Beispielcode

Sie können den Beispielcode für diesen Schnellstart auf GitHub überprüfen und herunterladen.

Einrichten

Erstellen einer neuen Python-Anwendung

Erstellen Sie in einem Terminal- oder Konsolenfenster einen neuen Ordner für Ihre Anwendung, und navigieren Sie zu diesem Verzeichnis.

mkdir jobrouter-quickstart && cd jobrouter-quickstart

Installieren des Pakets

Sie müssen die Azure Communication-Auftragsrouter-Clientbibliothek für Python Version 1.0.0 oder höher verwenden.

Führen Sie in der Konsolen-Eingabeaufforderung den folgenden Befehl aus:

pip install azure-communication-jobrouter

Einrichten des App-Frameworks

Erstellen Sie eine neue Datei namens router-quickstart.py, und fügen Sie die grundlegende Programmstruktur hinzu.

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

Initialisieren des Auftragsrouterclients und des Verwaltungsclients

Auftragsrouterclients können mithilfe Ihrer Verbindungszeichenfolge authentifiziert werden, die von einer Azure Communication Services-Ressource im Azure-Portal abgerufen wird. Wir generieren sowohl einen Client als auch einen Verwaltungsclient, der mit dem Auftragsrouterdienst interagiert. Der Administratorclient wird verwendet, um Warteschlangen und Richtlinien bereitzustellen, während der Client zum Übermitteln von Aufträgen und zum Registrieren von Workern verwendet wird. Weitere Informationen zu Verbindungszeichenfolgen finden Sie unter 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")

Erstellen einer Verteilungsrichtlinie

Der Auftragsrouter verwendet eine Verteilungsrichtlinie, um zu entscheiden, wie Worker über verfügbare Aufträge und die Gültigkeitsdauer für die Benachrichtigungen informiert werden. Dies wird als Angebote bezeichnet. Erstellen Sie die Richtlinie, indem Sie einen Wert für distribution_policy_id, name und offer_expires_after_seconds sowie einen Modus (mode) für die Verteilung angeben.

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

Erstellen einer Warteschlange

Erstellen Sie die Warteschlange, indem Sie eine ID, einen Namen und die ID des Objekts für die Verteilungsrichtlinie angeben, die Sie oben erstellt haben.

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

Übermitteln eines Auftrags

Jetzt können wir einen Auftrag direkt an diese Warteschlange mit einem Workerselektor übermitteln, der vorschreibt, dass die Bezeichnung Some-Skill des Workers größer als 10 ist.

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

Erstellen eines Workers

Nun erstellen wir einen Worker für den Empfang von Arbeit aus dieser Warteschlange, mit der Bezeichnung Some-Skill gleich 11 und Kapazität für 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
)

Erhalten eines Angebots

Wir sollten RouterWorkerOfferIssued aus unserem Event Grid-Abonnement erhalten. Wir könnten jedoch auch einige Sekunden warten und dann den Worker direkt mit der JobRouter-API abfragen, um zu sehen, ob ein Angebot an ihn ausgegeben wurde.

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

Annehmen des Auftragsangebots

Anschließend kann der Worker das Auftragsangebot annehmen, indem er das SDK verwendet, das den Auftrag dem Worker zuweist.

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

Abschließen des Auftrags

Sobald der Worker die dem Auftrag zugeordnete Arbeit abgeschlossen hat (z. B. den Aufruf abgeschlossen), schließen wir den Auftrag ab.

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

Schließen des Auftrags

Sobald der Worker bereit ist, neue Aufträge zu übernehmen, sollte er den Auftrag schließen. Optional kann der Worker einen Dispositionscode bereitstellen, um das Ergebnis des Auftrags anzugeben.

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

Löschen des Auftrags

Nachdem der Auftrag geschlossen wurde, können wir ihn löschen, sodass der Auftrag mit derselben ID neu erstellt werden kann, wenn wir dieses Beispiel erneut ausführen.

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

Ausführen des Codes

Vergewissern Sie sich, dass Sie sich in dem Verzeichnis befinden, in dem sich die router-quickstart.py-Datei befindet, um den Code auszuführen.

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

Hinweis

Wenn Sie die Anwendung mehrmals ausführen, wird jedes Mal ein neuer Auftrag in die Warteschlange eingereiht. Dies kann dazu führen, dass dem Worker ein anderer Auftrag als der angeboten wird, der beim Ausführen des obigen Codes erstellt wurde. Da dies die Anforderung verzerren kann, sollten Sie Aufträge in der Warteschlange ggf. jedes Mal löschen. Informationen zum Verwalten einer Warteschlange oder eines Auftrags finden Sie in der SDK-Dokumentation.

Referenzdokumentation

Lesen Sie mehr zu den vollständigen Funktionen von Azure Communication Services-Auftragsroutern in der Python SDK-Referenz oder REST-API-Referenz.

Voraussetzungen

Beispielcode

Sie können den Beispielcode für diesen Schnellstart auf GitHub überprüfen und herunterladen.

Einrichten

Erstellen einer neuen Java-Anwendung

Verwenden Sie in einem Konsolenfenster (z. B. cmd, PowerShell oder Bash) den Befehl mvn unten zum Erstellen einer neuen Konsolen-App mit dem Namen router-quickstart. Dieser Befehl erstellt ein einfaches Java-Projekt vom Typ „Hallo Welt“ mit einer einzelnen Quelldatei: App.java.

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

Einschließen des Pakets

Sie müssen die Azure Communication-Auftragsrouter-Clientbibliothek für Java Version 1.0.0 oder höher verwenden.

BOM-Datei einfügen

Fügen Sie azure-sdk-bom in Ihr Projekt ein, um die Abhängigkeit der allgemein verfügbaren Version der Bibliothek zu übernehmen. Ersetzen Sie im folgenden Codeausschnitt den Platzhalter {bom_version_to_target} durch die Versionsnummer. Weitere Informationen zur BOM finden Sie in der Azure SDK-BOM-Infodatei.

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

und fügen Sie dann die direkte Abhängigkeit ohne Versions-Tag in den Abschnitt „Abhängigkeit“ ein.

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

Direkte Abhängigkeiten einfügen

Wenn Sie eine Abhängigkeit von einer bestimmten Version der Bibliothek übernehmen möchten, die nicht in der BOM vorhanden ist, fügen Sie ihrem Projekt die direkte Abhängigkeit wie folgt hinzu.

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

Einrichten des App-Frameworks

Wechseln Sie zum Verzeichnis „/src/main/java/com/communication/quickstart“, und öffnen Sie die App.java-Datei. Fügen Sie den folgenden Code hinzu:

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

Initialisieren des Auftragsrouterclients und des Verwaltungsclients

Auftragsrouterclients können mithilfe Ihrer Verbindungszeichenfolge authentifiziert werden, die von einer Azure Communication Services-Ressource im Azure-Portal abgerufen wird. Wir generieren sowohl einen Client als auch einen Verwaltungsclient, der mit dem Auftragsrouterdienst interagiert. Der Administratorclient wird verwendet, um Warteschlangen und Richtlinien bereitzustellen, während der Client zum Übermitteln von Aufträgen und zum Registrieren von Workern verwendet wird. Weitere Informationen zu Verbindungszeichenfolgen finden Sie unter 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();

Erstellen einer Verteilungsrichtlinie

Der Auftragsrouter verwendet eine Verteilungsrichtlinie, um zu entscheiden, wie Worker über verfügbare Aufträge und die Gültigkeitsdauer für die Benachrichtigungen informiert werden. Dies wird als Angebote bezeichnet. Erstellen Sie die Richtlinie, indem Sie die ID, einen Namen, einen Wert für offerExpiresAfter und einen Verteilungsmodus angeben.

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

Erstellen einer Warteschlange

Erstellen Sie die Warteschlange, indem Sie eine ID, einen Namen und die ID des Objekts für die Verteilungsrichtlinie angeben, die Sie oben erstellt haben.

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

Übermitteln eines Auftrags

Jetzt können wir einen Auftrag direkt an diese Warteschlange mit einem Workerselektor übermitteln, der vorschreibt, dass die Bezeichnung Some-Skill des Workers größer als 10 ist.

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

Erstellen eines Workers

Nun erstellen wir einen Worker für den Empfang von Arbeit aus dieser Warteschlange, mit der Bezeichnung Some-Skill gleich 11 und Kapazität für 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))));

Erhalten eines Angebots

Wir sollten RouterWorkerOfferIssued aus unserem Event Grid-Abonnement erhalten. Wir könnten jedoch auch einige Sekunden warten und dann den Worker direkt mit der JobRouter-API abfragen, um zu sehen, ob ein Angebot an ihn ausgegeben wurde.

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

Annehmen des Auftragsangebots

Anschließend kann der Worker das Auftragsangebot annehmen, indem er das SDK verwendet, das den Auftrag dem Worker zuweist.

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

Abschließen des Auftrags

Sobald der Worker die dem Auftrag zugeordnete Arbeit abgeschlossen hat (z. B. den Aufruf abgeschlossen), schließen wir den Auftrag ab.

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

Schließen des Auftrags

Sobald der Worker bereit ist, neue Aufträge zu übernehmen, sollte er den Auftrag schließen.

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

Löschen des Auftrags

Nachdem der Auftrag geschlossen wurde, können wir ihn löschen, sodass der Auftrag mit derselben ID neu erstellt werden kann, wenn wir dieses Beispiel erneut ausführen.

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

Ausführen des Codes

Navigieren Sie zum Ausführen des Codes zum Verzeichnis, das die pom.xml-Datei enthält, und kompilieren Sie das Programm.

mvn compile

Erstellen Sie dann das Paket:

mvn package

Ausführen der Anwendung

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

In der erwarteten Ausgabe wird jede abgeschlossene Aktion beschrieben:

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

Hinweis

Wenn Sie die Anwendung mehrmals ausführen, wird jedes Mal ein neuer Auftrag in die Warteschlange eingereiht. Dies kann dazu führen, dass dem Worker ein anderer Auftrag als der angeboten wird, der beim Ausführen des obigen Codes erstellt wurde. Da dies die Anforderung verzerren kann, sollten Sie Aufträge in der Warteschlange ggf. jedes Mal löschen. Informationen zum Verwalten einer Warteschlange oder eines Auftrags finden Sie in der SDK-Dokumentation.

Referenzdokumentation

Lesen Sie mehr zu den vollständigen Funktionen von Azure Communication Services-Auftragsroutern in der Java-SDK-Referenz oder REST-API-Referenz.

Nächste Schritte

Erkunden der Tutorials zu Auftragsroutern