Compresser les messages

Si vous utilisez Pub/Sub pour publier des messages vous pouvez utiliser gRPC pour les compresser pour réduire les coûts de mise en réseau avant que votre client éditeur n'envoie les données requête. La compression Pub/Sub pour gRPC utilise le Algorithme Gzip.

Ce document fournit des informations sur la compression des messages publiées dans un sujet.

À propos de la compression des messages

Le taux de compression pour utiliser la fonctionnalité de compression côté client gRPC est différent pour les différents clients d'éditeurs et dépend des facteurs suivants :

  • Quantité de données Le taux de compression est amélioré lorsque la taille passe de quelques centaines d’octets à plusieurs kilo-octets de données. Le lot d'une demande de publication détermine la quantité de données à inclure chaque requête de publication. Pour de meilleurs résultats, nous vous recommandons d'activer les paramètres de lot en plus de la compression gRPC.

  • Type de données Les données textuelles telles que JSON ou XML sont plus compressibles que les données binaires telles que les images.

Si votre client éditeur se trouve sur Google Cloud, vous pouvez utiliser la métrique Octets envoyés (instance/network/sent_bytes_count) pour mesurer le débit de publication en octets. Si votre client éditeur se trouve dans une autre application, vous devez utiliser les outils spécifiques au client pour effectuer la mesure.

L'exemple de code de cette section présente un extrait de code de bibliothèque cliente Java qui inclut également la compression gRPC.

Avant de commencer

Avant de configurer le workflow de publication, assurez-vous d'avoir effectué les opérations suivantes tâches:

Rôles requis

Pour obtenir les autorisations nécessaires pour compresser les messages, demandez à votre administrateur de vous accorder le Éditeur Pub/Sub (roles/pubsub.publisher) sur votre sujet. Pour en savoir plus sur l'attribution de rôles, consultez la page Gérer l'accès aux projets, aux dossiers et aux organisations.

Vous pouvez également obtenir les autorisations requises via des rôles personnalisés ou d'autres rôles prédéfinis.

Vous avez besoin d'autorisations supplémentaires pour créer ou mettre à jour des sujets et des abonnements.

Compresser un message

C++

Avant d'essayer cet exemple, suivez les instructions d'installation dans le langage C++ qui se trouvent sur la page Démarrage rapide : utiliser des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence sur l'API Pub/Sub pour 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

Avant d'essayer cet exemple, suivez les instructions d'installation dans le langage Java qui se trouvent sur la page Démarrage rapide : utiliser des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence sur l'API Pub/Sub pour 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);
      }
    }
  }
}

Étape suivante

Pour savoir comment configurer les options de publication avancées, consultez les ressources suivantes :