Como usar as APIs DataStream

Datastream

Visão geral

Para empresas com muitas fontes de dados isoladas, pode ser difícil acessar os dados corporativos em toda a organização, especialmente em tempo real. Isso resulta em um mundo de acesso limitado e lento aos dados, impedindo a organização de introspectiva.

O Datastream oferece acesso quase em tempo real para alterar dados de várias fontes de dados no local e baseadas na nuvem para criar acesso aos dados organizacionais. O Datastream oferece uma experiência de configuração simples e uma API de consumo unificada, que democratiza o acesso da organização aos dados empresariais mais recentes disponíveis em toda a organização, o que permite criar cenários integrados quase em tempo real.

Por exemplo, transferir dados de um banco de dados de origem para uma fila de mensagens ou um serviço de armazenamento baseado na nuvem e transformar esses dados em uma forma legível por outros aplicativos e serviços que se comunicam com esse serviço de armazenamento ou fila de mensagens.

Neste tutorial, você aprenderá a usar o Datastream para transferir esquemas, tabelas e dados de um banco de dados Oracle de origem para uma pasta em um bucket do Cloud Storage. O Cloud Storage é um serviço da Web para armazenar e acessar dados no Google Cloud. O serviço combina o desempenho e a escalabilidade da nuvem do Google com recursos avançados de segurança e compartilhamento.

Como parte da transferência dessas informações para uma pasta no bucket de destino do Cloud Storage, o Datastream converte essas informações em Avro. O Avro é definido por um esquema escrito em JavaScript Object Notation (JSON). Essa tradução permite que você leia dados em diferentes fontes de maneira uniforme.

Objetivos

Neste tutorial, você aprenderá a realizar as seguintes tarefas:

  • Defina variáveis de ambiente. Você vai usar essas variáveis ao fazer solicitações ao Datastream para criar e gerenciar perfis de conexão e um stream.
  • Crie e gerencie perfis de conexão para um banco de dados de origem e um bucket de destino no Cloud Storage. Ao criar esses perfis de conexão, você cria registros que contêm informações sobre o banco de dados de origem e o bucket de destino do Cloud Storage. O stream no Datastream usa as informações dos perfis de conexão para transferir dados do banco de dados de origem para uma pasta no bucket de destino.
  • Criar e gerenciar um stream. O Datastream usa esse stream para transferir dados, esquemas e tabelas do banco de dados de origem para uma pasta no bucket de destino.
  • Verifique se o Datastream transfere os dados e as tabelas associados a um esquema do banco de dados Oracle de origem para uma pasta no bucket de destino e converte esses dados no formato de arquivo Avro.
  • Limpe os recursos que você criou no Datastream para que eles não ocupem a cota e não sejam cobrados no futuro.

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

  • Cloud Storage

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Antes de começar

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Make sure that billing is enabled for your Google Cloud project.

  4. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  5. Make sure that billing is enabled for your Google Cloud project.

  6. Ative a API Datastream.

    Ative a API

  7. Verifique se você tem o papel Administrador do Datastream atribuído à sua conta de usuário.

    Acessar a página IAM

  8. Verifique se você tem um banco de dados de origem que o Datastream possa acessar. Para este tutorial, um banco de dados Oracle é usado como origem.
  9. Configure o banco de dados de origem para permitir conexões de entrada de endereços IP públicos do Datastream. Consulte Regiões e listas de permissões de IP para acessar os locais de todas as regiões do Datastream e os endereços IP públicos associados.
  10. Verifique se você configurou um bucket do Cloud Storage de destino que o Datastream pode acessar usando a lista de permissões de IP, o túnel SSH de encaminhamento ou o método de conectividade de rede de peering de VPC.
  11. Verifique se há dados, tabelas e esquemas no banco de dados de origem que o Datastream pode transferir para uma pasta no bucket de destino do Cloud Storage.
  12. Faça o download e instale o Cloud Shell. Com esse aplicativo cliente, você tem acesso de linha de comando aos seus recursos de nuvem (incluindo o Datastream).
  13. Instale e configure o utilitário jq. Ele é um processador JSON de linha de comando leve e flexível. Você usará esse processador para exibir comandos cURL complexos em textos fáceis de ler.

Como definir variáveis de ambiente

Neste procedimento, você definirá as seguintes variáveis:

  • $PROJECT: essa variável está associada ao projeto do Google Cloud. Todos os recursos do Google Cloud que você alocar e usar precisam pertencer a um projeto.
  • $TOKEN: essa variável está associada a um token de acesso. O token de acesso fornece uma sessão que o Cloud Shell usa para realizar tarefas no Datastream usando APIs REST.

  1. Inicie o aplicativo Cloud Shell.

  2. Depois de fazer a autenticação no aplicativo com sua Conta do Google, insira gcloud auth login.

  3. No prompt Do you want to continue (Y/n)?, insira Y.

  4. Abra um navegador da Web e copie o URL nele.

  5. Faça a autenticação no SDK Google Cloud com sua Conta do Google. Um código aparece na página Fazer login. Esse código é seu token de acesso.

  6. Copie o token de acesso, cole-o no parâmetro Enter verification code: no seu aplicativo do Cloud Shell e pressione Enter.

  7. No prompt, insira PROJECT="YOUR_PROJECT_NAME" para definir a variável de ambiente $PROJECT como seu projeto do Google Cloud.

  8. No prompt, insira gcloud config set project YOUR_PROJECT_NAME para definir o projeto em que você quer trabalhar no seu projeto do Google Cloud.

    O prompt de comando é atualizado para refletir seu projeto ativo e segue este formato: USERNAME@cloudshell:~ (YOUR_PROJECT_NAME)$

  9. No prompt, insira TOKEN=$(gcloud auth print-access-token) para recuperar o token de acesso e armazená-lo como uma variável.

  10. No prompt, insira os seguintes comandos para garantir que as variáveis $PROJECT e $TOKEN estejam definidas corretamente:

    • echo $PROJECT
    • echo $TOKEN

Agora que você definiu suas variáveis, é possível fazer solicitações ao Datastream para criar e gerenciar os perfis de conexão e um stream.

Criar e gerenciar perfis de conexão

Nesta seção, você cria e gerencia perfis de conexão para um banco de dados Oracle de origem e um bucket de destino no Cloud Storage.

Ao criar esses perfis de conexão, você cria registros que contêm informações sobre o banco de dados de origem e o bucket de destino do Cloud Storage. O Datastream usa as informações dos perfis de conexão para transferir dados do banco de dados de origem para uma pasta no bucket de destino.

A criação e o gerenciamento de perfis de conexão incluem o seguinte:

  • Como criar perfis de conexão para um banco de dados Oracle de origem e um bucket de destino no Cloud Storage
  • Como recuperar informações sobre um perfil de conexão
  • Como modificar um perfil de conexão
  • Realizar uma chamada de API Discover no perfil de conexão do Oracle de origem. Esta chamada permite que você procure no seu banco de dados os objetos associados a ele. Esses objetos incluem os esquemas e as tabelas que contêm os dados do banco de dados. Ao usar o Datastream para configurar um stream, não é recomendável extrair todos os objetos do banco de dados, mas apenas um subconjunto dos objetos (por exemplo, apenas algumas tabelas e esquemas do banco de dados). Use a API Discover para ajudar a encontrar (ou descobrir) o subconjunto de objetos do banco de dados que você quer extrair.

Criar perfis de conexão

Neste procedimento, você criará dois perfis de conexão: um para um banco de dados Oracle de origem e outro para um bucket de destino no Cloud Storage.

  1. Criar um perfil de conexão com um banco de dados Oracle de origem. No prompt, insira o seguinte comando:
ORACLE="{\"displayName\":\"DISPLAY_NAME\",\"oracle_profile\":{\"hostname\":\"HOSTNAME\",\"username\":\"USERNAME\",\"password\":\"PASSWORD\",\"database_service\":\"DATABASE_SERVICE\",\"port\":"PORT_NUMBER\"},\"no_connectivity\":{}}"

Use a tabela a seguir para entender os valores dos parâmetros do banco de dados Oracle de origem:

Valor de parâmetroSubstituir por
DISPLAY_NAMEO nome de exibição do perfil de conexão com o banco de dados de origem.
HOSTNAMEO nome do host do servidor de banco de dados de origem.
USERNAMEO nome de usuário da conta para o banco de dados de origem (por exemplo, ROOT).
PASSWORDA senha da conta para o banco de dados de origem.
DATABASE_SERVICEO serviço que garante que o banco de dados de origem seja protegido e monitorado. Para bancos de dados Oracle, o serviço de banco de dados geralmente é ORCL.
PORT_NUMBERO número da porta reservado para o banco de dados de origem. Para um banco de dados Oracle, o número da porta geralmente é 1521.

  1. No prompt, insira o comando echo $ORACLE | jq para ver o perfil de conexão de origem que você criou em texto fácil de ler.

    {
  "displayName": "DISPLAY_NAME",
  "oracle_profile": {
    "hostname": "HOSTNAME",
    "username": "USERNAME",
    "password": "PASSWORD",
    "database_service": "DATABASE_SERVICE",
    "port": PORT_NUMBER
   },
  "no_connectivity": {}
}

  2. Envie o perfil de conexão do Oracle para que ele possa ser criado. No prompt, insira o seguinte comando:

    curl -X POST -d $ORACLE -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/connectionProfiles?connection_profile_id=SOURCE_CONNECTION_PROFILE_ID

    Use a tabela a seguir para entender os valores de parâmetro desse comando:

    Valor de parâmetroSubstituir por
    DATASTREAM_API_VERSIONA versão atual da API Datastream (por exemplo, v1).
    PROJECT_PATHO caminho completo do projeto do Google Cloud (por exemplo, projects/$PROJECT/locations/YOUR_PROJECT_LOCATION).
    SOURCE_CONNECTION_PROFILE_IDO identificador exclusivo reservado para este perfil de conexão (por exemplo, cp-1).

  3. Verifique se as seguintes linhas de código são exibidas:

    {
  "name": "PROJECT_PATH/operations/operation-SOURCE_CONNECTION_PROFILE_OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.datastream.DATASTREAM_API_VERSION.OperationMetadata",
    "createTime": "DATE_AND_TIME_STAMP",
    "target": "datastream.googleapis.com/DATASREAM_VERSION/PROJECT_PATH/connectionProfiles/SOURCE_CONNECTION_PROFILE_ID",
    "verb": "create",
    "requestedCancellation": false,
    "apiVersion": "DATASTREAM_API_VERSION"
  },
  "done": false
}

  4. Criar um perfil de conexão para um bucket de destino no Cloud Storage. No prompt, insira o seguinte comando: 

    GOOGLECLOUDSTORAGE="{\"displayName\":\"DISPLAY_NAME\",\"gcs_profile\":{\"bucket_name\":\"BUCKET_NAME\",\"root_path\":\"/FOLDER_PATH\"},\"no_connectivity\":{}}"

    Veja na tabela a seguir os valores de parâmetro do bucket de destino:

    Valor de parâmetroSubstituir por
    DISPLAY_NAMEO nome de exibição do perfil de conexão para o bucket de destino.
    BUCKET_NAMENome do bucket de destino.
    FOLDER_PATHA pasta no bucket de destino para onde o Datastream transferirá dados do banco de dados de origem (por exemplo, /root/path).

  5. Na solicitação, insira o comando echo $GOOGLECLOUDSTORAGE | jq para ver o perfil de conexão de destino criado em texto fácil de ler.

    {
  "displayName": "DISPLAY_NAME",
  "gcs_profile": {
    "bucket_name": "BUCKET_NAME",
    "root_path": "/FOLDER_PATH"
  },
  "no_connectivity": {}
}

  6. Envie o perfil de conexão do Cloud Storage para que ele possa ser criado. No prompt, insira o seguinte comando:

    curl -X POST -d $GOOGLECLOUDSTORAGE -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/connectionProfiles?connection_profile_id=DESTINATION_CONNECTION_PROFILE_ID

  7. Verifique se as seguintes linhas de código são exibidas:

    {
  "name": "PROJECT_PATH/operations/operation-DESTINATION_CONNECTION_PROFILE_OPERATION_ID",
  "metadata": {
    "@type": "@type": "type.googleapis.com/google.cloud.datastream.DATASTREAM_API_VERSION.OperationMetadata",
    "createTime": "DATE_AND_TIME_STAMP",
    "target": "datastream.googleapis.com/DATASTREAM_VERSION/PROJECT_PATH/connectionProfiles/DESTINATION_CONNECTION_PROFILE_ID",
    "verb": "create",
    "requestedCancellation": false,
    "apiVersion": "DATASTREAM_API_VERSION"
  },
  "done": false
}

  8. Confirme se os dois perfis de conexão foram criados. No prompt, insira o seguinte comando:

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/connectionProfiles

  9. Verifique se você recebeu dois resultados retornados para os perfis de conexão de origem e de destino.

    {
  "connectionProfiles": [
    {
      "name": "PROJECT_PATH/connectionProfiles/DESTINATION_CONNECTION_PROFILE_ID",
      "createTime": "DATE_AND_TIME_STAMP",
      "updateTime": "DATE_AND_TIME_STAMP",
      "displayName": "DISPLAY_NAME",
      "gcsProfile": {
        "bucketName": "BUCKET_NAME",
        "rootPath": "FOLDER_PATH"
      },
      "noConnectivity": {}
    },
   {
    "name": "PROJECT_PATH/connectionProfiles/SOURCE_CONNECTION_PROFILE_ID",
    "createTime": "DATE_AND_TIME_STAMP",
    "updateTime": "DATE_AND_TIME_STAMP",
    "displayName": "DISPLAY_NAME",
    "oracleProfile": {
      "hostname": "HOSTNAME",
      "port": PORT_NUMBER,
      "username": "USERNAME",
      "databaseService": "DATABASE_SERVICE"
    },
    "noConnectivity": {}
    }
  ]
}

