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 a API Google Workspace Events e o Google Cloud Pub/Sub para observar e reagir a eventos. em um espaço para reuniões do Meet. O aplicativo de amostra registra conferências começam e terminam, quando os participantes entram ou saem e quando qualquer os artefatos gerados da reunião estão disponíveis.

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

Pré-requisitos

Se você precisa ativar algum desses pré-requisitos na sua organização, peça seu administrador do Google Workspace para ativá-las:

Preparar o ambiente

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

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

Para criar e ativar uma nova nova rede ambiente, execute o seguinte 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 o menu > IAM e Administrador > Criar um projeto.

    Acessar "Criar um projeto"

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

    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, então escolha um ID que atenda às suas necessidades para o ciclo de vida projeto.

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

CLI da gcloud

Em um dos ambientes de desenvolvimento a seguir, acesse o Google Cloud CLI (`gcloud`):

  • Cloud Shell: para usar um terminal on-line com a gcloud CLI configure o Cloud Shell.
    Ativar o Cloud Shell
  • Local Shell: para usar um ambiente de desenvolvimento local, instalar e inicializar 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 do projeto do Google Cloud

Console do Google Cloud

  1. No console do Google Cloud, acesse Faturamento. Clique em Cardápio > Faturamento > Meus projetos.

    Acessar o faturamento dos meus projetos

  2. Em Selecionar uma organização, escolha a organização associada a seu projeto do Google Cloud.
  3. Na linha do projeto, abra o menu Ações. (), Clique em Alterar faturamento e escolha 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 da projeto do Google Cloud em que você quer ativar o faturamento.
    • BILLING_ACCOUNT_ID é o ID da conta de faturamento a ser vinculada. no projeto do Google Cloud.

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

A autenticação e a autorização permitem que o app acesse a API REST do Meet do Google Cloud. A autorização do usuário é necessária para chamar a API REST do Meet. Nesta seção, você aprende a 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 para configurar a tela de consentimento do OAuth para seu app. Antes de publicar o app externamente, atualize estas informações.

  1. No console do Google Cloud, acesse o 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.
  3. Em Nome do app, digite Meet REST API Tutorial.
  4. Preencha o formulário de registro do app e clique em Save and continue.
  5. Clique em Adicionar ou remover escopos. Será exibido um painel 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. Após selecionar os escopos necessários ao lado do seu app, clique em Salvar e continuar.
  10. Se você selecionou 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 qualquer outro usuário de teste autorizado e clique em Salvar e continuar.
  11. Analise o resumo do registro do app. Para fazer alterações, clique em Editar. Se o app estiver tudo certo, clique em Voltar para o painel.

Criar um Client-ID

O ID do cliente funciona como credenciais para o aplicativo durante a OAuth 2.0 flui. Como o app é executado localmente, crie um ID do cliente para computadores.

  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ó é mostrado no console do Google Cloud.
  5. Clique em Criar. A tela criada pelo cliente OAuth será exibida, mostrando o novo ID e a 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 exige credenciais de usuário na forma de um OAuth 2.0 token de acesso. Nesta seção, você vai implementar o fluxo do OAuth 2.0 para solicitar uma 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, tanto o ID do cliente quanto a chave secreta criados anteriormente são obrigatórios. Copie o arquivo da chave secreta do cliente baixado para o projeto em funcionamento e renomeie-o como client_secret.json.

  3. Para testar como a autorização funciona, execute o comando a seguir. O app solicita autorização e cria um arquivo token.json no 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 o método Conheça a API REST.

Ative as APIs

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

Console do Google Cloud

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

    Ative as APIs

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

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

CLI da gcloud

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

    gcloud config set project PROJECT_ID
    

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

  2. Ative a API REST do Google Meet, a API Google Workspace Events. 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 que pode ser inscrito.

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 o na API Google Workspace Events. Você também deve criar e se inscrever em um tópico do Google Cloud Pub/Sub, que serve como ponto de extremidade de notificação em que sua 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 o 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 seguintes:
    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 seu tópico está formatado como projects/{project}/topics/{topic}: Fazer uma anotação com esse nome para uso em etapas posteriores.
  3. Conceda acesso para publicar mensagens do Pub/Sub no seu tópico:
    1. No painel lateral, abra o Guia Permissões.
    2. Clique em Adicionar principal.
    3. Em Novos principais, digite meet-api-event-push@system.gserviceaccount.com.
    4. Em Atribuir funções, selecione Pub/Sub Publisher.
    5. Clique em Salvar.

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

CLI da gcloud

  1. No projeto do Cloud, execute o comando a seguir para criar um tópico:
    gcloud pubsub topics create workspace-events

    A saída mostra o nome completo do tópico, formatado como projects/{project}/topics/{topic}: Fazer uma anotação com esse nome para uso em etapas posteriores.

  2. Conceda acesso para publicar mensagens no seu tópico:
     gcloud pubsub topics add-iam-policy-binding workspace-events --member='serviceAccount:meet-api-event-push@system.gserviceaccount.com' --role='roles/pubsub.publisher'

    A atualização das permissões do 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 Google Cloud para seu app. Você vai usar o nome do tópico para criar o assinatura do Google Workspace mais tarde.

Criar uma conta de serviço

Console do Google Cloud

  1. No console do Google Cloud, acesse o 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.
  4. Opcional: atribua papéis à 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 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 à 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 personificar o 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 da conta de serviço como a função.
  5. Clique em Salvar.
  6. Volte ao terminal e faça login com gcloud para definir as credenciais padrão do aplicativo como o conta de serviço. Quando a autorização for solicitada, faça login usando a mesma 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 o 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 o Application Default Credentials como o conta de serviço. Quando a autorização for solicitada, faça login usando a mesma 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 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 seguinte código a main.py para definir um método de assinatura Eventos do Meet. Este código se inscreve em todos os eventos de uma reunião espaço. 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 para editar main.py e adicione o exemplo de código a seguir. Este código implementa o receptor e usa a API do Google Cloud Pub/Sub para extrair conforme são disponibilizados. Os vários métodos de gerenciamento 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 ao main.py para chamar os métodos e criar o espaço. inscrever-se em eventos e ouvir. Atualize o TOPIC_NAME e constantes SUBSCRIPTION_NAME com seu próprio topic e nomes de assinaturas que você já criados.

  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ê criados no projeto do Cloud.

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

  2. Execute o programa:

    python3 main.py
    

Se você ainda não executou o programa, ele vai solicitar a autorização, pela primeira vez. Conceda acesso ao aplicativo para chamar a API REST do Meet. Após a execução do programa, você 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 exibidos pelo aplicativo. Depois disso, tente estas ações para eventos acionadores:

  • Saia e entre novamente na reunião.
  • Convide outras pessoas ou ligue para a reunião usando seu smartphone.
  • Ativar gravações e transcrições.

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

Use ctrl-c para interromper o programa quando terminar.

Opcional: outras etapas a serem testadas

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

  • Use a API People para recuperar informações adicionais sobre participantes que fizeram login.
  • Usar a API Google Drive para fazer o download das gravações. e transcrições.
  • Em vez de fazer o download de transcrições do Google Drive, você pode recuperá-las usando o a transcrição estruturada métodos na API REST do Meet.

Opcional: limpar

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

Para excluir a assinatura:

Console

  1. No console do Google Cloud, acesse o 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 o 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

  1. No console do Google Cloud, acesse a página Gerenciar recursos. Clique em Cardápio > 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 o projeto.

CLI da gcloud

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

    gcloud projects delete PROJECT_ID