Como fazer streaming de dados do Cloud Storage para o BigQuery usando Cloud Functions

Neste tutorial, demonstraremos como fazer streaming de novos objetos de um intervalo do Cloud Storage para o BigQuery usando o Cloud Functions. Cloud Functions é uma plataforma de computação sem servidor e orientada a eventos do Google Cloud Platform (GCP) que fornece escalonamento automático, alta disponibilidade e tolerância a falhas, sem servidores para provisionar, gerenciar, atualizar ou corrigir. Faça o streaming de dados por meio do Cloud Functions para se conectar e estender outros serviços do GCP pagando apenas quando seu app estiver em execução.

Este artigo é voltado a analistas de dados, desenvolvedores ou operadores que precisam executar análises praticamente em tempo real em arquivos adicionados ao Cloud Storage. Para acompanhar este artigo, é necessário ter familiaridade com o Linux, o Cloud Storage e o BigQuery.

Arquitetura

O diagrama da arquitetura a seguir ilustra todos os componentes e todo o fluxo do canal de streaming deste tutorial. Para esse canal, é necessário fazer upload de arquivos JSON no Cloud Storage, mas pequenas alterações de código são necessárias para oferecer suporte a outros formatos de arquivo.A ingestão de outros formatos de arquivo não é abordada neste artigo.

Diagrama arquitetônico de canal

No diagrama anterior, o canal consiste nos seguintes passos:

  1. Os arquivos JSON são enviados para o intervalo FILES_SOURCE do Cloud Storage.
  2. Esse evento aciona a Função do Cloud streaming.
  3. Os dados são analisados e inseridos no BigQuery.
  4. O status de ingestão é registrado no Cloud Firestore e no Stackdriver Logging.
  5. Uma mensagem é publicada em um dos seguintes tópicos do Cloud Pub/Sub:
    • streaming_success_topic
    • streaming_error_topic
  6. Dependendo dos resultados, o Cloud Functions move o arquivo JSON do intervalo FILES_SOURCE para um destes:
    • FILES_ERROR
    • FILES_SUCCESS

Objetivos

  • Criar um intervalo do Cloud Storage para armazenar os arquivos JSON.
  • Criar um conjunto de dados e uma tabela do BigQuery para fazer streaming dos dados.
  • Configurar uma Função do Cloud a ser acionada sempre que os arquivos forem adicionados ao intervalo.
  • Configurar tópicos do Cloud Pub/Sub.
  • Configurar mais funções para processar a saída da função.
  • Testar o canal de streaming.
  • Configurar o Stackdriver Monitoring para alertar todos os comportamentos inesperados.

Custos

Neste tutorial, os seguintes componentes faturáveis do Google Cloud Platform são usados:

  • Cloud Storage
  • Cloud Functions
  • Cloud Firestore
  • BigQuery
  • Logging
  • Monitoring

Use a calculadora de preços para gerar uma estimativa de custo com base no uso do projeto. Novos usuários do GCP são qualificados para uma avaliação gratuita.

Antes de começar

  1. Faça login na sua Conta do Google.

    Se você ainda não tiver uma, inscreva-se.

  2. Selecione ou crie um projeto do GCP.

    Acessar a página Gerenciar recursos

  3. Verifique se o faturamento foi ativado para o projeto.

    Saiba como ativar o faturamento

  4. Ativar Cloud Functions API.

    Ativar a API

  5. Crie um espaço de trabalho do Stackdriver. Para mais informações sobre espaços de trabalho, consulte Como gerenciar espaços de trabalho.

    ACESSAR o Stackdriver

Ao concluir este tutorial, exclua os recursos criados para evitar o faturamento contínuo. Para mais informações, consulte Como fazer a limpeza.

Como configurar o ambiente

Neste tutorial, use o Cloud Shell para inserir comandos. O Cloud Shell dá acesso à linha de comando no Console do GCP e inclui o SDK do Cloud e outras ferramentas necessárias para o desenvolvimento no GCP. O Cloud Shell é exibido como uma janela na parte inferior do Console do GCP. A inicialização leva alguns minutos, mas a janela aparece imediatamente.

