Deferred API untuk Python 3

Halaman ini menjelaskan cara menggunakan Deferred API, salah satu layanan paket versi lama, dengan runtime Python 3 untuk lingkungan standar. Aplikasi Anda dapat mengakses layanan yang dipaketkan melalui SDK layanan App Engine untuk Python 3.

Ringkasan

Sebelumnya, paket Deferred google.appengine.ext.deferred bergantung pada framework webapp di Python 2. Karena framework webapp telah dihapus di SDK layanan App Engine untuk Python 3, Anda perlu melakukan beberapa perubahan saat mengupgrade aplikasi Python 2 ke Python 3.

Mengaktifkan Deferred API

Untuk mengaktifkan Deferred API untuk Python 3, Anda tidak perlu lagi menetapkan builtins.deferred ke on dalam file app.yaml. Sebagai gantinya, untuk mengaktifkan API, Anda harus meneruskan use_deferred=True dalam panggilan ke wrap_wsgi_app().

Kesamaan dan perbedaan

Secara default, Deferred API untuk Python 3 menggunakan /_ah/queue/deferred URL yang sama dan antrean default yang sama seperti di Python 2. Perlu diperhatikan bahwa untuk aplikasi yang bermigrasi ke Cloud Tasks, antrean default tidak dibuat secara otomatis dan library tugas yang ditangguhkan tidak tersedia.

Jika aplikasi Anda menggunakan endpoint /_ah/queue/deferred default, penggunaan deferred.defer() di Python 3 tetap sama dengan Python 2. Jika aplikasi Anda menggunakan URL kustom untuk eksekusi tugas yang ditangguhkan, Anda harus membuat beberapa perubahan karena class TaskHandler dalam modul deferred untuk Python 2 telah dihapus di versi Python 3 API ini.

Untuk menetapkan URL kustom bagi eksekusi tugas yang ditangguhkan, aplikasi dapat mengganti post ataurun_from_request dalam class deferred.Handler (sebelumnyadeferred.TaskHandler di Python 2), lalu meneruskan parameter environ yang mewakili kamus yang berisi parameter permintaan WSGI. Metode post kemudian dapat dipanggil dari endpoint kustom (seperti yang ditunjukkan dalam contoh Python 3).

Penggunaan menyeluruh Python 3 Deferred API, seperti pemilihan rute permintaan dan mengakses kamus environ, bergantung pada framework web tempat aplikasi dimigrasikan menjadi sasaran. Bandingkan perubahan kode yang dibuat dari contoh Python 2 dengan contoh Python 3 di bagian berikut.

Contoh Python 3

Contoh berikut menunjukkan cara mengeksekusi tugas yang ditangguhkan menggunakan endpoint default dan endpoint kustom di aplikasi Flask dan aplikasi Django.

Flask

import os

from flask import Flask, request
from google.appengine.api import wrap_wsgi_app
from google.appengine.ext import deferred
from google.appengine.ext import ndb

my_key = os.environ.get("GAE_VERSION", "Missing")

app = Flask(__name__)
app.wsgi_app = wrap_wsgi_app(app.wsgi_app, use_deferred=True)

class Counter(ndb.Model):
    count = ndb.IntegerProperty(indexed=False)

def do_something_later(key, amount):
    entity = Counter.get_or_insert(key, count=0)
    entity.count += amount
    entity.put()

@app.route("/counter/increment")
def increment_counter():
    # Use default URL and queue name, no task name, execute ASAP.
    deferred.defer(do_something_later, my_key, 10)

    # Use default URL and queue name, no task name, execute after 1 minute.
    deferred.defer(do_something_later, my_key, 10, _countdown=60)

    # Providing non-default task queue arguments
    deferred.defer(do_something_later, my_key, 10, _url="/custom/path", _countdown=120)

    return "Deferred counter increment."

@app.route("/counter/get")
def view_counter():
    counter = Counter.get_or_insert(my_key, count=0)
    return str(counter.count)

@app.route("/custom/path", methods=["POST"])
def custom_deferred():
    print("Executing deferred task.")
    # request.environ contains the WSGI `environ` dictionary (See PEP 0333)
    return deferred.Handler().post(request.environ)

Django

import os

from django.conf import settings
from django.core.wsgi import get_wsgi_application
from django.http import HttpResponse
from django.urls import path
from google.appengine.api import wrap_wsgi_app
from google.appengine.ext import deferred
from google.appengine.ext import ndb

my_key = os.environ.get("GAE_VERSION", "Missing")

class Counter(ndb.Model):
    count = ndb.IntegerProperty(indexed=False)

def do_something_later(key, amount):
    entity = Counter.get_or_insert(key, count=0)
    entity.count += amount
    entity.put()

def increment_counter(request):
    # Use default URL and queue name, no task name, execute ASAP.
    deferred.defer(do_something_later, my_key, 10)

    # Use default URL and queue name, no task name, execute after 1 minute.
    deferred.defer(do_something_later, my_key, 10, _countdown=60)

    # Providing non-default task queue arguments
    deferred.defer(do_something_later, my_key, 10, _url="/custom/path", _countdown=120)

    return HttpResponse("Deferred counter increment.")

def view_counter(request):
    counter = Counter.get_or_insert(my_key, count=0)
    return HttpResponse(str(counter.count))

def custom_deferred(request):
    print("Executing deferred task.")
    # request.environ contains the WSGI `environ` dictionary (See PEP 0333)
    response, status, headers = deferred.Handler().post(request.environ)
    return HttpResponse(response, status=status.value)

urlpatterns = (
    path("counter/get", view_counter, name="view_counter"),
    path("counter/increment", increment_counter, name="increment_counter"),
    path("custom/path", custom_deferred, name="custom_deferred"),
)

settings.configure(
    DEBUG=True,
    SECRET_KEY="thisisthesecretkey",
    ROOT_URLCONF=__name__,
    MIDDLEWARE_CLASSES=(
        "django.middleware.common.CommonMiddleware",
        "django.middleware.csrf.CsrfViewMiddleware",
        "django.middleware.clickjacking.XFrameOptionsMiddleware",
    ),
    ALLOWED_HOSTS=["*"],
)

app = wrap_wsgi_app(get_wsgi_application(), use_deferred=True)

Tanpa framework

import os
import re

from google.appengine.api import wrap_wsgi_app
from google.appengine.ext import deferred
from google.appengine.ext import ndb

my_key = os.environ.get("GAE_VERSION", "Missing")

class Counter(ndb.Model):
    count = ndb.IntegerProperty(indexed=False)

def do_something_later(key, amount):
    entity = Counter.get_or_insert(key, count=0)
    entity.count += amount
    entity.put()

def IncrementCounter(environ, start_response):
    # Use default URL and queue name, no task name, execute ASAP.
    deferred.defer(do_something_later, my_key, 10)

    # Use default URL and queue name, no task name, execute after 1 minute.
    deferred.defer(do_something_later, my_key, 10, _countdown=60)

    # Providing non-default task queue arguments
    deferred.defer(do_something_later, my_key, 10, _url="/custom/path", _countdown=120)

    start_response("200 OK", [("Content-Type", "text/html")])
    return [b"Deferred counter increment."]

def ViewCounter(environ, start_response):
    counter = Counter.get_or_insert(my_key, count=0)
    start_response("200 OK", [("Content-Type", "text/html")])
    return [str(counter.count).encode("utf-8")]

class CustomDeferredHandler(deferred.Handler):
    """Deferred task handler that adds additional logic."""

    def post(self, environ):
        print("Executing deferred task.")
        return super().post(environ)

routes = {
    "counter/increment": IncrementCounter,
    "counter/get": ViewCounter,
    "custom/path": CustomDeferredHandler(),
}

class WSGIApplication:
    def __call__(self, environ, start_response):
        path = environ.get("PATH_INFO", "").lstrip("/")
        for regex, handler in routes.items():
            match = re.search(regex, path)
            if match is not None:
                return handler(environ, start_response)

        start_response("404 Not Found", [("Content-Type", "text/plain")])
        return [b"Not found"]

app = wrap_wsgi_app(WSGIApplication(), use_deferred=True)

Contoh kode

Untuk melihat contoh kode lengkap dari panduan ini, lihat GitHub.