Sobre este codelab
1. Visão geral
Neste laboratório, você vai criar uma solução para automatizar a implementação de histórias de usuário do JIRA com a IA generativa.
O que você vai aprender
Há várias partes principais no laboratório:
- Implantar o aplicativo do Cloud Run para integração com as APIs Gemini
- Criar e implantar o app Atlassian Forge para JIRA
- Usar agentes LangChain ReAct para automatizar tarefas do GitLab
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 "Peça ao Gemini" na barra de pesquisa.
Ative a API Gemini para Google Cloud:
Clique em Start chatting e siga uma das perguntas de exemplo ou digite seu próprio comando para testar.
Sugestões de comandos:
- Explicar 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 principais.
- 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 as finalizaçõ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 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
Você tem várias opções para testar comandos.
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.
O Google AI Studio é uma ferramenta baseada na Web para prototipagem e experimentação com engenharia de comando e a API Gemini.
- 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.
4. Analisar o aplicativo
Criar a conta de serviço
Volte ao console do Google Cloud e ative o Cloud Shell clicando no ícone à direita da barra de pesquisa.
No terminal aberto, 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 Vertex AI Gemini no aplicativo do Cloud Run.
Configure os detalhes do projeto usando os detalhes do projeto do Qwiklabs.
Exemplo: qwiklabs-gcp-00-2c10937585bb
gcloud config set project YOUR_QWIKLABS_PROJECT_ID
Crie uma conta de serviço.
PROJECT_ID=$(gcloud config get-value project)
SERVICE_ACCOUNT_NAME='vertex-client'
DISPLAY_NAME='Vertex Client'
gcloud iam service-accounts create $SERVICE_ACCOUNT_NAME --project $PROJECT_ID --display-name "$DISPLAY_NAME"
Conceder papéis.
gcloud projects add-iam-policy-binding $PROJECT_ID --member="serviceAccount:$SERVICE_ACCOUNT_NAME@$PROJECT_ID.iam.gserviceaccount.com" --role="roles/aiplatform.admin"
gcloud projects add-iam-policy-binding $PROJECT_ID --member="serviceAccount:$SERVICE_ACCOUNT_NAME@$PROJECT_ID.iam.gserviceaccount.com" --role="roles/aiplatform.user"
gcloud projects add-iam-policy-binding $PROJECT_ID --member="serviceAccount:$SERVICE_ACCOUNT_NAME@$PROJECT_ID.iam.gserviceaccount.com" --role="roles/cloudbuild.builds.editor"
gcloud projects add-iam-policy-binding $PROJECT_ID --member="serviceAccount:$SERVICE_ACCOUNT_NAME@$PROJECT_ID.iam.gserviceaccount.com" --role="roles/artifactregistry.admin"
gcloud projects add-iam-policy-binding $PROJECT_ID --member="serviceAccount:$SERVICE_ACCOUNT_NAME@$PROJECT_ID.iam.gserviceaccount.com" --role="roles/storage.admin"
gcloud projects add-iam-policy-binding $PROJECT_ID --member="serviceAccount:$SERVICE_ACCOUNT_NAME@$PROJECT_ID.iam.gserviceaccount.com" --role="roles/run.admin"
gcloud projects add-iam-policy-binding $PROJECT_ID --member="serviceAccount:$SERVICE_ACCOUNT_NAME@$PROJECT_ID.iam.gserviceaccount.com" --role="roles/secretmanager.secretAccessor"
Se for necessário autorizar, clique em "Autorizar" para continuar.
Ative os serviços necessários para usar as APIs Vertex AI e o chat Gemini.
gcloud services enable \
generativelanguage.googleapis.com \
aiplatform.googleapis.com \
cloudaicompanion.googleapis.com \
run.googleapis.com \
cloudresourcemanager.googleapis.com
Ative os serviços necessários para usar as APIs Vertex AI e o chat Gemini.
gcloud services enable \
artifactregistry.googleapis.com \
cloudbuild.googleapis.com \
runapps.googleapis.com \
workstations.googleapis.com \
servicemanagement.googleapis.com \
secretmanager.googleapis.com \
containerscanning.googleapis.com
Clone o repositório do GitHub
Clonar o repositório GitHub.
git clone https://github.com/GoogleCloudPlatform/genai-for-developers.git
Abrir editor do Cloud Shell
Usando o item de menu "File / Open Folder", abra "genai-for-developers".
Abra o arquivo "devai-api/app/routes.py" e clique com o botão direito do mouse em qualquer lugar do arquivo. Em seguida, selecione "Gemini > Explain this"" no menu de contexto.
Leia a explicação do Gemini sobre o arquivo selecionado.
5. Configuração do repositório e do kit de ferramentas do GitLab
Neste laboratório, você vai usar o GitLabToolkit (em inglês) para automatizar a criação de solicitações de mesclagem do GitLab.
Aspectos gerais dos kits de ferramentas do LangChain
Os Kits de ferramentas do LangChain são conjuntos de ferramentas criadas para simplificar e aprimorar o desenvolvimento de aplicativos com o LangChain. Eles oferecem várias funcionalidades, dependendo do kit de ferramentas específico, mas, em geral, ajudam com:
- Conexão a fontes de dados externas: acesse e incorpore informações de APIs, bancos de dados e outras fontes externas nos seus aplicativos do LangChain.
- Técnicas avançadas de comando: use comandos pré-criados ou crie comandos personalizados para otimizar as interações com modelos de linguagem.
- Criação e gerenciamento de cadeias: crie e gerencie cadeias complexas com facilidade.
- Avaliação e monitoramento: analise o desempenho dos aplicativos e das cadeias do LangChain.
Alguns dos Kits de ferramentas LangChain mais conhecidos incluem:
- Kits de ferramentas de executor de agentes: ferramentas para desenvolver agentes que possam interagir com o mundo real por meio de ações como navegação na Web ou execução de código.
- Kit de ferramentas de engenharia de comandos: uma coleção de recursos para criar comandos eficientes.
Visão geral do Kit de ferramentas do GitLab
O kit de ferramentas do Gitlab contém ferramentas que permitem que um agente de LLM interaja com um repositório do Gitlab. A ferramenta é um wrapper para a biblioteca python-gitlab.
O kit de ferramentas do GitLab pode realizar as seguintes tarefas:
- Criar arquivo: cria um novo arquivo no repositório.
- Read File: lê um arquivo do repositório.
- Atualizar arquivo: atualiza um arquivo no repositório.
- Criar solicitação de envio: cria uma solicitação de envio da ramificação de trabalho do bot para a ramificação base.
- Extrair problemas: extrai problemas do repositório.
- Get Issue: busca detalhes sobre um problema específico.
- Comentário sobre o problema: publica um comentário sobre um problema específico.
- Excluir arquivo: exclui um arquivo do repositório.
Configuração do projeto do GitLab
Abra o GitLab, crie um projeto e configure o token de acesso do projeto em "Settings / Access Tokens".
Use os seguintes detalhes:
- Nome do token:
devai-api-qwiklabs - Papel:
Maintainer - Selecione os escopos:
api
Copie e cole o valor do token de acesso em um arquivo temporário no seu laptop. Ele será usado nas próximas etapas.
6. Preparar a implantação do aplicativo no Cloud Run
Volte ao editor do Cloud Shell e use um terminal existente ou abra um novo.
Configure os detalhes do projeto usando os detalhes do projeto do Qwiklabs.
Exemplo: qwiklabs-gcp-00-2c10937585bb
gcloud config set project YOUR-QWIKLABS-PROJECT-ID
Defina o restante das variáveis de ambiente:
export PROJECT_ID=$(gcloud config get-value project)
export LOCATION=us-central1
export REPO_NAME=devai-api
export SERVICE_NAME=devai-api
Defina as variáveis de ambiente necessárias para a integração do GitLab.
export GITLAB_PERSONAL_ACCESS_TOKEN=gitlab-token
Para evitar a exposição de informações sensíveis no terminal, a prática recomendada é usar read -s GITLAB_PERSONAL_ACCESS_TOKEN, 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. Você também vai precisar exportar a variável de ambiente: export GITLAB_PERSONAL_ACCESS_TOKEN
Esse comando exige que você atualize o ID de usuário e o nome do repositório do GitLab.
Exemplo: export GITLAB_REPOSITORY="gitrey/qwiklabs-test"
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"
Configuração de rastreamento de LLM do LangSmith
Configure a conta se quiser conferir informações de rastreamento do agente no LangSmith. Caso contrário, execute os comandos como estão.
Crie uma conta da LangSmith e gere uma chave da API Service na seção "Configurações". https://smith.langchain.com/settings
Defina as variáveis de ambiente necessárias para a integração do LangSmith.
export LANGCHAIN_TRACING_V2=true
export LANGCHAIN_ENDPOINT="https://api.smith.langchain.com"
export LANGCHAIN_API_KEY=langchain-service-api-key
Configuração do JIRA
Esses valores não são usados neste laboratório, então não é necessário atualizar para os valores específicos do seu projeto do JIRA antes de executar os comandos.
Defina as variáveis de ambiente necessárias para a implantação do serviço do Cloud Run.
export JIRA_API_TOKEN=jira-token
export JIRA_USERNAME="YOUR-EMAIL"
export JIRA_INSTANCE_URL="https://YOUR-JIRA-PROJECT.atlassian.net"
export JIRA_PROJECT_KEY="YOUR-JIRA-PROJECT-KEY"
export JIRA_CLOUD=true
Criar chave de API
Crie uma nova chave de API na seção APIs e serviços / Credenciais do Console do Cloud.
Essa chave será usada para autenticar chamadas da API JIRA no aplicativo do Cloud Run.
No ambiente de produção, você configura as restrições de aplicativo e de API para a chave de API criada. As restrições de aplicativo limitam o uso de uma chave de API a sites específicos(por exemplo, sua instância do JIRA).
Defina as variáveis de ambiente necessárias para a implantação do serviço do Cloud Run.
export DEVAI_API_KEY=your-api-key
Criar secrets no Secret Manager
Neste laboratório, seguimos as práticas recomendadas e usamos o Secret Manager para armazenar e referenciar os valores de tokens de acesso, chaves de API e chaves de API LangChain no Cloud Run.
Crie e armazene os secrets necessários no Secret Manager.
echo -n $DEVAI_API_KEY | \
gcloud secrets create DEVAI_API_KEY \
--data-file=-
echo -n $JIRA_API_TOKEN | \
gcloud secrets create JIRA_API_TOKEN \
--data-file=-
echo -n $GITLAB_PERSONAL_ACCESS_TOKEN | \
gcloud secrets create GITLAB_PERSONAL_ACCESS_TOKEN \
--data-file=-
echo -n $LANGCHAIN_API_KEY | \
gcloud secrets create LANGCHAIN_API_KEY \
--data-file=-
7. Implantar a API Devai no Cloud Run
Verifique se você está na pasta certa.
cd ~/genai-for-developers/devai-api
Implantar o aplicativo no Cloud Run.
gcloud run deploy "$SERVICE_NAME" \
--source=. \
--region="$LOCATION" \
--allow-unauthenticated \
--service-account vertex-client \
--set-env-vars PROJECT_ID="$PROJECT_ID" \
--set-env-vars LOCATION="$LOCATION" \
--set-env-vars GITLAB_URL="$GITLAB_URL" \
--set-env-vars GITLAB_REPOSITORY="$GITLAB_REPOSITORY" \
--set-env-vars GITLAB_BRANCH="$GITLAB_BRANCH" \
--set-env-vars GITLAB_BASE_BRANCH="$GITLAB_BASE_BRANCH" \
--set-env-vars JIRA_USERNAME="$JIRA_USERNAME" \
--set-env-vars JIRA_INSTANCE_URL="$JIRA_INSTANCE_URL" \
--set-env-vars JIRA_PROJECT_KEY="$JIRA_PROJECT_KEY" \
--set-env-vars JIRA_CLOUD="$JIRA_CLOUD" \
--set-env-vars LANGCHAIN_TRACING_V2="$LANGCHAIN_TRACING_V2" \
--update-secrets="LANGCHAIN_API_KEY=LANGCHAIN_API_KEY:latest" \
--update-secrets="GITLAB_PERSONAL_ACCESS_TOKEN=GITLAB_PERSONAL_ACCESS_TOKEN:latest" \
--update-secrets="JIRA_API_TOKEN=JIRA_API_TOKEN:latest" \
--update-secrets="DEVAI_API_KEY=DEVAI_API_KEY:latest" \
--min-instances=1 \
--max-instances=3
Responda Y para criar o repositório Docker do Artifact Registry.
Deploying from source requires an Artifact Registry Docker repository to store built containers. A repository named [cloud-run-source-deploy] in
region [us-central1] will be created.
Do you want to continue (Y/n)? y
Analise o fluxo gcloud run deploy SERVICE_NAME --source=. abaixo. Saiba mais.
Nos bastidores, esse comando usa o buildpacks e o Cloud Build do Google Cloud para criar automaticamente imagens de contêiner a partir do código-fonte sem instalar o Docker na máquina ou configurar os buildpacks ou o Cloud Build. Ou seja, o comando único descrito acima faz o que exigiria os comandos gcloud builds submit e gcloud run deploy.
Se você tiver fornecido um Dockerfile(como fizemos neste repositório), o Cloud Build vai usá-lo para criar imagens de contêiner em vez de depender dos pacotes de build para detectar e criar imagens de contêiner automaticamente. Para saber mais sobre buildpacks, consulte a documentação.
Revise os registros do Cloud Build no Console.
Revise a imagem Docker criada no Artifact Registry.
Revise os detalhes da instância do Cloud Run no console do Cloud.
Testar aplicativo
Teste o endpoint executando o comando curl.
Atualize com o URL do serviço do Cloud Run antes de executar o comando.
Exemplo:
curl -H "X-devai-api-key: $DEVAI_API_KEY" https://devai-api-1110000001.us-central1.run.app/test
8. Automatizar a implementação de histórias
O Forge é uma plataforma que permite que os desenvolvedores criem apps integrados aos produtos da Atlassian, como Jira, Confluence, Compass e Bitbucket.
Instalar a CLI do Forge
Instale a CLI do Forge globalmente executando o seguinte:
npm install -g @forge/cli
Neste laboratório, vamos usar variáveis de ambiente para fazer login.
Configurar o projeto do Jira
Use sua conta pessoal para criar/acessar projetos do JIRA.
Revise seus projetos do JIRA: https://admin.atlassian.com/
Crie um novo projeto do JIRA usando sua conta pessoal.
Acesse https://team.atlassian.com/your-work, clique em 
e selecione 
. Depois disso, selecione "JIRA Software" - "Testar agora". Siga as instruções para concluir a criação do projeto/site.
Selecione o software JIRA.
Crie um novo projeto.
Criar token da API Atlassian
Crie ou use um token de API da Atlassian para fazer login na CLI.
A CLI usa seu token ao executar comandos.
- Acesse https://id.atlassian.com/manage/api-tokens.
- Clique em Criar token de API.
- Insira um rótulo para descrever o token da API. Por exemplo, forge-api-token.
- Clique em Criar.
- Clique em Copiar para a área de transferência e feche a caixa de diálogo.
Configurar as configurações do ambiente do Forge
Volte ao Cloud Console e execute os comandos abaixo no terminal.
Faça login na CLI do Forge para começar a usar os comandos do Forge.
Defina seu endereço de e-mail do JIRA/FORGE. Substitua pelo seu endereço de e-mail.
export FORGE_EMAIL=your-email
Defina o token da API Forge. Substitua pelo seu token da API JIRA.
export FORGE_API_TOKEN=your-jira-api-token
Teste a CLI do Forge executando o comando abaixo. Responda "No" quando solicitado a coletar análises.
forge settings set usage-analytics false
Verifique se você fez login.
forge whoami
Exemplo de saída.
Logged in as John Green (johngreen@email.com) Account ID: 123090:aaabbcc-076a-455c-99d0-d1aavvccdd
Criar um aplicativo Forge
Verifique se você está na pasta "~/genai-for-developers".
Executar comando para criar um aplicativo do Forge.
forge create
Use os seguintes valores quando solicitado:
- Nome do aplicativo:
devai-jira-ui-qwiklabs - Selecione uma categoria:
UI Kit - Selecione um produto:
Jira - Selecione um modelo:
jira-issue-panel
Mude para a pasta do aplicativo.
cd devai-jira-ui-qwiklabs/
Execute o comando para instalar as dependências.
npm install
Execute o comando de implantação.
forge deploy
Exemplo de resposta:
Deploying your app to the development environment. Press Ctrl+C to cancel. Running forge lint... No issues found. ✔ Deploying devai-jira-ui-qwiklabs to development... ℹ Packaging app files ℹ Uploading app ℹ Validating manifest ℹ Snapshotting functions ℹ Deploying to environment ✔ Deployed Deployed devai-jira-ui-qwiklabs to the development environment.
Instale o aplicativo.
forge install
Use os seguintes valores quando solicitado:
- Selecione um produto:
Jira - Digite o URL do site:
your-domain.atlassian.net
Exemplo de resposta:
Select the product your app uses. ? Select a product: Jira Enter your site. For example, your-domain.atlassian.net ? Enter the site URL: genai-for-developers.atlassian.net Installing your app onto an Atlassian site. Press Ctrl+C to cancel. ? Do you want to continue? Yes ✔ Install complete! Your app in the development environment is now installed in Jira on genai-for-developers.atlassian.net
Abra seu site do JIRA e crie uma nova tarefa com a seguinte descrição:
Create HTML, CSS and JavaScript using React.js framework to implement Login page with username and password fields, validation and documentation. Provide complete implementation, do not omit anything.
Ao abrir a tarefa, você vai encontrar o botão "devai-jira-ui-qwiklabs".
Clique no botão e revise as mudanças na interface.
Acessar registros de back-end do Forge.
forge logs
Atlassian Developer Console
Também é possível conferir e gerenciar apps implantados no Console do desenvolvedor da Atlassian.
Analisar registros: alternar para o ambiente Development,
Revisar o manifesto e o código-fonte do aplicativo Forge
Abra o arquivo "devai-jira-ui-qwiklabs/manifest.yml" e use o Gemini Code Assist para explicar a configuração.
Leia a explicação.
Abra os seguintes arquivos e peça ao Gemini Code Assist para explicar:
devai-jira-ui-qwiklabs/src/frontend/index.jsxdevai-jira-ui-qwiklabs/src/resolvers/index.js
Atualizar o app Forge com o endpoint do Cloud Run da API DevAI
Verifique se o ID do projeto do GCP está definido:
gcloud config get project
Caso contrário, defina seu projeto do GCP usando o ID do projeto na página do laboratório do Qwiklabs:
Exemplo: qwiklabs-gcp-00-2c10937585bb
gcloud config set project YOUR_QWIKLABS_PROJECT_ID
Defina o URL do serviço do Cloud Run:
export DEVAI_API_URL=$(gcloud run services list --filter="(devai-api)" --format="value(URL)")
forge variables set DEVAI_API_URL $DEVAI_API_URL
Defina a chave da API DEVAI:
export DEVAI_API_KEY=api-key-that-you-created
forge variables set --encrypt DEVAI_API_KEY $DEVAI_API_KEY
Confirme executando o comando abaixo:
forge variables list
Exemplo de saída
Atualizar o manifesto e o código do aplicativo Forge
Esses snippets de código podem ser encontrados no repositório na pasta sample-devai-jira-ui.
Abra o arquivo de manifesto no editor: devai-jira-ui-qwiklabs/manifest.yml
Adicione as linhas abaixo no final do arquivo. Substitua o endpoint do Cloud Run pelo que você implantou.
permissions:
scopes:
- read:jira-work
- write:jira-work
external:
fetch:
client:
- devai-api-gjerpi6qqq-uc.a.run.app/create-gitlab-mr # replace with YOUR CLOUD RUN URL
Abra o arquivo de indexadores/resolvers no editor: devai-jira-ui-qwiklabs/src/resolvers/index.js
Adicione as linhas abaixo após a função getText atual.
resolver.define('getApiKey', (req) => {
return process.env.DEVAI_API_KEY;
});
resolver.define('getDevAIApiUrl', (req) => {
return process.env.DEVAI_API_URL;
});
Abra o arquivo de front-end/índice no editor: devai-jira-ui-qwiklabs/src/frontend/index.jsx
Substitua index.jsx pelo conteúdo abaixo. Atualize o link para o ID de usuário/repositório do GitLab.
Há dois lugares em que você precisa atualizar YOUR-GIT-USERID e YOUR-GIT-REPO.
Pesquise esta linha no arquivo e faça as alterações:
https://gitlab.com/YOUR-GIT-USERID/YOUR-GIT-REPO/-/merge_requests
import React from 'react';
import ForgeReconciler, { Text, Link, useProductContext } from '@forge/react';
import { requestJira } from '@forge/bridge';
import { invoke } from '@forge/bridge';
import api, { route, assumeTrustedRoute } from '@forge/api';
const devAIApiKey = await invoke("getApiKey")
const devAIApiUrl = await invoke("getDevAIApiUrl")
const App = () => {
const context = useProductContext();
const [description, setDescription] = React.useState();
const fetchDescriptionForIssue = async () => {
const issueId = context?.extension.issue.id;
const res = await requestJira(`/rest/api/2/issue/${issueId}`);
const data = await res.json();
const bodyGenerateData = `{"prompt": ${JSON.stringify(data.fields.description)}}`;
const generateRes = await api.fetch(devAIApiUrl+'/create-gitlab-mr,
{
body: bodyGenerateData,
method: 'post',
headers: {
'Content-Type': 'application/json',
'x-devai-api-key': devAIApiKey,
},
}
)
const resData = await generateRes.text();
// Add link to the GitLab merge request page as a comment
await requestJira(`/rest/api/2/issue/${issueId}/comment`, {
method: 'POST',
headers: {
'Accept': 'application/json',
'Content-Type': 'application/json'
},
body: `{"body": "[GitLab Merge Request|https://gitlab.com/YOUR-GIT-USERID/YOUR-GIT-REPO/-/merge_requests]"}`
});
return "Response will be added as a comment. Please refresh in a few moments.";
};
React.useEffect(() => {
if (context) {
fetchDescriptionForIssue().then(setDescription);
}
}, [context]);
return (
<>
<Text>{description}</Text>
<Link href='https://gitlab.com/YOUR-GIT-USERID/YOUR-GIT-REPO/-/merge_requests' openNewTab={true}>GitLab Merge Request</Link>
</>
);
};
ForgeReconciler.render(
<React.StrictMode>
<App />
</React.StrictMode>
);
Reimplantar o aplicativo Forge
Adicione dependências no arquivo package.json:
"@forge/api": "4.0.0",
Execute o comando para instalar as dependências:
npm install
Implante o aplicativo atualizado:
forge deploy
Exemplo de resposta:
ℹ Uploading app ℹ Validating manifest ℹ Snapshotting functions ℹ Deploying to environment ✔ Deployed Deployed devai-jira-ui-qwiklabs to the development environment. We've detected new scopes or egress URLs in your app. Run forge install --upgrade and restart your tunnel to put them into effect.
Instalar o aplicativo atualizado:
forge install --upgrade
Exemplo de resposta:
Upgrading your app on the Atlassian site. Your app will be upgraded with the following additional scopes: - read:jira-work - write:jira-work Your app will exchange data with the following urls: - devai-api-7su2ctuqpq-uc.a.run.app ? Do you want to continue? Yes ✔ Upgrade complete! Your app in the development environment is now the latest in Jira on genai-for-developers.atlassian.net.
Testar o aplicativo Forge
Abra ou crie uma tarefa do JIRA no seu projeto.
Se o painel anterior já tiver sido adicionado, você vai precisar removê-lo.
Clique em "..." e selecione "Remover" no menu. Depois disso, clique no botão novamente.
Verificar os comentários do Jira
Quando você receber uma resposta da API DEVAI, um comentário será adicionado ao problema do JIRA.
- Link da solicitação de mesclagem do GitLab
Alterne entre as guias "History" e "Comments" para atualizar a visualização.
Verificar a solicitação de mesclagem do GitLab
Abra o GitLab e verifique se há novas solicitações de mesclagem no projeto.
Rastros de LLM do LangSmith
Se você tiver configurado o rastreamento de LLM, abra o portal do LangSmith e analise o rastro de LLM para a chamada de criação de solicitação de mesclagem do GitLab.
Exemplo de rastreamento de LLM do LangSmith.
9. Envie suas alterações para o repositório do GitHub
(SEÇÃO OPCIONAL)
Acesse o site do GitHub e crie um novo repositório para enviar as mudanças deste laboratório ao seu repositório pessoal.
Volte ao console do Cloud e 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"
Gere uma chave SSH e adicione-a ao repositório do GitHub.
Atualize seu e-mail antes de executar os comandos.
Não insira a senha longa e pressione Enter várias vezes para concluir a geração de chaves.
ssh-keygen -t ed25519 -C "your-email-address"
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519
cat ~/.ssh/id_ed25519.pub
Adicione a chave pública gerada à sua conta do GitHub.
Abra https://github.com/settings/keys e clique em "New SSH key".
Para o nome da chave, use "qwiklabs-key" e copie e cole a saída do último comando.
Volte ao terminal, confirme e envie as mudanças.
cd ~/genai-for-developers
git remote rm origin
Defina a origem remota usando o repositório criado acima.
Substitua pelo URL do repositório.
git remote add origin git@github.com:YOUR-GITHUB-USERID/YOUR-GITHUB-REPO.git
Adicione, confirme e envie as mudanças.
git add .
git commit -m "lab changes"
git push -u origin main
10. Parabéns!
Parabéns, você concluiu o laboratório!
O que aprendemos:
- Como implantar aplicativos do Cloud Run para integração com as APIs Gemini.
- Como criar e implantar o app Atlassian Forge para JIRA.
- Como usar os agentes LangChain ReAct para automatizar tarefas do GitLab.
- Como analisar rastros de LLM no LangSmith.
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.