Pruebe la última versión del Traductor de Azure AI. Si sigue este inicio rápido, podrá comenzar a usar el servicio Translator para traducir texto mediante un lenguaje de programación de su elección o la API de REST. Para este proyecto, se recomienda usar el plan de tarifa gratuito (F0), mientras se familiariza con la tecnología y, posteriormente, actualizarlo a un nivel de pago para producción.
Para obtener más información sobre las opciones de autenticación para Translator, consulte la guía de referencia de Translator v3.
La operación básica del servicio Translator consiste en traducir texto. En este inicio rápido creará una solicitud, mediante un lenguaje de programación de su elección, que tome un único origen (from
) y proporcione dos salidas (to
). Luego, conocerá algunos parámetros que se pueden usar para ajustar tanto la solicitud como la respuesta.
Configuración del proyecto de Visual Studio
Asegúrese de que tiene instalada la versión más reciente del IDE de Visual Studio.
Abra Visual Studio.
En la página Inicio, seleccione Crear un nuevo proyecto.
En la página Crear un proyecto, escriba consola en el cuadro de búsqueda. Elija la plantilla Aplicación de consola y, a continuación, seleccione Siguiente.
En la ventana de diálogo Configure su nuevo proyecto, escriba translator_quickstart
en el cuadro Nombre de proyecto. Deje desactivada la casilla "Colocar la solución y el proyecto en el mismo directorio" y seleccione el botón Siguiente.
En la ventana de diálogo Información adicional, asegúrese de que esté seleccionado el elemento .NET 6.0 (compatibilidad a largo plazo). Deje la casilla "No usar instrucciones de nivel superior" desactivada y seleccione Crear.
Instalación del paquete Newtonsoft.json con NuGet
Haga clic con el botón derecho sobre el proyecto formRecognizer_quickstart y seleccione Administrar paquetes NuGet...
Seleccione la pestaña "Examinar" y escriba Newtonsoft.json.
Para agregar el paquete al proyecto, seleccione Instalar en la ventana del administrador de paquetes derecha.
Compilación de la aplicación de C#
Nota
- A partir de .NET 6, los nuevos proyectos que usan la plantilla
console
generan un nuevo estilo de programa que difiere de las versiones anteriores.
- El nuevo tipo de salida usa características recientes de C# que simplifican el código que debe escribir.
- Cuando se usa la versión más reciente, solo es necesario escribir el cuerpo del método
Main
. Es decir, no es necesario incluir instrucciones de nivel superior, directivas Using globales o directivas Using implícitas.
- Para obtener más información, consulte Las nuevas plantillas de C# generan instrucciones de nivel superior.
Abra el archivo Program.cs.
Elimine el código preexistente, incluida la línea Console.WriteLine("Hello World!")
. Copie y pegue el código de ejemplo en el archivo Program.cs de la aplicación. Asegúrese de actualizar la variable de clave con el valor correspondiente de la instancia de Translator de Azure Portal:
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);
}
}
}
Ejecute la aplicación C#
Una vez que agregue una muestra de código a su aplicación, elija el botón Iniciar verde junto a formRecognizer_quickstart para crear y ejecutar su programa, o pulse F5.
Salida del servicio Translation:
Si realiza una llamada correcta, debería ver la siguiente respuesta:
[
{
"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"
}
]
}
]
Configure el entorno de Go
Puede usar cualquier editor de texto para escribir aplicaciones de Go. Se recomienda usar la versión más reciente de Visual Studio Code y la extensión Go.
Sugerencia
Si es la primera vez que usa Go, pruebe el módulo de Learn Introducción a Go.
Asegúrese de que está instalada la versión más reciente de Go:
Descargue la versión más reciente de Go para su sistema operativo.
Cuando se haya completado la descarga, ejecute el instalador.
Abra un símbolo del sistema e introduzca el siguiente comando para confirmar que Go esté instalado:
go version
Compilación de la aplicación de Go
En una ventana de consola (como CMD, PowerShell o Bash), cree un nuevo directorio para la aplicación que se llame translator-app y vaya hasta él.
Cree un nuevo archivo Go denominado translation.go desde el directorio translator-app.
Copie y pegue el código de ejemplo que se proporciona a continuación en el archivo translation.go. Asegúrese de actualizar la variable de clave con el valor correspondiente de la instancia de Translator de Azure Portal:
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)
}
Ejecute la aplicación Go
Una vez que agregue un código de ejemplo a la aplicación, el programa Go se podrá ejecutar mediante un símbolo del sistema o terminal. Asegúrese de que la ruta de acceso del símbolo del sistema esté establecida en la carpeta translator-app y use el siguiente comando:
go run translation.go
Salida del servicio Translation:
Si realiza una llamada correcta, debería ver la siguiente respuesta:
[
{
"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"
}
]
}
]
Configuración del entorno Java
Debe tener instalada la versión más reciente de Visual Studio Code o del IDE que prefiera usar. Consulte Java en Visual Studio Code.
Sugerencia
- Visual Studio Code ofrece un paquete de codificación para Java para Windows y macOS. El paquete de codificación es un conjunto de VS Code, el Kit de desarrollo de Java (JDK) y una colección de extensiones sugeridas por Microsoft. El paquete de codificación también se puede usar para corregir un entorno de desarrollo existente.
- Si usa VS Code y el paquete de codificación para Java, instale la extensión Gradle para Java.
Si no usa Visual Studio Code, asegúrese de que tiene lo siguiente instalado en el entorno de desarrollo:
Creación de un proyecto de Gradle
En una ventana de consola (como CMD, PowerShell o Bash), cree un nuevo directorio para la aplicación que se llame translator-text-app y vaya hasta él.
mkdir translator-text-app && translator-text-app
mkdir translator-text-app; cd translator-text-app
Ejecute el comando gradle init
desde el directorio translator-text-app. Este comando crea archivos de compilación esenciales para Gradle, como build.gradle.kts, que se usa en el runtime para crear y configurar la aplicación.
gradle init --type basic
Cuando se le solicite que elija un DSL, seleccione Kotlin.
Acepte el nombre predeterminado del proyecto (translator-text-app). Para ello, presione la tecla INTRO o ENTRAR.
Actualice build.gradle.kts
con el siguiente 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")
}
Creación de una aplicación de Java
En el directorio translator-text-app, ejecute el siguiente comando:
mkdir -p src/main/java
Va a crear la estructura de directorios siguiente:
Vaya al directorio java
y cree un archivo denominado TranslatorText.java
.
Sugerencia
Puede crear un nuevo archivo mediante PowerShell.
Abra una ventana de PowerShell en el directorio del proyecto. Para ello, mantenga presionada la tecla Mayús y haga clic con el botón derecho en la carpeta.
Escriba el siguiente comando: New-Item TranslatorText.java.
También puede crear un nuevo archivo en el IDE que se llame TranslatorText.java
y guardarlo en el directorio java
.
Abra el archivo TranslatorText.java
en el IDE y copie el siguientes código de ejemplo para pegarlo en la aplicación. Asegúrese de actualizar la variable de clave con el valor correspondiente de la instancia de Translator de Azure Portal:
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);
}
}
}
Compilación y ejecución de la aplicación de Java
Una vez que agregue un código de ejemplo a la aplicación, vuelva al directorio principal del proyecto: translator-text-app. A continuación, abra una ventana de consola e introduzca los siguientes comandos:
Compile la aplicación con el comando build
:
gradle build
Ejecute la aplicación con el comando run
:
gradle run
Salida del servicio Translation:
Si realiza una llamada correcta, debería ver la siguiente respuesta:
[
{
"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"
}
]
}
]
Configuración del proyecto de Node.js Express
Asegúrese de que está instalada la versión más reciente de Node.js. La instalación de Node.js incluye el administrador de paquetes de nodos (npm).
En una ventana de consola (como CMD, PowerShell o Bash), cree un directorio para la aplicación que se llame translator-app
y vaya a él.
mkdir translator-app && cd translator-app
mkdir translator-app; cd translator-app
Ejecute el comando "npm init" para inicializar la aplicación y aplicar la técnica scaffolding al proyecto.
npm init
Especifique los atributos del proyecto mediante las indicaciones que se presentan en el terminal.
- Los atributos más importantes son el nombre, el número de versión y el punto de entrada.
- Se recomienda mantener
index.js
para el nombre del punto de entrada. La descripción, el comando de prueba, el repositorio de GitHub, las palabras clave, el autor y la información de la licencia son atributos opcionales; se pueden omitir para este proyecto.
- Acepte las sugerencias entre paréntesis seleccionando Retorno o Entrar.
- Después de completar las solicitudes, se creará un archivo
package.json
en el directorio translator-app.
Abra una ventana de consola y use el comando npm para instalar la biblioteca HTTP axios
y el paquete uuid
:
npm install axios uuid
Cree el archivo index.js
en el directorio de la aplicación.
Sugerencia
Puede crear un nuevo archivo mediante PowerShell.
Abra una ventana de PowerShell en el directorio del proyecto. Para ello, mantenga presionada la tecla Mayús y haga clic con el botón derecho en la carpeta.
Escriba el siguiente comando New-Item index.js.
También puede crear un nuevo archivo en el IDE que se llame index.js
y guardarlo en el directorio translator-app
.
Compilación de la aplicación de JavaScript
Agregue el siguiente código de ejemplo al archivo index.js
. Asegúrese de actualizar la variable de clave con el valor correspondiente de la instancia de Translator de Azure Portal:
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));
})
Ejecución de la aplicación de JavaScript
Una vez que agregue un código de ejemplo a la aplicación, ejecute el programa de la siguiente forma:
Vaya al directorio de la aplicación (translator-app).
Escriba el siguiente comando en el terminal:
node index.js
Salida del servicio Translation:
Si realiza una llamada correcta, debería ver la siguiente respuesta:
[
{
"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"
}
]
}
]
Configuración del proyecto de Python
Asegúrese de que está instalada la versión más reciente de Python 3.x. La instalación de Python incluye el paquete del instalador de Python (pip).
Abra una ventana de terminal y use el comando pip para instalar la biblioteca de solicitudes y el paquete uuid0:
pip install requests uuid
Nota
También usaremos un paquete integrado de Python denominado json. Este se usa para trabajar con datos JSON.
Compilación de la aplicación de Python
Cree un archivo Python que se llame translator-app.py en el editor o IDE que prefiera usar.
Agregue el siguiente código de ejemplo al archivo translator-app.py
. Asegúrese de actualizar la variable de clave con el valor correspondiente de la instancia de Translator de Azure Portal.
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=(',', ': ')))
Ejecución de la aplicación de Python
Una vez agregado un ejemplo de código a la aplicación, compile y ejecute el programa:
Vaya al archivo translator-app.py.
Escriba el siguiente comando en la ventana de consola:
python translator-app.py
Salida del servicio Translation:
Si realiza una llamada correcta, debería ver la siguiente respuesta:
[
{
"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"
}
]
}
]
Eso es todo, ¡enhorabuena! Acaba de aprender cómo usar el servicio Translator para traducir texto.
Explore nuestra documentación paso a paso y profundice en las funcionalidades del servicio Translator: