O Google usa tecnologia de IA na tradução de conteúdos para seu idioma de preferência. As traduções com IA podem ter erros.

Solução de problemas gerais

Saiba mais sobre as etapas de solução de problemas que podem ser úteis se você tiver problemas durante o uso do Pub/Sub.

Não é possível criar um tópico

Verifique se você tem as permissões necessárias permissions. Para criar um tópico do Pub/Sub, você precisa do papel Editor do Pub/Sub (roles/pubsub.editor) do Identity and Access Management no projeto. Se você não tiver esse papel, entre em contato com o administrador. Para mais informações sobre a solução de problemas relacionados a tópicos, consulte as seguintes páginas:

Não é possível criar uma assinatura

Verifique se você fez o seguinte:

Verifique se você tem as permissões necessárias permissions. Para criar uma assinatura do Pub/Sub, você precisa do papel de IAM Editor do Pub/Sub (roles/pubsub.editor) no projeto. Se você não tiver esse papel, entre em contato com o administrador.
Especificou um nome para a assinatura.
Especificou o nome de um tópico existente ao qual você quer anexar a assinatura.
Se você estiver criando uma assinatura por push, especifique https:// em letras minúsculas (não http:// ou HTTPS://) como o protocolo para o URL de recebimento no campo pushEndpoint.

Para mais informações sobre a solução de problemas relacionados a assinaturas, consulte as seguintes páginas:

Solução de problemas de pull, push, BigQuery, ou Cloud Storage
Solução de problemas de assinaturas com transformações de mensagem única
Solução de problemas de permissões

Resolver problemas de permissão

As permissões do Pub/Sub controlam quais usuários e contas de serviço podem realizar ações nos recursos do Pub/Sub. Quando as permissões estão mal configuradas, isso pode levar a erros de permissão negada e interromper o fluxo de mensagens. Os registros de auditoria fornecem um registro detalhado de todas as mudanças de permissão, permitindo que você identifique a origem desses problemas.

Para resolver problemas de permissão do Pub/Sub com registros de auditoria:

Receba as permissões necessárias para acessar a Análise de registros.

Para mais informações, consulte Antes de começar.
No Google Cloud console do, acesse a página Análise de registros.

Acessar a Análise de registros
Selecione um Google Cloud projeto, uma pasta ou uma organização do.
Confira uma lista de filtros que podem ser usados para encontrar registros relevantes:
- resource.type="pubsub_topic" OR resource.type="pubsub_subscription": Use esta consulta como ponto de partida ao resolver qualquer problema que possa envolver mudanças nas configurações de tópico ou assinatura, ou controle de acesso. É possível combiná-la com outros filtros para refinar ainda mais a pesquisa.
- protoPayload.methodName="google.iam.v1.SetIamPolicy": use essa consulta quando suspeitar que um problema é causado por permissões incorretas ou ausentes. Ela ajuda a rastrear quem fez mudanças na política do IAM e quais foram essas mudanças. Isso pode ser útil para resolver problemas como usuários que não conseguem publicar em tópicos ou se inscrever em assinaturas, aplicativos com acesso negado a recursos do Pub/Sub ou mudanças inesperadas no controle de acesso.
- protoPayload.status.code=7: use essa consulta quando encontrar erros explicitamente relacionados a permissões. Isso ajuda a identificar quais ações estão falhando e quem está tentando realizá-las. É possível combinar essa consulta com as anteriores para identificar o recurso específico e a mudança na política do IAM que podem estar causando a negação de permissão.
Analise os registros para determinar fatores como o carimbo de data/hora do evento, o principal que fez a mudança e o tipo de mudanças feitas.
Com base nas informações coletadas nos registros de auditoria, você pode tomar ações corretivas.

Resolver problemas de permissão do Terraform

Ao usar o Pub/Sub com o Terraform, conceda explicitamente os papéis necessários no código do Terraform. Por exemplo, para publicar, a conta de serviço do aplicativo precisa do papel roles/pubsub.publisher. Se esse papel não estiver definido explicitamente no código do Terraform, um terraform apply futuro poderá removê-lo. Isso geralmente acontece durante atualizações não relacionadas, fazendo com que um aplicativo confiável falhe repentinamente com erros PERMISSION_DENIED. Definir explicitamente o papel no código impede essas regressões acidentais.

A assinatura foi excluída

As assinaturas do Pub/Sub podem ser excluídas de duas maneiras principais:

Um usuário ou conta de serviço com permissões suficientes exclui intencionalmente a assinatura.
Uma assinatura é excluída automaticamente após um período de inatividade, que é de 31 dias por padrão. Para mais informações sobre a política de expiração de assinatura, consulte Período de expiração.

Para resolver problemas de uma assinatura excluída, siga estas etapas:

No Google Cloud console do, acesse a página de assinaturas do Pub/Sub e verifique se a assinatura não está mais listada. Para mais informações sobre como listar assinaturas, consulte Listar uma assinatura.
Verifique os registros de auditoria. Acesse a Análise de registros. Use o filtro protoPayload.methodName="google.pubsub.v1.Subscriber.DeleteSubscription" para encontrar assinaturas excluídas. Examine os registros para determinar se alguém excluiu a assinatura ou se ela foi excluída devido à inatividade. InternalExpireInactiveSubscription indica que uma assinatura foi excluída devido à inatividade. Para mais informações sobre como usar registros de auditoria para solução de problemas, consulte Resolver problemas do Pub/Sub com registros de auditoria.

Erro `403 (Forbidden)`

Um erro 403 geralmente significa que você não tem as permissões corretas para realizar uma ação. Por exemplo, você pode receber um erro 403 User not authorized ao tentar publicar em um tópico ou extrair de uma assinatura.

Se você receber esse erro, faça o seguinte:

Verifique se você ativou a API Pub/Sub no Google Cloud console.
Confira se quem fez a solicitação tem as permissões necessárias para os recursos relevantes da API Pub/Sub, especialmente se a API Pub/Sub estiver sendo usada para a comunicação entre projetos.
Se você usa o Cloud Dataflow, certifique-se de que o {PROJECT_NUMBER}@cloudservices.gserviceaccount.com e a conta de serviço do Compute Engine {PROJECT_NUMBER}-compute@developer.gserviceaccount.com tenham as permissões necessárias no recurso da API Pub/Sub correspondente. Para mais informações, consulte Segurança e permissões do Dataflow.
Se você está usando o App Engine, verifique a página Permissões do seu projeto para ver se uma conta de serviço do App Engine está listada como um Editor do Pub/Sub. Se não houver, adicione sua conta de serviço do App Engine como um Editor do Pub/Sub. Normalmente, a conta de serviço do App Engine está no formato <project-id>@appspot.gserviceaccount.com.
É possível usar registros de auditoria para resolver problemas de permissão.

Outros códigos de erro comuns

Para uma lista de outros códigos de erro comuns relacionados à API Pub/Sub e suas descrições, consulte Códigos de erro.

Tempos limite de conexão, latência ou erros de rede

Você pode ter falhas intermitentes ou persistentes quando os aplicativos cliente do Pub/Sub tentam se conectar a Google Cloud serviços. Esses problemas podem se manifestar como:

Atrasos significativos ao publicar mensagens, o que pode causar atrasos no aplicativo.
Erros de tempo limite, como gRPC DEADLINE_EXCEEDED, code = DeadlineExceeded ou java.net.SocketTimeoutException.
Falhas de E/S de rede, como UNAVAILABLE: io exception ou erros Connection refused ao tentar acessar serviços como pubsub.googleapis.com ou oauth2.googleapis.com.

Esses problemas de conectividade podem surgir mesmo sem mudanças na configuração do Pub/Sub ou no código do aplicativo. Isso ocorre com frequência quando firewalls locais ou de VPC usam listas de permissões de endereço IP codificadas para APIs do Google. Os serviços do Google, incluindo o Pub/Sub e dependências como serviços de autenticação, usam um intervalo dinâmico de endereços IP. Se o firewall não considerar novos endereços IP, ele poderá bloquear o tráfego para os novos endereços IP, causando falhas de conexão e autenticação.

Para garantir uma conectividade estável, evite regras de firewall estáticas baseadas em IP para serviços do Google. Em vez disso:

Configure o firewall para permitir o tráfego usando os intervalos de IP publicados do Google para domínios padrão, em vez de endereços codificados. Para saber como acessar esses intervalos e automatizar atualizações nas regras de firewall, consulte Endereços IP para domínios padrão.
Ative o Acesso privado do Google, que permite que instâncias na rede VPC alcancem APIs do Google e serviços sem atravessar a Internet pública, simplificando o gerenciamento de firewall.

JWT inválido: o token precisa ser de curta duração

Se você receber um erro como Invalid JWT: Token must be a short-lived token (60 minutes) and in a reasonable timeframe quando o aplicativo interage com a API Pub/Sub, isso geralmente indica um problema com o tempo das credenciais de autenticação.

Esse erro ocorre durante a validação do JSON Web Token (JWT) usado para autenticar solicitações de API. Uma causa comum é uma diferença de tempo significativa (distorção de tempo) entre a máquina cliente que executa a biblioteca do Pub/Sub e os servidores de autenticação do Google. Como os JWTs têm uma janela de validade limitada, as discrepâncias de relógio podem fazer com que eles sejam tratados como expirados ou ainda não válidos.

Para resolver esse problema, sincronize o relógio da máquina cliente:

Verifique se a data, a hora e o fuso horário da máquina estão corretos.
Use um serviço de Network Time Protocol (NTP) para manter a hora do sistema sincronizada e verifique se o serviço está em execução e configurado corretamente.

Operações administrativas excessivas

Se você perceber que está gastando muito da cota de operações administrativas, talvez seja necessário refatorar o código. Para ilustrar, considere este pseudo-código. Neste exemplo, uma operação administrativa (GET) está sendo usada para verificar a presença de uma assinatura antes de tentar consumir os recursos dela. As operações GET e CREATE são do administrador:

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

Um padrão mais eficiente é tentar consumir mensagens da assinatura (supondo que você possa ter certeza razoável do nome da assinatura). Nesse caso, você só recebe ou cria a assinatura em caso de erro. Por exemplo,

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

É possível usar os exemplos de código a seguir para implementar esse padrão na linguagem de sua preferência:

Go

O exemplo a seguir usa a versão principal da biblioteca de cliente do Go Pub/Sub (v2). Se você ainda estiver usando a biblioteca v1, consulte o guia de migração para a v2. Para conferir uma lista de exemplos de código v1, consulte os exemplos de código obsoletos.

Antes de tentar esse exemplo, siga as instruções de configuração do Go em Guia de início rápido: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Pub/Sub Go.

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

Antes de tentar essa amostra, siga as instruções de configuração do Java em Guia de início rápido: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Pub/Sub para Java (em inglês).


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

Antes de tentar essa amostra, siga as instruções de configuração do Node.js em Guia de início rápido: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Pub/Sub para Node.js (em inglês).

/**
 * 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

Antes de tentar esse exemplo, siga as instruções de configuração do Python em Guia de início rápido: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Python do Pub/Sub.

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++

Antes de tentar esse exemplo, siga as instruções de configuração do C++ em Guia de início rápido: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Pub/Sub C++.

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

Solução de problemas gerais Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.