Utiliser les bibliothèques clientes Cloud dans Cloud Code

Cette page vous explique comment démarrer rapidement avec les bibliothèques clientes Cloud et Cloud Code. Vous configurerez une nouvelle application Kubernetes l'exemple d'application Hello World, puis mettez-la à jour pour qu'elle utilise l'API Cloud Translation pour traduire la réponse en espagnol.

Avant de commencer

  1. Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.
  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud 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.

    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. Installez Git pour que Cloud Code peut effectuer des opérations Git, comme cloner un échantillon.
  9. installer le plug-in Cloud Code ; si ce n'est pas déjà fait.

Créer une application

  1. Dans la palette de commandes (Cmd/Ctrl+Shift+P), exécutez Cloud Code: New Application (Cloud Code : Nouvelle application), choisissez Kubernetes Application (Application Kubernetes), puis choisissez une application Hello World dans la langue de votre choix. Par exemple, choisissez Node.js: Hello World pour créer une application Hello World Node.js de démarrage.
  2. Enregistrez la nouvelle application. Une notification confirme que votre application a été créée et qu'une nouvelle fenêtre s'ouvre.

Configurer les identifiants

  1. Pour ouvrir un terminal, cliquez sur Terminal > Nouveau terminal.

  2. Créez un compte de service pour authentifier vos requêtes API :

    gcloud iam service-accounts create \
    translation-quickstart \
    --project PROJECT_ID
  3. Attribuez le rôle d'utilisateur de l'API Cloud Translation à votre compte de service :

    gcloud projects \
    add-iam-policy-binding \
    PROJECT_ID \
    --member='serviceAccount:translation-quickstart@PROJECT_ID.iam.gserviceaccount.com' \
    --role='roles/cloudtranslate.user'
  4. Créez une clé de compte de service :

    gcloud iam service-accounts keys \
    create key.json --iam-account \
    translation-quickstart@PROJECT_ID.iam.gserviceaccount.com
  5. Définissez la clé comme identifiant par défaut :

    export \
     GOOGLE_APPLICATION_CREDENTIALS=key.json
    

Appeler l'API Cloud Translation depuis votre application

Go

  1. Installez les bibliothèques clientes Cloud de l'API Cloud Translation:

    1. Pour ouvrir un terminal, cliquez sur Terminal > Nouveau terminal.
    2. Exécutez la commande suivante :

      go get cloud.google.com/go/translate/apiv3
      
  2. Créez un fichier app.go.

  3. Ouvrez app.go et ajoutez le nom du package, les importations et le squelette de l'application :

    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. Dans votre fonction translateText(), ajoutez le code suivant, qui traduit le texte spécifié. Sélectionnez Fichier > Enregistrer pour reformater le fichier code:

    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. Dans votre fonction main(), appelez translateText(). Les éléments suivants : sont traduites de l'anglais vers l'espagnol:

    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. Depuis le terminal, exécutez votre application.

    go run app.go
    

Java

  1. Ouvrez pom.xml et ajoutez l'extrait de code suivant à 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. Ensuite, dans le fichier pom.xml, ajoutez l'extrait de code suivant à la section 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>
    

    Assurez-vous d'utiliser la dernière version des services Google Cloud compatibles Bibliothèques. Pour obtenir la liste des versions, consultez la section Bibliothèques compatibles avec Google Cloud.

  3. Lorsqu'il vous est demandé si vous souhaitez synchroniser le classpath/la configuration Java, cliquez sur Toujours.

  4. Créez un fichier nommé app.java.

  5. Dans app.java, incluez les importations suivantes après le package définition:

    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. Ajoutez la méthode translateText() à votre classe App. Cette méthode définit et transmet des variables à une méthode translateText() surchargée. Les valeurs suivantes permettent une traduction de l'anglais vers l'espagnol :

    public static void translateText() throws IOException {
      String projectId = "<walkthrough-project-id/>";
      String targetLanguage = "es";
      String text = "Hello world!";
      translateText(projectId, targetLanguage, text);
    }
    
  7. Ajoutez une méthode translateText() surchargée. Cette méthode prend du texte et le traduit dans la langue cible.

    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. Remplacez l'instruction d'impression dans votre main par un appel à translateText():

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

Node.js

  1. Installez les bibliothèques clientes Cloud de l'API Cloud Translation :

    1. Cliquez sur . Cloud Code, puis développez l'explorateur d'API Cloud.
    2. Développez Cloud AI, puis cliquez sur API Cloud Translation :
    3. Pour installer la bibliothèque cliente, cliquez sur NodeJS, puis sur play_arrow Exécuter dans le terminal
  2. Créez un fichier app.js dans votre projet.

  3. Ouvrirapp.js et importez la bibliothèque cliente Translation au début du fichier:

    const {TranslationServiceClient} = require('@google-cloud/translate');
    
  4. Créez un client pour l'API Translation et ajoutez des variables pour l'ID de votre projet. la zone géographique et le texte à traduire:

    // Instantiates a client
    const translationClient = new TranslationServiceClient();
    
    const projectId = 'PROJECT_ID';
    const location = 'global';
    const text = 'Hello, world!';
    
  5. Ajoutez la fonction async suivante, qui détecte la langue de votre Hello, world! et le traduit en espagnol:

    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. À la fin de votre fichier app.js, appelez translateText() :

    translateText();
    
  7. Pour exécuter votre application, ouvrez la palette de commandes (appuyez sur Ctrl/Cmd + Shift + P), puis exécuter Cloud Code: exécution sur Kubernetes.

  8. Une fois l'application déployée, affichez le service en cours d'exécution en ouvrant la URL affichée dans la webview.

Python

  1. Installez les bibliothèques clientes Cloud de l'API Cloud Translation :

    1. Cliquez sur . Cloud Code, puis développez l'explorateur d'API Cloud.
    2. Développez IA Cloud, puis cliquez sur API Cloud Translation.
    3. Pour installer la bibliothèque cliente, cliquez sur Python, puis sur play_arrow Exécuter dans le terminal.
      Remarque : Si vous utilisez un système d'exploitation basé sur Linux, y compris un Chromebook, modifiez la commande pour utiliser pip3 au lieu de pip. Si vous utilisez un Mac, révisez la commande pour utiliser pip3 et ajoutez l'indicateur --user.
  2. Créez un fichier app.py dans votre projet.

  3. Dans app.py, importez la bibliothèque cliente au début du fichier :

    from google.cloud import translate
    
  4. Ajoutez la fonction translate_text : Cela initialise un client avec lequel interagir 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. Pour traduire du texte de l'anglais vers l'espagnol et imprimer le résultat, dans votre translate_text, ajoutez l'appel suivant à l'API Cloud Translation Bibliothèques clientes 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))
    
  6. À la fin de app.py, appelez translate_text().

    translate_text()
  7. Pour exécuter votre application, ouvrez la palette de commandes (appuyez sur Ctrl/Cmd + Shift + P), puis exécuter Cloud Code: exécution sur Kubernetes.

  8. Une fois l'application déployée, affichez votre service en cours d'exécution en ouvrant l'URL affichée dans la vue Web.

Effectuer un nettoyage

Une fois l'application arrêtée, toutes les ressources Kubernetes déployées pendant l'exécution sont automatiquement supprimés.

Afin d'éviter que des frais ne soient facturés sur votre compte pour d'autres ressources utilisées au cours de cette n'oubliez pas de supprimer le projet ou le cluster que vous avez créé vous souhaitez réutiliser le projet.

Pour supprimer le cluster :

  1. Dans Explorateur Kubernetes, interrompez la session sur le nom de votre cluster, puis cliquez sur open_in_new Ouvrez-les dans la console Google Cloud.
  2. Cliquez sur Supprimer et de nouveau sur Supprimer.

Pour supprimer votre projet (et les ressources associées, y compris les clusters) :

  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.

Obtenir de l'aide

Pour envoyer des commentaires, signalez les problèmes sur GitHub ou poser une question sur Stack Overflow.

Étape suivante