Usar as bibliotecas de cliente do Cloud no Cloud Code

Nesta página, mostramos como começar rapidamente a usar as bibliotecas de cliente do Cloud e Cloud Code. Você vai configurar um novo aplicativo do Kubernetes usando um o aplicativo de exemplo Hello World e atualizar o aplicativo para usar a A API Cloud Translation para traduzir a resposta para o espanhol.

Antes de começar

  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.

    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.

  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.
  8. Instale o Git para que O Cloud Code pode executar operações Git, como a clonagem de amostra.
  9. Instale o plug-in do Cloud Code, caso ainda não tenha feito isso.

Criar um aplicativo

  1. Na paleta de comandos (Cmd/Ctrl+Shift+P), execute Cloud Code: novo aplicativo, escolha Aplicativo Kubernetes e escolha um app Hello World no idioma da sua preferência. Por exemplo, escolha Node.js: Hello World para criar um app "Hello World" em Node.js.
  2. Salve o novo aplicativo. Uma notificação confirma que seu aplicativo foi criado e um uma nova janela com seu aplicativo é aberto.

Configurar credenciais

  1. Para abrir um terminal, clique em Terminal > Novo terminal.

  2. Crie uma conta de serviço para autenticar suas solicitações de API:

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

  3. Conceda à sua conta de serviço a função do usuário da 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. Crie uma chave de conta de serviço:

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

  5. Defina a chave como suas credenciais padrão:

    export \
 GOOGLE_APPLICATION_CREDENTIALS=key.json

Chamar a API Cloud Translation a partir do seu aplicativo

Go

  1. Instale as bibliotecas de cliente do Cloud para a API Cloud Translation:

    1. Para abrir um terminal, clique em Terminal > Novo terminal.

    2. Execute este comando:

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

  2. Crie um arquivo app.go.

  3. Abra app.go e adicione o nome do pacote, as importações e o esqueleto do 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. Na função translateText(), adicione o código abaixo, que traduz o texto especificado. Selecione Arquivo > Salvar para reformatar seu código:

    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. Na função main(), chame translateText(). O seguinte valores de parâmetro traduzem do inglês para o espanhol:

    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. Execute o aplicativo no terminal.

    go run app.go

Java

  1. Abra pom.xml e adicione o seguinte snippet de código ao dependencies seção:

    <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. Em seguida, no arquivo pom.xml, adicione o seguinte snippet de código à seção 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>

    Verifique se você está usando a versão mais recente das bibliotecas com suporte do Google Cloud. Para uma lista de versões, consulte Bibliotecas compatíveis com o Google Cloud.

  3. Quando for perguntado se você quer sincronizar o caminho de classe/configuração do Java, Clique em Sempre.

  4. Crie um arquivo chamado app.java.

  5. Em app.java, inclua as seguintes importações após o pacote definição:

    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. Adicione o método translateText() à classe App. Esse método define e transmite variáveis para um método translateText() sobrecarregado. Os valores de parâmetro a seguir traduzem inglês para espanhol:

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

  7. Adicione um método translateText() sobrecarregado. Esse método pega o texto e o traduz para o idioma de destino.

    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. Substitua a instrução de impressão no main por uma chamada para translateText():

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

Node.js

  1. Instale as bibliotecas de cliente do Cloud para a API Cloud Translation:

    1. Clique em Cloud Code e abra o explorador de APIs do Cloud.
    2. Expanda Cloud AI e clique em API Cloud Translation.
    3. Para instalar a biblioteca de cliente, clique em NodeJS e em play_arrow Execute no terminal.

  2. Crie um arquivo app.js no projeto.

  3. Abrir app.js e importe a biblioteca de cliente do Translation no início do arquivo:

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

  4. Crie um cliente da API Translation e adicione variáveis para o ID do projeto, o local e o texto que você quer traduzir:

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

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

  5. Adicione a seguinte função async, que detecta o idioma do seu Hello, world! e traduz o texto para o espanhol:

    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. No final do arquivo app.js, chame translateText():

    translateText();

  7. Para executar o aplicativo, abra a paleta de comandos (pressione Ctrl/Cmd + Shift + P) e execute Cloud Code: Run on Kubernetes.

  8. Depois que o aplicativo for implantado, abra o URL exibido na WebView para conferir o serviço em execução.

Python

  1. Instale as bibliotecas de cliente do Cloud da API Cloud Translation:

    1. Clique em Cloud Code e abra o explorador de APIs do Cloud.
    2. Expanda Cloud AI e clique em API Cloud Translation.
    3. Para instalar a biblioteca de cliente, clique em Python e depois em play_arrow Execute no terminal.
      Observação: se você está usando um sistema operacional baseado em Linux, incluindo Chromebook, revise o comando para usar pip3 em vez de pip Se você estiver usando um Mac, revise o comando para usar pip3 e adicione a sinalização --user.

  2. Crie um arquivo app.py no projeto.

  3. Em app.py, importe a biblioteca de cliente no início do arquivo:

    from google.cloud import translate

  4. Adicione a função translate_text. Isso inicializa um cliente para 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. Para traduzir um texto do inglês para o espanhol e imprimir o resultado, no translate_text, adicione a seguinte chamada à API Cloud Translation Bibliotecas de cliente do 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. No final de app.py, chame translate_text().

    translate_text()

  7. Para executar o aplicativo, abra a paleta de comandos (pressione Ctrl/Cmd + Shift + P) e executar Cloud Code: executar no Kubernetes.

  8. Depois que o aplicativo for implantado, acesse o serviço em execução no URL exibido no webview.

Limpar

Após a interrupção do aplicativo, todos os recursos do Kubernetes implantados durante execução são excluídos automaticamente.

Para evitar cobranças na sua conta por outros recursos usados neste de início rápido, exclua o projeto ou o cluster criado se você quer reutilizar o projeto.

Para excluir o cluster, siga estas etapas:

  1. Na Kubernetes Explorer, pause o nome do cluster e clique em open_in_new Abrir no console do Google Cloud.
  2. Clique em Excluir e em Excluir.

Para excluir o projeto (e os recursos associados, incluindo os 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.

Receber suporte

Para enviar feedback, informe problemas em GitHub, ou faça uma pergunta sobre Stack Overflow.

A seguir