Guia de início rápido: enviar um trabalho para enfileiramento e roteamento

  • Artigo

Comece a usar o Roteador de Tarefas dos Serviços de Comunicação do Azure configurando seu cliente e, em seguida, configurando a funcionalidade principal, como filas, políticas, trabalhadores e Trabalhos. Para saber mais sobre os conceitos do Job Router, visite a documentação conceitual do Job Router

Pré-requisitos

Código de exemplo

Você pode revisar e baixar o código de exemplo para este início rápido no GitHub.

Configuração

Criar um novo aplicativo C#

Em uma janela de console (como cmd, PowerShell ou Bash), use o comando para criar um novo aplicativo de console com o dotnet new nome JobRouterQuickstart. Este comando cria um projeto C# "Hello World" simples com um único arquivo de origem: Program.cs.

dotnet new console -o JobRouterQuickstart

Altere seu diretório para a pasta do aplicativo recém-criada e use o dotnet build comando para compilar seu aplicativo.

cd JobRouterQuickstart
dotnet build

Instalar o pacote

Instale a biblioteca de cliente do Azure Communication Job Router para .NET com NuGet:

dotnet add package Azure.Communication.JobRouter

Você precisará usar a biblioteca de cliente do Azure Communication Job Router para .NET versão 1.0.0 ou superior.

Adicione as seguintes using diretivas à parte superior de Program.cs para incluir os namespaces JobRouter.

using Azure.Communication.JobRouter;

Inicializar o cliente do Job Router e o cliente de administração

Os clientes do Job Router podem ser autenticados usando sua cadeia de conexão adquirida de um recurso dos Serviços de Comunicação do Azure no portal do Azure. Geramos um cliente e um cliente de administração para interagir com o serviço Job Router. O cliente admin é usado para provisionar filas e políticas, enquanto o cliente é usado para enviar trabalhos e registrar trabalhadores. Para obter mais informações sobre cadeias de conexão, consulte 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");

Criar uma política de distribuição

O Job Router usa uma política de distribuição para decidir como os Trabalhadores serão notificados sobre os Trabalhos disponíveis e o tempo de vida para as notificações, conhecido como Ofertas. Crie a política especificando o ID, um nome, um offerExpiresAfter e um modo de distribuição.

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

Criar uma fila

Crie a Fila especificando uma ID, um nome e forneça a ID do objeto de Política de Distribuição que você criou acima.

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

Enviar uma vaga

Agora, podemos enviar um trabalho diretamente para essa fila, com um seletor de trabalhador que exige que o trabalhador tenha o rótulo Some-Skill maior que 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))
        }
    });

Criar um trabalhador

Agora, criamos um trabalhador para receber o trabalho dessa fila, com uma etiqueta igual Some-Skill a 11 e capacidade em 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
    });

Receba uma oferta

Devemos obter um RouterWorkerOfferIssued a partir da nossa subscrição da Grelha de Eventos. No entanto, também podemos esperar alguns segundos e, em seguida, consultar o trabalhador diretamente na API do JobRouter para ver se uma oferta foi emitida para ele.

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

Aceitar a oferta de emprego

Em seguida, o trabalhador pode aceitar a oferta de trabalho usando o SDK, que atribui o trabalho ao trabalhador.

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

Conclua o trabalho

Uma vez que o trabalhador tenha concluído o trabalho associado ao trabalho (por exemplo, concluído a chamada), concluímos o trabalho.

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

Fechar o trabalho

Quando o trabalhador estiver pronto para assumir novos empregos, o trabalhador deve fechar o trabalho. Opcionalmente, o trabalhador pode fornecer um código de disposição para indicar o resultado do trabalho.

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

Excluir o trabalho

Depois que o trabalho for fechado, podemos excluí-lo para que possamos recriá-lo com a mesma ID se executarmos este exemplo novamente

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

Executar o código

Execute o aplicativo usando dotnet run e observe os resultados.

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

Nota

Executar o aplicativo mais de uma vez fará com que um novo trabalho seja colocado na fila a cada vez. Isso pode fazer com que seja oferecido ao Trabalhador um Trabalho diferente daquele criado quando você executa o código acima. Como isso pode distorcer sua solicitação, considere excluir trabalhos na fila a cada vez. Consulte a documentação do SDK para gerenciar uma fila ou um trabalho.

Documentação de referência

Leia sobre o conjunto completo de recursos do Job Router dos Serviços de Comunicação do Azure a partir da referência do SDK do .NET ou da referência da API REST.

Pré-requisitos

  • Uma conta do Azure com uma subscrição ativa. Crie uma conta gratuitamente.
  • Um recurso ativo dos Serviços de Comunicação e uma cadeia de conexão. Crie um recurso de Serviços de Comunicação.
  • As versões mais recentes do Node.js Ative LTS e Maintenance LTS.

Código de exemplo

Você pode revisar e baixar o código de exemplo para este início rápido no GitHub.

Configuração

Criar um novo aplicativo Web

Em uma janela de terminal ou console, crie uma nova pasta para seu aplicativo e navegue até ela.

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

Execute npm init para criar um arquivo package.json com as configurações padrão.

npm init -y

Crie um novo arquivo index.js onde você adicionará o código para este início rápido.

Instalar os pacotes

Você precisará usar a biblioteca de cliente do Azure Communication Job Router para JavaScript versão 1.0.0 ou superior.

Use o npm install comando para instalar os SDKs de Serviços de Comunicação para JavaScript abaixo.

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

Configurar a estrutura do aplicativo

index.js No arquivo, adicione o código a seguir. Vamos adicionar o código para o início rápido na main função.

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

Inicializar o cliente do Job Router

Os clientes do Job Router podem ser autenticados usando sua cadeia de conexão adquirida de um recurso dos Serviços de Comunicação do Azure no portal do Azure. Geramos um cliente para interagir com o serviço Job Router. Para obter mais informações sobre cadeias de conexão, consulte access-your-connection-strings-and-service-endpoints.

Adicione o seguinte código dentro index.js da main função.

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

Criar uma política de distribuição

O Job Router usa uma política de distribuição para decidir como os trabalhadores são notificados sobre os trabalhos disponíveis e o tempo de vida para as notificações, conhecido como Ofertas. Crie a política especificando o Id, um nome, um offerExpiresAfterSeconds e um modo de distribuição.

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

Criar uma fila

Crie a Fila especificando uma ID, um nome e forneça a ID do objeto de Política de Distribuição que você criou acima.

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

Enviar uma vaga

Agora, podemos enviar um trabalho diretamente para essa fila, com um seletor de trabalhador que exige que o trabalhador tenha o rótulo Some-Skill maior que 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"
});

Criar um trabalhador

Agora, criamos um trabalhador para receber o trabalho dessa fila, com uma etiqueta igual Some-Skill a 11 e capacidade em 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"
});

Receba uma oferta

Devemos obter um RouterWorkerOfferIssued a partir da nossa subscrição da Grelha de Eventos. No entanto, também podemos esperar alguns segundos e, em seguida, consultar o trabalhador diretamente na API do JobRouter para ver se uma oferta foi emitida para ele.

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

Aceitar a oferta de emprego

Em seguida, o trabalhador pode aceitar a oferta de trabalho usando o SDK, que atribui o trabalho ao trabalhador.

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

Conclua o trabalho

Uma vez que o trabalhador tenha concluído o trabalho associado ao trabalho (por exemplo, concluído a chamada), concluímos o trabalho.

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

Fechar o trabalho

Quando o trabalhador estiver pronto para assumir novos empregos, o trabalhador deve fechar o trabalho. Opcionalmente, o trabalhador pode fornecer um código de disposição para indicar o resultado do trabalho.

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

Excluir o trabalho

Depois que o trabalho for fechado, podemos excluí-lo para que possamos recriá-lo com a mesma ID se executarmos este exemplo novamente

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

Executar o código

Para executar o código, certifique-se de que está no diretório onde index.js se encontra o ficheiro.

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

Nota

Executar o aplicativo mais de uma vez fará com que um novo trabalho seja colocado na fila a cada vez. Isso pode fazer com que seja oferecido ao Trabalhador um Trabalho diferente daquele criado quando você executa o código acima. Como isso pode distorcer sua solicitação, considere excluir trabalhos na fila a cada vez. Consulte a documentação do SDK para gerenciar uma fila ou um trabalho.

Documentação de referência

Leia sobre o conjunto completo de recursos do Job Router dos Serviços de Comunicação do Azure na referência do SDK JavaScript ou na referência da API REST.

Pré-requisitos

Código de exemplo

Você pode revisar e baixar o código de exemplo para este início rápido no GitHub.

Configuração

Criar uma aplicação Python nova

Em uma janela de terminal ou console, crie uma nova pasta para seu aplicativo e navegue até ela.

mkdir jobrouter-quickstart && cd jobrouter-quickstart

Instalar o pacote

Você precisará usar a biblioteca de cliente do Azure Communication Job Router para Python versão 1.0.0 ou superior.

Em um prompt do console, execute o seguinte comando:

pip install azure-communication-jobrouter

Configurar a estrutura do aplicativo

Crie um novo arquivo chamado router-quickstart.py e adicione a estrutura básica do programa.

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

Inicializar o cliente do Job Router e o cliente de administração

Os clientes do Job Router podem ser autenticados usando sua cadeia de conexão adquirida de um recurso dos Serviços de Comunicação do Azure no portal do Azure. Geramos um cliente e um cliente de administração para interagir com o serviço Job Router. O cliente admin é usado para provisionar filas e políticas, enquanto o cliente é usado para enviar trabalhos e registrar trabalhadores. Para obter mais informações sobre cadeias de conexão, consulte 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")

Criar uma política de distribuição

O Job Router usa uma política de distribuição para decidir como os Trabalhadores serão notificados sobre os Trabalhos disponíveis e o tempo de vida para as notificações, conhecido como Ofertas. Crie a política especificando o distribution_policy_id, um nome, um valor offer_expires_after_seconds e um modo de distribuição.

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

Criar uma fila

Crie a Fila especificando uma ID, um nome e forneça a ID do objeto de Política de Distribuição que você criou acima.

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

Enviar uma vaga

Agora, podemos enviar um trabalho diretamente para essa fila, com um seletor de trabalhador que exige que o trabalhador tenha o rótulo Some-Skill maior que 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
        )
    ])

Criar um trabalhador

Agora, criamos um trabalhador para receber o trabalho dessa fila, com uma etiqueta igual Some-Skill a 11 e capacidade em 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
)

Receba uma oferta

Devemos obter um RouterWorkerOfferIssued a partir da nossa subscrição da Grelha de Eventos. No entanto, também podemos esperar alguns segundos e, em seguida, consultar o trabalhador diretamente na API do JobRouter para ver se uma oferta foi emitida para ele.

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

Aceitar a oferta de emprego

Em seguida, o trabalhador pode aceitar a oferta de trabalho usando o SDK, que atribui o trabalho ao trabalhador.

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

Conclua o trabalho

Uma vez que o trabalhador tenha concluído o trabalho associado ao trabalho (por exemplo, concluído a chamada), concluímos o trabalho.

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

Fechar o trabalho

Quando o trabalhador estiver pronto para assumir novos empregos, o trabalhador deve fechar o trabalho. Opcionalmente, o trabalhador pode fornecer um código de disposição para indicar o resultado do trabalho.

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

Excluir o trabalho

Depois que o trabalho for fechado, podemos excluí-lo para que possamos recriá-lo com a mesma ID se executarmos este exemplo novamente

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

Executar o código

Para executar o código, certifique-se de que está no diretório onde router-quickstart.py se encontra o ficheiro.

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

Nota

Executar o aplicativo mais de uma vez fará com que um novo trabalho seja colocado na fila a cada vez. Isso pode fazer com que seja oferecido ao Trabalhador um Trabalho diferente daquele criado quando você executa o código acima. Como isso pode distorcer sua solicitação, considere excluir trabalhos na fila a cada vez. Consulte a documentação do SDK para gerenciar uma fila ou um trabalho.

Documentação de referência

Leia sobre o conjunto completo de recursos do Azure Communication Services Job Router a partir da referência do SDK do Python ou da referência da API REST.

Pré-requisitos

Código de exemplo

Você pode revisar e baixar o código de exemplo para este início rápido no GitHub.

Configuração

Criar uma nova aplicação Java

Em uma janela de console (como cmd, PowerShell ou Bash), use o comando abaixo para criar um novo aplicativo de console com o mvn nome router-quickstart. Este comando cria um projeto Java simples "Hello World" com um único arquivo de origem: App.java.

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

Inclua o pacote

Você precisará usar a biblioteca de cliente do Azure Communication Job Router para Java versão 1.0.0 ou superior.

Incluir o arquivo BOM

Inclua o azure-sdk-bom em seu projeto para depender da versão de disponibilidade geral (GA) da biblioteca. No trecho a seguir, substitua o espaço reservado {bom_version_to_target} pelo número da versão. Para saber mais sobre a lista técnica, consulte o Leiame da lista técnica do SDK do Azure.

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

e, em seguida, inclua a dependência direta na seção dependências sem a marca de versão.

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

Incluir dependência direta

Se você quiser depender de uma versão específica da biblioteca que não está presente na lista técnica, adicione a dependência direta ao seu projeto da seguinte maneira.

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

Configurar a estrutura do aplicativo

Vá para o diretório /src/main/java/com/communication/quickstart e abra o App.java arquivo. Adicione o seguinte código:

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

Inicializar o cliente do Job Router e o cliente de administração

Os clientes do Job Router podem ser autenticados usando sua cadeia de conexão adquirida de um recurso dos Serviços de Comunicação do Azure no portal do Azure. Geramos um cliente e um cliente de administração para interagir com o serviço Job Router. O cliente admin é usado para provisionar filas e políticas, enquanto o cliente é usado para enviar trabalhos e registrar trabalhadores. Para obter mais informações sobre cadeias de conexão, consulte 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();

Criar uma política de distribuição

O Job Router usa uma política de distribuição para decidir como os Trabalhadores serão notificados sobre os Trabalhos disponíveis e o tempo de vida para as notificações, conhecido como Ofertas. Crie a política especificando o ID, um nome, um offerExpiresAfter e um modo de distribuição.

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

Criar uma fila

Crie a Fila especificando uma ID, um nome e forneça a ID do objeto de Política de Distribuição que você criou acima.

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

Enviar uma vaga

Agora, podemos enviar um trabalho diretamente para essa fila, com um seletor de trabalhador que exige que o trabalhador tenha o rótulo Some-Skill maior que 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)))));

Criar um trabalhador

Agora, criamos um trabalhador para receber o trabalho dessa fila, com uma etiqueta igual Some-Skill a 11 e capacidade em 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))));

Receba uma oferta

Devemos obter um RouterWorkerOfferIssued a partir da nossa subscrição da Grelha de Eventos. No entanto, também podemos esperar alguns segundos e, em seguida, consultar o trabalhador diretamente na API do JobRouter para ver se uma oferta foi emitida para ele.

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

Aceitar a oferta de emprego

Em seguida, o trabalhador pode aceitar a oferta de trabalho usando o SDK, que atribui o trabalho ao trabalhador.

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

Conclua o trabalho

Uma vez que o trabalhador tenha concluído o trabalho associado ao trabalho (por exemplo, concluído a chamada), concluímos o trabalho.

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

Fechar o trabalho

Quando o trabalhador estiver pronto para assumir novos empregos, o trabalhador deve fechar o trabalho.

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

Excluir o trabalho

Depois que o trabalho for fechado, podemos excluí-lo para que possamos recriá-lo com a mesma ID se executarmos este exemplo novamente

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

Executar o código

Para executar o código, vá para o diretório que contém o arquivo e compile o pom.xml programa.

mvn compile

Em seguida, compile o pacote:

mvn package

Executar o aplicativo

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

A saída esperada descreve cada ação concluída:

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

Nota

Executar o aplicativo mais de uma vez fará com que um novo trabalho seja colocado na fila a cada vez. Isso pode fazer com que seja oferecido ao Trabalhador um Trabalho diferente daquele criado quando você executa o código acima. Como isso pode distorcer sua solicitação, considere excluir trabalhos na fila a cada vez. Consulte a documentação do SDK para gerenciar uma fila ou um trabalho.

Documentação de referência

Leia sobre o conjunto completo de recursos do Azure Communication Services Job Router a partir da referência do Java SDK ou da referência da API REST.

Passos Seguintes

Explore os tutoriais de instruções do Job Router