Se usó la API de Cloud Translation para traducir esta página.

Implementación de historias de usuario de JIRA con IA generativa

1. Descripción general

En este lab, crearás una solución para automatizar la implementación de historias de uso 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
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 "Pregúntale a Gemini" en la barra de búsqueda.

Habilita la API de Cloud AI Companion:

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 privacidad de Google

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 la información de entrada o el código que le envías para que las 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

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

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.

Aplicación para dispositivos móviles de Google Gemini para Android y app de Google en iOS

4. (SECCI￳N OPCIONAL) Crea una cuenta de servicio

Estos pasos se ejecutaron durante la configuración del lab. No es necesario que los ejecutes.

Estos pasos se incluyen para mostrar cómo configurar una cuenta de servicio y roles de IAM.

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 y otorga roles.

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 --project $PROJECT_ID --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"

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"


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

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

(END OF OPTIONAL SECTION)

5. Otorga acceso a Cloud Workstations

Abre Cloud Workstations en la consola de Cloud.

Otorga acceso a Cloud Workstation al estudiante de Qwiklabs aprovisionado.

Copia el nombre de usuario o correo electrónico de Qwiklabs que se creó para este proyecto y úsalo para agregar un administrador. Selecciona la estación de trabajo y haz clic en "PERMISSIONS".

(consulte los detalles que aparecen a continuación).

Haz clic en el botón “ADD PRINCIPAL”.

Pega el correo electrónico del estudiante de Qwiklabs y selecciona el rol “Cloud Workstations User”.

Haz clic en "Start" y, luego, en "Launch" para abrir la estación de trabajo y continuar con los siguientes pasos usando la terminal integrada.

Clona el repositorio de GitHub

Crea una carpeta y clona el repositorio de GitHub.

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

En el elemento de menú “File / Open Folder”, abre “github/genai-for-developers”.

6. Habilita Gemini Code Assist

Haz clic en el ícono de “Gemini” y, en la esquina inferior derecha, haz clic en “Login to Google Cloud”.

Haz clic en el vínculo de la terminal para iniciar el flujo de autorización.

Haz clic en “Abrir” para seguir el vínculo.

Selecciona tu cuenta de estudiante de Qwiklabs y haz clic en "Acceder" en la siguiente pantalla.

Copia el código de verificación:

Regresa a la terminal y pega el código.

Espera a que se complete la autenticación y, luego, haz clic en "Seleccionar un proyecto de Google".

En la ventana emergente, selecciona tu proyecto de Qwiklabs.

Ejemplo:

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.

7. 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 indicaciones: Utiliza indicaciones prediseñadas o crea indicaciones 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 del ejecutor 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.

Kit de herramientas de GitLab

En este lab, usarás el kit de herramientas de GitLab para automatizar la creación de solicitudes de combinación 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.

8. Configuración del repositorio y el kit de herramientas de GitLab

Abre GitLab, crea un proyecto público 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. Se usará en los próximos pasos.

9. Prepárate para implementar la aplicación en Cloud Run

Regresa a la instancia de Cloud Workstations y usa una terminal existente o abre una nueva.

Obtén credenciales de acceso para tu cuenta de usuario a través de un flujo de autorización basado en la Web.

Haz clic en el vínculo y sigue los pasos para generar el código de verificación.

gcloud auth login

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

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"

10. Configuración de registro de LLM de LangSmith

Crea una cuenta de LangSmith y genera una clave de API de servicio en la sección Configuración. https://docs.smith.langchain.com/

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

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

12. Implementa Devai-API en Cloud Run

Verifica que estés en la carpeta correcta.

cd ~/github/genai-for-developers/devai-api

En este lab, seguimos las prácticas recomendadas y usamos Secret Manager para almacenar y hacer referencia a los valores del token de acceso y la clave de API de LangChain en Cloud Run.

Almacena el token de acceso de JIRA en Secret Manager.

echo -n $JIRA_API_TOKEN | \
 gcloud secrets create JIRA_API_TOKEN \
 --data-file=-

Almacena el token de acceso de GitLab en Secret Manager.

echo -n $GITLAB_PERSONAL_ACCESS_TOKEN | \
 gcloud secrets create GITLAB_PERSONAL_ACCESS_TOKEN \
 --data-file=-

Almacena la clave de API de LangChain en Secret Manager.

echo -n $LANGCHAIN_API_KEY | \
 gcloud secrets create LANGCHAIN_API_KEY \
 --data-file=-

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" \
  --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 contenedores en lugar de depender de los paquetes de compilación para detectar e implementar imágenes de contenedores 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.

Abre cloud-run-source-deploy/devai-api y revisa las vulnerabilidades que se detectaron automáticamente. Revisa los que tienen correcciones disponibles y consulta cómo se pueden solucionar según la descripción.

