Esta página foi traduzida pela API Cloud Translation.

Automação da revisão de código com a IA generativa

1. Visão geral

Neste laboratório, você vai configurar o pipeline CICD e integrar com o Gemini para automatizar as etapas de revisão de código.

O que você vai aprender

Você vai aprender a:

Como adicionar etapas de automação de revisão de código do GenAI no GitHub, GitLab e CircleCI
Como usar agentes e kits de ferramentas do LangChain ReAct para automatizar tarefas, como comentar em problemas do GitLab e abrir tickets do JIRA

Pré-requisitos

Para fazer este laboratório, é preciso saber usar o console do Cloud e os ambientes do Cloud Shell.

2. Configuração e requisitos

Configuração do projeto do Cloud

Faça login no Console do Google Cloud e crie um novo projeto ou reutilize um existente. Crie uma conta do Gmail ou do Google Workspace, se ainda não tiver uma.

O Nome do projeto é o nome de exibição para os participantes do projeto. É uma string de caracteres não usada pelas APIs do Google e pode ser atualizada quando você quiser.
O ID do projeto precisa ser exclusivo em todos os projetos do Google Cloud e não pode ser mudado após a definição. O console do Cloud gera automaticamente uma string exclusiva. Em geral, não importa o que seja. Na maioria dos codelabs, é necessário fazer referência ao ID do projeto, normalmente identificado como PROJECT_ID. Se você não gostar do ID gerado, crie outro aleatório. Se preferir, teste o seu e confira se ele está disponível. Ele não pode ser mudado após essa etapa e permanece durante o projeto.
Para sua informação, há um terceiro valor, um Número do projeto, que algumas APIs usam. Saiba mais sobre esses três valores na documentação.

Em seguida, ative o faturamento no console do Cloud para usar os recursos/APIs do Cloud. A execução deste codelab não vai ser muito cara, se tiver algum custo. Para encerrar os recursos e evitar cobranças além deste tutorial, exclua os recursos criados ou exclua o projeto. Novos usuários do Google Cloud estão qualificados para o programa de US$ 300 de avaliação sem custos.

Configuração do ambiente

Abra o chat do Gemini.

Ou digite "Pergunte ao Gemini" na barra de pesquisa.

Ative a API Cloud AI Companion:

Clique em Start chatting e siga uma das perguntas de exemplo ou digite seu próprio comando para testar.

Sugestões de comandos:

Explique o Cloud Run em cinco pontos principais.
Você é gerente de produto do Google Cloud Run e explica o Cloud Run para um estudante em cinco pontos-chave.
Você é gerente de produto do Google Cloud Run e explica o Cloud Run para um desenvolvedor certificado do Kubernetes em cinco pontos-chave.
Você é gerente de produto do Google Cloud Run e explica a um desenvolvedor sênior em cinco pontos principais quando usar o Cloud Run em vez do GKE.

Confira o guia de comandos para saber como escrever comandos melhores.

Como o Gemini para o Google Cloud usa seus dados

Compromisso do Google com a privacidade

O Google foi um dos primeiros no setor a publicar um compromisso de privacidade de IA/ML, que descreve que os clientes precisam ter o mais alto nível de segurança e controle sobre os dados armazenados na nuvem.

Dados que você envia e recebe

As perguntas que você faz ao Gemini, incluindo qualquer informação de entrada ou código que você envia para análise ou conclusão, são chamadas de comandos. As respostas ou códigos que você recebe do Gemini são chamados de respostas. O Gemini não usa seus comandos nem as respostas deles como dados para treinar os modelos.

Criptografia de instruções

Quando você envia comandos para o Gemini, os dados são criptografados em trânsito como entrada para o modelo subjacente no Gemini.

Dados do programa gerados pelo Gemini

O Gemini é treinado com base no código próprio do Google Cloud e em códigos de terceiros selecionados. Você é responsável pela segurança, testes e eficácia do seu código, incluindo qualquer preenchimento, geração ou análise de código que o Gemini oferece.

Saiba mais sobre como o Google processa suas solicitações.

3. Opções para testar solicitações

Se você quiser mudar/ampliar as solicitações de cli devai, você tem várias opções para isso.

Vertex AI Studio

O Vertex AI Studio faz parte da plataforma Vertex AI do Google Cloud, projetada especificamente para simplificar e acelerar o desenvolvimento e o uso de modelos de IA generativa.

Google AI Studio

O Google AI Studio é uma ferramenta baseada na Web para prototipagem e experimentação com engenharia de comando e a API Gemini. Inscreva-se no Gemini 1.5 Pro com janela de contexto de 1 milhão ou saiba mais.

Web app Gemini (gemini.google.com)

O web app Gemini (gemini.google.com) é uma ferramenta baseada na Web projetada para ajudar você a explorar e usar o poder dos modelos de IA do Gemini do Google.

App Google Gemini para dispositivos móveis Android e Google para iOS

4. Criar a conta de serviço

Ative o Cloud Shell clicando no ícone à direita da barra de pesquisa.

No terminal aberto, ative os serviços necessários para usar as APIs da Vertex AI e o chat Gemini.

gcloud services enable \
    aiplatform.googleapis.com \
    cloudaicompanion.googleapis.com \
    cloudresourcemanager.googleapis.com \
    secretmanager.googleapis.com

Se for preciso autorizar, clique em "Autorizar" para continuar.

Execute os comandos a seguir para criar uma nova conta de serviço e chaves.

Você vai usar essa conta de serviço para fazer chamadas de API para a API Gemini da Vertex AI de pipelines CICD.

PROJECT_ID=$(gcloud config get-value project)
SERVICE_ACCOUNT_NAME='vertex-client'
DISPLAY_NAME='Vertex Client'
KEY_FILE_NAME='vertex-client-key'

gcloud iam service-accounts create $SERVICE_ACCOUNT_NAME --display-name "$DISPLAY_NAME"

gcloud projects add-iam-policy-binding $PROJECT_ID --member="serviceAccount:$SERVICE_ACCOUNT_NAME@$PROJECT_ID.iam.gserviceaccount.com" --role="roles/aiplatform.admin" --condition None

gcloud projects add-iam-policy-binding $PROJECT_ID --member="serviceAccount:$SERVICE_ACCOUNT_NAME@$PROJECT_ID.iam.gserviceaccount.com" --role="roles/secretmanager.secretAccessor" --condition None

gcloud iam service-accounts keys create $KEY_FILE_NAME.json --iam-account=$SERVICE_ACCOUNT_NAME@$PROJECT_ID.iam.gserviceaccount.com

5. Bifurcar o repositório do GitHub para o repositório pessoal do GitHub

Acesse https://github.com/GoogleCloudPlatform/genai-for-developers/fork e selecione seu ID de usuário do GitHub como proprietário.

Desmarque a opção para copiar apenas a ramificação "main".

Clique em "Create fork".

6. Ativar fluxos de trabalho do GitHub Actions

Abra o repositório do GitHub bifurcado no navegador e mude para a guia "Actions" para ativar os fluxos de trabalho.

7. Adicionar segredos de repositório

Crie um segredo de repositório em "Settings / Secrets and variables / Actions" no repositório do GitHub bifurcado.

Adicione o secret do repositório com o nome "GOOGLE_API_CREDENTIALS".

Mude para a janela/guia do Google Cloud Shell e execute o comando abaixo no terminal do Cloud Shell.

cat ~/vertex-client-key.json

Copie o conteúdo do arquivo e cole como um valor para o secret.

Adicione o segredo PROJECT_ID com o ID do projeto do Qwiklabs como um valor

8. Executar o fluxo de trabalho do GitHub Actions

Acesse o repositório do GitHub no navegador e execute o fluxo de trabalho.

O fluxo de trabalho está configurado para ser executado em envio de código ou execução manual.

Selecione "GenAI For Developers" em "Todos os fluxos de trabalho" e clique em "Run workflow" usando a ramificação "main".

Analisar resultados:

Resultados do comando de cobertura de teste:

devai review testcoverage -c ${{ github.workspace }}/sample-app/src/main/java/anthos/samples/bankofanthos/balancereader

Resultados do comando de análise de código:

devai review code -c ${{ github.workspace }}/sample-app/src/main/java/anthos/samples/bankofanthos/balancereader

Resultados do comando de análise de desempenho:

devai review performance -c ${{ github.workspace }}/sample-app/src/main/java/anthos/samples/bankofanthos/balancereader

Resultados do comando de análise de segurança:

devai review security -c ${{ github.workspace }}/sample-app/src/main/java/anthos/samples/bankofanthos/balancereader

Resultados do comando "Blockers review":

devai review blockers -c ${{ github.workspace }}/sample-app/pom.xml

9. Clonar o repositório

Volte ao terminal do Cloud Shell e clone o repositório.

Crie uma pasta para o repositório do GitHub.

mkdir github
cd github

Mude YOUR-GITHUB-USERID para o ID do usuário do GitHub antes de executar os comandos.

