Optimizar las herramientas de redes

La simplicidad de Cloud Functions te permite desarrollar código rápidamente y ejecutarlo en un entorno sin servidores. A una escala moderada, el costo de ejecutar funciones es bajo, y puedes considerar que optimizar tu código no es una prioridad importante. Sin embargo, a medida que tu implementación aumenta su escala, optimizar tu código se vuelve cada vez más relevante.

En este documento, se describe cómo optimizar las Herramientas de redes para tus funciones. Algunos de los beneficios de optimizar las Herramientas de redes son los siguientes:

• Reduce el tiempo de CPU que se usa para establecer conexiones nuevas en cada llamada a función.
• Reduce la probabilidad de agotar las cuotas de DNS o de conexión.

Cómo mantener conexiones continuas

Esta sección muestra ejemplos sobre cómo mantener conexiones continuas en una función. No hacerlo puede causar que agotes tu cuota de conexión rápidamente.

En esta sección, se abordan los siguientes casos:

• HTTP/S
• API de Google

Solicitudes HTTP(S)

El fragmento de código optimizado de más abajo muestra cómo mantener la coherencia de las conexiones en lugar de crear una conexión nueva para cada invocación de función:

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!")
    

Acceso a las API de Google

En el siguiente ejemplo, se usa Cloud Pub/Sub, pero este enfoque también sirve para otras bibliotecas cliente, como Cloud Natural Language o Cloud Spanner. Ten en cuenta que las mejoras de rendimiento pueden depender de la implementación actual de algunas bibliotecas cliente en particular.

Si se crea un objeto de cliente de Pub/Sub se genera una conexión y dos consultas de DNS por invocación. Para evitar consultas de DNS y conexiones innecesarias, crea el objeto de cliente de Pub/Sub en alcance global, como se indica en el siguiente ejemplo:

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")
    

Conexiones salientes

Tiempos de espera de solicitud saliente

Hay un tiempo de espera después de 10 minutos de tiempo de inactividad de las solicitudes de tu función a la red de VPC. Para las solicitudes de tu función a Internet, hay un tiempo de espera después de 20 minutos de tiempo de inactividad.

Se restablece la conexión saliente

Las transmisiones de conexión de tu función a Internet y red de VPC pueden finalizarse y reemplazarse de forma ocasional cuando se reinicia o actualiza la infraestructura subyacente. Si tu aplicación vuelve a usar conexiones de larga duración, te recomendamos entonces que configures tu aplicación para restablecer las conexiones para evitar la reutilización de una conexión inactiva.

Prueba la carga de tu función

Para medir cuántas conexiones ejecuta en promedio tu función, solo debes implementarla como una función de HTTP y usar un marco de trabajo de prueba de rendimiento para invocarla con una cierta cantidad de QPS. Una opción posible es Artillery, que puedes invocar con una sola línea:

$ artillery quick -d 300 -r 30 URL

Este comando recupera la URL determinada a 30 QPS por 300 segundos.

Después de ejecutar la prueba, verifica el uso de tu cuota de conexión en la página de cuotas de la API Cloud Functions en Cloud Console. Si el uso se mantiene alrededor de 30 (o sus múltiplos), estás estableciendo una (o varias) conexiones en cada invocación. Después de optimizar el código, deberías ver que se ejecutan unas pocas conexiones (entre 10 y 30) solo al comienzo de la prueba.

También puedes comparar el costo de CPU antes y después de la optimización en el gráfico de cuota de CPU, en la misma página.