Schnellstart: Azure KI Übersetzer-REST-APIs

Einrichten Ihres Visual Studio-Projekts

1. Vergewissern Sie sich, dass Sie die neueste Version der Visual Studio-IDE installiert haben.

   Tipp

   Wenn Sie neu in Visual Studio einsteigen, sehen Sie sich das Learn-Modul Einführung in Visual Studio an.

2. Öffnen Sie Visual Studio.

3. Wählen Sie auf der Startseite Neues Projekt erstellen aus.

   

4. Geben Sie auf der Seite Neues Projekt erstellen im Suchfeld den Suchbegriff Konsole ein. Wählen Sie die Vorlage Konsolenanwendung und dann Weiter aus.

   

5. Geben Sie im Dialogfeld Neues Projekt konfigurieren im Feld für den Projektnamen den Namen translator_quickstart ein. Lassen Sie das Kontrollkästchen „Projektmappe und Projekt im selben Verzeichnis platzieren“ deaktiviert, und wählen Sie Weiter aus.

   

6. Stellen Sie im Dialogfeld Zusätzliche Informationen sicher, dass .NET 6.0 (Langfristiger Support) ausgewählt ist. Lassen Sie das Kontrollkästchen „Anweisungen auf oberster Ebene nicht verwenden“ deaktiviert, und wählen Sie Erstellen aus.

   

Installieren des Newtonsoft.json-Pakets mit NuGet

1. Klicken Sie mit der rechten Maustaste auf Ihr Projekt translator_quickstart, und wählen Sie NuGet-Pakete verwalten... aus.

   

2. Wählen Sie die Registerkarte „Durchsuchen“ aus, und geben Sie „Newtonsoft.json“ ein.

   

3. Wählen Sie im rechten Paket-Manager-Fenster „Installieren“ aus, um Ihrem Projekt das Paket hinzuzufügen.

   

Erstellen Ihrer C#-Anwendung

1. Öffnen Sie die Datei Program.cs.

2. Löschen Sie den vorhandenen Code, einschließlich der Zeile Console.WriteLine("Hello World!"). Kopieren Sie das Codebeispiel, und fügen Sie es in die Datei „Program.cs“ Ihrer Anwendung ein. Achten Sie darauf, die Schlüsselvariable mit dem Wert aus Ihrer Übersetzerinstanz aus dem Azure-Portal zu aktualisieren:

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

Ausführen Ihrer C#-Anwendung

Nachdem Sie Ihrer Anwendung ein Codebeispiel hinzugefügt haben, wählen Sie die grüne Schaltfläche Start neben „formRecognizer_quickstart“ aus, um Ihr Programm zu erstellen und auszuführen, oder drücken Sie F5.

Übersetzungsausgabe:

Nach einem erfolgreichen Aufruf sollten Sie die folgende Antwort sehen:

[
    {
        "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"
            }
        ]
    }
]

Einrichten Ihrer Go-Umgebung

Zum Schreiben von Go-Anwendungen können Sie einen beliebigen Text-Editor verwenden. Es empfiehlt sich, die neueste Version von Visual Studio Code und die Go-Erweiterung zu verwenden.

1. Stellen Sie sicher, dass die neueste Version von Go installiert ist:

   • Laden Sie die Go Programmierspracheversion für Ihr Betriebssystem herunter.

   • Führen Sie das Installationsprogramm aus, nachdem der Download abgeschlossen ist.

   • Öffnen Sie eine Eingabeaufforderung, und geben Sie Folgendes ein, um zu bestätigen, dass Go installiert wurde:

       go version
     

Erstellen Ihrer Go-Anwendung

1. Erstellen Sie in einem Konsolenfenster (etwa einer Eingabeaufforderung, PowerShell oder Bash) ein neues Verzeichnis für Ihre neue App mit dem Namen translator-app, und navigieren Sie zu dem Verzeichnis.

2. Erstellen Sie im Verzeichnis translator-app eine neue GO-Datei namens translation.go.

3. Kopieren Sie das angegebene Codebeispiel, und fügen Sie es in Ihre translation.go-Datei ein. Achten Sie darauf, die Schlüsselvariable mit dem Wert aus Ihrer Übersetzerinstanz aus dem Azure-Portal zu aktualisieren:

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

Ausführen Ihrer Go-Anwendung

Nachdem Sie Ihrer Anwendung ein Codebeispiel hinzugefügt haben, kann Ihr Go-Programm an einer Eingabeaufforderung oder einer Terminalaufforderung ausgeführt werden. Vergewissern Sie sich, dass der Pfad Ihrer Eingabeaufforderung auf den Ordner translator-app festgelegt ist, und verwenden Sie den folgenden Befehl:

 go run translation.go

Übersetzungsausgabe:

Nach einem erfolgreichen Aufruf sollten Sie die folgende Antwort sehen:

[
    {
        "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"
            }
        ]
    }
]

Einrichten Ihrer Java-Umgebung

• Sie sollten die aktuelle Version von Visual Studio Code oder Ihrer bevorzugten IDE verwenden. Weitere Informationen finden Sie unter Java in Visual Studio Code.

  Tipp

  • Visual Studio Code bietet ein Coding Pack für Java für Windows und macOS. Das Coding Pack ist ein Paket aus VS Code, dem Java Development Kit (JDK) und einer Sammlung vorgeschlagener Erweiterungen von Microsoft. Das Coding Pack kann auch verwendet werden, um eine vorhandene Entwicklungsumgebung zu korrigieren.
  • Wenn Sie VS Code Code Pack für Java verwenden, installieren Sie die Erweiterung Gradle für Java.

• Wenn Sie nicht Visual Studio Code verwenden, stellen Sie sicher, dass Folgendes in Ihrer Entwicklungsumgebung installiert ist:

  • Ein Java Development Kit (OpenJDK), Version 8 oder höher.

  • Az Version 6.8 oder höher.

Erstellen eines neuen Gradle-Projekts

1. Erstellen Sie in einem Konsolenfenster (etwa einer Eingabeaufforderung, PowerShell oder Bash) ein neues Verzeichnis für Ihre neue App mit dem Namen translator-text-app, und navigieren Sie zu dem Verzeichnis.

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

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

2. Führen Sie den gradle init-Befehl aus dem Verzeichnis „translator-text-app“ aus. Mit diesem Befehl werden grundlegende Builddateien für Gradle erstellt, u. a. die Datei build.gradle.kts. Diese Datei wird zur Laufzeit zum Erstellen und Konfigurieren Ihrer Anwendung verwendet.

   gradle init --type basic
   

3. Wenn Sie zur Auswahl einer DSL aufgefordert werden, wählen Sie Kotlin aus.

4. Akzeptieren Sie den Standardprojektnamen (Übersetzer-Text-App), indem Sie "Zurückgeben" oder "Eingabetaste" auswählen.

5. Aktualisieren Sie build.gradle.kts mit folgendem Code:

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

Erstellen Ihrer Java-Anwendung

1. Führen Sie im Verzeichnis translator-text-app den folgenden Befehl aus:

   mkdir -p src/main/java
   

   Sie erstellen die folgende Verzeichnisstruktur:

   

2. Navigieren Sie zum java-Verzeichnis, und erstellen Sie eine Datei namens TranslatorText.java.

   Tipp

   • Sie können eine neue Datei mithilfe von PowerShell erstellen.

   • Öffnen Sie ein PowerShell-Fenster in Ihrem Projektverzeichnis, indem Sie die UMSCHALTTASTE gedrückt halten und mit der rechten Maustaste auf den Ordner klicken.

   • Geben Sie den folgenden Befehl New-Item TranslatorText.java ein.

   • Sie können auch eine neue Datei in Ihrer IDE mit dem Namen TranslatorText.java erstellen und sie im Verzeichnis java speichern.

3. Öffnen Sie die Datei TranslatorText.java in Ihrer IDE, kopieren Sie das folgende Codebeispiel, und fügen Sie es in Ihre Anwendung ein. Achten Sie darauf, den Schlüssel mit einem der Schlüsselwerte aus Ihrer Übersetzerinstanz aus dem Azure-Portal zu aktualisieren:

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

Erstellen und Ausführen der Java-Anwendung

Nachdem Sie Ihrer Anwendung ein Codebeispiel hinzugefügt haben, navigieren Sie zu Ihrem Hauptprojektverzeichnis zurück – translator-text-app –, öffnen Sie ein Konsolenfenster, und geben Sie die folgenden Befehle ein:

1. Erstellen Sie Ihre Anwendung mit dem Befehl build:

   gradle build
   

2. Führen Sie Ihre Anwendung mit dem Befehl run aus:

   gradle run
   

Übersetzungsausgabe:

Nach einem erfolgreichen Aufruf sollten Sie die folgende Antwort sehen:

[
  {
    "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"
      }
    ]
  }
]

Einrichten Ihres Node.js Express-Projekts

1. Stellen Sie sicher, dass die neueste Version von Node.js installiert ist. Der Node Package Manager (npm) ist in der Node.js-Installation enthalten.

   Tipp

   Wenn Sie neu in Node.js einsteigen, sehen Sie sich das Learn-Modul Einführung in Node.js an.

