Środowisko programistyczne

1. Przegląd

W tym laboratorium dowiesz się o funkcjach i możliwościach, które usprawniają przepływ pracy dla inżynierów oprogramowania, których zadaniem jest tworzenie aplikacji w Pythonie w środowisku skonteneryzowanym. Typowe tworzenie kontenerów wymaga od użytkownika znajomości szczegółów dotyczących kontenerów i procesu kompilacji kontenerów. Deweloperzy zwykle muszą też przerywać pracę i opuszczać IDE, aby testować i debugować aplikacje w środowiskach zdalnych. Dzięki narzędziom i technologiom wymienionym w tym samouczku deweloperzy mogą efektywnie pracować z aplikacjami w kontenerach bez opuszczania środowiska IDE.

Co to jest Cloud Workstations?

Cloud Workstations to zarządzane środowiska programistyczne w Google Cloud z wbudowanymi zabezpieczeniami oraz wstępnie skonfigurowanymi, ale konfigurowalnymi środowiskami programistycznymi. Dostęp do Cloud Workstations można uzyskać za pomocą IDE w przeglądarce, z wielu lokalnych edytorów kodu (takich jak VSCode lub IDE JetBrains, np. IntelliJ IDEA Ultimate i PyCharm Professional) lub przez SSH.

Cloud Workstations korzysta 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 jak szablon stacji roboczych.
• Deweloperzy mogą tworzyć stacje robocze, które definiują środowiska programistyczne udostępniające Cloud IDE, narzędzia językowe, biblioteki i nie tylko.

Cloud Workstations umożliwia administratorom IT i administratorom ds. bezpieczeństwa łatwe udostępnianie, skalowanie, zarządzanie i zabezpieczanie środowisk programistycznych, a deweloperom – dostęp do środowisk programistycznych o spójnych konfiguracjach i konfigurowalnych narzędziach.

Cloud Workstations pomaga przenieść zabezpieczenia na wcześniejszy etap, zwiększając stan zabezpieczeń środowisk programistycznych. Ma funkcje zabezpieczeń, takie jak ustawienia usługi VPC, prywatny ruch przychodzący lub wychodzący, wymuszone aktualizowanie obrazu i zasady dostępu usługi zarządzania tożsamościami i dostępem.

Co to jest Cloud Code?

Cloud Code zapewnia obsługę IDE w całym cyklu tworzenia aplikacji Kubernetes i Cloud Run, od tworzenia i dostosowywania nowej aplikacji na podstawie przykładowych szablonów po uruchamianie gotowej aplikacji. Cloud Code ułatwia pracę dzięki gotowym do uruchomienia przykładom, gotowym fragmentom konfiguracji i dostosowanemu debugowaniu, co znacznie ułatwia tworzenie aplikacji w Kubernetes i Cloud Run.

Oto niektóre funkcje Cloud Code:

• Ciągłe tworzenie i uruchamianie aplikacji
• Obsługa debugowania aplikacji Kubernetes w trakcie tworzenia
• Przesyłanie strumieniowe i wyświetlanie logów

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

Czego się nauczysz

W tym module poznasz metody tworzenia aplikacji w kontenerach w GCP, w tym:

• Sprawdzanie Cloud Workstations
• Uruchom stację roboczą
• Sprawdzanie Cloud Code
• Debugowanie w Kubernetes

2. Konfiguracja i wymagania

Samodzielne konfigurowanie środowiska

1. 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óry nie jest używany przez interfejsy API Google. Możesz ją zaktualizować w dowolnym momencie.
• Identyfikator projektu jest unikalny we wszystkich projektach Google Cloud i nie można go zmienić po ustawieniu. Konsola Cloud automatycznie generuje unikalny ciąg znaków. Zwykle nie musisz się nim przejmować. W większości ćwiczeń z programowania musisz odwoływać się do identyfikatora projektu (zwykle jest on oznaczony jako PROJECT_ID). Jeśli wygenerowany identyfikator Ci się nie podoba, możesz wygenerować inny losowy identyfikator. Możesz też spróbować własnej nazwy i sprawdzić, czy jest dostępna. Po tym kroku nie można go zmienić i będzie obowiązywać przez cały czas trwania projektu.
• Warto wiedzieć, że istnieje też trzecia wartość, czyli numer projektu, z której korzystają niektóre interfejsy API. Więcej informacji o tych 3 wartościach znajdziesz w dokumentacji.

Ostrzeżenie: identyfikator projektu jest unikalny globalnie i po jego wybraniu nie może być używany przez nikogo innego. Jesteś jedynym użytkownikiem tego identyfikatora. Nawet jeśli projekt zostanie usunięty, identyfikator nie będzie już nigdy używany.

Uwaga: jeśli używasz konta Gmail, możesz pozostawić domyślną lokalizację ustawioną na Brak organizacji. Jeśli używasz konta Google Workspace, wybierz lokalizację odpowiednią dla Twojej organizacji.

2. Następnie musisz włączyć płatności w konsoli Cloud, aby korzystać z zasobów i interfejsów API Google Cloud. Ukończenie tego laboratorium nie powinno wiązać się z dużymi kosztami, a nawet z żadnymi. Aby wyłączyć zasoby i uniknąć naliczania opłat po zakończeniu tego samouczka, możesz usunąć utworzone zasoby lub cały 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

W Cloud Shell ustaw identyfikator projektu 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 laboratorium wdrożysz kod w GKE. Jako środowiska IDE będziesz też używać stacji roboczych w chmurze.

Poniższy skrypt konfiguracji przygotuje tę infrastrukturę.

1. Pobierz skrypt konfiguracji i ustaw go jako wykonywalny.

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 edytuj wartości haseł, które są obecnie ustawione na CHANGEME.
3. Uruchom skrypt konfiguracji, aby utworzyć klaster GKE, którego będziesz używać w tym module. Konfiguracja zajmie około 20 minut.

./setup_with_cw.sh &

4. Otwórz Cloud Workstations w Cloud Console. Zanim przejdziesz do następnych kroków, poczekaj, aż klaster osiągnie stan READY.
5. Jeśli sesja Cloud Shell została odłączona, kliknij „Połącz ponownie”, a następnie uruchom polecenie gcloud cli, aby ustawić identyfikator projektu. Przed uruchomieniem polecenia zastąp poniższy przykładowy identyfikator projektu identyfikatorem projektu Qwiklabs.

gcloud config set project qwiklabs-gcp-project-id

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

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 Cloud Console. Sprawdź, czy klaster ma stan 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 stację roboczą. Uruchomienie stacji roboczej może potrwać kilka minut.

2. Zezwól na pliki cookie innych firm, klikając ikonę na pasku adresu.

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

4. Kliknij „Zezwalaj na pliki cookie”.

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

Na stronie Wprowadzenie w środowisku IDE stacji roboczej kliknij „Oznacz jako gotowe”.

3. Omówienie Cloud Code

Zapoznaj się z różnymi sekcjami dostępnymi w Cloud Code.

• Tworzenie aplikacji Kubernetes Uzyskaj w pełni zintegrowane środowisko programowania i debugowania Kubernetes w środowisku IDE. Twórz klastry i zarządzaj nimi bezpośrednio w środowisku IDE.
• Debugowanie działających aplikacji Debuguj kod w środowiskach IDE za pomocą Cloud Code dla VS Code i Cloud Code dla IntelliJ, korzystając z wbudowanych funkcji debugowania IDE.
• Przeglądaj wdrożenia Wyświetlanie zasobów bazowych i metadanych klastrów Kubernetes oraz usług Cloud Run. Możesz pobrać opis, wyświetlić logi, zarządzać obiektami tajnymi lub uzyskać dostęp do terminala bezpośrednio w podzie.
• Uprość lokalne programowanie w Kubernetes. Cloud Code dla środowisk IDE korzysta z popularnych narzędzi, takich jak Skaffold, Jib i kubectl, aby zapewniać ciągłe informacje zwrotne o kodzie w czasie rzeczywistym.

Logowanie się do Google Cloud

1. Kliknij ikonę Cloud Code i wybierz „Zaloguj się w Google Cloud”:

2. Kliknij „Przejdź do logowania”.

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

4. Zaloguj się, używając danych logowania ucznia Qwiklabs.

5. Wybierz „Zezwól”:

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

7. Wklej kod weryfikacyjny i naciśnij Enter.

Jeśli zobaczysz ten komunikat, kliknij przycisk „Zezwól”, aby móc kopiować i wklejać dane na stacji roboczej.

4. Tworzenie nowej aplikacji startowej w Pythonie

W tej sekcji utworzysz nową aplikację w Pythonie.

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ę treść:

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 ten 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 wczytywanie zmian w kodzie aplikacji Flask w języku Python. Ten plik Dockerfile umożliwia przekazywanie tej wartości jako argumentu kompilacji.

Generowanie manifestów

W terminalu wykonaj to polecenie, aby wygenerować domyślne pliki skaffold.yaml i deployment.yaml.

1. Zainicjuj Skaffold za pomocą tego polecenia:

skaffold init --generate-manifests

Gdy pojawi się odpowiedni komunikat, użyj strzałek, aby przesunąć kursor, a spacji, aby wybrać opcje.

Wybierz:

• 8080 dla portu
• y, aby zapisać konfigurację.

Aktualizowanie konfiguracji Skaffold

• Zmiana domyślnej nazwy aplikacji
• Otwórz: skaffold.yaml
• Wybierz nazwę obrazu, która jest obecnie ustawiona jako dockerfile-image.
• Kliknij prawym przyciskiem myszy i wybierz Zmień wszystkie wystąpienia.
• Wpisz nową nazwę w formacie python-app.
• Dalsze edytowanie sekcji kompilacji
• dodaj docker.buildArgs do karty FLASK_DEBUG=1
• Synchronizowanie ustawień w celu wczytania zmian 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'

Modyfikowanie pliku konfiguracyjnego Kubernetes

1. Zmiana domyślnej nazwy

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

5. Omówienie procesu tworzenia

Po dodaniu logiki biznesowej możesz wdrożyć i przetestować aplikację. W sekcji poniżej pokazujemy, jak używać wtyczki Cloud Code. Ta wtyczka jest między innymi zintegrowana z narzędziem Skaffold, aby usprawnić proces tworzenia. Gdy w kolejnych krokach wdrożysz aplikację w GKE, Cloud Code i Skaffold automatycznie skompilują obraz kontenera, wypchną go do Container Registry, a następnie wdrożą aplikację your w GKE. Dzieje się to w sposób niewidoczny, co pozwala deweloperowi skupić się na innych aspektach.

Dodawanie klastra Kubernetes

1. Dodawanie klastra

2. Wybierz Google Kubernetes Engine:

3. Wybierz projekt.

4. Wybierz „python-cluster” utworzony podczas wstępnej konfiguracji.

5. Klaster pojawi się teraz na liście klastrów Kubernetes w Cloud Code. Poruszaj się po klastrze i poznawaj go.

Wdrażanie w Kubernetes

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

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

Jeśli pojawi się taka prośba, wybierz Yes (Tak), aby użyć bieżącego kontekstu Kubernetes.

To polecenie rozpoczyna kompilację kodu źródłowego, a następnie uruchamia testy. Kompilacja i testy potrwają kilka minut. Obejmują one testy jednostkowe i etap weryfikacji, który sprawdza reguły ustawione dla środowiska wdrażania. Ten krok weryfikacji jest już skonfigurowany i zapewnia, że otrzymasz ostrzeżenie o problemach z wdrożeniem, nawet jeśli nadal pracujesz w środowisku programistycznym.

3. Gdy po raz pierwszy uruchomisz to polecenie, u góry ekranu pojawi się pytanie, czy chcesz użyć bieżącego kontekstu Kubernetes. Aby zaakceptować i użyć bieżącego kontekstu, kliknij „Yes” (Tak).
4. Następnie pojawi się pytanie o to, którego repozytorium kontenerów chcesz użyć. Naciśnij Enter, aby zaakceptować podaną wartość domyślną.
5. Aby wyświetlić postęp i powiadomienia, w dolnym panelu kliknij kartę „Dane wyjściowe”. W menu wybierz „Kubernetes: Run/Debug” (Kubernetes: uruchom/debuguj).

