Monitoraggio delle prestazioni web serverless mediante Cloud Functions

---

Questo tutorial descrive come creare un'app per il monitoraggio delle prestazioni sul web utilizzando le tecnologie serverless di Google Cloud.

La performance gioca un ruolo principale per il successo di qualsiasi app web. Se il tuo sito non ha un buon rendimento, potresti riscontrare meno registrazioni e una minore fidelizzazione il che probabilmente influirà sui tuoi obiettivi commerciali. Le prestazioni devono essere fondamentali un criterio di successo durante la progettazione, la creazione e il test della tua app web.

Tuttavia, anche le prestazioni delle pagine possono cambiare nel tempo man mano che l'app si evolve. Gli sviluppatori possono aggiungere o aggiornare immagini e script oppure la pubblicazione dell'app sottostante la stessa infrastruttura può cambiare. Pertanto, è importante monitorare regolarmente le prestazioni della pagina. Generalmente, memorizzi le metriche sul rendimento per abilitare l'analisi storica. È pratica comune anche generare avvisi se il rendimento è inferiore ad alcune soglie definite.

Obiettivi

• Crea un funzione Cloud Functions Functions che utilizza Chrome headless per raccogliere metriche sulle prestazioni delle pagine web.
• Archivia le metriche in Cloud Storage.
• Crea un'altra Cloud Function, attivata da Cloud Storage per analizzare le metriche della pagina.
• Archivia i risultati dell'analisi in Firestore.
• Crea un'altra Cloud Function, attivata da Firestore evento di creazione, per pubblicare un avviso Pub/Sub se le prestazioni della pagina sono scarse.
• Crea un Cloud Scheduler un job per attivare periodicamente la prima Cloud Function.
• Verifica gli output per verificare che siano riusciti e per gli scenari di errore.

Costi

Questo tutorial utilizza componenti fatturabili di Google Cloud, tra cui:

• Cloud Functions
• Cloud Scheduler
• Cloud Storage
• Firestore
• Pub/Sub
• Container Registry
• Cloud Build

Utilizza la Calcolatore prezzi per generare una stima dei costi in base all'utilizzo previsto.

Prima di iniziare

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

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

2. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

3. Abilita le API Cloud Functions, Cloud Scheduler, Pub/Sub, and Cloud Build.

   Abilita le API

Architettura

Le operazioni di monitoraggio delle prestazioni web sono in genere stateless e di breve durata. Spesso sono anche basati su eventi e si verificano in base a una pianificazione o vengono attivati parte di un altro processo, ad esempio una pipeline di test automatizzata. Questi rendono le architetture serverless una scelta che implementano le app di analisi web.

In questo tutorial, utilizzerai varie parti del framework Google Cloud serverless tra cui Cloud Functions, Firestore, Cloud Scheduler e Pub/Sub. Non è necessario gestire infrastruttura per uno qualsiasi di questi servizi e paghi solo per ciò che utilizzi. La core dell'app è implementato utilizzando Cloud Functions, che fornisce un ambiente di esecuzione serverless scalabile e basato su eventi. Utilizzo Cloud Functions, puoi creare e connettere app pezzi di logica indipendenti e a basso accoppiamento.

Il seguente diagramma mostra l'architettura della soluzione serverless che che crei in questo tutorial.

preparazione dell'ambiente

Prima di creare l'ambiente serverless, ottieni il codice da GitHub, imposta variabili e preparare le risorse di cui avrai bisogno in seguito per l'analisi e l'archiviazione.

Ottieni il codice e imposta le variabili di ambiente

1. Nella console Google Cloud, apri Cloud Shell.

   Apri Cloud Shell

2. Clona il repository che contiene il codice per Cloud Functions utilizzato in questo tutorial:

   git clone https://github.com/GoogleCloudPlatform/solutions-serverless-web-monitoring.git
   

3. Passa alla directory Functions:

   cd solutions-serverless-web-monitoring/functions
   

4. Imposta l'ID e il numero di progetto attuali come variabili di shell:

   export PROJECT=$DEVSHELL_PROJECT_ID
   export PROJECT_NUM=$(gcloud projects list \
       --filter="$PROJECT" \
       --format="value(PROJECT_NUMBER)")
   

5. Imposta la regione di deployment predefinita per Cloud Functions. La nell'esempio seguente la regione viene impostata su us-east1, ma puoi modificare l'impostazione a qualsiasi regione in cui è disponibile Cloud Functions.

   export REGION=us-east1
   gcloud config set functions/region $REGION
   

Creazione di bucket di Cloud Storage

In questa sezione creerai un bucket Cloud Storage per archiviare raccolti dai dati sulle prestazioni delle pagine. Puoi scegliere qualsiasi località o classe di archiviazione, ma è buona norma creare bucket nella stessa posizione Cloud Functions che utilizzerà i bucket.

1. In Cloud Shell, esporta una variabile shell per i nomi dei Bucket Cloud Storage in cui verranno archiviate le metriche. Nomi dei bucket deve essere univoco a livello globale, quindi il seguente comando utilizza il numero di progetto Google Cloud come suffisso del nome del bucket.

   export METRICS_BUCKET=page-metrics-$PROJECT_NUM
   

2. Utilizza gcloud CLI per creare i bucket:

   gcloud storage buckets create gs://$METRICS_BUCKET --location=$REGION
   

3. Aggiorna il file env-vars.yaml con i nomi dei bucket. Questo file contiene variabili di ambiente che passerai Cloud Functions in seguito.

   sed -i "s/\[YOUR_METRICS_BUCKET\]/$METRICS_BUCKET/" env-vars.yaml
   

Crea una raccolta Firestore

In una sezione successiva analizzerai le metriche relative alle prestazioni della pagina. In questa sezione, crei un'istanza Firestore collezione per archiviare i risultati di ogni analisi.

1. Nella console Google Cloud, vai alla pagina di Firestore.

   Vai alla pagina di Firestore

2. Se non hai mai creato un database Firestore prima d'ora, segui questi passaggi:

   1. Fai clic su Seleziona modalità Native per attivare Firestore.
   2. Seleziona una località regionale vicina alla regione in cui durante l'esecuzione di Cloud Functions.
   3. Fai clic su Crea database.

   Il completamento della configurazione richiede qualche istante.

3. Fai clic su Avvia raccolta e imposta l'ID raccolta su page-metrics.

4. Fai clic su Salva.

Crea un argomento e una sottoscrizione Pub/Sub

In genere si desidera avvisare i sistemi e le parti interessati se l'analisi indica che una pagina ha un rendimento scarso. In questa sezione, creerai Argomenti Pub/Sub che conterranno messaggi che descrivono eventuali problemi delle prestazioni.

1. In Cloud Shell, crea un argomento Pub/Sub denominato performance-alerts:

   gcloud pubsub topics create performance-alerts
   

2. Creare una sottoscrizione all'argomento. Devi usare l'abbonamento per effettuare la verifica che i messaggi di avviso vengono pubblicati nell'argomento.

   gcloud pubsub subscriptions create performance-alerts-sub \
       --topic performance-alerts
   

Raccolta di metriche sul rendimento delle pagine in corso...

Molti siti web utilizzano JavaScript per eseguire il rendering dinamico dei contenuti delle pagine. Ciò rende dell'analisi del rendimento più complicata, perché il cliente deve emulare un browser per caricare completamente la pagina web. Il runtime Node.js per Cloud Functions supporta Chrome headless, che offre le funzionalità di un browser web completo in un ambiente completamente gestito di Google Cloud.

Battutaio è una libreria Node.js creata dal team Chrome DevTools che fornisce una API di alto livello per controllare Chrome headless. Per impostazione predefinita, Puppeteer installa all'ultima versione del browser accanto alla libreria. Pertanto, puoi aggiungi Puppeteer come dipendenza alla Cloud Function per usare facilmente Chrome headless all'interno della funzione.

La misurazione e l'analisi del rendimento delle pagine web è un campo ampio e complesso. Per Semplicità, in questo tutorial userai Puppeteer per raccogliere alcune pagine di primo livello metriche sul rendimento. Tuttavia, puoi anche usare Puppeteer e Protocollo Chrome DevTools (CDP) per raccogliere informazioni più dettagliate, come tracce temporali. Puoi anche rappresentare meglio la tua esperienza dell'utente finale emulando la rete la congestione e la limitazione della CPU. Per una buona introduzione all'analisi le prestazioni della pagina web, consulta Sito web di Chrome per gli sviluppatori.

Tieni presente che i tempi di caricamento delle pagine web sono influenzati da molti fattori, tra cui: le caratteristiche prestazionali del cliente. È importante stabilire utilizzando le configurazioni di CPU e RAM della Cloud Function.

Il seguente snippet del file tracer/index.js mostra come utilizzare Puppeteer per caricare la pagina web:

// launch Puppeteer and start a Chrome DevTools Protocol (CDP) session
// with performance tracking enabled.
browser = await puppeteer.launch({
  headless: true,
  args: ['--no-sandbox']
});
const page = await browser.newPage();
const client = await page.target().createCDPSession();
await client.send('Performance.enable');

// browse to the page, capture and write the performance metrics
console.log('Fetching url: '+url.href);
await page.goto(url.href, {
  'waitUntil' : 'networkidle0'
});
const performanceMetrics = await client.send('Performance.getMetrics');
options = createUploadOptions('application/json', page.url());
await writeToGcs(metricsBucket, filename, JSON.stringify(performanceMetrics), options);

• In Cloud Shell, esegui il deployment della Cloud Function trace:

  gcloud functions deploy trace \
      --trigger-http \
      --runtime nodejs10 \
      --memory 1GB \
      --source tracer \
      --env-vars-file env-vars.yaml \
      --quiet
  

  Il deployment della Cloud Function può richiedere diversi minuti.

  I parametri di deployment specificano che la funzione deve avere un trigger HTTP, deve utilizzare il runtime Node.js 10 e avere 1 GB la memoria. Questa quantità di memoria è necessaria per eseguire Chrome headless. Le variabili di ambiente vengono fornite alla funzione utilizzando il file env-vars.yaml

Per impostazione predefinita, le funzioni Cloud Functions attivate da HTTP consentono chiamate non autenticate. Pertanto, devi sicurezza la funzione trace.

• Rimuovi il ruolo IAM cloudfunctions.invoker per allUsers:

  gcloud beta functions remove-iam-policy-binding trace \
      --member allUsers \
      --role roles/cloudfunctions.invoker
  

Analisi delle metriche

Un tipico obiettivo degli esercizi di monitoraggio delle prestazioni sul web è monitorare il rendimento rispetto ad alcuni benchmark definiti. Se una determinata metrica supera una previsione soglia, può indicare un problema con una release software recente oppure un problema con l'infrastruttura sottostante.

In questa sezione creerai una Cloud Function in Python per analizzare le metriche della pagina e salvare i risultati in una raccolta Firestore. La funzione valuta la metrica FirstMeaningfulPaint rispetto a una soglia prevista e contrassegna il risultato dell'analisi come problematico se viene superata la soglia. FirstMeaningfulPaint è un metrica incentrata sugli utenti che descrive in modo generale quando di Google Cloud diventa utile per l'utente. Puoi utilizzare un trigger di Cloud Storage la funzione di analisi ogni volta che viene scritto un nuovo file nel bucket contiene le metriche.

Il seguente snippet del file analyzer/main.py mostra la funzione logica:

def analyze(data, context):
  """Function entry point, triggered by creation of an object in a GCS bucket.

  The function reads the content of the triggering file, analyses its contents,
  and persists the results of the analysis to a new Firestore document.

  Args:
    data (dict): The trigger event payload.
    context (google.cloud.functions.Context): Metadata for the event.
  """
  page_metrics = get_gcs_file_contents(data)
  max_time_meaningful_paint = int(os.environ.get('MAX_TIME_MEANINGFUL_PAINT'))
  analysis_result = analyze_metrics(data, page_metrics,
                                    max_time_meaningful_paint)
  docref = persist(analysis_result, data['name'])
  logging.info('Created new Firestore document %s/%s describing analysis of %s',
               docref.parent.id, docref.id, analysis_result['input_file'])

• Esegui il deployment della Cloud Function analyze:

  gcloud functions deploy analyze \
      --trigger-resource gs://$METRICS_BUCKET \
      --trigger-event google.storage.object.finalize \
      --runtime python37 \
      --source analyzer \
      --env-vars-file env-vars.yaml
  

  La funzione viene attivata da un evento finalize nel bucket delle metriche, che viene inviato ogni volta che viene creato un oggetto nel bucket. La funzione utilizza il runtime Python 3.7.

Avvisi sugli errori

In genere, è opportuno intervenire se l'analisi delle metriche indica un rendimento scarso del rendimento della pagina.

In questa sezione creerai una Cloud Function per inviare un messaggio argomento Pub/Sub se le prestazioni della pagina non sono soddisfacenti. La funzione viene attivato ogni volta che viene creato un documento in Firestore . Le parti interessate possono iscriversi all'argomento Pub/Sub e intraprendere le azioni appropriate. Ad esempio, un'app di assistenza può abbonarsi al e inviare un'email, attivare un cercapersone di assistenza o aprire un bug.

Il seguente snippet del file alerter/main.py mostra la funzione logica:

def generate_alert(data, context):
  """Cloud Function entry point, triggered by a change to a Firestore document.

  If the triggering document indicates a Failed status, send the document to
  configured PubSub topic.

  Args:
    data (dict): The event payload.
    context (google.cloud.functions.Context): Metadata for the event.
  """
  doc_fields = data['value']['fields']
  status = doc_fields['status']['stringValue']
  if 'FAIL' in status:
    global publish_client
    if not publish_client:
      publish_client = pubsub.PublisherClient()

    logging.info('Sending alert in response to %s status in document %s',
                 status, context.resource)
    project = os.environ.get('GCP_PROJECT')
    topic = os.environ.get('ALERT_TOPIC')
    fqtn = 'projects/{}/topics/{}'.format(project, topic)
    msg = json.dumps(data['value']).encode('utf-8')
    publish_client.publish(fqtn, msg)

Tieni presente che l'avviso viene inviato solo se il campo dello stato indica un errore.

• Esegui il deployment della Cloud Function alert:

  gcloud functions deploy alert \
      --trigger-event providers/cloud.firestore/eventTypes/document.create \
      --trigger-resource "projects/$PROJECT/databases/(default)/documents/page-metrics/{any}" \
      --runtime python37 \
      --source alerter \
      --env-vars-file env-vars.yaml \
      --entry-point generate_alert
  

  La funzione viene attivata da un evento document.create nel page-metrics raccolta Firestore. Il suffisso {any} è un carattere jolly che indica che la funzione deve essere attivata ogni volta che viene eseguita una documento creato nella raccolta.

Pianificare l'analisi

È buona norma monitorare regolarmente le prestazioni delle pagine. Ad esempio, potresti voler analizzare una determinata pagina ogni ora, ogni giorno o ogni settimana. Nella In questa sezione creerai un job Cloud Scheduler per eseguire periodicamente la pipeline di analisi attivando la funzione trace.

Il job Cloud Scheduler viene eseguito utilizzando un account di servizio disponi del ruolo IAM cloudfunctions.invoker richiesto per trace personalizzata.

A volte le pagine web non rispondono correttamente o le richieste scadono, quindi i nuovi tentativi vengono eseguiti sono inevitabili con le app di analisi web. È quindi importante avere dei nuovi tentativi nell'app. Cloud Functions supporta i nuovi tentativi funzioni in background.

I nuovi tentativi non sono disponibili per le funzioni Cloud Functions attivate da HTTP, quindi non puoi utilizzare Cloud Functions per riprovare la funzione trace. Tuttavia, Cloud Scheduler supporta i nuovi tentativi. Per ulteriori informazioni sulla configurazione nuovi parametri, consulta RetryConfig documentazione.

1. Verifica che le tre funzioni Cloud Functions siano state implementato e mostra lo stato ACTIVE:

   gcloud functions list
   

2. Crea un nuovo account di servizio che verrà utilizzato come identità per che esegue il job Cloud Scheduler:

   gcloud iam service-accounts create tracer-job-sa
   

3. Concedi al nuovo account di servizio il ruolo IAM cloudfunctions.invoker per la funzione trace:

   gcloud beta functions add-iam-policy-binding trace \
       --role roles/cloudfunctions.invoker \
       --member "serviceAccount:tracer-job-sa@$PROJECT.iam.gserviceaccount.com"
   

4. Crea un job Cloud Scheduler:

   gcloud scheduler jobs create http traceWithRetry \
       --uri="https://$REGION-$PROJECT.cloudfunctions.net/trace" \
       --http-method=POST \
       --message-body="{\"url\":\"http://www.example.com\"}" \
       --headers="Content-Type=application/json" \
       --oidc-service-account-email="tracer-job-sa@$PROJECT.iam.gserviceaccount.com" \
       --schedule="0 3 * * *" \
       --time-zone="UTC" \
       --max-retry-attempts=3 \
       --min-backoff=30s
   

   Poiché il job chiamerà la funzione trace attivata tramite HTTP, il valore specifica il tipo di job come http e fornisce il trigger di funzione URL come valore uri. La pagina da analizzare, in questo caso www.example.com, viene fornito nel flag message-body. oidc-service-account-email definisce l'account di servizio da utilizzare per l'autenticazione. Il comando indica il numero di nuovi tentativi utilizzando l'max-retry-attempts e il valore passato con il flag schedule imposta la pianificazione dell'esecuzione alle 03:00 UTC ogni giorno.

Verifica dei risultati

