Cómo comprimir mensajes

Si usas Pub/Sub para publicar mensajes que equivalen a una gran cantidad de datos, puedes usar gRPC para comprimir tus datos y ahorrar costos de redes antes de que tu cliente publicador envíe la solicitud de publicación. La compresión de Pub/Sub para gRPC usa el algoritmo Gzip.

En este documento, se proporciona información sobre la compresión de mensajes publicados en un tema.

Acerca de la compresión de mensajes

La relación de compresión para usar la función de compresión del cliente de gRPC es diferente para los distintos clientes de publicadores y depende de los siguientes factores:

  • Cantidad de datos. La relación de compresión mejora cuando el tamaño de la carga útil aumenta de unos cientos de bytes a muchos kilobytes de datos. La configuración de lotes de una solicitud de publicación determina la cantidad de datos que se incluyen en cada solicitud de publicación. Te recomendamos que actives la configuración de lotes junto con la compresión de gRPC para obtener los mejores resultados.

  • Tipo de datos. Los datos basados en texto, como JSON o XML, se pueden comprimir más en comparación con los datos binarios, como las imágenes.

Si tu cliente publicador está en Google Cloud, puedes usar la métrica Bytes enviados (instance/network/sent_bytes_count) para medir la capacidad de procesamiento de la publicación en bytes. Si tu cliente publicador se encuentra en una aplicación diferente, debes usar las herramientas específicas del cliente para realizar la medición.

La muestra de código de esta sección muestra un fragmento de código de la biblioteca cliente de Java de ejemplo que también incluye la compresión de gRPC.

Antes de comenzar

Antes de configurar el flujo de trabajo de publicación, asegúrate de haber completado las siguientes tareas:

Roles obligatorios

Para obtener los permisos que necesitas para comprimir mensajes, pídele a tu administrador que te otorgue el rol de IAM de Publicador de Pub/Sub (roles/pubsub.publisher) en tu tema. Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios mediante roles personalizados o cualquier otro rol predefinido.

Necesitas permisos adicionales para crear o actualizar temas y suscripciones.

Cómo comprimir un mensaje

C++

Antes de probar esta muestra, sigue las instrucciones de configuración de C++ en la guía de inicio rápido sobre el uso de bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Pub/Sub para C++. 

namespace g = ::google::cloud;
namespace pubsub = ::google::cloud::pubsub;
[](std::string project_id, std::string topic_id) {
  auto topic = pubsub::Topic(std::move(project_id), std::move(topic_id));
  auto publisher = pubsub::Publisher(pubsub::MakePublisherConnection(
      std::move(topic),
      g::Options{}
          // Compress any batch of messages over 10 bytes. By default, no
          // messages are compressed, set this to 0 to compress all batches,
          // regardless of their size.
          .set<pubsub::CompressionThresholdOption>(10)
          // Compress using the GZIP algorithm. By default, the library uses
          // GRPC_COMPRESS_DEFLATE.
          .set<pubsub::CompressionAlgorithmOption>(GRPC_COMPRESS_GZIP)));
  auto message_id = publisher.Publish(
      pubsub::MessageBuilder{}.SetData("Hello World!").Build());
  auto done = message_id.then([](g::future<g::StatusOr<std::string>> f) {
    auto id = f.get();
    if (!id) throw std::move(id).status();
    std::cout << "Hello World! published with id=" << *id << "\n";
  });
  // Block until the message is published
  done.get();
}

Java

Antes de probar esta muestra, sigue las instrucciones de configuración de Java en la guía de inicio rápido sobre el uso de bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Pub/Sub para Java. 

import com.google.api.core.ApiFuture;
import com.google.cloud.pubsub.v1.Publisher;
import com.google.protobuf.ByteString;
import com.google.pubsub.v1.PubsubMessage;
import com.google.pubsub.v1.TopicName;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

public class PublishWithGrpcCompressionExample {
  public static void main(String... args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    // Choose an existing topic.
    String topicId = "your-topic-id";

    publishWithGrpcCompressionExample(projectId, topicId);
  }

  public static void publishWithGrpcCompressionExample(String projectId, String topicId)
      throws IOException, ExecutionException, InterruptedException {
    TopicName topicName = TopicName.of(projectId, topicId);

    // Create a publisher and set enable compression to true.
    Publisher publisher = null;
    try {
      // Enable compression and configure the compression threshold to 10 bytes (default to 240 B).
      // Publish requests of sizes > 10 B (excluding the request headers) will get compressed.
      // The number of messages in a publish request is determined by publisher batch settings.
      // Batching is turned off by default, i.e. each publish request contains only one message.
      publisher =
          Publisher.newBuilder(topicName)
              .setEnableCompression(true)
              .setCompressionBytesThreshold(10L)
              .build();

      byte[] bytes = new byte[1024];
      ByteString data = ByteString.copyFrom(bytes);
      PubsubMessage pubsubMessage = PubsubMessage.newBuilder().setData(data).build();

      // Once published, returns a server-assigned message id (unique within the topic).
      // You can look up the actual size of the outbound data using the Java Logging API.
      // Configure logging properties as shown in
      // https://github.com/googleapis/java-pubsub/tree/main/samples/snippets/src/main/resources/logging.properties
      // and look for "OUTBOUND DATA" with "length=" in the output log.
      ApiFuture<String> messageIdFuture = publisher.publish(pubsubMessage);
      String messageId = messageIdFuture.get();
      System.out.println("Published a compressed message of message ID: " + messageId);
    } finally {
      if (publisher != null) {
        // When finished with the publisher, shutdown to free up resources.
        publisher.shutdown();
        publisher.awaitTermination(1, TimeUnit.MINUTES);
      }
    }
  }
}

¿Qué sigue?

Para obtener información sobre cómo configurar las opciones de publicación avanzadas, consulta lo siguiente: