Google は AI 技術を使用して、コンテンツをご希望の言語に翻訳しています。AI 翻訳には誤りが含まれる場合があります。

一般的なトラブルシューティング

Pub/Sub の使用中に問題が発生した場合に役立つトラブルシューティング手順について説明します。

トピックを作成できない

必要な権限を付与されていることを確認します。 Pub/Sub トピックを作成するには、プロジェクトに対する Pub/Sub 編集者（roles/pubsub.editor）Identity and Access Management ロールが必要です。このロールを付与されていない場合は、管理者にお問い合わせください。トピックに関するトラブルシューティングの詳細については、次のページをご覧ください。

サブスクリプションを作成できない

以下を行ったことを確認します。

必要な権限を付与されていることを確認します。 Pub/Sub サブスクリプションを作成するには、プロジェクトに対する Pub/Sub 編集者（roles/pubsub.editor）IAM ロールが必要です。このロールを付与されていない場合は、管理者にお問い合わせください。
サブスクリプションの名前を指定している。
サブスクリプションをアタッチする既存のトピックの名前を指定している。
push サブスクリプションを作成する場合、受信 URL のプロトコルとして、pushEndpoint フィールドに https:// を小文字で指定している（http:// や HTTPS:// は不可）。

サブスクリプションに関するトラブルシューティングの詳細については、次のページをご覧ください。

pull、push、BigQuery、または Cloud Storage のトラブルシューティング
単一メッセージ変換を使用したサブスクリプションのトラブルシューティング
権限に関する問題のトラブルシューティング

権限に関する問題のトラブルシューティング

Pub/Sub 権限は、Pub/Sub リソースに対してアクションを実行できるユーザーとサービスアカウントを制御します。権限が正しく構成されていないと、権限拒否エラーが発生し、メッセージフローが中断される可能性があります。監査ログには、すべての権限変更の詳細な記録が残るため、これらの問題の原因を特定できます。

監査ログを使用して Pub/Sub の権限に関する問題をトラブルシューティングするには:

[ログエクスプローラ] を表示するために必要な権限を取得します。

詳細については、始める前にをご覧ください。
コンソール Google Cloud で、[**ログエクスプローラ**] ページに移動します。

[ログエクスプローラ] に移動
既存の Google Cloud プロジェクト、フォルダ、または組織を選択します。
関連するログを検索するために使用できるフィルタの一覧を次に示します。
- resource.type="pubsub_topic" OR resource.type="pubsub_subscription":トピックまたはサブスクリプションの構成の変更、アクセス制御に関連する問題のトラブルシューティングを行う場合は、このクエリを起点として使用します。他のフィルタと組み合わせて、検索を絞り込むことができます。
- protoPayload.methodName="google.iam.v1.SetIamPolicy": 問題の原因が権限の誤りまたは欠落であると思われる場合は、このクエリを使用します。IAM ポリシーを変更したユーザーと、その変更内容を追跡できます。これは、ユーザーがトピックに公開できない、またはサブスクリプションに登録できない、アプリケーションが Pub/Sub リソースへのアクセスを拒否された、アクセス制御が予期せず変更されたなどの問題のトラブルシューティングに役立ちます。
- protoPayload.status.code=7: 権限に明示的に関連するエラーが発生した場合は、このクエリを使用します。これにより、失敗しているアクションと、そのアクションを試行しているユーザーを特定できます。このクエリを前のクエリと組み合わせて、権限拒否の原因となっている可能性のある特定のリソースと IAM ポリシーの変更を特定できます。
ログを分析して、イベントのタイムスタンプ、変更を行ったプリンシパル、行われた変更の種類などの要素を特定します。
監査ログから収集した情報に基づいて、修正措置を講じることができます。

Terraform の権限に関する問題のトラブルシューティング

Terraform で Pub/Sub を使用する場合は、Terraform コードで必要なロールを明示的に付与します。たとえば、公開の場合、アプリケーションのサービスアカウントには roles/pubsub.publisher ロールが必要です。このロールが Terraform コードで明示的に定義されていない場合、今後の terraform apply で削除される可能性があります。これは、関連のないアップデート中に発生することが多く、信頼性の高いアプリケーションが突然 PERMISSION_DENIED エラーで失敗する原因となります。コードでロールを明示的に定義すると、このような意図しない回帰を防ぐことができます。

サブスクリプションが削除された

Pub/Sub サブスクリプションは、主に次の 2 つの方法で削除できます。

十分な権限を持つユーザーまたはサービスアカウントが、サブスクリプションを意図的に削除する。
サブスクリプションは、操作が行われない状態が一定期間（デフォルトでは 31 日間）続くと自動的に削除されます。サブスクリプションの有効期限ポリシーの詳細については、有効期間をご覧ください。

削除されたサブスクリプションのトラブルシューティングを行うには、次の手順を行います。

コンソール Google Cloud で、Pub/Sub の [サブスクリプション] ページに移動し、サブスクリプションがリストに表示されなくなったことを確認します。サブスクリプションを一覧表示する方法の詳細については、サブスクリプションを一覧表示するをご覧ください。
監査ログを確認します。[ログエクスプローラ] に移動します。フィルタ protoPayload.methodName="google.pubsub.v1.Subscriber.DeleteSubscription" を使用して、削除されたサブスクリプションを検索します。ログを調べて、誰かがサブスクリプションを削除したのか、操作が行われない状態が続いたために削除されたのかを確認します。 InternalExpireInactiveSubscription は、操作が行われない状態が続いたためにサブスクリプションが削除されたことを示します。トラブルシューティングに監査ログを使用する方法の詳細については、監査ログを使用して Pub/Sub の問題をトラブルシューティングするをご覧ください。

`403 (Forbidden)` エラー

通常、403 エラーは、アクションを実行するための適切な権限がないことを意味します。たとえば、トピックに公開しようとしたり、サブスクリプションから pull しようとしたりすると、403 User not authorized エラーが発生することがあります。

このエラーが発生した場合、以下を行ってください。

Google Cloud コンソールで Pub/Sub API が有効になっていることを確認します。
プロジェクト間の通信に Pub/Sub API を使用する場合は、リクエストを行うプリンシパルが、関連する Pub/Sub API リソースに必要な権限を持っていることを確認します。
Dataflow を使用している場合は、{PROJECT_NUMBER}@cloudservices.gserviceaccount.com と Compute Engine サービスアカウントの {PROJECT_NUMBER}-compute@developer.gserviceaccount.com の両方が、関連する Pub/Sub API リソースに対して必要な権限を持っていることを確認します。詳細については、Dataflow のセキュリティと権限をご覧ください。
App Engine を使用している場合、プロジェクトの権限ページで、App Engine サービスアカウントが Pub/Sub 編集者としてリストされているかどうか確認します。リストされていない場合、App Engine サービスアカウントを Pub/Sub 編集者として追加します。通常、 App Engine サービスアカウントは次の形式になります: <project-id>@appspot.gserviceaccount.com
監査ログを使用して、権限に関する問題をトラブルシューティングできます。

その他の一般的なエラーコード

Pub/Sub API に関連するその他の一般的なエラーコードとその説明の一覧については、エラーコードをご覧ください。

接続タイムアウト、レイテンシ、ネットワークエラー

Pub/Sub クライアントアプリケーションがサービスに接続 Google Cloud しようとすると、断続的または永続的な障害が発生することがあります。これらの問題は、次のように現れることがあります。

メッセージの公開時に大幅な遅延が発生し、アプリケーションのバックログが発生する可能性がある。
gRPC DEADLINE_EXCEEDED、code = DeadlineExceeded、java.net.SocketTimeoutException などのタイムアウトエラー。
pubsub.googleapis.com や oauth2.googleapis.com などのサービスにアクセスしようとしたときに発生する UNAVAILABLE: io exception や Connection refused などのネットワーク I/O エラー。

これらの接続の問題は、Pub/Sub 構成やアプリケーションコードを変更しなくても発生する可能性があります。これは、オンプレミスまたは VPC ファイアウォールが Google API にハードコードされた IP アドレスの許可リストを使用している場合に頻繁に発生します。Pub/Sub や認証サービスなどの依存関係を含む Google サービスでは、IP アドレスの動的範囲を使用します。ファイアウォールが新しい IP アドレスに対応していない場合、新しい IP アドレスへのトラフィックがブロックされ、接続と認証が失敗する可能性があります。

安定した接続を確保するには、Google サービスに静的 IP ベースのファイアウォールルールを使用しないでください。代替方法は次のとおりです。

ハードコードされたアドレスではなく、Google が公開しているデフォルトドメインの IP 範囲を使用してトラフィックを許可するようにファイアウォールを構成します。これらの範囲を取得してファイアウォールルールの更新を自動化する方法については、デフォルトドメインの IP アドレスをご覧ください。
プライベート Google アクセスを有効にします。これにより、VPC ネットワーク内のインスタンスは、公共のインターネットを経由せずに Google API とサービスにアクセスできるようになり、ファイアウォールの管理が簡素化されます。

JWT が無効です: トークンは有効期間が短いトークンである必要があります

アプリケーションが Invalid JWT: Token must be a short-lived token (60 minutes) and in a reasonable timeframe のようなエラーを Pub/Sub API とやり取りするときに受信する場合は、通常、認証情報のタイミングに問題があることを示しています。

このエラーは、API リクエストの認証に使用される JSON Web Token（JWT）の検証中に発生します。一般的な原因は、Pub/Sub ライブラリを実行しているクライアントマシンと Google の認証サーバーとの間に大きな時間差（時刻のずれ）があることです。JWT の有効期間は限られているため、クロックの不一致により、有効期限切れまたはまだ有効でないとみなされる可能性があります。

この問題を解決するには、クライアントマシンのクロックを同期します。

マシンの日付、時刻、タイムゾーンが正しいことを確認します。
ネットワークタイムプロトコル（NTP）サービスを使用してシステム時刻を同期し、サービスが実行されていて正しく構成されていることを確認します。

過剰な管理オペレーションの使用

管理オペレーションで割り当てを過剰に消費している場合、コードのリファクタリングが必要な可能性があります。ここでは、以下の疑似コードに基づいて説明します。この例では、リソースの消費を試行する前に、管理オペレーション（GET）を使用して、サブスクリプションが存在することを確認しています。GET と CREATE はどちらも管理者オペレーションです。

if !GetSubscription my-sub {
  CreateSubscription my-sub
}
Consume from subscription my-sub

サブスクリプションからメッセージを利用すると、より効率的になります（ただし、サブスクリプションの名前がある程度確実にわかる場合に限ります）。この楽観的なアプローチでは、エラーが発生した場合にのみサブスクリプションが取得または作成されます。次の例を考えてみましょう。

try {
  Consume from subscription my-sub
} catch NotFoundError {
  CreateSubscription my-sub
  Consume from subscription my-sub
}

次のコードサンプルを使用して、選択した言語でこのパターンを実装できます。

Go

次のサンプルでは、Go Pub/Sub クライアントライブラリのメジャーバージョン（v2）を使用しています。引き続き v1 ライブラリを使用している場合は、 v2 への移行ガイドをご覧ください。 v1 コードサンプルのリストについては、非推奨のコードサンプルをご覧ください。

このサンプルを試す前に、クイックスタート: クライアントライブラリの使用の Go の設定手順を実施してください。詳細については、Pub/Sub Go API のリファレンスドキュメントをご覧ください。

import (
	"context"
	"errors"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/pubsub/v2"
	"cloud.google.com/go/pubsub/v2/apiv1/pubsubpb"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
)

// optimisticSubscribe shows the recommended pattern for optimistically
// assuming a subscription exists prior to receiving messages.
func optimisticSubscribe(w io.Writer, projectID, topic, subscriptionName string) error {
	// projectID := "my-project-id"
	// topic := "projects/my-project-id/topics/my-topic"
	// subscription := "projects/my-project/subscriptions/my-sub"
	ctx := context.Background()
	client, err := pubsub.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("pubsub.NewClient: %w", err)
	}
	defer client.Close()

	// client.Subscriber can be passed a subscription ID (e.g. "my-sub") or
	// a fully qualified name (e.g. "projects/my-project/subscriptions/my-sub").
	// If a subscription ID is provided, the project ID from the client is used.
	sub := client.Subscriber(subscriptionName)

	// Receive messages for 10 seconds, which simplifies testing.
	// Comment this out in production, since `Receive` should
	// be used as a long running operation.
	ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
	defer cancel()

	// Instead of checking if the subscription exists, optimistically try to
	// receive from the subscription assuming it exists.
	err = sub.Receive(ctx, func(_ context.Context, msg *pubsub.Message) {
		fmt.Fprintf(w, "Got from existing subscription: %q\n", string(msg.Data))
		msg.Ack()
	})
	if err != nil {
		if st, ok := status.FromError(err); ok {
			if st.Code() == codes.NotFound {
				// If the subscription does not exist, then create the subscription.
				subscription, err := client.SubscriptionAdminClient.CreateSubscription(ctx, &pubsubpb.Subscription{
					Name:  subscriptionName,
					Topic: topic,
				})
				if err != nil {
					return err
				}
				fmt.Fprintf(w, "Created subscription: %q\n", subscriptionName)

				// client.Subscriber can be passed a subscription ID (e.g. "my-sub") or
				// a fully qualified name (e.g. "projects/my-project/subscriptions/my-sub").
				// If a subscription ID is provided, the project ID from the client is used.
				sub = client.Subscriber(subscription.GetName())
				err = sub.Receive(ctx, func(ctx context.Context, msg *pubsub.Message) {
					fmt.Fprintf(w, "Got from new subscription: %q\n", string(msg.Data))
					msg.Ack()
				})
				if err != nil && !errors.Is(err, context.Canceled) {
					return err
				}
			}
		}
	}
	return nil
}

Java

このサンプルを試す前に、クイックスタート: クライアントライブラリの使用の Java の設定手順を実施してください。詳細については、Pub/Sub Java API リファレンスドキュメントをご覧ください。


import com.google.api.gax.rpc.NotFoundException;
import com.google.cloud.pubsub.v1.AckReplyConsumer;
import com.google.cloud.pubsub.v1.MessageReceiver;
import com.google.cloud.pubsub.v1.Subscriber;
import com.google.cloud.pubsub.v1.SubscriptionAdminClient;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.pubsub.v1.ProjectSubscriptionName;
import com.google.pubsub.v1.PubsubMessage;
import com.google.pubsub.v1.PushConfig;
import com.google.pubsub.v1.Subscription;
import com.google.pubsub.v1.TopicName;
import java.io.IOException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class OptimisticSubscribeExample {
  public static void main(String... args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String subscriptionId = "your-subscription-id";
    String topicId = "your-topic-id";

    optimisticSubscribeExample(projectId, subscriptionId, topicId);
  }

  public static void optimisticSubscribeExample(
      String projectId, String subscriptionId, String topicId) throws IOException {
    ProjectSubscriptionName subscriptionName =
        ProjectSubscriptionName.of(projectId, subscriptionId);

    // Instantiate an asynchronous message receiver.
    MessageReceiver receiver =
        (PubsubMessage message, AckReplyConsumer consumer) -> {
          // Handle incoming message, then ack the received message.
          System.out.println("Id: " + message.getMessageId());
          System.out.println("Data: " + message.getData().toStringUtf8());
          consumer.ack();
        };

    Subscriber subscriber = null;
    try {
      subscriber = Subscriber.newBuilder(subscriptionName, receiver).build();

      // Listen for resource NOT_FOUND errors and rebuild the  subscriber and restart subscribing
      // when the current subscriber encounters these errors.
      subscriber.addListener(
          new Subscriber.Listener() {
            public void failed(Subscriber.State from, Throwable failure) {
              System.out.println(failure.getStackTrace());
              if (failure instanceof NotFoundException) {
                try (SubscriptionAdminClient subscriptionAdminClient =
                    SubscriptionAdminClient.create()) {
                  TopicName topicName = TopicName.of(projectId, topicId);
                  // Create a pull subscription with default acknowledgement deadline of 10 seconds.
                  // The client library will automatically extend acknowledgement deadlines.
                  Subscription subscription =
                      subscriptionAdminClient.createSubscription(
                          subscriptionName, topicName, PushConfig.getDefaultInstance(), 10);
                  System.out.println("Created pull subscription: " + subscription.getName());
                  optimisticSubscribeExample(projectId, subscriptionId, topicId);
                } catch (IOException err) {
                  System.out.println("Failed to create pull subscription: " + err.getMessage());
                }
              }
            }
          },
          MoreExecutors.directExecutor());

      subscriber.startAsync().awaitRunning();
      System.out.printf("Listening for messages on %s:\n", subscriptionName.toString());
      subscriber.awaitTerminated(30, TimeUnit.SECONDS);
    } catch (IllegalStateException e) {
      // Prevent an exception from being thrown if it is the expected NotFoundException
      if (!(subscriber.failureCause() instanceof NotFoundException)) {
        throw e;
      }
    } catch (TimeoutException e) {
      subscriber.stopAsync();
    }
  }
}

Node.js

このサンプルを試す前に、クイックスタート: クライアントライブラリの使用の Node.js の設定手順を実施してください。詳細については、Pub/Sub Node.js API リファレンスドキュメントをご覧ください。

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const subscriptionNameOrId = 'YOUR_SUBSCRIPTION_NAME_OR_ID';
// const topicNameOrId = 'YOUR_TOPIC_NAME_OR_ID';
// const timeout = 60;

// Imports the Google Cloud client library
const {PubSub} = require('@google-cloud/pubsub');

// Creates a client; cache this for further use
const pubSubClient = new PubSub();

function optimisticSubscribe(subscriptionNameOrId, topicNameOrId, timeout) {
  // Try using an existing subscription
  let subscription = pubSubClient.subscription(subscriptionNameOrId);

  // Create an event handler to handle messages
  let messageCount = 0;
  const messageHandler = message => {
    console.log(`Received message ${message.id}:`);
    console.log(`\tData: ${message.data}`);
    console.log(`\tAttributes: ${message.attributes}`);
    messageCount += 1;

    // "Ack" (acknowledge receipt of) the message
    message.ack();
  };

  // Set an error handler so that we're notified if the subscription doesn't
  // already exist.
  subscription.on('error', async e => {
    // Resource Not Found
    if (e.code === 5) {
      console.log('Subscription not found, creating it');
      await pubSubClient.createSubscription(
        topicNameOrId,
        subscriptionNameOrId,
      );

      // Refresh our subscriber object and re-attach the message handler.
      subscription = pubSubClient.subscription(subscriptionNameOrId);
      subscription.on('message', messageHandler);
    }
  });

  // Listen for new messages until timeout is hit; this will attempt to
  // open the actual subscriber streams. If it fails, the error handler
  // above will be called.
  subscription.on('message', messageHandler);

  // Wait a while for the subscription to run. (Part of the sample only.)
  setTimeout(() => {
    subscription.removeListener('message', messageHandler);
    console.log(`${messageCount} message(s) received.`);
  }, timeout * 1000);
}

Node.ts

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const subscriptionNameOrId = 'YOUR_SUBSCRIPTION_NAME_OR_ID';
// const topicNameOrId = 'YOUR_TOPIC_NAME_OR_ID';
// const timeout = 60;

// Imports the Google Cloud client library
import {PubSub, Message, StatusError} from '@google-cloud/pubsub';

// Creates a client; cache this for further use
const pubSubClient = new PubSub();

function optimisticSubscribe(
  subscriptionNameOrId: string,
  topicNameOrId: string,
  timeout: number,
) {
  // Try using an existing subscription
  let subscription = pubSubClient.subscription(subscriptionNameOrId);

  // Create an event handler to handle messages
  let messageCount = 0;
  const messageHandler = (message: Message) => {
    console.log(`Received message ${message.id}:`);
    console.log(`\tData: ${message.data}`);
    console.log(`\tAttributes: ${message.attributes}`);
    messageCount += 1;

    // "Ack" (acknowledge receipt of) the message
    message.ack();
  };

  // Set an error handler so that we're notified if the subscription doesn't
  // already exist.
  subscription.on('error', async (e: StatusError) => {
    // Resource Not Found
    if (e.code === 5) {
      console.log('Subscription not found, creating it');
      await pubSubClient.createSubscription(
        topicNameOrId,
        subscriptionNameOrId,
      );

      // Refresh our subscriber object and re-attach the message handler.
      subscription = pubSubClient.subscription(subscriptionNameOrId);
      subscription.on('message', messageHandler);
    }
  });

  // Listen for new messages until timeout is hit; this will attempt to
  // open the actual subscriber streams. If it fails, the error handler
  // above will be called.
  subscription.on('message', messageHandler);

  // Wait a while for the subscription to run. (Part of the sample only.)
  setTimeout(() => {
    subscription.removeListener('message', messageHandler);
    console.log(`${messageCount} message(s) received.`);
  }, timeout * 1000);
}

