Nachrichten komprimieren

Wenn Sie mit Pub/Sub Nachrichten mit vielen Daten veröffentlichen, können Sie gRPC verwenden, um Ihre Daten zu komprimieren und so Netzwerkkosten zu sparen, bevor Ihr Publisher-Client die Veröffentlichungsanfrage sendet. Die Pub/Sub-Komprimierung für gRPC verwendet den Algorithmus Gzip.

In diesem Dokument finden Sie Informationen zum Komprimieren von Nachrichten, die in einem Thema veröffentlicht werden.

Nachrichten komprimieren

Das Komprimierungsverhältnis für die Verwendung der gRPC-clientseitigen Komprimierungsfunktion ist für verschiedene Publisher-Clients unterschiedlich und hängt von den folgenden Faktoren ab:

  • Datenmenge Das Komprimierungsverhältnis verbessert sich, wenn die Größe der Nutzlast von einigen hundert Bytes auf viele Kilobyte ansteigt. Die Batch-Einstellungen einer Veröffentlichungsanfrage legen fest, wie viele Daten in jeder Veröffentlichungsanfrage enthalten sind. Für optimale Ergebnisse empfehlen wir, die Batch-Einstellungen in Verbindung mit der gRPC-Komprimierung zu aktivieren.

  • Datentyp Textbasierte Daten wie JSON oder XML lassen sich im Vergleich zu binären Daten wie Bildern besser komprimieren.

Wenn sich dein Publisher-Client in Google Cloud befindet, kannst du den Messwert Gesendete Bytes (instance/network/sent_bytes_count) verwenden, um den Veröffentlichungsdurchsatz in Byte zu messen. Wenn sich Ihr Publisher-Client in einer anderen Anwendung befindet, müssen Sie die clientspezifischen Tools für die Analyse verwenden.

Das Codebeispiel in diesem Abschnitt zeigt ein Code-Snippet für eine Java-Clientbibliothek, das auch die gRPC-Komprimierung enthält.

Hinweise

Bevor du den Veröffentlichungsworkflow konfigurierst, musst du die folgenden Aufgaben erledigt haben:

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Pub/Sub-Publisher (roles/pubsub.publisher) für das gewünschte Thema zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Komprimieren von Nachrichten benötigen. Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

Sie benötigen zusätzliche Berechtigungen, um Themen und Abos zu erstellen oder zu aktualisieren.

Nachrichten komprimieren

C++

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für C++ in der Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub C++ API. 

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

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für Java in der Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu Pub/Sub Java API. 

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

Nächste Schritte

Informationen zum Konfigurieren erweiterter Veröffentlichungsoptionen finden Sie unter den folgenden Links: