Python 2 wird von der Community nicht mehr unterstützt. Wir empfehlen die Migration von Python 2-Anwendungen zu Python 3.

Push-Aufgaben erstellen

Auf dieser Seite wird beschrieben, wie Sie Aufgaben erstellen und in Push-Warteschlangen einfügen. Wenn Sie eine Aufgabe verarbeiten möchten, müssen Sie ein neues Aufgabenobjekt erstellen und in eine Warteschlange stellen. Sie können den Dienst und den Handler, mit denen die Aufgabe verarbeitet wird, ausdrücklich angeben und optional aufgabenspezifische Daten an den Handler weiterleiten. Außerdem können Sie für die Konfiguration der Aufgabe Feineinstellungen vornehmen, z. B. einen Zeitpunkt in der Zukunft angeben, zu dem die Aufgabe ausgeführt werden soll, oder die Anzahl ihrer Wiederholungen im Fall von Fehlversuchen beschränken.

Neue Aufgabe erstellen

Rufen Sie die Funktion taskqueue.add() auf, um eine Aufgabe zu erstellen und in eine Warteschlange einzufügen. Der folgende Code erstellt eine Aufgabe, die auf den Dienst namens worker ausgerichtet ist, und ruft dessen Handler durch Festlegen der URL /update-counter auf:

class EnqueueTaskHandler(webapp2.RequestHandler):
    def post(self):
        amount = int(self.request.get('amount'))

        task = taskqueue.add(
            url='/update_counter',
            target='worker',
            params={'amount': amount})

        self.response.write(
            'Task {} enqueued, ETA {}.'.format(task.name, task.eta))

Alternativ können Sie ein Objekt vom Typ Task erstellen und dessen Methode add() aufrufen.

Worker-Dienst angeben

Wenn eine Aufgabe in der Warteschlange an der Reihe ist, wird sie vom Dienst für Aufgabenwarteschlangen an einen Worker-Dienst gesendet. Jede Aufgabe hat ein Ziel und eine URL, mit denen bestimmt wird, von welchem Dienst und Handler die Aufgabe letztendlich ausgeführt wird.

target

Das Ziel gibt den Dienst an, der den HTTP-Request zur Ausführung der Aufgabe erhält. Dabei handelt es sich um einen String, mit dem ein Dienst, eine Version oder eine Instanz in einem der kanonischen Formate angegeben wird. Am häufigsten werden folgende Formate verwendet:

    service
    version.service
    instance.version.service

Der String "target" wird dem Domainnamen Ihrer Anwendung vorangestellt. Es gibt drei Möglichkeiten, um das Ziel für eine Aufgabe festzulegen:

  • Deklarieren Sie das Ziel beim Erstellen der Aufgabe. Sie können das Ziel explizit mit dem Parameter target in der Funktion taskqueue.add() festlegen. Sehen Sie sich dazu das Beispiel oben an.

  • Fügen Sie eine target-Anweisung hinzu, wenn Sie eine Warteschlange in der Datei queue.yaml definieren, genauso wie bei der Definition von queue-blue. Alle Aufgaben, die mit target in die Warteschlange eingefügt werden, verwenden dieses Ziel, auch wenn der Aufgabe zum Zeitpunkt ihres Erstellens ein anderes Ziel zugewiesen war.

  • Wenn kein Ziel mit einer der beiden vorherigen Methoden angegeben wurde, ist das Ziel der Aufgabe die Version des Dienstes, von der sie in die Warteschlange gestellt wurde. Wenn Sie auf diese Weise eine Aufgabe vom Standarddienst und der Standardversion in die Warteschlange stellen und sich die Standardversion vor Ausführung der Aufgabe ändert, wird die Aufgabe in der neuen Standardversion ausgeführt.

url

url wählt einen der Handler im Zieldienst aus, der die Aufgabe ausführen soll.

Dabei muss url mit einem der URL-Muster des Handlers im Zieldienst übereinstimmen. url kann Abfrageparameter enthalten, wenn in der Aufgabe die Methode GET oder PULL festgelegt wurde. Wenn kein url-Wert in der Standard-URL festgelegt ist, wird /_ah/queue/[QUEUE_NAME] verwendet. Dabei ist [QUEUE_NAME] der Name der Aufgabenwarteschlange.

Daten an den Handler übergeben

Sie können Daten als Abfrageparameter an den Handler in der URL der Aufgabe übergeben. Voraussetzung ist, dass in der Aufgabe die Methode GET oder PULL angegeben wurde.

Sie können auch eines der folgenden Felder verwenden, um Daten zu einer Aufgabe hinzuzufügen:

  • payload, die Aufgabendaten im Text der HTTP-Anfrage bereitstellt.
  • params

Folgende drei Aufrufe sind äquivalent:

taskqueue.add(method=GET, url='/update-counter?key=blue', target='worker')
taskqueue.add(url='/update-counter', params={'key': 'blue'}, target='worker')
taskqueue.add(url='/update-counter', payload="{'key': 'blue'}", target='worker')

Aufgabe benennen

Wenn Sie eine neue Aufgabe erstellen, wird ihr von App Engine standardmäßig ein eindeutiger Name zugewiesen. Sie können einer Aufgabe jedoch mit dem Parameter name auch eigene Namen zuweisen. Die Zuweisung eigener Aufgabennamen hat den Vorteil, dass benannte Aufgaben dedupliziert werden. So können Sie anhand von Aufgabennamen gewährleisten, dass eine Aufgabe nur einmal hinzugefügt wird. Die Deduplizierung wird noch neun Tage fortgeführt, nachdem die Aufgabe abgeschlossen oder gelöscht wurde.

Dabei ist zu beachten, dass die Deduplizierungslogik zu signifikanten Leistungseinbußen führen und die Latenzen und unter Umständen auch die Fehlerraten im Zusammenhang mit benannten Aufgaben erhöhen kann. Bei sequenziellen Aufgabennamen, beispielsweise mit Zeitstempeln, können diese Einbußen noch erheblich höher ausfallen. Wir empfehlen daher, beim Zuweisen eigener Namen ein wohlüberlegtes Präfix für Aufgabennamen zu verwenden, beispielsweise einen Hashwert des Inhalts.

Wenn Sie Aufgaben eigene Namen zuweisen, dürfen Sie die maximale Namenslänge von 500 Zeichen nicht überschreiten. Der Name kann Groß- und Kleinbuchstaben, Zahlen sowie Unter- und Bindestriche enthalten.

taskqueue.add(url='/url/path', name='first-try')

Aufgaben asynchron hinzufügen

Standardmäßig sind die Aufrufe, die Aufgaben zu Warteschlangen hinzufügen, synchron. In den meisten Szenarien funktionieren synchrone Aufrufe problemlos. Aufgaben können normalerweise schnell in eine Warteschlange gestellt werden. Ein kleiner Prozentsatz der Vorgänge, mit denen Aufgaben hinzugefügt werden, kann deutlich länger dauern. Durchschnittlich dauert es jedoch weniger als 5 ms, eine Aufgabe hinzuzufügen.

Vorgänge zum Einstellen von Aufgaben in verschiedene Warteschlangen können nicht im Batch-Modus ausgeführt werden, deshalb ermöglicht die Task Queue API auch asynchrone Aufrufe, über die Sie diese Aufgaben parallel einstellen und somit die Latenz weiter verringern können. Dies ist hilfreich, wenn Sie eine sehr latenzempfindliche Anwendung erstellen, die mehrere Vorgänge zum Einstellen von Aufgaben in verschiedene Warteschlangen gleichzeitig ausführen muss.

