העברת תורי דחיפה ל-Cloud Tasks‏ (Java)

לפני שאתם עוברים לספריות הלקוח של Cloud Tasks, כדאי לקרוא את הסקירה הכללית על המעבר.

שדרוג לספריות הלקוח של Cloud Tasks

אם אתם מעדיפים להפסיק לגמרי את השימוש בחבילות השירות הקודמות, אתם יכולים להעביר את הקוד כך שישתמש ישירות ב-Cloud Tasks API. כדי לעשות את זה, צריך לשנות את קוד האפליקציה.

באמצעות Cloud Tasks אתם ניגשים לאותו שירות שאליו אתם ניגשים באמצעות Task Queues RPC API. כלומר, לא צריך ליצור מחדש את תורי הדחיפה ומשימות הדחיפה הקיימים. עם זאת, כדי להשתמש ב-Cloud Tasks API, צריך להעביר את הקוד שיוצר תורי דחיפה או משימות דחיפה, או מקיים איתם אינטראקציה.

אתם יכולים ליצור תורי דחיפה ומשימות דחיפה ולבצע בהם פעולות באמצעות ממשקי ה-API ל-REST ול-RPC של Cloud Tasks, ספריית הלקוח של Cloud Tasks, ה-CLI של Google Cloud ומסוףGoogle Cloud . בדף הזה מופיעות דוגמאות לשימוש ב-CLI של gcloud ובספריית הלקוח של Cloud Tasks.

תכונות שלא זמינות ב-Cloud Tasks

בספריות הלקוח של Cloud Tasks, התכונות הבאות לא זמינות:

  • הוספת משימות לתור בטרנזקציות של Datastore
  • שימוש בספריית המשימות שנדחו במקום בשירות של Worker
  • עבודה עם משימות באפליקציות מרובות דיירים
  • סימולציה באמצעות שרת הפיתוח המקומי
  • הוספת משימות באופן אסינכרוני

לחלופין, אם תשדרגו לגרסה העדכנית של ה-SDK, תכונות כמו משימות מושהות, מרחבי שמות וסימולציה מקומית ייתמכו באמצעות ה-wrapper של ה-SDK.

תמחור ומכסות

העברת תורי הדחיפה ל-Cloud Tasks עשויה להשפיע על התמחור ועל המכסות של האפליקציה.

תמחור

כדאי לעיין בתמחור של Cloud Tasks כדי להעריך את העלות החודשית לפני המעבר.

בדומה לתורי משימות, שליחת בקשות לאפליקציית App Engine עם יעד דחיפה של Cloud Tasks היא בחינם. עם זאת, בניגוד לתורי משימות, ב-Cloud Tasks החיוב הוא על פעולות שבוצעו, כמו יצירה, מחיקה או ניהול של משימות. יכול להיות שהעלות החודשית הכוללת תהיה גבוהה יותר בהשוואה לשימוש בתור המשימות של App Engine, שניתן בחינם.

אם אתם משדרגים את ה-SDK של שירותי App Engine כדי להעביר את האפליקציה, והאפליקציה מוסיפה לתור משימות טרנזקציות בתוך טרנזקציות של Datastore, כל משימה שנוספת לתור כרוכה ב-3 פעולות כתיבה, 2 פעולות קריאה ופעולת מחיקה אחת ב-Datastore, בנוסף לחיוב הרגיל של Cloud Tasks API.

מכסות

בקשות של Cloud Tasks נכללות גם במכסות הבקשות של App Engine.

בדומה לתורי משימות, ל-Cloud Tasks יש מכסות ספציפיות לשירות. המעבר ל-Cloud Tasks כנראה ישנה את המכסות שלכם.

לפני שמתחילים

בקטעים הבאים מפורטים שלבי ההגדרה לפני העברת תורי דחיפה (push queue) ל-Cloud Tasks.

העברת תורי משיכה (pull queue)

לפני שמתחילים, צריך להעביר את תורי המשיכה (pull), ורק אחר כך לפעול לפי ההוראות במדריך הזה כדי להעביר את תורי הדחיפה (push). לא מומלץ להעביר תורי משיכה אחרי שמעבירים תורי דחיפה, כי השימוש הנדרש בקובץ queue.yaml עלול לגרום להתנהגות בלתי צפויה ב-Cloud Tasks.

הגדרת תור ההגנה

אחרי שמתחילים את תהליך ההעברה ל-Cloud Tasks, שינוי של הקובץ queue.yaml עלול לגרום להתנהגות לא צפויה, ולכן לא מומלץ לעשות זאת. כדי להגן על הגדרות התור מפני שינויים באמצעות הקובץ queue.yaml, מבצעים את השלבים הבאים.

  1. מגדירים את ה-CLI של gcloud כך שישמיט את הקובץ queue.yaml בפריסות עתידיות.

    מוסיפים את הקובץ queue.yaml לקובץ .gcloudignore. כדי לבדוק אם כבר יש לכם קובץ .gcloudignore, אתם יכולים להריץ את הפקודה הבאה בטרמינל מהספרייה ברמה העליונה של האפליקציה. הפקודה הזו תציג את שם הקובץ אם הוא קיים.

    ls -a | grep .gcloudignore

    לקבלת מידע נוסף על קובצי .gcloudignore, קראו את קובץ העזר בנושא .gcloudignore.

  2. להגביל את ההרשאות בקובץ queue.yaml.

    כדאי לפעול לפי השיטות המומלצות שמתוארות במדריך אבטחת הגדרת התור.

  3. מידע על Cloud Tasks ועל הקובץ queue.yaml (אופציונלי).

    כשמשתמשים ב-Cloud Tasks API כדי לנהל את הגדרות התור, פריסה של קובץ queue.yaml מבטלת את ההגדרות שנקבעו על ידי Cloud Tasks, מה שעלול לגרום להתנהגות בלתי צפויה. למידע נוסף, קראו את המאמר שימוש בניהול תורים לעומת queue.yaml.

אימות האפליקציה ל-Cloud Tasks API

אתם צריכים לאמת את האפליקציה ב-Cloud Tasks API. בקטע הזה נדון באימות בשני תרחישים שונים לדוגמה.

כדי לפתח או לבדוק את האפליקציה באופן מקומי, מומלץ להשתמש בחשבון שירות. במאמר קבלת פרטי כניסה לחשבון שירות ומתן פרטי כניסה באופן ידני מוסבר איך מגדירים חשבון שירות ומקשרים אותו לאפליקציה.

כדי לפרוס את האפליקציה ב-App Engine, לא צריך לספק אימות חדש. פרטי האימות של אפליקציות App Engine מוסקים מ-Application Default Credentials‏ (ADC).

ייבוא ספריות הלקוח של Cloud

כדי להשתמש בספריית הלקוח של Cloud Tasks באפליקציית App Engine:

  1. מציינים את התלות בספריית הלקוח של Cloud Tasks בקובץ pom.xml:

    <dependency>
      <groupId>com.google.cloud</groupId>
      <artifactId>google-cloud-tasks</artifactId>
      <version>1.3.0</version>
    </dependency>
  2. מייבאים את יחסי התלות של ספריית הלקוח של Cloud Tasks בקבצים שאחראים ליצירת המשימות ולהוספה שלהן לתור:

    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;

יצירה וניהול של תורים

בקטע הזה מוסבר איך ליצור ולנהל תורים באמצעות Cloud Tasks API.

ב-Cloud Tasks לא משתמשים בקובץ queue.yaml כדי ליצור או לנהל תורים. במקום זאת, משתמשים ב-Cloud Tasks API. לא מומלץ להשתמש גם בקובץ queue.yaml וגם ב-Cloud Tasks API, אבל יכול להיות שזה יהיה חלק בלתי נמנע מהמעבר מתורי משימות ל-Cloud Tasks, בהתאם לאפליקציה שלכם. מומלץ לקרוא את המאמר שימוש בניהול תורים לעומת queue.yaml כדי ללמוד על השיטות המומלצות.

יצירת תורים

אם האפליקציה שלכם יוצרת תורים באופן פרוגרמטי, או אם אתם רוצים ליצור תורים נוספים משורת הפקודה, קראו את הקטע הזה.

ב-Cloud Tasks, שמות התורים הם בפורמט projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID. החלק LOCATION_ID בשם התור תואם ל Google Cloud אזור. החלק QUEUE_ID בשם תור המשימות מקביל לשדה name של התור ב-Task Queues. שם התור נוצר במהלך יצירת התור, על סמך הפרויקט, האזור וה-QUEUE_ID שציינתם.

באופן כללי, מיקום התור (כלומר, האזור) חייב להיות זהה לאזור של האפליקציה. שני החריגים לכלל הזה הם אפליקציות שמשתמשות באזור europe-west ואפליקציות שמשתמשות באזור us-central. ב-Cloud Tasks, האזורים האלה נקראים europe-west1 ו-us-central1 בהתאמה.

אפשר לציין הגדרות אופציונליות לתור בזמן שיוצרים אותו, אבל אפשר גם לעדכן את התור אחרי שהוא נוצר.

אין צורך ליצור מחדש תורים קיימים. במקום זאת, העבירו את הקוד שמקיים אינטראקציה עם התורים הקיימים שלכם על ידי קריאת החלקים הרלוונטיים במדריך הזה.

שימוש חוזר בשמות של תורים

אחרי שמוחקים תור, צריך להמתין 7 ימים לפני שיוצרים תור עם אותו מזהה באותו פרויקט ובאותו מיקום (כלומר, אזור).

בדוגמה הבאה נוצרים שני תורים באמצעות Cloud Tasks. בתור הראשון, מזהה התור הוא queue-blue והוא מוגדר לשלוח את כל המשימות לגרסה v2 של השירות task-module בקצב של 5/s. מזהה התור השני הוא queue-red והוא שולח משימות בקצב של 1/s. שניהם נוצרים בפרויקט עם מזהה הפרויקט your-project-id במיקום us-central1. זוהי המקבילה ב-Cloud Tasks ליצירת תורי משימות ב-Task Queues.

gcloud

ה-CLI של gcloud מסיק את הפרויקט והמיקום מההגדרות האישיות של ה-CLI של gcloud.

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

ספריית לקוח

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);
      }
    }
  }
}

למידע נוסף, קראו את המאמר יצירת תור של Cloud Tasks.

הגדרת קצב העיבוד של התור

בטבלה הבאה מפורטים השדות ששונים בין תורי משימות לבין Cloud Tasks.

השדה "תורי משימות" שדה של Cloud Tasks תיאור
rate max_dispatches_per_second הקצב המקסימלי שבו משימות נשלחות מהתור
max_concurrent_requests max_concurrent_dispatches המספר המקסימלי של משימות שאפשר לשלוח בו-זמנית מהתור
bucket_size max_burst_size

ב-Cloud Tasks מחושב מאפיין מסוג get-only‏ max_burst_size שמגביל את מהירות העיבוד של המשימות בתור על סמך הערך של max_dispatches_per_second. השדה הזה מאפשר לתור לפעול בקצב גבוה, כך שהעיבוד מתחיל זמן קצר אחרי שהמשימה נכנסת לתור, אבל עדיין מגביל את השימוש במשאבים כשמשימות רבות נכנסות לתור בפרק זמן קצר.

בתורים של App Engine שנוצרו או עודכנו באמצעות קובץ queue.xml/yaml, הערך של max_burst_size שווה בהתחלה ל-bucket_size. עם זאת, אם התור מועבר מאוחר יותר לפקודה update באמצעות ממשק כלשהו של Cloud Tasks, הערך של max_burst_size יאופס על סמך הערך של max_dispatches_per_second, גם אם הערך של max_dispatches_per_second לא עודכן.

total_storage_limit הוצאה משימוש ב-Cloud Tasks ב-Cloud Tasks אי אפשר להגדיר מגבלת אחסון בהתאמה אישית

