Crea un argomento di importazione di Amazon Kinesis Data Streams

Un argomento di importazione di flussi di dati Amazon Kinesis ti consente di importare dati da Flussi di dati Amazon Kinesis come origine esterna e in Pub/Sub. Poi puoi inviare i dati in modalità flusso in qualsiasi destinazione Supporta Pub/Sub.

Questo documento mostra come creare e gestire Amazon Kinesis Argomenti di importazione degli stream di dati. Per creare un argomento standard, consulta Crea un argomento standard.

Prima di iniziare

Ruoli e autorizzazioni richiesti per gestire gli argomenti di importazione

Per ottenere le autorizzazioni necessarie per creare e gestire gli argomenti di importazione di Amazon Kinesis Data Streams, chiedi all'amministratore di concederti il ruolo IAM Editor Pub/Sub (roles/pubsub.editor) sul tuo argomento o progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso a progetti, cartelle e organizzazioni.

Questo ruolo predefinito contiene le autorizzazioni necessarie per creare e gestire gli argomenti di importazione di Amazon Kinesis Data Streams. Per visualizzare le autorizzazioni esatte richieste, espandi la sezione Autorizzazioni richieste:

Autorizzazioni obbligatorie

Per creare e gestire gli argomenti di importazione di Amazon Kinesis Data Streams sono necessarie le seguenti autorizzazioni:

  • Crea un argomento di importazione: pubsub.topics.create
  • Elimina un argomento di importazione: pubsub.topics.delete
  • Ricevi un argomento di importazione: pubsub.topics.get
  • Elenca un argomento di importazione: pubsub.topics.list
  • Pubblica in un argomento di importazione: pubsub.topics.publish
  • Aggiorna un argomento relativo all'importazione: pubsub.topics.update
  • Ottieni il criterio IAM per un argomento di importazione: pubsub.topics.getIamPolicy
  • Configura il criterio IAM per un argomento di importazione: pubsub.topics.setIamPolicy

Potresti anche riuscire a ottenere queste autorizzazioni con ruoli personalizzati altri ruoli predefiniti.

Puoi configurare il controllo dell'accesso a livello di progetto e di singola risorsa.

Configura l'identità federata per accedere ai flussi di dati Kinesis

La federazione delle identità dei carichi di lavoro consente ai servizi Google Cloud di accedere ai carichi di lavoro eseguiti al di fuori di Google Cloud. Con la federazione delle identità non è necessario per gestire o passare le credenziali a Google Cloud per accedere alle tue risorse in altre nuvole. In alternativa, puoi utilizzare le identità dei carichi di lavoro stessi per autenticarti su Google Cloud e accedere alle risorse.

Creare un account di servizio in Google Cloud

Questo passaggio è facoltativo. Se hai già un account di servizio, puoi utilizzarlo in questa procedura anziché crearne uno nuovo. Se utilizzi un account di servizio esistente, vai a Registra l'ID univoco dell'account di servizio per al passaggio successivo.

Per un argomento di importazione di Amazon Kinesis Data Streams, Pub/Sub utilizza l'account di servizio come identità per accedere alle risorse da AWS.

Per ulteriori informazioni sulla creazione di un account di servizio, inclusi i prerequisiti, i ruoli e le autorizzazioni richiesti e le linee guida per la denominazione, consulta Crea gli account di servizio. Dopo aver creato un account di servizio, potrebbe essere necessario attendere almeno 60 secondi prima di utilizzarlo. Questo comportamento si verifica perché le operazioni di lettura alla fine coerente; potrebbe volerci del tempo prima che il nuovo account di servizio diventano visibili.

Registrare l'ID univoco dell'account di servizio.

Per configurare un ruolo nella console AWS, devi disporre di un ID univoco dell'account di servizio.

  1. Nella console Google Cloud, vai alla pagina dei dettagli dell'account di servizio.

    Vai all'account di servizio

  2. Fai clic sull'account di servizio che hai appena creato o su quello che stai che intendi utilizzare.

  3. Nella pagina Dettagli account di servizio, registra il numero ID univoco.

    Ti servirà l'ID nella sezione Creare un ruolo in AWS utilizzando un criterio di attendibilità personalizzato.

Aggiungi il ruolo Creatore token account di servizio all'account di servizio Pub/Sub

Il ruolo Creatore token account di servizio (roles/iam.serviceAccountTokenCreator) consente alle entità di creare credenziali di breve durata per un account di servizio. Questi token o credenziali vengono utilizzati per impersonare l'account di servizio.

Per ulteriori informazioni sull'impersonificazione degli account di servizio, consulta Impersonificazione degli account di servizio.

