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

Neste tutorial, mostramos 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 da reunião. O aplicativo de amostra registra o início e o término de uma conferência, o momento em que os participantes entram ou saem e quando os artefatos gerados na reunião estão disponíveis.

Para saber mais sobre como trabalhar com eventos, consulte Inscrever-se em eventos do Google Meet na documentação da API Events do Google Workspace.

Pré-requisitos

Se você precisar ativar algum destes pré-requisitos para sua organização, peça ao administrador do Google Workspace para ativá-lo:

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

Prepare o ambiente

Nesta seção, mostramos como criar e configurar o 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 seu 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, digite um nome descritivo para o projeto.

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

3. No campo Local, clique em Procurar para exibir possíveis locais para seu 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.
  Ative o Cloud Shell
• Shell local: para usar um ambiente de desenvolvimento local, instale e initialize 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 tem 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" dos 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. Vincule 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 Cloud em que você quer ativar o faturamento.
   • BILLING_ACCOUNT_ID é o ID da conta de faturamento que será vinculada 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. Nesta seção, explicamos como configurar as credenciais do usuário e solicitar autorização.

Configurar a tela de permissão OAuth e escolher escopos

As etapas a seguir sugerem informações de marcador de posição para configurar a tela de permissão OAuth do 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 permissão 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 é exibido com uma lista de escopos para cada API ativada 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 exigidos pelo app, clique em Save and Continue.
10. Se você tiver selecionado Externo como tipo de usuário, adicione usuários de teste:
    1. Em Usuários de teste, clique em Adicionar usuários.
    2. Insira seu endereço de e-mail e outros usuários de teste autorizados e clique em Salvar e continuar.
11. Analise o resumo de registro do seu app. Para fazer mudanças, clique em Editar. Se o registro do app estiver correto, clique em Voltar para o painel.

Criar um ID de cliente

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

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. Ele só aparece no console do Google Cloud.
5. Clique em Criar. A tela cliente OAuth criado é exibida, mostrando seu novo ID e chave secreta do cliente.
6. Clique em OK. A credencial recém-criada aparece em IDs do 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 requer credenciais de usuário na forma de um token de acesso OAuth 2.0. Nesta seção, você implementa o fluxo do OAuth 2.0 para solicitar um token de acesso e um token de atualização para o usuário.

1. No seu 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, o ID do cliente e a chave secreta criada anteriormente são necessários. Copie o arquivo da chave secreta do cliente salvo no 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 após a aprovação da solicitação.

   python3 main.py
   

Adicionar a API REST do Meet

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

Ativar as APIs

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

Console do Google Cloud

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

   Ative as APIs

2. Confirme se você está ativando as APIs no projeto correto do Cloud e clique em Próxima.

3. Confirme se você ativou as APIs corretas e clique em Ativar.

CLI da gcloud

1. Se necessário, defina o projeto atual do Cloud para aquele 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 de eventos 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 para reuniões em que você pode se inscrever.

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 para reuniões, crie uma assinatura usando a API Google Workspace Events. Você também precisa criar e se inscrever em um tópico do Google Cloud Pub/Sub que serve como o endpoint de notificação em que seu app recebe os eventos.

Configurar o Google Cloud Pub/Sub

Para criar e assinar 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 seu app está selecionado.

2. Clique em Criar tópico e faça o seguinte:
   1. Digite workspace-events como o nome do tópico.
   2. Deixe a opção Adicionar uma assinatura padrão selecionada.
   3. Clique em Criar. O nome completo do tópico está formatado como projects/{project}/topics/{topic}. Anote esse nome para usar em etapas posteriores.
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.

   A atualização das permissões do seu tópico pode levar alguns minutos.

CLI da gcloud

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

   gcloud pubsub topics create workspace-events

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

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

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

   A atualização das permissões do seu tópico pode levar alguns minutos.

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 do seu app. Você vai usar o nome do tópico para criar a assinatura do Google Workspace mais tarde.

Crie 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 mudá-lo, mude o ID no campo "ID da conta de serviço".
4. Opcional: atribua papéis à sua conta de serviço para conceder acesso aos recursos do seu projeto do Google Cloud. Confira mais detalhes em Como conceder, alterar e revogar 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 de uma 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 seu projeto do Google Cloud. Confira mais detalhes em Como conceder, alterar e revogar acesso a recursos.

Usar a conta de serviço

Depois de criar a conta de serviço, conceda a si mesmo acesso para personificar 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. Digite seu endereço de e-mail em Adicionar participantes.
4. Selecione Contas de serviço > Criador de token de conta de serviço como o papel.
5. Clique em Salvar.

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 com gcloud para definir as credenciais padrão do aplicativo para a conta de serviço. Quando a autorização for solicitada, faça login com 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 para o 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 a seguir ao main.py para definir um método de inscrição em eventos do Meet. Esse código faz a inscrição em todos os eventos de um espaço para reuniões. Quando inscritos, os eventos são postados 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 exemplo de código a seguir. Esse código implementa o lado do recebimento e usa a API Google Cloud Pub/Sub para extrair eventos à medida que 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 a seguir ao main.py para chamar os métodos para criar o espaço, inscrever-se em eventos e detectar. Atualize as constantes TOPIC_NAME e SUBSCRIPTION_NAME com os próprios nomes de tópicos e assinaturas criados 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ê nunca executou o programa, ele solicitará autorização na primeira vez. Conceda acesso ao aplicativo para chamar a API REST do Meet. Depois que o programa for executado, você vai ver uma resposta semelhante a esta:

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

Participe da conferência

Para gerar eventos para o aplicativo, participe da conferência usando o URL mostrado pelo aplicativo. Depois de ingressar, tente estas ações para acionar eventos:

• Saia e entre novamente na reunião.
• Convide outras pessoas ou ligue para a reunião com seu smartphone.
• 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 das gravações e transcrições pode levar vários minutos após o término da reunião. Mantenha 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 para testar

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

• Use a API People para recuperar mais informações sobre os participantes que fizeram login.
• 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, recupere-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, faça o seguinte:

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 será exibida.

4. Clique em Excluir.

CLI da gcloud

1. Excluir a assinatura:

   gcloud pubsub subscriptions delete SUBSCRIPTION_NAME
   

Para excluir o tópico:

Console

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

   Acesse Tópicos

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

3. Clique em Excluir. A janela Excluir tópico é exibida.

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.

   Acessar 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 excluí-lo.

CLI da gcloud

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

   gcloud projects delete PROJECT_ID
   

Temas relacionados

• Saiba mais sobre o que a API REST do Google Meet pode fazer e consulte a documentação de referência.
• Leia sobre como assinar eventos usando a API Events do Google Workspace.
• Para saber mais sobre autenticação, consulte Configurar a tela de permissão OAuth e escolher escopos.