Implementazione delle storie utente di JIRA con l'IA generativa

1. Panoramica

In questo lab creerai una soluzione per automatizzare l'implementazione delle storie utente di JIRA con l'AI generativa.

Cosa imparerai a fare

Il laboratorio è composto da diverse parti principali:

Esegui il deployment dell'applicazione Cloud Run per l'integrazione con le API Gemini
Crea ed esegui il deployment dell'app Atlassian Forge per JIRA
Utilizzare gli agenti LangChain ReAct per l'automazione delle attività di GitLab

Prerequisiti

Questo lab presuppone la familiarità con gli ambienti della console Cloud e di Cloud Shell.

2. Configurazione e requisiti

Configurazione del progetto Cloud

Accedi alla console Google Cloud e crea un nuovo progetto o riutilizzane uno esistente. Se non hai ancora un account Gmail o Google Workspace, devi crearne uno.

Il nome del progetto è il nome visualizzato per i partecipanti a questo progetto. È una stringa di caratteri non utilizzata dalle API di Google. Puoi sempre aggiornarlo.
L'ID progetto è univoco in tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo l'impostazione). La console Cloud genera automaticamente una stringa univoca, di solito non ti interessa di cosa si tratta. Nella maggior parte dei codelab, dovrai fare riferimento all'ID progetto (in genere identificato come PROJECT_ID). Se l'ID generato non ti piace, puoi generarne un altro casuale. In alternativa, puoi provare a crearne uno e vedere se è disponibile. Non può essere modificato dopo questo passaggio e rimane per tutta la durata del progetto.
Per tua informazione, esiste un terzo valore, un numero di progetto, utilizzato da alcune API. Scopri di più su tutti e tre questi valori nella documentazione.

Successivamente, devi abilitare la fatturazione in Cloud Console per utilizzare le risorse/API Cloud. Completare questo codelab non costa molto, se non nulla. Per arrestare le risorse ed evitare addebiti oltre a quelli previsti in questo tutorial, puoi eliminare le risorse che hai creato o il progetto. I nuovi utenti di Google Cloud possono beneficiare del programma prova senza costi di 300$.

Configurazione dell'ambiente

Apri la chat con Gemini.

In alternativa, digita "Chiedi a Gemini" nella barra di ricerca.

Abilita l'API Gemini for Google Cloud:

Fai clic su "Start chatting" e segui una delle domande di esempio o digita il tuo prompt per provarlo.

Prompt da provare:

Spiega Cloud Run in 5 punti chiave.
Sei il Product Manager di Google Cloud Run, spiega Cloud Run a uno studente in 5 punti chiave brevi.
Sei il Product Manager di Google Cloud Run, spiega Cloud Run a uno sviluppatore Kubernetes certificato in 5 brevi punti chiave.
Sei il Product Manager di Google Cloud Run. Spiega a un Senior Developer quando utilizzare Cloud Run anziché GKE in 5 brevi punti chiave.

Consulta la guida ai prompt per scoprire di più su come scrivere prompt migliori.

Come Gemini per Google Cloud usa i tuoi dati

L'impegno di Google per la privacy

Google è stata una delle prime aziende del settore a pubblicare un impegno in materia di privacy AI/ML, che delinea la nostra convinzione che i clienti debbano disporre del massimo livello di sicurezza e controllo sui propri dati archiviati nel cloud.

Dati che invii e ricevi

Le domande che poni a Gemini, incluse le informazioni o il codice che invii a Gemini per l'analisi o il completamento, sono chiamate prompt. Le risposte o i completamenti del codice che ricevi da Gemini sono chiamati risposte. Gemini non utilizza i tuoi prompt o le relative risposte come dati per addestrare i propri modelli.

Crittografia dei prompt

Quando invii prompt a Gemini, i tuoi dati vengono criptati in transito come input per il modello sottostante in Gemini.

Dati del programma generati da Gemini

Gemini è addestrato sul codice Google Cloud proprietario e su codice di terze parti selezionato. Sei responsabile della sicurezza, del test e dell'efficacia del tuo codice, inclusi il completamento, la generazione o l'analisi del codice che Gemini ti offre.

Scopri di più su come Google gestisce i tuoi prompt.

3. Opzioni per testare i prompt

Hai diverse opzioni per testare i prompt.

Vertex AI Studio

Vertex AI Studio fa parte della piattaforma Vertex AI di Google Cloud, progettata specificamente per semplificare e accelerare lo sviluppo e l'utilizzo di modelli di AI generativa.

Google AI Studio

Google AI Studio è uno strumento basato sul web per la prototipazione e la sperimentazione con l'ingegneria dei prompt e l'API Gemini.

App web Gemini (gemini.google.com)

L'app web Gemini di Google (gemini.google.com) è uno strumento basato sul web progettato per aiutarti a esplorare e utilizzare la potenza dei modelli di AI Gemini di Google.

App mobile Gemini per Android e app Google su iOS

4. Esamina la richiesta

Crea service account

Torna alla console Google Cloud e attiva Cloud Shell facendo clic sull'icona a destra della barra di ricerca.

Nel terminale aperto, esegui i seguenti comandi per creare un nuovo service account e le relative chiavi.

Utilizzerai questo service account per effettuare chiamate API all'API Vertex AI Gemini dall'applicazione Cloud Run.

Configura i dettagli del progetto utilizzando i dettagli del progetto Qwiklabs.

Esempio: qwiklabs-gcp-00-2c10937585bb

gcloud config set project YOUR_QWIKLABS_PROJECT_ID

Crea un account di servizio.

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"

Concedi i ruoli.

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"

Se ti viene richiesto di concedere l'autorizzazione, fai clic su "Autorizza" per continuare.

Abilita i servizi richiesti per utilizzare le API Vertex AI e la chat con Gemini.

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

Abilita i servizi richiesti per utilizzare le API Vertex AI e la chat con Gemini.

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

Clona il repository GitHub

Clona il repository GitHub.

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

Apri editor di Cloud Shell

Utilizzando la voce di menu "File / Open Folder", apri "genai-for-developers".

Apri il file "devai-api/app/routes.py", fai clic con il tasto destro del mouse in un punto qualsiasi del file e seleziona "Gemini > Explain this"" dal menu contestuale.

Esamina la spiegazione di Gemini per il file selezionato.

5. Configurazione del repository e del toolkit GitLab

In questo lab utilizzerai GitLabToolkit per automatizzare la creazione di richieste di unione GitLab.

Panoramica dei toolkit LangChain

I toolkit LangChain sono insiemi di strumenti progettati per semplificare e migliorare lo sviluppo di applicazioni con LangChain. Offrono varie funzionalità a seconda del toolkit specifico, ma in genere aiutano a:

Connessione a origini dati esterne: accedi e incorpora informazioni da API, database e altre origini esterne nelle tue applicazioni LangChain.
Tecniche avanzate di prompt: utilizza prompt predefiniti o creane di personalizzati per ottimizzare le interazioni con i modelli linguistici.
Creazione e gestione di catene: crea catene complesse con facilità e gestiscile in modo efficiente.
Valutazione e monitoraggio: analizza il rendimento delle tue applicazioni e catene LangChain.

Alcuni toolkit LangChain popolari includono:

Agent Executor Toolkits: strumenti per sviluppare agenti in grado di interagire con il mondo reale tramite azioni come la navigazione web o l'esecuzione di codice.
Toolkit di prompt engineering: una raccolta di risorse per creare prompt efficaci.

Panoramica di GitLab Toolkit

Il toolkit Gitlab contiene strumenti che consentono a un agente LLM di interagire con un repository Gitlab. Lo strumento è un wrapper per la libreria python-gitlab.

Il toolkit GitLab può eseguire le seguenti attività:

Crea file: crea un nuovo file nel repository.
Read File (Leggi file): legge un file dal repository.
Aggiorna file: aggiorna un file nel repository.
Crea richiesta di pull: crea una richiesta di pull dal ramo di lavoro del bot al ramo di base.
Get Issues (Ottieni problemi): recupera i problemi dal repository.
Get Issue: recupera i dettagli di un problema specifico.
Comment on Issue (Commenta problema) - pubblica un commento su un problema specifico.
Elimina file: elimina un file dal repository.

Configurazione del progetto GitLab

Apri GitLab, crea un nuovo progetto e configura il token di accesso al progetto nella sezione "Settings / Access Tokens".

Utilizza i seguenti dettagli:

Nome token: devai-api-qwiklabs
Ruolo: Maintainer
Seleziona ambiti: api

Copia e incolla il valore del token di accesso in un file temporaneo sul laptop. Lo userai nei passaggi successivi.

6. Preparati a eseguire il deployment dell'applicazione su Cloud Run

Torna all'editor di Cloud Shell e utilizza un terminale esistente o aprine uno nuovo.

Configura i dettagli del progetto utilizzando i dettagli del progetto Qwiklabs.

Esempio: qwiklabs-gcp-00-2c10937585bb

gcloud config set project YOUR-QWIKLABS-PROJECT-ID

Imposta le altre variabili di ambiente:

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

Imposta le variabili di ambiente richieste per l'integrazione di GitLab.

export GITLAB_PERSONAL_ACCESS_TOKEN=gitlab-token

Per evitare di esporre informazioni sensibili nel terminale, la best practice consiste nell'utilizzare read -s GITLAB_PERSONAL_ACCESS_TOKEN. Questo è un modo sicuro per impostare le variabili di ambiente senza che il valore venga visualizzato nella cronologia dei comandi della console. Dopo averlo eseguito, devi incollare il valore e premere Invio. Dovrai esportare anche la variabile di ambiente: export GITLAB_PERSONAL_ACCESS_TOKEN

Questo comando richiede l'aggiornamento dell'ID utente GitLab e del nome del repository.

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

export GITLAB_REPOSITORY="USERID/REPOSITORY"

Imposta le altre variabili di ambiente:

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

Configurazione del tracciamento LLM di LangSmith

Configura l'account se vuoi visualizzare le informazioni di tracciamento dell'agente in LangSmith, altrimenti esegui i comandi così come sono.

Crea un account LangSmith e genera una chiave API del servizio nella sezione Impostazioni. https://smith.langchain.com/settings

Imposta le variabili di ambiente richieste per l'integrazione di LangSmith.

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

export LANGCHAIN_API_KEY=langchain-service-api-key

Configurazione JIRA

Questi valori non vengono utilizzati in questo lab, quindi non devi aggiornarli con i valori specifici del tuo progetto JIRA prima di eseguire i comandi.

Imposta le variabili di ambiente richieste per il deployment del servizio 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

Crea chiave API

Crea una nuova chiave API nella sezione Cloud Console / API e servizi / Credenziali.

Questa chiave verrà utilizzata per autenticare le chiamate API JIRA all'applicazione Cloud Run.

Per l'ambiente di produzione, devi configurare le limitazioni delle applicazioni e delle API per la chiave API creata. Le limitazioni delle applicazioni limitano l'utilizzo di una chiave API a siti web specifici(ad es. la tua istanza JIRA).

Imposta le variabili di ambiente richieste per il deployment del servizio Cloud Run.

export DEVAI_API_KEY=your-api-key

Crea secret in Secret Manager

Per questo lab, seguiamo le best practice e utilizziamo Secret Manager per archiviare e fare riferimento ai valori di token di accesso, chiave API e chiave API LangChain in Cloud Run.

Crea e archivia i secret richiesti in 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. Esegui il deployment di Devai-API su Cloud Run

Verifica di trovarti nella cartella giusta.

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

Esegui il deployment dell'applicazione in 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

Rispondi Y per creare il repository Docker di 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

Esamina il flusso gcloud run deploy SERVICE_NAME --source=. di seguito. Scopri di più.

Dietro le quinte, questo comando utilizza buildpacks e Cloud Build di Google Cloud per creare automaticamente immagini container dal codice sorgente senza dover installare Docker sulla tua macchina o configurare buildpack o Cloud Build. ovvero il singolo comando descritto sopra fa ciò che altrimenti richiederebbe i comandi gcloud builds submit e gcloud run deploy.

Se hai fornito Dockerfile(come abbiamo fatto in questo repository), Cloud Build lo utilizzerà per creare immagini container anziché affidarsi ai buildpack per rilevare e creare automaticamente immagini container. Per scoprire di più sui buildpack, consulta la documentazione.

Esamina i log di Cloud Build nella console.

Esamina l'immagine Docker creata in Artifact Registry.

Esamina i dettagli dell'istanza Cloud Run in Cloud Console.

Test dell'applicazione

Testa l'endpoint eseguendo il comando curl.

Aggiorna con l'URL del servizio Cloud Run prima di eseguire il comando.

Esempio:

curl -H "X-devai-api-key: $DEVAI_API_KEY" https://devai-api-1110000001.us-central1.run.app/test

8. Automatizzare l'implementazione delle storie

Forge è una piattaforma che consente agli sviluppatori di creare app che si integrano con i prodotti Atlassian, come Jira, Confluence, Compass e Bitbucket.

Installa Forge CLI

Installa Forge CLI a livello globale eseguendo:

npm install -g @forge/cli

Per questo lab, utilizzeremo le variabili di ambiente per accedere.

Configura il progetto JIRA

Utilizza il tuo account personale per creare/visualizzare progetti JIRA.

Esamina i progetti JIRA esistenti: https://admin.atlassian.com/

Crea un nuovo progetto JIRA utilizzando il tuo account personale.

Vai a https://team.atlassian.com/your-work e fai clic su , quindi seleziona . Dopodiché, seleziona "JIRA Software" - "Prova ora". Segui le istruzioni per completare la creazione del progetto/sito.

Seleziona JIRA Software.

Crea un nuovo progetto.

Crea token API Atlassian

Crea o utilizza un token API Atlassian esistente per accedere alla CLI.

La CLI utilizza il token quando esegui i comandi.

Vai alla pagina https://id.atlassian.com/manage/api-tokens.
Fai clic su Genera token API.
Inserisci un'etichetta per descrivere il token API. Ad esempio, forge-api-token.
Fai clic su Crea.
Fai clic su Copia negli appunti e chiudi la finestra di dialogo.

Configura le impostazioni dell'ambiente Forge

Torna a Cloud Console ed esegui i comandi riportati di seguito nel terminale.

Accedi a Forge CLI per iniziare a utilizzare i comandi Forge.

Imposta il tuo indirizzo email JIRA/FORGE. Sostituisci con il tuo indirizzo email.

export FORGE_EMAIL=your-email

Imposta il token API di Forge. Sostituisci con il token API JIRA.

export FORGE_API_TOKEN=your-jira-api-token

Testa forge cli eseguendo il comando riportato di seguito. Rispondi "No" quando ti viene chiesto di raccogliere dati e analisi.

forge settings set usage-analytics false

Verifica di aver eseguito l'accesso.

forge whoami

Output di esempio.

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

Crea applicazione Forge

Verifica di trovarti nella cartella "~/genai-for-developers".

Esegui il comando per creare un'applicazione Forge.

forge create

Utilizza i seguenti valori quando richiesto:

Nome app: devai-jira-ui-qwiklabs
Seleziona una categoria: UI Kit
Seleziona un prodotto: Jira
Seleziona un modello: jira-issue-panel

Passa alla cartella dell'applicazione.

cd devai-jira-ui-qwiklabs/

Esegui il comando per installare le dipendenze.

npm install

Esegui il comando di deployment.

forge deploy

Esempio di output:

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.

Installa l'applicazione.

forge install

Utilizza i seguenti valori quando richiesto:

Seleziona un prodotto: Jira
Inserisci l'URL del sito: your-domain.atlassian.net

Esempio di output:

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

Apri il tuo sito JIRA e crea una nuova attività JIRA con la seguente descrizione:

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.

Quando apri l'attività, vedrai il pulsante "devai-jira-ui-qwiklabs".

Fai clic sul pulsante e rivedi le modifiche nell'interfaccia utente.

Visualizza i log del backend di Forge.

forge logs

Atlassian Developer Console

Puoi anche visualizzare e gestire le app di cui è stato eseguito il deployment nella Atlassian Developer Console.

Esamina i log: passa all'ambiente Development.

Esamina il manifest e il codice sorgente dell'applicazione Forge

Apri il file "devai-jira-ui-qwiklabs/manifest.yml" e utilizza Gemini Code Assist per spiegare la configurazione.

Esamina la spiegazione.

Apri i seguenti file e chiedi a Gemini Code Assist di spiegarli:

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

Aggiorna l'app Forge con l'endpoint Cloud Run dell'API DevAI

Verifica se è impostato GCP PROJECT ID:

gcloud config get project

In caso contrario, imposta il progetto GCP utilizzando l'ID progetto della pagina del lab Qwiklabs:

Esempio: qwiklabs-gcp-00-2c10937585bb

gcloud config set project YOUR_QWIKLABS_PROJECT_ID

Imposta l'URL del servizio 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

Imposta la chiave API DEVAI:

export DEVAI_API_KEY=api-key-that-you-created

forge variables set --encrypt DEVAI_API_KEY $DEVAI_API_KEY

Conferma eseguendo il comando riportato di seguito:

forge variables list

Esempio di output

Aggiorna il codice e il file manifest dell'applicazione Forge

Questi snippet di codice sono disponibili nel repository nella cartella sample-devai-jira-ui.

Apri il file manifest nell'editor: devai-jira-ui-qwiklabs/manifest.yml

Aggiungi le righe seguenti alla fine del file. Sostituisci l'endpoint Cloud Run con quello che hai deployment.

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

Apri il file di resolver/indice nell'editor: devai-jira-ui-qwiklabs/src/resolvers/index.js

Aggiungi le righe riportate di seguito dopo la funzione getText esistente.

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

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

Apri il file frontend/index nell'editor: devai-jira-ui-qwiklabs/src/frontend/index.jsx

Sostituisci index.jsx con i contenuti riportati di seguito. Aggiorna il link al tuo ID utente/repository GitLab.

Esistono due posizioni in cui devi aggiornare YOUR-GIT-USERID e YOUR-GIT-REPO.

Cerca questa riga nel file e apporta le modifiche:

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

Esegui nuovamente il deployment dell'applicazione Forge

Aggiungi dipendenze nel file package.json:

"@forge/api": "4.0.0",

Esegui il comando per installare le dipendenze:

npm install

Esegui il deployment dell'applicazione aggiornata:

forge deploy

Esempio di output:

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

Installa l'applicazione aggiornata:

forge install --upgrade

Esempio di output:

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.

Testa l'applicazione Forge

Apri un'attività JIRA esistente o creane una nuova nel tuo progetto JIRA.

Se è già stato aggiunto, dovrai rimuovere il pannello precedente.

Fai clic su "..." e seleziona Rimuovi dal menu. Dopodiché, puoi fare di nuovo clic sul pulsante.

Controlla i commenti di Jira

Una volta ricevuta una risposta dall'API DEVAI, verrà aggiunto un commento al problema JIRA.

Link alla richiesta di merge di GitLab

Passa dalla scheda "History" a quella "Comments" per aggiornare la visualizzazione.

Verifica la richiesta di unione di GitLab

Apri GitLab e verifica la presenza di nuove richieste di unione nel tuo progetto.

Tracce LLM di LangSmith

Se hai configurato la tracciabilità LLM, apri il portale LangSmith e controlla la traccia LLM per la chiamata di creazione della richiesta di unione di GitLab.

Traccia LLM di esempio di LangSmith.

9. Esegui il push delle modifiche nel repository GitHub

(OPTIONAL SECTION)

Vai al sito web GitHub e crea un nuovo repository per eseguire il push delle modifiche per questo lab nel tuo repository personale.

Torna alla console Cloud e imposta il nome utente e l'email di Git nel terminale.

Aggiorna i valori prima di eseguire i comandi.

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

Genera la chiave SSH e aggiungila al repository GitHub.

Aggiorna la tua email prima di eseguire i comandi.

Non inserire la passphrase e premere Invio più volte per completare la generazione della chiave.

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

eval "$(ssh-agent -s)"

ssh-add ~/.ssh/id_ed25519

cat ~/.ssh/id_ed25519.pub

Aggiungi la chiave pubblica generata al tuo account GitHub.

Apri https://github.com/settings/keys e fai clic su "New SSH key".

Per il nome della chiave, utilizza "qwiklabs-key" e copia/incolla l'output dell'ultimo comando.

Torna al terminale, esegui il commit e il push delle modifiche.

cd ~/genai-for-developers

git remote rm origin

Imposta l'origine remota utilizzando il repository creato in precedenza.

Sostituiscilo con l'URL del tuo repository.

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

Aggiungi, esegui il commit e il push delle modifiche.

git add .

git commit -m "lab changes"

git push -u origin main

10. Complimenti!

Complimenti, hai completato il lab.

Argomenti trattati:

Come eseguire il deployment delle applicazioni Cloud Run per l'integrazione con le API Gemini.
Come creare ed eseguire il deployment dell'app Atlassian Forge per JIRA.
Come utilizzare gli agenti LangChain ReAct per l'automazione delle attività di GitLab.
Come esaminare le tracce LLM in LangSmith.

Qual è il passaggio successivo?

A breve saranno disponibili altre sessioni pratiche.

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Elimina il progetto

Il modo più semplice per eliminare la fatturazione è eliminare il progetto creato per il tutorial.