Ta strona została przetłumaczona przez Cloud Translation API.

Wdrażanie historii użytkowników Jira za pomocą generatywnej AI

1. Omówienie

W tym laboratorium utworzysz rozwiązanie, które automatyzuje implementację scenariuszy wykorzystania Jira za pomocą generatywnej AI.

Czego się nauczysz

Laboratorium składa się z kilku głównych części:

Wdrażanie aplikacji Cloud Run w celu integracji z interfejsami Gemini API
Tworzenie i wdrażanie aplikacji Atlassian Forge dla Jira
Automatyzacja zadań GitLab za pomocą agentów LangChain ReAct

Wymagania wstępne

Ten moduł zakłada, że znasz środowiska Cloud Console i Cloud Shell.

2. Konfiguracja i wymagania

Konfiguracja projektu Cloud

Zaloguj się w konsoli Google Cloud i utwórz nowy projekt lub użyj istniejącego. Jeśli nie masz jeszcze konta Gmail ani Google Workspace, musisz je utworzyć.

Nazwa projektu to wyświetlana nazwa uczestników tego projektu. Jest to ciąg znaków, którego nie używają interfejsy API Google. Zawsze możesz ją zaktualizować.
Identyfikator projektu jest niepowtarzalny w ramach wszystkich projektów Google Cloud i nie można go zmienić (po ustawieniu). Konsola Cloud automatycznie generuje unikalny ciąg znaków. Zwykle nie ma znaczenia, jaki to ciąg. W większości laboratoriów z kodem musisz podać identyfikator projektu (zwykle oznaczony jako PROJECT_ID). Jeśli nie podoba Ci się wygenerowany identyfikator, możesz wygenerować inny losowy. Możesz też spróbować użyć własnego adresu e-mail, aby sprawdzić, czy jest on dostępny. Nie można go zmienić po wykonaniu tego kroku. Pozostanie on do końca projektu.
Informacyjnie: istnieje jeszcze 3 wartość, numer projektu, której używają niektóre interfejsy API. Więcej informacji o wszystkich 3 wartościach znajdziesz w dokumentacji.

Następnie musisz włączyć rozliczenia w konsoli Cloud, aby korzystać z zasobów i interfejsów API Cloud. Przejście przez ten samouczek nie będzie kosztowne, a być może nawet bezpłatne. Aby wyłączyć zasoby i uniknąć obciążenia opłatami po zakończeniu samouczka, możesz usunąć utworzone zasoby lub usunąć projekt. Nowi użytkownicy Google Cloud mogą skorzystać z bezpłatnego okresu próbnego, w którym mają do dyspozycji środki w wysokości 300 USD.

Konfiguracja środowiska

Otwórz czat Gemini.

Możesz też wpisać „Zapytaj Gemini” na pasku wyszukiwania.

Włącz interfejs Cloud AI Companion API:

Kliknij „Start chatting” i użyj jednego z przykładowych pytań lub wpisz własne prompty, aby je wypróbować.

Prompty do wypróbowania:

Wyjaśnij Cloud Run w 5 kluczowych punktach.
Jesteś menedżerem produktu Google Cloud Run. Wyjaśnij studentowi, na czym polega Cloud Run, w 5 krótkich punktach.
Jesteś menedżerem produktu Cloud Run w Google i chcesz wyjaśnić Cloud Run certyfikowanemu deweloperowi Kubernetes w 5 krótkich punktach.
Jesteś menedżerem produktu Cloud Run w Google i chcesz wyjaśnić starszemu programiście, kiedy należy używać Cloud Run, a kiedy GKE. W tym celu przedstawiasz 5 krótkich kluczowych punktów.

Aby dowiedzieć się więcej o pisaniu lepszych promptów, zapoznaj się z przewodnikiem po promptach.

Jak Gemini dla Google Cloud korzysta z Twoich danych

Zobowiązanie Google do ochrony prywatności

Google jako jedna z pierwszych firm w branży opublikowała zobowiązanie do ochrony prywatności w systemach AI/ML, w którym wyraziliśmy przekonanie, że klienci powinni mieć najwyższy poziom bezpieczeństwa i kontroli nad swoimi danymi przechowywanymi w chmurze.

Dane, które przesyłasz i odbierasz

Pytania, które zadajesz Gemini, w tym wszelkie informacje wejściowe lub kod, które przesyłasz do Gemini w celu analizy lub uzupełnienia, nazywamy promptami. Odpowiedzi lub dokończenia kodu, które otrzymujesz od Gemini, nazywane są odpowiedziami. Gemini nie używa Twoich promptów ani swoich odpowiedzi jako danych do trenowania swoich modeli.

Szyfrowanie promptów

Gdy przesyłasz prompty do Gemini, Twoje dane są szyfrowane podczas przesyłania i przesyłane do modelu podstawowego w Gemini.

Dane programu wygenerowane przez Gemini

Gemini jest trenowany na podstawie własnego kodu Google Cloud oraz wybranego kodu zewnętrznego. Ponosisz odpowiedzialność za bezpieczeństwo, testowanie i skuteczność kodu, w tym za uzupełnianie, generowanie i analizowanie kodu przez Gemini.

Dowiedz się więcej o tym, jak Google radzi sobie z potwierdzeniami.

3. Opcje testowania promptów

Możesz testować prompty na kilka sposobów.

Vertex AI Studio

Vertex AI Studio jest częścią platformy Vertex AI w Google Cloud, która została zaprojektowana z myślą o uproszczeniu i przyspieszeniu tworzenia oraz stosowania modeli generatywnej AI.

Google AI Studio

Google AI Studio to internetowe narzędzie do tworzenia prototypów i eksperymentowania z inżynierią promptów oraz interfejsem Gemini API.

Aplikacja internetowa Gemini (gemini.google.com)

Aplikacja internetowa Google Gemini (gemini.google.com) to narzędzie internetowe, które ułatwia poznawanie i wykorzystywanie potencjału modeli sztucznej inteligencji Gemini od Google.

aplikację mobilną Google Gemini na Android i aplikację Google na iOS.

4. (OPIS OPCJONALNY) Tworzenie konta usługi

Te kroki zostały wykonane podczas konfiguracji laboratorium – nie musisz ich powtarzać.

Te czynności pokazują, jak skonfigurować konto usługi i role IAM.

Wróć do Google Cloud Console i aktywuj Cloud Shell, klikając ikonę po prawej stronie paska wyszukiwania.

Aby utworzyć nowe konto usługi i klucze, uruchom w otwartym terminalu te polecenia.

Z tego konta usługi będziesz korzystać do wywoływania interfejsu Vertex AI Gemini API z aplikacji Cloud Run.

Skonfiguruj szczegóły projektu, korzystając z danych projektu Qwiklabs.

Przykład: qwiklabs-gcp-00-2c10937585bb

gcloud config set project YOUR_QWIKLABS_PROJECT_ID

Utwórz konto usługi i przyznaj mu role.

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

Jeśli pojawi się pytanie o autoryzację, kliknij „Autoryzuj”, aby kontynuować.

Włącz wymagane usługi, aby korzystać z interfejsów API Vertex AI i czatu Gemini.

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

Włącz wymagane usługi, aby korzystać z interfejsów API Vertex AI i czatu 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. Przyznawanie dostępu do Cloud Workstations

Otwórz Cloud Workstations w Cloud Console.

Przyznaj dostęp do Cloud Workstation studentowi Qwiklabs.

Skopiuj nazwę użytkownika lub adres e-mail Qwiklabs utworzony dla tego projektu i użyj go do dodania głównego konta. Wybierz stanowisko robocze i kliknij „PERMISSIONS”.

Więcej informacji na ten temat znajdziesz poniżej.

Kliknij przycisk „ADD PRINCIPAL”.

Wklej adres e-mail ucznia Qwiklabs i wybierz rolę „Cloud Workstations User”.