Python

このサンプルを試す前に、クイックスタート: クライアントライブラリの使用の Python の設定手順を実施してください。詳細については、Pub/Sub Python API リファレンスドキュメントをご覧ください。

from google.api_core.exceptions import NotFound
from google.cloud import pubsub_v1
from concurrent.futures import TimeoutError

# TODO(developer)
# project_id = "your-project-id"
# subscription_id = "your-subscription-id"
# Number of seconds the subscriber should listen for messages
# timeout = 5.0
# topic_id = "your-topic-id"

# Create a subscriber client.
subscriber = pubsub_v1.SubscriberClient()

# The `subscription_path` method creates a fully qualified identifier
# in the form `projects/{project_id}/subscriptions/{subscription_id}`
subscription_path = subscriber.subscription_path(project_id, subscription_id)

# Define callback to be called when a message is received.
def callback(message: pubsub_v1.subscriber.message.Message) -> None:
    # Ack message after processing it.
    message.ack()

# Wrap subscriber in a 'with' block to automatically call close() when done.
with subscriber:
    try:
        # Optimistically subscribe to messages on the subscription.
        streaming_pull_future = subscriber.subscribe(
            subscription_path, callback=callback
        )
        streaming_pull_future.result(timeout=timeout)
    except TimeoutError:
        print("Successfully subscribed until the timeout passed.")
        streaming_pull_future.cancel()  # Trigger the shutdown.
        streaming_pull_future.result()  # Block until the shutdown is complete.
    except NotFound:
        print(f"Subscription {subscription_path} not found, creating it.")

        try:
            # If the subscription does not exist, then create it.
            publisher = pubsub_v1.PublisherClient()
            topic_path = publisher.topic_path(project_id, topic_id)
            subscription = subscriber.create_subscription(
                request={"name": subscription_path, "topic": topic_path}
            )

            if subscription:
                print(f"Subscription {subscription.name} created")
            else:
                raise ValueError("Subscription creation failed.")

            # Subscribe on the created subscription.
            try:
                streaming_pull_future = subscriber.subscribe(
                    subscription.name, callback=callback
                )
                streaming_pull_future.result(timeout=timeout)
            except TimeoutError:
                streaming_pull_future.cancel()  # Trigger the shutdown.
                streaming_pull_future.result()  # Block until the shutdown is complete.
        except Exception as e:
            print(
                f"Exception occurred when creating subscription and subscribing to it: {e}"
            )
    except Exception as e:
        print(f"Exception occurred when attempting optimistic subscribe: {e}")

C++

このサンプルを試す前に、クイックスタート: クライアントライブラリの使用の C++ の設定手順を実施してください。詳細については、Pub/Sub C++ API リファレンスドキュメントをご覧ください。

auto process_response = [](gc::StatusOr<pubsub::PullResponse> response) {
  if (response) {
    std::cout << "Received message " << response->message << "\n";
    std::move(response->handler).ack();
    return gc::Status();
  }
  if (response.status().code() == gc::StatusCode::kUnavailable &&
      response.status().message() == "no messages returned") {
    std::cout << "No messages returned from Pull()\n";
    return gc::Status();
  }
  return response.status();
};

// Instead of checking if the subscription exists, optimistically try to
// consume from the subscription.
auto status = process_response(subscriber.Pull());
if (status.ok()) return;
if (status.code() != gc::StatusCode::kNotFound) throw std::move(status);

// Since the subscription does not exist, create the subscription.
pubsub_admin::SubscriptionAdminClient subscription_admin_client(
    pubsub_admin::MakeSubscriptionAdminConnection());
google::pubsub::v1::Subscription request;
request.set_name(
    pubsub::Subscription(project_id, subscription_id).FullName());
request.set_topic(
    pubsub::Topic(project_id, std::move(topic_id)).FullName());
auto sub = subscription_admin_client.CreateSubscription(request);
if (!sub) throw std::move(sub).status();

// Consume from the new subscription.
status = process_response(subscriber.Pull());
if (!status.ok()) throw std::move(status);

一般的なトラブルシューティング コレクションでコンテンツを整理 必要に応じて、コンテンツの保存と分類を行います。