Środowisko programistyczne

1. Omówienie

W tym module przedstawiamy funkcje i możliwości zaprojektowane w celu usprawnienia procesu programowania dla inżynierów, których zadaniem jest tworzenie aplikacji w języku Python w skonteneryzowanym środowisku. Typowe tworzenie kontenerów wymaga, aby użytkownik znał szczegóły kontenerów i proces ich tworzenia. Poza tym deweloperzy zwykle muszą przerwać przepływ pracy, wychodząc z IDE, aby przetestować i debugować aplikacje w środowiskach zdalnych. Dzięki narzędziom i technologiom wspomnianym w tym samouczku deweloperzy mogą wydajnie pracować z aplikacjami skonteneryzowanymi bez opuszczania IDE.

Co to są Cloud Workstations?

Cloud Workstations to zarządzane środowiska programistyczne w Google Cloud z wbudowanymi zabezpieczeniami i wstępnie skonfigurowanymi, ale też konfigurowalnymi środowiskami programistycznymi. Uzyskaj dostęp do Cloud Workstations przez IDE działającego w przeglądarce, z wielu lokalnych edytorów kodu (takich jak VSCode lub JetBrains IDE, np. IntelliJ IDEA Ultimate i PyCharm Professional) lub przez SSH.

Cloud Workstations korzystają z tych zasobów:

• Administratorzy tworzą klastry stacji roboczych.
• W każdym klastrze stacji roboczych administratorzy tworzą co najmniej 1 konfigurację stacji roboczych, która działa jako szablony stacji roboczych.
• Deweloperzy mogą tworzyć stacje robocze definiujące środowiska programistyczne m.in. zapewniające Cloud IDE, narzędzia językowe czy biblioteki.

Usługa Cloud Workstations umożliwia administratorom IT i bezpieczeństwa łatwe udostępnianie, skalowanie i zabezpieczanie środowisk programistycznych oraz zarządzanie nimi. Zapewnia też programistom dostęp do środowisk programistycznych dzięki spójnym konfiguracjom i narzędziom z możliwością dostosowania.

Usługa Cloud Workstations pomaga przenosić zabezpieczenia w lewo przez poprawę stanu zabezpieczeń środowisk programistycznych aplikacji. Zawiera funkcje zabezpieczeń, takie jak Ustawienia usługi VPC, prywatny ruch przychodzący lub wychodzący, wymuszona aktualizacja obrazu oraz zasady dostępu do Identity and Access Management.

Co to jest Cloud Code?

Cloud Code zapewnia obsługę IDE na potrzeby pełnego cyklu programowania aplikacji Kubernetes i Cloud Run – od tworzenia i dostosowywania nowej aplikacji – od przykładowych szablonów po uruchamianie gotowej aplikacji. Cloud Code zapewnia gotowe do uruchomienia fragmenty kodu, gotowe fragmenty konfiguracji i spersonalizowane środowisko debugowania. Programowanie w Kubernetes i Cloud Run staje się o wiele łatwiejsze.

Oto niektóre z funkcji Cloud Code:

• Nieustanne kompilowanie i uruchamianie aplikacji
• Obsługa debugowania w przypadku aplikacji Kubernetes, która jest w trakcie opracowywania
• Strumieniowanie i wyświetlanie logów

Dowiedz się więcej o innych funkcjach Cloud Code.

Czego się nauczysz

W tym module nauczysz się, jak tworzyć aplikacje z wykorzystaniem kontenerów w GCP, takich jak:

• Przejrzyj Cloud Workstations
• Uruchom stację roboczą
• Sprawdź Cloud Code
• Debuguj w Kubernetes

2. Konfiguracja i wymagania

Samodzielne konfigurowanie środowiska

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

• Nazwa projektu jest wyświetlaną nazwą uczestników tego projektu. To ciąg znaków, który nie jest używany przez interfejsy API Google. W każdej chwili możesz ją zmienić.
• Identyfikator projektu jest unikalny we wszystkich projektach Google Cloud i nie można go zmienić (po jego ustawieniu nie można go zmienić). Cloud Console automatycznie wygeneruje unikalny ciąg znaków. zwykle nieważne, co ona jest. W większości ćwiczeń z programowania konieczne jest odwołanie się do identyfikatora projektu (zwykle nazywa się on PROJECT_ID). Jeśli nie podoba Ci się wygenerowany identyfikator, możesz wygenerować kolejny losowy. Możesz też spróbować własnych sił i sprawdzić, czy jest dostępna. Potem nie będzie można go zmienić. Pozostanie ono przez czas trwania projektu.
• Dostępna jest trzecia wartość, numer projektu, z którego korzystają niektóre interfejsy API. Więcej informacji o wszystkich 3 wartościach znajdziesz w dokumentacji.

Uwaga: identyfikator projektu jest globalnie unikalny i po wybraniu nie może go użyć żaden inny użytkownik. Jesteś jedynym użytkownikiem tego identyfikatora. Nawet po usunięciu projektu identyfikatora nie można użyć ponownie

Uwaga: jeśli używasz konta Gmail, jako domyślną lokalizację możesz pozostawić ustawienie Brak organizacji. Jeśli używasz konta Google Workspace, wybierz lokalizację, która będzie odpowiednia dla Twojej organizacji.

2. Następnie musisz włączyć płatności w Cloud Console, aby korzystać z zasobów Cloud/interfejsów API. Ukończenie tego ćwiczenia z programowania nie powinno kosztować zbyt wiele. Aby wyłączyć zasoby, aby nie naliczać opłat po zakończeniu tego samouczka, możesz usunąć utworzone zasoby lub cały projekt. Nowi użytkownicy Google Cloud mogą skorzystać z programu bezpłatnego okresu próbnego o wartości 300 USD.

Konfiguracja środowiska

W Cloud Shell ustaw identyfikator i numer projektu. Zapisz je jako zmienne PROJECT_ID i PROJECT_ID.

export PROJECT_ID=$(gcloud config get-value project)
export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID \
    --format='value(projectNumber)')

W tym module wdrożysz kod w GKE. Jako IDE będziesz też używać stacji roboczych Cloud.

Poniższy skrypt konfiguracji przygotowuje dla Ciebie tę infrastrukturę.

1. Pobierz skrypt konfiguracji i uruchom go.

wget https://raw.githubusercontent.com/GoogleCloudPlatform/container-developer-workshop/main/labs/python/setup_with_cw.sh
chmod +x setup_with_cw.sh

2. Otwórz plik setup_with_cw.sh i zmień wartości haseł, które są obecnie ustawione na CHANGEME
3. Uruchom skrypt konfiguracji, aby utworzyć klaster GKE, którego użyjesz w tym module. Ta konfiguracja zajmie około 20 minut.

./setup_with_cw.sh &

4. Otwórz Cloud Workstations w konsoli Cloud. Zanim przejdziesz do kolejnych kroków, poczekaj, aż klaster będzie w stanie READY.
5. Jeśli sesja Cloud Shell została odłączona, kliknij „Połącz ponownie” a następnie uruchom polecenie wiersza poleceń gcloud, aby ustawić identyfikator projektu. Zanim uruchomisz polecenie, zastąp przykładowy identyfikator projektu poniżej identyfikatorem projektu qwiklabs.

gcloud config set project qwiklabs-gcp-project-id

6. Pobierz i uruchom poniższy skrypt w terminalu, aby utworzyć konfigurację Cloud Workstations.

wget https://raw.githubusercontent.com/GoogleCloudPlatform/container-developer-workshop/main/labs/python/workstation_config_setup.sh
chmod +x workstation_config_setup.sh
./workstation_config_setup.sh

Klaster i konfiguracja Cloud Workstations

Otwórz Cloud Workstations w konsoli Cloud. Sprawdź, czy klaster jest w stanie READY.

Sprawdź stan istniejących konfiguracji.

Utwórz nową stację roboczą.

Zmień nazwę na my-workstation i wybierz istniejącą konfigurację: codeoss-python.

Uruchom stację roboczą

1. Uruchom i uruchom stację roboczą. Uruchamianie stacji roboczej może chwilę potrwać.

2. Zezwalaj na pliki cookie innych firm, klikając ikonę na pasku adresu.

3. Kliknij „Witryna nie działa?”.

4. Kliknij przycisk „Zezwalaj na pliki cookie”.

5. Po uruchomieniu stacji roboczej pojawi się okno Code OSS IDE.

Kliknij „Oznacz jako gotowe”. na pierwszej stronie wprowadzającej do IDE stacji roboczej

3. Omówienie Cloud Code

Przejrzyj różne sekcje dostępne w Cloud Code.

• Programowanie Kubernetes. Korzystaj ze w pełni zintegrowanego środowiska programistycznego i debugowania Kubernetes w swoim IDE. Tworzenie klastrów i zarządzanie nimi bezpośrednio w IDE.
• Debuguj uruchomione aplikacje. Debuguj kod w IDE za pomocą Cloud Code for VS Code i Cloud Code for IntelliJ, wykorzystując wbudowane funkcje debugowania IDE.
• Poznaj wdrożenia Wyświetlanie bazowych zasobów i metadanych klastrów Kubernetes oraz usług Cloud Run. Możesz pobrać opis, wyświetlić logi, zarządzać obiektami tajnymi lub pobrać terminal bezpośrednio do poda.
• Uprość lokalne programowanie w Kubernetes. Pod osłoną Cloud Code dla IDE korzysta z popularnych narzędzi, takich jak Skaffold, Jib i kubectl, aby zapewniać ciągłość informacji zwrotnych na temat kodu w czasie rzeczywistym.

Logowanie się do Google Cloud

1. Kliknij ikonę Cloud Code i wybierz opcję „Sign in to Google Cloud” (Zaloguj się w Google Cloud):

2. Kliknij „Przejdź do logowania”.

3. Sprawdź dane wyjściowe w terminalu i otwórz link:

4. Zaloguj się danymi logowania uczniów Qwiklabs.

5. Wybierz „Zezwól”:

6. Skopiuj kod weryfikacyjny i wróć na kartę Workstations.

7. Wklej kod weryfikacyjny i naciśnij Enter.

Kliknij „Zezwól”. przycisk, który można skopiować do stacji roboczej.

4. Tworzenie nowej aplikacji startowej w języku Python

W tej sekcji utworzysz nową aplikację w języku Python.

1. Otwórz nowy terminal.

2. Utwórz nowy katalog i otwórz go jako obszar roboczy

mkdir music-service && cd music-service

code-oss-cloud-workstations -r --folder-uri="$PWD"

3. Utwórz plik o nazwie requirements.txt i skopiuj do niego tę zawartość

Flask
gunicorn
ptvsd==4.3.2

4. Utwórz plik o nazwie app.py i wklej do niego ten kod

import os
from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route("/")
def hello_world():
    message="Hello, World!"
    return message

if __name__ == '__main__':
    server_port = os.environ.get('PORT', '8080')
    app.run(debug=False, port=server_port, host='0.0.0.0')

5. Utwórz plik o nazwie Dockerfile i wklej do niego poniższy kod

FROM python:3.8
ARG FLASK_DEBUG=0
ENV FLASK_DEBUG=$FLASK_DEBUG
ENV FLASK_APP=app.py
WORKDIR /app
COPY requirements.txt .
RUN pip install --trusted-host pypi.python.org -r requirements.txt
COPY . .
ENTRYPOINT ["python3", "-m", "flask", "run", "--port=8080", "--host=0.0.0.0"]

Uwaga: FLASK_DEBUG=1 umożliwia automatyczne ponowne ładowanie zmian kodu w aplikacji w Pythonie na kolbę. Ten plik Dockerfile pozwala przekazać tę wartość jako argument kompilacji.

Generuj pliki manifestu

Wykonaj w terminalu to polecenie, aby wygenerować domyślne skaffold.yaml i deployment.yaml.

1. Zainicjuj Skaffold za pomocą tego polecenia

skaffold init --generate-manifests

Gdy pojawi się prośba, używaj strzałek, aby poruszać kursorem, a spację, aby wybierać opcje.

Wybierz:

• 8080 za port
• y, aby zapisać konfigurację.

Aktualizowanie konfiguracji Skaffold

• Zmień domyślną nazwę aplikacji
• Otwórz: skaffold.yaml
• Wybierz nazwę obrazu, który jest obecnie ustawiony jako dockerfile-image
• Kliknij prawym przyciskiem myszy i wybierz Zmień wszystkie wystąpienia
• Wpisz nową nazwę jako python-app
• Zmodyfikuj sekcję kompilacji, tak aby była
• dodaj docker.buildArgs, aby wjechać do firmy FLASK_DEBUG=1
• Zsynchronizuj ustawienia, aby wczytać wszelkie zmiany w plikach *.py z IDE do uruchomionego kontenera

Po wprowadzeniu zmian sekcja kompilacji w pliku skaffold.yaml będzie wyglądać tak:

build:
 artifacts:
 - image: python-app
   docker:
     buildArgs:
       FLASK_DEBUG: "1"
     dockerfile: Dockerfile
   sync:
     infer:
     - '**/*.py'

