À propos de cet atelier de programmation
1. Présentation
Dans cet atelier, vous allez créer une solution permettant d'automatiser l'implémentation des histoires d'utilisateurs 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
- Utiliser les agents ReAct de LangChain pour automatiser les 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 Gemini pour Google Cloud:
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.
3. Options pour tester les requêtes
Vous pouvez tester les requêtes de plusieurs façons.
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 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. Examiner la demande
Créer un compte de service
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.
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"
Attribuez des rôles.
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 vous êtes invité à autoriser l'accès, 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
Cloner le dépôt GitHub
Clonez le dépôt GitHub.
git clone https://github.com/GoogleCloudPlatform/genai-for-developers.git
Ouvrir l'éditeur Cloud Shell
À l'aide de l'élément de menu "File / Open Folder", ouvrez "genai-for-developers".
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é.
5. Configuration du dépôt et du kit d'outils GitLab
Dans cet atelier, vous allez utiliser GitLabToolkit pour automatiser la création de requêtes de fusion GitLab.
Présentation des 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 d'API, de bases de données et d'autres sources externes, puis 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.
Présentation du kit d'outils 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.
- Create Pull Request (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.
Configuration du projet GitLab
Ouvrez GitLab, créez un projet 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 des 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.
6. Préparer le déploiement d'une application sur Cloud Run
Revenez à l'éditeur Cloud Shell et utilisez un terminal existant ou ouvrez-en un nouveau.
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 GITLAB_PERSONAL_ACCESS_TOKEN. 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. Vous devez également exporter la variable d'environnement: export GITLAB_PERSONAL_ACCESS_TOKEN
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"
Configuration du traçage LLM LangSmith
Configurez le compte si vous souhaitez afficher des informations de traçage de l'agent dans LangSmith, sinon exécutez les commandes telles quelles.
Créez un compte LangSmith et générez une clé API de service dans la section "Paramètres". https://smith.langchain.com/settings
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
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
Créer une clé API
Créez une clé API dans la section Cloud Console / API et services / Identifiants.
Cette clé servira à authentifier les appels d'API JIRA à l'application Cloud Run.
Pour l'environnement de production, vous devez configurer des restrictions d'application et d'API pour la clé API créée. Les restrictions liées aux applications limitent l'utilisation d'une clé API à des sites Web spécifiques(par exemple, votre instance JIRA).
Définissez les variables d'environnement requises pour le déploiement du service Cloud Run.
export DEVAI_API_KEY=your-api-key
Créer des secrets dans Secret Manager
Pour cet atelier, nous suivons les bonnes pratiques et utilisons Secret Manager pour stocker et référencer les valeurs des jetons d'accès, de la clé API et de la clé API LangChain dans Cloud Run.
Créez et stockez les secrets requis dans 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. Déployer Devai-API sur Cloud Run
Vérifiez que vous êtes dans le bon dossier.
cd ~/genai-for-developers/devai-api
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" \
--update-secrets="DEVAI_API_KEY=DEVAI_API_KEY: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.
Consultez les détails de l'instance Cloud Run dans la console Cloud.
Tester l'application
Testez le point de terminaison en exécutant la commande curl.
Remplacez-la par l'URL de votre service Cloud Run avant d'exécuter la commande.
Exemple :
curl -H "X-devai-api-key: $DEVAI_API_KEY" https://devai-api-1110000001.us-central1.run.app/test
8. Automatiser l'implémentation des histoires
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
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.
Créer un 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.
Configurer les paramètres de l'environnement Forge
Revenez dans la console Cloud et exécutez les commandes ci-dessous dans le terminal.
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 "~/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 pour installer les dépendances.
npm install
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'interface utilisateur.
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 expliquer la configuration.
Consultez l'explication.
Ouvrez les fichiers suivants et demandez à Gemini Code Assist de vous les expliquer:
devai-jira-ui-qwiklabs/src/frontend/index.jsxdevai-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
Définir la clé API DEVAI:
export DEVAI_API_KEY=api-key-that-you-created
forge variables set --encrypt DEVAI_API_KEY $DEVAI_API_KEY
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/create-gitlab-mr # 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.DEVAI_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 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>
);
Redéployer l'application Forge
Ajoutez des dépendances dans le fichier package.json:
"@forge/api": "4.0.0",
Exécutez la commande pour installer 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 avez reçu une réponse de l'API DEVAI, un commentaire est ajouté au problème JIRA.
- Lien de la demande de fusion GitLab
Basculez entre les onglets "History" et "Comments" pour actualiser la vue.
Vérifier la demande de fusion GitLab
Ouvrez GitLab et recherchez de nouvelles requêtes de fusion dans votre projet.
Traces du LLM LangSmith
Si vous avez configuré le traçage LLM, ouvrez le portail LangSmith et examinez la trace LLM pour l'appel de création de la requête de fusion GitLab.
Exemple de trace LLM LangSmith.
9. Transférer vos modifications vers le dépôt GitHub
(SECTION FACULTATIF)
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 à la console Cloud 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 ~/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
10. 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.