Esta página foi traduzida pela API Cloud Translation.
Switch to English

Como migrar para o Translation - Advanced

Veja nesta página as principais diferenças entre o Cloud Translation - Basic e o Advanced. Encontre também alguns exemplos de código que ajudarão você a migrar seu aplicativo. Se quiser ver somente os recursos da versão Advanced, como os glossários, consulte o artigo Introdução ao Cloud Translation - Advanced.

O Cloud Translation - Advanced é compatível com todos os recursos e modelos disponíveis no Basic. No entanto, as bibliotecas de cliente não são compatíveis com versões anteriores à integração do cliente. Em outras palavras, você precisa planejar a migração dos seus aplicativos para aproveitar os recursos da versão Advanced.

Se você estiver planejando um novo projeto, crie seu aplicativo com o Cloud Translation - Advanced para aproveitar os novos recursos e as melhorias nos serviços. O Cloud Translation - Basic continua disponível, mas não é compatível com novos recursos, como glossários, tradução em lote ou seleção de modelos.

Principais diferenças entre o Basic e o Advanced

Há diversas diferenças entre o Cloud Translation - Advanced e o Basic.

Contas de serviço

O Cloud Translation - Basic permite o uso de chaves de API para fazer a autenticação para o Translation.

O Cloud Translation - Advanced tem funcionalidades que exigem recursos gerenciados pelo cliente, como o gerenciamento de permissões e papéis do IAM. Por essa razão, não é possível usar chaves de API para autenticar para o serviço. Em vez disso, é preciso usar contas de serviço ao autenticar para o Translation.

Papéis do IAM

As contas de serviço para autenticação para o Translation anteriormente não precisavam ter papéis do IAM especializados aplicados a elas.

Com o Cloud Translation - Advanced, você tem acesso a vários papéis do IAM que podem ser atribuídos à sua conta de serviço para acessar recursos específicos no seu projeto. Por exemplo, se você quiser usar sua conta de serviço para traduzir texto, atribua o papel roles/cloudtranslate.user a ela. Consulte Introdução ao Cloud Translation - Advanced para mais informações sobre os papéis do IAM disponíveis.

Recursos, projetos e locais

Ao fazer solicitações ao Cloud Translation - Advanced, você precisa fornecer o nome dos recursos que quer usar. Um recurso geralmente é um nome qualificado que inclui o nome do projeto e o local dele, como o nome de um modelo do AutoML.

Por exemplo, se o projeto do Google Cloud tiver o nome my-project e o local do recurso for us-central1, o nome completo dos seus recursos poderá ser semelhante a este:

projects/my-project/locations/us-central1/...

Use também o nome do local nos URLs para os quais envia solicitações REST. O local especifica onde a solicitação é executada. Por exemplo, o URL para o qual você envia uma solicitação getSupportedLanguages pode ser semelhante ao seguinte:

https://translation.googleapis.com/v3/projects/my-project/locations/us-central1/supportedLanguages

Modelos de tradução

Ao solicitar uma tradução do Cloud Translation - Advanced, você pode usar um modelo personalizado do AutoML Translation ou os modelos gerais, a tradução automática neural (NMT, na sigla em inglês) e a tradução automática baseada em frases (SPMT, na sigla em inglês).

Para fazer a integração com modelos do AutoML, as contas de serviço usadas para solicitações de tradução precisam ter as permissões apropriadas do IAM para acessar os modelos gerais e de AutoML, definidos no seu projeto ou em outro.

Para mais informações sobre a seleção de um modelo de tradução, consulte Como traduzir textos com o Cloud Translation - Advanced.

Limite de conteúdo por solicitação

A API Cloud Translation é otimizada para tradução de solicitações menores. O tamanho máximo recomendado para cada solicitação é de 5.000 caracteres (pontos de código). No entanto, quanto mais você incluir, maior será a latência de resposta. Para a Cloud Translation - Advanced, o número máximo de pontos de código para uma única solicitação é de 30.000. O tamanho máximo para solicitações da Cloud Translation - Basic é de 100.000 bytes.

A API Cloud Translation rejeitará solicitações maiores que o limite e enviará um erro 400 INVALID_ARGUMENT, independentemente da cota disponível.

Para mais informações sobre cotas e limites, consulte esta página.

Consulte as etapas a seguir para atualizar seu aplicativo do Cloud Translation - Basic para o Advanced.

  1. Faça um inventário dos seus projetos, aplicativos e usuários do Google Cloud que acessam a API Basic.
  2. Configure contas de serviço e autenticação para seu aplicativo. Consulte o material sobre os papéis do IAM, com atenção especial aos papéis do AutoML, Cloud Storage e Cloud Translation.
  3. Ative o Cloud Translation - Advanced para seu projeto. Se você usa modelos AutoML com a versão Advanced, também precisa ativar o AutoML.
  4. Use os métodos e as bibliotecas de cliente do Cloud Translation - Advanced. Para solicitações do Cloud Translation - Advanced, inclua o número (ou ID) do projeto e o local do projeto, que costuma ser global ou us-central1. Saiba mais em Diferenças entre API e bibliotecas de cliente.
  5. Atualize seu fluxo de trabalho de aplicativo ou de tradução para aproveitar os novos recursos. Para integrar seu aplicativo com o AutoML e o Cloud Storage, é preciso aplicar os papéis e permissões de IAM apropriados às suas contas de serviço para que eles possam acessar seus recursos.
  6. Verifique se o tamanho das suas solicitações de tradução para o Cloud Translation - Advanced não excede o limite.
  7. Planeje seu monitoramento de cota de solicitação de tradução. As duas versões da API compartilham as mesmas cotas diárias e mensais.
  8. Analise as possíveis alterações no faturamento.

Diferenças de API e bibliotecas de cliente

As seções a seguir descrevem as diferenças específicas entre fazer chamadas com o Cloud Translation - Basic e com o Advanced.

Como importar as bibliotecas de cliente do Cloud Translation - Advanced

Para importar as bibliotecas de cliente do Cloud Translation - Advanced, use o código a seguir.

C#

nuget install Google.Cloud.Translate.V3 -Pre

Go

go get -u cloud.google.com/go/translate/apiv3

Java

Se você estiver usando o Maven, adicione o código abaixo ao arquivo pom.xml. Para mais informações sobre BOMs, consulte BOM das bibliotecas do Google Cloud Platform.

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>com.google.cloud</groupId>
      <artifactId>libraries-bom</artifactId>
      <version>16.1.0</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

<dependencies>
  <dependency>
    <groupId>com.google.cloud</groupId>
    <artifactId>google-cloud-translate</artifactId>
  </dependency>
</dependencies>

Se você estiver usando o Gradle, adicione isto às dependências:

compile 'com.google.cloud:google-cloud-translate:1.95.4'

Se você estiver usando o sbt, adicione o seguinte às suas dependências:

libraryDependencies += "com.google.cloud" % "google-cloud-translate" % "1.95.4"

Caso você esteja usando o IntelliJ ou o Eclipse, poderá adicionar bibliotecas de cliente ao seu projeto usando estes plug-ins de ambiente de desenvolvimento integrado:

Os plug-ins também oferecem outras funcionalidades, como gerenciamento de chaves de contas de serviço. Consulte a documentação de cada plug-in para mais detalhes.

Node.js

Para mais informações sobre a configuração do ambiente de desenvolvimento do Node.js, consulte o Guia de configuração do ambiente de desenvolvimento do Node.js.

npm install --save @google-cloud/translate

PHP

composer require google/cloud-translate

Python

Para mais informações sobre a configuração do ambiente de desenvolvimento do Python, consulte o Guia de configuração do ambiente de desenvolvimento do Python.

pip install --upgrade google-cloud-translate

Ruby

Consulte o Guia de configuração do ambiente para desenvolvedores do Ruby para mais informações sobre esse assunto.

gem install google-cloud-translate

Como traduzir textos

No Cloud Translation - Basic, use o seguinte código para enviar uma solicitação de tradução para a API:

REST e linha de comando

Método HTTP e URL: 

POST https://translation.googleapis.com/language/translate/v2

Corpo JSON da solicitação:

{
  "q": ["Hello world", "My name is Jeff"],
  "target": "de"
}

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

curl

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

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
https://translation.googleapis.com/language/translate/v2

PowerShell

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

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
  -Method POST `
  -Headers $headers `
  -ContentType: "application/json; charset=utf-8" `
  -InFile request.json `
  -Uri "https://translation.googleapis.com/language/translate/v2
" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante a esta:

{
  "data": {
    "translations": [
      {
        "translatedText": "Hallo Welt",
        "detectedSourceLanguage": "en"
      },
      {
        "translatedText": "Mein Name ist Jeff",
        "detectedSourceLanguage": "en"
      }
    ]
  }
}

C#

Antes de testar esta amostra, siga as instruções de configuração para C# no Guia de início rápido do Translation: como usar bibliotecas de cliente. Saiba mais na documentação de referência da API Translation para C#. 


using Google.Cloud.Translation.V2;
using System;

public partial class TranslateSample
{
    public string TranslateText()
    {
        Console.OutputEncoding = System.Text.Encoding.UTF8;
        TranslationClient client = TranslationClient.Create();
        var response = client.TranslateText(
            text: "Hello World.",
            targetLanguage: "ru",  // Russian
            sourceLanguage: "en");  // English
        Console.WriteLine(response.TranslatedText);
        return response.TranslatedText;
    }
}

Go

Antes de testar esta amostra, siga as instruções de configuração para Go no Guia de início rápido do Translation: como usar bibliotecas de cliente. Saiba mais na documentação de referência da API Translation para Go. 

import (
	"context"
	"fmt"

	"cloud.google.com/go/translate"
	"golang.org/x/text/language"
)

func translateText(targetLanguage, text string) (string, error) {
	// text := "The Go Gopher is cute"
	ctx := context.Background()

	lang, err := language.Parse(targetLanguage)
	if err != nil {
		return "", fmt.Errorf("language.Parse: %v", err)
	}

	client, err := translate.NewClient(ctx)
	if err != nil {
		return "", err
	}
	defer client.Close()

	resp, err := client.Translate(ctx, []string{text}, lang, nil)
	if err != nil {
		return "", fmt.Errorf("Translate: %v", err)
	}
	if len(resp) == 0 {
		return "", fmt.Errorf("Translate returned empty response to text: %s", text)
	}
	return resp[0].Text, nil
}

Java

Antes de testar esta amostra, siga as instruções de configuração para Java no Guia de início rápido do Translation: como usar bibliotecas de cliente. Saiba mais na documentação de referência da API Translation para Java. 

// TODO(developer): Uncomment these lines.
// import com.google.cloud.translate.*;
// Translate translate = TranslateOptions.getDefaultInstance().getService();

Translation translation = translate.translate("¡Hola Mundo!");
System.out.printf("Translated Text:\n\t%s\n", translation.getTranslatedText());

Node.js

Antes de testar esta amostra, siga as instruções de configuração para Node.js no Guia de início rápido do Translation: como usar bibliotecas de cliente. Saiba mais na documentação de referência da API Translation para Node.js. 

// Imports the Google Cloud client library
const {Translate} = require('@google-cloud/translate').v2;

// Creates a client
const translate = new Translate();

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const text = 'The text to translate, e.g. Hello, world!';
// const target = 'The target language, e.g. ru';

async function translateText() {
  // Translates the text into the target language. "text" can be a string for
  // translating a single piece of text, or an array of strings for translating
  // multiple texts.
  let [translations] = await translate.translate(text, target);
  translations = Array.isArray(translations) ? translations : [translations];
  console.log('Translations:');
  translations.forEach((translation, i) => {
    console.log(`${text[i]} => (${target}) ${translation}`);
  });
}

translateText();

PHP

Antes de testar esta amostra, siga as instruções de configuração para PHP no Guia de início rápido do Translation: como usar bibliotecas de cliente. Saiba mais na documentação de referência da API Translation para PHP. 

use Google\Cloud\Translate\TranslateClient;

/** Uncomment and populate these variables in your code */
// $text = 'The text to translate.';
// $targetLanguage = 'ja';  // Language to translate to

$translate = new TranslateClient();
$result = $translate->translate($text, [
    'target' => $targetLanguage,
]);
print("Source language: $result[source]\n");
print("Translation: $result[text]\n");

Python

Antes de testar esta amostra, siga as instruções de configuração para Python no Guia de início rápido do Translation: como usar bibliotecas de cliente. Saiba mais na documentação de referência da API Translation para Python. 

"""Translates text into the target language.

Target must be an ISO 639-1 language code.
See https://g.co/cloud/translate/v2/translate-reference#supported_languages
"""
import six
from google.cloud import translate_v2 as translate

translate_client = translate.Client()

if isinstance(text, six.binary_type):
    text = text.decode("utf-8")

# Text can also be a sequence of strings, in which case this method
# will return a sequence of results for each text.
result = translate_client.translate(text, target_language=target)

print(u"Text: {}".format(result["input"]))
print(u"Translation: {}".format(result["translatedText"]))
print(u"Detected source language: {}".format(result["detectedSourceLanguage"]))

Ruby

Antes de testar esta amostra, siga as instruções de configuração para Ruby no Guia de início rápido do Translation: como usar bibliotecas de cliente. Saiba mais na documentação de referência da API Translation para Ruby. 

# project_id    = "Your Google Cloud project ID"
# text          = "The text you would like to translate"
# language_code = "The ISO 639-1 code of language to translate to, eg. 'en'"

require "google/cloud/translate"

translate   = Google::Cloud::Translate.translation_v2_service project_id: project_id
translation = translate.translate text, to: language_code

puts "Translated '#{text}' to '#{translation.text.inspect}'"
puts "Original language: #{translation.from} translated to: #{translation.to}"

Com o Cloud Translation - Advanced, você precisa fornecer o número ou ID do projeto e o local dele (normalmente global ou us-central1) ao fazer uma solicitação translateText.

Também é possível especificar explicitamente um modelo de tradução ou um glossário para utilizar ao traduzir o texto e até mesmo pedir para receber a tradução da resposta como text/plain ou text/html. O valor padrão é text/html.

REST e linha de comando

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

  • project-number-or-id: pelo número ou o código do seu projeto do Google Cloud

Método HTTP e URL: 

POST https://translation.googleapis.com/v3/projects/project-number-or-id:translateText

Corpo JSON da solicitação:

{
  "sourceLanguageCode": "en",
  "targetLanguageCode": "ru",
  "contents": ["Dr. Watson, come here!", "Bring me some coffee!"]
}

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

curl

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

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
https://translation.googleapis.com/v3/projects/project-number-or-id:translateText

PowerShell

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

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
  -Method POST `
  -Headers $headers `
  -ContentType: "application/json; charset=utf-8" `
  -InFile request.json `
  -Uri "https://translation.googleapis.com/v3/projects/project-number-or-id:translateText
" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante a esta:

{
  "translations": [
    {
      "translatedText": "Доктор Ватсон, иди сюда!",
    },
    {
      "translatedText": "Принеси мне кофе!",
    }
  ]
}

C#

Antes de testar esta amostra, siga as instruções de configuração para C# no Guia de início rápido do Translation: como usar bibliotecas de cliente. Saiba mais na documentação de referência da API Translation para C#. 


using Google.Api.Gax.ResourceNames;
using Google.Cloud.Translate.V3;
using System;