Defina o nome de usuário e o e-mail do Git no terminal.

Atualize os valores antes de executar os comandos.

git config --global user.name "Your Name"
git config --global user.email "your_email@example.com"

git clone https://github.com/YOUR-GITHUB-USERID/genai-for-developers.git

Mude a pasta e abra o arquivo de fluxo de trabalho no editor do Cloud Shell.

cd genai-for-developers

cloudshell edit .github/workflows/devai-review.yml

Aguarde até que o arquivo de configuração seja exibido no ambiente de desenvolvimento integrado.

10. Ativar o Gemini Code Assist

Clique no ícone Gemini no canto inferior direito .

Clique em "Login to Google Cloud" e "Select a Google Cloud Project".

Na janela pop-up, selecione seu projeto do Qwiklabs.

11. Explicar o código com o Gemini Code Assist

Clique com o botão direito do mouse em qualquer lugar do arquivo devai-review.yml e selecione Gemini Code Assist > Explain este.

Explicação da revisão:

12. Executar a CLI do DEVAI localmente

Volte ao editor do Cloud Shell e abra um novo terminal.

Volte ao terminal do Cloud Shell e execute os comandos abaixo para instalar o devai localmente.

pip3 install devai-cli

A CLI foi instalada, mas não está no PATH.

WARNING: The script devai is installed in '/home/student_00_478dfeb8df15/.local/bin' which is not on PATH.
  Consider adding this directory to PATH or, if you prefer to suppress this warning, use --no-warn-script-location.

Execute o comando abaixo para atualizar a variável de ambiente PATH. Substitua pelo nome da pasta pessoal do usuário. Por exemplo: student_00_478dfeb8df15

export PATH=$PATH:/home/YOUR-USER-HOME-FOLDER/.local/bin

Execute o comando devai cli para realizar a revisão de código localmente. Analise a saída da CLI.

export PROJECT_ID=$(gcloud config get-value project)
export LOCATION=us-central1

cd ~/github/genai-for-developers

devai review code -c ./sample-app/src/main/java/anthos/samples/bankofanthos/balancereader

Abra o script de análise executando o comando abaixo:

cloudshell edit devai-cli/src/devai/commands/review.py

Clique com o botão direito do mouse em qualquer lugar do arquivo review.py e selecione Gemini Code Assist > Explain este.

Leia a explicação.

13. Desenvolvimento da CLI do DevAI

Nesta seção, você vai fazer mudanças no devai cli.

Para começar, configure o virtualenv do Python, instale os requisitos e execute o comando de exemplo.

cd ~/github/genai-for-developers/devai-cli
python3 -m venv venv
. venv/bin/activate
pip3 install -r src/requirements.txt
pip3 install --editable ./src
devai echo

Execute o comando de análise da cobertura de teste para verificar se tudo está funcionando bem:

devai review testcoverage -c ~/github/genai-for-developers/sample-app/src

Revise os resultados usando a visualização Markdown no editor do Cloud Shell.

Crie um novo arquivo e cole a resposta do Gemini.

Em seguida, use a paleta de comandos e selecione "Markdown: Open Preview".

14. Conheça os comandos da CLI deva

Comando de revisão de código

devai review code -c ~/github/genai-for-developers/sample-app/src/main/java

Comando de análise de performance

devai review performance -c ~/github/genai-for-developers/sample-app/src/main/java

Comando de análise de segurança

devai review security -c ~/github/genai-for-developers/sample-app/src/main/java

Comando de análise da cobertura de teste

devai review testcoverage -c ~/github/genai-for-developers/sample-app/src

Comandos de análise de bloqueadores

devai review blockers -c ~/github/genai-for-developers/sample-app/pom.xml
devai review blockers -c ~/github/genai-for-developers/sample-app/setup.md

Revisão e resumo de imagens/diagramas:

Diagrama de entrada[~/github/genai-for-developers/images/extension-diagram.png]:

Revisar comando:

devai review image \
  -f ~/github/genai-for-developers/images/extension-diagram.png \
  -p "Review and summarize this diagram"

Saída:

The diagram outlines a process for conducting local code reviews using a VS Code extension or CLI, leveraging Google Cloud's Vertex AI (Gemini Pro) for generating review prompts.

**Process Flow:**

