Jak korzystać z kolejki zadań App Engine (zadania pull) w aplikacjach Flask (moduł 18)

1. Omówienie

Seria ćwiczeń z programowania dla bezserwerowych stacji migracji (samouczek, samouczków) i podobnych filmów ma pomóc deweloperom bezserwerowych Google Cloud w modernizacji aplikacji przez przeprowadzenie co najmniej 1 migracji, w wyniku rezygnacji ze starszych usług. W ten sposób Twoje aplikacje stają się bardziej przenośne, mają więcej opcji i elastyczność, co pozwala na integrację z szerszą gamą usług Cloud i uzyskiwanie do nich dostępu, a także łatwiejsze przejście na nowsze wersje językowe. Choć początkowo koncentrowaliśmy się na pierwszych użytkownikach Cloud, głównie deweloperów korzystających ze środowiska App Engine (środowisko standardowe), ta seria jest na tyle szeroka, aby uwzględnić inne platformy bezserwerowe, takie jak Cloud Functions i Cloud Run, oraz inne, w stosownych przypadkach.

Dzięki temu ćwiczeniu w Codelabs dowiesz się, jak uwzględnić zadania pull kolejki zadań w App Engine i jak ich używać w przykładowej aplikacji z Modułu 1. Sposób wykorzystania zadań pull dodajemy w tym samouczku w module 18, a następnie przenosimy to wykorzystanie do Cloud Pub/Sub w module 19. Użytkownicy korzystający z kolejek zadań do wykonywania zadań push zamiast tego zostaną przeniesieni do Cloud Tasks i powinni zapoznać się z modułami 7–9.

Dowiesz się, jak:

  • Używanie interfejsu App Engine Task Queue API/usługi pakietu
  • Dodawanie użycia kolejki pull do podstawowej aplikacji w języku Python 2 Flask NDB w języku App Engine

Czego potrzebujesz

Ankieta

Jak wykorzystasz ten samouczek?

Tylko do przeczytania Przeczytaj go i wykonaj ćwiczenia

Jak oceniasz swoje doświadczenia z językiem Python?

Początkujący Poziom średnio zaawansowany Biegły

Jak oceniasz korzystanie z usług Google Cloud?

Początkujący Poziom średnio zaawansowany Biegły .

2. Tło

Aby przeprowadzić migrację z zadań pull kolejki zadań App Engine, dodaj informacje o ich wykorzystaniu do dotychczasowej aplikacji Flask i App Engine NDB uzyskanej w ramach modułu 1 Codelabs. Przykładowa aplikacja wyświetla ostatnie wizyty użytkownika. To nie problem, ale jeszcze ciekawsze jest też śledzenie użytkowników, którzy odwiedzają ich najwięcej.

Przy użyciu zadań push do liczenia takich użytkowników możemy jednak rozdzielić odpowiedzialność między przykładową aplikację, której zadaniem jest rejestrowanie wizyt i natychmiastowe udzielanie odpowiedzi użytkownikom, oraz wyznaczonego „pracownika”. której zadaniem jest zliczanie liczby użytkowników poza normalnym przepływem pracy żądanie-odpowiedź.

Aby wdrożyć ten interfejs, dodajemy do głównej aplikacji kolejki pull oraz wspomagamy funkcje instancji roboczych. Instancja robocza może działać jako osobny proces (np. instancja backendu lub kod na maszynie wirtualnej, która zawsze działa), zadanie cron lub podstawowe żądanie HTTP z wiersza poleceń za pomocą interfejsu curl lub wget. Po zakończeniu integracji możesz przenieść aplikację do Cloud Pub/Sub w kolejnym ćwiczeniu z programowania (Moduł 19).

W tym samouczku omawiamy następujące kroki:

  1. Konfiguracja/praca
  2. Aktualizacja konfiguracji
  3. Modyfikowanie kodu aplikacji

3. Konfiguracja/praca

W tej sekcji dowiesz się, jak:

  1. Konfigurowanie projektu Cloud
  2. Pobierz przykładową aplikację bazową
  3. (Ponowne) wdrażanie i weryfikowanie aplikacji bazowej

Dzięki tym krokom zaczynasz od działającego kodu.

1. Konfigurowanie projektu

Jeśli masz już za sobą Moduł 1 z programowania, wykorzystaj ponownie ten sam projekt (i kod). Możesz też utworzyć nowy projekt lub wykorzystać inny istniejący projekt. Sprawdź, czy projekt ma aktywne konto rozliczeniowe i włączoną aplikację App Engine. Znajdź identyfikator projektu, ponieważ będziesz go potrzebować kilka razy w tym ćwiczeniu z programowania. Użyj go za każdym razem, gdy napotkasz zmienną PROJECT_ID.

2. Pobierz przykładową aplikację bazową

Jednym z warunków wstępnych tego ćwiczenia z programowania jest posiadanie działającej aplikacji App Engine z modułu 1. Ukończ ćwiczenie z programowania w module 1 (zalecane) lub skopiuj aplikację w module 1 z repozytorium. Bez względu na to, czy używasz swojego czy naszego, „ROZPOCZNIJ” kod Modułu 1. To ćwiczenie w Codelabs przeprowadzi Cię przez poszczególne kroki, kończąc kodem przypominającym zawartość folderu repozytorium modułu 18 „FINISH”.

Niezależnie od tego, której aplikacji w module 1 używasz, folder powinien wyglądać tak jak poniższe dane wyjściowe, np. wraz z folderem lib:

$ ls
README.md               appengine_config.py     requirements.txt
app.yaml                main.py                 templates

3. (Ponowne) wdrażanie aplikacji podstawowej

Aby wdrożyć aplikację modułu 1, wykonaj te czynności:

  1. Usuń folder lib (jeśli istnieje), a następnie uruchom polecenie pip install -t lib -r requirements.txt, aby ponownie uzupełnić dane lib. Jeśli masz zainstalowany język Python 2 i 3, może być konieczne użycie polecenia pip2.
  2. Upewnij się, że narzędzie wiersza poleceń gcloud zostało zainstalowane i zainicjowane, a także sprawdzisz jego użycie.
  3. Jeśli nie chcesz wpisywać PROJECT_ID w projekcie Cloud z każdym wydanym poleceniem gcloud, ustaw w nim gcloud config set project PROJECT_ID.
  4. Wdróż przykładową aplikację za pomocą: gcloud app deploy
  5. Potwierdź, że aplikacja w module 1 działa zgodnie z oczekiwaniami i wyświetla ostatnie wizyty (poniżej).

a7a9d2b80d706a2b.png

4. Aktualizacja konfiguracji

W standardowych plikach konfiguracji App Engine (app.yaml, requirements.txt, appengine_config.py) nie musisz wprowadzać żadnych zmian. Zamiast tego dodaj nowy plik konfiguracji queue.yaml z następującą zawartością i umieść go w tym samym katalogu najwyższego poziomu:

queue:
- name: pullq
  mode: pull

Plik queue.yaml określa wszystkie kolejki zadań istniejące dla aplikacji (z wyjątkiem kolejki [push] default tworzonej automatycznie przez App Engine). W tym przypadku istnieje tylko jedna kolejka pull o nazwie pullq. App Engine wymaga określenia dyrektywy mode jako pull. W przeciwnym razie domyślnie tworzy się kolejkę push. Więcej informacji o tworzeniu kolejek pull znajdziesz w dokumentacji. Inne opcje znajdziesz na stronie z dokumentacją queue.yaml.

Wdróż ten plik niezależnie od aplikacji. Nadal będziesz używać polecenia gcloud app deploy, ale dodatkowo użyjesz narzędzia queue.yaml w wierszu poleceń:

$ gcloud app deploy queue.yaml
Configurations to update:

descriptor:      [/tmp/mod18-gaepull/queue.yaml]
type:            [task queues]
target project:  [my-project]

WARNING: Caution: You are updating queue configuration. This will override any changes performed using 'gcloud tasks'. More details at
https://cloud.google.com/tasks/docs/queue-yaml

Do you want to continue (Y/n)?

Updating config [queue]...⠹WARNING: We are using the App Engine app location (us-central1) as the default location. Please use the "--location" flag if you want to use a different location.
Updating config [queue]...done.

Task queues have been updated.

Visit the Cloud Platform Console Task Queues page to view your queues and cron jobs.
$

5. Modyfikowanie kodu aplikacji

W tej sekcji znajdziesz informacje o aktualizacjach tych plików:

  • main.py – dodaj użycie kolejek pull do głównej aplikacji
  • templates/index.html – zaktualizuj szablon internetowy, aby wyświetlał nowe dane

Importy i stałe

Pierwszym krokiem jest dodanie jednego nowego importu i kilku stałych do obsługi kolejek pull:

  • Dodaj import z biblioteki kolejki zadań google.appengine.api.taskqueue.
  • Dodaj 3 stałe, aby umożliwić dzierżawie maksymalnej liczby zadań pull (TASKS) na godzinę (HOUR) z kolejki pull (QUEUE).
  • Dodaj stałą dla wyświetlania ostatnich i najpopularniejszych użytkowników (LIMIT).

Poniżej znajduje się oryginalny kod i wygląd po wprowadzeniu zmian:

PRZED:

from flask import Flask, render_template, request
from google.appengine.ext import ndb

app = Flask(__name__)

PO:

from flask import Flask, render_template, request
from google.appengine.api import taskqueue
from google.appengine.ext import ndb

HOUR = 3600
LIMIT = 10
TASKS = 1000
QNAME = 'pullq'
QUEUE = taskqueue.Queue(QNAME)
app = Flask(__name__)

Dodawanie zadania pull (zbieranie danych do zadania i tworzenie zadania w kolejce pull)

Model danych Visit pozostaje bez zmian, podobnie jak zapytania o wizyty w tabeli fetch_visits(). W tej części kodu wymagana jest jedynie zmiana w polu store_visit(). Oprócz zarejestrowania wizyty dodaj do kolejki pull zadanie z adresem IP użytkownika, aby instancja robocza mogła zwiększyć licznik odwiedzających.

PRZED:

class Visit(ndb.Model):
    'Visit entity registers visitor IP address & timestamp'
    visitor   = ndb.StringProperty()
    timestamp = ndb.DateTimeProperty(auto_now_add=True)

def store_visit(remote_addr, user_agent):
    'create new Visit entity in Datastore'
    Visit(visitor='{}: {}'.format(remote_addr, user_agent)).put()

def fetch_visits(limit):
    'get most recent visits'
    return Visit.query().order(-Visit.timestamp).fetch(limit)

PO:

class Visit(ndb.Model):
    'Visit entity registers visitor IP address & timestamp'
    visitor   = ndb.StringProperty()
    timestamp = ndb.DateTimeProperty(auto_now_add=True)

def store_visit(remote_addr, user_agent):
    'create new Visit in Datastore and queue request to bump visitor count'
    Visit(visitor='{}: {}'.format(remote_addr, user_agent)).put()
    QUEUE.add(taskqueue.Task(payload=remote_addr, method='PULL'))

def fetch_visits(limit):
    'get most recent visits'
    return Visit.query().order(-Visit.timestamp).fetch(limit)

Utworzenie modelu danych i funkcji zapytań do śledzenia użytkowników

Dodaj model danych VisitorCount, aby śledzić użytkowników. powinien zawierać pola dla samego visitor oraz liczbę całkowitą counter do śledzenia liczby wizyt. Następnie dodaj nową funkcję (alternatywnie może to być język Python classmethod) o nazwie fetch_counts(), aby wysyłać zapytania dotyczące najczęstszych użytkowników i wyświetlać je w kolejności od największej do najmniejszej. Dodaj klasę i funkcję tuż pod treścią fetch_visits():

class VisitorCount(ndb.Model):
    visitor = ndb.StringProperty(repeated=False, required=True)
    counter = ndb.IntegerProperty()

def fetch_counts(limit):
    'get top visitors'
    return VisitCount.query().order(-VisitCount.counter).fetch(limit)

Dodaj kod instancji roboczej

Dodaj nową funkcję log_visitors(), aby rejestrować użytkowników za pomocą żądania GET dla metody /log. Wykorzystuje słownik/hasz do śledzenia ostatniej liczby użytkowników i wynajmuje jak najwięcej zadań na godzinę. W przypadku każdego zadania zlicza wszystkie wizyty tego samego użytkownika. Aplikacja aktualizuje wszystkie odpowiednie encje VisitorCount już w Datastore lub w razie potrzeby tworzy nowe encje. Ostatni krok powoduje wyświetlenie zwykłego tekstu, który wskazuje, ilu użytkowników zostało zarejestrowanych z liczby przetworzonych zadań. Dodaj tę funkcję do main.py tuż pod fetch_counts():

@app.route('/log')
def log_visitors():
    'worker processes recent visitor counts and updates them in Datastore'
    # tally recent visitor counts from queue then delete those tasks
    tallies = {}
    tasks = QUEUE.lease_tasks(HOUR, TASKS)
    for task in tasks:
        visitor = task.payload
        tallies[visitor] = tallies.get(visitor, 0) + 1
    if tasks:
        QUEUE.delete_tasks(tasks)

    # increment those counts in Datastore and return
    for visitor in tallies:
        counter = VisitorCount.query(VisitorCount.visitor == visitor).get()
        if not counter:
            counter = VisitorCount(visitor=visitor, counter=0)
            counter.put()
        counter.counter += tallies[visitor]
        counter.put()
    return 'DONE (with %d task[s] logging %d visitor[s])\r\n' % (
            len(tasks), len(tallies))

Zaktualizuj główny moduł obsługi, dodając nowe dane wyświetlania

Aby wyświetlić najważniejszych użytkowników, zaktualizuj główny moduł obsługi root() tak, aby wywoływał fetch_counts(). Ponadto szablon zostanie zaktualizowany tak, aby wyświetlać liczbę najlepszych i ostatnich wizyt. Pogrupuj liczbę użytkowników wraz z ostatnimi wizytami (od wywołania do fetch_visits()) i upuść ją w jednym elemencie context, aby przekazać go do szablonu internetowego. Poniżej znajduje się kod zarówno przed, jak i po wprowadzeniu tej zmiany:

PRZED:

@app.route('/')
def root():
    'main application (GET) handler'
    store_visit(request.remote_addr, request.user_agent)
    visits = fetch_visits(10)
    return render_template('index.html', visits=visits)

PO:

@app.route('/')
def root():
    'main application (GET) handler'
    store_visit(request.remote_addr, request.user_agent)
    context = {
        'limit':  LIMIT,
        'visits': fetch_visits(LIMIT),
        'counts': fetch_counts(LIMIT),
    }
    return render_template('index.html', **context)

To wszystkie zmiany wymagane w usłudze main.py. Oto obrazowy schemat tych zmian, który ma charakter poglądowy. Pozwoli Ci to uzyskać ogólne pojęcie o zmianach wprowadzanych w usłudze main.py:

ad5fd3345efc13d0.png

Zaktualizuj szablon internetowy, dodając nowe dane wyświetlania

Szablon internetowy templates/index.html wymaga aktualizacji, tak aby oprócz zwykłego ładunku najnowszych użytkowników wyświetlała się największa liczba użytkowników. Upuść najlepszych użytkowników i ich liczby w tabeli u góry strony i kontynuuj renderowanie ostatnich odwiedzin tak jak do tej pory. Jedyna inna zmiana polega na podaniu liczby wyświetlanej w zmiennej limit, a nie na wpisaniu numeru na stałe. Oto zmiany, które musisz wprowadzić w szablonie internetowym:

PRZED:

<!doctype html>
<html>
<head>
<title>VisitMe Example</title>
<body>

<h1>VisitMe example</h1>
<h3>Last 10 visits</h3>
<ul>
{% for visit in visits %}
    <li>{{ visit.timestamp.ctime() }} from {{ visit.visitor }}</li>
{% endfor %}
</ul>

PO:

<!doctype html>
<html>
<head>
<title>VisitMe Example</title>
<body>

<h1>VisitMe example</h1>

<h3>Top {{ limit }} visitors</h3>
<table border=1 cellspacing=0 cellpadding=2>
    <tr><th>Visitor</th><th>Visits</th></tr>
{% for count in counts %}
    <tr><td>{{ count.visitor|e }}</td><td align="center">{{ count.counter }}</td></tr>
{% endfor %}
</table>

<h3>Last {{ limit }} visits</h3>
<ul>
{% for visit in visits %}
    <li>{{ visit.timestamp.ctime() }} from {{ visit.visitor }}</li>
{% endfor %}
</ul>

To już koniec niezbędnych zmian, dzięki którym do przykładowej aplikacji w module 1 dodaliśmy wykorzystanie zadań pull kolejki zadań App Engine. Twój katalog reprezentuje teraz przykładową aplikację w module 18 i powinien zawierać te pliki:

$ ls
README.md               appengine_config.py     queue.yaml              templates
app.yaml                main.py                 requirements.txt

6. Podsumowanie/Czyszczenie

