Comprimi i messaggi

Se utilizzi Pub/Sub per pubblicare messaggi che generano molti dati, puoi utilizzare gRPC per comprimere i dati per risparmiare sui costi di rete prima che il client publisher invii la richiesta di pubblicazione. La compressione Pub/Sub per gRPC utilizza l'algoritmo Gzip.

Questo documento fornisce informazioni sulla compressione dei messaggi pubblicati in un argomento.

Informazioni sulla compressione dei messaggi

Il rapporto di compressione per l'utilizzo della funzionalità di compressione lato client gRPC è diverso per diversi client publisher e dipende dai seguenti fattori:

  • Quantità di dati. Il rapporto di compressione migliora quando le dimensioni del payload aumentano da poche centinaia di byte a molti kilobyte di dati. Le impostazioni del gruppo di una richiesta di pubblicazione determinano la quantità di dati inclusi in ogni richiesta di pubblicazione. Per ottenere i risultati migliori, ti consigliamo di attivare le impostazioni batch in combinazione con la compressione gRPC.

  • Tipo di dati. I dati basati su testo, come JSON o XML, sono più comprimibili rispetto ai dati binari, come le immagini.

Se il client publisher è su Google Cloud, puoi utilizzare la metrica Byte inviati (instance/network/sent_bytes_count) per misurare il throughput di pubblicazione in byte. Se il cliente editore si trova in un'applicazione diversa, devi utilizzare gli strumenti specifici del cliente per eseguire la misurazione.

L'esempio di codice in questa sezione mostra uno snippet di codice della libreria client Java di esempio che include anche la compressione gRPC.

Prima di iniziare

Prima di configurare il flusso di lavoro di pubblicazione, assicurati di aver completato le seguenti attività:

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per comprimere i messaggi, chiedi all'amministratore di concederti il ruolo IAM Publisher Pub/Sub (roles/pubsub.publisher) per il tuo argomento. Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Per creare o aggiornare argomenti e iscrizioni, sono necessarie autorizzazioni aggiuntive.

Comprimire un messaggio

C++

Prima di provare questo esempio, segui le istruzioni di configurazione C++ riportate nella guida rapida all'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Pub/Sub 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

Prima di provare questo esempio, segui le istruzioni di configurazione di Java riportate nella guida rapida all'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Java Pub/Sub. 

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);
      }
    }
  }
}

Passaggi successivi

Per scoprire come configurare le opzioni di pubblicazione avanzate, consulta quanto segue: