Push-Warteschlangen zu Cloud Tasks migrieren

Auf dieser Seite wird beschrieben, wie Sie Push-Warteschlangencode von Aufgabenwarteschlangen zu Cloud Tasks migrieren können. Cloud Tasks ist jetzt die bevorzugte Methode für die Arbeit mit App Engine-Push-Warteschlangen.

Übersicht

Mit Cloud Tasks greifen Sie auf denselben Dienst zu wie mit der Task Queues RPC API. Das bedeutet, dass Sie Ihre vorhandenen Push-Warteschlangen und Push-Aufgaben nicht neu erstellen müssen. Sie müssen jedoch Code migrieren, der Push-Warteschlangen oder Push-Aufgaben erstellt oder damit interagiert, um die Cloud Tasks API zu verwenden.

Sie können Push-Warteschlangen und Push-Aufgaben mit den Cloud Tasks REST und RPC APIs, der Cloud Tasks-Clientbibliothek für Java, der Google Cloud CLI und der Google Cloud Console erstellen und damit interagieren. Auf dieser Seite finden Sie Beispiele mit der gcloud CLI und der Cloud Tasks-Clientbibliothek für Java.

In Cloud Tasks arbeiten alle Warteschlangen als Push-Warteschlangen. Im Rest dieses Anleitung und in der Cloud Tasks-Dokumentation entspricht der Begriff Warteschlange dem Begriff Push-Warteschlange. Ebenso entspricht der Begriff Aufgabe dem Begriff Push-Aufgabe.

Features, die derzeit in Cloud Tasks nicht verfügbar sind

Die folgenden Features sind derzeit in Cloud Tasks nicht verfügbar:

  • Warteschlange für Aufgaben in Datenspeichertransaktionen
  • Bibliothek für zurückgestellte Aufgaben anstelle eines Worker-Dienstes verwenden
  • Mit Aufgaben in Anwendungen mit mehreren Mandanten arbeiten
  • Mit dem lokalen Entwicklungsserver simulieren
  • Aufgaben asynchron hinzufügen

Preise und Kontingente

Die Migration von Push-Warteschlangen zu Cloud Tasks kann sich auf die Preise und Kontingente für Ihre Anwendung auswirken.

Preise

Für Cloud Tasks gelten eigene Preise. Wie bei Aufgabenwarteschlangen kann das Senden von Anfragen an Ihre App Engine-Anwendung mit einer Aufgabe dazu führen, dass die Anwendung Kosten verursacht.

Kontingente

Die Kontingente für Cloud Tasks unterscheiden sich von den Kontingenten für Aufgabenwarteschlangen. Wie bei Aufgabenwarteschlangen kann das Senden von Anfragen von Cloud Tasks an die App Engine-Anwendung Auswirkungen auf Ihre Anfragekontingente für App Engine haben.

Vor der Migration

In diesem Abschnitt wird erläutert, was Sie vor der Migration Ihrer Push-Warteschlangen zu Cloud Tasks tun müssen.

Pull-Warteschlangen migrieren

Verwenden Sie die Anleitung zum Migrieren von Pull-Warteschlangen, um Ihre Pull-Warteschlangen zu migrieren, bevor Sie diese Anleitung zum Migrieren von Push-Warteschlangen verwenden. Die Migration von Pull-Warteschlangen nach der Migration von Push-Warteschlangen wird nicht empfohlen, da die erforderliche Verwendung der Datei queue.yaml wahrscheinlich ein unerwartetes Verhalten bei Cloud Tasks verursacht.

Warteschlangenkonfiguration schützen

Wenn Sie mit der Migration zu Cloud Tasks beginnen, kann das Ändern der Datei queue.yaml zu unerwartetem Verhalten führen und wird nicht empfohlen. So können Sie Ihre Warteschlangenkonfiguration vor Änderungen durch die Datei queue.yaml schützen:

  1. Konfigurieren Sie die gcloud CLI, um die queue.yaml-Datei in zukünftigen Bereitstellungen auszulassen.

    Fügen Sie die Datei queue.yaml zu einer Datei .gcloudignore hinzu. Um zu prüfen, ob Sie bereits eine Datei .gcloudignore haben, können Sie den folgenden Befehl in Ihrem Terminal aus dem Verzeichnis der obersten Ebene Ihrer Anwendung ausführen. Dieser Befehl gibt den Dateinamen aus, wenn die Datei vorhanden ist.

    ls -a | grep .gcloudignore

    Weitere Informationen zu .gcloudignore-Dateien finden Sie in der .gcloudignore-Referenz.

  2. Schränken Sie die Berechtigungen für die Datei queue.yaml ein.

    Wenden Sie die Best Practices an, die in der Anleitung zum Sichern der Warteschlangenkonfiguration beschrieben sind.

  3. Weitere Informationen zu Cloud Tasks und der Datei queue.yaml (optional)

    Wenn Sie die Warteschlangenkonfiguration mit der Cloud Tasks API verwalten, überschreibt die Bereitstellung einer Datei queue.yaml die von Cloud Tasks festgelegte Konfiguration, was zu unerwartetem Verhalten führen kann. Lesen Sie Warteschlangenverwaltung im Vergleich zu queue.yaml, um weitere Informationen zu erhalten.

Cloud Tasks API aktivieren

Um die Cloud Tasks API zu aktivieren, klicken Sie bei der Cloud Tasks API in der API-Bibliothek auf Aktivieren. Wenn anstelle der Schaltfläche Aktivieren die Schaltfläche Verwalten angezeigt wird, haben Sie die Cloud Tasks API bereits für Ihr Projekt aktiviert und müssen dies nicht noch einmal tun.

Anwendung bei der Cloud Tasks API authentifizieren

Sie müssen Ihre Anwendung für die Cloud Tasks API authentifizieren. In diesem Abschnitt wird die Authentifizierung für zwei verschiedene Anwendungsfälle erläutert.

Wenn Sie Ihre Anwendung lokal entwickeln oder testen möchten, empfehlen wir die Verwendung eines Dienstkontos. Anleitungen zum Einrichten eines Dienstkontos und zum Verknüpfen des Dienstkontos mit Ihrer Anwendung finden Sie unter Dienstkonto-Anmeldedaten manuell abrufen und bereitstellen.

Zur Bereitstellung Ihrer Anwendung in App Engine müssen Sie keine neue Authentifizierung bereitstellen. Die Standardanmeldedaten für Anwendungen (Application Default Credentials, ADC) leiten die Authentifizierungsdetails für App Engine-Anwendungen ab.

gcloud CLI herunterladen

Laden Sie die gcloud CLI herunter und installieren Sie sie, um die gcloud CLI mit der Cloud Tasks API zu verwenden, falls Sie sie noch nicht installiert haben. Führen Sie folgenden Befehl über Ihr Terminal aus, wenn Sie die gcloud CLI bereits installiert haben.

gcloud components update

Client-Bibliothek für Java importieren

Führen Sie die folgenden Schritte aus, um die Cloud Tasks-Clientbibliothek für Java mit Ihrer App Engine-Anwendung zu verwenden:

  1. Geben Sie die Abhängigkeit der Cloud Tasks-Clientbibliothek in Ihrer pom.xml-Datei an:

    <dependency>
  <groupId>com.google.cloud</groupId>
  <artifactId>google-cloud-tasks</artifactId>
  <version>1.3.0</version>
</dependency>

  2. Importieren Sie die Abhängigkeiten der Cloud Tasks-Clientbibliothek in die Dateien, die für das Erstellen und das Einreihen Ihrer Aufgaben in die Warteschlange verantwortlich sind:

    import com.google.cloud.tasks.v2.AppEngineHttpRequest;
import com.google.cloud.tasks.v2.CloudTasksClient;
import com.google.cloud.tasks.v2.HttpMethod;
import com.google.cloud.tasks.v2.QueueName;
import com.google.cloud.tasks.v2.Task;

Warteschlangen erstellen und verwalten

In diesem Abschnitt wird beschrieben, wie Sie Warteschlangen mit der Cloud Tasks API erstellen und verwalten.

In Cloud Tasks verwenden Sie keine Datei queue.yaml, um Warteschlangen zu erstellen oder zu verwalten. Stattdessen verwenden Sie die Cloud Tasks API. Die Verwendung einer Datei queue.yaml und der Cloud Tasks API wird nicht empfohlen, kann jedoch je nach Anwendung ein unvermeidlicher Teil der Migration von Aufgabenwarteschlangen zu Cloud Tasks sein. Weitere Informationen zu Best Practices finden Sie unter Warteschlangenverwaltung im Vergleich zu queue.yaml verwenden.

Warteschlangen erstellen

Lesen Sie diesen Abschnitt, wenn Ihre Anwendung Warteschlangen programmatisch erstellt oder wenn Sie zusätzliche Warteschlangen über die Befehlszeile erstellen möchten.

In Cloud Tasks haben Warteschlangennamen das Format projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID. Der Teil LOCATION_ID des Warteschlangennamens entspricht einer Google Cloud -Region. Der Teil QUEUE_ID des Warteschlangennamens entspricht dem Feld name der Cloud Tasks-Warteschlange. Der Warteschlangenname wird bei der Erstellung der Warteschlange basierend auf Grundlage des angegebenen Projekt, der Region und QUEUE_ID generiert.

Im Allgemeinen muss der Standort der Warteschlange mit der Region Ihrer Anwendung übereinstimmen. Die beiden Ausnahmen von dieser Regel gelten für Anwendungen mit der Region europe-west und Anwendungen mit der Region us-central. In Cloud Tasks werden diese Regionen europe-west1 bzw. us-central1 genannt.

Sie können während der Erstellung der Warteschlange eine optionale Warteschlangenkonfiguration angeben. Alternativ können Sie die Warteschlange aktualisieren, nachdem sie erstellt wurde.

Sie müssen vorhandene Warteschlangen nicht neu erstellen. Migrieren Sie stattdessen den Code, der mit Ihren vorhandenen Warteschlangen interagiert, indem Sie die relevanten Teile dieser Anleitung lesen.

Warteschlangennamen wiederverwenden

Sie müssen nach dem Löschen einer Warteschlange sieben Tage warten, um eine Warteschlange mit derselben Warteschlangen-ID im selben Projekt und am selben Ort (d. h. derselben Region) zu erstellen.

Im folgenden Beispiel werden zwei Warteschlangen mit Cloud Tasks erstellt. Die erste Warteschlange hat die Warteschlangen-ID queue-blue und ist so konfiguriert, dass alle Aufgaben mit einer Rate von 5/s an die Version v2 des Dienstes task-module gesendet werden. Die zweite Warteschlange hat die Warteschlangen-ID queue-red und sendet Aufgaben mit einer Rate von 1/s. Beide werden im Projekt mit der Projekt-ID your-project-id am Standort us-central1 erstellt. Dies ist die Cloud Tasks-Entsprechung zum Erstellen von Warteschlangen in Aufgabenwarteschlangen.

