Elaborazione in background con PHP

Molte app devono eseguire l'elaborazione in background al di fuori del contesto di una richiesta web. Questo tutorial crea un'app web che consente agli utenti di inserire il testo da tradurre e poi visualizza un elenco delle traduzioni precedenti. La traduzione viene eseguita in un processo in background per evitare di bloccare la richiesta dell'utente.

Il seguente diagramma illustra il processo di richiesta di traduzione.

Diagramma dell'architettura.

Ecco la sequenza di eventi che descrive il funzionamento dell'app tutorial:

  1. Visita la pagina web per visualizzare un elenco delle traduzioni precedenti, archiviate in Firestore.
  2. Richiedi la traduzione di un testo inserendo un modulo HTML.
  3. La richiesta di traduzione viene pubblicata su Pub/Sub.
  4. Un'app Cloud Run riceve il messaggio Pub/Sub.
  5. L'app Cloud Run utilizza Cloud Translation per tradurre il testo.
  6. L'app Cloud Run archivia il risultato in Firestore.

Questo tutorial è rivolto a chiunque sia interessato a scoprire di più sull'elaborazione in background con Google Cloud. Non è richiesta alcuna esperienza pregressa con Pub/Sub, Firestore, App Engine o Cloud Run. Tuttavia, per comprendere tutto il codice, è utile avere una certa esperienza con PHP, JavaScript e HTML.

Obiettivi

  • Comprendere ed eseguire il deployment dei servizi Cloud Run.
  • Comprendere ed eseguire il deployment di un'app App Engine.
  • Prova l'app.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il calcolatore prezzi.

I nuovi utenti di Google Cloud potrebbero avere diritto a una prova senza costi.

Al termine delle attività descritte in questo documento, puoi evitare l'addebito di ulteriori costi eliminando le risorse che hai creato. Per saperne di più, consulta Esegui la pulizia.

Prima di iniziare

  1. Accedi al tuo account Google Cloud . Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti senza costi per l'esecuzione, il test e il deployment dei workload.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. Enable the Firestore, Cloud Run, Pub/Sub, and Cloud Translation APIs.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the APIs

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  6. Verify that billing is enabled for your Google Cloud project.

  7. Enable the Firestore, Cloud Run, Pub/Sub, and Cloud Translation APIs.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the APIs

    8.

  8. Nella console Google Cloud , apri l'app in Cloud Shell.

    Vai a Cloud Shell

    Cloud Shell fornisce l'accesso da riga di comando alle risorse cloud direttamente dal browser. Apri Cloud Shell nel browser e fai clic su Continua per scaricare il codice campione e modificarlo nella directory dell'applicazione.

  9. In Cloud Shell, configura lo strumento gcloud in modo da utilizzare il tuo progetto Google Cloud : 
    # Configure gcloud for your project
gcloud config set project YOUR_PROJECT_ID

Informazioni sul backend di Cloud Run

Definisci una singola funzione PHP translateString e configura il servizio Cloud Run in modo che risponda a un messaggio Pub/Sub richiamando questa funzione.

use Google\Cloud\Firestore\FirestoreClient;
use Google\Cloud\Firestore\Transaction;
use Google\Cloud\Translate\TranslateClient;


/**
 * @param array $data {
 *     The PubSub message data containing text and target language.
 *
 *     @type string $text
 *           The full text to translate.
 *     @type string $language
 *           The target language for the translation.
 * }
 */
function translateString(array $data)
{
    if (empty($data['language']) || empty($data['text'])) {
        throw new Exception('Error parsing translation data');
    }

    $firestore = new FirestoreClient();
    $translate = new TranslateClient();

    $translation = [
        'original' => $data['text'],
        'lang' => $data['language'],
    ];

    $docId = sprintf('%s:%s', $data['language'], base64_encode($data['text']));
    $docRef = $firestore->collection('translations')->document($docId);

    $firestore->runTransaction(
        function (Transaction $transaction) use ($translate, $translation, $docRef) {
            $snapshot = $transaction->snapshot($docRef);
            if ($snapshot->exists()) {
                return; // Do nothing if the document already exists
            }

            $result = $translate->translate($translation['original'], [
                'target' => $translation['lang'],
            ]);
            $transaction->set($docRef, $translation + [
                'translated' => $result['text'],
                'originalLang' => $result['source'],
            ]);
        }
    );

    echo "Done.";
}

  1. La funzione deve importare diverse dipendenze per connettersi a Firestore e Translation.

    use Google\Cloud\Firestore\FirestoreClient;
use Google\Cloud\Firestore\Transaction;
use Google\Cloud\Translate\TranslateClient;

  2. Cloud Run inizia inizializzando i client Firestore e Pub/Sub. Quindi, analizza i dati dei messaggi Pub/Sub per ottenere il testo da tradurre e la lingua di destinazione desiderata.

    $firestore = new FirestoreClient();
$translate = new TranslateClient();

$translation = [
    'original' => $data['text'],
    'lang' => $data['language'],
];

  3. L'API Translation viene utilizzata per tradurre la stringa nella lingua desiderata.

    $result = $translate->translate($translation['original'], [
    'target' => $translation['lang'],
]);

  4. La funzione genera un nome univoco per la richiesta di traduzione per assicurarsi di non memorizzare traduzioni duplicate. Poi, la traduce in una transazione Firestore per assicurarsi che le esecuzioni simultanee non eseguano accidentalmente la stessa traduzione due volte.

    $docId = sprintf('%s:%s', $data['language'], base64_encode($data['text']));
$docRef = $firestore->collection('translations')->document($docId);

$firestore->runTransaction(
    function (Transaction $transaction) use ($translate, $translation, $docRef) {
        $snapshot = $transaction->snapshot($docRef);
        if ($snapshot->exists()) {
            return; // Do nothing if the document already exists
        }

        $result = $translate->translate($translation['original'], [
            'target' => $translation['lang'],
        ]);
        $transaction->set($docRef, $translation + [
            'translated' => $result['text'],
            'originalLang' => $result['source'],
        ]);
    }
);

Creazione ed esecuzione del deployment del backend Cloud Run

  • Crea l'app Cloud Run nella directory backend:

    gcloud builds submit backend/ \
  --tag gcr.io/PROJECT_ID/background-function

  • Esegui il deployment dell'app Cloud Run utilizzando il tag immagine del passaggio precedente:

    gcloud run deploy background-processing-function --platform managed \
  --image gcr.io/PROJECT_ID/background-function --region REGION

    Dove REGION è una Google Cloud regione.

  • Al termine del deployment, nell'output comando vedrai un URL per l'app di cui è stato eseguito il deployment. Ad esempio:

    Service [background-processing-function] revision [default-00002-vav] has been deployed and is serving 100 percent of traffic at https://default-c457u4v2ma-uc.a.run.app

    Copia questo URL per il passaggio successivo.

Configurazione della sottoscrizione Pub/Sub

La tua app Cloud Run riceverà messaggi da Pub/Sub ogni volta che un messaggio viene pubblicato nell'argomento translate.

Un controllo di autenticazione integrato garantisce che il messaggio Pub/Sub contenga un token di autorizzazione valido da unaccount di serviziot che dispone dell'autorizzazione per richiamare il backend Cloud Run.

I passaggi successivi ti guidano nella configurazione dell'argomento Pub/Sub, della sottoscrizione e del account di servizio per effettuare chiamate autenticate al backend Cloud Run. Scopri di più su questa integrazione in Autenticazione da servizio a servizio.

  1. Crea l'argomento translate per pubblicare nuove richieste di traduzione:

    gcloud pubsub topics create translate

  2. Consenti al tuo progetto di creare token di autenticazione Pub/Sub:

    gcloud projects add-iam-policy-binding PROJECT_ID \
     --member=serviceAccount:service-PROJECT_NUMBER@gcp-sa-pubsub.iam.gserviceaccount.com \
     --role=roles/iam.serviceAccountTokenCreator

    Dove PROJECT_NUMBER è il numero del tuo progetto Google Cloud , che puoi trovare eseguendo gcloud projects describe PROJECT_ID | grep projectNumber.

  3. Crea o seleziona un service account per rappresentare l'identità della sottoscrizione Pub/Sub.

    gcloud iam service-accounts create cloud-run-pubsub-invoker \
     --display-name "Cloud Run Pub/Sub Invoker"

    Nota: puoi utilizzare cloud-run-pubsub-invoker o sostituirlo con un nome univoco all'interno del tuo progetto Google Cloud .

  4. Concedi al account di servizio chiamante l'autorizzazione per richiamare il servizio background-processing-function:

    gcloud run services add-iam-policy-binding background-processing-function \
   --member=serviceAccount:cloud-run-pubsub-invoker@PROJECT_ID.iam.gserviceaccount.com \
   --role=roles/run.invoker  --platform managed --region REGION

    La propagazione delle modifiche di Identity and Access Management può richiedere diversi minuti. Nel frattempo, potresti visualizzare errori HTTP 403 nei log del servizio.

  5. Crea una sottoscrizione Pub/Sub con il account di servizio:

    gcloud pubsub subscriptions create run-translate-string --topic translate \
   --push-endpoint=CLOUD_RUN_URL \
   --push-auth-service-account=cloud-run-pubsub-invoker@PROJECT_ID.iam.gserviceaccount.com

    dove CLOUD_RUN_URL è l'URL HTTPS che hai copiato dopo aver creato e implementato il backend.

    Il flag --push-account-service-account attiva la funzionalità push di Pub/Sub per l'autenticazione e l'autorizzazione.

    Il dominio del servizio Cloud Run viene registrato automaticamente per l'utilizzo con gli abbonamenti Pub/Sub.

Informazioni sull'app

L'app web è composta da due componenti principali:

  • Un server HTTP PHP per gestire le richieste web. Il server ha i seguenti due endpoint:
    • /: elenca tutte le traduzioni esistenti e mostra un modulo che gli utenti possono inviare per richiedere nuove traduzioni.
    • /request-translation: gli invii di moduli vengono inviati a questo endpoint, che pubblica la richiesta su Pub/Sub per essere tradotta in modo asincrono.
  • Un modello HTML compilato con le traduzioni esistenti dal server PHP.

Il server HTTP

  • Nella directory app, index.php inizia configurando l'app Lumen e registrando i gestori HTTP:

    $app = new Laravel\Lumen\Application(__DIR__);
$app->router->group([
], function ($router) {
    require __DIR__ . '/routes/web.php';
});
$app->run();

  • Il gestore dell'indice (/) recupera tutte le traduzioni esistenti da Firestore e visualizza un modello con l'elenco:

    /**
 * Homepage listing all requested translations and their results.
 */
$router->get('/', function (Request $request) use ($projectId) {
    $firestore = new FirestoreClient([
        'projectId' => $projectId,
    ]);
    $translations = $firestore->collection('translations')->documents();
    return view('home', ['translations' => $translations]);
});

  • Il gestore di traduzione delle richieste, registrato all'indirizzo /request-translation, analizza l'invio del modulo HTML, convalida la richiesta e pubblica un messaggio in Pub/Sub:

    /**
 * Endpoint which publishes a PubSub request for a new translation.
 */
$router->post('/request-translation', function (Request $request) use ($projectId) {
    $acceptableLanguages = ['de', 'en', 'es', 'fr', 'ja', 'sw'];
    if (!in_array($lang = $request->get('lang'), $acceptableLanguages)) {
        throw new Exception('Unsupported Language: ' . $lang);
    }
    if (!$text = $request->get('v')) {
        throw new Exception('No text to translate');
    }
    $pubsub = new PubSubClient([
        'projectId' => $projectId,
    ]);
    $topic = $pubsub->topic('translate');
    $topic->publish(['data' => json_encode([
        'language' => $lang,
        'text' => $text,
    ])]);

    return '';
});

Modello HTML

Il modello HTML è la base della pagina HTML mostrata all'utente in modo che possa visualizzare le traduzioni precedenti e richiederne di nuove. Il modello viene compilato dal server HTTP con l'elenco delle traduzioni esistenti.

  • L'elemento <head> del modello HTML include metadati, fogli di stile e JavaScript per la pagina:

    La pagina recupera gli asset CSS e JavaScript di Material Design Lite (MDL). MDL ti consente di aggiungere l'aspetto di Material Design ai tuoi siti web.

    La pagina utilizza JQuery per attendere il completamento del caricamento del documento e impostare un gestore di invio del modulo. Ogni volta che viene inviato il modulo di richiesta di traduzione, la pagina esegue una convalida minima del modulo per verificare che il valore non sia vuoto, quindi invia una richiesta asincrona all'endpoint /request-translation.

    Infine, viene visualizzata una snackbar MDL per indicare se la richiesta è andata a buon fine o se si è verificato un errore.

  • Il corpo HTML della pagina utilizza un layout MDL e diversi componenti MDL per visualizzare un elenco di traduzioni e un modulo per richiedere traduzioni aggiuntive: 
    <body>
  <div class="mdl-layout mdl-js-layout mdl-layout--fixed-header">
    <header class="mdl-layout__header">
      <div class="mdl-layout__header-row">
        <!-- Title -->
        <span class="mdl-layout-title">Translate with Background Processing</span>
      </div>
    </header>
    <main class="mdl-layout__content">
      <div class="page-content">
        <div class="mdl-grid">
          <div class="mdl-cell mdl-cell--1-col"></div>
          <div class="mdl-cell mdl-cell--3-col">
            <form id="translate-form" class="translate-form">
              <div class="mdl-textfield mdl-js-textfield mdl-textfield--floating-label">
                <input class="mdl-textfield__input" type="text" id="v" name="v">
                <label class="mdl-textfield__label" for="v">Text to translate...</label>
              </div>
              <select class="mdl-textfield__input lang" name="lang">
                <option value="de">de</option>
                <option value="en">en</option>
                <option value="es">es</option>
                <option value="fr">fr</option>
                <option value="ja">ja</option>
                <option value="sw">sw</option>
              </select>
              <button class="mdl-button mdl-js-button mdl-button--raised mdl-button--accent" type="submit"
                  name="submit">Submit</button>
            </form>
          </div>
          <div class="mdl-cell mdl-cell--8-col">
            <table class="mdl-data-table mdl-js-data-table mdl-shadow--2dp">
              <thead>
                <tr>
                  <th class="mdl-data-table__cell--non-numeric"><strong>Original</strong></th>
                  <th class="mdl-data-table__cell--non-numeric"><strong>Translation</strong></th>
                </tr>
              </thead>
              <tbody>
              <?php foreach ($translations as $translation): ?>
                <tr>
                  <td class="mdl-data-table__cell--non-numeric">
                    <span class="mdl-chip mdl-color--primary">
                      <span class="mdl-chip__text mdl-color-text--white"><?= $translation['originalLang'] ?></span>
                    </span>
                  <?= $translation['original'] ?>
                  </td>
                  <td class="mdl-data-table__cell--non-numeric">
                    <span class="mdl-chip mdl-color--accent">
                      <span class="mdl-chip__text mdl-color-text--white"><?= $translation['lang'] ?></span>
                    </span>
                    <?= $translation['translated'] ?>
                  </td>
                </tr>
              <?php endforeach ?>
              </tbody>
            </table>
            <br/>
            <button class="mdl-button mdl-js-button mdl-button--raised" type="button" onClick="window.location.reload();">Refresh</button>
          </div>
        </div>
      </div>
      <div aria-live="assertive" aria-atomic="true" aria-relevant="text" class="mdl-snackbar mdl-js-snackbar" id="snackbar">
        <div class="mdl-snackbar__text mdl-color-text--black"></div>
        <button type="button" class="mdl-snackbar__action"></button>
      </div>
    </main>
  </div>
</body>
</html>

Esecuzione dell'app in Cloud Shell

Prima di provare a eseguire il deployment dell'app web, installa le dipendenze ed eseguila localmente.

  1. Innanzitutto, installa le dipendenze con Composer. È richiesta l'estensione gRPC per PHP, che è preinstallata su Cloud Shell.

    composer install -d app

  2. Successivamente, esegui il server web incorporato PHP per pubblicare l'app:

    APP_DEBUG=true php -S localhost:8080 -t app

    Il flag APP_DEBUG=true mostrerà eventuali eccezioni che si verificano.

  3. In Cloud Shell, fai clic su Anteprima web , e seleziona Anteprima sulla porta 8080. Viene visualizzata una nuova finestra che mostra la tua app in esecuzione.