Kliknij „Start”, a następnie „Launch”, aby otworzyć stację roboczą i wykonać podane niżej czynności za pomocą wbudowanego terminala.

Klonowanie repozytorium GitHub

Utwórz folder i skopiuj repozytorium GitHub.

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

Użyj elementu menu „File / Open Folder”, aby otworzyć „github/genai-for-developers”.

6. Włączanie Gemini Code Assist

Kliknij ikonę „Gemini”, a potem w prawym dolnym rogu kliknij Login to Google Cloud.

Kliknij link w terminalu, aby rozpocząć proces autoryzacji.

Kliknij „Otwórz”, aby otworzyć link.

Wybierz konto ucznia Qwiklabs i na następnym ekranie kliknij „Zaloguj się”.

Skopiuj kod weryfikacyjny:

Wróć do terminala i wklej kod.

Poczekaj na zakończenie uwierzytelniania, a potem kliknij „Wybierz projekt Google”.

W wyskakującym okienku wybierz projekt Qwiklabs.

Przykład:

Otwórz plik „devai-api/app/routes.py”, a potem kliknij prawym przyciskiem myszy dowolne miejsce w pliku i w menu kontekstowym wybierz „Gemini > Explain this"”.

Przeczytaj wyjaśnienie Gemini dotyczące wybranego pliku.

7. Zestawy narzędzi LangChain

Pakiet narzędzi LangChain to zestawy narzędzi, które mają na celu usprawnienie i ulepszanie tworzenia aplikacji za pomocą LangChain. Oferują one różne funkcje w zależności od konkretnego zestawu narzędzi, ale ogólnie pomagają w tych kwestiach:

Łączenie z zewnętrznymi źródłami danych: możesz uzyskiwać informacje z interfejsów API, baz danych i innych zewnętrznych źródeł oraz stosować je w swoich aplikacjach LangChain.
Zaawansowane techniki promptów: korzystaj z gotowych promptów lub twórz własne, aby optymalizować interakcje z modelami językowymi.
Tworzenie i zarządzanie łańcuchami: możesz łatwo tworzyć złożone łańcuchy i skutecznie nimi zarządzać.
Ocena i monitorowanie: analizuj skuteczność aplikacji i łańcuchów LangChain.

Oto niektóre popularne zestawy narzędzi LangChain:

Narzędzia do wykonywania zadań przez agentów: narzędzia do tworzenia agentów, które mogą wchodzić w interakcje ze światem rzeczywistym, wykonując takie działania jak przeglądanie internetu czy wykonywanie kodu.
Zestaw narzędzi do tworzenia promptów: zbiór zasobów do tworzenia skutecznych promptów.

Zestaw narzędzi GitLab

W tym laboratorium użyjesz narzędzia GitLab do zautomatyzowania tworzenia prośby o łączenie w GitLab.

Zestaw narzędzi Gitlab zawiera narzędzia, które umożliwiają interfejsowi LLM interakcję z repozytorium Gitlab. Narzędzie to obudowa biblioteki python-gitlab.

Pakiet GitLab umożliwia wykonywanie tych czynności:

Utwórz plik – tworzy nowy plik w repozytorium.
Read File (Odczytaj plik) – odczytuje plik z repozytorium.
Zaktualizuj plik – aktualizuje plik w repozytorium.
Utwórz żądanie pull – tworzy żądanie pull z gałęzi roboczej bota do gałęzi bazowej.
Get Issues – pobiera problemy z repozytorium.
Pobierz problem – pobiera szczegóły dotyczące konkretnego problemu.
Komentowanie problemu – publikowanie komentarza na temat konkretnego problemu.
Usuń plik – usuwa plik z repozytorium.

8. Konfiguracja repozytorium GitLab i Toolkit

Otwórz GitLab, utwórz nowy projekt publiczny i skonfiguruj token dostępu do projektu w sekcji „Settings / Access Tokens”.

Użyj tych informacji:

Nazwa tokena: devai-api-qwiklabs
Rola: Maintainer
Wybierz zakresy: api

Skopiuj i wklej wartość tokena dostępu do pliku tymczasowego na laptopie. Zostanie ona użyta w następnych krokach.

9. Przygotowanie do wdrożenia aplikacji w Cloud Run

Wróć do instancji Cloud Workstations i użyj istniejącego terminala lub otwórz nowy.

Uzyskaj dane logowania do swojego konta użytkownika za pomocą procedury autoryzacji internetowej.

Kliknij link i postępuj zgodnie z instrukcjami, aby wygenerować kod weryfikacyjny.

gcloud auth login

Skonfiguruj szczegóły projektu, korzystając z danych projektu Qwiklabs.

Przykład: qwiklabs-gcp-00-2c10937585bb

gcloud config set project YOUR-QWIKLABS-PROJECT-ID

Ustaw pozostałe zmienne środowiskowe:

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

Ustaw zmienne środowiskowe wymagane do integracji z GitLab.

export GITLAB_PERSONAL_ACCESS_TOKEN=gitlab-token

Aby uniknąć ujawniania poufnych informacji w terminalu, najlepiej użyć polecenia read -s. Jest to bezpieczny sposób ustawiania zmiennych środowiskowych bez wyświetlania wartości w historii poleceń w konsoli. Po jego uruchomieniu musisz wkleić wartość i nacisnąć Enter.

To polecenie wymaga zaktualizowania identyfikatora użytkownika i nazwy repozytorium GitLab.

Przykład: export GITLAB_REPOSITORY="gitrey/qwiklabs-test"

export GITLAB_REPOSITORY="USERID/REPOSITORY"

Ustaw pozostałe zmienne środowiskowe:

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

10. Konfiguracja śledzenia LangSmith LLM

Utwórz konto LangSmith i wygeneruj klucz interfejsu API usługi w sekcji Ustawienia. https://docs.smith.langchain.com/

Ustaw zmienne środowiskowe wymagane do integracji z LangSmith.

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

export LANGCHAIN_API_KEY=langchain-service-api-key

11. Konfiguracja JIRA

Te wartości nie są używane w tym laboratorium, więc przed wykonaniem poleceń nie musisz ich zmieniać na wartości z Twojego projektu Jira.

Ustaw zmienne środowiskowe wymagane do wdrożenia usługi 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. Wdrażanie interfejsu Devai-API w Cloud Run

Sprawdź, czy jesteś we właściwym folderze.

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

W tym laboratorium postępujemy zgodnie ze sprawdzonymi metodami i używamy usługi Secret Manager do przechowywania wartości klucza dostępu i klucza interfejsu LangChain API w Cloud Run oraz do odwoływania się do nich.

Zapisz token dostępu JIRA w usłudze Secret Manager.

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

Zapisz token dostępu GitLab w usłudze Secret Manager.

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

Przechowuj klucz API LangChain w Secret Managerze.

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

Wdróż aplikację w 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

Odpowiedź Y: utwórz repozytorium Dockera w 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

Zapoznaj się z procesem gcloud run deploy SERVICE_NAME --source=. poniżej. Więcej informacji

W tle to polecenie używa usług buildpacks i Cloud Build Google Cloud do automatycznego kompilowania obrazów kontenera z Twojego kodu źródłowego bez konieczności instalowania Dockera na komputerze ani konfigurowania pakietów kompilacji ani Cloud Build. Oznacza to, że jedno polecenie opisane powyżej wykonuje to samo, co wymagałoby użycia poleceń gcloud builds submit i gcloud run deploy.

Jeśli podano plik Dockerfile(jak w tym repozytorium), usługa Cloud Build użyje go do kompilowania obrazów kontenera zamiast polegać na pakietach kompilacji, które automatycznie wykrywają i kompilują obrazy kontenera. Więcej informacji o pakietach kompilacji znajdziesz w dokumentacji.

