Esta página foi traduzida pela API Cloud Translation.

Implantar automaticamente o aplicativo da Web Java de IA generativa do controle de versões para o Cloud Run

1. Visão geral

Implantar um aplicativo da Web pela primeira vez pode ser assustador. Mesmo depois da primeira implantação, se o processo for muito trabalhoso, você poderá evitar a implantação de novas versões do aplicativo. Com a implantação contínua, é possível implantar automaticamente as mudanças do seu aplicativo com facilidade.

Neste laboratório, você vai escrever um aplicativo da Web e configurar o Cloud Run para implantar automaticamente o aplicativo quando uma mudança for feita no código-fonte. Em seguida, modifique e implante o aplicativo novamente.

O que você vai aprender

Escrever um aplicativo da Web com o editor do Cloud Shell
Armazenar o código do aplicativo no GitHub
Implantar automaticamente seu aplicativo no Cloud Run

Adicionar IA generativa ao seu aplicativo usando a Vertex AI

2. Pré-requisitos

Se você ainda não tiver uma Conta do Google, crie uma.
- Use uma conta pessoal em vez de uma conta escolar ou de trabalho. As contas escolares e de trabalho podem ter restrições que impedem a ativação das APIs necessárias para este laboratório.
Se você ainda não tiver uma conta no GitHub, crie uma
- Se você já tiver uma conta, use-a, porque é mais provável que o GitHub bloqueie uma conta nova como spam.
- Configure a autenticação de dois fatores na sua conta do GitHub para reduzir as chances de sua conta ser marcada como spam.

3. Configurar o projeto

Faça login no Console do Google Cloud.
Ative o faturamento no Console do Cloud.
- A conclusão deste laboratório custa menos de US $1 em recursos do Cloud.
- Siga as etapas no final deste laboratório para excluir recursos e evitar mais cobranças.
- Novos usuários podem aproveitar a avaliação sem custos financeiros de US$300.
- Vai participar de um evento sobre IA generativa para desenvolvedores? Um crédito de US$1 pode estar disponível.
Crie um projeto ou reutilize um projeto existente.
Confirme se o faturamento está ativado em Meus projetos no Faturamento do Cloud
- Se o novo projeto mostrar Billing is disabled na coluna Billing account:
  1. Clique nos três pontos na coluna Actions.
  2. Clique em Mudar faturamento.
  3. Selecione a conta de faturamento que você quer usar.
- Se você estiver participando de um evento de IA generativa para desenvolvedores, a conta provavelmente será chamada de Conta de faturamento de avaliação do Google Cloud Platform.

4. Abrir editor do Cloud Shell

Acesse o editor do Cloud Shell.
Se o terminal não aparecer na parte de baixo da tela, abra-o:
- Clique no menu de navegação .
- Clique em Terminal.
- Clique em Novo Terminal.

No terminal, defina o projeto com este comando:

Formato:
```
gcloud config set project [PROJECT_ID]
```

Exemplo:

gcloud config set project lab-project-id-example

Se você não se lembrar do ID do projeto:
- Para listar todos os IDs de projeto, use:
```
gcloud projects list | awk '/PROJECT_ID/{print $2}'
```

Se for preciso autorizar, clique em Autorizar para continuar.
Você vai receber esta mensagem:
```
Updated property [core/project].
```
Se você encontrar um WARNING e receber a pergunta Do you want to continue (Y/N)?, provavelmente inseriu o ID do projeto de forma incorreta. Pressione N, Enter e tente executar o comando gcloud config set project novamente.

5. Ativar APIs

No terminal, ative as APIs:

gcloud services enable \
  run.googleapis.com \
  cloudbuild.googleapis.com \
  aiplatform.googleapis.com

Esse comando pode levar alguns minutos para ser concluído, mas vai gerar uma mensagem de sucesso semelhante a esta:

Operation "operations/acf.p2-73d90d00-47ee-447a-b600" finished successfully.

6. Configurar o Git

Defina seu e-mail de usuário global do Git:

git config --global user.email "you@example.com"

Defina seu nome de usuário global do Git:

git config --global user.name "Your Name"

Defina sua ramificação padrão global do Git como main:
```
git config --global init.defaultBranch main
```

7. Escrever o código

Para escrever um aplicativo em Java:

Navegue até o diretório principal:
```
cd ~
```
Crie o diretório codelab-genai:
```
mkdir codelab-genai
```
Navegue até o diretório codelab-genai:
```
cd codelab-genai
```

Crie um aplicativo inicial usando start.spring.io:

curl https://start.spring.io/starter.zip \
    -d dependencies=web \
    -d javaVersion=17 \
    -d type=maven-project \
    -d bootVersion=3.3.2 -o java-starter.zip

Descompacte o aplicativo inicial:
```
unzip java-starter.zip 
```
Remover o zíper para reduzir a desordem
```
rm java-starter.zip
```
Execute este comando para adicionar um arquivo project.toml que vai configurar os buildpacks do Cloud para usar o Java 17.
```
cat > project.toml << EOF
[[build.env]]
    name = "GOOGLE_RUNTIME_VERSION"
    value = "17"
EOF
```
Abra o arquivo DemoApplication.java no editor do Cloud Shell:
```
cloudshell edit src/main/java/com/example/demo/DemoApplication.java
```
Um arquivo principal estruturado vai aparecer na parte de cima da tela. É aqui que você pode editar o arquivo DemoApplication.java.

Copie o código a seguir e cole no arquivo DemoApplication.java aberto:

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.GetMapping;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

@RestController
class HelloController {

    @GetMapping("/")
    public String hello() {
        return "Hello world!";
    }

}

Depois de alguns segundos, o Cloud Shell Editor vai salvar seu código automaticamente. Esse código responde a solicitações HTTP com a saudação "Hello world!". Ter duas classes em um arquivo é um pouco incomum para apps Spring. Essa escolha foi feita para simplificar o codelab.

O código inicial do aplicativo está concluído e pronto para ser armazenado no controle de versão.

8. Criar um repositório

Volte ao terminal do Cloud Shell na parte de baixo da tela.
Verifique se você ainda está no diretório correto:
```
cd ~/codelab-genai
```
Inicializar o repositório Git
```
git init -b main
```
Faça login na CLI do GitHub
```
gh auth login
```
Pressione Enter para aceitar as opções padrão e siga as instruções na ferramenta de CLI do GitHub, incluindo:
1. Em qual conta você quer fazer login? GitHub.com
2. Qual é seu protocolo preferido para operações do Git neste host? HTTPS
3. Autenticar o Git com suas credenciais do GitHub? Y (pule se ele não aparecer)
4. Como você quer autenticar a CLI do GitHub? Login with a web browser
5. Copie o código único
6. Abra https://github.com/login/device.
7. Cole o código de uso único
8. Clique em Autorizar o GitHub.
9. Conclua o login
Confirme que você fez login:
```
gh api user -q ".login"
```
Se você tiver feito login, seu nome de usuário do GitHub vai aparecer.

Criar uma variável GITHUB_USERNAME

GITHUB_USERNAME=$(gh api user -q ".login")

Confirme se você criou a variável de ambiente:
```
echo ${GITHUB_USERNAME}
```
Se você tiver criado a variável, seu nome de usuário do GitHub vai aparecer.
Crie um repositório vazio do GitHub chamado codelab-genai:
```
gh repo create codelab-genai --private
```
Se você receber o erro:
```
GraphQL: Name already exists on this account (createRepository)
```
Então você já tem um repositório chamado codelab-genai. Você tem duas opções para continuar seguindo este tutorial:
- Excluir o repositório do GitHub atual
- Crie um repositório com um nome diferente e não se esqueça de mudá-lo nos comandos a seguir.

Adicione o repositório codelab-genai como o controle remoto origin:

git remote add origin https://github.com/${GITHUB_USERNAME}/codelab-genai

9. Compartilhar seu código

Confirme se você está no diretório correto:
```
cd ~/codelab-genai
```
Adicione todos os arquivos no diretório atual a este commit:
```
git add .
```
Crie o primeiro commit:
```
git commit -m "add http server"
```
Envie o commit para a ramificação main do repositório origin:
```
git push -u origin main
```

Execute este comando e acesse o URL resultante para conferir o código do aplicativo no GitHub:

echo -e "\n\nTo see your code, visit this URL:\n \
    https://github.com/${GITHUB_USERNAME}/codelab-genai/blob/main/src/main/java/com/example/demo/DemoApplication.java \n\n"

10. Configurar implantações automáticas

Deixe a guia do editor do Cloud Shell aberta. Vamos voltar a essa guia mais tarde.
Em uma nova guia, acesse a página do Cloud Run.
Selecione o projeto correto do Google Cloud no console
Clique em CONECTAR REPO.
Clique em CONFIGURAR COM O CLOUD BUILD
1. Selecione GitHub como o Provedor de repositório
  - Se você não tiver feito login na sua conta do GitHub no navegador, faça login com suas credenciais.
2. Clique em Autenticar e em Continuar.
3. Depois de fazer login, você vai ver uma mensagem na página do Cloud Run informando que O app GitHub não está instalado em nenhum dos seus repositórios.
4. Clique no botão INSTALAR O GOOGLE CLOUD BUILD.
  - Na página "Configuração da instalação", selecione Somente repositórios selecionados e escolha o repositório codelab-genai que você criou usando a CLI.
  - Clique em Instalar.
  - Observação: se você tiver muitos repositórios do GitHub, isso pode levar alguns minutos para carregar.
5. Selecione your-user-name/codelab-genai como o repositório
  - Se o repositório não estiver presente, clique no link Gerenciar repositórios conectados.
6. Deixe Ramificação como ^main$
7. Clique em Go, Node.js, Python, Java, .NET Core, Ruby ou PHP via buildpacks do Google Cloud
  - Deixe os outros campos (Build context directory, Entrypoint e Function target) como estão.
8. Clique em Salvar.
Role a tela para baixo até Autenticação.
Clique em Permitir invocações não autenticadas.
Clique em CRIAR.

Quando o build terminar (o que leva vários minutos), execute este comando e acesse o URL resultante para ver o aplicativo em execução:

echo -e "\n\nOnce the build finishes, visit your live application:\n \
    "$( \
        gcloud run services list | \
        grep codelab-genai | \
        awk '/URL/{print $2}' | \
        head -1 \
    )" \n\n"

11. Mudar o código

Volte ao editor do Cloud Shell.

Se você ainda tiver o editor do Cloud Shell aberto, pule estas etapas.

Acesse o editor do Cloud Shell.
Se o terminal não aparecer na parte de baixo da tela, abra-o:
- Clique no menu de navegação .
- Clique em Terminal.
- Clique em Novo Terminal.

No terminal, defina o projeto com este comando:

Formato:
```
gcloud config set project [PROJECT_ID]
```

Exemplo:

gcloud config set project lab-project-id-example

Se você não se lembrar do ID do projeto:
- Para listar todos os IDs de projeto, use:
```
gcloud projects list | awk '/PROJECT_ID/{print $2}'
```

Se for preciso autorizar, clique em Autorizar para continuar.
Você vai receber esta mensagem:
```
Updated property [core/project].
```
Se você encontrar um WARNING e receber a pergunta Do you want to continue (Y/N)?, provavelmente inseriu o ID do projeto de forma incorreta. Pressione N, Enter e tente executar o comando gcloud config set project novamente.

Adicionar a Vertex AI ao seu aplicativo

Volte ao terminal do Cloud Shell na parte de baixo da tela.
Verifique se você ainda está no diretório correto:
```
cd ~/codelab-genai
```

Instale o SDK da Vertex AI para Java adicionando o seguinte na linha 42 do seu pom.xml:

sed -i 's/<dependencies>/<dependencies>\r\n\r\n\t\t<dependency>\r\n\t\t\t<groupId>com.google.cloud<\/groupId>\r\n\t\t\t<artifactId>google-cloud-vertexai<\/artifactId>\r\n\t\t\t<version>1.7.0<\/version>\r\n\t\t<\/dependency>\r\n/g' pom.xml

Instale a biblioteca principal do Google Cloud para recuperar o ID do projeto mais tarde:

sed -i 's/<dependencies>/<dependencies>\r\n\r\n\t\t<dependency>\r\n\t\t\t<groupId>com.google.cloud<\/groupId>\r\n\t\t\t<artifactId>google-cloud-core<\/artifactId>\r\n\t\t\t<version>2.42.0<\/version>\r\n\t\t<\/dependency>\r\n/g' pom.xml

Reabra DemoApplication.java no editor do Cloud Shell.

cloudshell edit ~/codelab-genai/src/main/java/com/example/demo/DemoApplication.java

Substitua o código no arquivo DemoApplication.java por:

package com.example.demo;

import java.io.IOException;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.google.cloud.vertexai.VertexAI;
import com.google.cloud.vertexai.api.GenerateContentResponse;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.ResponseHandler;

import com.google.cloud.ServiceOptions;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

@RestController
class HelloController {

    String projectId = ServiceOptions.getDefaultProjectId();

    @GetMapping("/")
    public String getFacts(@RequestParam(defaultValue = "dog") String animal) throws IOException {
        String prompt = "Give me 10 fun facts about " + animal + ". Return this as html without backticks.";

        VertexAI vertexAI = new VertexAI(projectId, null);
        GenerativeModel model = new GenerativeModel("gemini-1.5-flash", vertexAI);

        GenerateContentResponse response = model.generateContent(prompt);
        return ResponseHandler.getText(response);
    }

}

12. Reimplantar

Confirme se você ainda está no diretório correto no Cloud Shell:
```
cd ~/codelab-genai
```
Execute estes comandos para confirmar uma nova versão do aplicativo no repositório git local:
```
git add .
git commit -m "add latest changes"
```
Envie as mudanças para o GitHub:
```
git push
```

Quando o build terminar, execute este comando e acesse o aplicativo implantado:

echo -e "\n\nOnce the build finishes, visit your live application:\n \
    "$( \
        gcloud run services list | \
        grep codelab-genai | \
        awk '/URL/{print $2}' | \
        head -1 \
    )" \n\n"

Pode levar vários minutos para que o build seja concluído e as mudanças apareçam.

Confira o histórico de todas as revisões aqui: https://console.cloud.google.com/run/detail/us-central1/codelab-genai/revisions

13. (Opcional) Auditar seu uso da Vertex AI

Assim como em outros serviços do Google Cloud, é possível auditar as operações da Vertex AI. Os registros de auditoria ajudam você a responder às perguntas "Quem fez o quê, onde e quando?". Os registros de auditoria administrativa da Vertex AI são ativados por padrão. Para auditar solicitações de geração de conteúdo, é necessário ativar os registros de auditoria de acesso a dados:

No console do Google Cloud, acesse a página Registros de auditoria:

Se você usar a barra de pesquisa para encontrar essa página, selecione o resultado com o subtítulo IAM e administrador.
Verifique se o projeto do Google Cloud é aquele em que você cria o aplicativo do Cloud Run.
Na tabela Configuração dos registros de auditoria de acesso a dados, encontre e selecione Vertex AI API na coluna "Serviço".
Na guia Tipos de registro, selecione os tipos de registro de auditoria de acesso a dados Admin read e Data read.
Clique em Salvar.

Depois de ativar, você poderá ver os registros de auditoria de cada invocação do aplicativo. Para ver os registros de auditoria com detalhes de invocação, faça o seguinte:

Volte para o aplicativo implantado e atualize a página para acionar o registro.
No console do Google Cloud, acesse a página Explorador de registros:

Na janela de consulta, digite:

LOG_ID("cloudaudit.googleapis.com%2Fdata_access")
protoPayload.serviceName="aiplatform.googleapis.com"

Clique em Executar consulta.

Os registros de auditoria capturam o uso da API Vertex AI, mas não permitem observar dados relacionados a cargas de trabalho, como comandos ou detalhes de respostas.

14. (Opcional) Aumentar a capacidade de observação da sua carga de trabalho de IA

Os registros de auditoria não capturam informações relacionadas à carga de trabalho. Para aumentar a capacidade de observação das suas cargas de trabalho, é necessário registrar essas informações explicitamente. Você pode usar sua estrutura de geração de registros favorita para fazer isso. As etapas a seguir demonstram como fazer isso usando o mecanismo de geração de registros nativo do Java Util.

Reabra DemoApplication.java no editor do Cloud Shell.

cloudshell edit ~/codelab-genai/src/main/java/com/example/demo/DemoApplication.java

Substitua o código no arquivo DemoApplication.java por:

package com.example.demo;

import java.io.IOException;
import java.util.HashMap;
import java.util.logging.Level;
import java.util.logging.Logger;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.google.cloud.vertexai.VertexAI;
import com.google.cloud.vertexai.api.GenerateContentResponse;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.ResponseHandler;

import com.google.cloud.ServiceOptions;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

@RestController
class HelloController {
    final Logger logger = Logger.getLogger(HelloController.class.getName());

    String projectId = ServiceOptions.getDefaultProjectId();

    @GetMapping("/")
    public String getFacts(@RequestParam(defaultValue = "dog") String animal) throws IOException {
        String prompt = "Give me 10 fun facts about " + animal + ". Return this as html without backticks.";

        VertexAI vertexAI = new VertexAI(projectId, null);
        GenerativeModel model = new GenerativeModel("gemini-1.5-flash", vertexAI);

        GenerateContentResponse response = model.generateContent(prompt);
        logger.log(Level.INFO, "Content is generated",
                new HashMap<String, Object>() {
                    {
                        put("prompt", prompt);
                        put("response", response);
                    }
                });
        return ResponseHandler.getText(response);
    }

}

Esse código grava informações de stdout sobre o conteúdo gerado usando o formato de geração de registros estruturada. Um agente do Logging no Cloud Run captura a saída impressa em stdout e grava esse formato no Cloud Logging.

Reabra o Cloud Shell e digite o seguinte comando para garantir que você esteja no diretório correto:
```
cd ~/codelab-genai
```

Confirme as alterações:

git commit -am "observe generated content"

Envie as mudanças para o GitHub para acionar a nova implantação da versão modificada:
```
git push
```

Depois que a nova versão for implantada, você poderá observar as informações de depuração sobre as chamadas para a Vertex AI.

Para conferir os registros do aplicativo, faça o seguinte:

No console do Google Cloud, acesse a página Explorador de registros:

Na janela de consulta, digite:

LOG_ID("run.googleapis.com%2Fstdout")
severity=DEBUG

Clique em Executar consulta.

O resultado da consulta mostra registros com a solicitação e a resposta da Vertex AI, incluindo "classificações de segurança" que podem ser usadas para monitorar práticas de segurança.

15. (Opcional) Limpar

O Cloud Run não gera custos quando o serviço não está em uso, mas você ainda pode receber cobranças pelo armazenamento da imagem do contêiner no Artifact Registry. Você pode excluir seu projeto do Cloud para evitar cobranças. A exclusão do projeto do Cloud interrompe o faturamento de todos os recursos usados nele.

Se quiser, exclua o projeto:

gcloud projects delete $GOOGLE_CLOUD_PROJECT

Você também pode excluir recursos desnecessários do disco do Cloud Shell. Você pode:

Exclua o diretório do projeto do codelab:
```
rm -rf ~/codelab-genai
```
Aviso: Essa ação não pode ser desfeita. Se você quiser excluir tudo no Cloud Shell para liberar espaço, exclua todo o diretório principal. Tenha cuidado para que tudo o que você quer manter seja salvo em outro lugar.
```
sudo rm -rf $HOME
```

16. Parabéns

Neste laboratório, você escreveu um aplicativo da Web e configurou o Cloud Run para implantar automaticamente o aplicativo quando uma mudança fosse feita no código-fonte. Em seguida, você modificou e implantou o aplicativo novamente.

Se você gostou deste laboratório, tente de novo em outra linguagem de programação ou framework:

Se você quiser participar de um estudo de pesquisa de experiência do usuário (UX) para melhorar os produtos com que trabalhou hoje, inscreva-se aqui.

Confira algumas opções para continuar aprendendo:

Documentos: use o Genkit como uma abstração de modelo flexível que facilita a integração de qualquer API de modelo e o uso de modelos mantidos pela comunidade.
Codelab: Como implantar um app de chat com tecnologia do Gemini no Cloud Run
Como usar a chamada de função do Gemini com o Cloud Run
Como usar a API Cloud Run Jobs Video Intelligence para processar um vídeo cena por cena
Workshop sob demanda: Integração do Google Kubernetes Engine