Verwenden Sie die asynchronen Methoden der Klasse "Queue" und ein RPC-Objekt, um asynchrone Aufrufe an eine Aufgabenwarteschlange auszuführen. Rufen Sie get_result() für das zurückgegebene RPC-Objekt auf, um den Abschluss der Anfrage zu erzwingen. Beim asynchronen Hinzufügen von Aufgaben in einer Transaktion sollten Sie vor dem Commit der Transaktion get_result() für das Objekt RPC aufrufen, um sicherzustellen, dass die Anfrage abgeschlossen wurde.

Aufgaben in Cloud Datastore-Transaktionen in die Warteschlange stellen

Sie können eine Aufgabe als Teil einer Datastore-Transaktion in die Warteschlange stellen, sodass die Aufgabe dann – und nur dann – in die Warteschlange aufgenommen wird, wenn der Commit für die Transaktion erfolgreich ausgeführt wurde. Aufgaben, die Sie einer Transaktion hinzufügen, werden als Teil dieser Transaktion behandelt. Sie weisen das gleiche Maß an Isolation und Konsistenz auf.

Eine Anwendung kann bei einer einzelnen Transaktion maximal fünf Transaktionsaufgaben in Aufgabenwarteschlangen einfügen. Transaktionsaufgaben dürfen keine benutzerdefinierten Namen haben.

Im folgenden Beispielcode ist dargestellt, wie Sie Transaktionsaufgaben als Teil einer Datastore-Transaktion in eine Push-Warteschlange einreihen:

from google.appengine.api import taskqueue
from google.appengine.ext import ndb

@ndb.transactional
def do_something_in_transaction():
  taskqueue.add(url='/path/to/my/worker', transactional=True)
  #...

do_something_in_transaction()

Bibliothek zurückgestellter Aufgaben anstelle eines Worker-Dienstes verwenden

Das Einrichten eines Handlers für jede einzelne Aufgabe (wie in den vorherigen Abschnitten beschrieben) kann genau wie das Serialisieren und Deserialisieren komplexer Argumente für die Aufgabe mühsam sein. Dies trifft vor allem dann zu, wenn Sie viele verschiedene, aber kleine Aufgaben haben, die Sie in der Warteschlange ausführen möchten. Das Python SDK beinhaltet eine Bibliothek (google.appengine.ext.deferred), die eine einfache Funktion bereitstellt, mit der Sie die gesamte Arbeit der Einrichtung dedizierter Aufgaben-Handler sowie der Serialisierung und Deserialisierung Ihrer Parameter umgehen können.

Um diese Bibliothek zu verwenden, müssen Sie deferred builtin zu app.yaml hinzufügen. Weitere Informationen finden Sie im Abschnitt Integrierte Handler der Referenz app.yaml.

Zur Verwendung der deferred-Bibliothek übergeben Sie einfach die Funktion und ihre Argumente an deferred.defer():

import logging

from google.appengine.ext import deferred

def do_something_expensive(a, b, c=None):
    logging.info("Doing something expensive!")
    # Do your work here

# Somewhere else
deferred.defer(do_something_expensive, "Hello, world!", 42, True)

Die deferred-Bibliothek bündelt den Funktionsaufruf und seine Argumente und fügt ihn dann der Aufgabenwarteschlange hinzu. Wenn die Aufgabe ausgeführt wird, führt die deferred-Bibliothek do_something_expensive("Hello, world!", 42, True) aus.

Weitere Informationen zur Verwendung der deferred-Bibliothek in Python finden Sie unter Hintergrundarbeit mit der zurückgestellten Bibliothek.

Aufgaben in einer mehrinstanzenfähigen Anwendung

Push-Warteschlangen verwenden standardmäßig den Namespace, der zum Zeitpunkt der Aufgabenerstellung im Namespace-Manager festgelegt war. Wenn Ihre Anwendung die Mehrinstanzenfähigkeit nutzt, lesen Sie die Informationen zur Namespaces Python 2 API.

Nächste Schritte