Comprimere i messaggi

Se utilizzi Pub/Sub per pubblicare messaggi che rappresentano una grande quantità di dati, puoi utilizzare gRPC per comprimere i dati e ridurre i 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 i vari client publisher e dipende dai seguenti fattori:

  • Quantità di dati. Il rapporto di compressione migliora quando la dimensione del payload aumenta da poche centinaia di byte a molti kilobyte di dati. Le impostazioni batch di una richiesta di pubblicazione determinano la quantità di dati inclusi in ogni richiesta di pubblicazione. Per ottenere risultati ottimali, ti consigliamo di attivare le impostazioni batch insieme alla 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 è attivo Google Cloud, puoi utilizzare la metrica Byte inviati (instance/network/sent_bytes_count) per misurare la velocità effettiva di pubblicazione in byte. Se il client publisher si trova su un'applicazione diversa, devi utilizzare gli strumenti specifici del client per eseguire la misurazione.

L'esempio di codice in questa sezione mostra un esempio di snippet di codice della libreria client Java 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 Pub/Sub Publisher (roles/pubsub.publisher) nell'argomento. Per saperne di più sulla concessione dei ruoli, consulta Gestisci 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 abbonamenti, sono necessarie autorizzazioni aggiuntive.

Comprimere un messaggio

C++

Prima di provare questo esempio, segui le istruzioni di configurazione di C++ in Guida rapida all'utilizzo delle librerie client. Per saperne di più, 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 in Guida rapida all'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Pub/Sub 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);
      }
    }
  }
}

Passaggi successivi

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