Odblokowywanie Google Cloud Platform za pomocą Pythona: Kompleksowy przewodnik po dostępie do usług GCP

Google Cloud Platform (GCP) oferuje szeroki wachlarz usług do budowy i wdrażania skalowalnych i niezawodnych aplikacji. Python, dzięki swojej przejrzystej składni i obszernym bibliotekom, jest popularnym wyborem do interakcji z GCP. Niniejszy przewodnik zawiera kompleksowy przegląd sposobu korzystania z biblioteki klienta Python w celu uzyskiwania dostępu do usług GCP i zarządzania nimi, skierowany do globalnej publiczności o zróżnicowanym zapleczu technicznym.

Dlaczego warto używać Pythona z GCP?

Python oferuje kilka korzyści podczas interakcji z GCP:

• Łatwość użycia: Czytelna składnia Pythona upraszcza rozwój, ułatwiając naukę i konserwację aplikacji GCP.
• Kompleksowe biblioteki: Google udostępnia dobrze utrzymywaną bibliotekę klienta Python, zaprojektowaną specjalnie dla usług GCP.
• Silne wsparcie społeczności: Duża i aktywna społeczność Python zapewnia bogate zasoby, samouczki i wsparcie dla rozwoju w GCP.
• Automatyzacja i skrypty: Python doskonale sprawdza się w automatyzacji zadań i skryptowaniu zarządzania infrastrukturą, co ma kluczowe znaczenie w środowiskach chmurowych.
• Data Science i uczenie maszynowe: Python jest językiem wyboru dla data science i uczenia maszynowego, które bezproblemowo integrują się z usługami AI/ML GCP.

Konfiguracja środowiska

Zanim zaczniesz, musisz skonfigurować swoje środowisko Python i zainstalować niezbędne biblioteki.

1. Zainstaluj Pythona i Pip

Jeśli nie masz zainstalowanego Pythona, pobierz i zainstaluj najnowszą wersję z oficjalnej strony internetowej Pythona (https://www.python.org/downloads/). Pip, instalator pakietów Pythona, jest zwykle dołączony do instalacji Pythona.

Weryfikacja: Otwórz terminal lub wiersz poleceń i uruchom następujące polecenia:

python --version
pip --version

Polecenia te powinny wyświetlić zainstalowane wersje Pythona i Pip.

2. Zainstaluj bibliotekę klienta Google Cloud dla Pythona

Biblioteka `google-cloud-python` zapewnia dostęp do wszystkich usług GCP. Zainstaluj ją za pomocą Pip:

pip install google-cloud-storage google-cloud-compute google-cloud-pubsub # Przykład - Zainstaluj pakiety storage, compute i pubsub

Zainstaluj tylko specyficzne biblioteki klienta dla usług GCP, z których zamierzasz korzystać. Zmniejsza to rozmiar zależności twojej aplikacji.

Przykład (Cloud Storage): Aby zainstalować bibliotekę klienta Cloud Storage:

pip install google-cloud-storage

3. Skonfiguruj uwierzytelnianie

Uwierzytelnianie ma kluczowe znaczenie dla przyznawania uprawnień twojej aplikacji Python do dostępu do zasobów GCP. Dostępnych jest kilka metod uwierzytelniania:

• Konta usług: Zalecane dla aplikacji działających w GCP (np. Compute Engine, Cloud Functions, Cloud Run).
• Poświadczenia użytkownika: Odpowiednie do lokalnego rozwoju i testowania.

Używanie kont usług (zalecane dla produkcji)

Konta usług to konta nieludzkie, których można używać do uwierzytelniania aplikacji i usług. Zapewniają bezpieczny i kontrolowany sposób przyznawania dostępu do zasobów GCP.

1. Utwórz konto usługi: W Google Cloud Console przejdź do IAM & Admin > Konta usług i kliknij Utwórz konto usługi. Podaj nazwę i opis dla swojego konta usługi.
2. Przyznaj uprawnienia: Przypisz odpowiednie role do swojego konta usługi w oparciu o zasoby GCP, do których twoja aplikacja musi mieć dostęp (np. `roles/storage.objectAdmin` dla pełnej kontroli nad obiektami Cloud Storage).
3. Pobierz klucz konta usługi: Utwórz plik klucza JSON dla swojego konta usługi i pobierz go. Traktuj ten plik klucza z najwyższą ostrożnością, ponieważ przyznaje on dostęp do twoich zasobów GCP. Przechowuj go bezpiecznie i nigdy nie zatwierdzaj go do kontroli wersji.
4. Ustaw zmienną środowiskową `GOOGLE_APPLICATION_CREDENTIALS`: Ustaw zmienną środowiskową `GOOGLE_APPLICATION_CREDENTIALS` na ścieżkę do pobranego pliku klucza JSON.

Przykład (Linux/macOS):

export GOOGLE_APPLICATION_CREDENTIALS="/ścieżka/do/twojego/service-account-key.json"

Przykład (Windows):

set GOOGLE_APPLICATION_CREDENTIALS=C:\ścieżka\do\twojego\service-account-key.json

Ważna informacja o bezpieczeństwie: Unikaj zakodowywania na stałe klucza konta usługi bezpośrednio w swoim kodzie. Używanie zmiennej środowiskowej `GOOGLE_APPLICATION_CREDENTIALS` jest zalecanym podejściem ze względu na bezpieczeństwo i łatwość konserwacji.

Używanie poświadczeń użytkownika (do rozwoju lokalnego)

Do rozwoju lokalnego i testowania możesz użyć własnych poświadczeń użytkownika Google Cloud.

1. Zainstaluj Google Cloud SDK (gcloud): Pobierz i zainstaluj Google Cloud SDK z oficjalnej strony internetowej (https://cloud.google.com/sdk/docs/install).
2. Uwierzytelnij się za pomocą gcloud: Uruchom następujące polecenie w terminalu lub wierszu poleceń:

gcloud auth application-default login

To polecenie otworzy okno przeglądarki, w którym możesz zalogować się na swoje konto Google Cloud i przyznać niezbędne uprawnienia Google Cloud SDK.

Dostęp do usług GCP za pomocą Pythona

Po skonfigurowaniu środowiska i uwierzytelniania możesz zacząć uzyskiwać dostęp do usług GCP za pomocą biblioteki klienta Python. Oto kilka przykładów:

1. Cloud Storage

Cloud Storage zapewnia skalowalną i trwałą pamięć masową obiektów. Możesz użyć biblioteki klienta Python do przesyłania, pobierania i zarządzania obiektami w swoich zasobnikach Cloud Storage.

Przykład: Przesyłanie pliku do Cloud Storage

from google.cloud import storage

# Zastąp nazwą swojego zasobnika i ścieżką pliku
BUCKET_NAME = "nazwa-twojego-zasobnika"
FILE_PATH = "/ścieżka/do/twojego/lokalnego/pliku.txt"
OBJECT_NAME = "zdalne/plik.txt" # Nazwa, jaką plik ma mieć w Cloud Storage

client = storage.Client()
bucket = client.bucket(BUCKET_NAME)
blob = bucket.blob(OBJECT_NAME)
blob.upload_from_filename(FILE_PATH)

print(f"Plik {FILE_PATH} przesłany do gs://{BUCKET_NAME}/{OBJECT_NAME}.")

Wyjaśnienie:

• `from google.cloud import storage`: Importuje moduł Cloud Storage.
• `storage.Client()`: Tworzy obiekt klienta Cloud Storage, używając wcześniej ustawionych poświadczeń uwierzytelniania.
• `client.bucket(BUCKET_NAME)`: Pobiera odniesienie do określonego zasobnika Cloud Storage.
• `bucket.blob(OBJECT_NAME)`: Tworzy blob (obiekt) w zasobniku, o określonej nazwie.
• `blob.upload_from_filename(FILE_PATH)`: Przesyła plik ze ścieżki pliku lokalnego do bloba Cloud Storage.

Przykład: Pobieranie pliku z Cloud Storage

from google.cloud import storage

# Zastąp nazwą swojego zasobnika, nazwą obiektu i lokalną ścieżką pliku
BUCKET_NAME = "nazwa-twojego-zasobnika"
OBJECT_NAME = "zdalne/plik.txt"
FILE_PATH = "/ścieżka/do/twojego/lokalnego/pobranego_pliku.txt"

client = storage.Client()
bucket = client.bucket(BUCKET_NAME)
blob = bucket.blob(OBJECT_NAME)
blob.download_to_filename(FILE_PATH)

print(f"Plik gs://{BUCKET_NAME}/{OBJECT_NAME} pobrany do {FILE_PATH}.")

2. Compute Engine

Compute Engine zapewnia maszyny wirtualne (VM) w GCP. Możesz użyć biblioteki klienta Python do zarządzania instancjami Compute Engine, w tym do ich tworzenia, uruchamiania, zatrzymywania i usuwania.

Przykład: Wyświetlanie listy instancji Compute Engine

from google.cloud import compute_v1

# Zastąp identyfikatorem swojego projektu i strefą
PROJECT_ID = "id-twojego-projektu"
ZONE = "us-central1-a"

client = compute_v1.InstancesClient()

request = compute_v1.ListInstancesRequest(
 project=PROJECT_ID,
 zone=ZONE
)

# Złóż zapytanie
pager = client.list(request=request)

print("Instancje w projekcie i strefie:")
# Obsłuż odpowiedź
for response in pager:
 print(response)

Wyjaśnienie:

• `from google.cloud import compute_v1`: Importuje moduł Compute Engine (wersja v1). Rozważ użycie nowszej wersji, jeśli jest dostępna.
• `compute_v1.InstancesClient()`: Tworzy obiekt klienta Compute Engine.
• `compute_v1.ListInstancesRequest()`: Tworzy żądanie wyświetlenia listy instancji w określonym projekcie i strefie.
• `client.list(request=request)`: Wysyła żądanie do interfejsu API Compute Engine.
• Kod następnie iteruje przez odpowiedź (obiekt pager) i drukuje informacje o każdej instancji.

3. Cloud Functions

Cloud Functions zapewnia bezserwerowe środowiska wykonawcze. Możesz użyć biblioteki klienta Python do wdrażania i zarządzania Cloud Functions.

Przykład: Wdrażanie Cloud Function (Wymaga Google Cloud SDK)

Wdrażanie Cloud Function często wiąże się z bezpośrednim użyciem Google Cloud SDK (gcloud), chociaż do bardziej złożonych scenariuszy można uzyskać dostęp do interfejsu API Cloud Functions za pośrednictwem biblioteki klienta Python. Ten przykład ilustruje podstawowe polecenie wdrażania gcloud. Najpierw utwórz pliki main.py i requirements.txt:

main.py (przykład)

def hello_world(request):
 return 'Witaj, świecie!'

requirements.txt (przykład)

functions-framework

Polecenie wdrażania:

gcloud functions deploy nazwa-twojej-funkcji --runtime python310 --trigger-http --entry-point hello_world

Wyjaśnienie:

• `gcloud functions deploy nazwa-twojej-funkcji`: Wdraża Cloud Function o określonej nazwie. Zastąp `nazwa-twojej-funkcji` żądaną nazwą swojej funkcji.
• `--runtime python310`: Określa środowisko wykonawcze Pythona (np. python310, python311). Wybierz obsługiwane środowisko wykonawcze.
• `--trigger-http`: Konfiguruje funkcję tak, aby była wyzwalana przez żądania HTTP.
• `--entry-point hello_world`: Określa funkcję do wykonania po wyzwoleniu funkcji. Odpowiada to funkcji `hello_world` zdefiniowanej w pliku `main.py`.

4. Cloud Run

Cloud Run umożliwia wdrażanie aplikacj kontenerowych w bezserwerowym środowisku. Możesz zarządzać usługami Cloud Run za pomocą biblioteki klienta Python, ale wdrażanie jest często wykonywane za pomocą Google Cloud SDK lub narzędzi infrastruktury jako kodu, takich jak Terraform.

Przykład: Wdrażanie usługi Cloud Run (Wymaga Google Cloud SDK i Dockera)

Wdrożenia Cloud Run często zaczynają się od pliku Dockerfile.

Dockerfile (przykład):

FROM python:3.10

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . .

CMD ["gunicorn", "--bind", "0.0.0.0:8080", "main:app"]

main.py (przykład) - Minimalna aplikacja Flask

from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello_world():
 return "Witaj ze Cloud Run!"

if __name__ == "__main__":
 app.run(debug=True, host='0.0.0.0', port=8080)

requirements.txt (przykład):

flask
gunicorn

Polecenia wdrażania:

# Zbuduj obraz Dockera
docker build -t gcr.io/id-twojego-projektu/obraz-cloud-run . 

# Prześlij obraz do Google Container Registry
docker push gcr.io/id-twojego-projektu/obraz-cloud-run

# Wdróż usługę Cloud Run
gcloud run deploy twoja-usluga-cloud-run \
 --image gcr.io/id-twojego-projektu/obraz-cloud-run \
 --platform managed \
 --region us-central1 \
 --allow-unauthenticated

Wyjaśnienie:

• `docker build`: Buduje obraz Dockera z pliku Dockerfile. Zastąp `gcr.io/id-twojego-projektu/obraz-cloud-run` żądaną nazwą obrazu i ścieżką do Google Container Registry.
• `docker push`: Przesyła obraz Dockera do Google Container Registry (GCR). Musisz skonfigurować Docker do uwierzytelniania w GCR.
• `gcloud run deploy`: Wdraża usługę Cloud Run.
• `--image`: Określa obraz Dockera, który ma być używany dla usługi.
• `--platform managed`: Określa, że usługa powinna być wdrożona na w pełni zarządzanej platformie Cloud Run.
• `--region`: Określa region, w którym usługa powinna zostać wdrożona.
• `--allow-unauthenticated`: Umożliwia nieuwierzytelniony dostęp do usługi (do celów testowych). W środowisku produkcyjnym należy skonfigurować prawidłowe uwierzytelnianie.

5. Cloud SQL

Cloud SQL zapewnia zarządzane relacyjne bazy danych w GCP. Możesz użyć biblioteki klienta Python (wraz z bibliotekami specyficznymi dla bazy danych, takimi jak `psycopg2` dla PostgreSQL lub `pymysql` dla MySQL) do łączenia się i zarządzania instancjami Cloud SQL.

Przykład: Łączenie się z instancją Cloud SQL PostgreSQL

import psycopg2

# Zastąp nazwą połączenia instancji Cloud SQL, nazwą bazy danych, nazwą użytkownika i hasłem
INSTANCE_CONNECTION_NAME = "id-twojego-projektu:twoj-region:nazwa-twojej-instancji"
DB_NAME = "nazwa_twojej_bazy_danych"
DB_USER = "nazwa_uzytkownika"
DB_PASS = "twoje_haslo"

try:
 conn = psycopg2.connect(
 f"host=/cloudsql/{INSTANCE_CONNECTION_NAME} dbname={DB_NAME} user={DB_USER} password={DB_PASS}"
 )
 print("Pomyślnie połączono z Cloud SQL!")

 # Wykonaj tu operacje na bazie danych (np. wykonaj zapytania)
 cur = conn.cursor()
 cur.execute("SELECT version();")
 db_version = cur.fetchone()
 print(f"Wersja bazy danych: {db_version}")

except Exception as e:
 print(f"Błąd połączenia z Cloud SQL: {e}")

finally:
 if conn:
 cur.close()
 conn.close()
 print("Połączenie zamknięte.")

Wyjaśnienie:

• `import psycopg2`: Importuje bibliotekę `psycopg2`, adapter PostgreSQL dla Pythona. Musisz ją zainstalować za pomocą `pip install psycopg2-binary`.
• `INSTANCE_CONNECTION_NAME`: Jest to kluczowy identyfikator, który określa sposób połączenia z instancją Cloud SQL. Tę wartość można znaleźć w Google Cloud Console w szczegółach instancji Cloud SQL.
• Funkcja `psycopg2.connect()` ustanawia połączenie z bazą danych za pomocą podanych parametrów.
• Kod następnie wykonuje proste zapytanie w celu pobrania wersji bazy danych i drukuje ją na konsoli.
• Blok `finally` zapewnia prawidłowe zamknięcie połączenia z bazą danych, nawet w przypadku wystąpienia błędów.

Najlepsze praktyki dotyczące używania Pythona z GCP

Oto kilka najlepszych praktyk, których należy przestrzegać podczas tworzenia aplikacji GCP za pomocą Pythona:

• Używaj kont usług: Zawsze używaj kont usług do uwierzytelniania, zwłaszcza w środowiskach produkcyjnych. Przyznaj im tylko niezbędne uprawnienia (zasada najmniejszego uprzywilejowania).
• Zarządzaj zależnościami: Użyj pliku `requirements.txt` do zarządzania zależnościami swojej aplikacji. Zapewnia to spójne wdrożenia i upraszcza zarządzanie zależnościami.
• Obsługuj błędy: Zaimplementuj odpowiednią obsługę błędów, aby w sposób elegancki obsługiwać wyjątki i zapobiegać awariom aplikacji. Użyj bloków try-except do przechwytywania potencjalnych błędów i rejestrowania ich w celu debugowania.
• Rejestruj skutecznie: Użyj usługi Cloud Logging GCP do rejestrowania zdarzeń i błędów aplikacji. Zapewnia to cenne informacje o zachowaniu aplikacji i pomaga w rozwiązywaniu problemów.
• Używaj zmiennych środowiskowych: Przechowuj poufne informacje, takie jak klucze API i poświadczenia bazy danych, w zmiennych środowiskowych. Zapobiega to ich zakodowaniu na stałe w kodzie i poprawia bezpieczeństwo.
• Optymalizuj wydajność: Używaj buforowania, operacji asynchronicznych i innych technik optymalizacji, aby poprawić wydajność swoich aplikacji GCP. Rozważ użycie usług GCP, takich jak Cloud CDN do dostarczania treści.
• Monitoruj swoje aplikacje: Użyj usługi Cloud Monitoring GCP do monitorowania stanu i wydajności swoich aplikacji. Skonfiguruj alerty, aby otrzymywać powiadomienia o wszelkich problemach.
• Automatyzuj wdrożenia: Użyj narzędzi infrastruktury jako kodu, takich jak Terraform, lub potoków wdrażania, aby zautomatyzować proces wdrażania. Zapewnia to spójne i powtarzalne wdrożenia.
• Wybierz odpowiednią usługę GCP: Wybierz odpowiednią usługę GCP dla potrzeb swojej aplikacji. Weź pod uwagę takie czynniki, jak skalowalność, koszt i złożoność operacyjna. Na przykład Cloud Functions dobrze nadają się do zadań opartych na zdarzeniach, podczas gdy Cloud Run jest idealny do wdrażania aplikacj kontenerowych.
• Wyczyść zasoby: Pamiętaj, aby oczyścić wszelkie nieużywane zasoby GCP, aby uniknąć ponoszenia niepotrzebnych kosztów.
• Aktualizuj biblioteki: Regularnie aktualizuj swoje biblioteki Pythona, aby korzystać z poprawek błędów, poprawek zabezpieczeń i nowych funkcji. Użyj `pip` do aktualizacji swoich pakietów: `pip install --upgrade `.
• Używaj środowisk wirtualnych: Twórz środowiska wirtualne dla każdego projektu, aby izolować zależności i unikać konfliktów między różnymi projektami.

Kwestie globalne

Podczas tworzenia aplikacji GCP dla globalnej publiczności, weź pod uwagę następujące kwestie:

• Rezydencja danych: Zrozum wymagania dotyczące rezydencji danych dla swoich regionów docelowych. Wybierz regiony GCP, które są zgodne z tymi wymaganiami.
• Opóźnienie: Zminimalizuj opóźnienia, wdrażając swoje aplikacje w regionach, które są geograficznie blisko twoich użytkowników.
• Lokalizacja: Zlokalizuj interfejs użytkownika i zawartość swojej aplikacji dla różnych języków i regionów.
• Waluty i przetwarzanie płatności: Jeśli twoja aplikacja obejmuje transakcje finansowe, upewnij się, że obsługujesz waluty i metody płatności używane w swoich regionach docelowych.
• Zgodność prawna i regulacyjna: Bądź świadomy wymagań prawnych i regulacyjnych w swoich regionach docelowych, takich jak przepisy dotyczące prywatności danych (np. RODO) i kontroli eksportu.
• Strefy czasowe: Obsługuj strefy czasowe poprawnie, aby zapewnić dokładne wyświetlanie dat i godzin w aplikacji dla użytkowników w różnych lokalizacjach. Użyj bibliotek takich jak `pytz` do zarządzania konwersjami stref czasowych.
• Wrażliwość kulturowa: Zwróć uwagę na różnice kulturowe podczas projektowania interfejsu użytkownika i treści swojej aplikacji.

Rozwiązywanie typowych problemów

Oto kilka typowych problemów, które możesz napotkać podczas używania Pythona z GCP i jak je rozwiązać:

• Błędy uwierzytelniania: Sprawdź, czy plik klucza konta usługi jest ważny i czy zmienna środowiskowa `GOOGLE_APPLICATION_CREDENTIALS` jest poprawnie ustawiona. Upewnij się również, że konto usługi ma niezbędne uprawnienia dostępu do zasobów GCP.
• Błędy „Permission Denied”: Sprawdź ponownie role IAM przypisane do konta usługi lub konta użytkownika. Upewnij się, że mają wymagane uprawnienia do operacji, którą próbujesz wykonać.
• Błędy importu: Sprawdź, czy zainstalowałeś niezbędne biblioteki Pythona za pomocą `pip`. Upewnij się, że nazwy bibliotek są poprawne i że używasz właściwej wersji.
• Problemy z łącznością sieciową: Jeśli uruchamiasz aplikację na instancji VM, upewnij się, że VM ma łączność sieciową z Internetem i usługami GCP, do których próbujesz uzyskać dostęp. Sprawdź swoje reguły zapory i konfigurację sieci.
• Limity szybkości API: Interfejsy API GCP mają limity szybkości, aby zapobiec nadużyciom. Jeśli przekraczasz limity szybkości, możesz napotkać błędy. Zaimplementuj wykładniczy wycofanie lub buforowanie, aby zmniejszyć liczbę wywołań API.

Podsumowanie

Python i Google Cloud Platform stanowią potężne połączenie do budowy i wdrażania skalowalnych, niezawodnych i globalnie dostępnych aplikacji. Postępując zgodnie z wytycznymi i najlepszymi praktykami opisanymi w tym przewodniku, możesz skutecznie wykorzystać bibliotekę klienta Python do uzyskiwania dostępu do usług GCP i zarządzania nimi, umożliwiając tworzenie innowacyjnych rozwiązań dla globalnej publiczności.

Pamiętaj, aby zawsze priorytetowo traktować bezpieczeństwo, optymalizować wydajność i brać pod uwagę globalne implikacje swoich aplikacji. Ciągła nauka i eksperymentowanie są kluczem do opanowania sztuki tworzenia chmury za pomocą Pythona w GCP.