W tej sekcji znajdziesz podsumowanie tego ćwiczenia w programie przez wdrożenie aplikacji oraz sprawdzenie, czy działa ona zgodnie z oczekiwaniami i we wszystkich uwzględnionych danych wyjściowych. Uruchom instancję roboczą oddzielnie, aby przetworzyć liczbę użytkowników. Po sprawdzeniu aplikacji wykonaj czynności związane z czyszczeniem i zastanów się nad dalszymi czynnościami.

Wdróż i zweryfikuj aplikację

Sprawdź, czy kolejka pull jest już skonfigurowana, tak jak w pierwszym kroku tego ćwiczenia z programowania w gcloud app deploy queue.yaml. Jeśli przykładowa aplikacja jest gotowa do użycia, wdróż ją za pomocą gcloud app deploy. Dane wyjściowe powinny być takie same jak w przypadku aplikacji z Modułu 1, ale teraz zawierają dane „najwięksi użytkownicy” u góry:

b667551dcbab1a09.png

W zaktualizowanym interfejsie internetowym wyświetlane są informacje o największych i najnowszych wizytach, jednak liczebność użytkowników nie uwzględnia tej wizyty. Aplikacja wyświetla liczbę poprzednich użytkowników, jednocześnie pomijając nowe zadanie, zwiększając liczbę tych użytkowników w kolejce pull, czyli zadanie, które oczekuje na przetworzenie.

Możesz to zrobić, wywołując funkcję /log na kilka sposobów:

Jeśli na przykład używasz curl do wysyłania żądania GET do /log, dane wyjściowe będą wyglądać tak przy podanej wartości PROJECT_ID:

$ curl https://PROJECT_ID.appspot.com/log
DONE (with 1 task[s] logging 1 visitor[s])

Zaktualizowana liczba zostanie uwzględniona podczas następnej wizyty w witrynie. Znakomicie.

Gratulujemy ukończenia tego ćwiczenia z programowania. Udało Ci się dodać usługę kolejki pull kolejki zadań App Engine do przykładowej aplikacji. Możesz teraz przeprowadzić migrację do Cloud Pub/Sub, Cloud NDB i Pythona 3 w module 19.

Czyszczenie danych

Ogólne

Jeśli na razie wszystko jest gotowe, wyłącz aplikację App Engine, aby uniknąć naliczania opłat. Jeśli jednak chcesz jeszcze bardziej przetestować lub poeksperymentować, platforma App Engine ma bezpłatny limit. Dopóki nie przekroczysz tego limitu, nie pobierzemy żadnych opłat. Oznacza to obliczenia, ale mogą być też naliczane opłaty za odpowiednie usługi App Engine. Więcej informacji znajdziesz na stronie z cennikiem. Jeśli ta migracja obejmuje inne usługi Cloud, są one rozliczane osobno. W obu przypadkach zapoznaj się z sekcją „Zapoznaj się z tymi ćwiczeniami”. sekcji poniżej.

Aby w pełni wyjaśnić wszystkie kwestie, wdrożenie na bezserwerowej platformie obliczeniowej Google Cloud, takiej jak App Engine, wiąże się z niewielkimi kosztami kompilacji i przechowywania danych. Cloud Build ma własny bezpłatny limit, podobnie jak Cloud Storage. Przechowywanie tego obrazu wykorzystuje część tego limitu. Możesz jednak mieszkać w regionie, w którym nie ma takiego poziomu bezpłatnego. Dlatego pamiętaj o wykorzystaniu miejsca na dane, aby zminimalizować potencjalne koszty. Określone „foldery” Cloud Storage należy sprawdzić m.in.:

  • console.cloud.google.com/storage/browser/LOC.artifacts.PROJECT_ID.appspot.com/containers/images
  • console.cloud.google.com/storage/browser/staging.PROJECT_ID.appspot.com
  • Powyższe linki do miejsca na dane zależą od Twoich danych PROJECT_ID oraz *LOC*, np. „us” jeśli aplikacja jest hostowana w Stanach Zjednoczonych.

Jeśli natomiast nie zamierzasz dalej korzystać z tej aplikacji lub innych powiązanych z nią ćwiczeń w Codelabs i chcesz całkowicie usunąć wszystko, zamknij projekt.

Powiązane z tym ćwiczeniam z programowania

Wymienione poniżej usługi są dostępne tylko w ramach tego ćwiczenia z programowania. Więcej informacji znajdziesz w dokumentacji poszczególnych usług:

Dalsze kroki

W trakcie migracji dodaliśmy użycie kolejki push kolejki zadań do przykładowej aplikacji w module 1, obsługując śledzenie użytkowników, co pozwoliło wdrożyć przykładową aplikację z modułu 18. Podczas następnej migracji uaktualnisz zadania pull App Engine do Cloud Pub/Sub. Pod koniec 2021 roku użytkownicy nie muszą już wymagać migracji do Cloud Pub/Sub po przejściu na Pythona 3. Więcej informacji na ten temat znajdziesz w następnej sekcji.

Jeśli chcesz przeprowadzić migrację do Cloud Pub/Sub, zapoznaj się z ćwiczeniami z programowania w module 19. Oprócz tego rozważ dodatkowe migracje, takie jak Cloud Datastore, Cloud Memorystore, Cloud Storage czy Cloud Tasks (kolejki push). Dostępne są też migracje z różnych usług do Cloud Run i Cloud Functions. Wszystkie materiały z serwerowej stacji migracji (laboratoria, filmy, kod źródłowy [jeśli jest dostępne]) są dostępne w repozytorium open source tej platformy.

7. Migracja do Pythona 3

Jesienią 2021 r. zespół App Engine rozszerzył obsługę wielu pakietów usług na środowiska wykonawcze drugiej generacji (ze środowiskiem wykonawczym pierwszej generacji). W rezultacie nie trzeba już podczas przenoszenia aplikacji na Pythona 3 przejść z pakietów usług, takich jak kolejka zadań App Engine, na samodzielną usługę Cloud lub usługi innych firm, takie jak Cloud Pub/Sub. Inaczej mówiąc, możesz nadal korzystać z kolejki zadań w aplikacjach App Engine w języku Python 3, o ile tylko zmodernizuj kod, aby uzyskał dostęp do pakietów usług ze środowisk wykonawczych nowej generacji.

Więcej informacji o tym, jak przenieść użycie usług zawartych w pakiecie do Pythona 3, znajdziesz w module Codelabs (Moduł 17) i odpowiednim filmie. Chociaż ten temat nie jest objęty Modułem 18, poniżej znajdziesz linki do wersji Pythona 3 aplikacji z modułu 1, przeniesionych do Pythona 3 i nadal używających App Engine NDB. (W pewnym momencie zostanie też udostępniona aplikacja Moduł 18 w języku Python 3).

8. Dodatkowe materiały

Poniżej znajdziesz dodatkowe materiały dla deweloperów omawiające ten lub powiązany moduł migracji oraz powiązane usługi. Są to miejsca, w których można przesłać opinię o tych treściach, linki do kodu i różne artykuły, które mogą Ci się przydać.

Problemy z ćwiczeniami w Codelabs/opinie

Jeśli podczas korzystania z tych ćwiczeń z programowania zauważysz jakiekolwiek problemy, najpierw je wyszukaj. Linki do wyszukiwania i tworzenia nowych problemów:

Zasoby migracji

Linki do folderów repozytorium w modułach 1 (START) i modułach 18 (FINISH) znajdziesz w tabeli poniżej. Dostęp do nich możesz też uzyskać z repozytorium w przypadku wszystkich migracji ćwiczeń z programowania App Engine. skopiuj go lub pobierz plik ZIP.

Codelab

Python 2

Python 3

Część 1

kod

code (kod nie jest omówiony w tym samouczku)

Moduł 18 (to ćwiczenia z programowania)

kod

Nie dotyczy

Dokumentacja online

Poniżej znajdziesz informacje na temat tego samouczka:

Kolejka zadań App Engine

Platforma App Engine

Dokumentacja App Engine

Środowisko wykonawcze App Engine (środowisko standardowe) Pythona 2

Środowisko wykonawcze App Engine w Pythonie 3 (środowisko standardowe)

Różnice między Pythonem 2 a Pythonem 2 3 środowiska wykonawcze App Engine (w środowisku standardowym)

Przewodnik po migracji do App Engine (w środowisku standardowym) w języku Python 2 do 3

Informacje o cenach i limitach App Engine

Wprowadzenie na rynek platformy App Engine drugiej generacji (2018)

Długoterminowa obsługa starszych środowisk wykonawczych

Przykłady migracji dokumentacji

Inne informacje o Google Cloud

Filmy

Licencja

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