1. Visão geral
Neste laboratório, você vai criar uma solução para automatizar a implementação de histórias de usuários do JIRA com a IA generativa.
O que você vai aprender
O laboratório tem várias partes principais:
- Implantar um aplicativo do Cloud Run para integrar com as APIs Gemini
- Criar e implantar um app do Atlassian Forge para o JIRA
- Usar agentes LangChain ReAct para automação de 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 a conversa no 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:
- 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 qualquer informação ou código de entrada que você envia ao Gemini para analisar ou concluir, 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
Você tem várias opções para testar comandos.
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.
O Google AI Studio é uma ferramenta baseada na Web para prototipagem e testes com engenharia de comandos e a API Gemini.
- 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. Revisar a inscrição
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 seguintes comandos 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 no aplicativo do Cloud Run.
Configure os detalhes do projeto usando as informações 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"
Conceda 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 preciso autorizar, clique em "Autorizar" para continuar.
Ative os serviços necessários para usar as APIs da Vertex AI e a conversa no 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 da Vertex AI e a conversa no 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
Clonar 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", clique com o botão direito do mouse em qualquer lugar do arquivo e selecione "Gemini > Explain this"" no menu de contexto.
Revise a explicação do Gemini para o arquivo selecionado.
5. Configuração do repositório e do kit de ferramentas do GitLab
Neste laboratório, você vai usar o GitLabToolkit para automatizar a criação de solicitações de mesclagem do GitLab.
Visão geral dos kits de ferramentas do LangChain
Os toolkits do LangChain são conjuntos de ferramentas projetadas para simplificar e melhorar o desenvolvimento de aplicativos com o LangChain. Eles oferecem várias funcionalidades, dependendo do kit de ferramentas específico, mas geralmente ajudam com:
- Conexão com fontes de dados externas: acesse e incorpore informações de APIs, bancos de dados e outras fontes externas aos seus aplicativos LangChain.
- Técnicas avançadas de comando: use comandos pré-criados ou crie os seus próprios para otimizar as interações com modelos de linguagem.
- Criação e gerenciamento de cadeias: crie cadeias complexas com facilidade e gerencie-as com eficiência.
- Avaliação e monitoramento: analise o desempenho dos seus aplicativos e cadeias do LangChain.
Alguns kits de ferramentas populares do LangChain incluem:
- Kits de ferramentas do Agent Executor: ferramentas para desenvolver agentes que podem 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 eficazes.
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.
- Ler arquivo: lê um arquivo do repositório.
- Atualizar arquivo: atualiza um arquivo no repositório.
- Criar solicitação de pull: cria uma solicitação de pull da ramificação de trabalho do bot para a ramificação base.
- Get Issues: busca problemas do repositório.
- Get Issue: busca detalhes sobre um problema específico.
- Comentar problema: publica um comentário em 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 ao projeto em "Settings / Access Tokens".
Use os seguintes detalhes:
- Nome do token:
devai-api-qwiklabs - Papel:
Maintainer - Selecionar 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 aberto ou abra um novo.
Configure os detalhes do projeto usando as informações 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. 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". Você também 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 ver informações de rastreamento do agente no LangSmith. Caso contrário, execute os comandos no estado em que se encontram.
Crie uma conta do LangSmith e gere uma chave de API de serviço 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. Portanto, não é necessário atualizar para os valores específicos do projeto 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 chave de API na seção Console do Cloud / API e serviços / Credenciais.
Essa chave será usada para autenticar chamadas da API JIRA no aplicativo do Cloud Run.
Para o ambiente de produção, configure 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, vamos seguir as práticas recomendadas e usar o Secret Manager para armazenar e referenciar os valores de tokens de acesso, chave de API e chave de API do 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 Devai-API no Cloud Run
Verifique se você está na pasta certa.
cd ~/genai-for-developers/devai-api
Implante 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
Confira o fluxo de 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 o Dockerfile(como fizemos neste repositório), o Cloud Build o usará para criar imagens de contêiner em vez de depender dos buildpacks 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.
Analise a imagem Docker criada no Artifact Registry.
Analise 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 aos desenvolvedores criar apps que se integram aos produtos da Atlassian, como Jira, Confluence, Compass e Bitbucket.
Instalar a CLI do Forge
Instale a CLI do Forge globalmente executando:
npm install -g @forge/cli
Neste laboratório, vamos usar variáveis de ambiente para fazer login.
Configurar projeto do JIRA
Use sua conta pessoal para criar/visualizar projetos do JIRA.
Revise seus projetos do JIRA: https://admin.atlassian.com/
Crie um projeto do JIRA usando sua conta pessoal.
Acesse https://team.atlassian.com/your-work, clique em 
e selecione 
. Depois disso, selecione "JIRA Software" - "Teste agora". Siga as instruções para concluir a criação do projeto/site.
Selecione "JIRA Software".
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 um token de API.
- Insira um rótulo para descrever o token de 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 definiçõ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 do JIRA.
export FORGE_API_TOKEN=your-jira-api-token
Teste a CLI do Forge executando o comando abaixo. Responda "No" quando for perguntado se você quer 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 aplicativo do Forge
Verifique se você está na pasta "~/genai-for-developers".
Execute o 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 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 app.
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.
Ver registros do back-end do Forge.
forge logs
Atlassian Developer Console
Também é possível ver e gerenciar apps implantados no Atlassian Developer Console.
Analisar registros: mude 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.
Revise 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 da 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 de 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 ao 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 resolvers/index no editor: devai-jira-ui-qwiklabs/src/resolvers/index.js
Adicione as linhas abaixo depois da função getText.
resolver.define('getApiKey', (req) => {
return process.env.DEVAI_API_KEY;
});
resolver.define('getDevAIApiUrl', (req) => {
return process.env.DEVAI_API_URL;
});
Abra o arquivo frontend/index no editor: devai-jira-ui-qwiklabs/src/frontend/index.jsx
Substitua index.jsx pelo conteúdo abaixo. Atualize o link para seu ID de usuário/repositório do GitLab.
Há dois lugares em que você precisa atualizar YOUR-GIT-USERID e YOUR-GIT-REPO.
Procure esta linha no arquivo e faça as mudanças:
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 do Forge
Adicione dependências no arquivo package.json:
"@forge/api": "4.0.0",
Execute o comando para instalar 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.
Instale 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 do JIRA.
Remova o painel anterior, se ele já tiver sido adicionado.
Clique em "..." e selecione "Remover" no menu. Depois disso, clique no botão novamente.
Verificar comentários do Jira
Depois que 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 solicitação de mesclagem do GitLab
Abra o GitLab e verifique se há novas solicitações de mesclagem no seu projeto.
Rastros de LLM do LangSmith
Se você configurou o rastreamento de LLM, abra o portal LangSmith e analise o rastreamento 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 mudanças para o repositório do GitHub
(SEÇÃO OPCIONAL)
Acesse o site do GitHub e crie um 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 digite a senha longa e pressione Enter várias vezes para concluir a geração da chave.
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/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 seu 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 integrar com as APIs do Gemini.
- Como criar e implantar um app do Atlassian Forge para o JIRA.
- Como usar agentes LangChain ReAct para automação de tarefas do GitLab.
- Como analisar rastreamentos de LLM no LangSmith.
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.