namespace GoogleCloudSamples
{
    public static class TranslateText
    {
        /// <summary>
        /// Translates a given text to a target language.
        /// </summary>
        /// <param name="text">The content to translate.</param>
        /// <param name="targetLanguage">Required. Target language code.</param>
        /// <param name="projectId">Your Google Cloud Project ID.</param>
        public static void TranslateTextSample(string text = "[TEXT_TO_TRANSLATE]",
            string targetLanguage = "ja",
            string projectId = "[Google Cloud Project ID]")
        {
            TranslationServiceClient translationServiceClient = TranslationServiceClient.Create();
            TranslateTextRequest request = new TranslateTextRequest
            {
                Contents =
                {
                    // The content to translate.
                    text,
                },
                TargetLanguageCode = targetLanguage,
                ParentAsLocationName = new LocationName(projectId, "global"),
            };
            TranslateTextResponse response = translationServiceClient.TranslateText(request);
            // Display the translation for each input text provided
            foreach (Translation translation in response.Translations)
            {
                Console.WriteLine($"Translated text: {translation.TranslatedText}");
            }
        }
    }

Go

Antes de testar esta amostra, siga as instruções de configuração para Go no Guia de início rápido do Translation: como usar bibliotecas de cliente. Saiba mais na documentação de referência da API Translation para Go. 

import (
	"context"
	"fmt"
	"io"

	translate "cloud.google.com/go/translate/apiv3"
	translatepb "google.golang.org/genproto/googleapis/cloud/translate/v3"
)

// translateText translates input text and returns translated text.
func translateText(w io.Writer, projectID string, sourceLang string, targetLang string, text string) error {
	// projectID := "my-project-id"
	// sourceLang := "en-US"
	// targetLang := "fr"
	// text := "Text you wish to translate"

	ctx := context.Background()
	client, err := translate.NewTranslationClient(ctx)
	if err != nil {
		return fmt.Errorf("NewTranslationClient: %v", err)
	}
	defer client.Close()

	req := &translatepb.TranslateTextRequest{
		Parent:             fmt.Sprintf("projects/%s/locations/global", projectID),
		SourceLanguageCode: sourceLang,
		TargetLanguageCode: targetLang,
		MimeType:           "text/plain", // Mime types: "text/plain", "text/html"
		Contents:           []string{text},
	}

	resp, err := client.TranslateText(ctx, req)
	if err != nil {
		return fmt.Errorf("TranslateText: %v", err)
	}

	// Display the translation for each input text provided
	for _, translation := range resp.GetTranslations() {
		fmt.Fprintf(w, "Translated text: %v\n", translation.GetTranslatedText())
	}

	return nil
}

Java

Antes de testar esta amostra, siga as instruções de configuração para Java no Guia de início rápido do Translation: como usar bibliotecas de cliente. Saiba mais na documentação de referência da API Translation para Java. 

import com.google.cloud.translate.v3.LocationName;
import com.google.cloud.translate.v3.TranslateTextRequest;
import com.google.cloud.translate.v3.TranslateTextResponse;
import com.google.cloud.translate.v3.Translation;
import com.google.cloud.translate.v3.TranslationServiceClient;
import java.io.IOException;

public class TranslateText {

  public static void translateText() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR-PROJECT-ID";
    // Supported Languages: https://cloud.google.com/translate/docs/languages
    String targetLanguage = "your-target-language";
    String text = "your-text";
    translateText(projectId, targetLanguage, text);
  }

  // Translating Text
  public static void translateText(String projectId, String targetLanguage, String text)
      throws IOException {

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (TranslationServiceClient client = TranslationServiceClient.create()) {
      // Supported Locations: `global`, [glossary location], or [model location]
      // Glossaries must be hosted in `us-central1`
      // Custom Models must use the same location as your model. (us-central1)
      LocationName parent = LocationName.of(projectId, "global");

      // Supported Mime Types: https://cloud.google.com/translate/docs/supported-formats
      TranslateTextRequest request =
          TranslateTextRequest.newBuilder()
              .setParent(parent.toString())
              .setMimeType("text/plain")
              .setTargetLanguageCode(targetLanguage)
              .addContents(text)
              .build();

      TranslateTextResponse response = client.translateText(request);

      // Display the translation for each input text provided
      for (Translation translation : response.getTranslationsList()) {
        System.out.printf("Translated text: %s\n", translation.getTranslatedText());
      }
    }
  }
}

Node.js

Antes de testar esta amostra, siga as instruções de configuração para Node.js no Guia de início rápido do Translation: como usar bibliotecas de cliente. Saiba mais na documentação de referência da API Translation para Node.js. 

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'global';
// const text = 'text to translate';

// Imports the Google Cloud Translation library
const {TranslationServiceClient} = require('@google-cloud/translate');

// Instantiates a client
const translationClient = new TranslationServiceClient();
async function translateText() {
  // Construct request
  const request = {
    parent: `projects/${projectId}/locations/${location}`,
    contents: [text],
    mimeType: 'text/plain', // mime types: text/plain, text/html
    sourceLanguageCode: 'en',
    targetLanguageCode: 'sr-Latn',
  };

  try {
    // Run request
    const [response] = await translationClient.translateText(request);

    for (const translation of response.translations) {
      console.log(`Translation: ${translation.translatedText}`);
    }
  } catch (error) {
    console.error(error.details);
  }
}

translateText();

Python

Antes de testar esta amostra, siga as instruções de configuração para Python no Guia de início rápido do Translation: como usar bibliotecas de cliente. Saiba mais na documentação de referência da API Translation para Python. 

from google.cloud import translate

def translate_text(text="YOUR_TEXT_TO_TRANSLATE", project_id="YOUR_PROJECT_ID"):
    """Translating Text."""

    client = translate.TranslationServiceClient()

    location = "global"

    parent = f"projects/{project_id}/locations/{location}"

    # Detail on supported types can be found here:
    # https://cloud.google.com/translate/docs/supported-formats
    response = client.translate_text(
        request={
            "parent": parent,
            "contents": [text],
            "mime_type": "text/plain",  # mime types: text/plain, text/html
            "source_language_code": "en-US",
            "target_language_code": "fr",
        }
    )

    # Display the translation for each input text provided
    for translation in response.translations:
        print("Translated text: {}".format(translation.translated_text))

