Desencapsulamento de payload para assinaturas de push do Pub/Sub

Ao criar seu sistema do Pub/Sub, o desencapsulamento de payload pode ajudar Você se conecta a outros sistemas que não atendem a todos os requisitos de um implementação padrão de endpoint de push do Pub/Sub.

Alguns possíveis casos de uso para desencapsulamento de payload são:

  • Você não quer escrever códigos de análise de mensagens específicos do Pub/Sub para os endpoints de push HTTP.
  • Você prefere receber metadados de mensagens do Pub/Sub como cabeçalhos HTTP em vez dos metadados no corpo do POST HTTP.
  • Você quer enviar mensagens do Pub/Sub e excluir metadados do Pub/Sub, por exemplo, ao enviar dados para um API de terceiros.

Como funciona o desencapsulamento de payload

O desencapsulamento de payload é um recurso que remove o Pub/Sub mensagens de todos os metadados da mensagem, exceto os dados da mensagem. Ao enviar dados brutos os assinantes podem processar a mensagem sem precisar seguir as os requisitos do sistema do Pub/Sub.

  • Com o desencapsulamento de payload, os dados da mensagem são entregues diretamente como o body.
  • Sem o desencapsulamento de payload, o Pub/Sub entrega um objeto JSON que contém vários campos de metadados de mensagem e um campo de dados da mensagem. Neste caso, o JSON deve ser analisado para recuperar os dados da mensagem e, em seguida, base64 decodificadas.

Gravar metadados

Depois de ativar o desencapsulamento de payload, use a opção write metadata, que adiciona metadados de mensagens removidos anteriormente ao cabeçalho da solicitação.

  • Metadados de gravação ativados. Adicionar metadados da mensagem de volta à solicitação cabeçalho. Também entrega os dados brutos e decodificados da mensagem.
  • Metadados de gravação desativados. Mostra apenas os dados brutos e decodificados da mensagem.

Os metadados de gravação são expostos por meio do Pub/Sub, a Google Cloud CLI argumento --push-no-wrapper-write-metadata e a propriedade de API NoWrapper. Por padrão, esse valor é nulo.

Antes de começar

Exemplo de mensagens com e sem wrapper

Os exemplos a seguir ilustram a diferença entre o envio de uma uma mensagem HTTP encapsulada ou não. Nestes exemplos, os dados da mensagem contêm a string {"status": "Hello there"}.

Para este exemplo, uma assinatura é criada com o desencapsulamento do payload recurso ativado e publica uma mensagem no mytopic. Ele usa uma função chave com um valor de some-key e o tipo de mídia é declarado como application/json.

gcloud pubsub topics publish mytopic
   --message='{"status": "Hello there"}'
   --ordering-key="some-key"
   --attribute "Content-Type=application/json"

As seções a seguir mostram a diferença entre um com wrapper e um desencapsulado. mensagem.

Mensagem encapsulada

O exemplo a seguir mostra uma mensagem encapsulada do Pub/Sub padrão. Em Nesse caso, o desencapsulamento de payload não está ativado.

Publicar Recebimentos do endpoint de push 
data="{"status": "Hello there"}"
ordering_key="some-key"
attributes=
  {
     {"Content-Type", "application/json"}
  }
 
Content-Length: 361
Content-Type: application/json
User-Agent: CloudPubSub-Google
Host: subscription-project.uc.r.appspot.com

{
  "message": {
      "attributes": {
          "Content-Type": "application/json"
      },
      "data": "eyJzdGF0dXMiOiAiSGVsbG8gdGhlcmUifQ==", //  Base64 - {"status": "Hello there"}
      "messageId": "2070443601311540",
      "message_id": "2070443601311540",
      "publishTime": "2021-02-26T19:13:55.749Z",
      "publish_time": "2021-02-26T19:13:55.749Z"
  },
  "subscription": "projects/myproject/..."
}

Mensagem desencapsulada com metadados de gravação desativados

O exemplo a seguir mostra uma mensagem desencapsulada com a opção de metadados de gravação desativado. Nesse caso, os cabeçalhos x-goog-pubsub-* e os atributos da mensagem não estão incluídas.

Publicar Recebimentos do endpoint de push 
data="{"status": "Hello there"}"
ordering_key="some-key"
attributes=
  {
     {"Content-Type", "application/json"}
  }
 
Content-Length: 25
User-Agent: CloudPubSub-Google
Host: subscription-project.uc.r.appspot.com

{"status": "Hello there"}

Mensagem desencapsulada com metadados de gravação ativados

O exemplo a seguir mostra uma mensagem desencapsulada com a opção de metadados de gravação ativado. Nesse caso, os cabeçalhos x-goog-pubsub-* e os atributos da mensagem estão incluídas.

Publicar Recebimentos do endpoint de push 
data="{"status": "Hello there"}"
ordering_key="some-key"
attributes=
  {
     {"Content-Type", "application/json"}
  }
 
x-goog-pubsub-subscription-name: "projects/myproject/..."
x-goog-pubsub-message-id: "2070443601311540"
x-goog-pubsub-publish-time: "2021-02-26T19:13:55.749Z"
x-goog-pubsub-ordering-key: "some-key"
Content-Type: application/json
Content-Length: 12
User-Agent: CloudPubSub-Google
Host: subscription-project.uc.r.appspot.com

{"status": "Hello there"}

Configurar desencapsulamento de payload

É possível ativar a entrega por push de desencapsulamento de payload para uma assinatura usando a página Detalhes da assinatura do console do Google Cloud, a Google Cloud CLI ou as bibliotecas de cliente.

Console

  1. No console do Google Cloud, acesse a página Assinaturas.

    Abrir assinaturas do Pub/Sub

  2. Clique em Criar assinatura.

  3. No campo ID da assinatura, digite um nome.

    Para saber mais sobre como nomear uma assinatura, consulte Diretrizes para nomear um tópico ou uma assinatura.

  4. Selecione um tópico no menu suspenso. A assinatura recebe mensagens do tópico.

  5. Em Tipo de entrega, selecione Push.

  6. Para ativar o desencapsulamento de payload, selecione Ativar desencapsulamento de payload.

  7. (Opcional) Para preservar os metadados das mensagens no cabeçalho da solicitação, faça o seguinte: selecione Gravar metadados. Você precisa ativar esta opção para definir um cabeçalho Content-Type para suas mensagens.

  8. Especifique um URL de endpoint.

  9. Mantenha todos os outros valores padrão.

  10. Clique em Criar.

gcloud

Para configurar uma assinatura com desencapsulamento de payload que inclua Cabeçalhos HTTP, execute o seguinte gcloud pubsub subscriptions create comando:

gcloud pubsub subscriptions create SUBSCRIPTION \
  --topic TOPIC \
  --push-endpoint=PUSH_ENDPOINT \
  --push-no-wrapper

Substitua:

  • SUBSCRIPTION: o nome ou o ID da assinatura de pull.
  • TOPIC: o ID do tópico.
  • PUSH_ENDPOINT: o URL que será usado como endpoint. assinatura. Por exemplo, https://myproject.appspot.com/myhandler
  • --push-no-wrapper: entrega os dados da mensagem diretamente como o corpo HTTP.

Para configurar uma assinatura com desencapsulamento de payload e controlar o uso de x-goog-pubsub-*, execute o seguinte comando:

gcloud pubsub subscriptions create SUBSCRIPTION \
  --topic TOPIC \
  --push-endpoint=PUSH_ENDPOINT \
  --push-no-wrapper \
  --push-no-wrapper-write-metadata
  • --push-no-wrapper-write-metadata: quando verdadeiro, grava o Metadados da mensagem do Pub/Sub para x-goog-pubsub-<KEY>:<VAL> cabeçalhos da solicitação HTTP. escreve a mensagem do Pub/Sub atributos aos cabeçalhos <KEY>:<VAL> da solicitação HTTP.

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 Pub/Sub Python. 

