Usar as bibliotecas de cliente do Cloud no Cloud Code

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. Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

2. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

   Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

   Acessar o seletor de projetos

3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

4. Ative as APIs Google Kubernetes Engine and Cloud Translation.

   Ative as APIs

5. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

   Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

   Acessar o seletor de projetos

6. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

7. Ative as APIs Google Kubernetes Engine and Cloud Translation.

   Ative as APIs

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

Observação: as chaves de conta de serviço poderão causar problemas de segurança se não forem gerenciadas corretamente. Sempre que possível, escolha uma alternativa mais segura para as chaves de conta de serviço. Caso seja necessário autenticar com uma chave de conta de serviço, você será responsável pela segurança da chave privada e por outras operações descritas em Práticas recomendadas para gerenciar chaves de contas de serviço. Se não for possível criar uma chave de conta de serviço, a criação pode ser desativada para sua organização. Para mais informações, consulte Gerenciar recursos da organização com segurança por padrão.

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 da 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 ao 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 do suporte do Google Cloud Bibliotecas. 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 exibiçã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 da API Cloud Translation:

   1. Clique em . Cloud Code e, em seguida, expandir 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. 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 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.

Python

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

   1. Clique em . Cloud Code e, em seguida, expandir 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):

Cuidado: excluir um projeto tem os seguintes efeitos:

• Tudo no projeto é excluído. Se você tiver usado um projeto existente para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos no projeto.
• Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja passar por várias arquiteturas, tutoriais ou guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

1. No Console do Google Cloud, acesse a página Gerenciar recursos.

   Acessar "Gerenciar recursos"

2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

Receber suporte

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

A seguir

• Saiba mais sobre a API Cloud Translation.
• Saiba mais sobre as bibliotecas de cliente do Cloud.
• Saiba mais sobre o Cloud Code para VS Code.