Para usar o Cloud Shell a fim de configurar o ambiente e clonar o repositório git usado neste tutorial:

  1. No Console do GCP, abra o Cloud Shell.

    ABRIR o Cloud Shell

  2. Verifique se você está trabalhando no projeto recém-criado. Substitua [YOUR_PROJECT_ID] pelo projeto do GCP recém-criado.

    gcloud config set project [YOUR_PROJECT_ID]
    
  3. Defina a zona de computação padrão. Para os fins deste tutorial, é us-east1. Se você estiver implantando em um ambiente de produção, implante em uma região de sua escolha.

    REGION=us-east1
    
  4. Clone o repositório que contém as funções usadas neste tutorial.

    git clone https://github.com/GoogleCloudPlatform/solutions-gcs-bq-streaming-functions-python
    cd solutions-gcs-bq-streaming-functions-python
    

Como criar coletores de origem e destino de streaming

Para fazer streaming de conteúdo para o BigQuery, você precisa ter um intervalo do Cloud Storage FILES_SOURCE e uma tabela de destino no BigQuery.

Criar o intervalo do Cloud Storage

Crie um intervalo do Cloud Storage que representa a origem do canal de streaming apresentado neste tutorial. A meta principal desse intervalo é armazenar temporariamente arquivos JSON transmitidos por streaming para o BigQuery.

  • Crie o intervalo do Cloud Storage FILES_SOURCE, em que FILES_SOURCE é configurado como uma variável de ambiente com um nome exclusivo.

    FILES_SOURCE=${DEVSHELL_PROJECT_ID}-files-source-$(date +%s)
    gsutil mb -c regional -l ${REGION} gs://${FILES_SOURCE}
    

Criar a tabela do BigQuery

Esta seção cria uma tabela do BigQuery usada como o destino de conteúdo para os arquivos. O BigQuery permite especificar o esquema da tabela quando você carrega dados na tabela ou cria uma nova tabela. Nesta seção, crie a tabela e especifique o esquema simultaneamente.

  1. Crie um conjunto de dados do BigQuery e uma tabela. O esquema definido no arquivo schema.json precisa corresponder ao esquema dos arquivos vindos do intervalo FILES_SOURCE.

    bq mk mydataset
    bq mk mydataset.mytable schema.json
    
  2. Verifique se a tabela foi criada.

    bq ls --format=pretty mydataset
    

    A saída é:

    +---------+-------+--------+-------------------+
    | tableId | Type  | Labels | Time Partitioning |
    +---------+-------+--------+-------------------+
    | mytable | TABLE |        |                   |
    +---------+-------+--------+-------------------+
    

Como fazer streaming de dados para o BigQuery

Agora que você criou os coletores de origem e de destino, crie a Função do Cloud para fazer streaming de dados do Cloud Storage para o BigQuery.

Configurar a Função do Cloud de streaming

A função de streaming detecta novos arquivos adicionados ao intervalo FILES_SOURCE e aciona um processo que realiza estas ações:

  • Analisa e valida o arquivo.
  • Verifica se há duplicações.
  • Insere o conteúdo do arquivo no BigQuery.
  • Registra o status de ingestão no Cloud Firestore e no Logging.
  • Publica uma mensagem em um tópico de erro ou de êxito no Cloud Pub/Sub.

Para implantar a função:

  1. Crie um intervalo do Cloud Storage para organizar as funções durante a implantação em que FUNCTIONS_BUCKET seja configurado como uma variável de ambiente com um nome exclusivo.

    FUNCTIONS_BUCKET=${DEVSHELL_PROJECT_ID}-functions-$(date +%s)
    gsutil mb -c regional -l ${REGION} gs://${FUNCTIONS_BUCKET}
    
  2. Implante a função streaming. O código de implementação está na pasta ./functions/streaming. Isso pode demorar alguns minutos.

    gcloud functions deploy streaming --region=${REGION} \
        --source=./functions/streaming --runtime=python37 \
        --stage-bucket=${FUNCTIONS_BUCKET} \
        --trigger-bucket=${FILES_SOURCE}
    

    Esse código implanta uma Função do Cloud escrita em Python, chamada streaming. Ela é acionada sempre que um arquivo é adicionado ao intervalo FILES_SOURCE.

  3. Verifique se a função foi implantada.

    gcloud functions describe streaming  --region=${REGION} \
        --format="table[box](entryPoint, status, eventTrigger.eventType)"
    

    A saída é:

    ┌────────────────┬────────┬────────────────────────────────┐
    │  ENTRY_POINT   │ STATUS │           EVENT_TYPE           │
    ├────────────────┼────────┼────────────────────────────────┤
    │ streaming      │ ACTIVE │ google.storage.object.finalize │
    └────────────────┴────────┴────────────────────────────────┘
    
  4. Provisione um tópico do Cloud Pub/Sub, chamado streaming_error_topic, para processar o caminho do erro.

    STREAMING_ERROR_TOPIC=streaming_error_topic
    gcloud pubsub topics create ${STREAMING_ERROR_TOPIC}
    
  5. Provisione um tópico do Cloud Pub/Sub, chamado streaming_success_topic, para processar o caminho bem-sucedido.

    STREAMING_SUCCESS_TOPIC=streaming_success_topic
    gcloud pubsub topics create ${STREAMING_SUCCESS_TOPIC}
    

Configurar o banco de dados do Cloud Firestore

Durante a transmissão dos dados para o BigQuery, é importante entender o que está acontecendo com a ingestão de cada arquivo. Por exemplo, suponhamos que você tenha arquivos importados incorretamente. Nesse caso, você precisa descobrir a causa principal do problema e corrigi-lo para evitar gerar dados corrompidos e relatórios imprecisos ao final do canal. A função streaming, implementada na seção anterior, armazena o status de ingestão de arquivos nos documentos do Cloud Firestore. Dessa maneira, é possível consultar erros recentes para resolver todos os problemas.

Para criar a instância do Cloud Firestore, siga estes passos:

  1. No Console do GCP, acesse o Cloud Firestore.

    ACESSAR A PÁGINA do Cloud Firestore

  2. Na janela Escolher onde você armazena os dados, próxima de Modo nativo, clique em Selecionar modo nativo.

  3. Na lista Selecionar um local, selecione nam5 (Estados Unidos) e clique em Criar banco de dados. Aguarde a conclusão da inicialização do Cloud Firestore. Isso normalmente demora alguns minutos.

Processar erros de streaming

Para provisionar um caminho a fim de processar arquivos de erros, implante outra Função do Cloud, que detecta mensagens publicadas em streaming_error_topic. A empresa precisa determinar como você processa esses erros em um ambiente de produção. Para os fins deste tutorial, os arquivos problemáticos são movidos para outro intervalo do Cloud Storage a fim de facilitar a solução de problemas.

  1. Crie o intervalo do Cloud Storage para armazenar arquivos problemáticos. FILES_ERROR é configurado como uma variável de ambiente com um nome exclusivo para o intervalo que armazena arquivos de erro.

    FILES_ERROR=${DEVSHELL_PROJECT_ID}-files-error-$(date +%s)
    gsutil mb -c regional -l ${REGION} gs://${FILES_ERROR}
    
  2. Implante a função streaming_error para processar erros. Isso pode demorar alguns minutos.

    gcloud functions deploy streaming_error --region=${REGION} \
        --source=./functions/move_file \
        --entry-point=move_file --runtime=python37 \
        --stage-bucket=${FUNCTIONS_BUCKET} \
        --trigger-topic=${STREAMING_ERROR_TOPIC} \
        --set-env-vars SOURCE_BUCKET=${FILES_SOURCE},DESTINATION_BUCKET=${FILES_ERROR}
    

    Esse comando é semelhante ao comando para implantar a função streaming. A diferença principal é que, nesse comando, a função é acionada por uma mensagem publicada em um tópico e recebe duas variáveis de ambiente: SOURCE_BUCKET, de onde arquivos são copiados, e DESTINATION_BUCKET, para onde os arquivos são copiados.

  3. Verifique se a função streaming_error foi criada.

    gcloud functions describe streaming_error --region=${REGION} \
        --format="table[box](entryPoint, status, eventTrigger.eventType)"
    

    A saída é:

    ┌─────────────┬────────┬─────────────────────────────┐
    │ ENTRY_POINT │ STATUS │          EVENT_TYPE         │
    ├─────────────┼────────┼─────────────────────────────┤
    │ move_file   │ ACTIVE │ google.pubsub.topic.publish │
    └─────────────┴────────┴─────────────────────────────┘
    

Processar streaming bem-sucedido

Para provisionar um caminho a fim de processar arquivos bem-sucedidos, você implanta uma terceira Função do Cloud, que detecta mensagens publicadas no streaming_success_topic. Para os fins deste tutorial, os arquivos ingeridos com êxito são arquivados em um intervalo do Cloud Storage Coldline.

  1. Crie o intervalo do Cloud Storage Coldline. FILES_SUCCESS é configurado como uma variável de ambiente com um nome exclusivo para o intervalo que armazena arquivos bem-sucedidos.

    FILES_SUCCESS=${DEVSHELL_PROJECT_ID}-files-success-$(date +%s)
    gsutil mb -c coldline -l ${REGION} gs://${FILES_SUCCESS}
    
  2. Implante a função streaming_success para processar êxitos. Isso pode demorar alguns minutos.

    gcloud functions deploy streaming_success --region=${REGION} \
        --source=./functions/move_file \
        --entry-point=move_file --runtime=python37 \
        --stage-bucket=${FUNCTIONS_BUCKET} \
        --trigger-topic=${STREAMING_SUCCESS_TOPIC} \
        --set-env-vars SOURCE_BUCKET=${FILES_SOURCE},DESTINATION_BUCKET=${FILES_SUCCESS}
    
  3. Verifique se a função foi criada.

    gcloud functions describe streaming_success  --region=${REGION} \
        --format="table[box](entryPoint, status, eventTrigger.eventType)"
    

    A saída é:

    ┌─────────────┬────────┬─────────────────────────────┐
    │ ENTRY_POINT │ STATUS │          EVENT_TYPE         │
    ├─────────────┼────────┼─────────────────────────────┤
    │ move_file   │ ACTIVE │ google.pubsub.topic.publish │
    └─────────────┴────────┴─────────────────────────────┘
    

Como testar o canal de streaming

Neste ponto, você terminou de criar o canal de streaming. Agora é hora de testar caminhos diferentes. Primeiro, você testa a ingestão de novos arquivos, depois de arquivos de duplicação e, por fim, de arquivos problemáticos.

Ingerir novos arquivos

Para testar a ingestão de novos arquivos, faça upload de um arquivo que precisa passar por todo o canal com êxito. Para garantir que tudo esteja se comportando corretamente, você precisa verificar todos os itens de armazenamento: intervalos do BigQuery, do Cloud Firestore e do Cloud Storage.

  1. Faça upload do arquivo data.json no intervalo FILES_SOURCE.

    gsutil cp test_files/data.json gs://${FILES_SOURCE}
    

    A saída:

    Operation completed over 1 objects/312.0 B.
    
  2. Consulte os dados no BigQuery.

    bq query 'select first_name, last_name, dob from mydataset.mytable'
    

    Este comando produz o conteúdo do arquivo data.json:

    +------------+-----------+------------+
    | first_name | last_name |    dob     |
    +------------+-----------+------------+
    | John       | Doe       | 1968-01-22 |
    +------------+-----------+------------+
    
  3. No Console do GCP, acesse a página do Cloud Firestore.

    ACESSAR A PÁGINA DO CLOUD FIRESTORE

  4. Acesse o documento / > streaming_files > data.json para verificar se o campo success: true está lá. A função streaming está armazenando o status do arquivo em uma coleção chamada streaming_files e usa o nome do arquivo como o ID do documento.

    Verifique se a função de "streaming" está armazenando o status de êxito do arquivo

  5. Volte para o Cloud Shell.

    ACESSAR O Cloud Shell

  6. Verifique se o arquivo ingerido foi removido do intervalo FILES_SOURCE pela função streaming_success.

    gsutil ls -l gs://${FILES_SOURCE}/data.json
    

    A saída é um CommandException porque o arquivo não existe mais no intervalo FILES_SOURCE.

  7. Verifique se o arquivo ingerido agora está no intervalo FILES_SUCCESS.

    gsutil ls -l gs://${FILES_SUCCESS}/data.json
    

    A saída é:

    TOTAL: 1 objects, 312 bytes.
    

Ingerir arquivos já processados

O nome do arquivo é usado como código do documento no Cloud Firestore. Isso facilitará a consulta da função streaming se um determinado arquivo tiver sido processado ou não. Se um arquivo tiver sido ingerido anteriormente, todas as novas tentativas de adicioná-lo serão ignoradas porque isso duplicaria as informações no BigQuery e resultaria em relatórios imprecisos.