Revisa los detalles de la instancia de Cloud Run en la consola de Cloud.

Ejecuta el comando curl para probar el extremo.

curl -X POST \
   -H "Content-Type: application/json" \
   -d '{"prompt": "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."}' \
   $(gcloud run services list --filter="(devai-api)" --format="value(URL)")/generate

(SECCI￳N OPCIONAL) Configura Cloud Workstation

Cloud Workstations proporciona entornos de desarrollo administrados en Google Cloud con seguridad integrada y entornos de desarrollo preconfigurados y personalizables. En lugar de exigirles a los desarrolladores que instalen software y ejecuten secuencias de comandos de configuración, puedes crear una configuración de estación de trabajo que especifique tu entorno de una manera reproducible. Cualquier actualización de la configuración de una estación de trabajo se aplica automáticamente a las estaciones de trabajo la próxima vez que se inician. Los desarrolladores acceden a las estaciones de trabajo a través de un IDE basado en el navegador, desde varios editores de código locales (como VSCode o IDE de JetBrains, como IntelliJ IDEA Ultimate y PyCharm Professional), o a través de SSH.

Cloud Workstations usa los siguientes recursos de Google Cloud para administrar tus entornos de desarrollo:

Los clústeres de estaciones de trabajo definen un grupo de estaciones de trabajo en una región en particular y la red de VPC a la que están conectadas. Los clústeres de las estaciones de trabajo no están relacionados con los clústeres de Google Kubernetes Engine (GKE).
Los parámetros de configuración de las estaciones de trabajo actúan como plantillas para ellas. La configuración de la estación de trabajo define detalles como el tipo de instancia de máquina virtual (VM) de la estación de trabajo, el almacenamiento persistente, el entorno de definición de la imagen del contenedor, qué IDE o editor de código usar y mucho más. Los administradores y los equipos de la plataforma también pueden usar las reglas de Identity and Access Management (IAM) para otorgar acceso a equipos o a desarrolladores individuales.
Las workstations son entornos de desarrollo preconfigurados que proporcionan un IDE en la nube, herramientas de lenguaje, bibliotecas y mucho más. Las estaciones de trabajo se pueden iniciar o detener a pedido y ejecutar en VMs de Compute Engine en tu proyecto, con un disco persistente conectado para almacenar datos entre sesiones.

Los administradores y los equipos de la plataforma crean configuraciones de estaciones de trabajo que comparten con su equipo de desarrollo. Cada desarrollador crea una estación de trabajo basada en una configuración de estación de trabajo.

En este lab, usas un IDE basado en el navegador, pero Cloud Workstations también admite otras interfaces de desarrollo comunes:

Puedes usar tus propios IDE de JetBrains locales a través de la puerta de enlace de JetBrains.
Si usas VSCode local, también puedes acceder a tus estaciones de trabajo para el desarrollo remoto a través de SSH.
También puedes configurar SSH y, hasta, túneles TCP en tu estación de trabajo desde tu máquina local.

(SECCI￳N OPCIONAL) Crea un clúster de estaciones de trabajo

Estos pasos se ejecutaron durante la configuración del lab. No es necesario que los ejecutes.

Estos pasos se incluyen para mostrar cómo configurar el clúster, la configuración y la estación de trabajo de Cloud Workstations.

Revisa esta sección y ve a la sección de la plataforma de Forge.

Crea un clúster de estaciones de trabajo:

gcloud workstations clusters create ws-cluster --region=us-central1

Crear configuración de estaciones de trabajo

gcloud workstations configs create devai-config \
--cluster=ws-cluster \
--machine-type=e2-standard-8 \
--region=us-central1 \
--running-timeout=21600 \
--idle-timeout=1800 \
--container-predefined-image=codeoss \
--pd-disk-size=200 \
--pd-disk-type=pd-standard \
--service-account=$SERVICE_ACCOUNT_NAME@$PROJECT_ID.iam.gserviceaccount.com \
--pool-size=1

Crear estación de trabajo

gcloud workstations create devai-workstation \
--cluster=ws-cluster \
--config=devai-config \
--region=us-central1

Consulta las estaciones de trabajo disponibles en la consola de Cloud. Inicia y abre "devai-workstation".

Habilita "Gemini" en la esquina inferior derecha, sigue el flujo de acceso en la nueva pestaña del navegador y vuelve a copiar el código generado en la consola para completar el acceso.

Abre el chat de "Gemini" en el panel izquierdo y pregúntale a Gemini lo siguiente:

"You are a Cloud Workstations Product Manager, tell me about Cloud Workstations".