2. Erstellen Sie in einem Konsolenfenster (etwa der Eingabeaufforderung, PowerShell oder Bash) ein neues Verzeichnis für Ihre App mit dem Namen translator-app, und navigieren Sie zu ihm.

       mkdir translator-app && cd translator-app
   

     mkdir translator-app; cd translator-app
   

3. Führen Sie den npm-init-Befehl aus, um die Anwendung zu initialisieren und das Gerüst für Ihr Projekt zu erstellen.

      npm init
   

4. Geben Sie die Attribute Ihres Projekts an, indem Sie die im Terminal angezeigten Eingabeaufforderungen verwenden.

   • Die wichtigsten Attribute sind Name, Versionsnummer und Einstiegspunkt.
   • Es wird empfohlen, index.js den Namen des Einstiegspunkts zu behalten. Beschreibung, Testbefehl, GitHub-Repository, Schlüsselwörter, Autor und Lizenzinformationen sind optionale Attribute, die Sie für dieses Projekt überspringen können.
   • Akzeptieren Sie die Vorschläge in Klammern, indem Sie Zurückgeben oder eingebenauswählen.
   • Nachdem Sie die Eingabeaufforderungen abgeschlossen haben, wird in Ihrem Verzeichnis „translator-app“ die Datei package.json erstellt.

5. Öffnen Sie ein Konsolenfenster, und verwenden Sie npm, um die HTTP-Bibliothek axios und das Paket uuid zu installieren:

      npm install axios uuid
   

6. Erstellen Sie die Datei index.js im Anwendungsverzeichnis.

   Tipp

   • Sie können eine neue Datei mithilfe von PowerShell erstellen.

   • Öffnen Sie ein PowerShell-Fenster in Ihrem Projektverzeichnis, indem Sie die UMSCHALTTASTE gedrückt halten und mit der rechten Maustaste auf den Ordner klicken.

   • Geben Sie in Ihrem Terminal den folgenden Befehl ein:

   • Sie können auch eine neue Datei mit dem Namen index.js in Ihrer IDE erstellen und sie im Verzeichnis translator-app speichern.

Erstellen Ihrer JavaScript-Anwendung

Fügen Sie Ihrer index.js-Datei das folgende Codebeispiel hinzu. Achten Sie darauf, die Schlüsselvariable mit dem Wert aus Ihrer Übersetzerinstanz aus dem Azure-Portal zu aktualisieren:

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

Ausführen der JavaScript-Anwendung

Nachdem Sie Ihrer Anwendung ein Codebeispiel hinzugefügt haben, führen Sie das Programm aus:

1. Navigieren Sie zu Ihrem Anwendungsverzeichnis (translator-app).

2. Geben Sie in Ihrem Terminal den folgenden Befehl ein:

   node index.js
   

Übersetzungsausgabe:

Nach einem erfolgreichen Aufruf sollten Sie die folgende Antwort sehen:

[
    {
        "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"
            }
        ]
    }
]

Einrichten Ihres Python-Projekts

1. Stellen Sie sicher, dass die neueste Version von Python 3.x installiert ist. Das Python-Installerpaket (pip) ist in der Python-Installation enthalten.

   Tipp

   Wenn Sie neu in Python einsteigen, sehen Sie sich das Learn-Modul Einführung in Python an.

2. Öffnen Sie ein Terminalfenster, und verwenden Sie pip, um die Anforderungsbibliothek und das uuid0-Paket zu installieren:

      pip install requests uuid
   

   Hinweis

   Wir verwenden außerdem ein in Python integriertes Paket namens „json“. Es wird für die Verarbeitung von JSON-Daten verwendet.

Erstellen Ihrer Python-Anwendung

1. Erstellen Sie eine neue Python-Datei namens translator-app.py in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE.

2. Fügen Sie Ihrer translator-app.py-Datei das folgende Codebeispiel hinzu. Achten Sie darauf, den Schlüssel mit einem der Werte aus Ihrer Übersetzerinstanz aus dem Azure-Portal zu aktualisieren.

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=(',', ': ')))

Ausführen der Python-Anwendung

Nachdem Sie Ihrer Anwendung ein Codebeispiel hinzugefügt haben, erstellen Sie das Programm, und führen Sie es aus:

1. Navigieren Sie zu Ihrer translator-app.py-Datei.

2. Geben Sie den folgenden Befehl in Ihrer Konsole ein:

   python translator-app.py
   

Übersetzungsausgabe:

Nach einem erfolgreichen Aufruf sollten Sie die folgende Antwort sehen:

[
  {
    "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"
      }
    ]
  }
]