Gerenciar perfis de conexão

Neste procedimento, você gerencia os perfis de conexão criados para um banco de dados Oracle de origem e um bucket de destino no Cloud Storage. Incluindo:

  • Como recuperar informações sobre o perfil de conexão do Cloud Storage de destino
  • Modificando este perfil de conexão. Neste tutorial, você mudará a pasta do bucket do Cloud Storage de destino para /root/tutorial. O Datastream transfere dados do banco de dados de origem para essa pasta.
  • Como executar uma chamada de API de descoberta no perfil de conexão do Oracle de origem

  1. Recupera informações sobre o perfil de conexão do Cloud Storage de destino. No prompt, insira o seguinte comando:

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/connectionProfiles/DESTINATION_CONNECTION_PROFILE_ID

  2. Verifique se você vê informações sobre o perfil de conexão.

    {
  "name": "PROJECT_PATH/connectionProfiles/DESTINATION_CONNECTION_PROFILE_ID",
  "createTime": "DATE_AND_TIME_STAMP",
  "updateTime": "DATE_AND_TIME_STAMP",
  "displayName": "DISPLAY_NAME",
  "gcsProfile": {
    "bucketName": "BUCKET_NAME",
    "rootPath": "FOLDER_PATH"
  },
  "noConnectivity": {}
}

  3. Modificar este perfil de conexão. Para fazer isso, primeiro defina uma variável UPDATE. Essa variável contém os valores do perfil de conexão que você quer alterar. Neste tutorial, você mudará a pasta do bucket de destino para /root/tutorial.

    Para definir a variável, no prompt, insira o seguinte comando:

    UPDATE="{\"gcsProfile\":{\"rootPath\":\"/root/tutorial\"}}"

  4. No prompt, insira o seguinte comando:

    curl -X PATCH -d $UPDATE -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/connectionProfiles/DESTINATION_CONNECTION_PROFILE_ID?update_mask=gcsProfile.rootPath

  5. Verifique se as seguintes linhas de código são exibidas:

    {
  "name": "PROJECT_PATH/operations/operation-DESTINATION_CONNECTION_PROFILE_OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.datastream.DATASTREAM_API_VERSION.OperationMetadata",
    "createTime": "DATE_AND_TIME_STAMP",
    "target": "PROJECT_PATH/connectionProfiles/DESTINATION_CONNECTION_PROFILE_ID",
    "verb": "update",
    "requestedCancellation": false,
    "apiVersion": "DATASTREAM_API_VERSION"
  },
  "done": false
}

  6. Confirme se o perfil de conexão foi modificado. No prompt, insira o seguinte comando:

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/connectionProfiles/DESTINATION_CONNECTION_PROFILE_ID

  7. Verifique se a pasta do bucket de destino do perfil de conexão do Cloud Storage agora é /root/tutorial.

    {
  "name": "PROJECT_PATH/connectionProfiles/DESTINATION_CONNECTION_PROFILE_ID",
  "createTime": "DATE_AND_TIME_STAMP",
  "updateTime": "DATE_AND_TIME_STAMP",
  "displayName": "DISPLAY_NAME",
  "gcsProfile": {
    "bucketName": "BUCKET_NAME",
    "rootPath": "/root/tutorial"
  },
  "noConnectivity": {}
}

  8. Use a API de descoberta do Datastream para descobrir os esquemas e as tabelas do banco de dados Oracle de origem. O Datastream fornece acesso a esse banco de dados por meio do perfil de conexão de origem.

    1. Descubra os esquemas do banco de dados Oracle. No prompt, insira o seguinte comando:

      curl -X POST -d "{\"connection_profile_name\":\"projects/YOUR_PROJECT_NUMBER/locations/YOUR_PROJECT_LOCATION/connectionProfiles/SOURCE_CONNECTION_PROFILE_ID\", \"oracle_rdbms\":{\"oracleSchemas\":[{\"schema\":\"ROOT\"}]}}" -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/connectionProfiles:discover

    2. Verifique se o Datastream recupera todos os esquemas do seu banco de dados.

    3. Recupere as tabelas de um esquema no seu banco de dados. Neste tutorial, você usará a API Discover para recuperar as tabelas do esquema ROOT. No entanto, é possível descobrir as tabelas de qualquer esquema no banco de dados.

      No prompt, insira o seguinte comando:

    curl -X POST -d "{\"connection_profile_name\":\"projects/YOUR_PROJECT_NUMBER/locations/YOUR_PROJECT_LOCATION/connectionProfiles/SOURCE_CONNECTION_PROFILE_ID\", \"oracle_rdbms\":{\"oracleSchemas\":[{\"schema\":\"ROOT\"}]}}" -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/connectionProfiles:discover
    1. Verifique se o Datastream recupera todas as tabelas do esquema especificado (neste tutorial, o esquema ROOT).

Agora que você criou e gerenciou perfis de conexão para um banco de dados Oracle de origem e um bucket de destino no Cloud Storage, já pode criar e gerenciar um stream no Datastream.

Como criar e gerenciar um stream

Nesta seção, você cria e gerencia um stream. O Datastream usa esse stream para transferir dados, esquemas e tabelas do banco de dados de origem para uma pasta no bucket de destino do Cloud Storage.

A criação e o gerenciamento de um stream incluem o seguinte:

  • Validação de um stream para garantir que ele seja executado e que todas as verificações de validação sejam aprovadas. As verificações incluem:
    • Indica se a fonte está configurada corretamente para permitir que o Datastream faça streaming de dados.
    • Se a transmissão pode se conectar à origem e ao destino.
    • A configuração completa do stream.
  • Crie o stream com as seguintes listas:
    • Uma lista de permissões. Esta lista especifica as tabelas e esquemas no banco de dados de origem que o Datastream pode transferir para uma pasta no bucket de destino do Cloud Storage. Para este tutorial, esta é a pasta /root/tutorial.
    • Uma lista de rejeição. Esta lista especifica as tabelas e esquemas no banco de dados de origem que o Datastream não pode transferir para a pasta no bucket de destino do Cloud Storage.
  • Como recuperar informações sobre o stream
  • Como modificar o stream
  • Iniciar o stream para que ele possa transferir dados, esquemas e tabelas do banco de dados de origem para uma pasta no bucket do Cloud Storage de destino;
  • Como usar a API Fetch Errors para detectar erros associados ao stream
  • Pausando o stream. Quando um stream é pausado, o Datastream não extrai dados novos do banco de dados de origem para o bucket de destino.
  • Retomada do stream pausado para que o Datastream possa continuar transferindo dados para o bucket de destino.

Criar um stream

Neste procedimento, você cria um stream do banco de dados Oracle de origem em uma pasta no bucket de destino do Cloud Storage. O stream criado inclui uma lista de permissões e uma lista de rejeição.

  1. Defina uma variável SCHEMAS. Essa variável define os esquemas que contêm os dados e as tabelas que você quer que o Datastream recupere do banco de dados de origem e transfira para a pasta /root/tutorial do bucket de destino do Cloud Storage. Neste tutorial, você definirá a variável SCHEMAS para ser associada ao esquema ROOT.

    No prompt, insira o seguinte comando:

    SCHEMAS="{\"oracleSchemas\":[{\"schema\":\"ROOT\"}]}"

  2. No prompt, insira o comando echo $SCHEMAS | jq para ver o esquema ROOT que você definiu para essa variável em um texto fácil de ler.

  3. Criar um stream. No prompt, insira o seguinte comando:

    STREAM="{\"display_name\":\"DISPLAY_NAME\",\"source_config\":{\"source_connection_profile_name\":\"PROJECT_PATH/connectionProfiles/SOURCE_CONNECTION_PROFILE_ID",\"oracle_source_config\":{\"allowlist\":$SCHEMAS,\"rejectlist\":{}}},\"destination_config\":{\"destination_connection_profile_name\":\"PROJECT_PATH/connectionProfiles/DESTINATION_CONNECTION_PROFILE_ID\",\"gcs_destination_config\":{\"file_rotation_mb\":5,\"file_rotation_interval\":{\"seconds\":15},\"avro_file_format\":{}},\"backfill_all\":{}}}"

  4. Na solicitação, insira o comando echo $STREAM | jq para ver o stream que você criou em um texto fácil de ler.

    {
  "display_name": "DISPLAY_NAME",
  "source_config": {
    "source_connection_profile_name": "PROJECT_PATH/connectionProfiles/SOURCE_CONNECTION_PROFILE_ID",
    "oracle_source_config": {
      "allowlist": {
        "oracleSchemas": [
          {
            "schema": "ROOT"
          }
        ]
      },
      "rejectlist": {}
    }
  },
  "destination_config": {
    "destination_connection_profile_name": "PROJECT_PATH/connectionProfiles/DESTINATION_CONNECTION_PROFILE_ID",
    "gcs_destination_config": {
      "file_rotation_mb": 5,
      "file_rotation_interval": {
        "seconds": 15
      },
      "avro_file_format": {}
    }
  },
  "backfill_all": {}
}

    Use esta tabela para entender os seguintes parâmetros do stream:

    ParâmetroDescrição
    allowlistOs esquemas, que contêm tabelas e dados, que serão transferidos do banco de dados de origem para uma pasta do bucket de destino do Cloud Storage. Para este tutorial, todas as tabelas e dados do esquema ROOT (e somente este esquema) serão transferidos para a pasta /root/tutorial do bucket de destino.
    rejectlistOs esquemas que contêm tabelas e dados não serão transferidos para uma pasta do bucket de destino do Cloud Storage. Neste tutorial, o valor {} significa que nenhuma tabela e dado do banco de dados de origem será impedido de ser transferido para o bucket de destino.
    file_rotation_mbO tamanho (em MBytes) de arquivos que contêm dados que estão sendo transferidos do banco de dados de origem para uma pasta no bucket de destino do Cloud Storage. Para este tutorial, conforme os dados são recuperados do banco de dados de origem, eles são gravados em arquivos de 5 MB. Se algum dado exceder esse tamanho, eles serão segmentados em vários arquivos de 5 MB.
    file_rotation_intervalO número de segundos decorridos até que o Datastream feche um arquivo existente em uma pasta do bucket de destino do Cloud Storage e abra outro arquivo com os dados que estão sendo transferidos do banco de dados de origem. Para este tutorial, o intervalo de rotação de arquivo é definido como 15 segundos.
    avro_file_format

    O formato dos arquivos que o Datastream transferirá do banco de dados de origem para uma pasta do bucket de destino do Cloud Storage. Neste tutorial, Avro é o formato do arquivo.

    backfill_all

    Esse parâmetro está associado ao preenchimento histórico. Ao definir esse parâmetro como um dicionário vazio ({}), o Datastream preencherá:

    • Dados históricos, além de alterações em andamento nos dados, desde o banco de dados de origem até o destino.
    • Esquemas e tabelas, da origem ao destino.

  5. Valide o stream para garantir que ele seja executado e que todas as verificações de validação sejam aprovadas. No prompt, insira o seguinte comando:

    curl -X POST -d $STREAM -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" "https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams?stream_id=STREAM_ID&validate_only=true"

  6. Verifique se você vê a linha de código {}. Isso indica que o stream foi aprovado em todas as verificações de validação e que não há erros associados a ele.

  7. Envie o stream para que ele possa ser criado. No prompt, insira o seguinte comando: 

    curl -X POST -d $STREAM -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams?stream_id=STREAM_ID

  8. Verifique se as seguintes linhas de código são exibidas:

    {
  "name": "PROJECT_PATH/operations/operation-STREAM_OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.datastream.DATASTREAM_API_VERSION.OperationMetadata",
    "createTime": "DATE_AND_TIME_STAMP",
    "target": "PROJECT_PATH/streams/STREAM_ID",
    "verb": "create",
    "requestedCancellation": false,
    "apiVersion": "DATASTREAM_API_VERSION"
  },
  "done": false
}

  9. Confirme se o stream foi criado. No prompt, insira o seguinte comando:

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams

  10. Verifique se você recebeu um resultado retornado para o stream que criou.

    {
  "streams": [
    {
      "name": "PROJECT_PATH/streams/STREAM_ID",
      "createTime": "DATE_AND_TIME_STAMP",
      "updateTime": "DATE_AND_TIME_STAMP",
      "displayName": "DISPLAY_NAME",
      "sourceConfig": {
        "sourceConnectionProfileName": "projects/YOUR_PROJECT_NUMBER/locations/YOUR_PROJECT_LOCATION/connectionProfiles/SOURCE_CONNECTION_PROFILE_ID",
        "oracleSourceConfig": {
          "allowlist": {
            "oracleSchemas": [
              {
                "schema": "ROOT"
              }
            ]
          },
          "rejectlist": {}
        }
      },
      "destinationConfig": {
        "destinationConnectionProfileName": "projects/YOUR_PROJECT_NUMBER/locations/YOUR_PROJECT_LOCATION/connectionProfiles/DESTINATION_CONNECTION_PROFILE_ID",
      "gcsDestinationConfig": {
          "fileRotationMb": 5,
          "fileRotationInterval": "15s"
          "avroFileFormat": {}
        }
      },
      "state": "CREATED",
      "backfillAll": {}
    }
  ]
}

Gerenciar o stream

Neste procedimento, você usa o stream que criou para transferir dados de um banco de dados Oracle de origem para uma pasta em um bucket de destino do Cloud Storage. Incluindo:

  • Como recuperar informações sobre o stream
  • Como modificar o stream
  • Como iniciar o stream
  • Como usar a API Fetch Errors para detectar erros associados ao stream
  • Como pausar e retomar o stream

  1. Recupere informações sobre o stream. No prompt, insira o seguinte comando:

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams/STREAM_ID

  2. Verifique se você vê informações sobre esta transmissão.

    {
  "name": "PROJECT_PATH/streams/STREAM_ID",
  "createTime": "DATE_AND_TIME_STAMP",
  "updateTime": "DATE_AND_TIME_STAMP",
  "displayName": "DISPLAY_NAME",
  "sourceConfig": {
    "sourceConnectionProfileName": "projects/YOUR_PROJECT_NUMBER/locations/YOUR_PROJECT_LOCATION/connectionProfiles/SOURCE_CONNECTION_PROFILE_ID",
    "oracleSourceConfig": {
      "allowlist": {
        "oracleSchemas": [
          {
            "schema": "ROOT"
          }
        ]
      },
      "rejectlist": {}
     }
    },
    "destinationConfig": {
      "destinationConnectionProfileName": "projects/YOUR_PROJECT_NUMBER/locations/YOUR_PROJECT_LOCATION/connectionProfiles/DESTINATION_CONNECTION_PROFILE_ID",
      "gcsDestinationConfig": {
        "fileRotationMb": 5,
        "fileRotationInterval": "15s"
        "avroFileFormat": {}
      }
    },
    "state": "CREATED",
    "backfillAll": {}
  }

  3. Modificar este stream. Para fazer isso, primeiro defina uma variável UPDATE. Essa variável contém os valores do stream que você quer alterar. Para este tutorial, altere o tamanho (em MBytes) de arquivos que contêm dados que estão sendo transferidos do banco de dados de origem para uma pasta no bucket de destino do Cloud Storage (de 5 Mbytes para 100 MBytes). Enquanto os dados estão sendo recuperados do banco de dados de origem, eles são gravados em arquivos de 100 MB. Se algum dado exceder esse tamanho, eles serão segmentados em vários arquivos de 100 MB.

    Para definir a variável, no prompt, insira o seguinte comando:

    UPDATE="{\"destination_config\":{\"gcs_destination_config\":{\"file_rotation_mb\":100}}}"

  4. No prompt, insira o seguinte comando:

    curl -X PATCH -d $UPDATE -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams/STREAM_ID/?update_mask=destination_config.gcs_destination_config.file_rotation_mb

  5. Verifique se as seguintes linhas de código são exibidas:

    {
  "name": "PROJECT_PATH/operations/operation-STREAM_OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.datastream.DATASTREAM_API_VERSION.OperationMetadata",
    "createTime": "DATE_AND_TIME_STAMP",
    "target": "PROJECT_PATH/streams/STREAM_ID",
    "verb": "update",
    "requestedCancellation": false,
    "apiVersion": "DATASTREAM_API_VERSION"
  },
  "done": false
}

  6. Confirme se o stream foi modificado. No prompt, insira o seguinte comando:

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams/STREAM_ID

  7. Verifique se o valor do parâmetro fileRotationMb para o perfil de conexão do Cloud Storage agora é 100.

    {
  "name": "PROJECT_PATH/streams/STREAM_ID",
  "createTime": "DATE_AND_TIME_STAMP",
  "updateTime": "DATE_AND_TIME_STAMP",
  "displayName": "DISPLAY_NAME",
  "sourceConfig": {
    "sourceConnectionProfileName": "projects/YOUR_PROJECT_NUMBER/locations/YOUR_PROJECT_LOCATION/connectionProfiles/SOURCE_CONNECTION_PROFILE_ID",
    "oracleSourceConfig": {
      "allowlist": {
        "oracleSchemas": [
          {
            "schema": "ROOT"
          }
        ]
      },
      "rejectlist": {}
     }
    },
    "destinationConfig": {
      "destinationConnectionProfileName": "projects/YOUR_PROJECT_NUMBER/locations/YOUR_PROJECT_LOCATION/connectionProfiles/DESTINATION_CONNECTION_PROFILE_ID",
      "gcsDestinationConfig": {
        "fileRotationMb": 100,
        "fileRotationInterval": "15s"
        "avroFileFormat": {}
      }
    },
    "state": "CREATED",
    "backfillAll": {}
  }

  8. Iniciar o stream. Para fazer isso, siga estas etapas:

    1. Mude a variável UPDATE. No prompt, insira o seguinte comando:

      UPDATE="{\"state\":\"RUNNING\"}"

    2. Em seguida, digite o seguinte comando:

      curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams/STREAM_ID?updateMask=state

  9. Verifique se as linhas de código a seguir são exibidas.

    {
  "name": "PROJECT_PATH/operations/operation-STREAM_OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.datastream.DATASTREAM_API_VERSION.OperationMetadata",
    "createTime": "DATE_AND_TIME_STAMP",
    "target": "PROJECT_PATH/streams/STREAM_ID",
    "verb": "start",
    "requestedCancellation": false,
    "apiVersion": "DATASTREAM_API_VERSION"
  },
  "done": false
}

  10. Após alguns minutos, recupere informações sobre o stream para confirmar que ele foi iniciado:

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams/STREAM_ID

  11. Verifique se o estado do stream mudou de CREATED para RUNNING.

    {
  "name": "PROJECT_PATH/streams/STREAM_ID",
  "createTime": "DATE_AND_TIME_STAMP",
  "updateTime": "DATE_AND_TIME_STAMP",
  "displayName": "DISPLAY_NAME",
  "sourceConfig": {
    "sourceConnectionProfileName": "projects/YOUR_PROJECT_NUMBER/locations/YOUR_PROJECT_LOCATION/connectionProfiles/SOURCE_CONNECTION_PROFILE_ID",
    "oracleSourceConfig": {
      "allowlist": {
        "oracleSchemas": [
          {
            "schema": "ROOT"
          }
        ]
      },
      "rejectlist": {}
    }
  },
  "destinationConfig": {
    "destinationConnectionProfileName": "projects/YOUR_PROJECT_NUMBER/locations/YOUR_PROJECT_LOCATION/connectionProfiles/DESTINATION_CONNECTION_PROFILE_ID",
    "gcsDestinationConfig": {
      "fileRotationMb": 100,
      "fileRotationInterval": "15s"
      "avroFileFormat": {}
    }
  },
  "state": "RUNNING",
  "backfillAll": {}
}

  12. Uso da API Fetch Errors para recuperar erros associados ao stream.

    1. No prompt, insira o seguinte comando:

      curl -X POST -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams/STREAM_ID:fetchErrors

    2. Verifique se as seguintes linhas de código são exibidas:

        {
    "name": "PROJECT_PATH/operations/operation-FETCH_ERRORS_OPERATION_ID",
    "metadata": {
      "@type": "type.googleapis.com/google.cloud.datastream.DATASTREAM_API_VERSION.OperationMetadata",
      "createTime": "DATE_AND_TIME_STAMP",
      "target": "PROJECT_PATH/streams/STREAM_ID",
      "verb": "fetchErrors",
      "requestedCancellation": false,
      "apiVersion": "DATASTREAM_API_VERSION"
    },
    "done": false
  }

    3. No prompt, insira o seguinte comando:

      curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/operations/operation-FETCH_ERRORS_OPERATION_ID

    4. Verifique se as seguintes linhas de código são exibidas:

        {
    "name": "PROJECT_PATH/operations/operation-FETCH_ERRORS_OPERATION_ID",
    "metadata": {
      "@type": "type.googleapis.com/google.cloud.datastream.DATASTREAM_API_VERSION.OperationMetadata",
      "createTime": "DATE_AND_TIME_STAMP",
      "endTime": "DATE_AND_TIME_STAMP",
      "target": "PROJECT_PATH/streams/STREAM_ID",
      "verb": "fetchErrors",
      "requestedCancellation": false,
      "apiVersion": "DATASTREAM_API_VERSION"
    },
    "done": true,
    "response": {
      "@type": "type.googleapis.com/google.cloud.datastream.DATASTREAM_API_VERSION.FetchErrorsResponse"
    }
  }

  13. Pausar a transmissão. Para fazer isso, siga estas etapas:

    1. Mude a variável UPDATE. No prompt, insira o seguinte comando:

      UPDATE="{\"state\":\"PAUSED\"}"

    2. Em seguida, digite o seguinte comando:

      curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams/STREAM_ID?updateMask=state

  14. Verifique se as linhas de código a seguir são exibidas.

    {
  "name": "PROJECT_PATH/operations/operation-STREAM_OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.datastream.DATASTREAM_API_VERSION.OperationMetadata",
    "createTime": "DATE_AND_TIME_STAMP",
    "target": "PROJECT_PATH/streams/STREAM_ID",
    "verb": "start",
    "requestedCancellation": false,
    "apiVersion": "DATASTREAM_API_VERSION"
  },
  "done": false
}

  15. Recupere informações sobre o stream para confirmar que ele está pausado.

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams/STREAM_ID

  16. Verifique se o estado do stream mudou de RUNNING para PAUSED.

    {
  "name": "PROJECT_PATH/streams/STREAM_ID",
  "createTime": "DATE_AND_TIME_STAMP",
  "updateTime": "DATE_AND_TIME_STAMP",
  "displayName": "DISPLAY_NAME",
  "sourceConfig": {
    "sourceConnectionProfileName": "projects/YOUR_PROJECT_NUMBER/locations/YOUR_PROJECT_LOCATION/connectionProfiles/SOURCE_CONNECTION_PROFILE_ID",
    "oracleSourceConfig": {
      "allowlist": {
        "oracleSchemas": [
          {
            "schema": "ROOT"
          }
        ]
      },
      "rejectlist": {}
    }
  },
  "destinationConfig": {
    "destinationConnectionProfileName": "projects/YOUR_PROJECT_NUMBER/locations/YOUR_PROJECT_LOCATION/connectionProfiles/DESTINATION_CONNECTION_PROFILE_ID",
    "gcsDestinationConfig": {
      "fileRotationMb": 100,
      "fileRotationInterval": "15s"
      "avroFileFormat": {}
    }
  },
  "state": "PAUSED",
  "backfillAll": {}
}

  17. Retomar o stream pausado. Para fazer isso, siga estas etapas:

    1. Mude a variável UPDATE. No prompt, insira o seguinte comando:

      UPDATE="{\"state\":\"RUNNING\"}"

    2. Em seguida, digite o seguinte comando:

      curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams/STREAM_ID?updateMask=state

  18. Verifique se as linhas de código a seguir são exibidas.

    {
  "name": "PROJECT_PATH/operations/operation-STREAM_OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.datastream.DATASTREAM_API_VERSION.OperationMetadata",
    "createTime": "DATE_AND_TIME_STAMP",
    "target": "PROJECT_PATH/streams/STREAM_ID",
    "verb": "start",
    "requestedCancellation": false,
    "apiVersion": "DATASTREAM_API_VERSION"
  },
  "done": false
}

  19. Após alguns segundos, recupere informações sobre o stream para confirmar que ele está sendo executado novamente.

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams/STREAM_ID

  20. Verifique se o estado do stream mudou de PAUSED de volta para RUNNING.

    {
  "name": "PROJECT_PATH/streams/STREAM_ID",
  "createTime": "DATE_AND_TIME_STAMP",
  "updateTime": "DATE_AND_TIME_STAMP",
  "displayName": "DISPLAY_NAME",
  "sourceConfig": {
    "sourceConnectionProfileName": "projects/YOUR_PROJECT_NUMBER/locations/YOUR_PROJECT_LOCATION/connectionProfiles/SOURCE_CONNECTION_PROFILE_ID",
    "oracleSourceConfig": {
      "allowlist": {
        "oracleSchemas": [
          {
            "schema": "ROOT"
          }
        ]
      },
      "rejectlist": {}
    }
  },
  "destinationConfig": {
    "destinationConnectionProfileName": "projects/YOUR_PROJECT_NUMBER/locations/YOUR_PROJECT_LOCATION/connectionProfiles/DESTINATION_CONNECTION_PROFILE_ID",
    "gcsDestinationConfig": {
      "fileRotationMb": 100,
      "fileRotationInterval": "15s"
      "avroFileFormat": {}
    }
  },
  "state": "RUNNING",
  "backfillAll": {}
}

Agora que você criou e gerenciou um stream, confirmou que não há erros associados a ele e que o estado do stream é RUNNING, está pronto para verificar se ele pode transferir dados do banco de dados de origem para um no bucket de destino do Cloud Storage.

Como verificar o stream

Neste procedimento, você confirma que o Datastream:

  • Transfere os dados de todas as tabelas associadas ao esquema ROOT do seu banco de dados Oracle de origem para a pasta /root/tutorial no bucket de destino do Cloud Storage.
  • Converte os dados no formato de arquivo Avro.

  1. Acesse a página Navegador do Storage no Cloud Storage.

    Acessar a página "Navegador do Storage"

  2. Clique no link que contém o bucket.

  3. Se a guia OBJETOS não estiver ativa, clique nela.

  4. Clique na pasta raiz e na pasta tutorial.

  5. Verifique se há pastas que representam tabelas do esquema ROOT do banco de dados Oracle de origem.

  6. Clique em uma das pastas da tabela e faça o detalhamento até ver os dados associados à tabela.

  7. Clique em um arquivo que represente os dados e clique em FAZER O DOWNLOAD.

  8. Abra o arquivo em uma ferramenta Avro (por exemplo, o Visualizador Avro) para garantir que o conteúdo seja legível. Isso confirma que o Datastream também traduziu os dados para o formato de arquivo Avro.

Limpar

Depois de concluir este tutorial, limpe os recursos criados no GCP para que não consumam sua cota e você não seja cobrado por eles no futuro. As próximas seções descrevem como excluir ou desativar esses recursos.

Excluir o projeto

O jeito mais fácil de evitar cobranças é excluindo o projeto que você criou para o tutorial.

Para excluir o projeto:

  1. In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

Excluir o bucket de destino do Cloud Storage

  1. Na gaveta de navegação à esquerda do Cloud Storage, clique no item Navegador.

  2. Marque a caixa de seleção à esquerda do bucket e clique em EXCLUIR.

  3. No bucket Excluir? , insira o nome do bucket no campo de texto e clique em CONFIRMAR.

Excluir o stream

  1. Verifique se o aplicativo Cloud Shell está ativo.

  2. No prompt, insira o seguinte comando:

    curl -X DELETE -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams/STREAM_ID

  3. Verifique se as seguintes linhas de código são exibidas:

    {
  "name": "PROJECT_PATH/operations/operation-STREAM_OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.datastream.DATASTREAM_API_VERSION.OperationMetadata",
    "createTime": "DATE_AND_TIME_STAMP",
    "target": "PROJECT_PATH/streams/STREAM_ID",
    "verb": "delete",
    "requestedCancellation": false,
    "apiVersion": "DATASTREAM_API_VERSION"
  },
  "done": false
}

  4. Confirme que o stream foi excluído. No prompt, insira o seguinte comando:

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams

  5. Verifique se um valor {} nulo é retornado. Isso significa que não há mais streams no Datastream e o stream que você criou é excluído.

Excluir os perfis de conexão

  1. Exclua o perfil de conexão com o banco de dados Oracle de origem. No prompt, insira o seguinte comando:

    curl -X DELETE -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/connectionProfiles/SOURCE_CONNECTION_PROFILE_ID

  2. Verifique se as seguintes linhas de código são exibidas:

    {
  "name": "PROJECT_PATH/operations/operation-SOURCE_CONNECTION_PROFILE_OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.datastream.DATASTREAM_API_VERSION.OperationMetadata",
    "createTime": "DATE_AND_TIME_STAMP",
    "target": "PROJECT_PATH/connectionProfiles/SOURCE_CONNECTION_PROFILE_ID",
    "verb": "delete",
    "requestedCancellation": false,
    "apiVersion": "DATASTREAM_API_VERSION"
  },
  "done": false
}

  3. Exclua o perfil de conexão do bucket de destino do Cloud Storage. No prompt, insira o seguinte comando:

    curl -X DELETE -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/connectionProfiles/DESTINATION_CONNECTION_PROFILE_ID

  4. Verifique se as seguintes linhas de código são exibidas:

    {
  "name": "PROJECT_PATH/operations/operation-DESTINATION_CONNECTION_PROFILE_OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.datastream.DATASTREAM_API_VERSION.OperationMetadata",
    "createTime": "DATE_AND_TIME_STAMP",
    "target": "PROJECT_PATH/connectionProfiles/DESTINATION_CONNECTION_PROFILE_ID",
    "verb": "delete",
    "requestedCancellation": false,
    "apiVersion": "DATASTREAM_API_VERSION"
  },
  "done": false
}

  5. Confirme que os dois perfis de conexão foram excluídos. No prompt, insira o seguinte comando:

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/connectionProfiles

  6. Verifique se um valor {} nulo é retornado. Isso significa que não há mais perfis de conexão no Datastream e que os perfis que você criou são excluídos.

A seguir