Cette page a été traduite par l'API Cloud Translation.

Implémentation des histoires d'utilisateurs JIRA avec l'IA générative

1. Présentation

Dans cet atelier, vous allez créer une solution permettant d'automatiser l'implémentation des histoires d'utilisation JIRA avec l'IA générative.

Objectifs de l'atelier

L'atelier se compose de plusieurs parties principales:

Déployer une application Cloud Run pour l'intégrer aux API Gemini
Créer et déployer une application Atlassian Forge pour JIRA
Agents ReAct LangChain pour l'automatisation des tâches GitLab

Prérequis

Dans cet atelier, nous considérons que vous connaissez la console Cloud et les environnements Cloud Shell.

2. Préparation

Configuration du projet Cloud

Connectez-vous à la console Google Cloud, puis créez un projet ou réutilisez un projet existant. Si vous n'avez pas encore de compte Gmail ou Google Workspace, vous devez en créer un.

Le nom du projet est le nom à afficher pour les participants au projet. Il s'agit d'une chaîne de caractères non utilisée par les API Google. Vous pourrez toujours le modifier.
L'ID du projet est unique parmi tous les projets Google Cloud et non modifiable une fois défini. La console Cloud génère automatiquement une chaîne unique (en général, vous n'y accordez d'importance particulière). Dans la plupart des ateliers de programmation, vous devrez indiquer l'ID de votre projet (généralement identifié par PROJECT_ID). Si l'ID généré ne vous convient pas, vous pouvez en générer un autre de manière aléatoire. Vous pouvez également en spécifier un et voir s'il est disponible. Après cette étape, l'ID n'est plus modifiable et restera donc le même pour toute la durée du projet.
Pour information, il existe une troisième valeur (le numéro de projet) que certaines API utilisent. Pour en savoir plus sur ces trois valeurs, consultez la documentation.

Vous devez ensuite activer la facturation dans la console Cloud pour utiliser les ressources/API Cloud. L'exécution de cet atelier de programmation est très peu coûteuse, voire sans frais. Pour désactiver les ressources et éviter ainsi que des frais ne vous soient facturés après ce tutoriel, vous pouvez supprimer le projet ou les ressources que vous avez créées. Les nouveaux utilisateurs de Google Cloud peuvent participer au programme d'essai sans frais pour bénéficier d'un crédit de 300 $.

Cofiguration de l'environnement

Ouvrez Gemini Chat.

Vous pouvez également saisir "Demander à Gemini" dans la barre de recherche.

Activez l'API Cloud AI Companion:

Cliquez sur Start chatting, puis suivez l'une des questions exemples ou saisissez votre propre requête pour tester la fonctionnalité.

Requêtes à tester :

Expliquez Cloud Run en cinq points clés.
Vous êtes responsable produit Google Cloud Run. Expliquez Cloud Run à un étudiant en cinq points clés.
Vous êtes responsable produit Google Cloud Run. Expliquez Cloud Run à un développeur Kubernetes certifié en cinq points clés.
Vous êtes responsable produit Google Cloud Run. Expliquez à un développeur expérimenté en cinq points clés quand utiliser Cloud Run par rapport à GKE.

Consultez le guide des requêtes pour en savoir plus sur la rédaction de requêtes plus efficaces.

Utilisation de vos données par Gemini pour Google Cloud

Engagement de Google en matière de confidentialité

Google a été l'un des premiers sur le marché à proposer un engagement en matière de confidentialité pour l'IA/le ML, ce qui souligne le fait que nos clients devraient disposer du plus haut niveau de sécurité et de contrôle sur leurs données stockées dans le cloud.

Données que vous envoyez et recevez

Les questions que vous posez à Gemini, y compris les informations ou le code que vous lui envoyez pour qu'il les analyse ou les complète, sont appelées requêtes. Les réponses ou les suggestions de code que vous recevez de Gemini sont appelées "réponses". Gemini n'utilise pas vos requêtes ni ses réponses comme données pour entraîner ses modèles.

Chiffrement des requêtes

Lorsque vous envoyez des requêtes à Gemini, vos données sont chiffrées en transit pour être transmises au modèle sous-jacent de Gemini.

Données de programme générées par Gemini

Gemini est entraîné sur du code Google Cloud propriétaire et sur du code tiers sélectionné. Vous êtes responsable de la sécurité, des tests et de l'efficacité de votre code, y compris de toute complétion, génération ou analyse de code que Gemini vous propose.

Découvrez comment Google traite vos requêtes.

3. Options pour tester les requêtes

Plusieurs options s'offrent à vous pour tester les requêtes.

Vertex AI Studio

Vertex AI Studio fait partie de la plate-forme Vertex AI de Google Cloud, spécialement conçue pour simplifier et accélérer le développement et l'utilisation de modèles d'IA générative.

Google AI Studio

Google AI Studio est un outil Web permettant de prototyper et de tester l'ingénierie des requêtes et l'API Gemini.

Application Web Gemini (gemini.google.com)

L'application Web Google Gemini (gemini.google.com) est un outil Web conçu pour vous aider à explorer et à exploiter la puissance des modèles d'IA Gemini de Google.

Application mobile Google Gemini pour Android et application Google sur iOS

4. (SECTION FACULTATIVE) Créer un compte de service

Ces étapes ont été exécutées lors de la configuration de l'atelier. Vous n'avez pas besoin de les exécuter.

Ces étapes vous montrent comment configurer un compte de service et des rôles IAM.

Revenez à la console Google Cloud et activez Cloud Shell en cliquant sur l'icône située à droite de la barre de recherche.

Dans le terminal ouvert, exécutez les commandes suivantes pour créer un compte de service et des clés.

Vous utiliserez ce compte de service pour effectuer des appels d'API à l'API Gemini Vertex AI à partir de l'application Cloud Run.

Configurez les informations de votre projet à l'aide des informations de votre projet Qwiklabs.

Exemple : qwiklabs-gcp-00-2c10937585bb

gcloud config set project YOUR_QWIKLABS_PROJECT_ID

Créez un compte de service et attribuez-lui des rôles.

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 vous y êtes invité, cliquez sur "Autoriser" pour continuer.

Activez les services requis pour utiliser les API Vertex AI et le chat Gemini.

gcloud services enable \
    generativelanguage.googleapis.com \
    aiplatform.googleapis.com \
    cloudaicompanion.googleapis.com \
    run.googleapis.com \
    cloudresourcemanager.googleapis.com

Activez les services requis pour utiliser les API Vertex AI et le chat Gemini.

gcloud services enable \
    artifactregistry.googleapis.com \
    cloudbuild.googleapis.com \
    runapps.googleapis.com \
    workstations.googleapis.com \
    servicemanagement.googleapis.com \
    secretmanager.googleapis.com \
    containerscanning.googleapis.com

(END OF OPTIONAL SECTION)

5. Accorder l'accès à Cloud Workstations

Ouvrez Cloud Workstations dans la Cloud Console.

Accordez l'accès à Cloud Workstation à l'étudiant Qwiklabs provisionné.

Copiez le nom d'utilisateur/l'adresse e-mail Qwiklabs créé pour ce projet, puis utilisez-le pour ajouter un principal. Sélectionnez la station de travail, puis cliquez sur PERMISSIONS.

Consultez les détails ci-dessous.

Cliquez sur le bouton "ADD PRINCIPAL".

Collez l'adresse e-mail de l'élève Qwiklabs, puis sélectionnez le rôle Cloud Workstations User.

Cliquez sur "Start", puis sur "Launch" pour ouvrir la station de travail et suivez les étapes suivantes à l'aide du terminal intégré.

Cloner le dépôt GitHub

Créez un dossier et clonez le dépôt GitHub.

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

À l'aide de l'élément de menu "File / Open Folder", ouvrez "github/genai-for-developers".

6. Activer Gemini Code Assist

Cliquez sur l'icône Gemini en bas à droite, puis sur Login to Google Cloud.

Cliquez sur le lien dans le terminal pour démarrer le flux d'autorisation.

Cliquez sur "Ouvrir" pour suivre le lien.

Sélectionnez votre compte étudiant Qwiklabs, puis cliquez sur "Se connecter" sur l'écran suivant.

Copiez le code de validation:

Revenez au terminal et collez le code.

Attendez que l'authentification soit terminée, puis cliquez sur "Sélectionner un projet Google".

Dans la fenêtre pop-up, sélectionnez votre projet Qwiklabs.

Exemple :