gcloud

Die gcloud CLI leitet das Projekt und den Speicherort von der Konfiguration der gcloud CLI ab.

gcloud tasks queues create queue-blue \
--max-dispatches-per-second=5 \
--routing-override=service:task-module,version:v2

gcloud tasks queues create queue-red \
--max-dispatches-per-second=1

Clientbibliothek

appengine-java8/tasks/snippets/src/main/java/com/example/task/CreateQueue.java 
import com.google.cloud.tasks.v2.AppEngineRouting;
import com.google.cloud.tasks.v2.CloudTasksClient;
import com.google.cloud.tasks.v2.LocationName;
import com.google.cloud.tasks.v2.Queue;
import com.google.cloud.tasks.v2.QueueName;
import com.google.cloud.tasks.v2.RateLimits;

public class CreateQueue {
  public static void createQueue(
      String projectId, String locationId, String queueBlueName, String queueRedName)
      throws Exception {
    try (CloudTasksClient client = CloudTasksClient.create()) {
      // TODO(developer): Uncomment these lines and replace with your values.
      // String projectId = "your-project-id";
      // String locationId = "us-central1";
      // String queueBlueName = "queue-blue";
      // String queueRedName = "queue-red";

      LocationName parent = LocationName.of(projectId, locationId);

      Queue queueBlue =
          Queue.newBuilder()
              .setName(QueueName.of(projectId, locationId, queueBlueName).toString())
              .setRateLimits(RateLimits.newBuilder().setMaxDispatchesPerSecond(5.0))
              .setAppEngineRoutingOverride(
                  AppEngineRouting.newBuilder().setVersion("v2").setService("task-module"))
              .build();

      Queue queueRed =
          Queue.newBuilder()
              .setName(QueueName.of(projectId, locationId, queueRedName).toString())
              .setRateLimits(RateLimits.newBuilder().setMaxDispatchesPerSecond(1.0))
              .build();

      Queue[] queues = new Queue[] {queueBlue, queueRed};
      for (Queue queue : queues) {
        Queue response = client.createQueue(parent, queue);
        System.out.println(response);
      }
    }
  }
}

Weitere Informationen finden Sie in der Cloud Tasks-Referenz Cloud Tasks-Warteschlange erstellen.

Verarbeitungsrate der Warteschlange festlegen

In der folgenden Tabelle sind die Felder aufgeführt, in denen sich Aufgabenwarteschlangen und Cloud Tasks unterscheiden.

Feld in Aufgabenwarteschlangen Feld in Cloud Tasks Beschreibung
rate max_dispatches_per_second Die maximale Rate, mit der Aufgaben aus der Warteschlange weitergeleitet werden
max_concurrent_requests max_concurrent_dispatches Die maximale Anzahl gleichzeitiger Aufgaben, die aus der Warteschlange weitergeleitet werden können
bucket_size max_burst_size

Cloud Tasks berechnet ein get-only-Attribut max_burst_size, das die Verarbeitungsgeschwindigkeit von Aufgaben in der Warteschlange entsprechend dem Wert von max_dispatches_per_second begrenzt. Dieses Feld ermöglicht der Warteschlange eine hohe Rate, sodass die Verarbeitung kurz nach dem Einreihen einer Aufgabe in die Warteschlange beginnt. Die Ressourcennutzung wird jedoch begrenzt, wenn viele Aufgaben in kurzer Zeit in die Warteschlange eingereiht werden.

Bei App Engine-Warteschlangen, die mit einer Datei queue.xml/yaml erstellt oder aktualisiert wurden, ist max_burst_size anfangs gleich bucket_size. Wenn die Warteschlange jedoch später über eine Cloud Tasks-Schnittstelle an den Befehl update übergeben wird, wird max_burst_size entsprechend dem Wert von max_dispatches_per_second zurückgesetzt, unabhängig davon, ob max_dispatches_per_second aktualisiert wird.

total_storage_limit In Cloud Tasks verworfen Cloud Tasks unterstützt derzeit nicht das Festlegen eines benutzerdefinierten Speicherlimits

Sie können die Verarbeitungsrate der Warteschlange beim Erstellen der Warteschlange festlegen oder sie anschließend aktualisieren. Im folgenden Beispiel wird Cloud Tasks verwendet, um die Verarbeitungsrate für eine Warteschlange mit dem Namen queue-blue festzulegen, die bereits erstellt wurde. Wenn queue-blue mit einer Datei queue.yaml erstellt oder konfiguriert wurde, wird im folgenden Beispiel max_burst_size entsprechend dem max_dispatches_per_second-Wert von 20 zurückgesetzt. Dies ist die Cloud Tasks-Entsprechung zum Festlegen der Verarbeitungsrate für die Warteschlange in Aufgabenwarteschlangen.

gcloud

gcloud tasks queues update queue-blue \
--max-dispatches-per-second=20 \
--max-concurrent-dispatches=10

Clientbibliothek

appengine-java8/tasks/snippets/src/main/java/com/example/task/UpdateQueue.java 
import com.google.cloud.tasks.v2.CloudTasksClient;
import com.google.cloud.tasks.v2.LocationName;
import com.google.cloud.tasks.v2.Queue;
import com.google.cloud.tasks.v2.QueueName;
import com.google.cloud.tasks.v2.RateLimits;
import com.google.cloud.tasks.v2.UpdateQueueRequest;

public class UpdateQueue {
  public static void updateQueue(String projectId, String locationId, String queueId)
      throws Exception {
    try (CloudTasksClient client = CloudTasksClient.create()) {
      // TODO(developer): Uncomment these lines and replace with your values.
      // String projectId = "your-project-id";
      // String locationId = "us-central1";
      // String queueId = "queue-blue";

      LocationName parent = LocationName.of(projectId, locationId);

      Queue queueBlue =
          Queue.newBuilder()
              .setName(QueueName.of(projectId, locationId, queueId).toString())
              .setRateLimits(
                  RateLimits.newBuilder()
                      .setMaxDispatchesPerSecond(20.0)
                      .setMaxConcurrentDispatches(10))
              .build();

      UpdateQueueRequest request = UpdateQueueRequest.newBuilder().setQueue(queueBlue).build();

      Queue response = client.updateQueue(request);
      System.out.println(response);
    }
  }
}

Weitere Informationen finden Sie unter Ratenbegrenzungen definieren.

Warteschlangen deaktivieren und fortsetzen

Cloud Tasks verwendet den Begriff pause auf die gleiche Weise wie Aufgabenwarteschlangen den Begriff disable. Durch das Pausieren einer Warteschlange wird die Ausführung der Aufgaben in der Warteschlange angehalten, bis die Warteschlange fortgesetzt wird. Sie können jedoch weiterhin Aufgaben zu einer Warteschlange hinzufügen, die pausiert wurde. Cloud Tasks verwendet den Begriff resume auf dieselbe Weise wie Aufgabenwarteschlangen.

Im folgenden Beispiel wird eine Warteschlange mit der Warteschlangen-ID queueName pausiert. Dies ist die Cloud Tasks-Entsprechung zum Deaktivieren von Warteschlangen in Aufgabenwarteschlangen.

gcloud

gcloud tasks queues pause queueName

Clientbibliothek

appengine-java8/tasks/snippets/src/main/java/com/example/task/PauseQueue.java 
import com.google.cloud.tasks.v2.CloudTasksClient;
import com.google.cloud.tasks.v2.QueueName;

public class PauseQueue {
  public static void pauseQueue(String projectId, String locationId, String queueId)
      throws Exception {
    try (CloudTasksClient client = CloudTasksClient.create()) {
      // TODO(developer): Uncomment these lines and replace with your values.
      // String projectId = "your-project-id";
      // String locationId = "us-central1";
      // String queueId = "foo";

      // Construct the fully qualified queue name.
      String queueName = QueueName.of(projectId, locationId, queueId).toString();

      client.pauseQueue(queueName);
      System.out.println("Queue Paused.");
    }
  }
}

Weitere Informationen finden Sie in der Cloud Tasks-Referenz Warteschlangen pausieren.

Warteschlangen löschen

Nachdem Sie eine Warteschlange gelöscht haben, müssen Sie sieben Tage warten, bevor Sie eine Warteschlange mit demselben Namen erstellen können. Sie könnten auch alle Aufgaben aus einer Warteschlange löschen und die Warteschlange neu konfigurieren, wenn Sie nicht sieben Tage warten können.

Im folgenden Beispiel wird die Warteschlange mit der Warteschlangen-ID foo gelöscht. Dies ist die Cloud Tasks-Entsprechung zum Löschen von Warteschlangen in Aufgabenwarteschlangen.

gcloud

gcloud tasks queues delete foo

Clientbibliothek

appengine-java8/tasks/snippets/src/main/java/com/example/task/DeleteQueue.java 
import com.google.cloud.tasks.v2.CloudTasksClient;
import com.google.cloud.tasks.v2.QueueName;

public class DeleteQueue {
  public static void deleteQueue(String projectId, String locationId, String queueId)
      throws Exception {
    try (CloudTasksClient client = CloudTasksClient.create()) {
      // TODO(developer): Uncomment these lines and replace with your values.
      // String projectId = "your-project-id";
      // String locationId = "us-central1";
      // String queueId = "foo";

      // Construct the fully qualified queue name.
      String queueName = QueueName.of(projectId, locationId, queueId).toString();

      client.deleteQueue(queueName);
      System.out.println("Queue Deleted.");
    }
  }
}

Weitere Informationen finden Sie in der Cloud Tasks-Referenz Warteschlangen löschen.

Aufgaben erstellen und verwalten

In diesem Abschnitt wird beschrieben, wie Sie Aufgaben mit der Cloud Tasks API erstellen und verwalten.

Aufgaben erstellen

In der folgenden Tabelle sind die Felder aufgeführt, in denen sich Aufgabenwarteschlangen und Cloud Tasks unterscheiden.

Feld in Aufgabenwarteschlangen Feld in Cloud Tasks Beschreibung
NEU in Cloud Tasks app_engine_http_request Erstellt eine Anfrage, die auf einen App Engine-Dienst abzielt. Diese Aufgaben werden als App Engine-Aufgaben bezeichnet.
method http_method Gibt die Anfragemethode an, z. B. POST.
url relative_uri Gibt den Aufgaben-Handler an. Beachten Sie den Unterschied im letzten Buchstaben: i für uniform resource identifier statt l für uniform resource locator
target app_engine_routing Optional. Gibt die App Engine service, version und instance für eine App Engine-Aufgabe an. Wenn nicht festgelegt, werden der Standarddienst, die Standardversion und die Standardinstanz verwendet.

Im folgenden Beispiel wird eine Aufgabe erstellt, die an den /worker-Handler im App Engine-Standarddienst weitergeleitet wird. Dies ist die Cloud Tasks-Entsprechung zum Erstellen von Aufgaben in Aufgabenwarteschlangen.

