דחיסת הודעות

אם אתם משתמשים ב-Pub/Sub כדי לפרסם הודעות שמכילות הרבה נתונים, אתם יכולים להשתמש ב-gRPC כדי לדחוס את הנתונים ולחסוך בעלויות הרשת לפני שלקוח בעל התוכן הדיגיטלי שולח את בקשת הפרסום. הדחיסה של Pub/Sub ל-gRPC משתמשת באלגוריתם Gzip.

במאמר הזה מוסבר איך לדחוס הודעות שפורסמו בנושא.

מידע על דחיסת הודעות

יחס הדחיסה כשמשתמשים בתכונה של דחיסה בצד הלקוח ב-gRPC משתנה בהתאם ללקוחות השונים של בעלי התוכן הדיגיטלי, והוא תלוי בגורמים הבאים:

  • כמות הנתונים. יחס הדחיסה משתפר ככל שגודל המטען הייעודי (payload) גדל מכמה מאות בייטים להרבה קילובייטים של נתונים. הגדרות האצווה של בקשת פרסום קובעות את כמות הנתונים שכלולה בכל בקשת פרסום. כדי לקבל את התוצאות הכי טובות, מומלץ להפעיל את הגדרות האצווה בשילוב עם דחיסת gRPC.

  • סוג הנתונים. נתונים מבוססי-טקסט כמו JSON או XML ניתנים לדחיסה יותר מאשר נתונים בינאריים כמו תמונות.

אם לקוח הפרסום שלכם נמצא ב- Google Cloud, אתם יכולים להשתמש במדד בייטים שנשלחו (instance/network/sent_bytes_count) כדי למדוד את קצב העברת הנתונים של הפרסום בבייטים. אם הלקוח של בעל האפליקציה נמצא באפליקציה אחרת, צריך להשתמש בכלים הספציפיים ללקוח כדי לבצע את המדידה.

דוגמת הקוד בקטע הזה מציגה קטע קוד לדוגמה של ספריית לקוח ב-Java שכולל גם דחיסת gRPC.

לפני שמתחילים

לפני שמגדירים את תהליך העבודה של הפרסום, צריך לבצע את המשימות הבאות:

התפקידים הנדרשים

כדי לקבל את ההרשאות שנדרשות לדחיסת הודעות, צריך לבקש מהאדמין להקצות לכם ב-IAM את התפקיד מפרסם הודעות ב-Pub/Sub (roles/pubsub.publisher) בנושא. כדי לקרוא הסבר על מתן תפקידים, ראו איך מנהלים את הגישה ברמת הפרויקט, התיקייה והארגון.

יכול להיות שאפשר לקבל את ההרשאות הנדרשות גם באמצעות תפקידים בהתאמה אישית או תפקידים מוגדרים מראש.

כדי ליצור או לעדכן נושאים ומינויים, צריך הרשאות נוספות.

כיווץ הודעה

C++‎

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי הוראות ההגדרה של C++‎ במאמר התחלה מהירה: שימוש בספריות לקוח. מידע נוסף זמין במאמרי העזרה של 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

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי הוראות ההגדרה של Java במאמר התחלה מהירה: שימוש בספריות לקוח. מידע נוסף מופיע במאמרי העזרה של 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);
      }
    }
  }
}

המאמרים הבאים

כדי ללמוד איך להגדיר אפשרויות פרסום מתקדמות, אפשר לעיין במאמרים הבאים: