Regionalização e residência de dados

O Dialogflow oferece residência de dados para manter os dados em repouso fisicamente em um local ou região geográfica. Quando uma região é especificada, os dados em repouso não são replicados fora da região. O preço é o mesmo para todas as regiões.

As regiões são usadas pelos seguintes motivos:

• Seu sistema pode ter requisitos regulatórios ou de políticas que regem o local dos dados.
• Suas latências de rede podem ser melhoradas quando os dados estão na mesma região que seus clientes. Por exemplo, se os clientes do Reino Unido usarem europe-west2, eles poderão esperar uma latência melhor.

Observação: a regionalização e a residência de dados do Dialogflow não se aplicam a dados em uso ou a dados em trânsito.

Dados em repouso

Todos os dados do usuário e do usuário final do Dialogflow estão incluídos nos dados em repouso (em inglês). Exemplo:

• Todos os recursos do agente definidos com console ou API (intents, entidades etc.)
• Todas as configurações do agente definidas com o console ou a API
• Histórico de consultas
• Resultados da validação
• Tarefas de criação de modelos
• Tarefas de treinamento
• Tarefas de operação de longa duração

Regiões disponíveis

O Dialogflow oferece as seguintes regiões:

Grupos de países	Localização geográfica	ID da região
Europa	Bélgica	europe-west1
Europa	Londres	europe-west2
Ásia-Pacífico	Sydney	australia-southeast1
Ásia-Pacífico	Tóquio	asia-northeast1
Global	O serviço do Dialogflow é global, mas os dados em repouso ficam armazenados nos EUA	global (preferencial), us (descontinuado) ou nenhuma região (padrão)

Observação: as chamadas para a região global podem ter uma latência maior quando chamadas de fora dos EUA. Se possível, prefira uma região mais específica mais próxima dos seus serviços e usuários finais.

Selecione uma região com o console

A área superior esquerda do Console do Dialogflow ES tem uma lista suspensa para a seleção de região. Cada agente tem uma região imutável especificada na criação. Ao selecionar uma região no console, é possível listar ou criar agentes somente para a região selecionada. A região padrão é us.

Observação :é possível criar um agente por região para um projeto do Google Cloud.

Selecionar uma região com a API

Se o agente foi criado em uma região não padrão, é preciso especificá-la ao chamar a API para solicitações de tempo de design ou tempo de execução.

Para fornecer uma região, ofereça um parâmetro location às solicitações de API. Para chamadas REST, siga estas orientações:

• Forneça o parâmetro de caminho do URL location.
• Use o nome de host específico da região no formato REGION_ID-dialogflow.googleapis.com. Por exemplo, asia-northeast1-dialogflow.googleapis.com. Se a região especificada no nome do host não corresponder à especificada no caminho do URL, a solicitação será rejeitada.

Para bibliotecas de cliente, consulte a documentação da biblioteca de cliente. Você precisa fazer o seguinte:

• Defina o endpoint do serviço do Dialogflow como:

  REGION_ID-dialogflow.googleapis.com:443
  

• Defina o nome da sessão como:

  projects/PROJECT_ID/locations/REGION_ID/agent/sessions/SESSION_ID
  

Exemplo:

REST

Antes de usar os dados da solicitação, faça as substituições a seguir:

• PROJECT_ID: o ID do projeto do Google Cloud
• REGION_ID: um ID de região, por exemplo: europe-west2
• SESSION_ID: um código da sessão.

Método HTTP e URL:

POST https://REGION_ID-dialogflow.googleapis.com/v2/projects/PROJECT_ID/locations/REGION_ID/agent/sessions/SESSION_ID:detectIntent

Corpo JSON da solicitação:

{
  "query_input": {
    "text": {
      "text": "I want a pony.",
      "language_code": "en-US"
    }
  }
}

Para enviar a solicitação, expanda uma destas opções:

curl (Linux, macOS ou Cloud Shell)

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que faz login automaticamente na CLI gcloud. É possível verificar a conta ativa atual executando gcloud auth list.

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "x-goog-user-project: PROJECT_ID" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://REGION_ID-dialogflow.googleapis.com/v2/projects/PROJECT_ID/locations/REGION_ID/agent/sessions/SESSION_ID:detectIntent"

PowerShell (Windows)

Observação: O comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login . É possível verificar a conta ativa atual executando gcloud auth list.

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "PROJECT_ID" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://REGION_ID-dialogflow.googleapis.com/v2/projects/PROJECT_ID/locations/REGION_ID/agent/sessions/SESSION_ID:detectIntent" | Select-Object -Expand Content

 

Java

Para autenticar no Dialogflow, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

import com.google.api.gax.rpc.ApiException;
import com.google.cloud.dialogflow.v2beta1.DetectIntentResponse;
import com.google.cloud.dialogflow.v2beta1.QueryInput;
import com.google.cloud.dialogflow.v2beta1.QueryResult;
import com.google.cloud.dialogflow.v2beta1.SessionName;
import com.google.cloud.dialogflow.v2beta1.SessionsClient;
import com.google.cloud.dialogflow.v2beta1.SessionsSettings;
import com.google.cloud.dialogflow.v2beta1.TextInput;
import com.google.common.collect.Maps;
import java.io.IOException;
import java.util.List;
import java.util.Map;

public class DetectIntentWithLocation {

  // DialogFlow API Detect Intent sample with text inputs.
  public static Map<String, QueryResult> detectIntentWithLocation(
      String projectId,
      String locationId,
      List<String> texts,
      String sessionId,
      String languageCode)
      throws IOException, ApiException {
    SessionsSettings sessionsSettings =
        SessionsSettings.newBuilder()
            .setEndpoint(locationId + "-dialogflow.googleapis.com:443")
            .build();
    Map<String, QueryResult> queryResults = Maps.newHashMap();
    // Instantiates a client
    try (SessionsClient sessionsClient = SessionsClient.create(sessionsSettings)) {
      // Set the session name using the projectId (my-project-id), locationId and sessionId (UUID)
      SessionName session =
          SessionName.ofProjectLocationSessionName(projectId, locationId, sessionId);
      System.out.println("Session Path: " + session.toString());

      // Detect intents for each text input
      for (String text : texts) {
        // Set the text (hello) and language code (en-US) for the query
        TextInput.Builder textInput =
            TextInput.newBuilder().setText(text).setLanguageCode(languageCode);

        // Build the query with the TextInput
        QueryInput queryInput = QueryInput.newBuilder().setText(textInput).build();

        // Performs the detect intent request
        DetectIntentResponse response = sessionsClient.detectIntent(session, queryInput);

        // Display the query result
        QueryResult queryResult = response.getQueryResult();

        System.out.println("====================");
        System.out.format("Query Text: '%s'\n", queryResult.getQueryText());
        System.out.format(
            "Detected Intent: %s (confidence: %f)\n",
            queryResult.getIntent().getDisplayName(), queryResult.getIntentDetectionConfidence());
        System.out.format(
            "Fulfillment Text: '%s'\n",
            queryResult.getFulfillmentMessagesCount() > 0
                ? queryResult.getFulfillmentMessages(0).getText()
                : "Triggered Default Fallback Intent");

        queryResults.put(text, queryResult);
      }
    }
    return queryResults;
  }
}

Python

Para autenticar no Dialogflow, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

def detect_intent_texts_with_location(
    project_id, location_id, session_id, texts, language_code
):
    """Returns the result of detect intent with texts as inputs.

    Using the same `session_id` between requests allows continuation
    of the conversation."""
    from google.cloud import dialogflow

    session_client = dialogflow.SessionsClient(
        client_options={"api_endpoint": f"{location_id}-dialogflow.googleapis.com"}
    )

    session = (
        f"projects/{project_id}/locations/{location_id}/agent/sessions/{session_id}"
    )
    print(f"Session path: {session}\n")

    for text in texts:
        text_input = dialogflow.TextInput(text=text, language_code=language_code)

        query_input = dialogflow.QueryInput(text=text_input)

        response = session_client.detect_intent(
            request={"session": session, "query_input": query_input}
        )

        print("=" * 20)
        print(f"Query text: {response.query_result.query_text}")
        print(
            f"Detected intent: {response.query_result.intent.display_name} (confidence: {response.query_result.intent_detection_confidence,})\n"
        )
        print(f"Fulfillment text: {response.query_result.fulfillment_text}\n")

Outras linguagens

C#: Siga as Instruções de configuração do C# na página das bibliotecas de cliente e acesse a Documentação de referência do Dialogflow para .NET.

PHP: Siga as Instruções de configuração do PHP na página das bibliotecas de cliente e acesse a Documentação de referência do Dialogflow para PHP.

Ruby: Siga as Instruções de configuração do Ruby na página das bibliotecas de cliente e acesse a Documentação de referência do Dialogflow para Ruby.

Cuidado: conforme descrito na documentação de configuração, use o ambiente GOOGLE_APPLICATION_CREDENTIALS. para fornecer credenciais às suas bibliotecas de cliente. No entanto, se você precisar fornecer manualmente um arquivo de credenciais no código, deverá realizar uma etapa extra ao chamar um endpoint regionalizado. Defina o escopo como https://www.googleapis.com/auth/cloud-platform ao gerar suas credenciais de autenticação. Por exemplo, isso é feito em Java ao criar um objeto GoogleCredentials:

GoogleCredentials.fromStream(new FileInputStream("credential_file"))
  .createScoped("https://www.googleapis.com/auth/cloud-platform")
  

Cloud Logging

Consulte o Guia do Cloud Logging para controlar a região em que os registros são armazenados.

Limitações

Quando uma região não padrão é selecionada no Console do Dialogflow, os seguintes recursos não estão disponíveis:

• Integrações
• Conectores de conhecimento
• Prebuilt Agents
• Small Talk
• Ferramenta de treinamento

O APIs Explorer, encontrado em muitos documentos de referência REST, só é compatível com a região global das chamadas de API.