gcloud

gcloud tasks create-app-engine-task --queue=default \
--method=POST --relative-uri=/worker?key=key

Clientbibliothek

appengine-java8/tasks/snippets/src/main/java/com/example/task/CreateTask.java 
import com.google.cloud.tasks.v2.AppEngineHttpRequest;
import com.google.cloud.tasks.v2.CloudTasksClient;
import com.google.cloud.tasks.v2.HttpMethod;
import com.google.cloud.tasks.v2.QueueName;
import com.google.cloud.tasks.v2.Task;
import com.google.protobuf.ByteString;
import java.nio.charset.Charset;

public class CreateTask {
  public static void createTask(String projectId, String locationId, String queueId)
      throws Exception {
    try (CloudTasksClient client = CloudTasksClient.create()) {
      // TODO(developer): Uncomment these lines and replace with your values.
      // String projectId = "your-project-id";
      // String locationId = "us-central1";
      // String queueId = "default";
      String key = "key";

      // Construct the fully qualified queue name.
      String queueName = QueueName.of(projectId, locationId, queueId).toString();

      // Construct the task body.
      Task taskParam =
          Task.newBuilder()
              .setAppEngineHttpRequest(
                  AppEngineHttpRequest.newBuilder()
                      .setRelativeUri("/worker?key=" + key)
                      .setHttpMethod(HttpMethod.GET)
                      .build())
              .build();

      Task taskPayload =
          Task.newBuilder()
              .setAppEngineHttpRequest(
                  AppEngineHttpRequest.newBuilder()
                      .setBody(ByteString.copyFrom(key, Charset.defaultCharset()))
                      .setRelativeUri("/worker")
                      .setHttpMethod(HttpMethod.POST)
                      .build())
              .build();

      // Send create task request.
      Task[] tasks = new Task[] {taskParam, taskPayload};
      for (Task task : tasks) {
        Task response = client.createTask(queueName, task);
        System.out.println(response);
      }
    }
  }
}

Weitere Informationen finden Sie in der Cloud Tasks-Referenz App Engine-Aufgaben erstellen.

Zieldienst und Routing angeben

Die Angabe des App Engine-Zieldienstes, der Version und der Instanz für App Engine-Aufgaben ist optional. App Engine-Aufgaben werden standardmäßig an den Dienst, die Version und die Instanz weitergeleitet, die beim Ausführen der Aufgabe die Standardeinstellung sind.

Legen Sie das Attribut app_engine_routing der Aufgabe während der Aufgabenerstellung fest, um einen anderen App Engine-Dienst, eine andere Version oder eine andere App Engine-Instanz für Ihre Aufgabe anzugeben.

Um alle Aufgaben in einer bestimmten Warteschlange an denselben App Engine-Dienst, dieselbe Version und dieselbe Instanz weiterzuleiten, können Sie das Attribut app_engine_routing_override in der Warteschlange festlegen.

Weitere Informationen finden Sie in der Cloud Tasks-Referenz Routing konfigurieren.

Daten an den Handler übergeben

Wie bei Aufgabenwarteschlangen können Sie mit Cloud Tasks Daten auf zwei Arten an den Handler übergeben. Sie können Daten entweder als Abfrageparameter im relativen URI oder im Anfragetext mit den HTTP-Methoden POST oder PUT übergeben.

Cloud Tasks verwendet den Begriff Text auf die gleiche Weise wie Aufgabenwarteschlangen Nutzlast. In Cloud Tasks ist der Standardtextinhaltstyp „octet-stream” statt „Nur Text”. Sie können den Inhaltstyp „Text“ im Header angeben, um ihn festzulegen.

Im folgenden Beispiel wird ein Schlüssel auf zwei verschiedene Arten an den Handler /worker übergeben. Dies ist die Cloud Tasks-Entsprechung zur Übergabe von Daten an den Handler in Aufgabenwarteschlangen.

Konsole

gcloud tasks create-app-engine-task --queue=default --method=GET  \
--relative-uri=/worker?key=blue --routing=service:worker

gcloud tasks create-app-engine-task --queue=default --method=POST \
--relative-uri=/worker --routing=service:worker \
--body-content="{'key': 'blue'}"

Clientbibliothek

appengine-java8/tasks/snippets/src/main/java/com/example/task/CreateTask.java 
import com.google.cloud.tasks.v2.AppEngineHttpRequest;
import com.google.cloud.tasks.v2.CloudTasksClient;
import com.google.cloud.tasks.v2.HttpMethod;
import com.google.cloud.tasks.v2.QueueName;
import com.google.cloud.tasks.v2.Task;
import com.google.protobuf.ByteString;
import java.nio.charset.Charset;

public class CreateTask {
  public static void createTask(String projectId, String locationId, String queueId)
      throws Exception {
    try (CloudTasksClient client = CloudTasksClient.create()) {
      // TODO(developer): Uncomment these lines and replace with your values.
      // String projectId = "your-project-id";
      // String locationId = "us-central1";
      // String queueId = "default";
      String key = "key";

      // Construct the fully qualified queue name.
      String queueName = QueueName.of(projectId, locationId, queueId).toString();

      // Construct the task body.
      Task taskParam =
          Task.newBuilder()
              .setAppEngineHttpRequest(
                  AppEngineHttpRequest.newBuilder()
                      .setRelativeUri("/worker?key=" + key)
                      .setHttpMethod(HttpMethod.GET)
                      .build())
              .build();

      Task taskPayload =
          Task.newBuilder()
              .setAppEngineHttpRequest(
                  AppEngineHttpRequest.newBuilder()
                      .setBody(ByteString.copyFrom(key, Charset.defaultCharset()))
                      .setRelativeUri("/worker")
                      .setHttpMethod(HttpMethod.POST)
                      .build())
              .build();

      // Send create task request.
      Task[] tasks = new Task[] {taskParam, taskPayload};
      for (Task task : tasks) {
        Task response = client.createTask(queueName, task);
        System.out.println(response);
      }
    }
  }
}

Aufgaben benennen

Die Angabe des Aufgabennamens ist optional. Wenn Sie den Aufgabennamen nicht angeben, wird er von Cloud Tasks durch Generieren einer Aufgaben-ID und Ableiten des Projekts und des Standorts (d. h. Region) basierend auf der Warteschlange erstellt, die Sie bei der Aufgabenerstellung angegeben haben.

Aufgabennamen haben das Format projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID/tasks/TASK_ID. Der Teil TASK_ID des Aufgabennamens entspricht dem Feld name der Aufgabenwarteschlange.

Aufgabennamen wiederverwenden

Sie müssen warten, bevor Sie den Namen einer Aufgabe wiederverwenden können. Wie lange Sie warten müssen, hängt davon ab, ob die Warteschlange, die die Aufgabe weiterleitet, in Cloud Tasks oder in Aufgabenwarteschlangen erstellt wurde.

Bei Aufgaben in Warteschlangen, die mithilfe von Aufgabenwarteschlangen erstellt wurden (einschließlich der Standardwarteschlange), müssen Sie etwa 9 Tage warten, nachdem die ursprüngliche Aufgabe gelöscht oder ausgeführt wurde. Bei Aufgaben in Warteschlangen, die mit Cloud Tasks erstellt wurden, müssen Sie etwa eine Stunde warten, nachdem die ursprüngliche Aufgabe gelöscht oder ausgeführt wurde.

Im folgenden Beispiel wird eine Aufgabe mit dem Wert TASK_ID auf first-try erstellt und der Standardwarteschlange hinzugefügt. Dies ist das die Cloud Tasks-Entsprechung zum Benennen von Aufgaben in Aufgabenwarteschlangen.

gcloud

Die gcloud CLI erstellt den Aufgabennamen, wozu sie Projekt und Standort aus der Konfiguration ableitet.

gcloud tasks create-app-engine-task first-try --queue=default \
--method=GET --relative-uri=/worker

Clientbibliothek

Bei der Clientbibliothek müssen Sie den vollständigen Aufgabennamen für TASK_ID angeben. Das Projekt und der Speicherort müssen mit dem Projekt und dem Speicherort der Warteschlange übereinstimmen, der die Aufgabe hinzugefügt wird.

appengine-java8/tasks/snippets/src/main/java/com/example/task/CreateTaskWithName.java 
import com.google.cloud.tasks.v2.AppEngineHttpRequest;
import com.google.cloud.tasks.v2.CloudTasksClient;
import com.google.cloud.tasks.v2.HttpMethod;
import com.google.cloud.tasks.v2.QueueName;
import com.google.cloud.tasks.v2.Task;
import com.google.cloud.tasks.v2.TaskName;

public class CreateTaskWithName {
  public static void createTaskWithName(
      String projectId, String locationId, String queueId, String taskId) throws Exception {
    try (CloudTasksClient client = CloudTasksClient.create()) {
      // TODO(developer): Uncomment these lines and replace with your values.
      // String projectId = "your-project-id";
      // String locationId = "us-central1";
      // String queueId = "default";
      // String taskId = "first-try"

      String queueName = QueueName.of(projectId, locationId, queueId).toString();

      Task.Builder taskBuilder =
          Task.newBuilder()
              .setName(TaskName.of(projectId, locationId, queueId, taskId).toString())
              .setAppEngineHttpRequest(
                  AppEngineHttpRequest.newBuilder()
                      .setRelativeUri("/worker")
                      .setHttpMethod(HttpMethod.GET)
                      .build());

      // Send create task request.
      Task response = client.createTask(queueName, taskBuilder.build());
      System.out.println(response);
    }
  }
}

Fehlgeschlagene Aufgaben wiederholen

Sie können die Konfiguration der Aufgabenwiederholung für Warteschlangen während der Erstellung der Warteschlange oder durch Aktualisieren der Warteschlange festlegen. In der folgenden Tabelle sind das Feld „Aufgabenwarteschlangen” und das entsprechende Feld „Cloud Tasks” aufgeführt.

Feld in Aufgabenwarteschlangen Feld in Cloud Tasks
task_retry_limit max_attempts
task_age_limit max_retry_duration
min_backoff_seconds min_backoff
max_backoff_seconds max_backoff
max_doublings max_doublings

Aufgabenspezifische Wiederholungsparameter

Aufgabenspezifische Wiederholungsparameter, die in Aufgabenwarteschlangen konfiguriert wurden, funktionieren in Cloud Tasks. Sie können sie jedoch nicht bearbeiten oder für neue Aufgaben festlegen. Um die Wiederholungsparameter für eine Aufgabe mit aufgabenspezifischen Wiederholungsparametern zu ändern, erstellen Sie die Aufgabe mit einer Cloud Tasks-Warteschlange mit den gewünschten Wiederholungsparametern neu.

