Migrazione delle code push a Cloud Tasks (Java)

Questa pagina descrive come eseguire la migrazione del codice delle code in coda in modalità push dalle code di attività a Cloud Tasks. Cloud Tasks è ora il modo preferito per lavorare con le code push di App Engine.

Con Cloud Tasks, accedi allo stesso servizio a cui accedi con l'API RPC Task Queues. Ciò significa che non devi ricreare le code e le attività push esistenti. Tuttavia, per utilizzare l'API Cloud Tasks, devi eseguire la migrazione del codice che crea o interagisce con code push o attività push.

Puoi creare ed eseguire interazioni con le code push e le attività push utilizzando le API REST e RPC di Cloud Tasks, la libreria client di Cloud Tasks, Google Cloud CLI e la console Google Cloud. Questa pagina fornisce esempi che utilizzano gcloud CLI e la libreria client Cloud Tasks.

In Cloud Tasks, tutte le code funzionano come code push. Nel resto di questa guida e nella documentazione di Cloud Tasks, il termine coda è equivalente al termine coda push. Analogamente, il termine task è equivalente al termine task push.

Funzionalità non disponibili in Cloud Tasks

Le seguenti funzionalità non sono disponibili in Cloud Tasks:

• Mettere in coda le attività nelle transazioni di Datastore
• Utilizzo della libreria delle attività differite anziché di un servizio di lavoro
• Lavorare con le attività nelle applicazioni multi-tenant
• Simulazione con il server di sviluppo locale
• Aggiunta di attività in modo asincrono

Prezzi e quote

La migrazione delle code push a Cloud Tasks potrebbe influire sui prezzi e sulle quote della tua app.

Prezzi

Cloud Tasks ha i propri prezzi. Come per le code di lavoro, l'invio di richieste all'app App Engine con un'attività può comportare costi per l'app.

Quote

Le quote di Cloud Tasks sono diverse da quelle per le code di attività. Come per le code di lavoro, l'invio di richieste all'app App Engine da Cloud Tasks potrebbe influire sulle quote di richiesta di App Engine.

Prima della migrazione

Le sezioni seguenti illustrano i passaggi di configurazione prima di eseguire la migrazione delle code push a Cloud Tasks.

Migrazione delle code pull

Prima di iniziare, esegui la migrazione delle code pull prima di seguire le istruzioni riportate in questa guida per eseguire la migrazione delle code push. La migrazione delle code pull dopo la migrazione delle code push non è consigliata perché l'utilizzo obbligatorio del file queue.yaml potrebbe causare comportamenti imprevisti con Cloud Tasks.

Protezione della configurazione delle code

Una volta avviato il processo di migrazione a Cloud Tasks, la modifica del file queue.yaml può causare un comportamento imprevisto e non è consigliata. Proteggi la configurazione della coda dalle modifiche apportate dal file queue.yaml seguendo i passaggi che seguono.

1. Configura gcloud CLI in modo da omettere il file queue.yaml nei futuri deployment.

   Aggiungi il file queue.yaml a un file .gcloudignore. Per verificare se hai già un file .gcloudignore, puoi eseguire il seguente comando nel terminale dalla directory di primo livello dell'app. Questo comando mostrerà il nome del file se esiste.

   ls -a | grep .gcloudignore

   Per saperne di più sui file .gcloudignore, consulta la pagina relativa al riferimento .gcloudignore.

2. Limita le autorizzazioni per il file queue.yaml.

   Segui le best practice descritte nella nostra guida sulla protezione della configurazione della coda.

3. Scopri di più su Cloud Tasks e sul file queue.yaml (facoltativo).

   Quando utilizzi l'API Cloud Tasks per gestire la configurazione della coda, il deployment di un file queue.yaml sostituisce la configurazione impostata da Cloud Tasks, il che può causare un comportamento imprevisto. Per saperne di più, consulta Gestione delle code e queue.yaml.

Attivazione dell'API Cloud Tasks

Per attivare l'API Cloud Tasks, fai clic su Attiva sull'API Cloud Tasks nella libreria API. Se vedi un pulsante Gestisci anziché un pulsante Abilita, significa che hai già abilitato l'API Cloud Tasks per il tuo progetto e non devi ripetere l'operazione.

Autenticazione dell'app all'API Cloud Tasks

Devi autenticare la tua app nell'API Cloud Tasks. Questa sezione discute l'autenticazione per due diversi casi d'uso.

Per sviluppare o testare l'app localmente, ti consigliamo di utilizzare un account di servizio. Per istruzioni su come configurare un account di servizio e collegarlo alla tua app, leggi Ottenere e fornire manualmente le credenziali dell'account di servizio.

Per eseguire il deployment dell'app su App Engine, non è necessario fornire nuova autenticazione. Le credenziali predefinite dell'applicazione deducono i dettagli di autenticazione per le app App Engine.

Download dell'interfaccia a riga di comando gcloud

Se non l'hai ancora fatto, scarica e installa gcloud CLI per utilizzarlo con l'API Cloud Tasks. Esegui il seguente comando dal terminale se hai già installato gcloud CLI.

gcloud components update

Importazione delle librerie client di Cloud

Per utilizzare la libreria client Cloud Tasks con la tua app App Engine:

1. Specifica la dipendenza della libreria client Cloud Tasks nel pom.xml file:

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

2. Importa le dipendenze della libreria client di Cloud Tasks nei file responsabili della creazione e dell'inserimento in coda delle attività:

   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;

Creazione e gestione delle code

Questa sezione descrive come creare e gestire le code utilizzando l'API Cloud Tasks.

Con Cloud Tasks, non utilizzi un file queue.yaml per creare o gestire le code. Utilizza invece l'API Cloud Tasks. L'utilizzo sia di un file queue.yaml sia dell'API Cloud Tasks non è consigliato, ma potrebbe essere un passaggio inevitabile per la migrazione da Task Queues a Cloud Tasks, a seconda dell'app. Leggi Utilizzare la gestione delle code rispetto a queue.yaml per scoprire le best practice.

Creazione di code

Leggi questa sezione se la tua app crea code a livello di programmazione o se vuoi creare code aggiuntive dalla riga di comando.

In Cloud Tasks, i nomi delle code hanno il formato projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID. La parte LOCATION_ID del nome della coda corrisponde a una regione Google Cloud. La parte QUEUE_ID del nome della coda è equivalente al campo name della coda Coda attività. Il nome della coda viene generato durante la creazione della coda in base al progetto, alla regione e al QUEUE_ID specificati.

In generale, la posizione della coda (ovvero la regione) deve essere la stessa della regione della tua app. Le due eccezioni a questa regola riguardano le app che utilizzano la regione europe-west e le app che utilizzano la regione us-central. In Cloud Tasks, queste regioni sono chiamate rispettivamente europe-west1 e us-central1.

Puoi specificare la configurazione facoltativa della coda durante la creazione, ma puoi anche farlo aggiornando la coda dopo la creazione.

Non è necessario ricreare le code esistenti. Esegui invece la migrazione del codice che interagisce con le code esistenti leggendo le parti pertinenti di questa guida.

Nota: il servizio App Engine Task Queue crea automaticamente una coda predefinita denominata default. Cloud Tasks non crea automaticamente questa coda.

Riutilizzo dei nomi delle code

Devi attendere 7 giorni dopo aver eliminato una coda per crearne una con lo stesso ID nello stesso progetto e nella stessa località (ovvero nella stessa regione).

L'esempio seguente crea due code utilizzando Cloud Tasks. La prima coda ha l'ID coda queue-blue ed è configurata per inviare tutte le attività alla versione v2 del servizio task-module a una frequenza di 5/s. La seconda coda ha l'ID coda queue-red e invia le attività a una frequenza di 1/s. Entrambi vengono creati nel progetto con ID progetto your-project-id nella località us-central1. Si tratta dell'equivalente in Cloud Tasks della creazione di code in Code di attività.

gcloud

Gcloud CLI deduce il progetto e la posizione dalla configurazione dellgcloud CLI.

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

libreria client

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

Per saperne di più, consulta la pagina di riferimento di Cloud Tasks sulla creazione di una coda Cloud Tasks.

Impostazione della frequenza di elaborazione della coda

La tabella seguente elenca i campi che differiscono da Task Queues a Cloud Tasks.

Campo Code di attività	Campo Cloud Tasks	Descrizione
rate	max_dispatches_per_second	La frequenza massima con cui le attività vengono inviate dalla coda
max_concurrent_requests	max_concurrent_dispatches	Il numero massimo di attività in parallelo che possono essere inviate dalla coda
bucket_size	max_burst_size	Cloud Tasks calcola una proprietà di sola lettura max_burst_size che limita la velocità di elaborazione delle attività nella coda in base al valore di max_dispatches_per_second. Questo campo consente alla coda di avere un tasso elevato in modo che l'elaborazione inizi poco dopo l'inserimento di un'attività, ma limita comunque l'utilizzo delle risorse quando molte attività vengono inserite in coda in un breve periodo di tempo. Per le code App Engine create o aggiornate utilizzando un queue.xml/yaml file, max_burst_size è inizialmente uguale a bucket_size. Tuttavia, se la coda viene successivamente passata a un comando update utilizzando qualsiasi interfaccia Cloud Tasks, max_burst_size verrà reimpostato in base al valore di max_dispatches_per_second, indipendentemente dal fatto che max_dispatches_per_second sia aggiornato.
total_storage_limit	Ritirata in Cloud Tasks	Cloud Tasks non supporta l'impostazione di un limite di spazio di archiviazione personalizzato

Puoi impostare la frequenza di elaborazione della coda quando la crei o successivamente. L'esempio seguente utilizza Cloud Tasks per impostare la frequenza di elaborazione su una coda denominata queue-blue già creata. Se queue-blue è stato creato o configurato utilizzando un file queue.yaml, il seguente esempio reimpostamax_burst_size in base al valore max_dispatches_per_second di 20. Si tratta dell'equivalente in Cloud Tasks dell'impostazione della frequenza di elaborazione della coda nelle code di attività.

gcloud

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

libreria client

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

Per scoprire di più, consulta Definire i limiti di frequenza.

Disattivare e riprendere le code

Cloud Tasks utilizza il termine metti in pausa nello stesso modo in cui Task Queues utilizza il termine disattiva. Mettendo in pausa una coda, l'esecuzione delle attività al suo interno viene interrotta fino a quando la coda non viene ripresa. Tuttavia, puoi continuare ad aggiungere attività a una coda in pausa. Cloud Tasks utilizza il termine riprendi nello stesso modo in cui lo fa Task Queues.

L'esempio seguente mette in pausa una coda con ID coda queueName . Si tratta dell'equivalente in Cloud Tasks della disattivazione delle code nelle code di attività.

gcloud

gcloud tasks queues pause 

queueName

libreria client

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

Per saperne di più, consulta la pagina di riferimento su Inibizione delle code di Cloud Tasks.

Eliminazione delle code

Dopo aver eliminato una coda, devi attendere 7 giorni prima di crearne una con lo stesso nome. Se non puoi attendere 7 giorni, ti consigliamo di eliminare definitivamente tutte le attività da una coda e di riconfigurarla.

L'esempio seguente elimina la coda con ID coda foo . Questo è l'equivalente in Cloud Tasks dell'eliminazione delle code in Code di attività.

gcloud

gcloud tasks queues delete 

foo

libreria client

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

Per saperne di più, consulta la pagina di riferimento di Cloud Tasks su Eliminazione delle code.

Creazione e gestione delle attività

Questa sezione descrive come creare e gestire le attività utilizzando l'API Cloud Tasks.

Creazione di attività

La tabella seguente elenca i campi che differiscono da Task Queues a Cloud Tasks.

