Acerca de este codelab
1. Descripción general
En este lab, crearás una solución para automatizar la implementación de historias de usuario de JIRA con la IA generativa.
Qué aprenderás
El lab tiene varias partes principales:
- Implementa la aplicación de Cloud Run para integrarla con las APIs de Gemini
- Crea e implementa la app de Atlassian Forge para JIRA
- Usa agentes de LangChain ReAct para la automatización de tareas de GitLab
Requisitos previos
- Para este lab, se da por sentado que el usuario tiene conocimientos previos sobre los entornos de shell y la consola de Cloud.
2. Configuración y requisitos
Configuración del proyecto de Cloud
- Accede a Google Cloud Console y crea un proyecto nuevo o reutiliza uno existente. Si aún no tienes una cuenta de Gmail o de Google Workspace, debes crear una.
- El Nombre del proyecto es el nombre visible de los participantes de este proyecto. Es una cadena de caracteres que no se utiliza en las APIs de Google. Puedes actualizarla cuando quieras.
- El ID del proyecto es único en todos los proyectos de Google Cloud y es inmutable (no se puede cambiar después de configurarlo). La consola de Cloud genera automáticamente una cadena única. Por lo general, no importa cuál sea. En la mayoría de los codelabs, deberás hacer referencia al ID de tu proyecto (suele identificarse como
PROJECT_ID). Si no te gusta el ID que se generó, podrías generar otro aleatorio. También puedes probar uno propio y ver si está disponible. No se puede cambiar después de este paso y se usa el mismo durante todo el proyecto. - Recuerda que hay un tercer valor, un número de proyecto, que usan algunas APIs. Obtén más información sobre estos tres valores en la documentación.
- A continuación, deberás habilitar la facturación en la consola de Cloud para usar las APIs o los recursos de Cloud. Ejecutar este codelab no costará mucho, tal vez nada. Para cerrar recursos y evitar que se generen cobros más allá de este instructivo, puedes borrar los recursos que creaste o borrar el proyecto. Los usuarios nuevos de Google Cloud son aptos para participar en el programa Prueba gratuita de $300.
Configuración del entorno
Abre el chat de Gemini.
También puedes escribir "Preguntarle a Gemini" en la barra de búsqueda.
Habilita la API de Gemini para Google Cloud:
Haz clic en "Start chatting" y sigue una de las preguntas de ejemplo o escribe tu propia instrucción para probarla.
Instrucciones que puedes probar:
- Explica Cloud Run en 5 puntos clave.
- Eres el gerente de producto de Google Cloud Run y debes explicarle Cloud Run a un estudiante en 5 puntos clave breves.
- Eres gerente de producto de Google Cloud Run y le explicas Cloud Run a un desarrollador certificado de Kubernetes en 5 puntos clave breves.
- Eres gerente de producto de Google Cloud Run y debes explicarle a un desarrollador sénior cuándo usarías Cloud Run en lugar de GKE en 5 puntos clave breves.
Consulta la Guía de instrucciones para obtener más información sobre cómo escribir mejores instrucciones.
Cómo Gemini para Google Cloud usa tus datos
Compromiso de Google con la privacidad
Google fue uno de los primeros en el sector en publicar un compromiso de privacidad con la IA y el AA, que describe nuestra creencia de que los clientes deben tener el nivel más alto de seguridad y control sobre sus datos que se almacenan en la nube.
Datos que envías y recibes
Las preguntas que le haces a Gemini, incluida cualquier información de entrada o código que envíes a Gemini para que lo analice o complete, se denominan instrucciones. Las respuestas o las terminaciones de código que recibes de Gemini se denominan respuestas. Gemini no usa tus instrucciones ni sus respuestas como datos para entrenar sus modelos.
Encriptación de instrucciones
Cuando envías instrucciones a Gemini, tus datos se encriptan en tránsito como entrada al modelo subyacente en Gemini.
Datos de programas generados a partir de Gemini
Gemini se entrena con código propio de Google Cloud y código de terceros seleccionado. Eres responsable de la seguridad, las pruebas y la eficacia de tu código, incluidos cualquier finalización, generación o análisis de código que te ofrezca Gemini.
Obtén más información sobre cómo Google maneja tus instrucciones.
3. Opciones para probar instrucciones
Tienes varias opciones para probar las instrucciones.
Vertex AI Studio es parte de la plataforma Vertex AI de Google Cloud, diseñada específicamente para simplificar y acelerar el desarrollo y el uso de modelos de IA generativa.
Google AI Studio es una herramienta basada en la Web para crear prototipos y experimentar con la ingeniería de instrucciones y la API de Gemini.
- App web de Gemini (gemini.google.com)
La app web de Google Gemini (gemini.google.com) es una herramienta basada en la Web diseñada para ayudarte a explorar y aprovechar el poder de los modelos de IA de Gemini de Google.
- App de Google Gemini para dispositivos móviles en Android y app de Google en iOS
4. Revisa la solicitud
Crear una cuenta de servicio.
Regresa a la consola de Google Cloud y activa Cloud Shell haciendo clic en el ícono que se encuentra a la derecha de la barra de búsqueda.
En la terminal abierta, ejecuta los siguientes comandos para crear una cuenta de servicio y claves nuevas.
Usarás esta cuenta de servicio para realizar llamadas a la API de Gemini de Vertex AI desde la aplicación de Cloud Run.
Configura los detalles del proyecto con los detalles de tu proyecto de Qwiklabs.
Ejemplo: qwiklabs-gcp-00-2c10937585bb
gcloud config set project YOUR_QWIKLABS_PROJECT_ID
Crea una cuenta de servicio.
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"
Otorga roles.
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"
Si se te solicita autorización, haz clic en "Autorizar" para continuar.
Habilita los servicios necesarios para usar las APIs de Vertex AI y el chat de Gemini.
gcloud services enable \
generativelanguage.googleapis.com \
aiplatform.googleapis.com \
cloudaicompanion.googleapis.com \
run.googleapis.com \
cloudresourcemanager.googleapis.com
Habilita los servicios necesarios para usar las APIs de Vertex AI y el chat de 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
Clona el repositorio de GitHub
Clona el repositorio de GitHub.
git clone https://github.com/GoogleCloudPlatform/genai-for-developers.git
Abrir el editor de Cloud Shell
En el elemento de menú “File / Open Folder”, abre “genai-for-developers”.
Abre el archivo "devai-api/app/routes.py" y, luego, haz clic con el botón derecho en cualquier parte del archivo y selecciona "Gemini > Explain this" en el menú contextual.
Revisa la explicación de Gemini para el archivo seleccionado.
5. Configuración del repositorio y el kit de herramientas de GitLab
En este lab, usarás GitLabToolkit para automatizar la creación de solicitudes de combinación de GitLab.
Descripción general de los kits de herramientas de LangChain
Los kits de herramientas de LangChain son conjuntos de herramientas diseñados para optimizar y mejorar el desarrollo de aplicaciones con LangChain. Ofrecen varias funcionalidades según el kit de herramientas específico, pero, en general, ayudan con lo siguiente:
- Conectarse a fuentes de datos externas: Accede a información de APIs, bases de datos y otras fuentes externas, y, luego, incorpórala a tus aplicaciones de LangChain.
- Técnicas avanzadas de instrucciones: Utiliza instrucciones prediseñadas o crea instrucciones personalizadas para optimizar las interacciones con los modelos de lenguaje.
- Creación y administración de cadenas: Crea cadenas complejas con facilidad y adminístralas de forma eficiente.
- Evaluación y supervisión: Analiza el rendimiento de tus cadenas y aplicaciones de LangChain.
Estos son algunos kits de herramientas de LangChain populares:
- Kits de herramientas de ejecutores de agentes: Son herramientas para desarrollar agentes que pueden interactuar con el mundo real a través de acciones como la navegación web o la ejecución de código.
- Kit de herramientas de ingeniería de instrucciones: Es una colección de recursos para crear instrucciones eficaces.
Descripción general del kit de herramientas de GitLab
El kit de herramientas de Gitlab contiene herramientas que permiten que un agente de LLM interactúe con un repositorio de Gitlab. La herramienta es un wrapper para la biblioteca python-gitlab.
El kit de herramientas de GitLab puede realizar las siguientes tareas:
- Create File: Crea un archivo nuevo en el repositorio.
- Read File: Lee un archivo del repositorio.
- Actualizar archivo: Actualiza un archivo en el repositorio.
- Create Pull Request: Crea una solicitud de extracción de la rama de trabajo del bot a la rama base.
- Get Issue: Recupera problemas del repositorio.
- Get Issue: Recupera detalles sobre un problema específico.
- Comentario sobre el problema: Publica un comentario sobre un problema específico.
- Borrar archivo: Borra un archivo del repositorio.
Configuración del proyecto de GitLab
Abre GitLab, crea un proyecto nuevo y configura el token de acceso del proyecto en "Settings / Access Tokens".
Usa los siguientes detalles:
- Nombre del token:
devai-api-qwiklabs - Rol:
Maintainer - Selecciona los permisos:
api
Copia y pega el valor del token de acceso en un archivo temporal de tu laptop. Lo usarás en los próximos pasos.
6. Prepárate para implementar la aplicación en Cloud Run
Regresa al Editor de Cloud Shell y usa una terminal existente o abre una nueva.
Configura los detalles del proyecto con los detalles de tu proyecto de Qwiklabs.
Ejemplo: qwiklabs-gcp-00-2c10937585bb
gcloud config set project YOUR-QWIKLABS-PROJECT-ID
Configura el resto de las variables de entorno:
export PROJECT_ID=$(gcloud config get-value project)
export LOCATION=us-central1
export REPO_NAME=devai-api
export SERVICE_NAME=devai-api
Configura las variables de entorno necesarias para la integración de GitLab.
export GITLAB_PERSONAL_ACCESS_TOKEN=gitlab-token
Para evitar exponer información sensible en la terminal, se recomienda usar read -s GITLAB_PERSONAL_ACCESS_TOKEN, ya que es una forma segura de establecer variables de entorno sin que el valor aparezca en el historial de comandos de la consola. Después de ejecutarlo, debes pegar el valor y presionar Intro. También deberás exportar la variable de entorno: export GITLAB_PERSONAL_ACCESS_TOKEN
Este comando requiere que actualices el ID de usuario y el nombre del repositorio de GitLab.
Ejemplo: export GITLAB_REPOSITORY="gitrey/qwiklabs-test"
export GITLAB_REPOSITORY="USERID/REPOSITORY"
Configura el resto de las variables de entorno:
export GITLAB_URL="https://gitlab.com"
export GITLAB_BRANCH="devai"
export GITLAB_BASE_BRANCH="main"
Configuración de registro de LLM de LangSmith
Configura la cuenta si deseas ver la información de seguimiento del agente en LangSmith. De lo contrario, ejecuta los comandos tal como están.
Crea una cuenta de LangSmith y genera una clave de API de servicio en la sección Configuración. https://smith.langchain.com/settings
Configura las variables de entorno necesarias para la integración de LangSmith.
export LANGCHAIN_TRACING_V2=true
export LANGCHAIN_ENDPOINT="https://api.smith.langchain.com"
export LANGCHAIN_API_KEY=langchain-service-api-key
Configuración de JIRA
Estos valores no se usan en este lab, por lo que no es necesario que los actualices a los valores específicos de tu proyecto de JIRA antes de ejecutar los comandos.
Establece las variables de entorno necesarias para la implementación del servicio de 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
Crear clave de API
Crea una clave de API nueva en la sección Cloud Console / API y servicios / Credenciales.
Esta clave se usará para autenticar las llamadas a la API de JIRA a la aplicación de Cloud Run.
Para el entorno de producción, debes configurar restricciones de aplicación y de API para la clave de API creada. Las restricciones de aplicaciones limitan el uso de una clave de API a sitios web específicos(p.ej., tu instancia de JIRA).
Establece las variables de entorno necesarias para la implementación del servicio de Cloud Run.
export DEVAI_API_KEY=your-api-key
Crea secretos en Secret Manager
En este lab, seguimos las prácticas recomendadas y usamos Secret Manager para almacenar y hacer referencia a los valores de los tokens de acceso, la clave de API y la clave de API de LangChain en Cloud Run.
Crea y almacena los secretos necesarios en 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. Implementa Devai-API en Cloud Run
Verifica que estés en la carpeta correcta.
cd ~/genai-for-developers/devai-api
Implementa la aplicación en 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
Responde Y para crear el repositorio de Docker de 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
Revisa el flujo de gcloud run deploy SERVICE_NAME --source=. a continuación. Obtén más información.
En segundo plano, este comando usa buildpacks y Cloud Build de Google Cloud para compilar automáticamente imágenes de contenedor a partir del código fuente sin tener que instalar Docker en tu máquina ni configurar los paquetes de compilación o Cloud Build. Es decir, el comando único descrito anteriormente hace lo que requeriría el uso de los comandos gcloud builds submit y gcloud run deploy.
Si proporcionaste un Dockerfile(como lo hicimos en este repositorio), Cloud Build lo usará para compilar imágenes de contenedor en lugar de depender de los paquetes de compilación para detectar y compilar imágenes de contenedor automáticamente. Para obtener más información sobre los paquetes de compilación, consulta la documentación.
Revisa los registros de Cloud Build en Console.
Revisa la imagen de Docker creada en Artifact Registry.
Revisa los detalles de la instancia de Cloud Run en la consola de Cloud.
Aplicación de prueba
Ejecuta el comando curl para probar el extremo.
Actualiza la URL del servicio de Cloud Run antes de ejecutar el comando.
Ejemplo:
curl -H "X-devai-api-key: $DEVAI_API_KEY" https://devai-api-1110000001.us-central1.run.app/test
8. Automatiza la implementación de historias
Forge es una plataforma que permite a los desarrolladores compilar apps que se integran con productos de Atlassian, como Jira, Confluence, Compass y Bitbucket.
Instala Forge CLI
Ejecuta el siguiente comando para instalar Forge CLI de forma global:
npm install -g @forge/cli
En este lab, usaremos variables de entorno para acceder.
Configura el proyecto de JIRA
Usa tu cuenta personal para crear o ver proyectos de JIRA.
Revisa tus proyectos de JIRA existentes: https://admin.atlassian.com/
Crea un proyecto de JIRA nuevo con tu cuenta personal.
Ve a https://team.atlassian.com/your-work, haz clic en 
y, luego, selecciona 
. Luego, selecciona "JIRA Software" - "Probar ahora". Sigue las indicaciones para completar la creación del proyecto o sitio.
Selecciona JIRA Software.
Crea un proyecto nuevo
Crea un token de la API de Atlassian
Crea o usa un token de API de Atlassian existente para acceder a la CLI.
La CLI usa tu token cuando ejecutas comandos.
- Ve a https://id.atlassian.com/manage/api-tokens.
- Haz clic en Crear token de API.
- Ingresa una etiqueta para describir tu token de API. Por ejemplo, forge-api-token.
- Haz clic en Crear.
- Haz clic en Copiar en el portapapeles y cierra el diálogo.
Configura la configuración del entorno de Forge
Regresa a la consola de Cloud y ejecuta los siguientes comandos en la terminal.
Accede a la CLI de Forge para comenzar a usar los comandos de Forge.
Establece tu dirección de correo electrónico de JIRA/FORGE. Reemplaza por tu dirección de correo electrónico.
export FORGE_EMAIL=your-email
Establece el token de API de Forge. Reemplaza el token de API de JIRA.
export FORGE_API_TOKEN=your-jira-api-token
Ejecuta el siguiente comando para probar forge cli. Responde "No" cuando se te solicite recopilar estadísticas.
forge settings set usage-analytics false
Verifica si accediste a tu cuenta.
forge whoami
Resultado de muestra.
Logged in as John Green (johngreen@email.com) Account ID: 123090:aaabbcc-076a-455c-99d0-d1aavvccdd
Crea una aplicación de Forge
Comprueba que estás en la carpeta "~/genai-for-developers".
Ejecuta el comando para crear una aplicación de Forge.
forge create
Usa los siguientes valores cuando se te solicite:
- Nombre de la app:
devai-jira-ui-qwiklabs - Selecciona una categoría:
UI Kit - Selecciona un producto:
Jira - Selecciona una plantilla:
jira-issue-panel
Cambia a la carpeta de la aplicación.
cd devai-jira-ui-qwiklabs/
Ejecuta el comando para instalar las dependencias.
npm install
Ejecuta el comando de implementación.
forge deploy
Resultado de muestra:
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.
Instala la aplicación.
forge install
Usa los siguientes valores cuando se te solicite:
- Selecciona un producto:
Jira - Ingresa la URL del sitio:
your-domain.atlassian.net
Resultado de muestra:
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
Abre tu sitio de JIRA y crea una tarea nueva con la siguiente descripción:
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.
Cuando abras la tarea, verás el botón "devai-jira-ui-qwiklabs".
Haz clic en el botón y revisa los cambios en la IU.
Consulta los registros del backend de Forge.
forge logs
Consola para desarrolladores de Atlassian
También puedes ver y administrar las apps implementadas en la consola de Atlassian Developer.
Revisa los registros: cambia al entorno Development.
Revisa el manifiesto y el código fuente de la aplicación de Forge
Abre el archivo "devai-jira-ui-qwiklabs/manifest.yml" y usa Gemini Code Assist para explicar la configuración.
Revisa la explicación.
Abre los siguientes archivos y pídele a Gemini Code Assist que los explique:
devai-jira-ui-qwiklabs/src/frontend/index.jsxdevai-jira-ui-qwiklabs/src/resolvers/index.js
Actualiza la app de Forge con el extremo de Cloud Run de la API de DevAI
Verifica si se configuró el ID del proyecto de GCP:
gcloud config get project
De lo contrario, configura tu proyecto de GCP con el ID del proyecto de la página del lab de Qwiklabs:
Ejemplo: qwiklabs-gcp-00-2c10937585bb
gcloud config set project YOUR_QWIKLABS_PROJECT_ID
Establece la URL del servicio de 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
Establece la clave de API de DEVAI:
export DEVAI_API_KEY=api-key-that-you-created
forge variables set --encrypt DEVAI_API_KEY $DEVAI_API_KEY
Ejecuta el siguiente comando para confirmar:
forge variables list
Resultado de muestra
Actualiza el manifiesto y el código de la aplicación de Forge
Puedes encontrar estos fragmentos de código en el repositorio, en la carpeta sample-devai-jira-ui.
Abre el archivo de manifiesto en el editor: devai-jira-ui-qwiklabs/manifest.yml
Agrega las siguientes líneas al final del archivo. Reemplaza el extremo de Cloud Run por el que implementaste.
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
Abre el archivo de resolución o índice en el editor: devai-jira-ui-qwiklabs/src/resolvers/index.js
Agrega las siguientes líneas después de la función getText existente.
resolver.define('getApiKey', (req) => {
return process.env.DEVAI_API_KEY;
});
resolver.define('getDevAIApiUrl', (req) => {
return process.env.DEVAI_API_URL;
});
Abre el archivo de frontend/índice en el editor: devai-jira-ui-qwiklabs/src/frontend/index.jsx
Reemplaza index.jsx por el siguiente contenido. Actualiza el vínculo a tu ID de usuario o repositorio de GitLab.
Hay dos lugares en los que debes actualizar TU-ID-DE-USUARIO-DE-GIT y TU-REPOSITORIO-DE-GIT.
Busca esta línea en el archivo y realiza los cambios:
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>
);
Vuelve a implementar la aplicación de Forge
Agrega dependencias en el archivo package.json:
"@forge/api": "4.0.0",
Ejecuta el comando para instalar las dependencias:
npm install
Implementa la aplicación actualizada:
forge deploy
Resultado de muestra:
ℹ 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.
Instala la aplicación actualizada:
forge install --upgrade
Resultado de muestra:
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.
Prueba la aplicación de Forge
Abre una tarea de JIRA existente o crea una nueva en tu proyecto de JIRA.
Si ya se agregó, deberás quitar el panel anterior.
Haz clic en "..." y selecciona quitar en el menú. Después, puedes volver a hacer clic en el botón.
Revisa los comentarios de Jira
Una vez que recibas una respuesta de la API de DEVAI, se agregará un comentario al problema de JIRA.
- Vínculo de solicitud de combinación de GitLab
Alterna entre las pestañas "History" y "Comments" para actualizar la vista.
Verifica la solicitud de combinación de GitLab
Abre GitLab y busca solicitudes de combinación nuevas en tu proyecto.
Registros de LLM de LangSmith
Si configuraste el seguimiento de LLM, abre el portal de LangSmith y revisa el seguimiento de LLM para la llamada de creación de solicitudes de combinación de GitLab.
Ejemplo de seguimiento de LLM de LangSmith.
9. Envía tus cambios al repositorio de GitHub
(OPTIONAL SECTION)
Ve al sitio web de GitHub y crea un repositorio nuevo para enviar los cambios de este lab a tu repositorio personal.
Regresa a la consola de Cloud y establece el nombre de usuario y el correo electrónico de Git en la terminal.
Actualiza los valores antes de ejecutar los comandos.
git config --global user.name "Your Name"
git config --global user.email "your_email@example.com"
Genera una clave SSH y agrégala al repositorio de GitHub.
Actualiza tu correo electrónico antes de ejecutar los comandos.
No ingreses la frase de contraseña ni presiones Intro varias veces para completar la generación de claves.
ssh-keygen -t ed25519 -C "your-email-address"
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519
cat ~/.ssh/id_ed25519.pub
Agrega la clave pública generada a tu cuenta de GitHub.
Abre https://github.com/settings/keys y haz clic en "New SSH key".
Para el nombre de la clave, usa "qwiklabs-key" y copia y pega el resultado del último comando.
Regresa a la terminal, confirma y envía los cambios.
cd ~/genai-for-developers
git remote rm origin
Establece el origen remoto con el repositorio que se creó anteriormente.
Reemplaza la URL del repositorio.
git remote add origin git@github.com:YOUR-GITHUB-USERID/YOUR-GITHUB-REPO.git
Agrega, confirma y envía los cambios.
git add .
git commit -m "lab changes"
git push -u origin main
10. ¡Felicitaciones!
¡Felicitaciones! Completaste el lab.
Temas abordados:
- Cómo implementar aplicaciones de Cloud Run para integrarlas con las APIs de Gemini
- Cómo crear e implementar la app de Atlassian Forge para JIRA
- Cómo usar agentes de ReAct de LangChain para la automatización de tareas de GitLab
- Cómo revisar los seguimientos de LLM en LangSmith
¿Qué sigue?
- ¡Pronto habrá más sesiones prácticas!
Limpia
Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.
Borra el proyecto
La manera más fácil de eliminar la facturación es borrar el proyecto que creaste para el instructivo.
©2024 Google LLC Todos los derechos reservados. Google y el logotipo de Google son marcas de Google LLC. El resto de los nombres de productos y empresas pueden ser marcas de las respectivas empresas a las que están asociados.