Sprawdź dzienniki Cloud Build w konsoli.

Sprawdź utworzony obraz Dockera w Artifact Registry.

Otwórz cloud-run-source-deploy/devai-api i sprawdź luki w zabezpieczeniach, które zostały wykryte automatycznie. Sprawdź te, dla których dostępne są poprawki, i sprawdź, jak można je rozwiązać na podstawie opisu.

Sprawdź szczegóły instancji Cloud Run w Cloud Console.

Przetestuj punkt końcowy, wykonując polecenie 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

(OPCJONALNA SEKCJA) Konfigurowanie Cloud Workstation

Cloud Workstations to zarządzane środowisko programistyczne w Google Cloud z wbudowanymi zabezpieczeniami i wstępnie skonfigurowanymi, ale konfigurowalnymi środowiskami programistycznymi. Zamiast wymagać od programistów instalowania oprogramowania i uruchamiania skryptów konfiguracyjnych, możesz utworzyć konfigurację stacji roboczej, która określa środowisko w sposób umożliwiający jego odtworzenie. Wszelkie aktualizacje konfiguracji stacji roboczej są automatycznie stosowane na stacjach roboczych przy następnym uruchomieniu. Programiści uzyskują dostęp do stacji roboczych za pomocą przeglądarkowego IDE, różnych lokalnych edytorów kodu (takich jak VSCode lub IDE JetBrains, np. IntelliJ IDEA Ultimate i PyCharm Professional) lub przez SSH.

Cloud Workstations używa tych zasobów Google Cloud do zarządzania środowiskami programistycznymi:

Klastry stacji roboczych definiują grupę stacji roboczych w danym regionie oraz sieć VPC, do której są one podłączone. Klastry stacji roboczych nie są powiązane z klastrami Google Kubernetes Engine (GKE).
Konfiguracje stacji roboczych działają jak szablony stacji roboczych. Konfiguracja stacji roboczej definiuje szczegóły, takie jak typ instancji maszyny wirtualnej stacji roboczej, trwałe miejsce na dane, środowisko definiujące obraz kontenera, IDE lub edytor kodu do użycia i inne. Administratorzy i zespoły platformy mogą też używać zasad zarządzania tożsamościami i dostępem (IAM) do przyznawania dostępu zespołom lub poszczególnym deweloperom.
Workstations to wstępnie skonfigurowane środowiska programistyczne, które zawierają Cloud IDE, narzędzia językowe, biblioteki i inne elementy. Stacje robocze można uruchamiać i zatrzymywać na żądanie oraz uruchamiać na maszynach wirtualnych Compute Engine w Twoim projekcie. Dołączony dysk trwały służy do przechowywania danych między sesjami.

Administratorzy i zespoły platformy tworzą konfiguracje stacji roboczych, które udostępniają zespołowi programistów. Każdy programista tworzy stację roboczą na podstawie konfiguracji stacji roboczej.

W tym module używasz IDE w przeglądarce, ale Cloud Workstations obsługuje też inne popularne interfejsy programistyczne:

Możesz używać własnych lokalnych środowisk JetBrains IDE za pomocą JetBrains Gateway.
Jeśli używasz lokalnej wersji VSCode, możesz też uzyskać dostęp do stacji roboczych w celu zdalnego programowania za pomocą SSH.
Możesz też skonfigurować tunele SSH i TCP do stacji roboczej z komputera lokalnego.

(OPCJONALNA SEKCJA) Tworzenie klastra stacji roboczych

Te kroki zostały wykonane podczas konfiguracji laboratorium – nie musisz ich powtarzać.

Te czynności pokazują, jak skonfigurować klaster, konfigurację i stację roboczą Cloud Workstations.

Przeczytaj tę sekcję i przejdź do sekcji Forge Platform.

Tworzenie klastra stacji roboczych:

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

Tworzenie konfiguracji stacji roboczych

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

Utwórz stację roboczą

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

Dostępne stacje robocze możesz wyświetlić w konsoli Google Cloud. Uruchom i otwórz aplikację „devai-workstation”.

Włącz „Gemini” w prawym dolnym rogu, postępuj zgodnie z procedurą logowania na nowej karcie przeglądarki i skopiuj wygenerowany kod z powrotem do konsoli, aby dokończyć logowanie.

Otwórz czat „Gemini” w panelu po lewej stronie i zapytaj 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. platforma Forge,

Forge to platforma, która umożliwia deweloperom tworzenie aplikacji integrujących się z usługami Atlassian, takimi jak Jira, Confluence, Compass i Bitbucket.

Instalowanie interfejsu wiersza poleceń Forge

Uruchom te polecenia w terminalu.

Pobierz menedżera wersji węzła ( nvm) i udostępnij go w ścieżce w bieżącej sesji terminala.

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

Zainstaluj nvm.

Wybierz najnowszą wersję LTS Node.js, uruchamiając w terminalu to polecenie:

nvm install --lts
nvm use --lts

Zainstaluj interfejs wiersza poleceń Forge globalnie, wykonując to polecenie:

npm install -g @forge/cli

W tym module do logowania użyjemy zmiennych środowiskowych.

Konfigurowanie projektu JIRA

Utwórz lub wyświetl projekty JIRA za pomocą swojego konta osobistego.

Sprawdź istniejące projekty JIRA: https://admin.atlassian.com/

Utwórz nowy projekt JIRA za pomocą swojego konta osobistego.

Otwórz stronę https://team.atlassian.com/your-work i kliknij , a następnie wybierz . Następnie wybierz „JIRA Software” – „Wypróbuj teraz”. Postępuj zgodnie z instrukcjami, aby utworzyć projekt lub stronę.

Wybierz JIRA Software.

Utwórz nowy projekt.

14. Token interfejsu Atlassian API

Aby zalogować się w interfejsie wiersza poleceń, utwórz token API Atlassian lub użyj istniejącego.

Podczas wykonywania poleceń interfejs wiersza poleceń używa Twojego tokena.

Otwórz stronę https://id.atlassian.com/manage/api-tokens.
Kliknij Utwórz token API.
Wpisz etykietę opisującą token API. Na przykład forge-api-token.
Kliknij Utwórz.
Kliknij Kopiuj do schowka i zamknij okno.

Uruchom to polecenie w terminalu Cloud Workstations.

Aby zacząć używać poleceń Forge, zaloguj się w Forge CLI.

Ustaw adres e-mail JIRA/FORGE. Zastąp go swoim adresem e-mail.

export FORGE_EMAIL=your-email

Ustaw token API Forge. Zastąp go swoim tokenem API JIRA.

export FORGE_API_TOKEN=your-jira-api-token

Przetestuj interfejs wiersza poleceń Forge, uruchamiając podane niżej polecenie. Gdy pojawi się prośba o zbieranie danych analitycznych, odpowiedz „No”.

forge settings set usage-analytics false

Sprawdź, czy jesteś zalogowany(-a).

forge whoami

Przykładowe dane wyjściowe.

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

Tworzenie aplikacji Forge

Sprawdź, czy jesteś w folderze „~/github/genai-for-developers”.

Uruchom polecenie, aby utworzyć aplikację Forge.

forge create

Gdy pojawi się prośba, wpisz te wartości:

Nazwa aplikacji: devai-jira-ui-qwiklabs
Wybierz kategorię: UI Kit
Wybierz usługę: Jira
Wybierz szablon: jira-issue-panel

Przejdź do folderu aplikacji.

cd devai-jira-ui-qwiklabs/

Uruchom polecenie wdrażania.

forge deploy

Przykładowe dane wyjściowe:

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.

Zainstaluj aplikację.

forge install

Gdy pojawi się prośba, wpisz te wartości:

Wybierz usługę: Jira
Wpisz adres URL witryny: your-domain.atlassian.net

Przykładowe dane wyjściowe:

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

Otwórz witrynę JIRA i utwórz nowe zadanie JIRA o następującym opisie:

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.

Gdy otworzysz zadanie, zobaczysz przycisk „devai-jira-ui-qwiklabs”.

Kliknij przycisk i sprawdź zmiany w interfejsie.

Wyświetlanie logów backendu Forge.

forge logs

Konsola dewelopera Atlassian

Możesz też wyświetlać w konsoli dla deweloperów Atlassian wdrożone aplikacje i nimi zarządzać.

Sprawdzanie dzienników – przełącz się na środowisko Development,

Sprawdzanie pliku manifestu i kodu źródłowego aplikacji Forge

Otwórz plik „devai-jira-ui-qwiklabs/manifest.yml” i użyj Gemini Code Assist, aby go wyjaśnić.

Zapoznaj się z wyjaśnieniem.

Otwórz te pliki i poproś Gemini Code Assist o ich wyjaśnienie:

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

Aktualizacja aplikacji Forge za pomocą punktu końcowego DevAI API Cloud Run

Sprawdź, czy ustawiony jest identyfikator projektu GCP:

gcloud config get project

Jeśli nie, skonfiguruj projekt GCP, korzystając z identyfikatora projektu na stronie laboratorium Qwiklabs:

Przykład: qwiklabs-gcp-00-2c10937585bb

gcloud config set project YOUR_QWIKLABS_PROJECT_ID

Ustaw adres URL usługi 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

Aby to potwierdzić, uruchom to polecenie:

forge variables list

Przykładowe dane wyjściowe

Aktualizowanie pliku manifestu i kodu aplikacji Forge

Te fragmenty kodu znajdziesz w repozytorium w folderze sample-devai-jira-ui.

Otwórz plik manifestu w edytorze: devai-jira-ui-qwiklabs/manifest.yml

Dodaj wiersze poniżej na końcu pliku – zastąp punkt końcowy Cloud Run tym, który został przez Ciebie wdrożony.

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

Otwórz plik resolverów/indeksów w edytorze: devai-jira-ui-qwiklabs/src/resolvers/index.js

Dodaj wiersze pod istniejącą funkcją getText.

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

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

Otwórz w edytorze plik front-endu lub indeksu: devai-jira-ui-qwiklabs/src/frontend/index.jsx

Zastąp index.jsx treścią poniżej. Zaktualizuj link do identyfikatora użytkownika lub repozytorium GitLab.

Musisz zaktualizować identyfikator użytkownika i repozytorium Git w 2 miejscach.

W pliku odszukaj ten wiersz i wprowadź zmiany:

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

Wdrażanie ponownie aplikacji Forge

Dodaj zależności w pliku package.json:

"@forge/api": "4.0.0",

Zainstaluj zależności:

npm install

Wdróż zaktualizowaną aplikację:

forge deploy

Przykładowe dane wyjściowe:

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

Instalowanie zaktualizowanej aplikacji:

forge install --upgrade

Przykładowe dane wyjściowe:

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.

Aplikacja Test Forge

Otwórz istniejące zadanie JIRA lub utwórz nowe w projekcie JIRA.

Jeśli poprzedni panel został już dodany, musisz go usunąć.

Kliknij ... i w menu wybierz usuń. Następnie możesz ponownie kliknąć przycisk.

Sprawdzanie komentarzy w Jira

Gdy otrzymasz odpowiedź z DEVAI API, do problemu w JIRA zostaną dodane 2 komentarze.

Prośba o połączenie w GitLab
Szczegóły implementacji historii użytkownika w Gemini

Aby odświeżyć widok, przełącz się między kartami „History” i „Comments”.

Włączanie tworzenia żądań scalania w GitLab

Otwórz plik devai-api/app/routes.py i usuń znaczniki komentarza z podanych niżej wierszy w metodie 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)

Wdrażanie aplikacji Cloud Run

Sprawdź, czy jesteś we właściwym folderze.

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

Jeśli używasz tej samej sesji terminala, wszystkie zmienne środowiskowe mogą być nadal ustawione.

Aby to sprawdzić, uruchom w terminalu polecenie „echo $GITLAB_REPOSITORY”.

Jeśli została otwarta nowa sesja terminala, wykonaj te czynności, aby je zresetować.

Przed ponownym wdrożeniem aplikacji zresetuj wymagane zmienne środowiskowe.

To polecenie wymaga zaktualizowania identyfikatora użytkownika i nazwy repozytorium GitLab.

export GITLAB_REPOSITORY="USERID/REPOSITORY"

Ustaw pozostałe zmienne środowiskowe:

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

Narzędzia GitLab będą używać gałęzi „devai”, aby przesłać zmiany do prośby o scalanie.

Sprawdź, czy ta gałąź została już utworzona.

Wdróż aplikację w 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

Weryfikacja kompleksowej integracji

Uruchom proces z zadania JIRA, klikając ponownie przycisk, i sprawdź dane wyjściowe w repozytorium GitLab w sekcji Prośba o łączenie i LangSmith.

Szczegóły prośby o scalanie w GitLab

Ślady LangSmith LLM

Otwórz portal LangSmith i sprawdź ślad LLM dla wywołania funkcji tworzenia problemu w JIRA.

Przykładowy ślad LangSmith LLM.

(OPISYWAĆ OPCJONALNIE) Przesyłanie zmian do repozytorium GitHub

Otwórz stronę GitHub i utwórz nowe repozytorium, aby przesłać zmiany z tego laboratorium do swojego osobistego repozytorium.

Wróć do instancji Cloud Workstations i ustaw w terminalu nazwę użytkownika i adres e-mail Git.

Zaktualizuj wartości przed uruchomieniem poleceń.

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

Wygeneruj klucz SSH i dodaj go do repozytorium GitHub.

Zaktualizuj adres e-mail przed uruchomieniem poleceń.

Nie wpisuj hasła i nie naciskaj klawisza Enter wielokrotnie, aby utworzyć klucz.

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

eval "$(ssh-agent -s)"

ssh-add ~/.ssh/id_ed25519

cat ~/.ssh/id_ed25519.pub

Dodaj wygenerowany klucz publiczny do swojego konta GitHub.

Otwórz https://github.com/settings/keys i kliknij „New SSH key”.

Jako nazwy klucza użyj „qwiklabs-key” i skopiuj/wklej dane wyjściowe z ostatniego polecenia.

Wróć do terminala, zatwierdź i prześlij zmiany.

cd ~/github/genai-for-developers

git remote rm origin

Ustaw zdalne źródło za pomocą utworzonego powyżej repozytorium.

Zastąp adresem URL repozytorium.

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

Dodaj, zatwierdź i prześlij zmiany.

git add .

git commit -m "lab changes"

git push -u origin main

15. Gratulacje!

Gratulacje! Masz ukończony ten moduł.

Omówione zagadnienia:

Jak wdrażać aplikacje Cloud Run w celu integracji z interfejsami Gemini API.
Jak utworzyć i wdrożyć aplikację Atlassian Forge dla JIRA.
Jak używać agentów LangChain ReAct do automatyzacji zadań GitLab
Jak przeglądać ścieżki LLM w LangSmith

Co dalej:

Wkrótce odbędą się kolejne praktyczne sesje.

Czyszczenie danych

Aby uniknąć obciążenia konta Google Cloud opłatami za zasoby zużyte w tym samouczku, możesz usunąć projekt zawierający te zasoby lub zachować projekt i usunąć poszczególne zasoby.

Usuwanie projektu

Najprostszym sposobem na uniknięcie płatności jest usunięcie projektu utworzonego na potrzeby tego samouczka.

©2024 Google LLC. Wszelkie prawa zastrzeżone. Google i logo Google są znakami towarowymi Google LLC. Wszelkie inne nazwy firm i produktów mogą być znakami towarowymi odpowiednich podmiotów, z którymi są powiązane.