Deployment dell'app web

Puoi utilizzare l'ambiente standard di App Engine per creare ed eseguire il deployment di un'app che viene eseguita in modo affidabile anche se sottoposta a un carico elevato e con grandi quantità di dati.

Questo tutorial utilizza l'ambiente standard di App Engine per eseguire il deployment del frontend HTTP.

app.yaml configura l'app App Engine:

runtime: php73

env_variables:
  APP_DEBUG: true
  LOG_CHANNEL: stderr
  APP_STORAGE: /tmp
  • Dalla stessa directory del file app.yaml, esegui il deployment dell'app nell'ambiente standard di App Engine: 
    gcloud app deploy

Testare l'app

Dopo aver eseguito il deployment della funzione Cloud Run e dell'app App Engine, prova a richiedere una traduzione.

  1. Per visualizzare l'app nel browser,inserisci il seguente URL:

    https://PROJECT_ID.REGION_ID.r.appspot.com

    Sostituisci quanto segue:

    C'è una pagina con un elenco vuoto di traduzioni e un modulo per richiedere nuove traduzioni.

  2. Nel campo Testo da tradurre, inserisci un testo da tradurre, ad esempio Hello, World.
  3. Seleziona una lingua dall'elenco a discesa in cui vuoi tradurre il testo.
  4. Fai clic su Invia.
  5. Per aggiornare la pagina, fai clic su Aggiorna . È presente una nuova riga nell'elenco delle traduzioni. Se non vedi una traduzione, attendi qualche altro secondo e riprova. Se ancora non vedi una traduzione, consulta la sezione successiva sul debug dell'app.

Esecuzione del debug dell'app

Se non riesci a connetterti alla tua app App Engine o non vedi nuove traduzioni, controlla quanto segue:

  1. Verifica che i comandi di deployment gcloud siano stati completati correttamente e non abbiano generato errori. Se si sono verificati errori (ad esempio, message=Build failed), correggili e prova a creare e distribuire l'app Cloud Run e distribuire di nuovo l'app App Engine.

  2. Nella console Google Cloud , vai alla pagina Esplora log.

    Vai alla pagina Esplora log

    1. Nell'elenco a discesa Risorse selezionate di recente, fai clic su GAE Application, quindi su Tutti i module_id. Viene visualizzato un elenco di richieste relative alle tue visite all'app. Se non vedi un elenco di richieste, verifica di aver selezionato Tutti i module_id dall'elenco a discesa. Se visualizzi messaggi di errore stampati nella console Google Cloud , controlla che il codice dell'app corrisponda al codice nella sezione relativa alla comprensione dell'app web.
    2. Nell'elenco a discesa Risorse selezionate di recente, fai clic su Revisione Cloud Run e poi su Tutti i log. Dovresti visualizzare una richiesta POST inviata all'URL dell'app di cui è stato eseguito il deployment. In caso contrario, verifica che l'app Cloud Run e App Engine utilizzino lo stesso argomento Pub/Sub e che esista un abbonamento Pub/Sub per il push all'endpoint Cloud Run.

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Elimina il progetto Google Cloud

  1. Nella console Google Cloud , vai alla pagina Gestisci risorse.

    Vai a Gestisci risorse

  2. Nell'elenco dei progetti, seleziona quello che vuoi eliminare, quindi fai clic su Elimina.
  3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Elimina le risorse del tutorial

  1. Elimina l'app App Engine che hai creato in questo tutorial:

    1. Nella console Google Cloud , vai alla pagina Versioni per App Engine.

      Vai a Versioni

    2. Seleziona la casella di controllo per la versione dell'app non predefinita che vuoi eliminare.
    3. Per eliminare la versione dell'app, fai clic su Elimina.

  2. Elimina il servizio Cloud Run di cui hai eseguito il deployment in questo tutorial:

    gcloud run services delete background-processing-function

    Puoi eliminare i servizi Cloud Run anche dalla consoleGoogle Cloud .

  3. Elimina le altre Google Cloud risorse create in questo tutorial:

Passaggi successivi