Compartilhar via

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

  • Artigo

Comece a usar o Roteador de Trabalhos dos Serviços de Comunicação do Azure configurando seu cliente e a funcionalidade principal, como filas, políticas, funções de trabalho e trabalhos. Para saber mais sobre os conceitos do Roteador de Trabalho, visite a documentação conceitual do Roteador de Trabalho

Pré-requisitos

Código de exemplo

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

Configurando

Criar um aplicativo em C#

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

dotnet new console -o JobRouterQuickstart

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

cd JobRouterQuickstart
dotnet build

Instalar o pacote

Instale a biblioteca de clientes do Roteador de Trabalhos de Comunicação do Azure para .NET com NuGet:

dotnet add package Azure.Communication.JobRouter

Você precisará usar a biblioteca de clientes do Roteador de Trabalho de Comunicação do Azure para .NET versão 1.0.0 ou superior.

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

using Azure.Communication.JobRouter;

Inicializar o cliente do Roteador de Trabalhos e o cliente de administração

Os clientes do Roteador de Trabalho podem ser autenticados usando a cadeia de conexão adquirida do 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 do Roteador de Trabalhos. O cliente administrador é usado para provisionar filas e políticas, enquanto o cliente é usado para enviar trabalhos e registrar funções de trabalho. 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 Roteador de Trabalho usa uma política de distribuição para decidir como os as funções de trabalho serão notificadas sobre os trabalhos disponíveis e a vida útil das notificações, conhecidas como Ofertas. Crie a política especificando a 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 um trabalho

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 trabalho dessa fila, com o rótulo Some-Skill igual a 11 e a 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
    });

Receber uma oferta

Devemos obter um RouterWorkerOfferIssued da assinatura da Grade de Eventos. No entanto, também podemos aguardar alguns segundos e, em seguida, consultar o trabalhador diretamente na API do JobRouter para ver se uma oferta foi emitida para ela.

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 trabalho

Em seguida, o trabalhador pode aceitar a oferta de trabalho usando o SDK, que atribui o trabalho à função de trabalho.

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

Concluir o trabalho

Depois que o trabalhador tiver concluído o trabalho associado ao cargo (por exemplo, a chamada foi concluída), concluiremos 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 trabalhos, o trabalhador deverá 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, poderemos excluir o trabalho para que possamos recriar o trabalho 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

Observação

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 à função de trabalho um trabalho diferente daquele criado quando você executou o código acima. Como isso pode distorcer a solicitação, considere excluir os trabalhos da fila a cada vez. Veja a documentação do SDK para gerenciar uma fila ou um trabalho.

Documentação de referência

Leia sobre o conjunto completo de funcionalidades do Roteador de Trabalhos dos Serviços de Comunicação do Azure na referência do SDK do .NET ou 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.

Configurando

Criar um aplicativo Web

Em uma janela do console ou terminal, crie uma 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 no qual você adicionará o código para este início rápido.

Instalar os pacotes

Você precisará usar a biblioteca de clientes do Roteador de Trabalho de Comunicação do Azure para JavaScript versão 1.0.0 ou superior.

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

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

Configurar o framework de aplicativos

No arquivo index.js, adicione o código a seguir. Adicionaremos o código para o início rápido na função 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);
})

Inicializar o cliente do Roteador de Trabalhos

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

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

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 Roteador de Trabalhos usa uma política de distribuição para decidir como os trabalhadores serão notificados sobre os trabalhos disponíveis e a vida útil das notificações, conhecidas como Ofertas. Crie a política especificando a 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 um trabalho

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 trabalho dessa fila, com o rótulo Some-Skill igual a 11 e a 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"
});

Receber uma oferta

Devemos obter um RouterWorkerOfferIssued da assinatura da Grade de Eventos. No entanto, também podemos aguardar alguns segundos e, em seguida, consultar o trabalhador diretamente na API do JobRouter para ver se uma oferta foi emitida para ela.

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 trabalho

Em seguida, o trabalhador pode aceitar a oferta de trabalho usando o SDK, que atribui o trabalho à função de trabalho.

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

Concluir o trabalho

Depois que o trabalhador tiver concluído o trabalho associado ao cargo (por exemplo, a chamada foi concluída), concluiremos 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 trabalhos, o trabalhador deverá 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, poderemos excluir o trabalho para que possamos recriar o trabalho 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, verifique se você está no diretório onde está o arquivo index.js.

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

Observação

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 à função de trabalho um trabalho diferente daquele criado quando você executou o código acima. Como isso pode distorcer a solicitação, considere excluir os trabalhos da fila a cada vez. Veja a documentação do SDK para gerenciar uma fila ou um trabalho.

Documentação de referência

Leia sobre o conjunto completo de funcionalidades do Roteador de Trabalhos dos Serviços de Comunicação do Azure na referência do SDK do 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.

Configurando

Criar um novo aplicativo Python

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

mkdir jobrouter-quickstart && cd jobrouter-quickstart

Instalar o pacote

Você precisará usar a biblioteca de clientes do Roteador de Trabalho de Comunicação do Azure para Python versão 1.0.0 ou superior.

No prompt de console, execute o seguinte comando:

pip install azure-communication-jobrouter

Configurar o framework de aplicativos

Crie um 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 Roteador de Trabalhos e o cliente de administração

Os clientes do Roteador de Trabalho podem ser autenticados usando a cadeia de conexão adquirida do 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 do Roteador de Trabalhos. O cliente administrador é usado para provisionar filas e políticas, enquanto o cliente é usado para enviar trabalhos e registrar funções de trabalho. 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 Roteador de Trabalho usa uma política de distribuição para decidir como os as funções de trabalho serão notificadas sobre os trabalhos disponíveis e a vida útil das notificações, conhecidas 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 um trabalho

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 trabalho dessa fila, com o rótulo Some-Skill igual a 11 e a 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
)

Receber uma oferta

Devemos obter um RouterWorkerOfferIssued da assinatura da Grade de Eventos. No entanto, também podemos aguardar alguns segundos e, em seguida, consultar o trabalhador diretamente na API do JobRouter para ver se uma oferta foi emitida para ela.

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 trabalho

Em seguida, o trabalhador pode aceitar a oferta de trabalho usando o SDK, que atribui o trabalho à função de trabalho.

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

Concluir o trabalho

Depois que o trabalhador tiver concluído o trabalho associado ao cargo (por exemplo, a chamada foi concluída), concluiremos 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 trabalhos, o trabalhador deverá 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, poderemos excluir o trabalho para que possamos recriar o trabalho 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, verifique se você está no diretório onde está o arquivo router-quickstart.py.

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

Observação

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 à função de trabalho um trabalho diferente daquele criado quando você executou o código acima. Como isso pode distorcer a solicitação, considere excluir os trabalhos da fila a cada vez. Veja a documentação do SDK para gerenciar uma fila ou um trabalho.

Documentação de referência

Leia sobre o conjunto completo de funcionalidades do Roteador de Trabalhos dos Serviços de Comunicação do Azure na referência do SDK do Python 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.

Configurando

Criar um aplicativo Java

Em uma janela de console, como cmd, PowerShell ou Bash, use o comando mvn abaixo para criar um aplicativo de console com o nome router-quickstart. Esse comando cria um projeto simples em Java do tipo "Olá, Mundo" com um arquivo de origem único: App.java.

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

Incluir o pacote

Você precisará usar a biblioteca de clientes do Roteador de Trabalho de Comunicação do Azure para Java versão 1.0.0 ou superior.

Incluir o arquivo da BOM

Inclua o azure-sdk-bom ao seu projeto para assumir a dependência da versão de GA (disponibilidade geral) da biblioteca. No trecho a seguir, substitua o espaço reservado {bom_version_to_target} pelo número de versão. Para saber mais sobre o BOM, confira o Leiame do BOM 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>

Depois, inclua a dependência direta na seção de 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 assumir a dependência de uma versão específica da biblioteca que não está presente no BOM, adicione a dependência direta ao seu projeto como descrito a seguir.

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

Configurar o framework de aplicativos

Vá para o diretório /src/main/java/com/communication/quickstart e abra o arquivo App.java. Adicione os códigos a seguir:

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 Roteador de Trabalhos e o cliente de administração

Os clientes do Roteador de Trabalho podem ser autenticados usando a cadeia de conexão adquirida do 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 do Roteador de Trabalhos. O cliente administrador é usado para provisionar filas e políticas, enquanto o cliente é usado para enviar trabalhos e registrar funções de trabalho. 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 Roteador de Trabalho usa uma política de distribuição para decidir como os as funções de trabalho serão notificadas sobre os trabalhos disponíveis e a vida útil das notificações, conhecidas como Ofertas. Crie a política especificando a 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 um trabalho

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 trabalho dessa fila, com o rótulo Some-Skill igual a 11 e a 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))));

Receber uma oferta

Devemos obter um RouterWorkerOfferIssued da assinatura da Grade de Eventos. No entanto, também podemos aguardar alguns segundos e, em seguida, consultar o trabalhador diretamente na API do JobRouter para ver se uma oferta foi emitida para ela.

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 trabalho

Em seguida, o trabalhador pode aceitar a oferta de trabalho usando o SDK, que atribui o trabalho à função de trabalho.

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

Concluir o trabalho

Depois que o trabalhador tiver concluído o trabalho associado ao cargo (por exemplo, a chamada foi concluída), concluiremos 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 trabalhos, o trabalhador deverá 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, poderemos excluir o trabalho para que possamos recriar o trabalho 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 pom.xml e compile o programa.

mvn compile

Então, crie 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

Observação

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 à função de trabalho um trabalho diferente daquele criado quando você executou o código acima. Como isso pode distorcer a solicitação, considere excluir os trabalhos da fila a cada vez. Veja a documentação do SDK para gerenciar uma fila ou um trabalho.

Documentação de referência

Leia sobre o conjunto completo de funcionalidades do Roteador de Trabalhos dos Serviços de Comunicação do Azure na referência do SDK do Java ou referência da API REST.

Próximas etapas

Explorar tutoriais de instruções do Roteador de Trabalhos