Zmodyfikuj plik konfiguracji Kubernetes

1. Zmiana nazwy domyślnej

• Otwórz plik deployment.yaml
• Wybierz nazwę obrazu, który jest obecnie ustawiony jako dockerfile-image
• Kliknij prawym przyciskiem myszy i wybierz Zmień wszystkie wystąpienia
• Wpisz nową nazwę jako python-app

5. Omówienie procesu programowania

Dzięki dodanej logice biznesowej możesz teraz wdrożyć i przetestować aplikację. W następnej sekcji dowiesz się, jak korzystać z wtyczki Cloud Code. Integruje się ona między innymi ze skaffold, aby usprawnić proces programowania. Gdy wdrożysz obraz kontenera w GKE za pomocą poniższych kroków, Cloud Code i Skaffold automatycznie skompilują obraz kontenera, wypchnie go do Container Registry, a następnie wdroży aplikację your w GKE. Dzieje się to za kulisami, odbierając szczegóły od procesu deweloperskiego.

Dodaj klaster Kubernetes

1. Dodaj klaster

2. Wybierz Google Kubernetes Engine:

3. Wybierz projekt.

4. Wybierz „python-cluster” utworzony podczas początkowej konfiguracji.

5. Klaster pojawi się na liście klastrów Kubernetes w sekcji Cloud Code. Tutaj możesz poruszać się po klastrze i go poznawać.

Wdróż w Kubernetes

1. W panelu u dołu edytora Cloud Shell wybierz Cloud Code .

2. W panelu, który się pojawi, kliknij Uruchom w Kubernetes.

W razie potrzeby wybierz Tak, aby użyć bieżącego kontekstu Kubernetes.

To polecenie uruchamia kompilację kodu źródłowego, a następnie uruchamia testy. Kompilacja i testy potrwają kilka minut. Te testy obejmują testy jednostkowe oraz etap weryfikacji, który sprawdza reguły ustawione dla środowiska wdrożenia. Ten etap weryfikacji jest już skonfigurowany i dzięki temu ostrzeżemy Cię o problemach z wdrożeniem, nawet jeśli nadal pracujesz w środowisku programistycznym.

3. Przy pierwszym uruchomieniu polecenia u góry ekranu pojawi się prompt z pytaniem, czy chcesz uzyskać bieżący kontekst Kubernetes. Wybierz „Tak”. aby zaakceptować i wykorzystać bieżący kontekst.
4. Pojawi się pytanie, którego rejestru kontenerów użyć. Naciśnij Enter, aby zaakceptować podaną wartość domyślną
5. Wybierz „Dane wyjściowe”. w panelu u dołu, aby wyświetlić postęp i powiadomienia. Za pomocą menu wybierz „Kubernetes: Run/Debug”.

6. Wybierz „Kubernetes: Run/Debug - detail”. w menu kanału po prawej stronie, aby wyświetlić dodatkowe szczegóły i logi, które są przesyłane na żywo z kontenerów.

Po zakończeniu kompilacji i testów w dziennikach karty Dane wyjściowe w sekcji „Kubernetes: Run/Debug” pojawi się adres URL http://localhost: 8080 widok.