Puoi anche aggiungere il ruolo Publisher Pub/Sub (roles/pubsub.publisher) durante questa procedura. Per ulteriori informazioni sul ruolo e sul motivo per cui lo aggiungi, consulta Aggiungere il ruolo Publisher Pub/Sub all'account di servizio Pub/Sub.

  1. Nella console Google Cloud, vai alla pagina IAM.

    Vai a IAM

  2. Attiva l'opzione Includi concessioni di ruoli fornite da Google.

  3. Cerca l'account di servizio con il formato service-{PROJECT_NUMBER}@gcp-sa-pubsub.iam.gserviceaccount.com.

  4. Per questo account di servizio, fai clic sul pulsante Modifica entità.

  5. Se necessario, fai clic su Aggiungi un altro ruolo.

  6. Cerca e seleziona il ruolo Creatore token account di servizio (roles/iam.serviceAccountTokenCreator).

  7. Fai clic su Salva.

Crea un criterio in AWS

È necessario un criterio in AWS per consentire a Pub/Sub l'autenticazione con AWS per consentire a Pub/Sub di importare dati da AWS Kinesis flusso di dati. Prima di creare un criterio AWS, crea un di uno stream di dati Kinesis e di un consumatore registrato. Lo consigliamo in modo da poter limitare le autorizzazioni allo stream specifico.

  • Per ulteriori informazioni su come creare uno stream di dati AWS Kinesis, consulta Stream di dati Kinesis.

  • Per ulteriori informazioni sull'API AWS Kinesis Data Stream utilizzata per registrare i consumer, consulta RegisterStreamConsumer.

  • Per altri metodi e informazioni su come creare un criterio in AWS, consulta Creazione di criteri IAM.

Per creare un criterio in AWS, svolgi i seguenti passaggi:

  1. Accedi alla Console di gestione AWS e apri la console IAM.

  2. Nel riquadro di navigazione della console per IAM, Fai clic su Access Management > Norme.

  3. Fai clic su Crea criterio.

  4. In Seleziona un servizio, seleziona Kinesis.

  5. Per azione consentita, seleziona quanto segue:

    • Elenco > ElencaShards.

      Questa azione concede l'autorizzazione per elencare i frammenti in uno stream e fornisce informazioni su ciascun frammento.

    • Leggi > SubscribeToShard.

      Questa azione concede l'autorizzazione per ascoltare uno specifico shard con fan-out migliorato.

    • Leggi > DescribeStreamConsumer.

      Questa azione concede l'autorizzazione per ottenere la descrizione di un consumatore di streaming registrato.

    Queste autorizzazioni riguardano la lettura dello stream. Pub/Sub supporta la lettura da uno stream Kinesis con fan-out avanzato solo utilizzando l'API SubscribeToShard in streaming.

  6. In Risorse, se vuoi limitare il criterio a flussi specifici o consumer (consigliato), specifica l'ARN del consumer e l'ARN del flusso.

  7. Fai clic su Aggiungi altre autorizzazioni.

  8. In Seleziona un servizio, inserisci e seleziona STS.

  9. Per Azione consentita, seleziona Scrivi > AssumeRoleWithWebIdentity.

    Questa azione concede l'autorizzazione per ottenere un insieme di credenziali di sicurezza temporanee per Pub/Sub per autenticarsi nello stream di dati Kinesis utilizzando la federazione delle identità.

  10. Fai clic su Avanti.

  11. Inserisci un nome e una descrizione per la norma.

  12. Fai clic su Crea criterio.

Crea un ruolo in AWS utilizzando un criterio di attendibilità personalizzato

Devi creare un ruolo in AWS in modo che Pub/Sub possa autenticarsi in AWS per importare i dati da Kinesis Data Streams.

Per creare un ruolo utilizzando un criterio di attendibilità personalizzato:

  1. Accedi alla console di gestione AWS e apri la console IAM.

  2. Nel riquadro di navigazione della console per IAM, fai clic su Ruoli.

  3. Fai clic su Crea ruolo.

  4. Per Seleziona entità attendibile, seleziona Criterio di attendibilità personalizzato.

  5. Nella sezione Criterio di attendibilità personalizzato, inserisci o incolla quanto segue:

    {
  "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>"
         }
      }
    }
  ]
}

    Sostituisci <SERVICE_ACCOUNT_UNIQUE_ID> con l'ID univoco dell'account di servizio registrato in Registrare l'ID univoco dell'account di servizio.

  6. Fai clic su Avanti.

  7. In Aggiungi autorizzazioni, cerca e seleziona il criterio personalizzato appena creato.

  8. Fai clic su Avanti.

  9. Inserisci un nome e una descrizione per il ruolo.

  10. Fai clic su Crea ruolo.

Aggiungere il ruolo di publisher Pub/Sub all'account di servizio Pub/Sub

Devi assegnare un ruolo di publisher all'account di servizio Pub/Sub in modo che Pub/Sub possa pubblicare nell'argomento di importazione da Flussi di dati AWS Kinesis.

Attiva la pubblicazione da tutti gli argomenti

  1. Nella console Google Cloud, vai alla pagina IAM.

    Vai a IAM

  2. Attiva l'opzione Includi concessioni dei ruoli fornite da Google.

  3. Cerca l'account di servizio con il formatoservice-{PROJECT_NUMBER}@gcp-sa-pubsub.iam.gserviceaccount.com.

  4. Per questo account di servizio, fai clic sul pulsante Modifica entità.

  5. Se necessario, fai clic su Aggiungi un altro ruolo.

  6. Cerca e seleziona il ruolo Publisher Pub/Sub (roles/pubsub.publisher).

  7. Fai clic su Salva.

Abilita la pubblicazione da un singolo argomento

Se vuoi concedere l'autorizzazione di pubblicazione solo a una specifica l'argomento di importazione dei flussi di dati Amazon Kinesis, segui questi passaggi:

  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. Esegui il 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"

    Sostituisci quanto segue:

    • TOPIC_ID è l'ID dell'argomento di importazione di Amazon Kinesis Data Streams.

    • PROJECT_NUMBER è il numero del progetto. Per visualizzare il progetto consulta Identificazione dei progetti.

Aggiungi il ruolo utente dell'account di servizio all'account di servizio

Il ruolo Utente account di servizio (roles/iam.serviceAccountUser) include l'autorizzazione iam.serviceAccounts.actAs che consente a un'entità di collegare l'account di servizio all'importazione dell'argomento di importazione dei flussi di dati Amazon Kinesis impostazioni e utilizzare quell'account di servizio per l'identità federata.

Procedi nel seguente modo:

  1. Nella console Google Cloud, vai alla pagina IAM.

    Vai a IAM

  2. Per l'entità che emette le chiamate all'argomento di creazione o aggiornamento, fai clic sul pulsante Modifica entità.

  3. Se necessario, fai clic su Aggiungi un altro ruolo.

  4. Cerca e seleziona il ruolo Utente account di servizio (roles/iam.serviceAccountUser).

  5. Fai clic su Salva.

Crea un argomento di importazione di Amazon Kinesis Data Streams

Per saperne di più sulle proprietà associate a un argomento, consulta Proprietà di un argomento.

Assicurati di aver completato le seguenti procedure:

Per creare un argomento di importazione di flussi di dati Amazon Kinesis:

Console

  1. Nella console Google Cloud, vai alla pagina Topic.

    Vai ad Argomenti

  2. Fai clic su Crea argomento.

  3. Nel campo ID argomento, inserisci un ID per l'argomento di importazione di Amazon Kinesis Data Streams.

    Per ulteriori informazioni sugli argomenti relativi alla denominazione, consulta le linee guida per i nomi.

  4. Seleziona Aggiungi una sottoscrizione predefinita.

  5. Seleziona Attiva importazione.

  6. Per l'origine di importazione, seleziona Amazon Kinesis Data Streams.

  7. Inserisci i seguenti dettagli:

    • ARN del flusso Kinesis: l'ARN del flusso di dati Kinesis che prevedi di importare in Pub/Sub. Il formato dell'ARN è il seguente: arn:${Partition}:kinesis:${Region}:${Account}:stream/${StreamName}.

    • ARN del consumer Kinesis: l'ARN della risorsa consumer che è registrato nel flusso di dati AWS Kinesis. Il formato ARN è il seguente che segue: arn:${Partition}:kinesis:${Region}:${Account}:${StreamType}/${StreamName}/consumer/${ConsumerName}:${ConsumerCreationTimpstamp}.

    • ARN del ruolo AWS: l'ARN del ruolo AWS. Il formato ARN del ruolo è il seguente: arn:aws:iam:${Account}:role/${RoleName}.

    • Account di servizio: l'account di servizio che hai creato in Creare un account di servizio in Google Cloud.

  8. Fai clic su Crea argomento.

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. Esegui il 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

    Sostituisci quanto segue:

    • TOPIC_ID è l'ID argomento.

    • KINESIS_STREAM_ARN è l'ARN dei flussi di dati Kinesis che prevedi di importare in Pub/Sub. Il formato dell'ARN è il seguente: arn:${Partition}:kinesis:${Region}:${Account}:stream/${StreamName}.

    • KINESIS_CONSUMER_ARN è l'ARN della risorsa consumer registrata in AWS Kinesis Data Streams. Il formato dell'ARN è il seguente: arn:${Partition}:kinesis:${Region}:${Account}:${StreamType}/${StreamName}/consumer/${ConsumerName}:${ConsumerCreationTimpstamp}.

    • KINESIS_ROLE_ARN è l'ARN del ruolo AWS. Il formato dell'ARN del ruolo è il seguente: arn:aws:iam:${Account}:role/${RoleName}.

    • PUBSUB_SERVICE_ACCOUNT è l'account di servizio che creato in Creare un account di servizio in Google Cloud.

