Início rápido: APIs REST do Tradutor de IA do Azure

Configurar seu projeto do Visual Studio

1. Verifique se você tem a versão atual do IDE do Visual Studio.

   Dica

   Caso não esteja familiarizado com o Visual Studio, experimente o módulo Introdução ao Visual Studio do Learn.

2. Abra o Visual Studio.

3. Na página Iniciar, escolha Criar um projeto.

   

4. Na página Criar um projeto, insira console na caixa de pesquisa. Escolha o modelo Aplicativo de Console e selecione Avançar.

   

5. Na janela do diálogo Configurar seu novo projeto, insira translator_quickstart na caixa Nome do projeto. Mantenha a caixa de seleção "Colocar solução e projeto no mesmo diretório" desmarcada e selecione Avançar.

   

6. Na janela da caixa de diálogo Informações adicionais, verifique se .NET 6.0 (suporte a longo prazo) está selecionado. Mantenha a caixa de seleção "Não usar instruções de nível superior" desmarcada e selecione Criar.

   

Instalar o pacote Newtonsoft.json com o NuGet

1. Clique com o botão direito do mouse no projeto translator_quickstart e selecione Gerenciar Pacotes NuGet….

   

2. Selecione a guia Procurar e digite Newtonsoft.json.

   

3. Para adicionar o pacote ao seu projeto, selecione Instalar na janela direita do gerenciador de pacotes.

   

Compilar seu aplicativo C#

1. Abra o arquivo Program.cs.

2. Exclua o código existente, incluindo a linha Console.WriteLine("Hello World!"). Copie e cole o exemplo de código no arquivo Program.cs do aplicativo. Atualize a variável de chave com o valor da instância de Tradução do portal do Azure:

using System.Text;
using Newtonsoft.Json;

class Program
{
    private static readonly string key = "<your-translator-key>";
    private static readonly string endpoint = "https://api.cognitive.microsofttranslator.com";

    // location, also known as region.
    // required if you're using a multi-service or regional (not global) resource. It can be found in the Azure portal on the Keys and Endpoint page.
    private static readonly string location = "<YOUR-RESOURCE-LOCATION>";

    static async Task Main(string[] args)
    {
        // Input and output languages are defined as parameters.
        string route = "/translate?api-version=3.0&from=en&to=fr&to=zu";
        string textToTranslate = "I would really like to drive your car around the block a few times!";
        object[] body = new object[] { new { Text = textToTranslate } };
        var requestBody = JsonConvert.SerializeObject(body);

        using (var client = new HttpClient())
        using (var request = new HttpRequestMessage())
        {
            // Build the request.
            request.Method = HttpMethod.Post;
            request.RequestUri = new Uri(endpoint + route);
            request.Content = new StringContent(requestBody, Encoding.UTF8, "application/json");
            request.Headers.Add("Ocp-Apim-Subscription-Key", key);
            // location required if you're using a multi-service or regional (not global) resource.
            request.Headers.Add("Ocp-Apim-Subscription-Region", location);

            // Send the request and get response.
            HttpResponseMessage response = await client.SendAsync(request).ConfigureAwait(false);
            // Read response as a string.
            string result = await response.Content.ReadAsStringAsync();
            Console.WriteLine(result);
        }
    }
}

Executar seu aplicativo C#

Depois de adicionar um exemplo de código ao aplicativo, selecione o botão verde Iniciar ao lado de formRecognizer_quickstart para compilar e executar o programa ou pressione F5.

Saída de tradução:

Após uma chamada bem-sucedida, você deverá ver a seguinte resposta:

[
    {
        "detectedLanguage": {
            "language": "en",
            "score": 1.0
        },
        "translations": [
            {
                "text": "J'aimerais vraiment conduire votre voiture autour du pâté de maisons plusieurs fois!",
                "to": "fr"
            },
            {
                "text": "Ngingathanda ngempela ukushayela imoto yakho endaweni evimbelayo izikhathi ezimbalwa!",
                "to": "zu"
            }
        ]
    }
]

Configurar o ambiente do Go

Você pode usar qualquer editor de texto para escrever aplicativos do Go. Recomendamos usar a versão mais recente do Visual Studio Code e a extensão Go.

1. Certifique-se de que a versão mais recente do Go esteja instalada:

   • Baixe a versão da linguagem de programação Go para seu sistema operacional.

   • Quando o download for concluído, execute o instalador.

   • Abra um prompt de comando e insira o seguinte para confirmar se o Go foi instalado:

       go version
     

Compilar seu aplicativo Go

1. Em uma janela de console (como o cmd, o PowerShell ou o Bash), crie um diretório para seu aplicativo chamado translator-app e navegue até ele.

2. Crie um arquivo GO chamado translation.go por meio do diretório translator-app.

3. Copie e cole o exemplo de código fornecido no arquivo translation.go. Atualize a variável de chave com o valor da instância de Tradução do portal do Azure:

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "net/url"
)

func main() {
    key := "<YOUR-TRANSLATOR-KEY>"
    endpoint := "https://api.cognitive.microsofttranslator.com/"
    uri := endpoint + "/translate?api-version=3.0"

    // location, also known as region.
    // required if you're using a multi-service or regional (not global) resource. It can be found in the Azure portal on the Keys and Endpoint page.
    location := "<YOUR-RESOURCE-LOCATION>"

    // Build the request URL. See: https://go.dev/pkg/net/url/#example_URL_Parse
    u, _ := url.Parse(uri)
    q := u.Query()
    q.Add("from", "en")
    q.Add("to", "fr")
    q.Add("to", "zu")
    u.RawQuery = q.Encode()

    // Create an anonymous struct for your request body and encode it to JSON
    body := []struct {
        Text string
    }{
        {Text: "I would really like to drive your car around the block a few times."},
    }
    b, _ := json.Marshal(body)

    // Build the HTTP POST request
    req, err := http.NewRequest("POST", u.String(), bytes.NewBuffer(b))
    if err != nil {
        log.Fatal(err)
    }
    // Add required headers to the request
    req.Header.Add("Ocp-Apim-Subscription-Key", key)
    // location required if you're using a multi-service or regional (not global) resource.
    req.Header.Add("Ocp-Apim-Subscription-Region", location)
    req.Header.Add("Content-Type", "application/json")

    // Call the Translator API
    res, err := http.DefaultClient.Do(req)
    if err != nil {
        log.Fatal(err)
    }

    // Decode the JSON response
    var result interface{}
    if err := json.NewDecoder(res.Body).Decode(&result); err != nil {
        log.Fatal(err)
    }
    // Format and print the response to terminal
    prettyJSON, _ := json.MarshalIndent(result, "", "  ")
    fmt.Printf("%s\n", prettyJSON)
}

Executar seu aplicativo Go

Depois de adicionar um exemplo de código ao seu aplicativo, o programa Go poderá ser executado em um prompt de comando ou terminal. Verifique se o caminho do prompt está definido para a pasta translator-app e use o seguinte comando:

 go run translation.go

Saída de tradução:

Após uma chamada bem-sucedida, você deverá ver a seguinte resposta:

[
    {
        "detectedLanguage": {
            "language": "en",
            "score": 1.0
        },
        "translations": [
            {
                "text": "J'aimerais vraiment conduire votre voiture autour du pâté de maisons plusieurs fois!",
                "to": "fr"
            },
            {
                "text": "Ngingathanda ngempela ukushayela imoto yakho endaweni evimbelayo izikhathi ezimbalwa!",
                "to": "zu"
            }
        ]
    }
]

Configurar o ambiente do Java

• Você deve ter a última versão do Visual Studio Code ou do seu IDE preferido. Consulte Java no Visual Studio Code.

  Dica

  • Visual Studio Code oferece um Pacote de Codificação para Java para Windows e macOS. O pacote de codificação é um pacote de VS Code, o JDK (Java Development Kit) e uma coleção de extensões sugeridas pela Microsoft. O Pacote de Codificação também pode ser usado para corrigir um ambiente de desenvolvimento existente.
  • Se você estiver usando VS Code e o Pacote de Codificação para Java, instale a extensão Gradle para Java.

• Se não estiver usando Visual Studio Code, você deverá ter o seguinte instalado em seu ambiente de desenvolvimento:

  • Um Java Development Kit (OpenJDK) versão 8 ou posterior.

  • Gradle, versão 6.8 ou posterior.

Criar um novo projeto Gradle

1. Na janela do console (como o cmd, o PowerShell ou o Bash), crie um diretório para seu aplicativo chamado translator-text-app e acesse-o.

   mkdir translator-text-app && translator-text-app
   

    mkdir translator-text-app; cd translator-text-app
   

2. Execute o comando gradle init no diretório translator-text-app. Esse comando cria arquivos de build essenciais para o Gradle, incluindo o build.gradle.kts, que é usado no runtime para criar e configurar seu aplicativo.

   gradle init --type basic
   

3. Quando solicitado a escolher uma DSL, escolha Kotlin.

4. Aceite o nome do projeto padrão (translator-text-app) selecionando Return ou ENTER.

5. Atualize build.gradle.kts com o seguinte código:

plugins {
  java
  application
}
application {
  mainClass.set("TranslatorText")
}
repositories {
  mavenCentral()
}
dependencies {
  implementation("com.squareup.okhttp3:okhttp:4.10.0")
  implementation("com.google.code.gson:gson:2.9.0")
}

Criar um aplicativo Java

1. No diretório translator-text-app, execute o seguinte comando:

   mkdir -p src/main/java
   

   Você cria a seguinte estrutura de diretório:

   

2. Navegue até o diretório do java e crie um arquivo chamado TranslatorText.java.

   Dica

   • Você pode criar um arquivo usando o PowerShell.

   • Abra uma janela do PowerShell no diretório do projeto mantendo a tecla Shift e clicando com o botão direito do mouse na pasta.

   • Digite o comando a seguir New-Item TranslatorText.java.

   • Crie também um arquivo no IDE chamado TranslatorText.java e salve-o no diretório java.

3. Abra o arquivo TranslatorText.java no IDE e copie e cole o exemplo de código a seguir no aplicativo. Atualize a chave com um dos valores de chave da instância de Tradução do portal do Azure:

import java.io.IOException;

import com.google.gson.*;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;

public class TranslatorText {
    private static String key = "<your-translator-key";

    // location, also known as region.
   // required if you're using a multi-service or regional (not global) resource. It can be found in the Azure portal on the Keys and Endpoint page.
    private static String location = "<YOUR-RESOURCE-LOCATION>";


    // Instantiates the OkHttpClient.
    OkHttpClient client = new OkHttpClient();

    // This function performs a POST request.
    public String Post() throws IOException {
        MediaType mediaType = MediaType.parse("application/json");
        RequestBody body = RequestBody.create(mediaType,
                "[{\"Text\": \"I would really like to drive your car around the block a few times!\"}]");
        Request request = new Request.Builder()
                .url("https://api.cognitive.microsofttranslator.com/translate?api-version=3.0&from=en&to=fr&to=zu")
                .post(body)
                .addHeader("Ocp-Apim-Subscription-Key", key)
                // location required if you're using a multi-service or regional (not global) resource.
                .addHeader("Ocp-Apim-Subscription-Region", location)
                .addHeader("Content-type", "application/json")
                .build();
        Response response = client.newCall(request).execute();
        return response.body().string();
    }

    // This function prettifies the json response.
    public static String prettify(String json_text) {
        JsonParser parser = new JsonParser();
        JsonElement json = parser.parse(json_text);
        Gson gson = new GsonBuilder().setPrettyPrinting().create();
        return gson.toJson(json);
    }

    public static void main(String[] args) {
        try {
            TranslatorText translateRequest = new TranslatorText();
            String response = translateRequest.Post();
            System.out.println(prettify(response));
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

Compilar e executar seu aplicativo do Java

Depois de adicionar um exemplo de código ao seu aplicativo, volte ao diretório principal do projeto translator-text-app, abra uma janela de console e insira os seguintes comandos:

1. Crie seu aplicativo com o comando build:

   gradle build
   

2. Execute seu aplicativo com o comando run:

   gradle run
   

Saída de tradução:

Após uma chamada bem-sucedida, você deverá ver a seguinte resposta:

[
  {
    "translations": [
      {
        "text": "J'aimerais vraiment conduire votre voiture autour du pâté de maisons plusieurs fois!",
        "to": "fr"
      },
      {
        "text": "Ngingathanda ngempela ukushayela imoto yakho endaweni evimbelayo izikhathi ezimbalwa!",
        "to": "zu"
      }
    ]
  }
]

Configurar seu projeto Node.js Express

1. Certifique-se de que a versão mais recente do Node.js esteja instalada. O npm (Node Package Manager) está incluído na instalação do Node.js.

   Dica

   Caso não esteja familiarizado com o Node.js, experimente o módulo Introdução ao Node.js do Learn.

2. Em uma janela de console (como o cmd, o PowerShell ou o Bash), crie um diretório chamado translator-app para seu aplicativo e navegue até ele.

       mkdir translator-app && cd translator-app
   

     mkdir translator-app; cd translator-app
   

3. Execute o comando npm init para inicializar o aplicativo e fazer scaffold do projeto.

      npm init
   

4. Especifique os atributos do projeto usando os prompts apresentados no terminal.

   • Os atributos mais importantes são nome, número de versão e ponto de entrada.
   • É recomendável manter index.js para o nome do ponto de entrada. Descrição, comando de teste, repositório GitHub, palavras-chave, autor e informações de licença são atributos opcionais - eles podem ser ignorados para este projeto.
   • Aceite as sugestões entre parênteses selecionando Retornar ou Enter.
   • Depois de concluir os prompts, um arquivo package.json será criado no diretório translator-app.

5. Abra uma janela do console e use o npm para instalar a biblioteca HTTP axios e o pacote uuid:

      npm install axios uuid
   

6. Crie o arquivo index.js no diretório do aplicativo.

   Dica

   • Você pode criar um arquivo usando o PowerShell.

   • Abra uma janela do PowerShell no diretório do projeto mantendo a tecla Shift e clicando com o botão direito do mouse na pasta.

   • No terminal, digite o comando New-Item index.js.

   • Crie também um arquivo chamado index.js no IDE e salve-o no diretório translator-app.

Compilar seu aplicativo JavaScript

Adicione o exemplo de código a seguir ao arquivo index.js. Atualize a variável de chave com o valor da instância de Tradução do portal do Azure:

    const axios = require('axios').default;
    const { v4: uuidv4 } = require('uuid');

    let key = "<your-translator-key>";
    let endpoint = "https://api.cognitive.microsofttranslator.com";

    // location, also known as region.
    // required if you're using a multi-service or regional (not global) resource. It can be found in the Azure portal on the Keys and Endpoint page.
    let location = "<YOUR-RESOURCE-LOCATION>";

    axios({
        baseURL: endpoint,
        url: '/translate',
        method: 'post',
        headers: {
            'Ocp-Apim-Subscription-Key': key,
             // location required if you're using a multi-service or regional (not global) resource.
            'Ocp-Apim-Subscription-Region': location,
            'Content-type': 'application/json',
            'X-ClientTraceId': uuidv4().toString()
        },
        params: {
            'api-version': '3.0',
            'from': 'en',
            'to': 'fr,zu'
        },
        data: [{
            'text': 'I would really like to drive your car around the block a few times!'
        }],
        responseType: 'json'
    }).then(function(response){
        console.log(JSON.stringify(response.data, null, 4));
    })

Executar seu aplicativo JavaScript

Depois de adicionar o exemplo de código ao seu aplicativo, execute o programa:

1. Procure o diretório do aplicativo (translator-app).

2. No terminal, digite o seguinte comando:

   node index.js
   

Saída de tradução:

Após uma chamada bem-sucedida, você deverá ver a seguinte resposta:

[
    {
        "translations": [
            {
                "text": "J'aimerais vraiment conduire votre voiture autour du pâté de maisons plusieurs fois!",
                "to": "fr"
            },
            {
                "text": "Ngingathanda ngempela ukushayela imoto yakho endaweni evimbelayo izikhathi ezimbalwa!",
                "to": "zu"
            }
        ]
    }
]

Configurar seu projeto Python

1. Certifique-se de que a versão mais recente do Python 3.x esteja instalada. O pip (pacote do instalador do Python) está incluído na instalação do Python.

   Dica

   Caso não esteja familiarizado com o Python, experimente o módulo Introdução ao Python do Learn.

2. Abra uma janela do terminal e use o pip para instalar a biblioteca Requests e o pacote uuid0:

      pip install requests uuid
   

   Observação

   Também usaremos um pacote interno do Python chamado json. Ele é usado para trabalhar com os dados JSON.

Compilar seu aplicativo Python

1. Crie um arquivo Python chamado translator-app.py no seu editor ou IDE preferido.

2. Adicione o exemplo de código a seguir ao arquivo translator-app.py. Atualize a chave com um dos valores da instância de Tradução do portal do Azure.

import requests, uuid, json

# Add your key and endpoint
key = "<your-translator-key>"
endpoint = "https://api.cognitive.microsofttranslator.com"

# location, also known as region.
# required if you're using a multi-service or regional (not global) resource. It can be found in the Azure portal on the Keys and Endpoint page.
location = "<YOUR-RESOURCE-LOCATION>"

path = '/translate'
constructed_url = endpoint + path

params = {
    'api-version': '3.0',
    'from': 'en',
    'to': ['fr', 'zu']
}

headers = {
    'Ocp-Apim-Subscription-Key': key,
    # location required if you're using a multi-service or regional (not global) resource.
    'Ocp-Apim-Subscription-Region': location,
    'Content-type': 'application/json',
    'X-ClientTraceId': str(uuid.uuid4())
}

# You can pass more than one object in body.
body = [{
    'text': 'I would really like to drive your car around the block a few times!'
}]

request = requests.post(constructed_url, params=params, headers=headers, json=body)
response = request.json()

print(json.dumps(response, sort_keys=True, ensure_ascii=False, indent=4, separators=(',', ': ')))

Executar seu aplicativo Python

Depois de adicionar um exemplo de código ao seu aplicativo, compile e execute o programa:

1. Procure o arquivo translator-app.py.

2. Digite o seguinte comando no console:

   python translator-app.py
   

Saída de tradução:

Após uma chamada bem-sucedida, você deverá ver a seguinte resposta:

[
  {
    "translations": [
      {
        "text": "J'aimerais vraiment conduire votre voiture autour du pâté de maisons plusieurs fois!",
        "to": "fr"
      },
      {
        "text": "Ngingathanda ngempela ukushayela imoto yakho endaweni evimbelayo izikhathi ezimbalwa!",
        "to": "zu"
      }
    ]
  }
]