Ruby

Antes de testar esta amostra, siga as instruções de configuração para Ruby no Guia de início rápido do Translation: como usar bibliotecas de cliente. Saiba mais na documentação de referência da API Translation para Ruby. 

require "google/cloud/translate"

# project_id = "[Google Cloud Project ID]"
# location_id = "[LOCATION ID]"

# The content to translate in string format
contents = ["Hello, world!"]
# Required. The BCP-47 language code to use for translation.
target_language = "fr"

client = Google::Cloud::Translate.translation_service

parent = client.location_path project: project_id, location: location_id

response = client.translate_text parent:               parent,
                                 contents:             contents,
                                 target_language_code: target_language

# Display the translation for each input text provided
response.translations.each do |translation|
  puts "Translated text: #{translation.translated_text}"
end

Como descobrir idiomas compatíveis

Para ver a lista de idiomas compatíveis com a API no Cloud Translation - Basic, use o seguinte código:

REST e linha de comando

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

  • project-number-or-id: pelo número ou o código do seu projeto do Google Cloud

Método HTTP e URL: 

GET https://translation.googleapis.com/v3/projects/project-number-or-id/locations/global/supportedLanguages

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

curl

Execute o comando a seguir:

curl -X GET \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
https://translation.googleapis.com/v3/projects/project-number-or-id/locations/global/supportedLanguages

PowerShell

Execute o comando a seguir:

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
  -Method GET `
  -Headers $headers `
  -Uri "https://translation.googleapis.com/v3/projects/project-number-or-id/locations/global/supportedLanguages
" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante a esta:

{
  "languages": [
     "languageCode": "af",
      "supportSource": true,
      "supportTarget": true
    },
    {
      "languageCode": "am",
      "supportSource": true,
      "supportTarget": true
    },
    {
      "languageCode": "ar",
      "supportSource": true,
      "supportTarget": true
    },
    ....
    {
      "languageCode": "zu",
      "supportSource": true,
      "supportTarget": true
    }
   ]
}

A lista é classificada em ordem alfabética por código de idioma. Esta consulta retorna códigos ISO 639-1 para idiomas compatíveis. Alguns códigos de idioma também incluem o código do país, como zh-CN ou zh-TW. Por exemplo:

   {
      "languageCode": "zh-TW",
      "supportSource": true,
      "supportTarget": true
    },

Java

// TODO(developer): Uncomment these lines.
// import com.google.cloud.translate.*;
// Translate translate = TranslateOptions.getDefaultInstance().getService();

List<Language> languages = translate.listSupportedLanguages();

for (Language language : languages) {
  System.out.printf("Name: %s, Code: %s\n", language.getName(), language.getCode());
}

Node.js

// Imports the Google Cloud client library
const {Translate} = require('@google-cloud/translate').v2;

// Creates a client
const translate = new Translate();

async function listLanguages() {
  // Lists available translation language with their names in English (the default).
  const [languages] = await translate.getLanguages();

  console.log('Languages:');
  languages.forEach(language => console.log(language));
}

listLanguages();

Python

"""Lists all available languages."""
from google.cloud import translate_v2 as translate

translate_client = translate.Client()

results = translate_client.get_languages()

for language in results:
    print(u"{name} ({language})".format(**language))

Com o Cloud Translation - Advanced, você precisa fornecer o número ou ID do projeto e o local dele (normalmente global ou us-central1) ao fazer uma solicitação getSupportedLanguages.

REST e linha de comando

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

  • project-number-or-id: pelo número ou o código do seu projeto do Google Cloud

Método HTTP e URL: 

GET https://translation.googleapis.com/v3/projects/project-number-or-id/locations/global/supportedLanguages

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

curl

Execute o comando a seguir:

curl -X GET \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
https://translation.googleapis.com/v3/projects/project-number-or-id/locations/global/supportedLanguages

PowerShell

Execute o comando a seguir:

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
  -Method GET `
  -Headers $headers `
  -Uri "https://translation.googleapis.com/v3/projects/project-number-or-id/locations/global/supportedLanguages
" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante a esta:

{
  "languages": [
     "languageCode": "af",
      "supportSource": true,
      "supportTarget": true
    },
    {
      "languageCode": "am",
      "supportSource": true,
      "supportTarget": true
    },
    {
      "languageCode": "ar",
      "supportSource": true,
      "supportTarget": true
    },
    ....
    {
      "languageCode": "zu",
      "supportSource": true,
      "supportTarget": true
    }
   ]
}

A lista é classificada em ordem alfabética por código de idioma. Esta consulta retorna códigos ISO 639-1 para idiomas compatíveis. Alguns códigos de idioma também incluem o código do país, como zh-CN ou zh-TW. Por exemplo:

   {
      "languageCode": "zh-TW",
      "supportSource": true,
      "supportTarget": true
    },

C#

Antes de testar esta amostra, siga as instruções de configuração para C# no Guia de início rápido do Translation: como usar bibliotecas de cliente. Saiba mais na documentação de referência da API Translation para C#. 


using Google.Api.Gax.ResourceNames;
using Google.Cloud.Translate.V3;
using System;