In questa sezione verificherai di ottenere il comportamento previsto per entrambi i casi e alle condizioni di errore.

Verifica l'esito positivo

Il job Cloud Scheduler non verrà eseguito fino alla successiva ora pianificata, in questo caso le ore 03:00 UTC. Per vedere subito i risultati, può attivare manualmente un'esecuzione.

1. Attendi 90 secondi per il completamento dell'inizializzazione del job dello scheduler.

2. Esegui manualmente il job Cloud Scheduler:

   gcloud scheduler jobs run traceWithRetry
   

3. Attendi circa 30 secondi per il completamento della pipeline di funzione.

4. Elenca i contenuti del bucket delle metriche per mostrare le metriche della pagina sono state raccolte:

   gcloud storage ls gs://$METRICS_BUCKET --long
   

5. Nella console Google Cloud, apri la pagina del visualizzatore Cloud Logging:

   Vai alla pagina Logging

   Puoi visualizzare i messaggi di log da ciascuna delle tre funzioni Cloud Functions: trace, analyze e alert. Può il flusso di log potrebbe richiedere qualche istante, quindi potrebbe essere necessario e aggiornalo al riquadro dei log.

   

6. Prendi nota dell'ID documento Firestore, che è elencato dopo il testo Created new Firestore document page-metrics/

7. Nella console Google Cloud, vai alla pagina di Firestore:

   Vai alla pagina di Firestore

8. Esamina il documento che contiene i risultati dell'analisi. La i valori del documento indicano uno stato PASS e contengono la pagina più recente metriche sul rendimento.

9. In Cloud Shell, verifica che non siano stati inviati messaggi di avviso a all'argomento Pub/Sub tentando di eseguire il pull di un messaggio abbonamento:

   gcloud pubsub subscriptions pull \
       projects/$PROJECT/subscriptions/performance-alerts-sub \
       --auto-ack
   

   Non vedi alcun elemento elencato.

Verifica non riuscita

1. Attiva manualmente la funzione di traccia. Questa volta fornisci Tutorial di Google Cloud pagina come URL. Questa pagina include molti contenuti dinamici che aumentano il della pagina supera la soglia massima prevista.

   gcloud functions call trace \
       --data='{"url":"https://cloud.google.com/docs/tutorials"}'
   

   Poiché hai il progetto del ruolo IAM Owner o Editor, devi autorizzazioni sufficienti per richiamare la funzione.

2. Attendi circa 30 secondi per il completamento della pipeline di funzione.

3. Elenca i contenuti del bucket delle metriche per verificare che Sono state raccolte altre metriche:

   gcloud storage ls gs://$METRICS_BUCKET --long
   

   Ora vedi due elementi in ogni bucket.

4. Nella console Google Cloud, vai alla pagina del visualizzatore Cloud Logging e filtra per i log della funzione Cloud Function:

   Vai alla pagina Logging

   Viene visualizzato un errore dalla funzione analyze che indica che la pagina superato il tempo di caricamento massimo consentito. Anche in questo caso, potresti dover aggiornare dei log per visualizzare i messaggi più recenti.

   

5. Prendi nota dell'ID documento Firestore.

6. Nella console Google Cloud, vai alla pagina di Firestore:

   Vai alla pagina di Firestore

7. Trova il documento che descrive l'analisi non riuscita.

   Il campo dello stato è contrassegnato come FAIL.

8. In Cloud Shell, verifica che sia stato inviato un messaggio di avviso alla all'argomento Pub/Sub estraendo un messaggio dalla sottoscrizione.

   gcloud pubsub subscriptions pull \
       projects/$PROJECT/subscriptions/performance-alerts-sub \
       --auto-ack
   

   Questa volta vedi i contenuti del messaggio.

Esegui la pulizia

Elimina il progetto

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:
• L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività in questo documento, quando lo elimini elimini anche qualsiasi altro lavoro svolto nel progetto.
• Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.
1. Nella console Google Cloud, vai alla pagina Gestisci risorse.

   Vai a Gestisci risorse

2. Nell'elenco dei progetti, seleziona il progetto 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.

Passaggi successivi

• Scopri di più su Google Cloud serverless tecnologie.
• Esplora altre funzioni Cloud Functions tutorial.
• Guarda il (video) dalla conferenza Google I/O '18 che descrive altri usi di Puppeteer e headless Chrome.
• Esplora le architetture di riferimento, i diagrammi e le best practice su Google Cloud. Dai un'occhiata al nostro Centro architetture cloud.