Ouvrez le fichier "devai-api/app/routes.py", puis effectuez un clic droit n'importe où dans le fichier et sélectionnez "Gemini > Explain this"" dans le menu contextuel.

Consultez l'explication de Gemini sur le fichier sélectionné.

7. Kits LangChain

Les kits d'outils LangChain sont des ensembles d'outils conçus pour simplifier et améliorer le développement d'applications avec LangChain. Ils offrent différentes fonctionnalités en fonction de la boîte à outils spécifique, mais en général, ils aident à:

Se connecter à des sources de données externes: accédez aux informations provenant d'API, de bases de données et d'autres sources externes, et incorporez-les dans vos applications LangChain.
Techniques avancées de requête: utilisez des requêtes prédéfinies ou créez-en des personnalisées pour optimiser les interactions avec les modèles de langage.
Création et gestion de chaînes: créez facilement des chaînes complexes et gérez-les efficacement.
Évaluation et surveillance: analysez les performances de vos applications et chaînes LangChain.

Voici quelques kits d'outils LangChain populaires:

Kits d'outils d'exécution d'agents: outils permettant de développer des agents capables d'interagir avec le monde réel via des actions telles que la navigation sur le Web ou l'exécution de code.
Kit d'ingénierie des requêtes: ensemble de ressources permettant de créer des requêtes efficaces.

Kit d'outils GitLab

Dans cet atelier, vous allez utiliser le Kit d'outils GitLab pour automatiser la création de demandes de fusion GitLab.

La boîte à outils GitLab contient des outils qui permettent à un agent LLM d'interagir avec un dépôt GitLab. Il s'agit d'un wrapper pour la bibliothèque python-gitlab.

Le toolkit GitLab peut effectuer les tâches suivantes:

Créer un fichier : crée un fichier dans le dépôt.
Read File (Lire un fichier) : lit un fichier à partir du dépôt.
Mettre à jour le fichier : met à jour un fichier du dépôt.
Créer une demande d'extraction : crée une demande d'extraction de la branche de travail du bot vers la branche de base.
Get Issue (Obtenir un problème) : extrait les problèmes du dépôt.
Get Issue (Obtenir le problème) : permet d'obtenir des informations sur un problème spécifique.
Commenter le problème : permet de publier un commentaire sur un problème spécifique.
Supprimer un fichier : supprime un fichier du dépôt.

8. Configuration du dépôt et du kit d'outils GitLab

Ouvrez GitLab, créez un projet public et configurez le jeton d'accès au projet sous "Settings / Access Tokens".

Utilisez les informations suivantes:

Nom du jeton: devai-api-qwiklabs
Rôle : Maintainer
Sélectionnez les champs d'application: api

Copiez et collez la valeur du jeton d'accès dans un fichier temporaire sur votre ordinateur portable. Vous l'utiliserez aux étapes suivantes.

9. Préparer le déploiement d'une application sur Cloud Run

Revenez à l'instance Cloud Workstations et utilisez un terminal existant ou ouvrez-en un nouveau.

Obtenez les identifiants d'accès à votre compte utilisateur via un flux d'autorisation Web.

Cliquez sur le lien et suivez les étapes pour générer un code de validation.

gcloud auth login

Configurez les informations de votre projet à l'aide des informations de votre projet Qwiklabs.

Exemple : qwiklabs-gcp-00-2c10937585bb

gcloud config set project YOUR-QWIKLABS-PROJECT-ID

Définissez le reste des variables d'environnement:

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

Définissez les variables d'environnement requises pour l'intégration GitLab.

export GITLAB_PERSONAL_ACCESS_TOKEN=gitlab-token

Pour éviter de divulguer des informations sensibles dans le terminal, il est recommandé d'utiliser read -s. Il s'agit d'un moyen sécurisé de définir des variables d'environnement sans que leur valeur ne s'affiche dans l'historique des commandes de la console. Après l'avoir exécuté, vous devez coller la valeur et appuyer sur Entrée.

Cette commande vous oblige à mettre à jour votre ID utilisateur et le nom de votre dépôt GitLab.

Exemple : export GITLAB_REPOSITORY="gitrey/qwiklabs-test"

export GITLAB_REPOSITORY="USERID/REPOSITORY"

Définissez le reste des variables d'environnement:

export GITLAB_URL="https://gitlab.com"
export GITLAB_BRANCH="devai"
export GITLAB_BASE_BRANCH="main"