Campo Code di attività	Campo Cloud Tasks	Descrizione
NOVITÀ in Cloud Tasks	app_engine_http_request	Crea una richiesta che ha come target un servizio App Engine. Queste attività sono indicate come attività App Engine.
method	http_method	Specifica il metodo di richiesta, ad esempio POST
url	relative_uri	Specifica il gestore dell'attività. Nota la differenza nella lettera finale: i per Uniform Resource Identifier anziché l per Uniform Resource Locator
target	app_engine_routing	Facoltativo. Specifica service, version e instance di App Engine per un'attività di App Engine. Se non impostato, vengono utilizzati il servizio, la versione e l'istanza predefiniti.

L'esempio seguente crea un'attività che viene inoltrata al gestore /worker nel servizio App Engine predefinito. Questo è l'equivalente in Cloud Tasks della creazione di attività nelle code di attività.

gcloud

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

libreria client

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

Per scoprire di più, leggi la documentazione di riferimento di Cloud Tasks su Creazione di attività App Engine.

Specifica del servizio target e del routing

La specifica del servizio, della versione e dell'istanza di destinazione App Engine per le attività App Engine è facoltativa. Per impostazione predefinita, le attività App Engine vengono inoltrate al servizio, alla versione e all'istanza predefiniti al momento del tentativo di esecuzione dell'attività.

Imposta la proprietà app_engine_routing dell'attività durante la creazione per specificare un servizio, una versione o un'istanza App Engine diversa per l'attività.

Per inoltrare tutte le attività di una determinata coda allo stesso servizio, alla stessa versione e alla stessa istanza di App Engine, puoi impostare la proprietà app_engine_routing_override sulla coda.

Per saperne di più, consulta la sezione di riferimento di Cloud Tasks Configurare il routing.

Trasferimento dei dati all'handler

Come con le code di attività, puoi passare i dati all'handler in due modi utilizzando Cloud Tasks. Puoi passare i dati come parametri di query nell'URI relativo oppure nel corpo della richiesta utilizzando i metodi HTTP POST o PUT.

Cloud Tasks utilizza il termine body nello stesso modo in cui Task Queues utilizza il termine payload. In Cloud Tasks, il tipo di contenuto predefinito del corpo è stream di byte anziché testo normale. Puoi impostare il tipo di contenuti del corpo specificandolo nell'intestazione.

L'esempio seguente passa una chiave all'handler /worker in due modi diversi. Si tratta dell'equivalente in Cloud Tasks della trasmissione dei dati all'handler in Code di attività.

console

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

libreria client

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

Denominazione delle attività

La specifica del nome dell'attività è facoltativa. Se non specifichi il nome dell'attività, Cloud Tasks lo genera per te generando un ID attività e deducendo il progetto e la posizione (ovvero la regione) in base alla coda specificata durante la creazione dell'attività.

I nomi delle attività hanno il formato projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID/tasks/TASK_ID. La parte TASK_ID del nome dell'attività è equivalente al campo name dell'attività Code di attività.

Riutilizzare i nomi delle attività

Devi attendere prima di riutilizzare il nome di un'attività. Il tempo di attesa prima di farlo varia a seconda che la coda che ha inviato l'attività sia stata creata in Cloud Tasks o in CodeQueue.

Per le attività nelle code create utilizzando le code di attività (inclusa la coda predefinita), devi attendere circa 9 giorni dall'eliminazione o dall'esecuzione dell'attività originale. Per le attività nelle code create con Cloud Tasks, devi attendere circa un'ora dopo l'eliminazione o l'esecuzione dell'attività originale.

L'esempio seguente crea un'attività con TASK_ID impostato su first-try e la aggiunge alla coda predefinita. Si tratta dell'equivalente in Cloud Tasks della denominazione delle attività nelle code di attività.

gcloud

Gcloud CLI crea il nome dell'attività deducendo il progetto e la posizione dalla configurazione.

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

/worker

libreria client

Con la libreria client, devi specificare il nome completo dell'attività se vuoi indicare TASK_ID. Il progetto e la località devono corrispondere al progetto e alla località della coda a cui viene aggiunta l'attività.

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

Nuovo tentativo di esecuzione delle attività non riuscite

Puoi impostare la configurazione del nuovo tentativo delle attività nelle code durante la loro creazione o aggiornandole. La tabella seguente elenca il campo CodePipeline Task Queues e il campo Cloud Tasks corrispondente.

Campo Code di attività	Campo 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

Parametri di ripetizione specifici per l'attività

I parametri di ripetizione specifici dell'attività configurati nelle code di lavoro funzionano in Cloud Tasks, ma non puoi modificarli o impostarli su nuove attività. Per modificare i parametri di ripetizione di un'attività con parametri di ripetizione specifici, ricrea l'attività con una coda Cloud Tasks che abbia i parametri di ripetizione desiderati.

L'esempio seguente mostra vari scenari di ripetizione:

• In fooqueue, i tentativi di esecuzione delle attività vengono ripetuti fino a sette volte e per un massimo di due giorni dal primo tentativo di esecuzione. Dopo aver superato entrambi i limiti, l'operazione non va a buon fine in modo definitivo.
• In barqueue, App Engine tenta di ripetere le attività, aumentando in modo lineare l'intervallo tra ogni nuovo tentativo fino a raggiungere il backoff massimo e ripetendo all'infinito il tentativo all'intervallo massimo (quindi gli intervalli tra le richieste sono 10 s, 20 s, 30 s, ..., 190 s, 200 s, 200 s e così via).
• In bazqueue, l'intervallo tra i tentativi inizia a 10 secondi, poi raddoppia tre volte, poi aumenta in modo lineare e infine esegue tentativi indefiniti all'intervallo massimo (quindi gli intervalli tra le richieste sono 10 secondi, 20 secondi, 40 secondi, 80 secondi, 160 secondi, 240 secondi, 300 secondi, 300 secondi e così via).

Si tratta dell'equivalente in Cloud Tasks della riprova delle attività nelle code di attività.

gcloud

Quando imposti opzioni che specificano un numero di secondi, devi includere s dopo il numero intero (ad es. 200s, non 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

libreria client

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

Per saperne di più, consulta la documentazione di riferimento di Cloud Tasks Impostare i parametri di ripetizione.

Eliminare attività da una coda

Quando elimini un'attività, devi attendere 9 giorni prima di crearne una con lo stesso nome se l'attività si trovava in una coda creata utilizzando un file queue.yaml o 1 ora se l'attività si trovava in una coda creata utilizzando Cloud Tasks.

L'esempio seguente elimina l'attività con ID attività foo dalla coda con ID coda queue1. Si tratta dell'equivalente in Cloud Tasks dell'eliminazione delle attività nelle code di attività.

gcloud

Il progetto e la posizione dell'attività vengono dedotti dal progetto predefinito gcloud CLI.

gcloud tasks delete foo --queue=queue1

libreria client

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

Per scoprire di più, leggi la documentazione di riferimento di Cloud Tasks su Elimina un'attività da una coda.

Pulizia delle attività

L'esempio seguente elimina definitivamente tutte le attività dalla coda con ID coda foo . Si tratta dell'equivalente in Cloud Tasks della pulizia delle attività nelle code di attività.

gcloud

Il progetto e la posizione della coda vengono dedotti dal progetto predefinito gcloud CLI.

gcloud tasks queues purge 

foo

libreria client

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

Per saperne di più, consulta la pagina di riferimento di Cloud Tasks su come eliminare tutte le attività da una coda.

Un esempio di Cloud Tasks in Java 8

L'esempio seguente è una configurazione di base per creare una coda e inserirvi un'attività con Cloud Tasks. Si presume che lo sviluppatore abbia creato un file pom.xml per specificare la dipendenza da Cloud Tasks come descritto nella sezione Importazione della libreria client. Questo è l'equivalente di Cloud Tasks di un esempio di coda di attività Java 8 nelle code di attività.

Il file responsabile della creazione e dell'inserimento in coda dell'attività crea un'attività e la aggiunge alla coda predefinita utilizzando la libreria client 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("/");
  }
}

Il file che definisce il worker gestisce l'attività:

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

Passaggi successivi

• Documentazione di Cloud Tasks
• Libreria client di Cloud Tasks
• Panoramica della documentazione di riferimento REST di Cloud Tasks
• Panoramica della documentazione di riferimento RPC di Cloud Tasks