1. **Code Style Check:** Developers initiate the process by checking their code for adherence to pre-defined style guidelines.
2. **Prompt Generation:** The VS Code extension/CLI sends the code to Vertex AI (Gemini Pro) on Google Cloud.
3. **Vertex AI Review:** Vertex AI analyzes the code and generates relevant review prompts.
4. **Local Review:** The prompts are sent back to the developer's IDE for their consideration.
5. **Optional Actions:** Developers can optionally:
- Create new JIRA issues directly from the IDE based on the review prompts.
- Generate new issues in a GitLab repository.

**Key Components:**

* **VS Code Extension/CLI:** Tools facilitating the interaction with Vertex AI and potential integrations with JIRA and GitLab.
* **Vertex AI (Gemini Pro):** Google Cloud's generative AI service responsible for understanding the code and generating meaningful review prompts.
* **Google Cloud Secret Manager:** Securely stores API keys and access tokens required to authenticate and interact with Google Cloud services.
* **JIRA/GitLab (Optional):** Issue tracking and project management tools that can be integrated for a streamlined workflow.

**Benefits:**

* **Automated Review Assistance:** Leveraging AI to generate review prompts saves time and improves the consistency and quality of code reviews.
* **Local Development:** The process empowers developers to conduct reviews locally within their familiar IDE.
* **Integration Options:** The flexibility to integrate with project management tools like JIRA and GitLab streamlines workflow and issue tracking.

Análise de diferença de imagem:

devai review imgdiff \
  -c ~/github/genai-for-developers/images/devai-api.png \
  -t ~/github/genai-for-developers/images/devai-api-slack.png

Saída:

The following UI elements are missing in the "AFTER UPGRADE STATE" image compared to the "BEFORE UPGRADE STATE" image:

1. **Slack:** The entire Slack element, including the icon, "Team channel" label, and the arrow indicating interaction, is absent in the AFTER UPGRADE image. 
2. **Storage Bucket:** The "Storage Bucket" element with its icon and "PDFs" label is missing in the AFTER UPGRADE image. 
3. **"GenAI Agents" label in Vertex AI block:** The BEFORE UPGRADE image has "Vertex AI Agents" and "GenAI Agent" labels within the Vertex AI block, while the AFTER UPGRADE image only has "Vertex AI."
4. **"Open JIRA Issue" and "Team Project" labels:** In the BEFORE UPGRADE image, these labels are connected to the JIRA block with an arrow. These are missing in the AFTER UPGRADE image.

**Decision Explanation:**

The analysis is based on a direct visual comparison of the two provided images, noting the presence and absence of specific UI elements and their associated labels. The elements listed above are present in the BEFORE UPGRADE image but absent in the AFTER UPGRADE image.

Comando de geração de documentação:

devai document readme -c ~/github/genai-for-developers/sample-app/src/main/

Saída:

# Bank of Anthos - Balance Reader Service

## Table of Contents
- [Description](#description)
- [Features](#features)
- [Technologies Used](#technologies-used)
- [Installation](#installation)
- [Configuration](#configuration)
- [Usage](#usage)
- [Health Checks](#health-checks)
- [Metrics and Tracing](#metrics-and-tracing)
- [Contributing](#contributing)
- [License](#license)

## Description

The Balance Reader service is a component of the Bank of Anthos sample application. It provides a REST endpoint for retrieving the current balance of a user account. This service demonstrates key concepts for building microservices with Spring Boot and deploying them to a Kubernetes cluster.

## Features

- Securely retrieves account balances using JWT authentication.
- Leverages a local cache for fast balance retrieval.
- Asynchronously processes transactions from a central ledger.
- Provides health check endpoints for Kubernetes liveness and readiness probes.
- Exposes metrics to Stackdriver for monitoring and observability.
- Supports distributed tracing with Zipkin.

## Technologies Used

- Java
- Spring Boot
- Spring Data JPA
- Hibernate
- Google Cloud SQL (PostgreSQL)
- JWT (JSON Web Token)
- Guava Cache
- Micrometer
- Stackdriver
- Zipkin

## Installation

1. **Prerequisites:**
   - Java 17 or later
   - Maven 3.5 or later
   - Docker (for containerization)
   - Kubernetes cluster (for deployment)
   - Google Cloud account (for Stackdriver and other GCP services)

Confira os comandos decli devai disponíveis no editor do Cloud Shell:

cloudshell edit ~/github/genai-for-developers/devai-cli/README.md

Ou consulte o README.md no repositório do GitHub.

15. Acompanhar todas as variáveis de ambiente em um arquivo

Inicie um novo arquivo para acompanhar todas as variáveis de ambiente (por exemplo, chaves de API, tokens de API etc.) que você vai criar.

Você vai usar esses dados para diferentes sistemas muitas vezes ao longo do laboratório. Por isso, é mais fácil fazer referência a eles em um único lugar.

16. Configuração de rastreamento de LLM do LangSmith

Crie uma conta da LangSmith e gere uma chave da API Service na seção "Configurações". https://docs.smith.langchain.com/

Defina as variáveis de ambiente necessárias para a integração do LangSmith. Substitua a chave da API do serviço antes de executar os comandos.

export LANGCHAIN_API_KEY=langsmith-service-api-key

export LANGCHAIN_TRACING_V2=true
export LANGCHAIN_ENDPOINT="https://api.smith.langchain.com"

Para evitar a exposição de informações sensíveis no terminal, a prática recomendada é usar read -s, uma maneira segura de definir variáveis de ambiente sem que o valor apareça no histórico de comandos do console. Depois de executar, cole o valor e pressione Enter.

17. Configuração do comando JIRA

Crie uma conta do JIRA, caso ainda não tenha uma.

Crie um token da API JIRA para seu projeto. https://id.atlassian.com/manage-profile/security/api-tokens

Defina estas variáveis de ambiente necessárias para a integração com o JIRA (substitua os valores antes de executar os comandos).

export JIRA_API_TOKEN=your-token-value
export JIRA_USERNAME="email that you used to register with JIRA"
export JIRA_INSTANCE_URL="https://YOUR-PROJECT.atlassian.net"
export JIRA_PROJECT_KEY="JIRA project key"
export JIRA_CLOUD=true

Abra o arquivo review.py:

cloudshell edit ~/github/genai-for-developers/devai-cli/src/devai/commands/review.py

Analisar o arquivo review.py:

    source=source.format(format_files_as_string(context))

    code_chat_model = GenerativeModel(model_name)
    code_chat = code_chat_model.start_chat()
    code_chat.send_message(qry)
    response = code_chat.send_message(source)
    ...
    else:
        click.echo(response.text)

Encontre e remova a marca de comentário da linha abaixo desta:

# Uncomment after configuring JIRA and GitLab env variables - see README.md for details

Importar o comando JIRA na parte de cima do arquivo

# from devai.commands.jira import create_jira_issue

Método para criar um problema do JIRA no método code

#create_jira_issue("Code Review Results", response.text)

Execute novamente o comando de análise do código e verifique a saída do agente:

export PROJECT_ID=$(gcloud config get-value project)
export LOCATION=us-central1

devai review code -c ~/github/genai-for-developers/sample-app/src/main/java/anthos/samples/bankofanthos/balancereader

Exemplo de resposta:

(venv) student_00_19a997c157f8@cloudshell:~/genai-for-developers/devai-cli (qwiklabs-gcp-02-71a9948ae110)$ devai review code -c ../sample-app/src/main/java/anthos/samples/bankofanthos/balancereader
/home/student_00_19a997c157f8/genai-for-developers/devai-cli/venv/lib/python3.9/site-packages/langchain_core/_api/deprecation.py:117: LangChainDeprecationWarning: The function `initialize_agent` was deprecated in LangChain 0.1.0 and will be removed in 0.2.0. Use new agent constructor methods like create_react_agent, create_json_agent, create_structured_chat_agent, etc. instead.
  warn_deprecated(
Response from Model: ```java
// Class: TransactionRepository
// Method: findBalance

// Efficiency
- Consider using a native SQL query to improve performance for complex database operations.
- Use prepared statements to avoid SQL injection vulnerabilities.

// Best Practices
- Return a Optional<Long> instead of null to handle the case when no balance is found for the given account.

/home/student_00_19a997c157f8/genai-for-developers/devai-cli/venv/lib/python3.9/site-packages/langchain_core/_api/deprecation.py:117: LangChainDeprecationWarning: a função __call__ foi descontinuada no LangChain 0.1.0 e será removida no 0.2.0. Use "invocar". warn_deprecated(

Entrando na nova cadeia AgentExecutor... Pensamento: a descrição é fornecida na pergunta, então não há nada para pensar Ação:

{
  "action": "create_issue",
  "action_input": {
    "description": "Class: TransactionRepository\nMethod: findBalance\n\nEfficiency\n- Consider using a native SQL query to improve performance for complex database operations.\n- Use prepared statements to avoid SQL injection vulnerabilities.\n\nBest Practices\n- Return a Optional<Long> instead of null to handle the case when no balance is found for the given account."
  }
}

Novo problema criado com a chave: CYMEATS-117

Observação: novo problema criado com a chave: CYMEATS-117 Pensamento:Resposta final: CYMEATS-117

Cadeia concluída.

Open your JIRA project in the browser and review the created issue.

Sample JIRA issue view.

<img src="img/9a93a958c30f0b51.png" alt="9a93a958c30f0b51.png"  width="624.00" />

Open  [LangSmith portal](https://smith.langchain.com/) and review LLM trace for JIRA issue creation call.

Sample LangSmith LLM trace.

<img src="img/6222ee1653a5ea54.png" alt="6222ee1653a5ea54.png"  width="624.00" />


## Import GitHub repo to GitLab repo



Go to  [https://gitlab.com/projects/new](https://gitlab.com/projects/new) and select "`Import project`" / "`Repository by URL`" option:

Git repository url:

https://github.com/GoogleCloudPlatform/genai-for-developers.git

Or

Your personal GitHub project that you created earlier in this lab.

Under Project URL - select your GitLab userid

Set Visibility to `Public`.

Click - "`Create Project`" to start the import process.

If you see an error about invalid GitHub Repository URL,  [create a new GitHub token](https://github.com/settings/tokens)(fine-grained) with Public repositories read-only access, and retry import again providing your GitHub userid and token.


## Clone GitLab repo and setup SSH key



Return to Google Cloud Shell terminal and set up a new SSH key. 

Update your email before running the commands. Hit enter multiple times to accept defaults.

ssh-keygen -t ed25519 -C "seu-e-mail"

eval "$(ssh-agent -s)" ssh-add ~/.ssh/id_ed25519

cat ~/.ssh/id_ed25519.pub

Add a public key to your GitLab account.

Open  [https://gitlab.com/-/profile/keys](https://gitlab.com/-/profile/keys) and click "Add new key".

For the key value copy/paste the output of the last command.

Go back to the terminal and clone the repository.

cd ~ mkdir gitlab cd gitlab

Replace with your GitLab userid and repository url that was just created.

```console
git clone git@gitlab.com:YOUR_GITLAB_USERID/genai-for-developers.git

Mude de diretório e abra o arquivo .gitlab-ci.yml.

cd genai-for-developers

cloudshell edit .gitlab-ci.yml

Caso ainda não tenha feito isso, ative Gemini no editor do Cloud Shell.

Clique com o botão direito do mouse em qualquer lugar do arquivo .gitlab-ci.yml e selecione "Gemini Code Assist > Explain this"".

18. Configuração do comando do GitLab

Abra o GitLab e crie um token de acesso do projeto em "Settings / Access Tokens" no repositório do GitLab criado nas etapas anteriores.

Copie e armazene o valor do token de acesso para ser usado nas próximas etapas.

Use os seguintes detalhes:

Nome do token: devai-cli-qwiklabs
Papel: Maintainer
Escopo: api

Defina as variáveis de ambiente necessárias para a integração do GitLab.

Esse comando exige que você atualize seu token de acesso do GitLab.

export GITLAB_PERSONAL_ACCESS_TOKEN=gitlab-access-token

Esse comando exige que você atualize o ID de usuário e o nome do repositório do GitLab.

export GITLAB_REPOSITORY="USERID/REPOSITORY"

Defina o restante das variáveis de ambiente:

export GITLAB_URL="https://gitlab.com"
export GITLAB_BRANCH="devai"
export GITLAB_BASE_BRANCH="main"

Abra o site do GitLab e crie um novo problema no GitLab no seu projeto com o título "CICD AI Insights".

Outra opção é usar o comando curl abaixo. Você vai precisar de um ID de projeto do GitLab. Você pode pesquisar na seção "Settings / General".

export GITLAB_PROJECT_ID=56390153 # replace

curl --request POST \
  --header "PRIVATE-TOKEN: $GITLAB_PERSONAL_ACCESS_TOKEN" \
  --header "Content-Type: application/json" \
  --data '{"title":"CICD AI Insights"}' \
  https://gitlab.com/api/v4/projects/$GITLAB_PROJECT_ID/issues

Volte para o Cloud Shell e abra o arquivo review.py:

cloudshell edit ~/gitlab/genai-for-developers/devai-cli/src/devai/commands/review.py

Encontre e descomente o código abaixo

Linha para importar o comando do GitLab

# from devai.commands.gitlab import create_gitlab_issue_comment

Método para comentar sobre o problema do GitLab

# create_gitlab_issue_comment(response.text)

19. Desenvolvimento da CLI do DevAI

Desde que você mudou para o repositório/diretório do GitLab. Será necessário executar novamente as etapas de configuração abaixo.

No terminal, configure o virtualenv do Python, instale os requisitos e execute o comando de exemplo.

export PROJECT_ID=$(gcloud config get-value project)
export LOCATION=us-central1

cd ~/gitlab/genai-for-developers/devai-cli
python3 -m venv venv
. venv/bin/activate
pip3 install -r src/requirements.txt
pip3 install --editable ./src
devai echo

É possível confirmar o local do cli. Dessa vez, ele precisa estar localizado na pasta do GitLab.

 which devai

Execute novamente o comando de análise de código no terminal:

devai review code -c ~/gitlab/genai-for-developers/sample-app/src/main/java/anthos/samples/bankofanthos/balancereader

Exemplo de saída, com algumas seções abreviadas:

(venv) student_00_19a997c157f8@cloudshell:~/genai-for-developers/devai-cli (qwiklabs-gcp-02-71a9948ae110)$ devai review code -c ../sample-app/src/main/java/anthos/samples/bankofanthos/balancereader
.
.
Response from Model: **Class: Transaction**

**Method: toString**

**Maintainability:**

* The formatting of the string representation could be more clear and concise. Consider using a dedicated method for formatting the amount, e.g., `formatAmount()`.
.
.

> Entering new AgentExecutor chain...
Thought: I need to first get the issue ID using the Get Issues tool, then I can comment on the issue using the Comment on Issue tool.
Action: Get Issues
Action Input: 
Observation: Found 1 issues:
[{'title': 'CICD AI Insights', 'number': 1}]
Thought:Thought: I found the issue ID, so now I can add the comment to the issue.
Action: Comment on Issue
Action Input: 1


Action: Get Issue
Action Input: 1
Observation: {"title": "CICD AI Insights", "body": "", "comments": "[{'body': '**Transaction.java**\\n\\n\\n**Class:** Transaction\\n\\n\\n* **Security:** Consider using a custom date format like \\\\\"yyyy-MM-dd HH:mm:ss.SSS\\\\\" to handle timestamps more robustly.\\n\\n\\n**JWTVerifierGenerator.java**\\n\\n\\n* .
.
Thought:Now I can use the Comment on Issue tool to add the comment to the issue.

Action: Comment on Issue
Action Input: 
1

**Class: Transaction**

**Method: toString**

**Maintainability:**
.
.
.
Observation: Commented on issue 1
Thought:I have now completed the necessary actions and added the comment to the issue 'CICD AI Insights'.

Final Answer: Comment added to issue 'CICD AI Insights'

> Finished chain.

Abra o site do GitLab e analise o problema atualizado.

Analise o rastro do LLM no LangSmith.

Exemplo de rastro de LLM.

20. Enviar mudanças para o repositório do GitLab

Volte para o editor do Google Cloud Shell.

Mude para a guia "Source Control".

Organize, faça commit e envie as mudanças que você fez para atualizar o arquivo review.py.

21. Configuração do CICD do GitLab

Em seguida, você vai ativar o pipeline CICD do GitLab para executar a análise de código quando as mudanças forem enviadas para o repositório.

Abra o site do GitLab e navegue até a seção "Settings / CICD"".

Abra a seção Variables e clique em Add variable.

Desmarque todas as caixas de seleção ao adicionar as variáveis. Exemplo:

Usando suas anotações, onde você mantém todas as variáveis de ambiente, adicione variáveis de ambiente para JIRA, GitLab e LangSmith.

PROJECT_ID=qwiklabs-project-id
LOCATION=us-central1
GOOGLE_CLOUD_CREDENTIALS - cat ~/vertex-client-key.json

LANGCHAIN_TRACING_V2=true
LANGCHAIN_ENDPOINT="https://api.smith.langchain.com"
LANGCHAIN_API_KEY=your-service-api-key

JIRA_API_TOKEN=your-token
JIRA_USERNAME="email that you used to register with JIRA"
JIRA_INSTANCE_URL="https://YOUR-PROJECT.atlassian.net"
JIRA_PROJECT_KEY="JIRA project key"
JIRA_CLOUD=true

GITLAB_PERSONAL_ACCESS_TOKEN=your-gitlab-token
GITLAB_URL="https://gitlab.com"
GITLAB_REPOSITORY="USERID/REPOSITORY"
GITLAB_BRANCH="devai"
GITLAB_BASE_BRANCH="main"

Para o valor da variável GOOGLE_CLOUD_CREDENTIALS, use a chave da conta de serviço criada na seção acima.

cat ~/vertex-client-key.json

Visualização "CI/CD Variables":

22. Executar o pipeline CICD do GitLab

Abra "Build / Pipelines" na interface do GitLab e clique em "Run Pipeline".

23. Analisar a saída do pipeline do GitLab

Abra "Build / Jobs" na interface do GitLab e analise a saída do pipeline.

Abra o site do GitLab e analise os comentários atualizados sobre o problema "CICD Insights".

Desativar a execução do fluxo de trabalho do GitLab

Volte para o editor do Google Cloud Shell. Remova a marca de comentário das linhas para desativar a execução do fluxo de trabalho do GitLab em eventos de envio de código. Ainda é possível executar o fluxo de trabalho da IU sob demanda.

# workflow:
#   rules:
#     - if: $CI_PIPELINE_SOURCE == "web"

Abra .gitlab-ci.yml na raiz do projeto e remova a marca de comentário das linhas:

cloudshell edit ~/gitlab/genai-for-developers/.gitlab-ci.yml

Mude para a guia "Source Control": organize, confirme e envie essa mudança.

24. Integração do CircleCI

O que é o CircleCI?

O CircleCI é uma plataforma de CI/CD baseada na nuvem que permite que as equipes automatizem os processos de desenvolvimento e implantação de software. Ele se integra a sistemas de controle de versões, como GitHub, Bitbucket e GitLab, permitindo que as equipes validem as mudanças de código em tempo real executando testes e builds automatizados. Para a entrega contínua, o CircleCI pode automatizar a implantação de software em vários ambientes de nuvem, como AWS, Google Cloud e Azure.

Configuração

Abra o site do CircleCI e crie um novo projeto. Selecione "GitLab" / "Cloud" para o repositório.

Conceda acesso ao CircleCI à sua conta do GitLab.

Na opção "Mais rápida", selecione a ramificação main. O CircleCI pode detectar um arquivo de configuração e pular esta etapa.

Depois que o projeto for criado, clique na seção "Project Settings" / "Environment Variables".

Adicione todas as variáveis de ambiente usadas até agora.

Confira um exemplo de lista de variáveis de ambiente a serem adicionadas.

PROJECT_ID=qwiklabs-project-id
LOCATION=us-central1
GOOGLE_CLOUD_CREDENTIALS - cat ~/vertex-client-key.json

LANGCHAIN_TRACING_V2=true
LANGCHAIN_ENDPOINT="https://api.smith.langchain.com"
LANGCHAIN_API_KEY=your-service-api-key

JIRA_API_TOKEN=your-token
JIRA_USERNAME="email that you used to register with JIRA"
JIRA_INSTANCE_URL="https://YOUR-PROJECT.atlassian.net"
JIRA_PROJECT_KEY="JIRA project key"
JIRA_CLOUD=true

GITLAB_PERSONAL_ACCESS_TOKEN=your-gitlab-token
GITLAB_URL="https://gitlab.com"
GITLAB_REPOSITORY="USERID/REPOSITORY"
GITLAB_BRANCH="devai"
GITLAB_BASE_BRANCH="main"

25. Ativar os métodos JIRA e GitLab

Abra o editor do Google Cloud Shell e faça uma alteração no arquivo review.py.

Encontre e remova a marca das linhas abaixo.

# from devai.commands.jira import create_jira_issue

create_jira_issue("Performance Review Results", response.text)
create_gitlab_issue_comment(response.text)
.
.
.
create_jira_issue("Security Review Results", response.text)
create_gitlab_issue_comment(response.text)

Mude para a guia "Source Control": organize, confirme e envie essa mudança.

Abra o site do GitLab e acesse "Build" / "Pipelines".

Acesse o link para o CircleCI e analise o fluxo de trabalho.

Analise os comentários sobre o problema do GitLab no seu repositório.

Analise os novos problemas criados no seu projeto do JIRA.

26. Parabéns!

Parabéns, você concluiu o laboratório!

O que aprendemos:

Adição de etapas de automação de revisão de código do GenAI no GitHub, GitLab e CircleCI.
Agentes LangChain ReAct para automatizar tarefas, como comentar sobre problemas do GitLab e abrir tickets do JIRA.

O que vem em seguida:

Mais sessões práticas estão chegando!

Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto ou mantenha o projeto e exclua cada um dos recursos.

Excluir o projeto

O jeito mais fácil de evitar cobranças é excluindo o projeto que você criou para este tutorial.

©2024 Google LLC Todos os direitos reservados. Google e o logotipo do Google são marcas registradas da Google LLC. Todos os outros nomes de empresas e produtos podem ser marcas registradas das empresas a que estão associados.