אפשר להגדיר את קצב העיבוד של התור כשיוצרים את התור או לעדכן אותו לאחר מכן. בדוגמה הבאה, אנחנו משתמשים ב-Cloud Tasks כדי להגדיר את קצב העיבוד בתור שכבר נוצר בשם queue-blue. אם queue-blue נוצר או הוגדר באמצעות קובץ queue.yaml, הדוגמה הבאה מאפסת את max_burst_size על סמך הערך של max_dispatches_per_second ב-20. זהו המקבילה ב-Cloud Tasks להגדרת קצב העיבוד של התור בתורי המשימות.

gcloud

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

ספריית לקוח

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);
    }
  }
}

מידע נוסף זמין במאמר הגדרת מגבלות קצב.

השבתה והפעלה מחדש של תורים

ב-Cloud Tasks משתמשים במונח השהיה באותו אופן שבו משתמשים במונח השבתה בתורי משימות. השהיית תור מפסיקה את ביצוע המשימות בתור עד שהתור מופעל מחדש. עם זאת, אפשר להמשיך להוסיף משימות לתור שהושהה. ב-Cloud Tasks משתמשים במונח resume באותו אופן שבו משתמשים בו בתורי משימות.

בדוגמה הבאה מושהה תור עם מזהה התור queueName. זהו המקבילה ב-Cloud Tasks להשבתת תורים ב-Task Queues.

gcloud

gcloud tasks queues pause queueName

ספריית לקוח

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.");
    }
  }
}

למידע נוסף, קראו את המאמר השהיית תורים במדריך של Cloud Tasks.

מחיקת תורים

אחרי שמוחקים תור, צריך להמתין 7 ימים לפני שיוצרים תור עם אותו שם. אם אתם לא יכולים לחכות 7 ימים, אתם יכולים למחוק את כל המשימות מהתור ולהגדיר אותו מחדש.

בדוגמה הבאה נמחק התור עם מזהה התור foo. זוהי המקבילה ב-Cloud Tasks למחיקת תורים ב-Task Queues.

gcloud

gcloud tasks queues delete foo

ספריית לקוח

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.");
    }
  }
}

למידע נוסף, קראו את המאמר מחיקת תורים בחומר העזר של Cloud Tasks.

יצירה וניהול של משימות

בקטע הזה מוסבר איך ליצור ולנהל משימות באמצעות Cloud Tasks API.

ליצור משימות

בטבלה הבאה מפורטים השדות ששונים בין תורי משימות לבין Cloud Tasks.

השדה "תורי משימות" שדה של Cloud Tasks תיאור
לא רלוונטי app_engine_http_request יצירת בקשה שמטרגטת שירות של App Engine. המשימות האלה נקראות משימות App Engine.
method http_method מציין את שיטת הבקשה, לדוגמה, POST
url relative_uri מציין את ה-task handler. שימו לב להבדל באות האחרונה: i עבור מזהה משאבים אחיד במקום l עבור מאתר משאבים אחיד
target app_engine_routing זה שינוי אופציונלי. מציין את service, version ו-instance של App Engine למשימה ב-App Engine. אם לא מגדירים את השירות, הגרסה והמכונה, המערכת משתמשת בערכי ברירת המחדל.

בדוגמה הבאה נוצרת משימה שמנותבת ל-handler‏ /worker בשירות App Engine שמוגדר כברירת מחדל. זוהי המקבילה ב-Cloud Tasks ליצירת משימות בתורי משימות.

gcloud

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

ספריית לקוח

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);
      }
    }
  }
}

למידע נוסף, קראו את המאמר יצירת משימות ב-App Engine במאמרי העזרה של Cloud Tasks.

מציינים את שירות היעד ואת הניתוב

לא חובה לציין את שירות היעד, הגרסה והמכונה של App Engine למשימות של App Engine. כברירת מחדל, משימות של App Engine מנותבות לשירות, לגרסה ולמכונה שמוגדרים כברירת מחדל בזמן הניסיון לבצע את המשימה.

כדי לציין שירות, גרסה או מכונה אחרים של App Engine למשימה, מגדירים את המאפיין app_engine_routing של המשימה במהלך יצירת המשימה.

כדי לנתב את כל המשימות בתור מסוים לאותו שירות, גרסה ומכונה של App Engine, אתם יכולים להגדיר את המאפיין app_engine_routing_override בתור.

מידע נוסף זמין במאמר העזרה של Cloud Tasks בנושא הגדרת ניתוב.

העברת נתונים ל-handler

כמו בתורי משימות, אפשר להעביר נתונים ל-handler בשתי דרכים באמצעות Cloud Tasks. אפשר להעביר נתונים כפרמטרים של שאילתה ב-URI היחסי, או להעביר נתונים בגוף הבקשה באמצעות השיטות POST או PUT של HTTP.

ב-Cloud Tasks משתמשים במונח body באותו אופן שבו משתמשים במונח payload בתורי משימות. ב-Cloud Tasks, סוג התוכן של גוף ברירת המחדל הוא octet-stream ולא טקסט פשוט. אפשר להגדיר את סוג התוכן של גוף הבקשה בכותרת.

בדוגמה הבאה, מפתח מועבר ל-handler /worker בשתי דרכים שונות. זהו המקבילה ב-Cloud Tasks להעברת נתונים ל-handler בתורי משימות.

gcloud

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'}"

ספריית לקוח

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);
      }
    }
  }
}

מציינים את שם המשימה.

לא חובה לציין את שם המשימה. אם לא תציינו את שם המשימה, Cloud Tasks ייצור אותו בשבילכם על ידי יצירת מזהה משימה והסקת הפרויקט והמיקום (כלומר, האזור) על סמך התור שציינתם במהלך יצירת המשימה.

שמות המשימות הם בפורמט projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID/tasks/TASK_ID. החלק TASK_ID בשם המשימה מקביל לשדה name של המשימה ב-Task Queues.

שימוש חוזר בשמות של משימות

צריך לחכות לפני שמשתמשים שוב בשם של משימה. משך הזמן שצריך להמתין לפני שמוחקים את המשימה תלוי בשאלה אם התור ששולח את המשימה נוצר ב-Cloud Tasks או ב-Task Queues.

במשימות בתורים שנוצרו באמצעות Task Queues (כולל תור ברירת המחדל), צריך להמתין כ-9 ימים אחרי שהמשימה המקורית נמחקה או בוצעה. במשימות בתורים שנוצרו באמצעות Cloud Tasks, צריך להמתין כשעה אחרי שהמשימה המקורית נמחקה או בוצעה.

בדוגמה הבאה נוצרת משימה עם TASK_ID שמוגדר ל-first-try, והיא מתווספת לתור שמוגדר כברירת מחדל. זהו המקבילה של Cloud Tasks למתן שמות למשימות בתורי משימות.

gcloud

ה-CLI של gcloud יוצר את שם המשימה על ידי הסקת הפרויקט והמיקום מההגדרות האישיות שלכם.

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

ספריית לקוח

בספריית הלקוח, צריך לציין את שם המשימה המלא אם רוצים לציין את TASK_ID. הפרויקט והמיקום חייבים להתאים לפרויקט ולמיקום של התור שאליו המשימה נוספת.

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);
    }
  }
}

ניסיון חוזר להשלים משימות שנכשלו

אתם יכולים להגדיר את ניסיונות השליחה החוזרים של המשימות בתורים בזמן יצירת התור, או על ידי עדכון התור. בטבלה הבאה מפורטים השדות של Task Queues והשדות התואמים של Cloud Tasks.

השדה "תורי משימות" שדה של 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

שימוש בפרמטרים של ניסיון חוזר ספציפיים למשימה

פרמטרים ספציפיים למשימה של ניסיונות חוזרים שהוגדרו בתורי משימות פועלים ב-Cloud Tasks, אבל אי אפשר לערוך אותם או להגדיר אותם במשימות חדשות. כדי לשנות את פרמטרי הניסיונות החוזרים של משימה עם פרמטרים ספציפיים, צריך ליצור מחדש את המשימה עם תור משימות של Cloud Tasks שכולל את הפרמטרים הרצויים.

בדוגמה הבאה מוצגים תרחישים שונים של ניסיונות חוזרים:

  • ב-fooqueue, המערכת מנסה להפעיל מחדש את המשימות עד שבע פעמים, במשך עד יומיים מניסיון ההפעלה הראשון. אחרי ששתי המגבלות חולפות, הוא נכשל באופן סופי.
  • ב-barqueue, מערכת App Engine מנסה שוב לבצע משימות, ומגדילה את המרווח באופן ליניארי בין כל ניסיון חוזר עד שמגיעים להשהיה המקסימלית לפני ניסיון חוזר, ומנסה שוב ללא הגבלת זמן במרווח המקסימלי (כך שהמרווחים בין הבקשות הם 10 שניות, 20 שניות, 30 שניות, ..., 190 שניות, 200 שניות, 200 שניות, ...).
  • ב-bazqueue, מרווח הזמן בין הניסיונות החוזרים מתחיל ב-10 שניות, מוכפל שלוש פעמים, גדל באופן ליניארי, ולבסוף הניסיונות החוזרים נמשכים ללא הגבלת זמן במרווח הזמן המקסימלי (כך שהמרווחים בין הבקשות הם 10 שניות, 20 שניות, 40 שניות, 80 שניות, 160 שניות, 240 שניות, 300 שניות, 300 שניות וכו').

זהו המקבילה ב-Cloud Tasks לניסיון חוזר של משימות בתורי משימות.

gcloud

כשמגדירים אפשרויות שמציינות מספר שניות, צריך לכלול את s אחרי המספר השלם (למשל 200s ולא 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

ספריית לקוח

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);
      }
    }
  }
}

למידע נוסף, קראו את המאמר הגדרת פרמטרים לניסיון חוזר במדריך של Cloud Tasks.

מחיקת משימות מתור

כשמוחקים משימה, צריך להמתין 9 ימים לפני שיוצרים משימה עם אותו שם אם המשימה הייתה בתור שנוצר באמצעות קובץ queue.yaml, או שעה אחת אם המשימה הייתה בתור שנוצר באמצעות Cloud Tasks.

בדוגמה הבאה, המשימה עם מזהה המשימה foo נמחקת מהתור עם מזהה התור queue1. זוהי הפעולה המקבילה ב-Cloud Tasks למחיקת משימות בתורי משימות.

gcloud

הפרויקט והמיקום של המשימה נגזרים מפרויקט ברירת המחדל של ה-CLI של gcloud.

gcloud tasks delete foo --queue=queue1

ספריית לקוח

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.");
    }
  }
}

למידע נוסף, קראו את המאמר מחיקת משימה מתור במדריך של Cloud Tasks.

מחיקת משימות

בדוגמה הבאה מוסרות כל המשימות מהתור עם מזהה התור foo. זוהי המקבילה ב-Cloud Tasks לטיהור משימות בתורי משימות.

gcloud

הפרויקט והמיקום של התור נגזרים מפרויקט ברירת המחדל של ה-CLI של gcloud.

gcloud tasks queues purge foo

ספריית לקוח

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.");
    }
  }
}

למידע נוסף, קראו את המאמר מחיקת כל המשימות מתור בחומר העזר של Cloud Tasks.

דוגמה ל-Cloud Tasks ב-Java 8

הדוגמה הבאה היא הגדרה בסיסית ליצירת תור והוספת משימה לתור באמצעות Cloud Tasks. ההנחה היא שהמפתח יצר קובץ pom.xml כדי לציין את התלות ב-Cloud Tasks, כפי שמתואר בקטע ייבוא ספריית הלקוח. זוהי המקבילה ב-Cloud Tasks לדוגמה של תור משימות ב-Java 8 ב-Task Queues.

הקובץ שאחראי ליצירת המשימה ולהוספה שלה לתור יוצר משימה ומוסיף אותה לתור ברירת המחדל באמצעות ספריית הלקוח של Cloud Tasks:

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("/");
  }
}

הקובץ שמגדיר את ה-worker מטפל במשימה:

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);
  }
}

המאמרים הבאים