from google.cloud import pubsub_v1

# TODO(developer)
# project_id = "your-project-id"
# topic_id = "your-topic-id"
# subscription_id = "your-subscription-id"
# endpoint = "https://my-test-project.appspot.com/push"

publisher = pubsub_v1.PublisherClient()
subscriber = pubsub_v1.SubscriberClient()
topic_path = publisher.topic_path(project_id, topic_id)
subscription_path = subscriber.subscription_path(project_id, subscription_id)

no_wrapper = pubsub_v1.types.PushConfig.NoWrapper(write_metadata=True)
push_config = pubsub_v1.types.PushConfig(
    push_endpoint=endpoint, no_wrapper=no_wrapper
)

# Wrap the subscriber in a 'with' block to automatically call close() to
# close the underlying gRPC channel when done.
with subscriber:
    subscription = subscriber.create_subscription(
        request={
            "name": subscription_path,
            "topic": topic_path,
            "push_config": push_config,
        }
    )

print(f"Push no wrapper subscription created: {subscription}.")
print(f"Endpoint for subscription is: {endpoint}")
print(f"No wrapper configuration for subscription is: {no_wrapper}")

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 Java. 

/*
 * Copyright 2016 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package pubsub;


import com.google.cloud.pubsub.v1.SubscriptionAdminClient;
import com.google.pubsub.v1.PushConfig;
import com.google.pubsub.v1.PushConfig.NoWrapper;
import com.google.pubsub.v1.Subscription;
import com.google.pubsub.v1.SubscriptionName;
import com.google.pubsub.v1.TopicName;
import java.io.IOException;

public class CreateUnwrappedPushSubscriptionExample {
  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";
    String pushEndpoint = "https://my-test-project.appspot.com/push";

    createPushSubscriptionExample(projectId, subscriptionId, topicId, pushEndpoint);
  }

  public static void createPushSubscriptionExample(
      String projectId, String subscriptionId, String topicId, String pushEndpoint)
      throws IOException {
    try (SubscriptionAdminClient subscriptionAdminClient = SubscriptionAdminClient.create()) {
      TopicName topicName = TopicName.of(projectId, topicId);
      SubscriptionName subscriptionName = SubscriptionName.of(projectId, subscriptionId);
      NoWrapper noWrapper =
          NoWrapper.newBuilder()
              // Determines if message metadata is added to the HTTP headers of
              // the delivered message.
              .setWriteMetadata(true)
              .build();
      PushConfig pushConfig =
          PushConfig.newBuilder().setPushEndpoint(pushEndpoint).setNoWrapper(noWrapper).build();

      // Create a push subscription with default acknowledgement deadline of 10 seconds.
      // Messages not successfully acknowledged within 10 seconds will get resent by the server.
      Subscription subscription =
          subscriptionAdminClient.createSubscription(subscriptionName, topicName, pushConfig, 10);
      System.out.println("Created push subscription: " + subscription.getName());
    }
  }
}

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

namespace pubsub = ::google::cloud::pubsub;
namespace pubsub_admin = ::google::cloud::pubsub_admin;
[](pubsub_admin::SubscriptionAdminClient client,
   std::string const& project_id, std::string const& topic_id,
   std::string const& subscription_id, std::string const& endpoint) {
  google::pubsub::v1::Subscription request;
  request.set_name(
      pubsub::Subscription(project_id, subscription_id).FullName());
  request.set_topic(pubsub::Topic(project_id, topic_id).FullName());
  request.mutable_push_config()->set_push_endpoint(endpoint);
  request.mutable_push_config()->mutable_no_wrapper()->set_write_metadata(
      true);
  auto sub = client.CreateSubscription(request);
  if (sub.status().code() == google::cloud::StatusCode::kAlreadyExists) {
    std::cout << "The subscription already exists\n";
    return;
  }
  if (!sub) throw std::move(sub).status();

  std::cout << "The subscription was successfully created: "
            << sub->DebugString() << "\n";
}

Go

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"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/pubsub"
)

// createPushNoWrapperSubscription creates a push subscription where messages are delivered in the HTTP body.
func createPushNoWrapperSubscription(w io.Writer, projectID, subID string, topic *pubsub.Topic, endpoint string) error {
	// projectID := "my-project-id"
	// subID := "my-sub"
	// topic of type https://godoc.org/cloud.google.com/go/pubsub#Topic
	// endpoint := "https://my-test-project.appspot.com/push"
	ctx := context.Background()
	client, err := pubsub.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("pubsub.NewClient: %w", err)
	}
	defer client.Close()

	sub, err := client.CreateSubscription(ctx, subID, pubsub.SubscriptionConfig{
		Topic:       topic,
		AckDeadline: 10 * time.Second,
		PushConfig: pubsub.PushConfig{
			Endpoint: endpoint,
			Wrapper: &pubsub.NoWrapper{
				// Determines if message metadata is added to the HTTP headers of
				// the delivered message.
				WriteMetadata: true,
			},
		},
	})
	if err != nil {
		return fmt.Errorf("CreateSubscription: %w", err)
	}
	fmt.Fprintf(w, "Created push no wrapper subscription: %v\n", sub)
	return nil
}

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 Node.js. 

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

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

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

async function createPushSubscriptionNoWrapper(
  pushEndpoint,
  topicNameOrId,
  subscriptionNameOrId
) {
  const options = {
    pushConfig: {
      // Set to an HTTPS endpoint of your choice. If necessary, register
      // (authorize) the domain on which the server is hosted.
      pushEndpoint,
      // When true, writes the Pub/Sub message metadata to
      // `x-goog-pubsub-<KEY>:<VAL>` headers of the HTTP request. Writes the
      // Pub/Sub message attributes to `<KEY>:<VAL>` headers of the HTTP request.
      noWrapper: {
        writeMetadata: true,
      },
    },
  };

  await pubSubClient
    .topic(topicNameOrId)
    .createSubscription(subscriptionNameOrId, options);
  console.log(`Subscription ${subscriptionNameOrId} created.`);
}

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 Node.js. 

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

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

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

async function createPushSubscriptionNoWrapper(
  pushEndpoint: string,
  topicNameOrId: string,
  subscriptionNameOrId: string
) {
  const options: CreateSubscriptionOptions = {
    pushConfig: {
      // Set to an HTTPS endpoint of your choice. If necessary, register
      // (authorize) the domain on which the server is hosted.
      pushEndpoint,
      // When true, writes the Pub/Sub message metadata to
      // `x-goog-pubsub-<KEY>:<VAL>` headers of the HTTP request. Writes the
      // Pub/Sub message attributes to `<KEY>:<VAL>` headers of the HTTP request.
      noWrapper: {
        writeMetadata: true,
      },
    },
  };

  await pubSubClient
    .topic(topicNameOrId)
    .createSubscription(subscriptionNameOrId, options);
  console.log(`Subscription ${subscriptionNameOrId} created.`);
}

Defina um cabeçalho de tipo de conteúdo na sua mensagem

Depois de ativar o desencapsulamento de payload, o Pub/Sub não define automaticamente um campo de cabeçalho de tipo de mídia na solicitação. Se você não definir explicitamente um campo de cabeçalho Content-Type, o servidor da Web processando sua solicitação pode definir um valor padrão de application/octet-stream ou interpretar a solicitação de maneira inesperada.

Se você precisa de um cabeçalho Content-Type, declare-o explicitamente no momento da publicação para cada mensagem publicada. Para fazer isso, você deve Ative a opção Metadados de gravação. O resultado da ativação da opção Metadados de gravação é mostrado nos exemplos fornecidos.

A seguir