Questa pagina è stata tradotta dall'API Cloud Translation.

Migrazione delle code in modalità push a Cloud Tasks

In questa pagina viene descritto come eseguire la migrazione del codice delle code in coda in modalità push da 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 accedi allo stesso servizio a cui accedi con l'API RPC Task Queues. Ciò significa che non hai bisogno per ricreare le code e le attività di push esistenti. Tuttavia, devi eseguire la migrazione codice che crea o interagisce con code in modalità push o attività push per utilizzare l'API Cloud Tasks.

Puoi creare e interagire con code in modalità push e attività di push utilizzando il API REST e RPC di Cloud Tasks, la piattaforma Cloud Tasks libreria client, Google Cloud CLI e Console Google Cloud. Questa pagina fornisce esempi relativi all'utilizzo gcloud CLI e Cloud Tasks libreria client.

In Cloud Tasks, tutte le code funzionano come code in modalità push. Nella nella parte restante di questa guida e documentazione di Cloud Tasks, il termine coda è equivalente al termine coda push. Analogamente, il termine attività equivale a il termine attività push.

Funzionalità non disponibili in Cloud Tasks

Le seguenti funzionalità non sono disponibili in Cloud Tasks:

Accodamento delle attività nelle transazioni Datastore
Utilizzo della libreria delle attività differite anziché di un servizio worker
Utilizzo delle attività nelle applicazioni multi-tenant
Simulazione con il server di sviluppo locale
Aggiunta delle attività in modo asincrono.

Prezzi e quote

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

Prezzi

Cloud Tasks prevede prezzi specifici. Come con code di attività, l'invio di richieste all'app App Engine con un può comportare costi aggiuntivi per la tua app.

Quote

Le quote di Cloud Tasks sono diverse le quote per le code di attività. Come con Code di attività, invio di richieste all'app App Engine da Cloud Tasks potrebbe influire su App Engine quote per le richieste.

Prima della migrazione

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

Migrazione delle code in modalità pull

Prima di iniziare, eseguire la migrazione delle code in modalità pull prima di seguire le istruzioni di questa guida per la migrazione delle code in modalità push. La migrazione delle code in modalità pull dopo la migrazione delle code in modalità push consigliato perché è probabile che l'uso obbligatorio del file queue.yaml causi e inaspettato con Cloud Tasks.

Protezione della configurazione delle code

Una volta iniziato il processo di migrazione a Cloud Tasks, la modifica del file queue.yaml può causare comportamenti imprevisti e non consigliato. Proteggi la configurazione della coda dalle modifiche apportate dal queue.yaml con i seguenti passaggi.

Configura gcloud CLI per omettere il file queue.yaml in futuro deployment di machine learning.

Aggiungi il tuo file queue.yaml a un file .gcloudignore. Per verificare se hai già un file .gcloudignore, puoi eseguire questo comando in del terminale dalla directory di primo livello dell'app. Questo comando restituisce il nome file, se esistente.
```
ls -a | grep .gcloudignore
```
Per scoprire di più sui file .gcloudignore, leggi le Riferimento .gcloudignore.
Limita le autorizzazioni per il tuo file queue.yaml.

Segui le best practice descritte nella nostra guida sulle di proteggere la configurazione della coda.
Scopri di più su Cloud Tasks e il file queue.yaml (facoltativo).

Quando utilizzi l'API Cloud Tasks per gestire la coda configurazione, il deployment di un file queue.yaml esegue l'override dell'insieme di configurazione da Cloud Tasks, che possono causare comportamenti imprevisti. Letto Utilizzo della gestione delle code e della gestione delle code.yaml per l'apprendimento altro ancora.

Abilitazione dell'API Cloud Tasks

Per abilitare l'API Cloud Tasks, fai clic su Abilita nella API Cloud Tasks nella libreria API. Se vedi un pulsante Gestisci anziché il pulsante Pulsante Abilita, hai precedentemente abilitato l'API Cloud Tasks per il tuo progetto e non dovrai 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 localmente, ti consigliamo di utilizzare un account di servizio. Per per istruzioni su come configurare un account di servizio e connetterlo alla tua app, leggi Ottenere e fornire manualmente le credenziali dell'account di servizio.

Per eseguire il deployment della tua app su App Engine, non devi fornire nuovi autenticazione. Le credenziali predefinite dell'applicazione (ADC) deducono l'autenticazione per le app di App Engine.

Download di gcloud CLI

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

gcloud components update

Importazione delle librerie client di Cloud

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

Specifica la dipendenza della libreria client di Cloud Tasks 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 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

In questa sezione viene descritto come creare e gestire le code utilizzando API Cloud Tasks.

Con Cloud Tasks, non utilizzi un file queue.yaml per creare o gestire le code. Utilizza invece l'API Cloud Tasks. Se utilizzi sia queue.yaml e l'API Cloud Tasks non sono consigliati, ma potrebbe essere una parte inevitabile della migrazione dalle code di attività di Cloud Tasks, a seconda dell'app. Letto Utilizzo della gestione delle code e della gestione delle code.yaml per l'apprendimento sulle best practice.

Creazione di code

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

In generale, la posizione della coda (ad es. regione) deve corrispondere alla regione di la tua app. Le due eccezioni a questa regola riguardano le app che utilizzano l'europe-west e le app che utilizzano la regione us-central. In Cloud Tasks, queste regioni sono rispettivamente denominate europe-west1 e us-central1.

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

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

Riutilizzo dei nomi di coda

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 es. regione).

L'esempio seguente crea due code utilizzando Cloud Tasks. La la prima coda ha l'ID coda queue-blue ed è configurata per inviare tutte le attività a la versione v2 del servizio task-module a una tariffa di 5/s. Il secondo La coda ha ID coda queue-red e invia attività a una frequenza di 1/s. Entrambi sono creato nel progetto con ID progetto your-project-id nella località us-central1. Questo è l'equivalente in Cloud Tasks della creazione di code nelle code di attività.

gcloud

gcloud CLI deduce il progetto e la località la configurazione della gcloud 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ù, leggi la documentazione di riferimento di Cloud Tasks Creazione di un'attività Cloud Tasks .

Impostare la frequenza di elaborazione della coda

Nella tabella seguente sono elencati i campi che differiscono dalle code di attività in 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 dall'account coda
`bucket_size`	`max_burst_size`	Cloud Tasks calcola una proprietà get-only `max_burst_size` che limita la velocità delle attività in coda vengono elaborati in base al valore `max_dispatches_per_second`. Questo campo consente alla coda hanno una frequenza elevata, in modo che l'elaborazione inizi poco dopo in coda, ma limita l'utilizzo delle risorse quando molte attività sono accodate in poco tempo. Per le code di 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 `update` utilizzando un qualsiasi comando Cloud Tasks a riga di comando, `max_burst_size` verrà reimpostato in base all'interfaccia di `max_dispatches_per_second`, indipendentemente dal fatto che `max_dispatches_per_second` è aggiornato.
`total_storage_limit`	Deprecato in Cloud Tasks	Cloud Tasks non supporta l'impostazione di limite di spazio di archiviazione personalizzato

Puoi impostare la frequenza di elaborazione della coda quando crei o la aggiorni in seguito. L'esempio seguente utilizza Cloud Tasks per impostare velocità di elaborazione su una coda denominata queue-blue già creata. Se queue-blue è stato creato o configurato utilizzando un file queue.yaml, come segue esempio reimpostamax_burst_size in base al valore max_dispatches_per_second di 20. Questo è l'equivalente di Cloud Tasks l'impostazione della coda di elaborazione conv. 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 ulteriori informazioni, consulta Definire i limiti di frequenza.

Disabilitazione e ripristino delle code

Cloud Tasks utilizza il termine pause nello stesso modo in cui l'attività Code utilizza il termine disable. Se metti in pausa una coda, le attività in coda verranno interrotte dall'esecuzione fino alla ripresa della coda. Tuttavia, puoi continuare ad aggiungere le attività in una coda in pausa. Cloud Tasks utilizza il termine riprendi come fa la coda di attività.

L'esempio seguente mette in pausa una coda con ID coda queueName. Questo è l'equivalente di Cloud Tasks disattivazione 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ù, leggi la documentazione di riferimento di Cloud Tasks Messa in pausa code.

Eliminazione delle code in corso...

Una volta eliminata una coda, devi attendere 7 giorni prima di creare una coda con con lo stesso nome. Valuta la possibilità di eliminare tutte le attività da una coda e riconfigurazione della coda se non puoi attendere 7 giorni.

Nell'esempio seguente viene eliminata la coda con ID coda foo. Questo è l'equivalente di Cloud Tasks eliminare 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ù, leggi la documentazione di riferimento di Cloud Tasks Eliminazione in corso code.

Creazione e gestione delle attività

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

Creazione di attività

Nella tabella seguente sono elencati i campi che differiscono dalle code di attività in 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. Questi vengono 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 Uniform Resource Identifier anziché per `l` per Uniform Resource Locator
`target`	`app_engine_routing`	Facoltativo. Specifica l'`service` di App Engine, `version` e `instance` per un dell'attività di App Engine. Se non viene configurato, viene utilizzato il servizio predefinito, la versione e l'istanza.

L'esempio seguente crea un'attività che instrada al gestore /worker nell'App Engine predefinito completamente gestito di Google Cloud. Questo è l'equivalente di Cloud Tasks creazione in corso le tue 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ù, leggi la documentazione di riferimento di Cloud Tasks Creazione di attività App Engine.

Specificare il servizio e il routing di destinazione

Specifica il servizio, la versione e l'istanza di destinazione di App Engine per Le attività di App Engine sono facoltative. Per impostazione predefinita, le attività di App Engine vengono instradate al servizio, alla versione e all'istanza, che sono le l'ora in cui viene tentata l'attività.

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

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

Per saperne di più, leggi la documentazione di riferimento di Cloud Tasks Configurare il routing.

Trasferimento dei dati al gestore

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

Cloud Tasks utilizza il termine corpo nello stesso modo in cui Attività Code utilizza il termine payload. In Cloud Tasks, l'impostazione predefinita il tipo di contenuti del corpo è in streaming a ottetto anziché in testo normale. Puoi impostare il corpo content type specificandolo nell'intestazione.

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

Specificare il nome dell'attività è facoltativo. Se non specifichi il nome dell'attività, Cloud Tasks lo crea per te generando un ID attività e dedurre il progetto e la località (ad es. la regione) in base alla coda specificato 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 TASK_ID parte del nome dell'attività equivale al Campo dell'attività name delle code di attività.

Riutilizzo dei nomi delle attività

Devi attendere prima di riutilizzare il nome di un'attività. La quantità di tempo che devi l'attesa prima di farlo varia a seconda che la coda di invio dell'attività sia in Cloud Tasks o nelle code di attività.

Per le attività in code create utilizzando Code di attività (compresa la coda predefinita), devi attendere circa 9 giorni dopo il l'attività originale è stata eliminata o eseguita. Per le attività in code create utilizzando Cloud Tasks, devi attendere circa un'ora dopo l'attività originale è stata eliminata o eseguita.

L'esempio seguente crea un'attività con TASK_ID impostato su first-try e la aggiunge alla coda predefinita. Questo è il Cloud Tasks equivalente di denominazione le tue attività nelle code di attività.

gcloud

gcloud CLI crea il nome dell'attività deducendo il progetto e località della 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 il progetto e la posizione 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à nelle code durante la creazione delle code oppure aggiornare la coda. La tabella seguente elenca il campo Code 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 dei nuovi tentativi specifici per l'attività

Parametri per i nuovi tentativi specifici dell'attività configurati in Le code di attività funzionano in Cloud Tasks, non possono modificarli né impostarli per nuove attività. Per modificare i parametri dei nuovi tentativi per un che ha parametri specifici per i nuovi tentativi, ricreala con Coda di Cloud Tasks con i parametri desiderati per i nuovi tentativi.

L'esempio seguente illustra vari scenari di nuovo tentativo:

In fooqueue, le attività vengono tentate di nuovo per un massimo di sette volte e per un massimo di due giorni dal primo tentativo di esecuzione. Dopo il superamento di entrambi i limiti, l'operazione non riesce definitivamente.
In barqueue, App Engine tenta di riprovare le attività, aumentando di intervallo in modo lineare tra un nuovo tentativo e l'altro fino a raggiungere il backoff massimo riprovando all'infinito all'intervallo massimo (quindi gli intervalli tra le richieste sono 10, 20, 30, ..., 190, 200, 200, ...).
Nel mese di bazqueue, l'intervallo tra nuovi tentativi inizia 10 secondi e poi raddoppia per tre volte. poi aumenta in modo lineare e infine riprova a tempo indeterminato per l'intervallo massimo (in modo che gli intervalli tra le richieste Anni '10, '20, '40, '80, 160, 240, 300, 300, ...).

Questo è l'equivalente di Cloud Tasks nuovo tentativo in corso le tue 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ù, leggi la documentazione di riferimento di Cloud Tasks Imposta i parametri per i nuovi tentativi.

Eliminazione di 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, oppure 1 ora se l'attività si trovava in una coda creata con Cloud Tasks.

L'esempio seguente elimina l'attività con ID attività foo dalla coda con ID coda queue1. Questo è l'equivalente di Cloud Tasks eliminazione le tue attività nelle code di attività.

gcloud

Il progetto e la località dell'attività vengono dedotti dall'interfaccia predefinita di gcloud CLI progetto.

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ù, leggi la documentazione di riferimento di Cloud Tasks L'eliminazione di un'attività da un .

Eliminazione definitiva delle attività

L'esempio seguente elimina definitivamente tutte le attività dalla coda con ID coda foo. Questo è il Equivalente di Cloud Tasks di eliminazione le tue attività nelle code di attività.

gcloud

Il progetto e la località della coda vengono dedotti dall'interfaccia predefinita di gcloud CLI progetto.

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ù, leggi la documentazione di riferimento di Cloud Tasks Espandere tutte le attività da una coda.

Esempio di Java 8 Cloud Tasks

L'esempio seguente è una configurazione di base per creare una coda e accodare un con Cloud Tasks. Si presuppone che lo sviluppatore abbia ha creato un file pom.xml per specificare la dipendenza di Cloud Tasks come descritto nella sezione Importazione del client libreria di Google Cloud. Questo è il Cloud Tasks equivalente di Una coda di attività Java 8 esempio in Code di attività.

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