10. Configuration du traçage LLM LangSmith

Créez un compte LangSmith et générez une clé API de service dans la section "Paramètres". https://docs.smith.langchain.com/

Définissez les variables d'environnement requises pour l'intégration de LangSmith.

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

export LANGCHAIN_API_KEY=langchain-service-api-key

11. Configuration JIRA

Ces valeurs ne sont pas utilisées dans cet atelier. Vous n'avez donc pas besoin de les remplacer par les valeurs de votre projet JIRA spécifique avant d'exécuter les commandes.

Définissez les variables d'environnement requises pour le déploiement du service 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. Déployer Devai-API sur Cloud Run

Vérifiez que vous êtes dans le bon dossier.

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

Pour cet atelier, nous suivons les bonnes pratiques et utilisons Secret Manager pour stocker et référencer les valeurs du jeton d'accès et de la clé API LangChain dans Cloud Run.

Stockez le jeton d'accès JIRA dans Secret Manager.

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

Stockez le jeton d'accès GitLab dans Secret Manager.

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

Stockez la clé API LangChain dans Secret Manager.

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

Déployez l'application sur 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

Répondez Y pour créer le dépôt Docker 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

Consultez le flux gcloud run deploy SERVICE_NAME --source=. ci-dessous. En savoir plus

En arrière-plan, cette commande utilise buildpacks et Cloud Build de Google Cloud pour créer automatiquement des images de conteneurs à partir de votre code source sans avoir à installer Docker sur votre machine ni à configurer des packs de création ou Cloud Build. En d'autres termes, la commande unique décrite ci-dessus effectue ce qui nécessite normalement les commandes gcloud builds submit et gcloud run deploy.

Si vous avez fourni un Dockerfile(comme nous l'avons fait dans ce dépôt), Cloud Build l'utilisera pour créer des images de conteneur au lieu de s'appuyer sur les buildpacks pour détecter et créer automatiquement des images de conteneur. Pour en savoir plus sur les buildpacks, consultez la documentation.

Examinez les journaux Cloud Build dans la console.

Examinez l'image Docker créée dans Artifact Registry.

Ouvrez cloud-run-source-deploy/devai-api et examinez les failles détectées automatiquement. Recherchez les problèmes pour lesquels des solutions sont disponibles et découvrez comment les résoudre en fonction de la description.

Consultez les détails de l'instance Cloud Run dans la console Cloud.

Testez le point de terminaison en exécutant la commande curl.

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

(SECTION FACULTATIVE) Configurer Cloud Workstation

Cloud Workstations fournit des environnements de développement gérés sur Google Cloud avec sécurité intégrée et des environnements de développement préconfigurés, mais personnalisables. Au lieu d'obliger vos développeurs à installer des logiciels et à exécuter des scripts de configuration, vous pouvez créer une configuration de poste de travail qui spécifie votre environnement de manière reproductible. Toute mise à jour de la configuration d'une station de travail s'applique automatiquement à la station de travail lors du prochain démarrage. Les développeurs accèdent aux stations de travail via un IDE basé sur un navigateur, à partir de plusieurs éditeurs de code locaux (tels que VSCode ou les IDE JetBrains tels qu'IntelliJ IDEA Ultimate et PyCharm Professional) ou via SSH.

Cloud Workstations utilise les ressources Google Cloud suivantes pour gérer vos environnements de développement:

Les clusters de stations de travail définissent un groupe de stations de travail dans une région spécifique et le réseau VPC auquel elles sont associées. Les clusters de stations de travail ne sont pas liés aux clusters Google Kubernetes Engine (GKE).
Les configurations de stations de travail servent de modèles pour les stations de travail. La configuration de la station de travail définit des détails tels que le type d'instance de machine virtuelle (VM) de la station de travail, le stockage persistant, l'environnement de définition de l'image de conteneur, l'IDE ou l'éditeur de code à utiliser, etc. Les administrateurs et les équipes de la plate-forme peuvent également utiliser des règles IAM (Identity and Access Management) pour accorder l'accès à des équipes ou à des développeurs individuels.
Les stations de travail sont des environnements de développement préconfigurés qui fournissent un IDE cloud, des outils de langage, des bibliothèques, etc. Les stations de travail peuvent être démarrées ou arrêtées à la demande, et exécutées sur des VM Compute Engine de votre projet, avec un disque persistant associé pour stocker les données entre les sessions.

Les administrateurs et les équipes de plate-forme créent des configurations de stations de travail qu'ils partagent avec leur équipe de développement. Chaque développeur crée une station de travail en fonction d'une configuration de station de travail.

Dans cet atelier, vous utilisez un IDE basé sur un navigateur, mais Cloud Workstations prend également en charge d'autres interfaces de développement courantes:

Vous pouvez utiliser vos propres IDE JetBrains locaux via JetBrains Gateway.
Si vous utilisez VSCode local, vous pouvez également accéder à vos stations de travail pour le développement à distance via SSH.
Vous pouvez également configurer des tunnels SSH et même TCP vers votre station de travail depuis votre machine locale.

(SECTION FACULTATIVE) Créer un cluster Workstations

Ces étapes ont été exécutées lors de la configuration de l'atelier. Vous n'avez pas besoin de les exécuter.

Ces étapes vous montrent comment configurer le cluster, la configuration et la station de travail Cloud Workstations.

Consultez cette section, puis passez à la section "Plate-forme Forge".

Créez un cluster Workstations:

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

Créer une configuration Workstations

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

Créer une station de travail

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

Affichez les stations de travail disponibles dans la console Cloud. Démarrez et lancez "devai-workstation".

Activez Gemini en bas à droite, suivez la procédure de connexion dans le nouvel onglet du navigateur, puis copiez le code généré dans la console pour terminer la connexion.

Ouvrez la discussion "Gemini" dans le panneau de gauche et demandez à Gemini:

"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. Plate-forme Forge

Forge est une plate-forme qui permet aux développeurs de créer des applications qui s'intègrent aux produits Atlassian, tels que Jira, Confluence, Compass et Bitbucket.

Installer la CLI Forge

Exécutez les commandes ci-dessous dans le terminal.

Téléchargez Node Version Manager ( nvm) et rendez-le disponible sur le chemin d'accès de la session de terminal actuelle.

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

Installez nvm.

Sélectionnez la dernière version LTS de Node.js en exécutant la commande suivante dans le terminal:

nvm install --lts
nvm use --lts

Installez la CLI Forge au niveau global en exécutant:

npm install -g @forge/cli

Pour cet atelier, nous utiliserons des variables d'environnement pour nous connecter.

Configurer le projet JIRA

Utilisez votre compte personnel pour créer/afficher des projets JIRA.

Consultez vos projets JIRA existants: https://admin.atlassian.com/

Créez un projet JIRA à l'aide de votre compte personnel.

Accédez à https://team.atlassian.com/your-work, cliquez sur , puis sélectionnez . Sélectionnez ensuite "JIRA Software" - "Essai sans frais". Suivez les instructions pour terminer de créer le projet/le site.

Sélectionnez JIRA Software.

Créez un projet.

14. Jeton d'API Atlassian

Créez ou utilisez un jeton d'API Atlassian existant pour vous connecter à la CLI.

La CLI utilise votre jeton lors de l'exécution de commandes.

Accédez à https://id.atlassian.com/manage/api-tokens.
Cliquez sur Créer un jeton d'API.
Saisissez un libellé pour décrire votre jeton d'API. Par exemple, "forge-api-token".
Cliquez sur Créer.
Cliquez sur Copier dans le presse-papiers, puis fermez la boîte de dialogue.

Exécutez la commande ci-dessous dans le terminal Cloud Workstations.

Connectez-vous à la CLI Forge pour commencer à utiliser les commandes Forge.

Indiquez votre adresse e-mail JIRA/FORGE. Remplacez-le par votre adresse e-mail.

export FORGE_EMAIL=your-email

Définissez le jeton d'API Forge. Remplacez-le par votre jeton d'API JIRA.

export FORGE_API_TOKEN=your-jira-api-token

Testez la CLI Forge en exécutant la commande ci-dessous. Répondez "No" lorsque vous êtes invité à collecter des données analytiques.

forge settings set usage-analytics false

Vérifiez que vous êtes connecté.

forge whoami

Exemple de résultat.

Logged in as John Green (johngreen@email.com)
Account ID: 123090:aaabbcc-076a-455c-99d0-d1aavvccdd

Créer une application Forge

Vérifiez que vous vous trouvez dans le dossier "~/github/genai-for-developers".

Exécutez la commande pour créer une application Forge.

forge create

Lorsque vous y êtes invité, utilisez les valeurs suivantes:

Nom de l'application: devai-jira-ui-qwiklabs
Sélectionnez une catégorie: UI Kit
Sélectionnez un produit: Jira
Sélectionnez un modèle: jira-issue-panel

Accédez au dossier de l'application.

cd devai-jira-ui-qwiklabs/

Exécutez la commande de déploiement.

forge deploy

Exemple de résultat :

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.

Installez l'application.

forge install

Lorsque vous y êtes invité, utilisez les valeurs suivantes:

Sélectionnez un produit: Jira
Saisissez l'URL du site: your-domain.atlassian.net.

Exemple de résultat :

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

Ouvrez votre site JIRA et créez une tâche JIRA avec la description suivante:

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.

Lorsque vous ouvrez la tâche, le bouton devai-jira-ui-qwiklabs s'affiche.

Cliquez sur le bouton et examinez les modifications dans l'UI.

Afficher les journaux du backend de Forge

forge logs

Console de développement Atlassian

Vous pouvez également afficher et gérer les applications déployées dans la console de développement Atlassian.

Examiner les journaux : passez à l'environnement Development.

Examiner le fichier manifeste et le code source de l'application Forge

Ouvrez le fichier "devai-jira-ui-qwiklabs/manifest.yml" et utilisez Gemini Code Assist pour l'expliquer.

Consultez l'explication.

Ouvrez les fichiers suivants et demandez à Gemini Code Assist de vous les expliquer:

devai-jira-ui-qwiklabs/src/frontend/index.jsx
devai-jira-ui-qwiklabs/src/resolvers/index.js

Mettre à jour l'application Forge avec le point de terminaison Cloud Run de l'API DevAI

Vérifiez si l'ID de projet GCP est défini:

gcloud config get project

Si ce n'est pas le cas, définissez votre projet GCP à l'aide de l'ID de projet figurant sur la page de l'atelier Qwiklabs:

Exemple : qwiklabs-gcp-00-2c10937585bb

gcloud config set project YOUR_QWIKLABS_PROJECT_ID

Définissez l'URL du service 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

Vérifiez en exécutant la commande ci-dessous:

forge variables list

Exemple de résultat

Mettre à jour le code et le fichier manifeste de l'application Forge

Ces extraits de code se trouvent dans le dépôt, dans le dossier sample-devai-jira-ui.

Ouvrez le fichier manifeste dans l'éditeur: devai-jira-ui-qwiklabs/manifest.yml

Ajoutez les lignes ci-dessous à la fin du fichier. Remplacez le point de terminaison Cloud Run par celui que vous avez déployé.

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

Ouvrez le fichier resolvers/index dans l'éditeur: devai-jira-ui-qwiklabs/src/resolvers/index.js

Ajoutez des lignes ci-dessous après la fonction getText existante.

resolver.define('getApiKey', (req) => {
  return process.env.LLM_API_KEY;
});

resolver.define('getDevAIApiUrl', (req) => {
  return process.env.DEVAI_API_URL;
});

Ouvrez le fichier frontend/index dans l'éditeur: devai-jira-ui-qwiklabs/src/frontend/index.jsx

Remplacez index.jsx par le contenu ci-dessous. Mettez à jour le lien vers votre ID utilisateur/dépôt GitLab.

Vous devez mettre à jour YOUR-GIT-USERID et YOUR-GIT-REPO à deux endroits.

Recherchez cette ligne dans le fichier et apportez les modifications suivantes:

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>
);

Redéployer l'application Forge

Ajoutez des dépendances dans le fichier package.json:

"@forge/api": "4.0.0",

Installez les dépendances :

npm install

Déployez l'application mise à jour:

forge deploy

Exemple de résultat :

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

Installer l'application mise à jour:

forge install --upgrade

Exemple de résultat :

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.

Tester l'application Forge

Ouvrez une tâche JIRA existante ou créez-en une dans votre projet JIRA.

Vous devrez supprimer le panneau précédent s'il a déjà été ajouté.

Cliquez sur ..., puis sélectionnez "Supprimer" dans le menu. Vous pouvez ensuite cliquer à nouveau sur le bouton.

Consulter les commentaires Jira

Une fois que vous aurez reçu une réponse de l'API DEVAI, deux commentaires seront ajoutés au problème JIRA.

Demande de fusion GitLab
Détails de l'implémentation de l'histoire d'utilisateur Gemini

Basculez entre les onglets "History" et "Comments" pour actualiser la vue.

Activer la création de demandes de fusion GitLab

Ouvrez le fichier devai-api/app/routes.py et annulez la mise en commentaire des lignes ci-dessous dans la méthode 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)

Redéployer l'application Cloud Run

Vérifiez que vous êtes dans le bon dossier.

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

Si vous utilisez la même session de terminal, il est possible que toutes les variables d'environnement soient toujours définies.

Vérifiez-le en exécutant "echo $GITLAB_REPOSITORY" dans le terminal.

Suivez cette procédure pour les réinitialiser si une nouvelle session de terminal a été ouverte.

Veillez à réinitialiser les variables d'environnement requises avant de redéployer l'application.

Cette commande vous oblige à mettre à jour votre ID utilisateur et le nom de votre dépôt GitLab.

export GITLAB_REPOSITORY="USERID/REPOSITORY"

Définissez le reste des variables d'environnement:

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

La boîte à outils GitLab utilisera la branche "devai" pour envoyer les modifications de la requête de fusion.

Vérifiez que vous avez déjà créé cette branche.

Déployez l'application sur 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

Vérifier l'intégration de bout en bout

Lancez le processus à partir de la tâche JIRA en cliquant à nouveau sur le bouton, puis vérifiez la sortie dans le dépôt GitLab, sous la section "Demande de fusion" et LangSmith.

Détails de la demande de fusion GitLab.

Traces du LLM LangSmith

Ouvrez le portail LangSmith et examinez la trace LLM pour l'appel de création de problème JIRA.

Exemple de trace LLM LangSmith.

(SECTION FACULTATIVE) Transférer vos modifications vers le dépôt GitHub

Accédez au site Web GitHub et créez un dépôt pour transférer les modifications de cet atelier vers votre dépôt personnel.

Revenez à l'instance Cloud Workstations et définissez le nom d'utilisateur et l'adresse e-mail Git dans le terminal.

Mettez à jour les valeurs avant d'exécuter les commandes.

git config --global user.name "Your Name"
git config --global user.email "your_email@example.com"

Générez une clé SSH et ajoutez-la au dépôt GitHub.

Modifiez votre adresse e-mail avant d'exécuter les commandes.

Ne saisissez pas de phrase secrète et n'appuyez pas plusieurs fois sur Entrée pour générer une clé.

ssh-keygen -t ed25519 -C "your-email-address"

eval "$(ssh-agent -s)"

ssh-add ~/.ssh/id_ed25519

cat ~/.ssh/id_ed25519.pub

Ajoutez la clé publique générée à votre compte GitHub.

Ouvrez https://github.com/settings/keys, puis cliquez sur New SSH key.

Pour le nom de la clé, utilisez "qwiklabs-key", puis copiez/collez la sortie de la dernière commande.

Revenez au terminal, effectuez un commit et transférez les modifications.

cd ~/github/genai-for-developers

git remote rm origin

Définissez l'origine distante à l'aide du dépôt créé ci-dessus.

Remplacez-la par l'URL de votre dépôt.

git remote add origin git@github.com:YOUR-GITHUB-USERID/YOUR-GITHUB-REPO.git

Ajoutez, validez et transférez les modifications.

git add .

git commit -m "lab changes"

git push -u origin main

15. Félicitations !

Félicitations, vous avez terminé l'atelier.

Points abordés

Déployer des applications Cloud Run pour les intégrer aux API Gemini
Créer et déployer une application Atlassian Forge pour JIRA
Utiliser les agents ReAct de LangChain pour automatiser les tâches GitLab
Examiner les traces de LLM dans LangSmith

Étapes suivantes :

D'autres sessions pratiques seront bientôt disponibles.

Effectuer un nettoyage

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez chaque ressource individuellement.

Supprimer le projet

Le moyen le plus simple d'empêcher la facturation est de supprimer le projet que vous avez créé pour ce tutoriel.

© 2024 Google LLC Tous droits réservés. Google et le logo Google sont des marques de Google LLC. Tous les autres noms de société et de produit peuvent être des marques des sociétés auxquelles ils sont associés.