namespace GoogleCloudSamples
{
    public static class GetSupportedLanguages
    {
        /// <summary>
        /// Getting a list of supported language codes
        /// </summary>
        /// <param name="projectId">Your Google Cloud Project ID.</param>
        public static void GetSupportedLanguagesSample(string projectId = "[Google Cloud Project ID]")
        {
            TranslationServiceClient translationServiceClient = TranslationServiceClient.Create();
            GetSupportedLanguagesRequest request = new GetSupportedLanguagesRequest
            {
                ParentAsLocationName = new LocationName(projectId, "global"),
            };
            SupportedLanguages response = translationServiceClient.GetSupportedLanguages(request);
            // List language codes of supported languages
            foreach (SupportedLanguage language in response.Languages)
            {
                Console.WriteLine($"Language Code: {language.LanguageCode}");
            }
        }
    }

Go

Antes de testar esta amostra, siga as instruções de configuração para Go no Guia de início rápido do Translation: como usar bibliotecas de cliente. Saiba mais na documentação de referência da API Translation para Go. 

import (
	"context"
	"fmt"
	"io"

	translate "cloud.google.com/go/translate/apiv3"
	translatepb "google.golang.org/genproto/googleapis/cloud/translate/v3"
)

// getSupportedLanguages gets a list of supported language codes.
func getSupportedLanguages(w io.Writer, projectID string) error {
	// projectID := "my-project-id"

	ctx := context.Background()
	client, err := translate.NewTranslationClient(ctx)
	if err != nil {
		return fmt.Errorf("NewTranslationClient: %v", err)
	}
	defer client.Close()

	req := &translatepb.GetSupportedLanguagesRequest{
		Parent: fmt.Sprintf("projects/%s/locations/global", projectID),
	}

	resp, err := client.GetSupportedLanguages(ctx, req)
	if err != nil {
		return fmt.Errorf("GetSupportedLanguages: %v", err)
	}

	// List language codes of supported languages
	fmt.Fprintf(w, "Supported languages:\n")
	for _, language := range resp.GetLanguages() {
		fmt.Fprintf(w, "Language code: %v\n", language.GetLanguageCode())
	}

	return nil
}

Java

Antes de testar esta amostra, siga as instruções de configuração para Java no Guia de início rápido do Translation: como usar bibliotecas de cliente. Saiba mais na documentação de referência da API Translation para Java. 

import com.google.cloud.translate.v3.GetSupportedLanguagesRequest;
import com.google.cloud.translate.v3.LocationName;
import com.google.cloud.translate.v3.SupportedLanguage;
import com.google.cloud.translate.v3.SupportedLanguages;
import com.google.cloud.translate.v3.TranslationServiceClient;
import java.io.IOException;

public class GetSupportedLanguages {

  public static void getSupportedLanguages() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR-PROJECT-ID";
    getSupportedLanguages(projectId);
  }

  // Getting a list of supported language codes
  public static void getSupportedLanguages(String projectId) throws IOException {

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (TranslationServiceClient client = TranslationServiceClient.create()) {
      // Supported Locations: `global`, [glossary location], or [model location]
      // Glossaries must be hosted in `us-central1`
      // Custom Models must use the same location as your model. (us-central1)
      LocationName parent = LocationName.of(projectId, "global");
      GetSupportedLanguagesRequest request =
          GetSupportedLanguagesRequest.newBuilder().setParent(parent.toString()).build();

      SupportedLanguages response = client.getSupportedLanguages(request);

      // List language codes of supported languages
      for (SupportedLanguage language : response.getLanguagesList()) {
        System.out.printf("Language Code: %s\n", language.getLanguageCode());
      }
    }
  }
}

Node.js

Antes de testar esta amostra, siga as instruções de configuração para Node.js no Guia de início rápido do Translation: como usar bibliotecas de cliente. Saiba mais na documentação de referência da API Translation para Node.js. 

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'global';

// Imports the Google Cloud Translation library
const {TranslationServiceClient} = require('@google-cloud/translate');

// Instantiates a client
const translationClient = new TranslationServiceClient();

async function getSupportedLanguages() {
  // Construct request
  const request = {
    parent: `projects/${projectId}/locations/${location}`,
  };

  try {
    // Get supported languages
    const [response] = await translationClient.getSupportedLanguages(request);

    for (const language of response.languages) {
      // Supported language code, generally consisting of its ISO 639-1 identifier, for
      // example, 'en', 'ja'. In certain cases, BCP-47 codes including language and
      // region identifiers are returned (for example, 'zh-TW' and 'zh-CN')
      console.log(`Language - Language Code: ${language.languageCode}`);
      // Human readable name of the language localized in the display language specified
      // in the request.
      console.log(`Language - Display Name: ${language.displayName}`);
      // Can be used as source language.
      console.log(`Language - Support Source: ${language.supportSource}`);
      // Can be used as target language.
      console.log(`Language - Support Target: ${language.supportTarget}`);
    }
  } catch (error) {
    console.error(error.details);
  }
}

getSupportedLanguages();

Python

Antes de testar esta amostra, siga as instruções de configuração para Python no Guia de início rápido do Translation: como usar bibliotecas de cliente. Saiba mais na documentação de referência da API Translation para Python. 

from google.cloud import translate

