Migrazione delle code in modalità push a Cloud Tasks

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 migliore per lavorare con le code in modalità push di App Engine.

Con Cloud Tasks, puoi accedere 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 le code o le attività push.

Puoi creare e interagire con code e 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 di utilizzo di gcloud CLI e della libreria client di Cloud Tasks.

In Cloud Tasks, tutte le code funzionano come code in modalità push. Nel resto della guida e nella documentazione di Cloud Tasks, il termine coda è equivalente al termine coda push. Allo stesso modo, il termine attività equivale al termine attività push.

Funzionalità attualmente non disponibili in Cloud Tasks

Le seguenti funzionalità non sono attualmente disponibili in Cloud Tasks:

Accoda le attività nelle transazioni Datastore
Utilizzo della libreria delle attività differite invece di un servizio worker
Lavorare con le attività in applicazioni multi-tenant
Simulazione con il server di sviluppo locale
Aggiunta di attività in modo asincrono

Prezzi e quote

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

Prezzi

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

Quote

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

Prima di eseguire la migrazione

Le sezioni seguenti descrivono i passaggi di configurazione prima di eseguire la migrazione delle code in modalità push a Cloud Tasks.

Migrazione delle code in modalità pull

Prima di iniziare, esegui la migrazione delle code in modalità pull prima di seguire le istruzioni in questa guida per eseguire la migrazione delle code in modalità push. La migrazione delle code in modalità pull dopo la migrazione delle code in modalità push non è consigliata perché l'utilizzo richiesto del file queue.yaml potrebbe causare un comportamento imprevisto 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 comportamenti imprevisti e non è consigliata. Proteggi la configurazione della coda dalle modifiche apportate dal file queue.yaml seguendo i passaggi riportati di seguito.

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

Aggiungi il tuo 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 restituirà il nome del file se il file esiste.
```
ls -a | grep .gcloudignore
```
Per scoprire di più sui file .gcloudignore, consulta il riferimento .gcloudignore.
Limita le autorizzazioni per il tuo file queue.yaml.

Segui le best practice descritte nella nostra guida sulla protezione della configurazione delle code.
Scopri di più su Cloud Tasks e il file queue.yaml (facoltativo).

Quando utilizzi l'API Cloud Tasks per gestire la configurazione delle code, il deployment di un file queue.yaml sostituisce la configurazione impostata da Cloud Tasks, il che può causare comportamenti imprevisti. Per saperne di più, consulta Utilizzo della gestione delle code rispetto aQueue.yaml.

Abilitazione dell'API Cloud Tasks

Per abilitare l'API Cloud Tasks, fai clic su Abilita nell'API Cloud Tasks nella libreria API. Se visualizzi un pulsante Gestisci anziché un pulsante Abilita, significa che hai precedentemente abilitato l'API Cloud Tasks per il tuo progetto e non è necessario farlo di nuovo.

Autenticazione dell'app nell'API Cloud Tasks

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

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

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

Download di gcloud CLI

Scarica e installa gcloud CLI per utilizzare gcloud CLI con l'API Cloud Tasks, se non l'hai già installato. Esegui questo comando dal terminale se hai già installato gcloud CLI.

gcloud components update

Importazione delle librerie client di Cloud

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

Specifica la dipendenza dalla libreria client di Cloud Tasks nel tuo file pom.xml:

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

Importa le dipendenze della libreria client di Cloud Tasks nei file responsabili della creazione e dell'accodamento 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. Non è consigliabile utilizzare sia un file queue.yaml che l'API Cloud Tasks, ma potrebbe essere una parte inevitabile della migrazione dalle code di attività a Cloud Tasks, a seconda dell'app. Consulta Utilizzo della gestione delle code rispetto aQueue.yaml per conoscere le best practice.

Creazione di code

Leggi questa sezione se la tua app crea code in modo programmatico 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 porzione LOCATION_ID del nome della coda corrisponde a una regione Google Cloud. La parte QUEUE_ID del nome della coda equivale al campo della coda delle code di attività name. Il nome della coda viene generato durante la creazione della coda in base al progetto, alla regione e a QUEUE_ID specificati.

In generale, la posizione della coda (ossia la regione) deve corrispondere alla regione dell'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 della coda, ma puoi farlo anche aggiornando la coda dopo la sua 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.

Riutilizzo dei nomi delle code

Devi attendere 7 giorni dopo l'eliminazione di una coda per creare una coda con lo stesso ID coda nello stesso progetto e nella stessa località (ad esempio, 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 velocità di 5/s. La seconda coda ha l'ID coda queue-red e invia le attività a una velocità pari a 1/s. Entrambi vengono creati nel progetto con ID progetto your-project-id nella località us-central1. Questo è l'equivalente di Cloud Tasks per la creazione di code nelle code di attività.

gcloud

Gcloud CLI deduce il progetto e la località 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 il riferimento di Cloud Tasks Creazione di una coda di Cloud Tasks.

Impostazione della velocità di elaborazione della coda

La seguente tabella elenca i campi che differiscono dalle code di attività alle code di attività per 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à simultanee che possono essere inviate dalla coda
`bucket_size`	`max_burst_size`	Cloud Tasks calcola una proprietà get-only `max_burst_size` che limita la velocità di elaborazione delle attività in coda in base al valore di `max_dispatches_per_second`. Questo campo consente alla coda di avere una frequenza elevata in modo che l'elaborazione venga avviata poco dopo che un'attività è stata accodata, ma limita l'utilizzo delle risorse quando molte attività sono accodate in un breve periodo di tempo. Per le code di App Engine create o aggiornate utilizzando un file `queue.xml/yaml`, `max_burst_size` è inizialmente uguale a `bucket_size`. Tuttavia, se la coda viene passata in un secondo momento a un comando `update` utilizzando qualsiasi interfaccia di 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 o meno.
`total_storage_limit`	Deprecata in Cloud Tasks	Al momento Cloud Tasks non supporta l'impostazione di un limite di archiviazione personalizzato

Puoi impostare la frequenza di elaborazione della coda quando crei la coda o la aggiorni in un secondo momento. L'esempio seguente utilizza Cloud Tasks per impostare la velocità di elaborazione su una coda denominata queue-blue già creata. Se queue-blue è stato creato o configurato utilizzando un file queue.yaml, l'esempio riportato di seguito viene reimpostatomax_burst_size in base al valore max_dispatches_per_second di 20. Questo è l'equivalente di Cloud Tasks per impostare la velocità di elaborazione delle code 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.

Disabilitazione e ripristino delle code

Cloud Tasks utilizza il termine pause allo stesso modo in cui il termine disable per le code di attività. Mettendo in pausa una coda, l'esecuzione delle attività in coda viene interrotta fino al suo ripristino. Tuttavia, puoi continuare ad aggiungere attività a una coda in pausa. Cloud Tasks utilizza il termine ripresa allo stesso modo delle code di attività.

L'esempio seguente mette in pausa una coda con ID coda queueName. Questo è l'equivalente di 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 il riferimento di Cloud Tasks Mettere in pausa le code.

Eliminazione delle code in corso...

Dopo aver eliminato una coda, devi attendere 7 giorni prima di creare una coda con lo stesso nome. Valuta la possibilità di eliminare tutte le attività da una coda e riconfigurarla se non puoi attendere 7 giorni.

L'esempio seguente elimina la coda con ID foo. Questo è l'equivalente di Cloud Tasks per l'eliminazione di code nelle 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 il riferimento di Cloud Tasks sull'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 seguente tabella elenca i campi che differiscono dalle code di attività alle code di attività per 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 definite attività di App Engine.
`method`	`http_method`	Specifica il metodo di richiesta, ad esempio `POST`
`url`	`relative_uri`	Specifica il gestore delle attività. Nota la differenza nella lettera finale: `i` per l'identificatore della risorsa uniforme anziché `l` per l'identificatore della risorsa uniforme
`target`	`app_engine_routing`	Facoltativo. Specifica i valori `service`, `version` e `instance` di App Engine per un'attività di App Engine. Se non viene configurato, vengono utilizzati il servizio, la versione e l'istanza predefiniti.

L'esempio seguente crea un'attività che viene instradata al gestore /worker sul servizio App Engine predefinito. Questo è l'equivalente di Cloud Tasks per la 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 saperne di più, consulta il riferimento di Cloud Tasks Creazione di attività App Engine.

Specificare il servizio di destinazione e il routing

Specificare il servizio, la versione e l'istanza di App Engine di destinazione per le attività di App Engine è facoltativo. Per impostazione predefinita, le attività di App Engine vengono instradate al servizio, alla versione e all'istanza che sono quelli predefiniti al momento in cui viene tentata l'attività.

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

Per instradare tutte le attività su una determinata coda allo stesso servizio, versione e istanza App Engine, puoi impostare la proprietà app_engine_routing_override nella coda.

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

