Ottimizzazione del networking

La semplicità di Cloud Functions ti consente di sviluppare rapidamente codice ed eseguirlo in un ambiente serverless. Su scala moderata, il costo di esecuzione delle funzioni è basso e l'ottimizzazione del codice potrebbe non sembrare una priorità elevata. Con lo scale up del deployment, tuttavia, l'ottimizzazione del codice diventa sempre più importante.

Questo documento descrive come ottimizzare il networking per le tue funzioni. Ecco alcuni dei vantaggi dell'ottimizzazione del networking:

• Riduzione del tempo di CPU impiegato per stabilire nuove connessioni in uscita a ogni chiamata di funzione.
• Riduzione della probabilità di esaurire le quote di connessioni o DNS.

Mantenere connessioni permanenti

Questa sezione fornisce esempi di come mantenere connessioni permanenti in una funzione. Se ciò non dovesse verificarsi, le quote di connessioni potrebbero esaurirsi rapidamente.

Questa sezione tratta i seguenti scenari:

• HTTP/S
• API di Google

Richieste HTTP/S

Il seguente snippet di codice ottimizzato mostra come mantenere connessioni permanenti anziché crearne una nuova a ogni chiamata di funzione:

const http = require('http');
const functions = require('firebase-functions');

// Setting the `keepAlive` option to `true` keeps
// connections open between function invocations
const agent = new http.Agent({keepAlive: true});

exports.function = functions.https.onRequest((request, response) => {
    req = http.request({
        host: '',
        port: 80,
        path: '',
        method: 'GET',
        agent: agent, // Holds the connection open after the first invocation
    }, res => {
        let rawData = '';
        res.setEncoding('utf8');
        res.on('data', chunk => { rawData += chunk; });
        res.on('end', () => {
            response.status(200).send(`Data: ${rawData}`);
        });
    });
    req.on('error', e => {
        response.status(500).send(`Error: ${e.message}`);
    });
    req.end();
});

from firebase_functions import https_fn
import requests

# Create a global HTTP session (which provides connection pooling)
session = requests.Session()

@https_fn.on_request()
def connection_pooling(request):

    # The URL to send the request to
    url = "http://example.com"

    # Process the request
    response = session.get(url)
    response.raise_for_status()
    return https_fn.Response("Success!")
    

Accesso alle API di Google

L'esempio seguente utilizza Cloud Pub/Sub, ma questo approccio funziona anche per altre librerie client, ad esempio Cloud Natural Language o Cloud Spanner. Tieni presente che i miglioramenti delle prestazioni potrebbero dipendere dall'implementazione attuale di determinate librerie client.

La creazione di un oggetto client Pub/Sub comporta una connessione e due query DNS per chiamata. Per evitare connessioni e query DNS non necessarie, crea l'oggetto client Pub/Sub nell'ambito globale come mostrato nell'esempio seguente:

const PubSub = require('@google-cloud/pubsub');
const functions = require('firebase-functions');
const pubsub = PubSub();

exports.function = functions.https.onRequest((req, res) => {
    const topic = pubsub.topic('');

    topic.publish('Test message', err => {
        if (err) {
            res.status(500).send(`Error publishing the message: ${err}`);
        } else {
            res.status(200).send('1 message published');
        }
    });
});

import os

from firebase_functions import https_fn
from google.cloud import pubsub_v1

# from firebase_functions import https_fn
# Create a global Pub/Sub client to avoid unneeded network activity
pubsub = pubsub_v1.PublisherClient()

@https_fn.on_request()
def gcp_api_call(request):

    project = os.getenv("GCP_PROJECT")
    request_json = request.get_json()

    topic_name = request_json["topic"]
    topic_path = pubsub.topic_path(project, topic_name)

    # Process the request
    data = b"Test message"
    pubsub.publish(topic_path, data=data)

    return https_fn.Response("1 message published")
    

Connessioni in uscita

Timeout delle richieste in uscita

Si verifica un timeout dopo 10 minuti di inattività per le richieste dalla funzione alla rete VPC. Per le richieste dalla tua funzione a internet, si verifica un timeout dopo 20 minuti di inattività.

Reimpostazione delle connessioni in uscita

I flussi di connessione dalla tua funzione sia alla rete VPC che a internet possono essere interrotti e sostituiti occasionalmente quando l'infrastruttura sottostante viene riavviata o aggiornata. Se la tua applicazione riutilizza connessioni di lunga durata, ti consigliamo di configurarla in modo da ristabilire le connessioni per evitare il riutilizzo di una connessione non più attiva.

Test di carico della funzione

Per misurare il numero di connessioni eseguite in media dalla funzione, eseguine il deployment come funzione HTTP e utilizza un framework di test delle prestazioni per richiamarla a un determinato QPS. Una scelta possibile è Artillery, che puoi richiamare con una sola riga:

$ artillery quick -d 300 -r 30 URL

Questo comando recupera l'URL specificato a 30 QPS per 300 secondi.

Dopo aver eseguito il test, controlla l'utilizzo della quota di connessioni nella pagina delle quote dell'API Cloud Functions in Cloud Console. Se l'utilizzo è costantemente intorno a 30 (o a un suo multiplo), stai stabilendo una (o più) connessioni in ogni chiamata. Dopo aver ottimizzato il codice, dovresti vedere alcune (10-30) connessioni solo all'inizio del test.

Puoi anche confrontare il costo della CPU prima e dopo l'ottimizzazione nel grafico della quota di CPU nella stessa pagina.