"You are Cloud Workstations Product Manager, Can I create my custom Cloud Workstations image with my company tools so new developers can onboard in minutes?".

(END OF OPTIONAL SECTION)

13. Plataforma de Forge

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 los siguientes comandos en la terminal.

Descarga el Administrador de versiones de Node ( nvm) y haz que esté disponible en la ruta de acceso de la sesión de la terminal actual.

cd ~/github/genai-for-developers

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash


export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh" # This loads nvm
[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion" # This loads nvm bash_completion

Instala nvm.

Para seleccionar la versión LTS más reciente de Node.js, ejecuta el siguiente comando en la terminal:

nvm install --lts
nvm use --lts

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

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

Ejecuta el siguiente comando en la terminal de Cloud Workstations.

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 la CLI de Forge. 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 "~/github/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 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 explicarlo.

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

Ejecuta el siguiente comando para confirmarlo:

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/generate # 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.LLM_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 apiKey = 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 genAI = new GoogleGenerativeAI(apiKey);
    // const model = genAI.getGenerativeModel({ model: "gemini-pro"});
    // const prompt = `You are principal software engineer at Google and given requirements below to implement.\nPlease provide implementation details and documentation.\n\nREQUIREMENTS:\n\n${data.fields.description}`
    // const result = await model.generateContent(prompt);
    // const text = result.response.text();
    // const jsonText = JSON.stringify(text);

    const bodyGenerateData = `{"prompt": ${JSON.stringify(data.fields.description)}}`;

    const generateRes = await api.fetch(devAIApiUrl+'/generate',
      {
        body: bodyGenerateData,
        method: 'post',
        headers: { 'Content-Type': 'application/json' },
      }
    )


    const resData = await generateRes.text();
    const jsonText = JSON.stringify(resData);

    const bodyData = `{
      "body": ${jsonText}
    }`;

    console.log("bodyData", bodyData)
    // Add Gemini response as a comment on the JIRA issue
    await requestJira(`/rest/api/2/issue/${issueId}/comment`, {
      method: 'POST',
      headers: {
        'Accept': 'application/json',
        'Content-Type': 'application/json'
      },
      body: bodyData
    });
    // 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",

Instala 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án dos comentarios al problema de JIRA.

Solicitud de combinación de GitLab
Detalles de la implementación de la historia de usuario de Gemini

Alterna entre las pestañas "History" y "Comments" para actualizar la vista.

Habilita la creación de solicitudes de combinación de GitLab

Abre el archivo devai-api/app/routes.py y quita los comentarios de las siguientes líneas en el método generate_handler:

print(f"{response.text}\n")

    # resp_text = response.candidates[0].content.parts[0].text

    # pr_prompt = f"""Create GitLab merge request using provided details below.
    # Create new files, commit them and push them to opened merge request.
    # When creating new files, remove the lines that start with ``` before saving the files.

    # DETAILS: 
    # {resp_text}
    # """

    # print(pr_prompt)
    # agent.invoke(pr_prompt)

Vuelve a implementar la aplicación de Cloud Run

Verifica que estés en la carpeta correcta.

cd ~/github/genai-for-developers/devai-api

Si usas la misma sesión de terminal, es posible que todas las variables de entorno sigan configuradas.

Para verificarlo, ejecuta "echo $GITLAB_REPOSITORY" en la terminal.

Sigue estos pasos para restablecerlos si se abrió una sesión de terminal nueva.

Asegúrate de restablecer las variables de entorno necesarias antes de volver a implementar la aplicación.

Este comando requiere que actualices el ID de usuario y el nombre del repositorio de GitLab.

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"

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

export LOCATION=us-central1
export REPO_NAME=devai-api
export SERVICE_NAME=devai-api
export PROJECT_ID=$(gcloud config get-value project)

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

El kit de herramientas de GitLab usará la rama “devai” para enviar los cambios de la solicitud de combinación.

Verifica que ya hayas creado esa rama.

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" \
  --min-instances=1 \
  --max-instances=3

Verifica la integración de extremo a extremo

Inicia el proceso desde la tarea de JIRA haciendo clic nuevamente en el botón y verifica el resultado en el repositorio de GitLab, en la sección Solicitud de combinación y LangSmith.

Detalles de la solicitud de combinación de GitLab.

Registros de LLM de LangSmith

Abre el portal de LangSmith y revisa el registro de LLM para la llamada de creación de problemas de JIRA.

Ejemplo de seguimiento de LLM de LangSmith.

(SECCI￳N OPCIONAL) Envía tus cambios al repositorio de GitHub

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 instancia de Cloud Workstations y configura 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 ~/github/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

15. ¡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?

Próximamente, habrá más sesiones prácticas.

Realiza una limpieza

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.