Crie um tópico de importação do Amazon Kinesis Data Streams

Um tópico de importação do Amazon Kinesis Data Streams permite ingerir dados de Amazon Kinesis Data Streams como fonte externa para o Pub/Sub. Depois, é possível transmitir os dados para qualquer um dos destinos com suporte do Pub/Sub.

Este documento mostra como criar e gerenciar o Amazon Kinesis Tópicos de importação de fluxos de dados. Para criar um tópico padrão, consulte Crie um tópico padrão.

Antes de começar

Papéis e permissões necessários para gerenciar tópicos de importação

Para ter as permissões necessárias para criar e gerenciar tópicos de importação do Amazon Kinesis Data Streams, peça ao administrador para conceder a você Editor do Pub/Sub(roles/pubsub.editor) papel do IAM no tópico ou projeto. Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Esse papel predefinido contém as permissões necessárias para criar e gerenciar tópicos de importação do Amazon Kinesis Data Streams. Para conferir as permissões exatas necessárias, expanda a seção Permissões necessárias:

Permissões necessárias

As seguintes permissões são necessárias para criar e gerenciar tópicos de importação do Amazon Kinesis Data Streams:

  • Crie um tópico de importação: pubsub.topics.create
  • Exclua um tema de importação: pubsub.topics.delete
  • Receba um tema de importação: pubsub.topics.get
  • Listar um tema de importação: pubsub.topics.list
  • Publicar em um tópico de importação: pubsub.topics.publish
  • Atualizar um tópico de importação: pubsub.topics.update
  • Acesse a política do IAM para um tópico de importação: pubsub.topics.getIamPolicy
  • Configure a política do IAM para um tópico de importação: pubsub.topics.setIamPolicy

Essas permissões também podem ser concedidas com funções personalizadas ou outros papéis predefinidos.

É possível configurar o controle de acesso no nível do projeto e do recurso individual.

Configure a identidade federada para acessar o Kinesis Data Streams

A federação de identidade da carga de trabalho permite que os serviços do Google Cloud acessem cargas de trabalho em execução fora do Google Cloud. Com a federação de identidade, não é necessário manter ou transmitir credenciais para o Google Cloud para acessar seus recursos em outras nuvens. Em vez disso, use as identidades das próprias cargas de trabalho para autenticar no Google Cloud e acessar recursos.

Criar uma conta de serviço no Google Cloud

Essa é uma etapa opcional. Se você já tiver uma conta de serviço, poderá usá-la neste procedimento em vez de criar uma nova. Se você estiver usando uma conta de serviço atual, acesse Registre o ID exclusivo da conta de serviço do para a próxima etapa.

Para um tópico de importação do Amazon Kinesis Data Streams, o Pub/Sub usa a conta de serviço como identidade para acessar recursos da AWS.

Para mais informações sobre como criar uma conta de serviço, incluindo pré-requisitos, papéis e permissões obrigatórios e diretrizes de nomenclatura, consulte Criar contas de serviço. Depois de criar uma conta de serviço, talvez seja necessário aguardar 60 segundos ou mais para usá-la. Esse comportamento ocorre porque as operações de leitura têm consistência eventual e pode levar algum tempo para a nova conta de serviço ficar visível.

Gravar o ID exclusivo da conta de serviço

Você precisa de um ID exclusivo da conta de serviço para configurar uma função no console da AWS.

  1. No console do Google Cloud, acesse a página de detalhes da Conta de serviço.

    Acessar a conta de serviço

  2. Clique na conta de serviço que você acabou de criar ou naquela que que planeja usar.

  3. Na página Detalhes da conta de serviço, registre o número do ID exclusivo.

    Você vai precisar do ID como parte da seção Criar uma função na AWS usando uma política de confiança personalizada.

Adicione o papel de criador do token da conta de serviço à conta de serviço do Pub/Sub

O Papel de criador de token da conta de serviço (roles/iam.serviceAccountTokenCreator) permite que os principais criem credenciais de curta duração para uma conta de serviço. Esses tokens ou credenciais são usados para falsificar a conta de serviço.

Para mais informações sobre representação da conta de serviço, consulte Representação da conta de serviço.

Também é possível adicionar o papel de editor do Pub/Sub (roles/pubsub.publisher) durante este procedimento. Para mais informações sobre o papel e por que ele está sendo adicionado, consulte Adicionar o papel de editor do Pub/Sub à conta de serviço do Pub/Sub.

  1. No console do Google Cloud, abra a página IAM.

    Acessar IAM

  2. Ative a opção Incluir concessões de papel fornecidas pelo Google.

  3. Procure a conta de serviço com o formato service-{PROJECT_NUMBER}@gcp-sa-pubsub.iam.gserviceaccount.com.

  4. Para essa conta de serviço, clique no botão Editar principal.

  5. Se necessário, clique em Adicionar outro papel.

  6. Pesquise e selecione o papel de criador do token da conta de serviço (roles/iam.serviceAccountTokenCreator).

  7. Clique em Salvar.

Criar uma política na AWS

Você precisa de uma política na AWS para permitir que o Pub/Sub se autentique com a AWS e ingira dados de um fluxo de dados do AWS Kinesis. Antes de criar uma política da AWS, um fluxo de dados do Kinesis e um consumidor registrado nele. Recomendamos isso para restringir as permissões ao fluxo específico.

Para criar uma política na AWS, siga estas etapas:

  1. Faça login no AWS Management Console e abra o Console do IAM.

  2. No painel de navegação do console do IAM, clique em Gerenciamento de acesso > Políticas.

  3. Clique em Criar política.

  4. Em Selecionar um serviço, selecione Kinesis.

  5. Em Ação permitida, selecione o seguinte:

    • List > ListShards.

      Essa ação concede permissão para listar os fragmentos em um fluxo e fornece informações sobre cada fragmento.

    • Leitura > SubscribeToShard.

      Essa ação concede permissão para detectar um fragmento específico com o fan-out aprimorado.

    • Leitura > DescribeStreamConsumer (em inglês).

      Essa ação concede permissão para receber a descrição de um consumidor de stream registrado.

    Essas permissões abrangem a leitura no stream. Pub/Sub oferece suporte somente à leitura de streams do Kinesis com Fan-out aprimorado usando o Streaming da API SubscriptionToShard.

  6. Em Recursos, se você quiser restringir a política a um stream ou consumidor específico (recomendado), especifique o ARN do consumidor e o ARN do stream.

  7. Clique em Adicionar mais permissões.

  8. Em Selecionar um serviço, insira e selecione STS.

  9. Em Ação permitida, selecione Gravar > AssumeRoleWithWebIdentity.

    Essa ação concede permissão para receber um conjunto de credenciais de segurança temporárias para que o Pub/Sub se autentique no fluxo de dados do Kinesis usando a federação de identidade.

  10. Clique em Próxima.

  11. Digite um nome e uma descrição para a política.

  12. Clique em Criar política.

Criar uma função na AWS usando uma política de confiança personalizada

Você precisa criar um papel na AWS para que o Pub/Sub possa se autenticar para a AWS para ingerir dados do Kinesis Data Streams.

Para criar um papel usando uma política de confiança personalizada, siga estas etapas:

  1. Faça login no AWS Management Console e abra o console do IAM.

  2. No painel de navegação do console do IAM, clique em Papéis.

  3. Clique em Criar papel.

  4. Em Selecionar entidade confiável, escolha Política de confiança personalizada.

  5. Na seção Política de confiança personalizada, insira ou cole o seguinte:

    {
  "Version": "2012-10-17",
  "Statement": [
    {
     "Effect": "Allow",
     "Principal": {
        "Federated": "accounts.google.com"
     },
     "Action": "sts:AssumeRoleWithWebIdentity",
     "Condition": {
         "StringEquals": {
           "accounts.google.com:sub": "<SERVICE_ACCOUNT_UNIQUE_ID>"
         }
      }
    }
  ]
}

    Substitua <SERVICE_ACCOUNT_UNIQUE_ID> pelo ID exclusivo de a conta de serviço que você registrou Registre o ID exclusivo da conta de serviço.

  6. Clique em Próxima.

  7. Em Adicionar permissões, pesquise e selecione a política personalizada que que você acabou de criar.

  8. Clique em Próxima.

  9. Digite um nome e uma descrição para a função.

  10. Clique em Criar papel.

Adicione o papel de editor do Pub/Sub à conta de serviço do Pub/Sub

Você precisa atribuir um papel de editor à conta de serviço do Pub/Sub para que o Pub/Sub possa publicar no tópico de importação AWS Kinesis Data Streams.

Ativar a publicação em todos os tópicos

  1. No console do Google Cloud, abra a página IAM.

    Acessar IAM

  2. Ative a opção Incluir atribuições de papéis fornecidos pelo Google.

  3. Procure a conta de serviço com o formato service-{PROJECT_NUMBER}@gcp-sa-pubsub.iam.gserviceaccount.com:

  4. Para essa conta de serviço, clique no botão Editar principal.

  5. Se necessário, clique em Adicionar outro papel.

  6. Pesquise e selecione o papel de editor do Pub/Sub (roles/pubsub.publisher).

  7. Clique em Salvar.

Ativar a publicação em um único tópico

Se você quiser conceder a permissão de publicação somente a um o tópico de importação do Amazon Kinesis Data Streams siga estas etapas:

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Execute o comando gcloud pubsub topics add-iam-policy-binding:

    gcloud pubsub topics add-iam-policy-binding TOPIC_ID\
   --member="serviceAccount:service-PROJECT_NUMBER@gcp-sa-pubsub.iam.gserviceaccount.com"\
   --role="roles/pubsub.publisher"

    Substitua:

    • TOPIC_ID é o ID do tópico de importação do Amazon Kinesis Data Streams.

    • PROJECT_NUMBER é o número do projeto. Para acessar o projeto consulte Como identificar projetos.

Adicionar o função do usuário da conta de serviço

O papel de usuário da conta de serviço (roles/iam.serviceAccountUser) inclui a permissão iam.serviceAccounts.actAs, que permite que um principal anexe uma conta de serviço às configurações de transferência do tópico de importação do Amazon Kinesis Data Streams e use essa conta de serviço para identidade federada.

Siga as etapas abaixo:

  1. No console do Google Cloud, abra a página IAM.

    Acessar IAM

  2. Para o principal que está emitindo as chamadas de criação ou atualização de tópicos, clique no botão Editar principal.

  3. Se necessário, clique em Adicionar outro papel.

  4. Pesquise e selecione a Função de usuário da conta de serviço (roles/iam.serviceAccountUser).

  5. Clique em Salvar.

Criar um tópico de importação do Amazon Kinesis Data Streams

Para saber mais sobre as propriedades associadas a um tópico, confira Propriedades de um tópico.

Verifique se você concluiu os seguintes procedimentos:

Para criar um tópico de importação do Amazon Kinesis Data Streams, siga estas etapas:

Console

  1. No console do Google Cloud, acesse a página Tópicos.

    Acesse Tópicos

  2. Selecione Criar tópico.

  3. No campo ID do tópico, insira um ID para o tópico de importação do Amazon Kinesis Data Streams.

    Para mais informações sobre como nomear tópicos, consulte as diretrizes de nomenclatura.

  4. Selecione Adicionar uma assinatura padrão.

  5. Selecione Ativar ingestão.

  6. Em "Origem de transferência", selecione Amazon Kinesis Data Streams.

  7. Digite os seguintes detalhes:

    • ARN do fluxo do Kinesis: o ARN do fluxo de dados do Kinesis que que você planeja ingerir no Pub/Sub. O formato ARN é o seguinte: arn:${Partition}:kinesis:${Region}:${Account}:stream/${StreamName}:

    • ARN do consumidor do Kinesis: o ARN do recurso do consumidor registrado no fluxo de dados do AWS Kinesis. O formato ARN é segue: arn:${Partition}:kinesis:${Region}:${Account}:${StreamType}/${StreamName}/consumer/${ConsumerName}:${ConsumerCreationTimpstamp}:

    • ARN do papel da AWS: o ARN do papel da AWS. O formato ARN do papel é o seguinte: arn:aws:iam:${Account}:role/${RoleName}.

    • Conta de serviço: a conta de serviço que você criou em Criar uma conta de serviço em Google Cloud.

  8. Selecione Criar tópico.

gcloud

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Execute o comando gcloud pubsub topics create:

    gcloud pubsub topics create TOPIC_ID 
    
       --kinesis-ingestion-stream-arn KINESIS_STREAM_ARN
    
       --kinesis-ingestion-consumer-arn KINESIS_CONSUMER_ARN
    
       --kinesis-ingestion-role-arn KINESIS_ROLE_ARN
    
       --kinesis-ingestion-service-account PUBSUB_SERVICE_ACCOUNT

    Substitua:

    • TOPIC_ID é o ID do tópico.

    • KINESIS_STREAM_ARN é o ARN dos fluxos de dados do Kinesis que você planeja ingerir no Pub/Sub. O ARN é o seguinte: arn:${Partition}:kinesis:${Region}:${Account}:stream/${StreamName}:

    • KINESIS_CONSUMER_ARN é o ARN do recurso do consumidor. registrado no AWS Kinesis Data Streams. O formato ARN é da seguinte forma: arn:${Partition}:kinesis:${Region}:${Account}:${StreamType}/${StreamName}/consumer/${ConsumerName}:${ConsumerCreationTimpstamp}:

    • KINESIS_ROLE_ARN é o ARN do papel da AWS. O ARN do papel é o seguinte: arn:aws:iam:${Account}:role/${RoleName}:

    • PUBSUB_SERVICE_ACCOUNT é a conta de serviço que você criou em Criar uma conta de serviço no Google Cloud.

Go

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

Para autenticar no Pub/Sub, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

import (
	"context"
	"fmt"
	"io"

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

func createTopicWithKinesisIngestion(w io.Writer, projectID, topicID string) error {
	// projectID := "my-project-id"
	// topicID := "my-topic"
	streamARN := "stream-arn"
	consumerARN := "consumer-arn"
	awsRoleARN := "aws-role-arn"
	gcpServiceAccount := "gcp-service-account"

	ctx := context.Background()
	client, err := pubsub.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("pubsub.NewClient: %w", err)
	}
	defer client.Close()

	cfg := &pubsub.TopicConfig{
		IngestionDataSourceSettings: &pubsub.IngestionDataSourceSettings{
			Source: &pubsub.IngestionDataSourceAWSKinesis{
				StreamARN:         streamARN,
				ConsumerARN:       consumerARN,
				AWSRoleARN:        awsRoleARN,
				GCPServiceAccount: gcpServiceAccount,
			},
		},
	}
	t, err := client.CreateTopicWithConfig(ctx, topicID, cfg)
	if err != nil {
		return fmt.Errorf("CreateTopic: %w", err)
	}
	fmt.Fprintf(w, "Kinesis topic created: %v\n", t)
	return nil
}

Java

Antes de testar este exemplo, siga as instruções de configuração do Java na Guia de início rápido do Pub/Sub usando bibliotecas de cliente. Para mais informações, consulte a API Java do Pub/Sub documentação de referência.

Para autenticar no Pub/Sub, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 


import com.google.cloud.pubsub.v1.TopicAdminClient;
import com.google.pubsub.v1.IngestionDataSourceSettings;
import com.google.pubsub.v1.Topic;
import com.google.pubsub.v1.TopicName;
import java.io.IOException;

public class CreateTopicWithKinesisIngestionExample {
  public static void main(String... args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String topicId = "your-topic-id";
    // Kinesis ingestion settings.
    String streamArn = "stream-arn";
    String consumerArn = "consumer-arn";
    String awsRoleArn = "aws-role-arn";
    String gcpServiceAccount = "gcp-service-account";

    createTopicWithKinesisIngestionExample(
        projectId, topicId, streamArn, consumerArn, awsRoleArn, gcpServiceAccount);
  }

  public static void createTopicWithKinesisIngestionExample(
      String projectId,
      String topicId,
      String streamArn,
      String consumerArn,
      String awsRoleArn,
      String gcpServiceAccount)
      throws IOException {
    try (TopicAdminClient topicAdminClient = TopicAdminClient.create()) {
      TopicName topicName = TopicName.of(projectId, topicId);

      IngestionDataSourceSettings.AwsKinesis awsKinesis =
          IngestionDataSourceSettings.AwsKinesis.newBuilder()
              .setStreamArn(streamArn)
              .setConsumerArn(consumerArn)
              .setAwsRoleArn(awsRoleArn)
              .setGcpServiceAccount(gcpServiceAccount)
              .build();
      IngestionDataSourceSettings ingestionDataSourceSettings =
          IngestionDataSourceSettings.newBuilder().setAwsKinesis(awsKinesis).build();

      Topic topic =
          topicAdminClient.createTopic(
              Topic.newBuilder()
                  .setName(topicName.toString())
                  .setIngestionDataSourceSettings(ingestionDataSourceSettings)
                  .build());

      System.out.println("Created topic with Kinesis ingestion settings: " + topic.getAllFields());
    }
  }
}

Node.js

Antes de testar esta amostra, siga as instruções de configuração do Node.js no Guia de início rápido do Pub/Sub: como usar bibliotecas de cliente. Para mais informações, consulte a API Node.js do Pub/Sub documentação de referência.

Para autenticar no Pub/Sub, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const topicNameOrId = 'YOUR_TOPIC_NAME_OR_ID';
// const roleArn = 'arn:aws:iam:...';
// const gcpServiceAccount = 'ingestion-account@...';
// const streamArn = 'arn:aws:kinesis:...';
// const consumerArn = 'arn:aws:kinesis:...';

// 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 createTopicWithKinesisIngestion(
  topicNameOrId,
  awsRoleArn,
  gcpServiceAccount,
  streamArn,
  consumerArn
) {
  // Creates a new topic with a schema. Note that you might also
  // pass Encodings.Json or Encodings.Binary here.
  await pubSubClient.createTopic({
    name: topicNameOrId,
    ingestionDataSourceSettings: {
      awsKinesis: {
        awsRoleArn,
        gcpServiceAccount,
        streamArn,
        consumerArn,
      },
    },
  });
  console.log(`Topic ${topicNameOrId} created with AWS Kinesis ingestion.`);
}

Python

Antes de testar este exemplo, siga as instruções de configuração do Python na Guia de início rápido do Pub/Sub usando bibliotecas de cliente. Para mais informações, consulte a API Python do Pub/Sub documentação de referência.

Para autenticar no Pub/Sub, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

from google.cloud import pubsub_v1
from google.pubsub_v1.types import Topic
from google.pubsub_v1.types import IngestionDataSourceSettings

# TODO(developer)
# project_id = "your-project-id"
# topic_id = "your-topic-id"
# stream_arn = "your-stream-arn"
# consumer_arn = "your-consumer-arn"
# aws_role_arn = "your-aws-role-arn"
# gcp_service_account = "your-gcp-service-account"

publisher = pubsub_v1.PublisherClient()
topic_path = publisher.topic_path(project_id, topic_id)

request = Topic(
    name=topic_path,
    ingestion_data_source_settings=IngestionDataSourceSettings(
        aws_kinesis=IngestionDataSourceSettings.AwsKinesis(
            stream_arn=stream_arn,
            consumer_arn=consumer_arn,
            aws_role_arn=aws_role_arn,
            gcp_service_account=gcp_service_account,
        )
    ),
)

topic = publisher.create_topic(request=request)

print(f"Created topic: {topic.name} with AWS Kinesis Ingestion Settings")

C++

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

Para autenticar no Pub/Sub, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

namespace pubsub = ::google::cloud::pubsub;
namespace pubsub_admin = ::google::cloud::pubsub_admin;
[](pubsub_admin::TopicAdminClient client, std::string project_id,
   std::string topic_id, std::string stream_arn, std::string consumer_arn,
   std::string aws_role_arn, std::string gcp_service_account) {
  google::pubsub::v1::Topic request;
  request.set_name(
      pubsub::Topic(std::move(project_id), std::move(topic_id)).FullName());
  auto* aws_kinesis =
      request.mutable_ingestion_data_source_settings()->mutable_aws_kinesis();
  aws_kinesis->set_stream_arn(stream_arn);
  aws_kinesis->set_consumer_arn(consumer_arn);
  aws_kinesis->set_aws_role_arn(aws_role_arn);
  aws_kinesis->set_gcp_service_account(gcp_service_account);

  auto topic = client.CreateTopic(request);
  // Note that kAlreadyExists is a possible error when the library retries.
  if (topic.status().code() == google::cloud::StatusCode::kAlreadyExists) {
    std::cout << "The topic already exists\n";
    return;
  }
  if (!topic) throw std::move(topic).status();

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

Node.js (TypeScript)

Antes de testar esta amostra, siga as instruções de configuração do Node.js no Guia de início rápido do Pub/Sub: como usar bibliotecas de cliente. Para mais informações, consulte a API Pub/Sub Node.js documentação de referência.

Para autenticar no Pub/Sub, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const topicNameOrId = 'YOUR_TOPIC_NAME_OR_ID';
// const roleArn = 'arn:aws:iam:...';
// const gcpServiceAccount = 'ingestion-account@...';
// const streamArn = 'arn:aws:kinesis:...';
// const consumerArn = 'arn:aws:kinesis:...';

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

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

async function createTopicWithKinesisIngestion(
  topicNameOrId: string,
  awsRoleArn: string,
  gcpServiceAccount: string,
  streamArn: string,
  consumerArn: string
) {
  // Creates a new topic with a schema. Note that you might also
  // pass Encodings.Json or Encodings.Binary here.
  await pubSubClient.createTopic({
    name: topicNameOrId,
    ingestionDataSourceSettings: {
      awsKinesis: {
        awsRoleArn,
        gcpServiceAccount,
        streamArn,
        consumerArn,
      },
    },
  });
  console.log(`Topic ${topicNameOrId} created with AWS Kinesis ingestion.`);
}

Para mais informações sobre ARNs, consulte Nomes de recursos da Amazon (ARNs) e Identificadores do IAM.

Se você tiver problemas, consulte Resolver problemas em um tópico de importação do Amazon Kinesis Data Streams.

Editar um tópico de importação do Amazon Kinesis Data Streams

Você pode editar as configurações da fonte de dados de ingestão de um tópico de importação do Amazon Kinesis Data Streams. Siga as etapas abaixo:

Console

  1. No console do Google Cloud, acesse a página Tópicos.

    Acesse Tópicos

  2. Clique no tópico de importação do Amazon Kinesis Data Streams.

  3. Na página de detalhes do tópico, clique em Editar.

  4. Atualize os campos que você quer mudar.

  5. Clique em Atualizar.

gcloud

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Execute o comando gcloud pubsub topics update com todas as flags mencionadas no exemplo abaixo:

      gcloud pubsub topics update TOPIC_ID 
    
         --kinesis-ingestion-stream-arn KINESIS_STREAM_ARN
    
         --kinesis-ingestion-consumer-arn KINESIS_CONSUMER_ARN
    
         --kinesis-ingestion-role-arn KINESIS_ROLE_ARN
    
         --kinesis-ingestion-service-account PUBSUB_SERVICE_ACCOUNT

    Substitua:

    • TOPIC_ID é o ID do tópico. Não é possível atualizar este campo.

    • KINESIS_STREAM_ARN é o ARN dos fluxos de dados do Kinesis. que você planeja ingerir no Pub/Sub. O ARN é o seguinte: arn:${Partition}:kinesis:${Region}:${Account}:stream/${StreamName}:

    • KINESIS_CONSUMER_ARN é o ARN do recurso do consumidor. registrado no AWS Kinesis Data Streams. O formato ARN é o seguinte: arn:${Partition}:kinesis:${Region}:${Account}:${StreamType}/${StreamName}/consumer/${ConsumerName}:${ConsumerCreationTimpstamp}.

    • KINESIS_ROLE_ARN é o ARN do papel da AWS. O formato ARN do papel é o seguinte: arn:aws:iam:${Account}:role/${RoleName}:

    • PUBSUB_SERVICE_ACCOUNT é a conta de serviço que você criada em Criar uma conta de serviço no Google Cloud.

Tópicos de importação de cotas e limites para o Amazon Kinesis Data Streams

A capacidade do editor para tópicos de importação é limitada pela cota de publicação. do tópico. Para mais informações, consulte Cotas e limites do Pub/Sub.

A seguir