Wdrażanie aplikacji internetowej w języku Python Flask w elastycznym środowisku App Engine

Podsumowanie

Z tych ćwiczeń z programowania dowiesz się, jak wdrożyć aplikację internetową w Pythonie Flask w elastycznym środowisku App Engine. Przykładowa aplikacja umożliwia użytkownikowi przesłanie zdjęcia twarzy i sprawdzenie, jak duże jest prawdopodobieństwo, że dana osoba jest szczęśliwa. Aplikacja korzysta z interfejsów API Google Cloud dla usług Vision, Storage i Datastore.

Informacje o App Engine

Aplikacje Google App Engine są łatwe w tworzeniu, utrzymywaniu i skalowaniu w miarę zmian w ruchu i potrzebach związanych z przechowywaniem danych. W przypadku App Engine nie musisz utrzymywać serwerów. Wystarczy przesłać aplikację, aby była gotowa do użycia.

Aplikacje App Engine są automatycznie skalowane na podstawie ruchu przychodzącego. Równoważenie obciążenia, mikrousługi, autoryzacja, bazy danych SQL i NoSQL, dzielenie ruchu, rejestrowanie, wyszukiwanie, wersjonowanie, wdrażanie i wycofywanie zmian oraz skanowanie pod kątem bezpieczeństwa są obsługiwane natywnie i można je w dużym stopniu dostosowywać.

Środowisko elastyczne App Engine obsługuje wszystkie te języki programowania: C#, Go, Java, Node.js, PHP, Python i Ruby. Elastyczne środowisko App Engine uruchamia aplikację w kontenerach Dockera działających na maszynach wirtualnych Google Compute Engine. Standardowe środowisko App Engine to alternatywna opcja dla niektórych języków, w tym Pythona. Standardowe środowisko App Engine uruchamia aplikację w bardziej restrykcyjnym środowisku piaskownicy. Więcej informacji znajdziesz w artykule Wybór środowiska App Engine.

Czego się nauczysz

  • Jak wdrożyć prostą aplikację internetową w elastycznym środowisku App Engine
  • Jak uzyskać dostęp do bibliotek klienta Google Cloud dla usług Vision, Storage i Datastore
  • Jak używać konsoli Google Cloud i pakietu SDK Google Cloud do zarządzania różnymi zasobami w chmurze
  • Jak korzystać z Cloud Shell

Czego potrzebujesz

  • znajomość Pythona,
  • Znajomość standardowych edytorów tekstu systemu Linux, takich jak Vim, Emacs lub Nano

Tworzenie projektu

Jeśli nie masz jeszcze konta Google (Gmail lub Google Apps), musisz je utworzyć. Zaloguj się w konsoli Google Cloud Platform (console.cloud.google.com) i utwórz nowy projekt:

Zapamiętaj identyfikator projektu, czyli unikalną nazwę we wszystkich projektach Google Cloud (podana powyżej nazwa jest już zajęta i nie będzie działać w Twoim przypadku). W dalszej części tych ćwiczeń z programowania będzie on nazywany PROJECT_ID.

Płatności

Następnie musisz włączyć płatności w konsoli Cloud, aby móc korzystać z zasobów Google Cloud.

Wykonanie tego samouczka nie powinno kosztować więcej niż kilka dolarów, ale może okazać się droższe, jeśli zdecydujesz się wykorzystać więcej zasobów lub pozostawisz je uruchomione.

Nowi użytkownicy Google Cloud Platform mogą skorzystać z bezpłatnego okresu próbnego, w którym mają do dyspozycji środki w wysokości 300 USD.

Google Cloud można obsługiwać zdalnie z laptopa, ale w tym module praktycznym będziemy używać Google Cloud Shell, czyli środowiska wiersza poleceń działającego w chmurze. Ta maszyna wirtualna oparta na Debianie zawiera wszystkie potrzebne narzędzia dla programistów (gcloud, python, virtualenv, pip i inne), oferuje trwały katalog domowy o pojemności 5 GB i działa w Google Cloud, co znacznie zwiększa wydajność sieci i uwierzytelniania. Oznacza to, że do ukończenia tego ćwiczenia potrzebujesz tylko przeglądarki (tak, działa ona na Chromebooku).

Aby aktywować Google Cloud Shell, w konsoli dewelopera kliknij przycisk w prawym górnym rogu (przygotowanie środowiska i połączenie z nim zajmie tylko kilka sekund):

Po połączeniu z Cloud Shell powinna pojawić się informacja, że użytkownik jest już uwierzytelniony, a projekt jest już ustawiony na PROJECT_ID:

gcloud auth list
Credentialed accounts:
- <myaccount>@<mydomain>.com (active)
 
gcloud config list project
[core]
Project = <PROJECT_ID>

Jeśli z jakiegoś powodu projekt nie jest ustawiony, po prostu wydaj to polecenie:

gcloud config set project <PROJECT_ID>

Szukasz PROJECT_ID? Sprawdź, jakiego identyfikatora projektu użyto w krokach konfiguracji, lub wyszukaj go w panelu konsoli:

Aby sklonować repozytorium GitHub, w Cloud Shell uruchom to polecenie:

git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git

Przejdź do katalogu python-docs-samples/codelabs/flex_and_vision:

cd python-docs-samples/codelabs/flex_and_vision

Zanim zaczniesz korzystać z interfejsów Vision API, Storage API i Datastore API, musisz je włączyć za pomocą tych poleceń:

gcloud services enable vision.googleapis.com
 
gcloud services enable storage-component.googleapis.com
 
gcloud services enable datastore.googleapis.com

Aby wysyłać żądania do interfejsów Vision API, Storage API i Datastore API, potrzebujesz danych logowania na konto usługi. Dane logowania konta usługi z Twojego projektu możesz wygenerować za pomocą narzędzia gcloud.

Ustaw zmienną środowiskową dla parametru PROJECT_ID, zastępując [YOUR_PROJECT_ID] identyfikatorem projektu:

export PROJECT_ID=[YOUR_PROJECT_ID]

Utwórz konto usługi, aby uzyskać dostęp do interfejsów Google Cloud API podczas testowania lokalnego:

gcloud iam service-accounts create codelab \
  --display-name "My Codelab Service Account"

Przyznaj nowo utworzonemu kontu usługi odpowiednie uprawnienia:

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
--member serviceAccount:codelab@${PROJECT_ID}.iam.gserviceaccount.com \
--role roles/owner

Po utworzeniu konta usługi utwórz klucz konta usługi:

gcloud iam service-accounts keys create ~/key.json \
--iam-account codelab@${PROJECT_ID}.iam.gserviceaccount.com

To polecenie generuje klucz konta usługi przechowywany w pliku JSON o nazwie key.json w katalogu domowym.

Ustaw zmienną środowiskową dla klucza konta usługi w Cloud Shell, używając ścieżki bezwzględnej wygenerowanego klucza:

export GOOGLE_APPLICATION_CREDENTIALS="/home/${USER}/key.json"

Więcej informacji o uwierzytelnianiu interfejsu Vision API

Uruchamianie środowiska wirtualnego i instalowanie zależności

Utwórz izolowane środowisko Pythona 3 o nazwie env za pomocą narzędzia virtualenv:

virtualenv -p python3 env

Otwórz nowo utworzone środowisko virtualenv o nazwie env:

source env/bin/activate

Użyj narzędzia pip, aby zainstalować zależności projektu z pliku requirements.txt:

pip install -r requirements.txt

Plik requirements.txt to lista zależności pakietów potrzebnych w projekcie. Powyższe polecenie pobrało wszystkie wymienione zależności pakietów do virtualenv.

Tworzenie aplikacji App Engine

Następnie utwórz instancję App Engine, używając tego polecenia:

gcloud app create

Tworzenie zasobnika na dane

Najpierw ustaw zmienną środowiskową CLOUD_STORAGE_BUCKET na nazwę IDENTYFIKATORA_PROJEKTU. (Z wygody zaleca się nadanie zasobnikowi nazwy takiej samej jak PROJECT_ID).

export CLOUD_STORAGE_BUCKET=${PROJECT_ID}

Nasza aplikacja korzysta z zasobnika Cloud Storage, który musisz utworzyć w Cloud Shell za pomocą narzędzia gsutil. Uruchom to polecenie, aby utworzyć zasobnik o nazwie takiej samej jak PROJECT_ID.

gsutil mb gs://${PROJECT_ID}

Uruchamianie aplikacji

python main.py

Po uruchomieniu aplikacji kliknij ikonę podglądu w przeglądarce  na pasku narzędzi Cloud Shell i wybierz „Podejrzyj na porcie 8080”.

W przeglądarce otworzy się karta, która połączy się z uruchomionym serwerem. Powinien pojawić się ekran podobny do tego:

Screen Shot 2017-02-23 at 7.22.50 PM.png

Spróbuj przesłać zdjęcie, na którym widać ludzką twarz. Kliknij przycisk Wybierz plik, wybierz obraz z komputera, a potem kliknij Prześlij.

Po przesłaniu zdjęcia powinien pojawić się ekran podobny do tego:

Screen Shot 2017-02-23 at 7.32.08 PM.png

Układ przykładowego kodu

Przykładowy plik ma następujący układ:

templates/
  homepage.html   /* HTML template that uses Jinja2 */
app.yaml          /* App Engine application configuration file */
main.py           /* Python Flask web application */
requirements.txt  /* List of dependencies for the project */

main.py

Ten plik w języku Python to aplikacja internetowa Flask. Aplikacja umożliwia użytkownikom przesyłanie zdjęć (najlepiej twarzy), które są przechowywane w Cloud Storage i analizowane za pomocą funkcji wykrywania twarzy w interfejsie Cloud Vision API. Kluczowe informacje o każdym zdjęciu są przechowywane w Datastore, bazie danych NoSQL na platformie Google Cloud, do której dostęp jest uzyskiwany za każdym razem, gdy użytkownik odwiedza witrynę.

Ta aplikacja korzysta z bibliotek klienta Google Cloud Platform dla usług Storage, Datastore i Vision. Te biblioteki klienta ułatwiają dostęp do interfejsów API Cloud w ulubionych językach programowania.

Przyjrzyjmy się najważniejszym fragmentom kodu.

Sekcja importów u góry służy do importowania różnych pakietów potrzebnych w naszym kodzie. Oto sposób importowania bibliotek klienta Google Cloud dla Datastore, Storage i Vision:

from google.cloud import datastore
from google.cloud import storage
from google.cloud import vision

Oto kod opisujący, co się dzieje, gdy użytkownik odwiedza główny adres URL witryny. Tworzymy obiekt klienta Datastore, który służy do uzyskiwania dostępu do biblioteki klienta Datastore. Następnie wysyłamy do Datastore zapytanie o encje typu Faces (Twarze). Na koniec renderujemy szablon HTML, przekazując wyodrębnione z Datastore image_entities jako zmienną.

@app.route('/')
def homepage():
    # Create a Cloud Datastore client.
    datastore_client = datastore.Client()

    # Use the Cloud Datastore client to fetch information from Datastore about
    # each photo.
    query = datastore_client.query(kind='Faces')
    image_entities = list(query.fetch())

    # Return a Jinja2 HTML template and pass in image_entities as a parameter.
    return render_template('homepage.html', image_entities=image_entities)

Przyjrzyjmy się, jak encje są zapisywane w Datastore. Datastore to rozwiązanie Google Cloud do obsługi baz danych NoSQL. Dane są przechowywane w obiektach zwanych encjami. Każdemu elementowi przypisywany jest unikalny klucz, który można utworzyć za pomocą rodzaju i ciągu znaków nazwy klucza. Rodzaj to kategoria organizacyjna określająca typ encji. Możemy na przykład skonfigurować rodzaje dla zdjęć, osób i zwierząt.

Każdy obiekt może mieć wiele zdefiniowanych przez dewelopera właściwości, które mogą mieć wartości różnych typów, w tym liczby całkowite, liczby zmiennoprzecinkowe, ciągi znaków, daty lub dane binarne.

    # Create a Cloud Datastore client.
    datastore_client = datastore.Client()

    # Fetch the current date / time.
    current_datetime = datetime.now()

    # The kind for the new entity.
    kind = 'Faces'

    # The name/ID for the new entity.
    name = blob.name

    # Create the Cloud Datastore key for the new entity.
    key = datastore_client.key(kind, name)

    # Construct the new entity using the key. Set dictionary values for entity
    # keys blob_name, storage_public_url, timestamp, and joy.
    entity = datastore.Entity(key)
    entity['blob_name'] = blob.name
    entity['image_public_url'] = blob.public_url
    entity['timestamp'] = current_datetime
    entity['joy'] = face_joy

    # Save the new entity to Datastore.
    datastore_client.put(entity)

Do bibliotek klienta Storage i Vision można uzyskać dostęp w sposób programowy, podobnie jak w przypadku Datastore. Możesz samodzielnie otworzyć plik main.py za pomocą edytora vim, emacs lub nano, aby zapoznać się z całym przykładowym kodem.

Więcej informacji o Flask znajdziesz na stronie http://flask.pocoo.org/.

Więcej informacji o bibliotekach klienta znajdziesz na stronie https://googlecloudplatform.github.io/google-cloud-python/.

homepage.html

Platforma programistyczna Flask korzysta z Jinja2 jako silnika szablonów. Dzięki temu możemy przekazywać zmienne i wyrażenia z pliku main.py do pliku homepage.html, które po wyrenderowaniu strony zostaną zastąpione wartościami.

Więcej informacji o Jinja2 znajdziesz na stronie http://jinja.pocoo.org/docs/2.9/templates/.

Ten szablon HTML Jinja2 wyświetla formularz, za pomocą którego użytkownicy mogą przesyłać zdjęcia do bazy danych. Wyświetla też każde przesłane wcześniej zdjęcie wraz z nazwą pliku, datą i godziną przesłania oraz prawdopodobieństwem, że twarz wykryta przez interfejs Vision API jest uśmiechnięta.

homepage.html

<h1>Google Cloud Platform - Face Detection Sample</h1>

<p>This Python Flask application demonstrates App Engine Flexible, Google Cloud
Storage, Datastore, and the Cloud Vision API.</p>

<br>

<html>
  <body>
    <form action="upload_photo" method="POST" enctype="multipart/form-data">
      Upload File: <input type="file" name="file"><br>
      <input type="submit" name="submit" value="Submit">
    </form>
    
  </body>
</html>

Środowisko elastyczne App Engine używa pliku o nazwie app.yaml do opisywania konfiguracji wdrożenia aplikacji. Jeśli tego pliku nie ma, App Engine spróbuje odgadnąć konfigurację wdrożenia. Warto jednak przesłać ten plik.

Następnie zmodyfikuj plik app.yaml za pomocą wybranego edytora vim, nano lub emacs. Użyjemy edytora nano:

nano app.yaml

app.yaml

runtime: python
env: flex
entrypoint: gunicorn -b :$PORT main:app

runtime_config:
    python_version: 3

env_variables:
    CLOUD_STORAGE_BUCKET: <your-cloud-storage-bucket>

Jest to podstawowa konfiguracja potrzebna do wdrożenia aplikacji App Engine Flex w Pythonie 3. Więcej informacji o konfigurowaniu App Engine znajdziesz tutaj.

Po otwarciu pliku app.yaml zastąp fragment < your-cloud-storage-bucket > nazwą zasobnika Cloud Storage. (Jeśli nie pamiętasz nazwy zasobnika Cloud Storage, skopiuj identyfikator projektu GCP z Qwiklabs, który jest taki sam). Sekcja env_variables konfiguruje zmienne środowiskowe, które będą używane w pliku main.py po wdrożeniu aplikacji.

Możesz teraz zapisać i zamknąć plik w nano, używając skrótu Ctrl + x. Pojawi się wtedy pytanie:

Screen Shot 2017-02-17 at 4.47.12 PM.png

Wpisz literę y, a następnie naciśnij klawisz ENTER jeszcze raz, aby potwierdzić nazwę pliku w odpowiedzi na następujący monit:

Screen Shot 2017-02-24 at 4.18.23 PM.png

Wdróż aplikację w App Engine za pomocą polecenia gcloud:

gcloud app deploy

Po wdrożeniu aplikacji możesz ją otworzyć, wpisując w przeglądarce adres URL https://< PROJECT_ID >.appspot.com.

Podsumowanie

W tym kroku skonfigurujesz aplikację internetową w Pythonie i wdrożysz ją w elastycznym środowisku App Engine.

Wiesz już, jak napisać i wdrożyć pierwszą aplikację internetową w środowisku elastycznym App Engine.

Czyszczenie

Oto kroki, które musisz wykonać, aby uniknąć obciążenia konta Google Cloud Platform opłatami za zasoby zużyte podczas krótkiego wprowadzenia:

  • Otwórz konsolę Cloud Platform.
  • Wybierz projekt, który chcesz zamknąć, a potem kliknij „Usuń” u góry. Spowoduje to zaplanowanie usunięcia projektu.

Więcej informacji

Licencja

To zadanie jest licencjonowane na podstawie ogólnej licencji Creative Commons Attribution 2.0.