1. Présentation
Dans cet atelier, vous allez créer une solution pour automatiser l'implémentation des user stories 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 LangChain ReAct 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 $.
Configuration de l'environnement
Ouvrez le chat Gemini.
Vous pouvez également saisir "Demander à Gemini" dans la barre de recherche.
Activez l'API Gemini for Google Cloud :
Cliquez sur "Start chatting", puis suivez l'une des questions exemples ou saisissez votre propre requête pour l'essayer.
Prompts à tester :
- Explique 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 senior quand utiliser Cloud Run plutôt que GKE en cinq points clés.
Consultez le guide des requêtes pour découvrir comment rédiger des requêtes plus efficaces.
Utilisation de vos données par Gemini pour Google Cloud
Engagement de Google concernant la confidentialité
Google a été l'un des premiers acteurs du secteur à publier un engagement concernant la confidentialité de l'IA/du ML, affirmant ainsi que ses clients doivent bénéficier 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 complétions 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 prompts
Lorsque vous envoyez des requêtes à Gemini, vos données sont chiffrées en transit, c'est-à-dire pendant le transfert vers le 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 ainsi que sur du code tiers sélectionné. Vous êtes responsable de la sécurité, des tests et de l'efficacité de votre code, y compris pour les éléments générés à l'aide des fonctionnalités de complétion, de génération ou d'analyse de code proposées par Gemini.
En savoir plus sur la façon dont Google traite vos requêtes
3. Options pour tester les requêtes
Vous disposez de plusieurs options pour tester les requêtes.
Vertex AI Studio fait partie de la plate-forme Vertex AI de Google Cloud. Il est spécialement conçu 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 qui permet de prototyper et de tester le prompt engineering 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 à droite de la barre de recherche.
Dans le terminal qui s'ouvre, 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 vers l'API Vertex AI Gemini depuis l'application Cloud Run.
Configurez les détails du 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é à donner votre autorisation, 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 pour le fichier sélectionné.
5. Configuration du dépôt et de la boîte à outils GitLab
Dans cet atelier, vous allez utiliser GitLabToolkit pour automatiser la création de demandes de fusion GitLab.
Présentation des toolkits LangChain
Les toolkits LangChain sont des ensembles d'outils conçus pour simplifier et améliorer le développement d'applications avec LangChain. Ils offrent diverses fonctionnalités selon 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 intégrez-les à vos applications LangChain.
- Techniques avancées de création de requêtes : 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 exemples de kits d'outils LangChain populaires :
- Kits d'outils Agent Executor : outils permettant de développer des agents capables d'interagir avec le monde réel grâce à des actions telles que la navigation sur le Web ou l'exécution de code.
- Boîte à outils d'ingénierie des requêtes : collection de ressources pour créer des requêtes efficaces.
Présentation de GitLab Toolkit
La boîte à outils Gitlab contient des outils qui permettent à un agent LLM d'interagir avec un dépôt Gitlab. Cet outil est un wrapper pour la bibliothèque python-gitlab.
Le kit d'outils GitLab peut effectuer les tâches suivantes :
- Créer un fichier : crée un fichier dans le dépôt.
- Lire le fichier : lit un fichier à partir du dépôt.
- Update File (Mettre à jour le fichier) : met à jour un fichier dans le 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 Issues : récupère les problèmes du dépôt.
- Get Issue (Obtenir le problème) : récupère les détails d'un problème spécifique.
- Comment on Issue (Commenter un problème) : publie un commentaire sur un problème spécifique.
- Supprimer un fichier : supprime un fichier du dépôt.
Configurer un projet GitLab
Ouvrez GitLab, créez un projet, puis configurez un 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 niveaux d'accès :
api
Copiez et collez la valeur du jeton d'accès dans un fichier temporaire sur votre ordinateur portable. Vous en aurez besoin lors des prochaines étapes.
6. Préparer le déploiement de l'application sur Cloud Run
Revenez à l'éditeur Cloud Shell et utilisez un terminal existant ou ouvrez-en un nouveau.
Configurez les détails du projet à l'aide des informations de votre projet Qwiklabs.
Exemple : qwiklabs-gcp-00-2c10937585bb
gcloud config set project YOUR-QWIKLABS-PROJECT-ID
Définissez les autres 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 de GitLab.
export GITLAB_PERSONAL_ACCESS_TOKEN=gitlab-token
Pour éviter d'exposer 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 n'apparaisse 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 devrez également exporter la variable d'environnement : export GITLAB_PERSONAL_ACCESS_TOKEN
Cette commande vous oblige à mettre à jour votre ID utilisateur GitLab et le nom du dépôt.
Exemple : export GITLAB_REPOSITORY="gitrey/qwiklabs-test"
export GITLAB_REPOSITORY="USERID/REPOSITORY"
Définissez les autres 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 "Settings" (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 de JIRA
Ces valeurs ne sont pas utilisées dans cet atelier. Vous n'avez donc pas besoin de les remplacer par les valeurs spécifiques à votre projet JIRA 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é sera utilisée pour authentifier les appels à l'API JIRA vers 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 du code source sans avoir à installer Docker sur votre machine ni configurer des buildpacks 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 fichier 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.
Consultez les journaux Cloud Build dans la console.
Vérifiez l'image Docker créée dans Artifact Registry.
Consultez les détails des instances Cloud Run dans la console Cloud.
Tester l'application
Testez le point de terminaison en exécutant la commande curl.
Mettez à jour 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 la commande suivante :
npm install -g @forge/cli
Pour cet atelier, nous utiliserons des variables d'environnement pour nous connecter.
Configurer un projet JIRA
Utilisez votre compte personnel pour créer/afficher des projets JIRA.
Examinez vos projets JIRA existants : https://admin.atlassian.com/.
Créez un projet JIRA avec votre compte personnel.
Accédez à https://team.atlassian.com/your-work, puis cliquez sur 
et sélectionnez 
. Sélectionnez ensuite "JIRA Software" > "Try it now" (Essayer maintenant). Suivez les instructions pour créer un projet ou un 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 lorsque vous exécutez des commandes.
- Accédez à https://id.atlassian.com/manage/api-tokens.
- Cliquez sur Create API token (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 à la console Cloud et exécutez les commandes ci-dessous dans le terminal.
Connectez-vous à la CLI Forge pour commencer à utiliser les commandes Forge.
Définissez votre adresse e-mail JIRA/FORGE. Remplacez par votre adresse e-mail.
export FORGE_EMAIL=your-email
Définissez le jeton d'API Forge. Remplacez par votre jeton d'API JIRA.
export FORGE_API_TOKEN=your-jira-api-token
Testez l'interface de ligne de commande 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
Utilisez les valeurs suivantes lorsque vous y êtes invité :
- 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.
Installer l'application.
forge install
Utilisez les valeurs suivantes lorsque vous y êtes invité :
- 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 apportées à l'UI.
Affichez les journaux du backend Forge.
forge logs
Console Atlassian pour les développeurs
Vous pouvez également afficher et gérer les applications déployées dans la console Atlassian pour les développeurs.
Consultez 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 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 de 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éfinissez la clé API DEVAI :
export DEVAI_API_KEY=api-key-that-you-created
forge variables set --encrypt DEVAI_API_KEY $DEVAI_API_KEY
Confirmez en exécutant la commande ci-dessous :
forge variables list
Exemple de sortie
Mettre à jour le fichier manifeste et le code 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 les 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 modifiée :
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.
Installez 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.
Si vous l'avez déjà ajouté, vous devrez supprimer le panneau précédent.
Cliquez sur ..., puis sélectionnez "Supprimer" dans le menu. Vous pourrez 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 vers 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 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 demande de fusion GitLab.
Exemple de trace LLM LangSmith.
9. Transférer vos modifications vers le dépôt GitHub
(SECTION FACULTATIVE)
Accédez au site Web GitHub et créez un dépôt pour transférer les modifications apportées à 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.
Mettez à jour votre adresse e-mail avant d'exécuter les commandes.
Ne saisissez pas de phrase secrète et appuyez plusieurs fois sur Entrée pour générer la 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" et copiez/collez le résultat de la dernière commande.
Revenez au terminal, validez 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 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
- Découvrez comment créer et déployer une application Atlassian Forge pour JIRA.
- Découvrez comment utiliser les agents LangChain ReAct pour automatiser les tâches GitLab.
- Découvrez comment examiner les traces 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.