Im folgenden Beispiel werden verschiedene Wiederholungsszenarien demonstriert:

  • In fooqueue werden Aufgaben bis zu siebenmal und bis zu zwei Tage nach dem ersten Ausführungsversuch wiederholt. Nachdem beide Limits überschritten wurden, gilt die Ausführung als endgültig gescheitert.
  • In barqueue versucht App Engine, die Ausführung von Aufgaben zu wiederholen, wobei das Intervall zwischen den einzelnen Versuchen linear erhöht wird, bis das maximale Backoff erreicht ist. Die Versuche werden dann unbegrenzt im maximalen Intervall fortgesetzt. Die Intervalle zwischen den Anfragen betragen somit 10 s, 20 s, 30 s, ..., 190 s, 200 s, 200 s usw.
  • In bazqueue beginnt das Wiederholungsintervall bei 10 s, verdoppelt sich dreimal und steigt dann linear bis zum maximalen Intervall an, mit dem auf unbestimmte Zeit wiederholt wird. Die Intervalle zwischen den Anfragen betragen somit 10 s, 20 s, 40 s, 80 s, 160 s, 240 s, 300 s, 300 s usw.

Dies ist die Cloud Tasks-Entsprechung zum Wiederholen von Aufgaben in Aufgabenwarteschlangen.

gcloud

Wenn Sie Optionen festlegen, die eine Anzahl von Sekunden angeben, müssen Sie s nach der Ganzzahl einfügen (z. B. 200s, nicht 200).

gcloud tasks queues create fooqueue \
--max-attempts=7 \
--max-retry-duration=172800s  #2*60*60*24 seconds in 2 days

gcloud tasks queues create barqueue \
--min-backoff=10s \
--max-backoff=200s \
--max-doublings=0

gcloud tasks queues create bazqueue \
--min-backoff=10s \
--max-backoff=300s \
--max-doublings=3

Clientbibliothek

appengine-java8/tasks/snippets/src/main/java/com/example/task/RetryTask.java 
import com.google.cloud.tasks.v2.CloudTasksClient;
import com.google.cloud.tasks.v2.LocationName;
import com.google.cloud.tasks.v2.Queue;
import com.google.cloud.tasks.v2.QueueName;
import com.google.cloud.tasks.v2.RateLimits;
import com.google.cloud.tasks.v2.RetryConfig;
import com.google.protobuf.Duration;

public class RetryTask {
  public static void retryTask(
      String projectId, String locationId, String fooqueue, String barqueue, String bazqueue)
      throws Exception {
    try (CloudTasksClient client = CloudTasksClient.create()) {
      // TODO(developer): Uncomment these lines and replace with your values.
      // String projectId = "your-project-id";
      // String locationId = "us-central1";
      // String fooqueue = "fooqueue";
      // String barqueue = "barqueue";
      // String bazqueue = "bazqueue";

      LocationName parent = LocationName.of(projectId, locationId);

      Duration retryDuration = Duration.newBuilder().setSeconds(2 * 60 * 60 * 24).build();
      Duration min = Duration.newBuilder().setSeconds(10).build();
      Duration max1 = Duration.newBuilder().setSeconds(200).build();
      Duration max2 = Duration.newBuilder().setSeconds(300).build();

      Queue foo =
          Queue.newBuilder()
              .setName(QueueName.of(projectId, locationId, fooqueue).toString())
              .setRateLimits(RateLimits.newBuilder().setMaxDispatchesPerSecond(1.0))
              .setRetryConfig(
                  RetryConfig.newBuilder().setMaxAttempts(7).setMaxRetryDuration(retryDuration))
              .build();

      Queue bar =
          Queue.newBuilder()
              .setName(QueueName.of(projectId, locationId, barqueue).toString())
              .setRateLimits(RateLimits.newBuilder().setMaxDispatchesPerSecond(1.0))
              .setRetryConfig(
                  RetryConfig.newBuilder()
                      .setMinBackoff(min)
                      .setMaxBackoff(max1)
                      .setMaxDoublings(0))
              .build();

      Queue baz =
          Queue.newBuilder()
              .setName(QueueName.of(projectId, locationId, bazqueue).toString())
              .setRateLimits(RateLimits.newBuilder().setMaxDispatchesPerSecond(1.0))
              .setRetryConfig(
                  RetryConfig.newBuilder()
                      .setMinBackoff(min)
                      .setMaxBackoff(max2)
                      .setMaxDoublings(3))
              .build();

      Queue[] queues = new Queue[] {foo, bar, baz};
      for (Queue queue : queues) {
        Queue response = client.createQueue(parent, queue);
        System.out.println(response);
      }
    }
  }
}

Weitere Informationen finden Sie in der Cloud Tasks-Referenz Wiederholungsparameter festlegen.

Aufgaben aus einer Warteschlange löschen

Nachdem Sie eine Aufgabe gelöscht haben, müssen Sie 9 Tage warten, bevor Sie eine Aufgabe mit demselben Namen erstellen, wenn sich die Aufgabe in einer Warteschlange befand, die mit einer Datei queue.yaml erstellt wurde. Wenn sich die Aufgabe in einer Warteschlange befand, die mit Cloud Tasks erstellt wurde, müssen Sie 1 Stunde warten.

Im folgenden Beispiel wird die Aufgabe mit der Aufgaben-ID foo aus der Warteschlange mit der Warteschlangen-ID queue1 gelöscht. Dies ist die Cloud Tasks-Entsprechung zum Löschen von Aufgaben in Aufgabenwarteschlangen.

gcloud

Aufgabenprojekt und Standort werden aus dem Standardprojekt der gcloud CLI abgeleitet.

gcloud tasks delete foo --queue=queue1

Clientbibliothek

appengine-java8/tasks/snippets/src/main/java/com/example/task/DeleteTask.java 
import com.google.cloud.tasks.v2.CloudTasksClient;
import com.google.cloud.tasks.v2.TaskName;

public class DeleteTask {
  public static void deleteTask(String projectId, String locationId, String queueId, String taskId)
      throws Exception {
    try (CloudTasksClient client = CloudTasksClient.create()) {
      // TODO(developer): Uncomment these lines and replace with your values.
      // String projectId = "your-project-id";
      // String locationId = "us-central1";
      // String queueId = "queue1";
      // String taskId = "foo";

      // Construct the fully qualified queue name.
      String taskName = TaskName.of(projectId, locationId, queueId, taskId).toString();

      client.deleteTask(taskName);
      System.out.println("Task Deleted.");
    }
  }
}

Weitere Informationen finden Sie in der Cloud Tasks-Referenz Aufgabe aus einer Warteschlange löschen.

Aufgaben dauerhaft löschen

Im folgenden Beispiel werden alle Aufgaben aus der Warteschlange mit der Warteschlangen-ID foo dauerhaft gelöscht. Dies ist die Cloud Tasks-Entsprechung für das dauerhafte Löschen von Aufgaben in Aufgabenwarteschlangen.

gcloud

Das Warteschlangenprojekt und der Standort werden aus dem Standardprojekt der gcloud CLI abgeleitet.

gcloud tasks queues purge foo

Clientbibliothek

appengine-java8/tasks/snippets/src/main/java/com/example/task/PurgeQueue.java 
import com.google.cloud.tasks.v2.CloudTasksClient;
import com.google.cloud.tasks.v2.QueueName;

public class PurgeQueue {
  public static void purgeQueue(String projectId, String locationId, String queueId)
      throws Exception {
    try (CloudTasksClient client = CloudTasksClient.create()) {
      // TODO(developer): Uncomment these lines and replace with your values.
      // String projectId = "your-project-id";
      // String locationId = "us-central1";
      // String queueId = "foo";

      // Construct the fully qualified queue name.
      String queueName = QueueName.of(projectId, locationId, queueId).toString();

      client.purgeQueue(queueName);
      System.out.println("Queue Purged.");
    }
  }
}

Weitere Informationen finden Sie in der Cloud Tasks-Referenz Alle Aufgaben aus einer Warteschlange dauerhaft löschen.

Ein Java 8-Cloud Tasks-Beispiel

Das folgende Beispiel zeigt eine grundlegende Einstellung zum Erstellen einer Warteschlange und zum Einreihen einer Aufgabe mithilfe von Cloud Tasks. Es wird davon ausgegangen, dass der Entwickler eine pom.xml-Datei zur Angabe der Cloud Tasks-Abhängigkeit erstellt hat, wie im Abschnitt Clientbibliothek importieren beschrieben. Dies ist die Cloud Tasks-Entsprechung für ein Beispiel für eine Java 8-Aufgabenwarteschlange in Aufgabenwarteschlangen.

Die Datei, die für das Erstellen und Einreihen der Aufgabe verantwortlich ist, erstellt eine Aufgabe und fügt sie mithilfe der Cloud Tasks-Clientbibliothek für Java der Standardwarteschlange hinzu:

appengine-java8/tasks/app/src/main/java/com/example/task/Enqueue.java 
import com.google.cloud.tasks.v2.AppEngineHttpRequest;
import com.google.cloud.tasks.v2.CloudTasksClient;
import com.google.cloud.tasks.v2.HttpMethod;
import com.google.cloud.tasks.v2.QueueName;
import com.google.cloud.tasks.v2.Task;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet(
    name = "TaskEnqueue",
    description = "Enqueue a task targeted at endpoint '/cloudtasks/worker'",
    urlPatterns = "/cloudtasks/enqueue")
public class Enqueue extends HttpServlet {

  // TODO(developer): Replace these variables before running the sample.
  static final String projectId = "my-project-id";
  static final String locationId = "us-central1";

  // Function creates Cloud Tasks from form submissions.
  protected void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    String key = request.getParameter("key");

    try (CloudTasksClient client = CloudTasksClient.create()) {
      // Construct the fully qualified queue name.
      String queueName = QueueName.of(projectId, locationId, "default").toString();

      // Construct the task body.
      Task task =
          Task.newBuilder()
              .setAppEngineHttpRequest(
                  AppEngineHttpRequest.newBuilder()
                      .setRelativeUri("/cloudtasks/worker?key=" + key)
                      .setHttpMethod(HttpMethod.POST)
                      .build())
              .build();

      // Add the task to the default queue.
      Task taskResponse = client.createTask(queueName, task);
      System.out.println("Task created: " + taskResponse.getName());
    }

    response.sendRedirect("/");
  }
}

Die Datei, die den Worker definiert, verarbeitet die Aufgabe:

appengine-java8/tasks/app/src/main/java/com/example/task/Worker.java 
import java.io.IOException;
import java.util.logging.Logger;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet(
    name = "TaskWorker",
    description = "Endpoint to process Cloud Task requests",
    urlPatterns = "/cloudtasks/worker"
)
public class Worker extends HttpServlet {

  private static final Logger log = Logger.getLogger(Worker.class.getName());

  // Worker function to process POST requests from Cloud Tasks targeted at the
  // '/cloudtasks/worker' endpoint.
  protected void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    String key = request.getParameter("key");
    log.info("Worker is processing " + key);
  }
}

Nächste Schritte