Go

Prima di provare questo esempio, segui le istruzioni per la configurazione di Go nel Guida rapida di Pub/Sub con librerie client. Per ulteriori informazioni, consulta API Pub/Sub Go documentazione di riferimento.

Per eseguire l'autenticazione su Pub/Sub, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale. 

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

Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nel Guida rapida di Pub/Sub con librerie client. Per ulteriori informazioni, consulta API Pub/Sub Java documentazione di riferimento.

Per autenticarti a Pub/Sub, configura le credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 


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

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js riportate nella guida rapida di Pub/Sub che utilizza le librerie client. Per ulteriori informazioni, consulta API Pub/Sub Node.js documentazione di riferimento.

Per autenticarti a Pub/Sub, configura le credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

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

Prima di provare questo esempio, segui le istruzioni per la configurazione di Python nel Guida rapida di Pub/Sub con librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Pub/Sub Python.

Per eseguire l'autenticazione su Pub/Sub, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale. 

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

Prima di provare questo esempio, segui le istruzioni di configurazione di C++ riportate nella guida rapida di Pub/Sub che utilizza le librerie client. Per ulteriori informazioni, consulta API Pub/Sub C++ documentazione di riferimento.

Per eseguire l'autenticazione su Pub/Sub, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale. 

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)

Prima di provare questo esempio, segui le istruzioni per la configurazione di Node.js nella Guida rapida di Pub/Sub con l'utilizzo librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Pub/Sub Node.js.

Per eseguire l'autenticazione su Pub/Sub, configura le credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

/**
 * 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.`);
}

Per saperne di più sugli ARN, consulta Nomi delle risorse Amazon (ARN) e Identificatori IAM.

Se riscontri problemi, consulta Risolvere i problemi relativi a un argomento di importazione di Amazon Kinesis Data Streams.

Modifica un argomento di importazione di flussi di dati Amazon Kinesis

Puoi modificare le impostazioni dell'origine dati di importazione di un argomento di importazione di flussi di dati Amazon Kinesis. Procedi nel seguente modo:

Console

  1. Nella console Google Cloud, vai alla pagina Topic.

    Vai ad Argomenti

  2. Fai clic sull'argomento di importazione di Amazon Kinesis Data Streams.

  3. Nella pagina dei dettagli dell'argomento, fai clic su Modifica.

  4. Aggiorna i campi che vuoi modificare.

  5. Fai clic su Aggiorna.

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. Esegui il comando gcloud pubsub topics update con tutti i flag menzionati nel seguente esempio:

      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

    Sostituisci quanto segue:

    • TOPIC_ID è l'ID argomento. Questo campo non può essere aggiornato.

    • KINESIS_STREAM_ARN è l'ARN dei flussi di dati Kinesis che prevedi di importare in Pub/Sub. L'ARN formato è il seguente: arn:${Partition}:kinesis:${Region}:${Account}:stream/${StreamName}.

    • KINESIS_CONSUMER_ARN è l'ARN della risorsa consumer registrato nei flussi di dati AWS Kinesis. Il formato dell'ARN è il seguente: arn:${Partition}:kinesis:${Region}:${Account}:${StreamType}/${StreamName}/consumer/${ConsumerName}:${ConsumerCreationTimpstamp}.

    • KINESIS_ROLE_ARN è l'ARN del ruolo AWS. Il formato ARN del ruolo è il seguente: arn:aws:iam:${Account}:role/${RoleName}.

    • PUBSUB_SERVICE_ACCOUNT è l'account di servizio che creato in Creare un account di servizio in Google Cloud.

Quote e limiti per gli argomenti di importazione di flussi di dati Amazon Kinesis

Il throughput del publisher per gli argomenti di importazione è limitato dalla quota di pubblicazione dell'argomento. Per ulteriori informazioni, vedi Quote e limiti di Pub/Sub.

Passaggi successivi