Utilizza le librerie client di Cloud in Cloud Code

Utilizza le librerie client di Cloud in Cloud Code

Questa pagina mostra come iniziare rapidamente a utilizzare le librerie client di Cloud Cloud Code. Configurerai una nuova applicazione Kubernetes utilizzando un dell'applicazione di esempio Hello World, quindi aggiornala in modo che utilizzi l'API Cloud Translation per tradurre la risposta in spagnolo.

Prima di iniziare

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Make sure that billing is enabled for your Google Cloud project.

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

   Enable the APIs

5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

6. Make sure that billing is enabled for your Google Cloud project.

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

   Enable the APIs

8. Installa Git in modo che Cloud Code può eseguire operazioni Git, come la clonazione di campione.
9. Se non l'hai ancora fatto, installa il plug-in Cloud Code.

Crea un'applicazione

1. Dalla tavolozza dei comandi (Cmd/Ctrl+Shift+P), esegui Cloud Code: New Application, scegli Kubernetes Application quindi scegli un'app Hello World nella lingua che preferisci. Ad esempio, scegli Node.js: Hello World per creare un'app di partenza Node.js Hello World.
2. Salva la nuova applicazione. Viene visualizzata una notifica che conferma la creazione della richiesta e si apre una nuova finestra con la richiesta.

Configura le credenziali

Nota: le chiavi degli account di servizio comportano un rischio per la sicurezza se non vengono gestite correttamente. Dovresti Scegliere un'alternativa più sicura alle chiavi degli account di servizio ove possibile. Se devi effettuare l'autenticazione con una chiave dell'account di servizio, sei responsabile della sicurezza della chiave privata e di altre operazioni descritte dalle best practice per la gestione delle chiavi degli account di servizio. Se non è possibile creare una chiave dell'account di servizio, è possibile disattivato per la tua organizzazione. Per ulteriori informazioni, vedi Gestione delle risorse dell'organizzazione sicure per impostazione predefinita.

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

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 la versione più recente di Google Cloud Supportata Biblioteche. Per un elenco delle versioni, consulta Librerie supportate di Google Cloud.

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

4. Crea un file denominato app.java.

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

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 la dichiarazione stampata in main con una chiamata a translateText():

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

Node.js

1. Installa le librerie client di Cloud Translation:

   1. Fai clic su Cloud Code ed espandi l'esploratore 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 quindi su play_arrow Esegui nel terminale.
      

2. Crea un file app.js nel progetto.

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

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

4. 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!';
   

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: esegui su 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 l'esploratore 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, inclusi Chromebook, rivedi il comando in modo che utilizzi pip3 anziché pip. Se utilizzi un Mac, rivedi il comando da utilizzare pip3 e aggiungi il flag --user.

2. Crea un file app.py nel 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 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"
   

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: esegui su Kubernetes.

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

Esegui la pulizia

Dopo aver interrotto 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 questo inizio rapido, assicurati di eliminare il progetto o il cluster che hai creato se vuoi riutilizzarlo.

Per eliminare il cluster:

1. Nella Kubernetes Explorer, metti in pausa il nome del cluster e fai clic su open_in_new Apri nella console Google Cloud.
2. Fai clic su Elimina e quindi su Elimina.

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

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

• L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività descritte in questo documento, quando lo elimini elimini anche tutto il lavoro svolto nel progetto.
• Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un appspot.com URL, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, il riuso dei progetti può aiutarti a non superare i limiti di quota.

1. In the Google 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 i problemi su GitHub o fai una domanda su Stack Overflow.

Passaggi successivi

• Scopri di più sull'API Cloud Translation
• Scopri di più sulle librerie client di Cloud
• Scopri di più su Cloud Code per VS Code