Passaggio di dati al gestore

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

Cloud Tasks utilizza il termine body nello stesso modo in cui le code di attività utilizzano il termine payload. In Cloud Tasks, il tipo predefinito di contenuti del corpo è un flusso ottetto anziché testo normale. Puoi impostare il tipo di contenuto del corpo specificandolo nell'intestazione.

L'esempio seguente passa una chiave al gestore /worker in due modi diversi. Questo è l'equivalente di Cloud Tasks per passare dati al gestore nelle 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);
      }
    }
  }
}

Attività di denominazione

La specifica del nome dell'attività è facoltativa. Se non specifichi il nome dell'attività, Cloud Tasks la crea per te generando un ID attività e deducendo il progetto e la località (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à equivale al campo name dell'attività delle code di attività.

Riutilizzo dei nomi delle attività

Devi attendere prima di riutilizzare il nome di un'attività. Il tempo che devi attendere prima di eseguire questa operazione varia a seconda che la coda di invio dell'attività sia stata creata in Cloud Tasks o nelle code di attività.

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

L'esempio seguente crea un'attività con l'opzione TASK_ID impostata su first-try e la aggiunge alla coda predefinita. Questo è l'equivalente di Cloud Tasks per la denominazione delle attività nelle code di attività.

gcloud

Gcloud CLI costruisce il nome dell'attività deducendo il progetto e la località dalla tua 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 specificare 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 attività non riuscite

Puoi impostare la configurazione dei nuovi tentativi delle attività sulle code durante la creazione della coda o aggiornando la coda. La tabella seguente elenca il campo Code di attività 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 per i nuovi tentativi specifici per le attività

I parametri per i nuovi tentativi specifici per le attività configurati nelle code di attività funzionano in Cloud Tasks, ma non puoi modificarli o impostarli in nuove attività. Per modificare i parametri dei tentativi per un'attività con parametri per i tentativi specifici per l'attività, ricrea l'attività con una coda Cloud Tasks che abbia i parametri desiderati per i nuovi tentativi.

L'esempio seguente illustra vari scenari di nuovi tentativi:

In fooqueue, le attività vengono tentate fino a sette volte e fino a due giorni dal primo tentativo di esecuzione. Una volta superati entrambi i limiti, il test fallisce definitivamente.
In barqueue, App Engine tenta di riprovare a eseguire le attività, aumentando l'intervallo in modo lineare tra ogni tentativo fino al raggiungimento del backoff massimo e riprovando a tempo indeterminato all'intervallo massimo (quindi gli intervalli tra le richieste sono 10, 20, 30, ..., 190, 200, 200 secondi e così via).
In bazqueue, l'intervallo tra i tentativi inizia da 10 secondi, poi raddoppia tre volte, poi aumenta in modo lineare e infine riprova a tempo indeterminato all'intervallo massimo (quindi gli intervalli tra le richieste sono 10, 20, 40, 80, 160, 240, 300, 300 secondi e così via).

Questo è l'equivalente di Cloud Tasks per ritentare le 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 e 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ù, leggi il riferimento di Cloud Tasks Impostare i parametri per i nuovi tentativi.

Eliminazione di attività da una coda

Quando elimini un'attività, devi attendere 9 giorni prima di creare un'attività con lo stesso nome se 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 foo dalla coda con ID coda queue1. Questo è l'equivalente di Cloud Tasks per l'eliminazione di attività nelle code di attività.

gcloud

Il progetto e la località dell'attività vengono dedotti dal progetto predefinito di 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 saperne di più, consulta il riferimento di Cloud Tasks sull'eliminazione di un'attività da una coda.

Eliminazione definitiva delle attività

L'esempio seguente elimina definitivamente tutte le attività dalla coda con ID coda foo. Questo è l'equivalente di Cloud Tasks per la cancellazione delle attività nelle code di attività.

gcloud

Il progetto e la località della coda vengono dedotti dal progetto predefinito di 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 il riferimento di Cloud Tasks Eliminazione di tutte le attività da una coda.

Per un esempio di Java, vedi Aggiungere un'attività a una coda di Cloud Tasks.

Un esempio di Cloud Tasks in Java 8

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

Il file responsabile della creazione e dell'accodamento dell'attività crea un'attività e la aggiunge alla coda predefinita utilizzando la libreria client di 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 del riferimento REST di Cloud Tasks
Panoramica Riferimento RPC di Cloud Tasks