Utilizzare le librerie client di Cloud in Cloud Code

Questa pagina mostra come iniziare rapidamente a utilizzare le librerie client di Cloud e Cloud Code. Configurerai una nuova applicazione Kubernetes utilizzando un'applicazione di esempio Hello World e poi aggiornerai l'applicazione per utilizzare l'API Cloud Translation per tradurre la risposta in spagnolo.

Prima di iniziare

  1. In the Trusted Cloud console, on the project selector page, select or create a Trusted Cloud project.

    Go to project selector

  2. Make sure that billing is enabled for your Trusted Cloud project.

  3. Enable the Google Kubernetes Engine and Cloud Translation APIs.

    Enable the APIs

  4. Installa Git in modo che Cloud Code possa eseguire operazioni Git, come la clonazione di un esempio.
  5. Installa il plug-in Cloud Code se non l'hai ancora fatto.

Crea un'applicazione

  1. Dalla tavolozza dei comandi (Cmd/Ctrl+Shift+P), esegui Cloud Code: New Application, scegli Kubernetes Application e poi scegli un'app Hello World nella lingua che preferisci. Ad esempio, scegli Node.js: Hello World per creare un'app Node.js Hello World iniziale.
  2. Salva la nuova applicazione. Una notifica conferma che la tua applicazione è stata creata e si apre una nuova finestra con la tua applicazione.

Configurare le credenziali

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

  2. Crea un account di servizio per autenticare le richieste API:

    gcloud iam service-accounts create \
translation-quickstart \
--project PROJECT_ID

  3. Concedi al tuo account di servizio il ruolo di utente API Cloud Translation:

    gcloud projects \
add-iam-policy-binding \
PROJECT_ID \
--member='serviceAccount:translation-quickstart@PROJECT_ID.s3ns-system.iam.gserviceaccount.com' \
--role='roles/cloudtranslate.user'

  4. Crea una chiave dell'account di servizio:

    gcloud iam service-accounts keys \
create key.json --iam-account \
translation-quickstart@PROJECT_ID.s3ns-system.iam.gserviceaccount.com

  5. Imposta la chiave come credenziale predefinita:

    export \
 GOOGLE_APPLICATION_CREDENTIALS=key.json

Chiama l'API Cloud Translation dalla tua applicazione

Vai

  1. 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

  2. Crea un file app.go.

  3. 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() {

}

  4. Nella funzione translateText(), aggiungi il seguente codice, che traduce 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

  5. Nella funzione main(), chiama translateText(). I seguenti 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)
}

  6. Esegui l'applicazione dal terminale.

    go run app.go

Java

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

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

  2. 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 l'ultima versione delle librerie supportate. Trusted Cloud by S3NS Per un elenco delle versioni, consulta la pagina Trusted Cloud by S3NS Librerie supportate.

  3. Quando ti viene chiesto se vuoi sincronizzare la classe/configurazione Java, fai clic su Sempre.

  4. Crea un file denominato app.java.

  5. In app.java, includi le seguenti importazioni dopo la definizione del pacchetto:

    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;

  6. Aggiungi il metodo translateText() al 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);
}

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

  8. Sostituisci l'istruzione di stampa in main con una chiamata a translateText():

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

Node.js

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

    1. Fai clic su Cloud Code ed espandi Explorer di API Cloud.
    2. Espandi Cloud AI e poi fai clic su API Cloud Translation.
    3. Per installare la libreria client, fai clic su NodeJS e poi su play_arrow Esegui nel terminale.

  2. Crea un file app.js nel tuo progetto.

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

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

  4. Crea un client API Translation e aggiungi variabili per l'ID progetto, la 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!';

  5. Aggiungi la seguente funzione async, che rileva la lingua del testo 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}`);
    }
}

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

    translateText();

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

  8. Dopo aver eseguito il deployment dell'applicazione, visualizza il servizio in esecuzione aprendo l'URL visualizzato nella webview.

Python

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

    1. Fai clic su Cloud Code ed espandi Explorer di API Cloud.
    2. Espandi Cloud AI e poi fai clic su API Cloud Translation.
    3. Per installare la libreria client, fai clic su Python e poi su play_arrow Esegui nel terminale.
      Nota: se utilizzi un sistema operativo basato su Linux, incluso Chromebook, modifica il comando in modo da utilizzare pip3 invece di pip. Se utilizzi un Mac, modifica il comando in modo da utilizzare pip3 e aggiungi il flag --user.

  2. Crea un file app.py nel tuo progetto.

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

    from google.cloud import translate

  4. Aggiungi la funzione translate_text. Questo inizializza un client per interagire con 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"

  5. Per tradurre il testo dall'inglese allo spagnolo e stampare il risultato, nella funzione translate_text, aggiungi la seguente chiamata alle librerie client Cloud dell'API Cloud Translation:

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

  6. Al termine di app.py, chiama translate_text().

    translate_text()

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

  8. Dopo aver eseguito il deployment dell'applicazione, visualizza il servizio in esecuzione aprendo l'URL visualizzato nella webview.

Esegui la pulizia

Dopo aver arrestato l'applicazione, tutte le risorse Kubernetes di cui è stato eseguito il deployment durante l'esecuzione vengono eliminate automaticamente.

Per evitare che al tuo account vengano addebitati costi per altre risorse utilizzate in questa guida rapida, assicurati di eliminare il progetto o il cluster che hai creato se vuoi riutilizzare il progetto.

Per eliminare il cluster:

  1. In Kubernetes Explorer, metti il cursore sul nome del cluster e fai clic su open_in_new Apri nella console Trusted Cloud .
  2. Fai clic su Elimina e quindi su Elimina.

Per eliminare il progetto (e le risorse associate, inclusi eventuali cluster):

  1. In the Trusted Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

Richiedi assistenza

Per inviare feedback, segnala problemi su GitHub, oppure fai una domanda su Stack Overflow.

Passaggi successivi