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

1. Visão geral

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

O que você vai aprender

Neste laboratório, você vai aprender a:

Como adicionar etapas de automação de revisão de código da IA generativa no GitHub, GitLab e CircleCI
Como usar agentes e kits de ferramentas do LangChain ReAct para automatizar tarefas, como comentar em um problema do GitLab e abrir tíquetes 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 a conversa no Gemini.

Ou digite "Peça 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 produtos do Google Cloud Run. Explique o Cloud Run para um estudante em cinco pontos principais.
Você é gerente de produtos do Google Cloud Run. Explique o Cloud Run para um desenvolvedor certificado do Kubernetes em cinco pontos principais curtos.
Você é gerente de produtos do Google Cloud Run. Explique quando usar o Cloud Run em vez do GKE para um desenvolvedor sênior em cinco pontos principais curtos.

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

Como o Gemini para 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 nossa convicção de 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 informações ou códigos que você envia para ele analisar ou realizar, são chamadas de comandos. As respostas ou gerações de código que você recebe do Gemini são chamadas de respostas. O Gemini não usa seus comandos nem as respostas deles como dados para treinar os modelos.

Criptografia de comandos

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

Dados de programação gerados pelo Gemini

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

Saiba mais sobre como o Google processa seus comandos.

3. Opções para testar comandos

Se você quiser mudar/estender os comandos da CLI devai, há várias opções.

Vertex AI Studio

O Vertex AI Studio faz parte da plataforma Vertex AI do Google Cloud e foi projetado 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 testes 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 do Gemini (gemini.google.com)

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

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

4. Criar a conta de serviço

Clique no ícone à direita da barra de pesquisa para ativar o Cloud Shell.

No terminal aberto, ative os serviços necessários para usar as APIs da Vertex AI e a conversa no 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 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 em pipelines de CI/CD.

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. Copie o repositório do GitHub para seu 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 bifurcado do GitHub no navegador e mude para a guia "Actions" para ativar os fluxos de trabalho.

7. Adicionar secrets do repositório

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

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 fluxo de trabalho do GitHub Actions

Navegue até o repositório do GitHub no navegador e execute o fluxo de trabalho.

O fluxo de trabalho é configurado para ser executado por push 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 revisão 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 performance:

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 de análise de bloqueadores:

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 seu ID de 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 IDE.

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 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.

Explicação da revisão:

12. Executar a CLI DEVAI localmente

Volte para o 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 inicial do usuário. Por exemplo: student_00_478dfeb8df15

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

Execute o comando da CLI devai para fazer 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 revisão 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.

Revise a explicação.

13. Desenvolvimento da CLI da DevAI

Nesta seção, você vai fazer mudanças na CLI devai.

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 revisão 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 prévia em Markdown no editor do Cloud Shell.

Crie um arquivo e cole a resposta do Gemini.

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

14. Conhecer os comandos da CLI devai

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 revisão de segurança

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

Comando de revisão da cobertura de teste

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

Comandos de revisão 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]:

Comando de revisão:

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 comparação de imagens:

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)

Revise os comandos da CLI devai disponíveis no editor do Cloud Shell:

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

Ou revise o arquivo README.md no repositório do GitHub.

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

Comece 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 usá-las em diferentes sistemas várias vezes durante o laboratório. Por isso, é mais fácil consultar tudo em um só lugar.

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

Crie uma conta do LangSmith e gere uma chave de API de serviço 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 de 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. Essa é 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 de comandos do JIRA

Crie uma conta do JIRA, se você ainda não tiver uma.

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

Defina as variáveis de ambiente necessárias para a integração do 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

Revise 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

Importe 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 revisão de 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 na versão 0.2.0. Use invoke em vez disso. warn_deprecated(

Entering new AgentExecutor chain... Raciocínio: a descrição é fornecida na pergunta, então não há nada a 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

Finished chain.

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 "your-email-address"

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 o diretório e abra o arquivo .gitlab-ci.yml.

cd genai-for-developers

cloudshell edit .gitlab-ci.yml

Se você ainda não fez 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 de comandos do GitLab

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

Copie e armazene o valor do token de acesso para usar 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 seu projeto com o título "CICD AI Insights".

Outra opção é usar o comando curl abaixo. Você vai precisar de um ID do projeto do GitLab. Para encontrá-lo, consulte a 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 remova a marca de comentário do código abaixo

Linha para importar o comando do GitLab

# from devai.commands.gitlab import create_gitlab_issue_comment

Método para comentar em um problema do GitLab

# create_gitlab_issue_comment(response.text)

19. Desenvolvimento da CLI da DevAI

Como você mudou para o repositório/diretório do GitLab. Você vai precisar executar as etapas de configuração abaixo novamente.

No terminal, configure seu 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

Confirme o local da CLI. Desta vez, ela deve estar na pasta do GitLab.

 which devai

Execute novamente o comando de revisão 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 rastreamento de LLM no LangSmith.

Exemplo de rastreamento 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 feitas para atualizar o arquivo review.py.

21. Configuração do GitLab CICD

Em seguida, você vai ativar o pipeline de CICD do GitLab para executar a revisão de código quando as mudanças forem enviadas ao 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 de variáveis de CI/CD:

22. Executar o pipeline de 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 no 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 na interface 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": adicione, 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 às equipes automatizar 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 mudanças no código em tempo real executando testes e builds automatizados. Para 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 projeto. Selecione "GitLab" / "Cloud" para seu repositório.

Conceda acesso do 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 existente 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 que você usou até agora.

Confira uma lista de exemplo 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 métodos do JIRA e do GitLab

Abra o editor do Google Cloud Shell e faça uma mudança 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": adicione, confirme e envie essa mudança.

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

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

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

Revise 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 de IA generativa no GitHub, GitLab e CircleCI.
Agentes LangChain ReAct para automatizar tarefas como comentar em um problema do GitLab e abrir tíquetes do JIRA.

Qual é a próxima etapa?

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.