Nachrichten komprimieren

Wenn Sie Pub/Sub verwenden, um Nachrichten zu veröffentlichen, die eine große Datenmenge umfassen, 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 Gzip-Algorithmus.

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

Nachrichten komprimieren

Das Komprimierungsverhältnis für die Verwendung der clientseitigen gRPC-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 Byte auf viele Kilobyte Daten steigt. Die Batch-Einstellungen einer Veröffentlichungsanfrage bestimmen die Datenmenge, die in jeder Veröffentlichungsanfrage enthalten ist. Wir empfehlen, die Batcheinstellungen in Verbindung mit der gRPC-Komprimierung zu aktivieren, um die besten Ergebnisse zu erzielen.

  • Datentyp: Textbasierte Daten wie JSON oder XML sind im Vergleich zu Binärdaten wie Bildern besser komprimierbar.

Wenn Ihr Publisher-Client auf Google Cloudist, können Sie den Messwert Gesendete Byte (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 Messung verwenden.

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

Hinweis

Führen Sie vor dem Konfigurieren des Veröffentlichungs-Workflows die folgenden Aufgaben aus:

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Pub/Sub-Publisher (roles/pubsub.publisher) für Ihr 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.

Nachricht 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 Pub/Sub C++ API-Referenzdokumentation.

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 Pub/Sub Java API-Referenzdokumentation.

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 hier: