Nachrichten komprimieren

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

Dieses Dokument enthält Informationen zum Komprimieren von Nachrichten, die in einem Thema veröffentlicht wurden.

Informationen zum Komprimieren von Nachrichten

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

  • Datenmenge: Das Komprimierungsverhältnis verbessert sich, wenn die Größe der Nutzlast von einigen Hundert Byte auf viele Kilobyte an Daten ansteigt. Die Batcheinstellungen einer Veröffentlichungsanfrage bestimmen die Datenmenge, die in einer Veröffentlichungsanfrage enthalten ist. Wir empfehlen, Batcheinstellungen in Verbindung mit gRPC-Komprimierung zu aktivieren, um optimale Ergebnisse zu erzielen.

  • Datentyp: Textbasierte Daten wie JSON oder XML lassen sich im Vergleich zu Binärdaten wie Bildern besser komprimieren.

Wenn sich Ihr Publisher-Client in Google Cloud befindet, können Sie mit dem Messwert Gesendete Byte (instance/network/sent_bytes_count) den Durchsatz der Veröffentlichung in Byte messen. Wenn Ihr Publisher-Client eine andere Anwendung verwendet, müssen Sie die clientspezifischen Tools für die Messung verwenden.

Das Codebeispiel in diesem Abschnitt zeigt ein Code-Snippet der Java-Clientbibliothek, das auch die gRPC-Komprimierung umfasst.

Hinweise

Bevor Sie den Veröffentlichungsworkflow konfigurieren, müssen Sie die folgenden Aufgaben ausgeführt haben:

Erforderliche Rollen

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

Möglicherweise können Sie 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 zur 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

Hier erfahren Sie, wie Sie erweiterte Veröffentlichungsoptionen konfigurieren: