Acompanhe eventos de reuniões com Python e a API REST do Google Meet

Este tutorial mostra como usar a API REST do Google Meet com a API Events do Google Workspace e o Google Cloud Pub/Sub para observar e reagir a eventos em um espaço de reunião do Meet. O aplicativo de exemplo registra quando as conferências começam e terminam, quando os participantes entram ou saem e quando os artefatos de reunião gerados estão disponíveis.

Em vez de se inscrever em um espaço de reunião específico, você pode se inscrever em um usuário do Meet para receber eventos de qualquer espaço de reunião que o usuário tenha ou organize. Para mais detalhes, consulte Inscrever-se em eventos do Google Meet na documentação da API Google Workspace Events.

Pré-requisitos

Se você precisar ativar algum desses pré-requisitos na sua organização, peça ao administrador do Google Workspace para fazer isso:

• Uma conta do Google Workspace com acesso ao Google Meet.
• Acesso para criar um projeto do Google Cloud.
• Python 3 instalado.
• A CLI gcloud instalada.

Preparar o ambiente

Esta seção mostra como criar e configurar seu ambiente local e o projeto do Google Cloud para este tutorial.

Criar um diretório de trabalho e um ambiente virtual do Python

Para criar e ativar um novo ambiente virtual, execute os seguintes comandos no terminal.

Linux/macOS

mkdir meet-tutorial
cd meet-tutorial
python3 -mvenv env
source env/bin/activate

Windows (prompt de comando)

mkdir meet-tutorial
cd meet-tutorial
python3 -mvenv env
env/bin/activate.bat

Windows (PowerShell)

mkdir meet-tutorial
cd meet-tutorial
python3 -mvenv env
env/bin/activate.ps1

Criar um projeto do Google Cloud

Console do Google Cloud

1. No console do Google Cloud, acesse Menu > IAM e administrador > Criar um projeto.

   Acessar "Criar um projeto"

2. No campo Nome do projeto, insira um nome descritivo.

   Opcional: para editar o ID do projeto, clique em Editar. O ID do projeto não pode ser alterado após a criação do projeto. Portanto, escolha um ID que atenda às suas necessidades durante a vida útil do projeto.

3. No campo Local, clique em Procurar para mostrar possíveis locais para o projeto. Em seguida, clique em Selecionar.
4. Clique em Criar. O console do Google Cloud navega até a página "Painel", e seu projeto é criado em alguns minutos.

CLI da gcloud

Em um dos seguintes ambientes de desenvolvimento, acesse a CLI do Google Cloud (gcloud):

• Cloud Shell: para usar um terminal on-line com a CLI gcloud já configurada, ative o Cloud Shell.
  Ativar o Cloud Shell
• Shell local: para usar um ambiente de desenvolvimento local, instale e inicialize a CLI gcloud.
  Para criar um projeto do Cloud, use o comando gcloud projects create:

  gcloud projects create PROJECT_ID

  Substitua PROJECT_ID definindo o ID do projeto que você quer criar.

Ativar o faturamento para o projeto do Google Cloud

Se não for possível vincular uma conta de faturamento, você não terá as permissões necessárias para fazer essa alteração. Para mais informações, consulte Permissões necessárias para ativar o faturamento.

Console do Google Cloud

1. No console do Google Cloud, acesse Faturamento. Clique em Menu > Faturamento > Meus projetos.

   Acessar "Faturamento para Meus projetos"

2. Em Selecionar uma organização, escolha a organização associada ao seu projeto do Google Cloud.
3. Na linha do projeto, abra o menu Ações (), clique em Alterar faturamento e escolha a conta do Cloud Billing.
4. Clique em Definir conta.

CLI da gcloud

1. Para listar as contas de faturamento disponíveis, execute:

   gcloud billing accounts list

2. Vincular uma conta de faturamento a um projeto do Google Cloud:

   gcloud billing projects link PROJECT_ID --billing-account=BILLING_ACCOUNT_ID

   Substitua:

   • PROJECT_ID é o ID do projeto do projeto do Cloud para o qual você quer ativar o faturamento.
   • BILLING_ACCOUNT_ID é o ID da conta de faturamento a ser vinculado ao projeto do Google Cloud.

Configurar a autenticação e a autorização

A autenticação e a autorização permitem que o app acesse os recursos da API REST do Meet. A autorização do usuário é necessária para chamar a API REST do Meet. Esta seção mostra como configurar as credenciais do usuário e solicitar autorização.

Configurar a tela de consentimento OAuth e escolher escopos

As etapas a seguir sugerem informações de marcador de posição para configurar a tela de consentimento do OAuth para o app. Antes de publicar o app externamente, atualize essas informações.

1. No console do Google Cloud, acesse Menu > APIs e serviços > Tela de consentimento do OAuth.

   Acessar a tela de permissão OAuth

2. Em Tipo de usuário, selecione Interno e clique em Criar.
   Se não for possível criar um app interno, selecione Externo.
3. Em Nome do app, insira Meet REST API Tutorial.
4. Preencha o formulário de registro do app e clique em Salvar e continuar.
5. Clique em Adicionar ou remover escopos. Um painel aparece com uma lista de escopos para cada API que você ativou no projeto do Google Cloud.
6. Em Adicionar escopos manualmente, cole os seguintes escopos:
   • https://www.googleapis.com/auth/meetings.space.created
7. Clique em Adicionar à tabela.
8. Clique em Atualizar.
9. Depois de selecionar os escopos necessários pelo app, clique em Salvar e continuar.
10. Se você selecionou Externo como tipo de usuário, adicione usuários de teste:
    1. Em Test users, clique em Add users.
    2. Insira seu endereço de e-mail e os outros usuários de teste autorizados. Depois, clique em Salvar e continuar.
11. Analise o resumo do registro do app. Para fazer alterações, clique em Editar. Se o registro do app estiver correto, clique em Voltar ao painel.

Criar um Client-ID

O ID do cliente funciona como credenciais para seu aplicativo durante os fluxos do OAuth 2.0. Como o app é executado localmente, crie um ID de cliente para computador.

1. No console do Google Cloud, acesse Menu > APIs e serviços > Credenciais.

   Ir para Credenciais

2. Clique em Criar credenciais > ID do cliente OAuth.
3. Clique em Tipo de aplicativo > App para computador.
4. No campo Nome, digite um nome para a credencial. Esse nome só aparece no console do Google Cloud.
5. Clique em Criar. A tela do cliente OAuth criado aparece, mostrando o novo ID e a chave secreta do cliente.
6. Clique em OK. A credencial recém-criada aparece em IDs de cliente OAuth 2.0.

Instalar as bibliotecas de autenticação do Google

Instale as bibliotecas de autenticação do Google:

pip install google-auth google-auth-oauthlib

Executar autorização

A API REST do Meet exige credenciais do usuário na forma de um token de acesso OAuth 2.0. Nesta seção, você vai implementar o fluxo OAuth 2.0 para solicitar um token de acesso e um token de atualização para o usuário.

1. No diretório de trabalho, crie o arquivo main.py e adicione o seguinte conteúdo:

   import os
   import json
   
   from google.auth.transport import requests
   from google.oauth2.credentials import Credentials
   from google_auth_oauthlib.flow import InstalledAppFlow
   
   def authorize() -> Credentials:
       """Ensure valid credentials for calling the Meet REST API."""
       CLIENT_SECRET_FILE = "./client_secret.json"
       credentials = None
   
       if os.path.exists('token.json'):
           credentials = Credentials.from_authorized_user_file('token.json')
   
       if credentials is None:
           flow = InstalledAppFlow.from_client_secrets_file(
               CLIENT_SECRET_FILE,
               scopes=[
                   'https://www.googleapis.com/auth/meetings.space.created',
               ])
           flow.run_local_server(port=0)
           credentials = flow.credentials
   
       if credentials and credentials.expired:
           credentials.refresh(requests.Request())
   
       if credentials is not None:
           with open("token.json", "w") as f:
               f.write(credentials.to_json())
   
       return credentials
   
   USER_CREDENTIALS = authorize()
   

2. Para executar o código, são necessários o ID do cliente e a chave secreta criada anteriormente. Copie o arquivo de segredo do cliente transferido por download para o diretório de trabalho do projeto e renomeie-o como client_secret.json.

3. Se você quiser testar como a autorização funciona, execute o comando a seguir. O app solicita autorização e cria um arquivo token.json no diretório de trabalho do projeto depois que a solicitação é aprovada.

   python3 main.py

Adicionar a API REST do Meet

Agora que o código de autorização foi concluído, é hora de ativar e chamar a API REST do Meet.

Ative as APIs

Embora esta seção se concentre na API REST do Meet, este tutorial também usa a API Google Workspace Events e a Pub/Sub do Google Cloud.

Console do Google Cloud

1. No console do Google Cloud, ative a API REST do Google Meet, a API Google Workspace Events e o Pub/Sub do Google Cloud.

   Ative as APIs

2. Confirme que você está ativando as APIs no projeto do Cloud correto e clique em Next.

3. Confirme se você está ativando as APIs corretas e clique em Ativar.

CLI da gcloud

1. Se necessário, defina o projeto do Cloud atual como o que você criou com o comando gcloud config set project:

   gcloud config set project PROJECT_ID

   Substitua PROJECT_ID pelo ID do projeto do projeto do Cloud que você criou.

2. Ative a API REST do Google Meet, a API Events do Google Workspace e o Google Cloud Pub/Sub com o comando gcloud services enable:

   gcloud services enable meet.googleapis.com workspaceevents.googleapis.com pubsub.googleapis.com

Instalar a biblioteca de cliente da API REST do Meet

Siga estas etapas para instalar a biblioteca de cliente da API REST do Meet:

1. Execute o comando:

   pip install google-apps-meet

2. Edite o arquivo main.py para importar o cliente:

   from google.apps import meet_v2 as meet
   

Criar um espaço

Agora que a API REST do Meet está disponível, defina uma função para criar um espaço de reunião que possa ser assinado.

Edite main.py e adicione:

def create_space() -> meet.Space:
    """Create a meeting space."""
    client = meet.SpacesServiceClient(credentials=USER_CREDENTIALS)
    request = meet.CreateSpaceRequest()
    return client.create_space(request=request)

Inscrever-se em eventos

Para receber eventos sobre um espaço de reunião, crie uma assinatura usando a API Google Workspace Events. Você também precisa criar e assinar um tópico do Pub/Sub do Google Cloud que serve como o endpoint de notificação em que o app recebe os eventos.

Configurar o Google Cloud Pub/Sub

Para criar e se inscrever em um tópico do Pub/Sub:

Console do Google Cloud

1. No console do Google Cloud, acesse Menu > Pub/Sub.

   Ir para o Pub/Sub

   Verifique se o projeto do Cloud para o app está selecionado.

2. Clique em Criar tópico e faça o seguinte:
   1. Insira workspace-events como o nome do tema.
   2. Deixe a opção Adicionar uma assinatura padrão selecionada.
   3. Clique em Criar. O nome completo do tópico é formatado como projects/{project}/topics/{topic}. Anote esse nome para usar nas etapas seguintes.
3. Conceda acesso para publicar mensagens do Pub/Sub no seu tópico:
   1. No painel lateral, abra a guia Permissões.
   2. Clique em Adicionar principal.
   3. Em Novos principais, digite [e-mail].
   4. Em Atribuir funções, selecione Pub/Sub Publisher.
   5. Clique em Salvar.

   Pode levar alguns minutos para atualizar as permissões do seu tópico.

CLI da gcloud

1. No seu projeto do Cloud, crie um tópico executando o seguinte:

   gcloud pubsub topics create workspace-events

   A saída mostra o nome completo do tópico, formatado como projects/{project}/topics/{topic}. Anote esse nome para usar nas etapas seguintes.

2. Conceder acesso para publicar mensagens no tópico:

    gcloud pubsub topics add-iam-policy-binding workspace-events --member='serviceAccount:[e-mail]' --role='roles/pubsub.publisher'

   Pode levar alguns minutos para atualizar as permissões do seu tópico.

3. Crie uma assinatura do Pub/Sub para o tópico:

   gcloud pubsub subscriptions create workspace-events-sub --topic=TOPIC_NAME

   Substitua:

   • TOPIC_NAME: o nome do tópico que você criou na etapa anterior.

Anote o nome do tópico e verifique se o valor de {project} é o ID do projeto do Cloud para o app. Você vai usar o nome do tópico para criar a assinatura do Google Workspace mais tarde.

Criar uma conta de serviço

Console do Google Cloud

1. No console do Google Cloud, acesse Menu > IAM e administrador > Contas de serviço.

   Acessar a página "Contas de serviço"

2. Clique em Criar conta de serviço.
3. Preencha os detalhes da conta de serviço e clique em Criar e continuar.
   Observação: por padrão, o Google cria um ID de conta de serviço exclusivo. Se você quiser mudar o ID, modifique-o no campo "ID da conta de serviço".
4. Opcional: atribua papéis à sua conta de serviço para conceder acesso aos recursos do projeto do Google Cloud. Para mais detalhes, consulte Como conceder, alterar e revogar o acesso a recursos.
5. Clique em Continuar.
6. Opcional: insira usuários ou grupos que podem gerenciar e realizar ações com essa conta de serviço. Para mais detalhes, consulte Como gerenciar a representação da conta de serviço.
7. Clique em Concluído. Anote o endereço de e-mail da conta de serviço.

CLI da gcloud

1. Crie a conta de serviço:

   gcloud iam service-accounts create meet-event-listener \
     --display-name="meet-event-listener"

2. Opcional: atribua papéis à sua conta de serviço para conceder acesso aos recursos do projeto do Google Cloud. Para mais detalhes, consulte Como conceder, alterar e revogar o acesso a recursos.

Usar a conta de serviço

Depois de criar a conta de serviço, conceda a si mesmo acesso para falsificar a conta de serviço.

Console do Google Cloud

1. Na coluna Ações da conta de serviço recém-criada, clique em > Gerenciar permissões.
2. Clique em Adicionar chave > Conceder acesso.
3. Insira seu endereço de e-mail em Adicionar diretores.
4. Selecione Contas de serviço > Criador de token de conta de serviço como o papel.
5. Clique em Salvar.
6. Volte ao terminal e faça login com gcloud para definir as credenciais padrão do aplicativo para a conta de serviço. Quando for solicitado, faça login usando a mesma conta usada nas etapas anteriores.

   gcloud auth application-default login --impersonate-service-account=SERVICE_ACCOUNT_EMAIL

CLI da gcloud

1. Para adicionar a permissão, execute gcloud iam service-accounts add-iam-policy-binding usando o endereço de e-mail da conta de serviço e do usuário.

   gcloud iam service-accounts add-iam-policy-binding \
     SERVICE_ACCOUNT_EMAIL \
     --member="user:YOUR_EMAIL \
     --role="roles/iam.serviceAccountTokenCreator"

2. Faça login para definir as credenciais padrão do aplicativo na conta de serviço. Quando for solicitado, faça login usando a mesma conta usada nas etapas anteriores.

   gcloud auth application-default login --impersonate-service-account=SERVICE_ACCOUNT_EMAIL

Instalar a biblioteca de cliente do Pub/Sub

1. Use pip para instalar a biblioteca de cliente do Pub/Sub:

   pip install google-cloud-pubsub

2. Em seguida, edite main.py para importar o cliente:

   from google.cloud import pubsub_v1
   

Criar a assinatura do Google Workspace

Adicione o código abaixo a main.py para definir um método de inscrição em eventos do Meet. Esse código se inscreve em todos os eventos de um espaço de reunião. Quando você se inscreve, os eventos são publicados no tópico do Pub/Sub.

def subscribe_to_space(space_name: str = None, topic_name: str = None):
    """Subscribe to events for a meeting space."""
    session = requests.AuthorizedSession(USER_CREDENTIALS)
    body = {
        'targetResource': f"//meet.googleapis.com/{space_name}",
        "eventTypes": [
            "google.workspace.meet.conference.v2.started",
            "google.workspace.meet.conference.v2.ended",
            "google.workspace.meet.participant.v2.joined",
            "google.workspace.meet.participant.v2.left",
            "google.workspace.meet.recording.v2.fileGenerated",
            "google.workspace.meet.transcript.v2.fileGenerated",
        ],
        "payloadOptions": {
            "includeResource": False,
        },
        "notificationEndpoint": {
            "pubsubTopic": topic_name
        },
        "ttl": "86400s",
    }
    response = session.post("https://workspaceevents.googleapis.com/v1/subscriptions", json=body)
    return response

Em seguida, adicione o código correspondente para extrair e processar os eventos.

Detectar e processar eventos

Continue editando main.py e adicione o código de exemplo abaixo. Esse código implementa o lado receptor e usa a API Google Cloud Pub/Sub para extrair eventos conforme eles são disponibilizados. Os vários métodos de gerenciador imprimem informações sobre os eventos correspondentes.

def format_participant(participant: meet.Participant) -> str:
    """Formats a participant for display on the console."""
    if participant.anonymous_user:
        return f"{participant.anonymous_user.display_name} (Anonymous)"

    if participant.signedin_user:
        return f"{participant.signedin_user.display_name} (ID: {participant.signedin_user.user})"

    if participant.phone_user:
        return f"{participant.phone_user.display_name} (Phone)"

    return "Unknown participant"


def fetch_participant_from_session(session_name: str) -> meet.Participant:
    """Fetches the participant for a session."""
    client = meet.ConferenceRecordsServiceClient(credentials=USER_CREDENTIALS)
    # Use the parent path of the session to fetch the participant details
    parsed_session_path = client.parse_participant_session_path(session_name)
    participant_resource_name = client.participant_path(
        parsed_session_path["conference_record"],
        parsed_session_path["participant"])
    return client.get_participant(name=participant_resource_name)


def on_conference_started(message: pubsub_v1.subscriber.message.Message):
    """Display information about a conference when started."""
    payload = json.loads(message.data)
    resource_name = payload.get("conferenceRecord").get("name")
    client = meet.ConferenceRecordsServiceClient(credentials=USER_CREDENTIALS)
    conference = client.get_conference_record(name=resource_name)
    print(f"Conference (ID {conference.name}) started at {conference.start_time.rfc3339()}")


def on_conference_ended(message: pubsub_v1.subscriber.message.Message):
    """Display information about a conference when ended."""
    payload = json.loads(message.data)
    resource_name = payload.get("conferenceRecord").get("name")
    client = meet.ConferenceRecordsServiceClient(credentials=USER_CREDENTIALS)
    conference = client.get_conference_record(name=resource_name)
    print(f"Conference (ID {conference.name}) ended at {conference.end_time.rfc3339()}")


def on_participant_joined(message: pubsub_v1.subscriber.message.Message):
    """Display information about a participant when they join a meeting."""
    payload = json.loads(message.data)
    resource_name = payload.get("participantSession").get("name")
    client = meet.ConferenceRecordsServiceClient(credentials=USER_CREDENTIALS)
    session = client.get_participant_session(name=resource_name)
    participant = fetch_participant_from_session(resource_name)
    display_name = format_participant(participant)
    print(f"{display_name} joined at {session.start_time.rfc3339()}")


def on_participant_left(message: pubsub_v1.subscriber.message.Message):
    """Display information about a participant when they leave a meeting."""
    payload = json.loads(message.data)
    resource_name = payload.get("participantSession").get("name")
    client = meet.ConferenceRecordsServiceClient(credentials=USER_CREDENTIALS)
    session = client.get_participant_session(name=resource_name)
    participant = fetch_participant_from_session(resource_name)
    display_name = format_participant(participant)
    print(f"{display_name} left at {session.end_time.rfc3339()}")


def on_recording_ready(message: pubsub_v1.subscriber.message.Message):
    """Display information about a recorded meeting when artifact is ready."""
    payload = json.loads(message.data)
    resource_name = payload.get("recording").get("name")
    client = meet.ConferenceRecordsServiceClient(credentials=USER_CREDENTIALS)
    recording = client.get_recording(name=resource_name)
    print(f"Recording available at {recording.drive_destination.export_uri}")


def on_transcript_ready(message: pubsub_v1.subscriber.message.Message):
    """Display information about a meeting transcript when artifact is ready."""
    payload = json.loads(message.data)
    resource_name = payload.get("transcript").get("name")
    client = meet.ConferenceRecordsServiceClient(credentials=USER_CREDENTIALS)
    transcript = client.get_transcript(name=resource_name)
    print(f"Transcript available at {transcript.docs_destination.export_uri}")


def on_message(message: pubsub_v1.subscriber.message.Message) -> None:
    """Handles an incoming event from the Google Cloud Pub/Sub API."""
    event_type = message.attributes.get("ce-type")
    handler = {
        "google.workspace.meet.conference.v2.started": on_conference_started,
        "google.workspace.meet.conference.v2.ended": on_conference_ended,
        "google.workspace.meet.participant.v2.joined": on_participant_joined,
        "google.workspace.meet.participant.v2.left": on_participant_left,
        "google.workspace.meet.recording.v2.fileGenerated": on_recording_ready,
        "google.workspace.meet.transcript.v2.fileGenerated": on_transcript_ready,
    }.get(event_type)

    try:
        if handler is not None:
            handler(message)
        message.ack()
    except Exception as error:
        print("Unable to process event")
        print(error)


def listen_for_events(subscription_name: str = None):
    """Subscribe to events on the subscription."""
    subscriber = pubsub_v1.SubscriberClient()
    with subscriber:
        future = subscriber.subscribe(subscription_name, callback=on_message)
        print("Listening for events")
        try:
            future.result()
        except KeyboardInterrupt:
            future.cancel()
    print("Done")

Finalizar o código

Adicione o código abaixo a main.py para chamar os métodos de criação do espaço, assinatura de eventos e escuta. Atualize as constantes TOPIC_NAME e SUBSCRIPTION_NAME com seus próprios nomes de tópico e assinatura que você criou anteriormente.

1. Adicione o código a main.py:

   space = create_space()
   print(f"Join the meeting at {space.meeting_uri}")
   
   TOPIC_NAME = "projects/PROJECT_ID/topics/TOPIC_ID"
   SUBSCRIPTION_NAME = "projects/PROJECT_ID/subscriptions/SUBSCRIPTION_ID"
   
   subscription = subscribe_to_space(topic_name=TOPIC_NAME, space_name=space.name)
   listen_for_events(subscription_name=SUBSCRIPTION_NAME)
   

   Substitua:

   • PROJECT_ID: o ID exclusivo do projeto do Cloud para seu app, como my-sample-project-191923.

   • TOPIC_ID: o nome do tópico do Pub/Sub que você criou no projeto do Cloud.

   • SUBSCRIPTION_ID: o nome da sua assinatura, como workspace-events-sub.

2. Execute o programa:

   python3 main.py

Se você não tiver executado o programa anteriormente, ele solicitará autorização pela primeira vez. Conceda acesso ao aplicativo para chamar a API REST do Meet. Depois que o programa for executado, você verá uma saída semelhante a esta:

Join the meeting at https://meet.google.com/abc-mnop-xyz

Participar da conferência

Para gerar eventos para o aplicativo, participe da conferência usando o URL exibido pelo aplicativo. Depois de participar, você pode tentar estas ações para acionar eventos:

• Saia e volte para a reunião.
• Convide outras pessoas ou ligue pelo telefone.
• Ative as gravações e transcrições.

Cada uma dessas atividades gera um evento que o aplicativo recebe e registra no console do Google Cloud.

Observação: a geração de gravações e transcrições pode levar vários minutos após o término da reunião. Deixe o programa em execução depois de sair da reunião e aguarde.

Use ctrl-c para interromper o programa quando terminar.

Opcional: outras etapas que você pode testar

O app registra detalhes básicos sobre os eventos. Para continuar explorando a API REST do Meet, tente modificar o aplicativo para realizar essas outras ações.

• Use a API People para recuperar mais informações sobre os participantes conectados.
• Use a API Google Drive para fazer o download de gravações e transcrições.
• Em vez de fazer o download de transcrições do Google Drive, extraia-as usando os métodos de transcrição estruturada na API REST do Meet.

Opcional: limpar

Para evitar cobranças na sua conta do console do Google Cloud pelos recursos usados neste tutorial, recomendamos que você limpe todos os recursos e projetos criados.

Para excluir a assinatura:

Console

1. No console do Google Cloud, acesse Menu > Pub/Sub > Assinaturas

   Acessar "Assinaturas"

2. Selecione a assinatura e clique em Mais ações.

3. Clique em Excluir. A janela Excluir assinatura vai aparecer.

4. Clique em Excluir.

CLI da gcloud

1. Exclua a assinatura:

   gcloud pubsub subscriptions delete SUBSCRIPTION_NAME

Para excluir o tópico:

Console

1. No console do Google Cloud, acesse Menu > Pub/Sub > Topics

   Acesse Tópicos

2. Selecione o tópico e clique em Mais ações.

3. Clique em Excluir. A janela Excluir tópico vai aparecer.

4. Digite delete e clique em Excluir.

CLI da gcloud

1. Exclua o tópico:

   gcloud pubsub topics delete TOPIC_NAME

Para excluir o projeto:

Console

Cuidado:excluir um projeto tem os seguintes efeitos:

• Tudo no projeto é excluído. Se você tiver usado um projeto atual para seguir este tutorial, a exclusão dele incluirá quaisquer outras ações feitas no projeto.
• Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um ID do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL em appspot.com, exclua os recursos selecionados dentro do projeto em vez de excluir o projeto inteiro.

Se você planeja conferir vários tutoriais e guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

1. No console do Google Cloud, acesse a página Gerenciar recursos. Clique em Menu > IAM e administrador > Gerenciar recursos.

   Acesse o Resource Manager

2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluir o projeto.

CLI da gcloud

1. Para excluir um projeto, use o comando gcloud projects delete:

   gcloud projects delete PROJECT_ID

Temas relacionados

• Saiba mais sobre os tipos de eventos do Meet que você pode assinar.
• Saiba mais sobre o que a API REST do Google Meet pode fazer e consulte a documentação de referência.
• Crie uma assinatura do Google Workspace para espaços de reunião do Meet ou usuários usando a API Google Workspace Events.
• Para saber mais sobre a autenticação, consulte Configurar a tela de consentimento OAuth e escolher escopos.