def get_supported_languages(project_id="YOUR_PROJECT_ID"):
    """Getting a list of supported language codes."""

    client = translate.TranslationServiceClient()

    parent = f"projects/{project_id}"

    # Supported language codes: https://cloud.google.com/translate/docs/languages
    response = client.get_supported_languages(parent=parent)

    # List language codes of supported languages.
    print("Supported Languages:")
    for language in response.languages:
        print("Language Code: {}".format(language.language_code))

Ruby

Antes de testar esta amostra, siga as instruções de configuração para Ruby no Guia de início rápido do Translation: como usar bibliotecas de cliente. Saiba mais na documentação de referência da API Translation para Ruby. 

require "google/cloud/translate"

# project_id = "[Google Cloud Project ID]"
# location_id = "[LOCATION ID]"

client = Google::Cloud::Translate.translation_service

parent = client.location_path project: project_id, location: location_id

response = client.get_supported_languages parent: parent

# List language codes of supported languages
response.languages.each do |language|
  puts "Language Code: #{language.language_code}"
end

Como detectar um idioma

Para detectar o idioma de origem de um texto com o Cloud Translation - Basic, use o seguinte código:

curl

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     --data "{
  'q': 'Omnia Gallia est divisa in tres partes',
}" "https://translation.googleapis.com/language/translate/v2/detect"

Quando a solicitação é bem-sucedida, o servidor retorna um código de status HTTP 200 OK e a resposta no formato JSON:

{
  "data": {
    "detections": [
      [
        {
          "confidence": 0.93554825,
          "isReliable": false,
          "language": "la"
        }
      ]
    ]
  }

Java

Antes de testar esta amostra, siga as instruções de configuração para Java no Guia de início rápido do Translation: como usar bibliotecas de cliente. Saiba mais na documentação de referência da API Translation para Java. 

// TODO(developer): Uncomment these lines.
// import com.google.cloud.translate.*;
// Translate translate = TranslateOptions.getDefaultInstance().getService();

List<String> texts = new LinkedList<>();
texts.add("Hello, World!");
texts.add("¡Hola Mundo!");
List<Detection> detections = translate.detect(texts);

System.out.println("Language(s) detected:");
for (Detection detection : detections) {
  System.out.printf("\t%s\n", detection);
}

Node.js

Antes de testar esta amostra, siga as instruções de configuração para Node.js no Guia de início rápido do Translation: como usar bibliotecas de cliente. Saiba mais na documentação de referência da API Translation para Node.js. 

// Imports the Google Cloud client library
const {Translate} = require('@google-cloud/translate').v2;

// Creates a client
const translate = new Translate();

/**
 * TODO(developer): Uncomment the following line before running the sample.
 */
// const text = 'The text for which to detect language, e.g. Hello, world!';

// Detects the language. "text" can be a string for detecting the language of
// a single piece of text, or an array of strings for detecting the languages
// of multiple texts.
async function detectLanguage() {
  let [detections] = await translate.detect(text);
  detections = Array.isArray(detections) ? detections : [detections];
  console.log('Detections:');
  detections.forEach(detection => {
    console.log(`${detection.input} => ${detection.language}`);
  });
}

detectLanguage();

Python

Antes de testar esta amostra, siga as instruções de configuração para Python no Guia de início rápido do Translation: como usar bibliotecas de cliente. Saiba mais na documentação de referência da API Translation para Python. 

"""Detects the text's language."""
from google.cloud import translate_v2 as translate

translate_client = translate.Client()

# Text can also be a sequence of strings, in which case this method
# will return a sequence of results for each text.
result = translate_client.detect_language(text)

print("Text: {}".format(text))
print("Confidence: {}".format(result["confidence"]))
print("Language: {}".format(result["language"]))

Com o Cloud Translation - Advanced, você precisa fornecer o número ou ID do projeto e o local dele (normalmente global ou us-central1) ao fazer uma solicitação detectLanguage.

Além disso, é possível configurar a solicitação feita ao Cloud Translation - Advanced para enviar diferentes tipos de MIME. Por exemplo, solicite text/html ou text/plain. O valor padrão é text/html.

REST e linha de comando

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

  • project-number-or-id: pelo número ou o código do seu projeto do Google Cloud

Método HTTP e URL: 

POST https://translation.googleapis.com/v3/projects/project-number-or-id/locations/global:detectLanguage

Corpo JSON da solicitação:

{
   "content":"Доктор Ватсон, иди сюда!"
}

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

curl

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

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
https://translation.googleapis.com/v3/projects/project-number-or-id/locations/global:detectLanguage

PowerShell

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

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
  -Method POST `
  -Headers $headers `
  -ContentType: "application/json; charset=utf-8" `
  -InFile request.json `
  -Uri "https://translation.googleapis.com/v3/projects/project-number-or-id/locations/global:detectLanguage
" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante a esta:

{
  "languages": [
    {
      "languageCode": "ru",
      "confidence": 1
    }
  ]
}
Na resposta, languageCode informa o código do idioma detectado. confidence é um intervalo de 0 a 1, sendo que 1 indica confiança total.

C#

Antes de testar esta amostra, siga as instruções de configuração para C# no Guia de início rápido do Translation: como usar bibliotecas de cliente. Saiba mais na documentação de referência da API Translation para C#. 


using Google.Api.Gax.ResourceNames;
using Google.Cloud.Translate.V3;
using System;

namespace GoogleCloudSamples
{
    public static class DetectLanguage
    {
        /// <summary>
        /// Detects the language of a given text.
        /// </summary>
        /// <param name="text">The text string for performing language detection</param>
        /// <param name="projectId">Your Google Cloud Project ID.</param>
        public static void DetectLanguageSample(string text = "[TEXT_STRING_FOR_DETECTION]",
            string projectId = "[Google Cloud Project ID]")
        {
            TranslationServiceClient translationServiceClient = TranslationServiceClient.Create();
            DetectLanguageRequest request = new DetectLanguageRequest
            {
                ParentAsLocationName = new LocationName(projectId, "global"),
                Content = text,
                MimeType = "text/plain",
            };
            DetectLanguageResponse response = translationServiceClient.DetectLanguage(request);
            // Display list of detected languages sorted by detection confidence.
            // The most probable language is first.
            foreach (DetectedLanguage language in response.Languages)
            {
                // The language detected
                Console.WriteLine($"Language code: {language.LanguageCode}");
                // Confidence of detection result for this language
                Console.WriteLine($"Confidence: {language.Confidence}");
            }
        }
    }

Go

Antes de testar esta amostra, siga as instruções de configuração para Go no Guia de início rápido do Translation: como usar bibliotecas de cliente. Saiba mais na documentação de referência da API Translation para Go. 

import (
	"context"
	"fmt"
	"io"

	translate "cloud.google.com/go/translate/apiv3"
	translatepb "google.golang.org/genproto/googleapis/cloud/translate/v3"
)

// detectLanguage detects the language of a text string.
func detectLanguage(w io.Writer, projectID string, text string) error {
	// projectID := "my-project-id"
	// text := "Hello, world!"

	ctx := context.Background()
	client, err := translate.NewTranslationClient(ctx)
	if err != nil {
		return fmt.Errorf("NewTranslationClient: %v", err)
	}
	defer client.Close()

	req := &translatepb.DetectLanguageRequest{
		Parent:   fmt.Sprintf("projects/%s/locations/global", projectID),
		MimeType: "text/plain", // Mime types: "text/plain", "text/html"
		Source: &translatepb.DetectLanguageRequest_Content{
			Content: text,
		},
	}

	resp, err := client.DetectLanguage(ctx, req)
	if err != nil {
		return fmt.Errorf("DetectLanguage: %v", err)
	}

	// Display list of detected languages sorted by detection confidence.
	// The most probable language is first.
	for _, language := range resp.GetLanguages() {
		// The language detected.
		fmt.Fprintf(w, "Language code: %v\n", language.GetLanguageCode())
		// Confidence of detection result for this language.
		fmt.Fprintf(w, "Confidence: %v\n", language.GetConfidence())
	}

	return nil
}

Node.js

Antes de testar esta amostra, siga as instruções de configuração para Node.js no Guia de início rápido do Translation: como usar bibliotecas de cliente. Saiba mais na documentação de referência da API Translation para Node.js. 

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'global';
// const text = 'text to translate';

// Imports the Google Cloud Translation library
const {TranslationServiceClient} = require('@google-cloud/translate');

// Instantiates a client
const translationClient = new TranslationServiceClient();

async function detectLanguage() {
  // Construct request
  const request = {
    parent: `projects/${projectId}/locations/${location}`,
    content: text,
  };

  try {
    // Run request
    const [response] = await translationClient.detectLanguage(request);

    console.log('Detected Languages:');
    for (const language of response.languages) {
      console.log(`Language Code: ${language.languageCode}`);
      console.log(`Confidence: ${language.confidence}`);
    }
  } catch (error) {
    console.error(error.details);
  }
}

detectLanguage();

Python

Antes de testar esta amostra, siga as instruções de configuração para Python no Guia de início rápido do Translation: como usar bibliotecas de cliente. Saiba mais na documentação de referência da API Translation para Python. 

from google.cloud import translate

def detect_language(project_id="YOUR_PROJECT_ID"):
    """Detecting the language of a text string."""

    client = translate.TranslationServiceClient()

    location = "global"

    parent = f"projects/{project_id}/locations/{location}"

    # Detail on supported types can be found here:
    # https://cloud.google.com/translate/docs/supported-formats
    response = client.detect_language(
        content="Hello, world!",
        parent=parent,
        mime_type="text/plain",  # mime types: text/plain, text/html
    )

    # Display list of detected languages sorted by detection confidence.
    # The most probable language is first.
    for language in response.languages:
        # The language detected
        print("Language code: {}".format(language.language_code))
        # Confidence of detection result for this language
        print("Confidence: {}".format(language.confidence))

Ruby

Antes de testar esta amostra, siga as instruções de configuração para Ruby no Guia de início rápido do Translation: como usar bibliotecas de cliente. Saiba mais na documentação de referência da API Translation para Ruby. 

require "google/cloud/translate"

# project_id = "[Google Cloud Project ID]"
# location_id = "[LOCATION ID]"

client = Google::Cloud::Translate.translation_service

# The text string for performing language detection
content = "Hello, world!"
# Optional. Can be "text/plain" or "text/html".
mime_type = "text/plain"

parent = client.location_path project: project_id, location: location_id

response = client.detect_language parent:    parent,
                                  content:   content,
                                  mime_type: mime_type

# Display list of detected languages sorted by detection confidence.
# The most probable language is first.
response.languages.each do |language|
  # The language detected
  puts "Language Code: #{language.language_code}"
  # Confidence of detection result for this language
  puts "Confidence: #{language.confidence}"
end