7. W terminalu Cloud Code najedź kursorem na pierwszy adres URL w danych wyjściowych (http://localhost:8080), a następnie w wyświetlonej wskazówce narzędzia wybierz Otwórz podgląd w przeglądarce.
8. Otworzy się nowa karta przeglądarki z komunikatem: Hello, World!

Ponowne załadowanie „na gorąco”

1. Otwórz plik app.py.
2. Zmień wiadomość powitalną na Hello from Python

Od razu zauważysz, że w oknie Output, widoku Kubernetes: Run/Debug obserwator synchronizuje zaktualizowane pliki z kontenerem w Kubernetes.

Update initiated
Build started for artifact python-app
Build completed for artifact python-app

Deploy started
Deploy completed

Status check started
Resource pod/python-app-6f646ffcbb-tn7qd status updated to In Progress
Resource deployment/python-app status updated to In Progress
Resource deployment/python-app status completed successfully
Status check succeeded
...

3. Jeśli przełączysz się na widok Kubernetes: Run/Debug - Detailed, zauważysz, że rozpoznaje zmiany w plikach, a następnie skompiluje i ponownie wdroży aplikację

files modified: [app.py]
Syncing 1 files for gcr.io/veer-pylab-01/python-app:3c04f58-dirty@sha256:a42ca7250851c2f2570ff05209f108c5491d13d2b453bb9608c7b4af511109bd
Copying files:map[app.py:[/app/app.py]]togcr.io/veer-pylab-01/python-app:3c04f58-dirty@sha256:a42ca7250851c2f2570ff05209f108c5491d13d2b453bb9608c7b4af511109bd
Watching for changes...
[python-app] * Detected change in '/app/app.py', reloading
[python-app] * Restarting with stat
[python-app] * Debugger is active!
[python-app] * Debugger PIN: 744-729-662

4. Aby zobaczyć zaktualizowane wyniki, odśwież kartę przeglądarki, w której były poprzednie wyniki.

Debugowanie

1. Otwórz widok debugowania i zatrzymaj bieżący wątek . Jeśli pojawi się prośba, możesz wyczyścić dane po każdym uruchomieniu.
2. 
3. Kliknij Cloud Code w dolnym menu i wybierz Debug on Kubernetes, aby uruchomić aplikację w trybie debug.

• W widoku Kubernetes Run/Debug - Detailed okna Output zwróć uwagę, że skaffold wdroży tę aplikację w trybie debugowania.

4. Przy pierwszym uruchomieniu pojawi się pytanie, gdzie w kontenerze znajduje się źródło. Ta wartość jest powiązana z katalogami w pliku Dockerfile.

Naciśnij Enter, aby zaakceptować domyślną wartość

Skompilowanie i wdrożenie aplikacji zajmie kilka minut. Jeśli sesja debugowania zostanie odłączona, powtórz czynności opisane w sekcji „Debugowanie w Kubernetes” z sekcji „Development Sessions”, .

5. Po zakończeniu procesu. Dołączenie debugera to: Attached debugger to container "python-app-8476f4bbc-h6dsl" successfully., na karcie Wyniki są wyświetlany adres URL http://localhost:8080.

Port forwarding pod/python-app-8bd64cf8b-cskfl in namespace default, remote port 5678 -> http://127.0.0.1:5678

6. Kolor dolnego paska stanu zmieni się z niebieskiego na pomarańczowy, co oznacza, że urządzenie działa w trybie debugowania.

7. Zwróć uwagę na to, że w widoku Kubernetes Run/Debug został uruchomiony kontener z możliwością debugowania.

**************URLs*****************
Forwarded URL from service python-app: http://localhost:8080
Debuggable container started pod/python-app-8bd64cf8b-cskfl:python-app (default)
Update succeeded
***********************************

Wykorzystuj punkty przerwania

1. Otwórz plik app.py.
2. Znajdź instrukcję, która brzmi: return message
3. Dodaj do tego wiersza punkt przerwania, klikając puste miejsce po lewej stronie numeru wiersza. Pojawi się czerwony wskaźnik informujący o ustawieniu punktu przerwania
4. Załaduj ponownie przeglądarkę. Pamiętaj, że debuger zatrzymuje proces w punkcie przerwania i umożliwia zbadanie zmiennych oraz stanu aplikacji uruchomionej zdalnie w GKE.
5. Kliknij w dół do sekcji ZMIENNE
6. Kliknij przycisk Lokalne. Znajdziesz tam zmienną "message".
7. Kliknij dwukrotnie zmienną o nazwie „wiadomość”. i w wyskakującym okienku zmień wartość na inną, np. "Greetings from Python".
8. Kliknij przycisk Dalej w panelu sterowania debugowania .
9. Sprawdź odpowiedź w przeglądarce, w której wyświetla się wprowadzona przed chwilą zaktualizowana wartość.
10. Zatrzymaj „Debugowanie” naciśnij przycisk zatrzymania i usuń punkt przerwania, ponownie klikając go.

6. Czyszczenie

Gratulacje! W tym module udało Ci się utworzyć od zera nową aplikację w Pythonie i skonfigurować ją tak, aby wydajnie współpracowała z kontenerami. Następnie wdrożono i debugowałeś(-aś) aplikację w zdalnym klastrze GKE, postępując zgodnie z procedurą programistyczną obowiązującą w tradycyjnych stosach aplikacji.

Aby posprzątać po ukończeniu modułu:

1. Usuń pliki używane w module

cd ~ && rm -rf ~/music-service

2. Usuń projekt, aby usunąć całą powiązaną infrastrukturę i zasoby

–

Ostatnia aktualizacja: 22.03.2023 r.