Utilizza le librerie client di Cloud in Cloud Code

Installa le librerie client di Cloud dell'API Cloud Translation:

1. Per aprire un terminale, fai clic su Terminale > Nuovo terminale.

2. Esegui questo comando:

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

Crea un file app.go.

Apri app.go e aggiungi il nome del pacchetto, le importazioni e lo scheletro dell'app:

package main

import (
  "context"
  "fmt"

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

func translateText(w io.Writer, projectID string, sourceLang string, targetLang string, text string) error {

}

func main() {

}

Nella funzione translateText(), aggiungi il seguente codice, che consente di tradurre il testo specificato. Seleziona File > Salva per riformattare il codice:

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

Nella funzione main(), chiama translateText(). Le seguenti I valori dei parametri traducono dall'inglese allo spagnolo:

projectID := "<var>PROJECT_ID</var>"
sourceLang := "en-US"
targetLang := "es"
text := "Text to translate"

err := translateText(os.Stdout, projectID, sourceLang, targetLang, text)
if err != nil {
  fmt.Print(err)
}

Esegui l'applicazione dal terminale.

go run app.go

Apri pom.xml e aggiungi il seguente snippet di codice a dependencies sezione:

<dependencies>
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>test</scope>
  </dependency>
  <dependency>
    <groupId>com.google.cloud</groupId>
    <artifactId>google-cloud-translate</artifactId>
  </dependency>
</dependencies>

Poi, nel file pom.xml, aggiungi il seguente snippet di codice alla Sezione dependencyManagement:

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

Assicurati di utilizzare la versione più recente di Google Cloud Supportata Biblioteche. Per un elenco delle versioni, vedi Librerie supportate da Google Cloud.

Quando ti viene chiesto se vuoi sincronizzare classpath/configurazione di Java, fai clic su Sempre.

Crea un file denominato app.java.

In app.java, includi le seguenti importazioni dopo il pacchetto definizione:

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;

Aggiungi il metodo translateText() al tuo corso App. Questo metodo imposta e trasmette le variabili a un metodo translateText() sovraccarico. I seguenti valori traducono dall'inglese allo spagnolo:

public static void translateText() throws IOException {
  String projectId = "<walkthrough-project-id/>";
  String targetLanguage = "es";
  String text = "Hello world!";
  translateText(projectId, targetLanguage, text);
}

Aggiungi un metodo translateText() sovraccarico. Questo metodo converte il testo nella lingua di destinazione.

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

  try (TranslationServiceClient client = TranslationServiceClient.create()) {
    LocationName parent = LocationName.of(projectId, "global");

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

Sostituisci il testo stampato in main con una chiamata a translateText():

try {
  translateText();
}
catch (IOException e) {
  e.printStackTrace();
}

Installa le librerie client di Cloud dell'API Cloud Translation:

1. Fai clic su Cloud Code ed espandi l'explorer dell'API Cloud.
2. Espandi Cloud AI e fai clic su API Cloud Translation.
3. Per installare la libreria client, fai clic su NodeJS e quindi su play_arrow Esegui nel terminale.
   

Crea un file app.js nel progetto.

Apriapp.js e importa la libreria client di traduzione all'inizio del file:

const {TranslationServiceClient} = require('@google-cloud/translate');

Crea un client API Translation e aggiungi variabili per il tuo ID progetto. posizione e il testo che vuoi tradurre:

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

const projectId = 'PROJECT_ID';
const location = 'global';
const text = 'Hello, world!';

Aggiungi la seguente funzione async, che rileva la lingua del tuo Hello, world! e lo traduce in spagnolo:

async function translateText() {
    // Construct request
    const request = {
        parent: `projects/PROJECT_ID/locations/LOCATION`,
        contents: [text],
        mimeType: 'text/plain', // mime types: text/plain, text/html
        sourceLanguageCode: 'en',
        targetLanguageCode: 'es',
    };

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

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

Al termine del tuo file app.js, chiama translateText():

translateText();

Per eseguire l'applicazione, apri la tavolozza dei comandi (premi Ctrl/Cmd Shift P) e poi esegui Cloud Code: esegui su Kubernetes.

Dopo il deployment dell'applicazione, visualizza il servizio in esecuzione aprendo la URL visualizzato nella webView.

Installa le librerie client di Cloud dell'API Cloud Translation:

1. Fai clic su Cloud Code ed espandi l'explorer dell'API Cloud.
2. Espandi Cloud AI e fai clic su API Cloud Translation.
3. Per installare la libreria client, fai clic su Python, quindi fai clic su play_arrow Esegui nel terminale.
   Nota: se utilizzi un sistema operativo basato su Linux, inclusi Chromebook, rivedi il comando in modo che utilizzi pip3 anziché pip. Se utilizzi un Mac, rivedi il comando per utilizzare pip3 e aggiungi il flag --user.

Crea un file app.py nel progetto.

In app.py, importa la libreria client all'inizio del file:

from google.cloud import translate

Aggiungi la funzione translate_text. Questo comando inizializza un client per l'interazione l'API Cloud Translation.

def translate_text(text="Hello, world!", project_id="PROJECT_ID"):

client = translate.TranslationServiceClient()
location = "global"
parent = "projects/PROJECT_ID/locations/LOCATION"

Per tradurre il testo dall'inglese allo spagnolo e stampare il risultato, translate_text, aggiungi la chiamata seguente all'API Cloud Translation Librerie client di Cloud:

   response = client.translate_text(
    request={
        "parent": parent,
        "contents": [text],
        "mime_type": "text/plain",
        "source_language_code": "en-US",
        "target_language_code": "es",
    }
)

for translation in response.translations:
    print("Translated text: {}".format(translation.translated_text))

Alla fine di app.py, chiama il numero translate_text().

translate_text()

Per eseguire l'applicazione, apri la tavolozza dei comandi (premi Ctrl/Cmd Shift P) e poi esegui Cloud Code: esegui su Kubernetes.

Dopo il deployment dell'applicazione, visualizza il servizio in esecuzione aprendo la URL visualizzato nella webView.