Nesta seção, você verifica se o canal está funcionando conforme esperado quando arquivos duplicados são enviados para o intervalo FILES_SOURCE.

  1. Faça upload do mesmo arquivo data.json no intervalo FILES_SOURCE novamente.

    gsutil cp test_files/data.json gs://${FILES_SOURCE}
    

    A saída é:

    Operation completed over 1 objects/312.0 B.
    
  2. A consulta ao BigQuery retorna o mesmo resultado anterior. Isso significa que o canal processou o arquivo, mas não inseriu o conteúdo no BigQuery porque ele foi ingerido antes.

    bq query 'select first_name, last_name, dob from mydataset.mytable'
    

    A saída é:

    +------------+-----------+------------+
    | first_name | last_name |    dob     |
    +------------+-----------+------------+
    | John       | Doe       | 1968-01-22 |
    +------------+-----------+------------+
    
  3. No Console do GCP, acesse a página do Cloud Firestore.

    ACESSAR A PÁGINA DO CLOUD FIRESTORE

  4. No documento / > streaming_files > data.json, verifique se o novo campo **duplication_attempts** foi adicionado.

    Verifique se a função de "streaming" está armazenando as "tentativas de duplicação"

    Sempre que um arquivo é adicionado ao intervalo FILES_SOURCE com o mesmo nome de um processado anteriormente com êxito, o conteúdo do arquivo é ignorado e uma nova tentativa de duplicação é anexada ao campo **duplication_attempts** no Cloud Firestore.

  5. Volte para o Cloud Shell.

    ACESSAR O Cloud Shell

  6. Verifique se o arquivo duplicado ainda está no intervalo FILES_SOURCE.

    gsutil ls -l gs://${FILES_SOURCE}/data.json
    

    A saída é:

    TOTAL: 1 objects, 312 bytes.
    

    No cenário de duplicação, a função streaming registra a ingestão inesperada no Logging, ignora a ingestão e deixa o arquivo no intervalo FILES_SOURCE para análise posterior.

Ingerir arquivos com erros

Agora que você confirmou que o canal de streaming está funcionando e que duplicações não são ingeridas no BigQuery, é hora de verificar o caminho do erro.

  1. Faça upload do data_error.json no intervalo FILES_SOURCE.

    gsutil cp test_files/data_error.json gs://${FILES_SOURCE}
    

    A saída é:

    Operation completed over 1 objects/311.0 B.
    
  2. A consulta ao BigQuery retorna o mesmo resultado anterior. Isso significa que o canal processou o arquivo, mas não inseriu o conteúdo no BigQuery porque ele não obedece o esquema esperado.

    bq query 'select first_name, last_name, dob from mydataset.mytable'
    

    A saída é:

    +------------+-----------+------------+
    | first_name | last_name |    dob     |
    +------------+-----------+------------+
    | John       | Doe       | 1968-01-22 |
    +------------+-----------+------------+
    
  3. No Console do GCP, acesse a página do Cloud Firestore.

    ACESSAR A PÁGINA DO CLOUD FIRESTORE

  4. No documento / > streaming_files > data_error.json, verifique se o campo success: false está adicionado.

    Verifique se a função de "streaming" está armazenando o status de erro do arquivo

    Para arquivos com erros, a função streaming também armazena um campo error_message, que fornece informações detalhadas sobre por que o arquivo não foi ingerido.

  5. Volte para o Cloud Shell.

    ACESSAR O Cloud Shell

  6. Verifique se o arquivo foi removido do intervalo FILES_SOURCE pela função streaming_error.

    gsutil ls -l gs://${FILES_SOURCE}/data_error.json
    

    A saída é um CommandException porque o arquivo não existe mais no intervalo FILES_SOURCE.

  7. Verifique se o arquivo já está no intervalo FILES_ERROR, conforme esperado.

    gsutil ls -l gs://${FILES_ERROR}/data_error.json
    

    A saída é:

    TOTAL: 1 objects, 311 bytes.
    

Encontrar e corrigir problemas na ingestão de dados

A execução de consultas na coleção streaming_files no Cloud Firestore permite fazer o diagnóstico e corrigir rapidamente problemas. Nesta seção, você filtra todos os arquivos de erro usando a API Python padrão para o Cloud Firestore.

db = firestore.Client()
docs = db.collection(u'streaming_files')\
    .where(u'success', u'==', False)\
    .get()

Para ver os resultados da consulta no ambiente:

  1. Crie um ambiente virtual na pasta firestore.

    pip install virtualenv
    virtualenv firestore
    source firestore/bin/activate
    
  2. Instale o módulo Python Cloud Firestore no ambiente virtual.

    pip install google-cloud-firestore
    
  3. Visualize os problemas de canal atuais.

    python firestore/show_streaming_errors.py
    

    O arquivo show_streaming_errors.py contém a consulta do Cloud Firestore e outro padrão para repetir o resultado e formatar a saída. Depois que você executa o comando anterior, a saída é semelhante a:

    +-----------------+-------------------------+----------------------------------------------------------------------------------+
    | File Name       | When                    | Error Message                                                                    |
    +-----------------+-------------------------+----------------------------------------------------------------------------------+
    | data_error.json | 2019-01-22 11:31:58 UTC | Error streaming file 'data_error.json'. Cause: Traceback (most recent call las.. |
    +-----------------+-------------------------+----------------------------------------------------------------------------------+
    
  4. Desative o ambiente virtual quando você terminar a análise.

    deactivate
    

    Depois de encontrar e corrigir os arquivos problemáticos, refaça o upload deles no intervalo FILES_SOURCE com o mesmo nome de arquivo. Esse processo faz com que eles passem por todo o canal de streaming a fim de inserir o conteúdo no BigQuery.

Alerta sobre comportamentos inesperados

Em ambientes de produção, é importante monitorar e alertar sempre que acontece algo estranho. Um dos muitos recursos do Logging são métricas personalizadas. As métricas personalizadas permitem criar políticas de alerta para notificar você e a equipe quando a métrica atender aos critérios especificados.

Nesta seção, você configura o Monitoring para enviar alertas por e-mail sempre que uma ingestão de arquivo falhar. Para identificar uma falha na ingestão, a configuração a seguir usa as mensagens logging.error(..) do Python padrão.

  1. No Console do GCP, acesse a página de métricas com base em registros.

    ACESSAR A PÁGINA DE MÉTRICAS COM BASE EM REGISTROS

  2. Clique em Criar métrica.

  3. Na lista Filtro, selecione Converter em filtro avançado.

    Menu de filtro avançado

  4. No filtro avançado, cole a configuração a seguir.

    resource.type="cloud_function"
    resource.labels.function_name="streaming"
    resource.labels.region="us-east1"
    "Error streaming file "
    

    Configuração para colar no filtro avançado

  5. No Editor de métricas, preencha os campos a seguir e clique em Criar métrica.

    • No campo Nome, insira streaming-error.
    • Na seção Rótulo, insira payload_error no campo Nome.
    • Na lista Tipo de rótulo, selecione String.
    • Na lista Nome do campo, selecione textPayload.
    • No campo Expressão regular de extração, insira (Error streaming file '.*'.).
    • Na lista Tipo, selecione Contador.

      Campos do editor de métrica

  6. No Monitoring, acesse Criar uma política para criar uma política de alerta.

    ACESSAR O STACKDRIVER MONITORING

  7. Na janela Criar uma política, conclua os passos a seguir.

    1. Clique em Adicionar condição.
    2. Preencha os campos a seguir e clique em Salvar.

      • No campo Título, insira streaming-error-condition.
      • No campo Métrica, insira logging/user/streaming-error.

        Adicionar IU de condição no Monitoring

      • Na lista Acionador da condição, selecione Qualquer série temporal que violada.

      • Na lista Condição, selecione está acima.

      • No campo Limite, insira 0.

      • Na lista Para, selecione está acima.

        Acionadores de condição

    3. Na lista Tipo de canal de notificação, selecione E-mail, insira o endereço de e-mail e clique em Adicionar canal de notificação.

    4. No campo Nomear esta política, insira streaming-error-alert e clique em Salvar.

Depois de salvar a política de alertas, o Stackdriver vai monitorar os registros de erro da função streaming e vai enviar um alerta por e-mail sempre que houver erros de streaming durante um intervalo de um minuto.

Como limpar

Para evitar que os recursos usados neste tutorial sejam cobrados na conta do Google Cloud Platform, é possível fazer o seguinte:

Excluir o projeto

  1. No Console do GCP, acesse a página "Projetos".

    Acessar a página Projetos

  2. Na lista de projetos, selecione um e clique em Excluir projeto.
  3. Na caixa de diálogo, digite o código do projeto e clique em Encerrar para excluí-lo.

A seguir

  • Consulte Eventos e acionadores para aprender outras maneiras de acionar uma função sem servidor no GCP.
  • Visite a página de alertas para saber como melhorar a política de alertas definida neste tutorial.
  • Visite a documentação do Cloud Firestore para saber mais sobre essa escala global, o banco de dados NoSQL.
  • Visite a página Cota e limites do BigQuery para entender os limites de inserção de streaming durante a implementação dessa solução em um ambiente de produção.
  • Visite a página Cota e limites do Cloud Functions para entender o tamanho máximo que uma função implantada pode manipular.
  • Teste outros recursos do Google Cloud Platform. Veja os tutoriais.
Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…