6. Aby wyświetlić dodatkowe szczegóły i logi przesyłane strumieniowo na żywo z kontenerów, w menu po prawej stronie wybierz „Kubernetes: Run/Debug - Detailed” (Kubernetes: uruchamianie/debugowanie – szczegółowe).

Po zakończeniu kompilacji i testów w logach na karcie Wynik w widoku „Kubernetes: Run/Debug” (Kubernetes: uruchamianie/debugowanie) pojawi się adres URL http://localhost:8080.

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

Gorące przeładowanie

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

Zauważ, że w oknie Output, w 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 przejdziesz do widoku Kubernetes: Run/Debug - Detailed, zauważysz, że rozpoznaje on zmiany w pliku, a następnie kompiluje i ponownie wdraża 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. Odśwież kartę przeglądarki, na której były wyświetlane poprzednie wyniki, aby zobaczyć zaktualizowane wyniki.

Debugowanie

1. Otwórz widok debugowania i zatrzymaj bieżący wątek . Jeśli pojawi się odpowiednie pytanie, możesz wybrać opcję zwalniania miejsca po każdym uruchomieniu.
2. 
3. Kliknij Cloud Code w menu u dołu i wybierz Debug on Kubernetes, aby uruchomić aplikację w trybie debug.

• W widoku Kubernetes Run/Debug - Detailed okna Output zauważ, że Skaffold wdroży tę aplikację w trybie debugowania.

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

Aby zaakceptować wartość domyślną, naciśnij Enter.

Kompilacja i wdrożenie aplikacji zajmie kilka minut. Jeśli sesja debugowania zostanie rozłączona, ponownie wykonaj czynności opisane w sekcji „Debugowanie w Kubernetes” w sekcji „Sesje deweloperskie”.

5. Po zakończeniu procesu. Zauważysz, że dołączony jest debuger, a na karcie Dane wyjściowe widnieje komunikat Attached debugger to container "python-app-8476f4bbc-h6dsl" successfully. i 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. Dolny pasek stanu zmieni kolor z niebieskiego na pomarańczowy, co oznacza, że jest w trybie debugowania.

7. W widoku Kubernetes Run/Debug zobaczysz, że uruchomiono 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
***********************************

Wykorzystywanie punktów przerwania

1. Otwórz plik app.py.
2. Znajdź zdanie return message
3. Dodaj punkt przerwania do tego wiersza, klikając puste miejsce po lewej stronie numeru wiersza. Pojawi się czerwony wskaźnik, który oznacza, że punkt przerwania został ustawiony.
4. Odśwież przeglądarkę i zwróć uwagę, że debuger zatrzymuje proces w punkcie przerwania i umożliwia zbadanie zmiennych i stanu aplikacji, która jest uruchomiona zdalnie w GKE.
5. Kliknij sekcję ZMIENNE.
6. Kliknij Zmienne lokalne, aby znaleźć zmienną "message".
7. Kliknij dwukrotnie nazwę zmiennej „message” i w wyskakującym okienku zmień wartość na inną, np. "Greetings from Python"
8. W panelu sterowania debugowaniem kliknij przycisk Dalej.
9. Sprawdź odpowiedź w przeglądarce, w której powinna się teraz wyświetlać wpisana przez Ciebie zaktualizowana wartość.
10. Zatrzymaj tryb „Debugowanie”, naciskając przycisk zatrzymania , i usuń punkt przerwania, klikając go ponownie.

6. Czyszczenie

Gratulacje! W tym module udało Ci się utworzyć od podstaw nową aplikację w Pythonie i skonfigurować ją tak, aby skutecznie działała z kontenerami. Następnie wdrożyliśmy i debugowaliśmy aplikację w zdalnym klastrze GKE, korzystając z tego samego przepływu pracy dewelopera, który jest stosowany w tradycyjnych stosach aplikacji.

Aby zwolnić miejsce po ukończeniu modułu:

1. Usuwanie plików użytych w laboratorium

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

2. Usuwanie projektu w celu usunięcia całej powiązanej infrastruktury i zasobów

–

Ostatnia aktualizacja: 22.03.2023