Questo tutorial mostra come utilizzare l'API REST di Google Meet insieme all'API Google Workspace Eventi e a Google Cloud Pub/Sub per osservare e reagire agli eventi delle riunioni. L'applicazione di esempio registra l'inizio e la fine delle conferenze, quando i partecipanti entrano o escono e quando sono disponibili gli elementi generati per la riunione.
Per scoprire di più sull'utilizzo degli eventi, consulta la pagina dedicata agli eventi di Iscriviti agli eventi di Google Meet nella documentazione dell'API Eventi di Google Workspace.
Prerequisiti
Se hai bisogno di attivare uno di questi prerequisiti per la tua organizzazione, chiedi all'amministratore di Google Workspace di farlo:
- Un account Google Workspace con accesso a Google Meet.
- Accesso per creare un progetto Google Cloud.
- Python 3 installato.
- L'interfaccia a riga di comando gcloud CLI è installata.
prepara l'ambiente
Questa sezione mostra come creare e configurare il tuo ambiente locale e il progetto Google Cloud per questo tutorial.
Crea una directory di lavoro e un ambiente virtuale Python
Per creare e attivare un nuovo ambiente virtuale, esegui questi comandi nel terminale.
Linux/macOS
mkdir meet-tutorial
cd meet-tutorial
python3 -mvenv env
source env/bin/activate
Windows (prompt dei comandi)
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
Creare un progetto Google Cloud
Console Google Cloud
- Nella console Google Cloud, vai a Menu > IAM e amministrazione > Crea un progetto.
-
Nel campo Nome progetto, inserisci un nome descrittivo per il progetto.
(Facoltativo) Per modificare l'ID progetto, fai clic su Modifica. L'ID progetto non può essere modificato dopo la creazione del progetto, quindi scegli un ID che soddisfi le tue esigenze per tutta la durata del progetto.
- Nel campo Località, fai clic su Sfoglia per visualizzare le potenziali località per il tuo progetto. Poi, fai clic su Seleziona.
- Fai clic su Crea. La console Google Cloud accede alla pagina Dashboard e il tuo progetto viene creato in pochi minuti.
Interfaccia a riga di comando gcloud
In uno dei seguenti ambienti di sviluppo, accedi a Google Cloud CLI ("gcloud"):
-
Cloud Shell: per utilizzare un terminale online con gcloud CLI già configurato, attiva Cloud Shell.
Attivare Cloud Shell -
shell locale: per utilizzare un ambiente di sviluppo locale, installa e initialize gcloud CLI.
Per creare un progetto Cloud, utilizza il comando "gcloud projects create":gcloud projects create PROJECT_ID
Abilita la fatturazione per il progetto Google Cloud
Console Google Cloud
- Nella console Google Cloud, vai a Fatturazione. Fai clic su Menu > Fatturazione > I miei progetti.
- In Seleziona un'organizzazione, scegli l'organizzazione associata al tuo progetto Google Cloud.
- Nella riga del progetto, apri il menu Azioni ( ), fai clic su Modifica fatturazione e scegli l'account di fatturazione Cloud.
- Fai clic su Imposta account.
Interfaccia a riga di comando gcloud
- Per elencare gli account di fatturazione disponibili, esegui:
gcloud billing accounts list
- Collega un account di fatturazione a un progetto Google Cloud:
gcloud billing projects link PROJECT_ID --billing-account=BILLING_ACCOUNT_ID
Sostituisci quanto segue:
PROJECT_ID
è l'ID progetto del progetto Cloud per cui vuoi abilitare la fatturazione.BILLING_ACCOUNT_ID
è l'ID account di fatturazione da collegare al progetto Google Cloud.
Configura autenticazione e autorizzazione
L'autenticazione e l'autorizzazione consentono all'app di accedere alle risorse dell'API REST di Meet. Per chiamare l'API REST di Meet è necessaria l'autorizzazione dell'utente. Questa sezione spiega come configurare le credenziali utente e richiedere l'autorizzazione.
Configurare la schermata per il consenso OAuth e scegliere gli ambiti
I passaggi seguenti suggeriscono informazioni segnaposto per configurare la schermata di consenso OAuth per la tua app. Prima di pubblicare l'app esternamente, aggiorna queste informazioni.
- Nella console Google Cloud, vai a Menu > API e servizi > Schermata consenso OAuth.
- In Tipo di utente, seleziona Interno e poi fai clic su Crea.
- In Nome app, inserisci
Meet REST API Tutorial
. - Compila il modulo di registrazione dell'app, poi fai clic su Salva e continua.
- Fai clic su Aggiungi o rimuovi ambiti. Viene visualizzato un riquadro con un elenco di ambiti per ciascuna API abilitata nel tuo progetto Google Cloud.
- In Aggiungi manualmente gli ambiti, incolla i seguenti ambiti:
https://www.googleapis.com/auth/meetings.space.created
- Fai clic su Aggiungi alla tabella.
- Fai clic su Update (Aggiorna).
- Dopo aver selezionato gli ambiti richiesti dalla tua app, fai clic su Salva e continua.
- Se hai selezionato Esterno come tipo di utente, aggiungi gli utenti di test:
- In Utenti di test, fai clic su Aggiungi utenti.
- Inserisci il tuo indirizzo email e tutti gli altri utenti di test autorizzati, quindi fai clic su Salva e continua.
- Rivedi il riepilogo della registrazione dell'app. Per apportare modifiche, fai clic su Modifica. Se la registrazione dell'app è corretta, fai clic su Torna alla dashboard.
Creare un ID client
L'ID client funge da credenziali per l'applicazione durante i flussi OAuth 2.0. Poiché l'app viene eseguita localmente, crea un ID client desktop.
- Nella console Google Cloud, vai a Menu > API e servizi > Credenziali.
- Fai clic su Crea credenziali > ID client OAuth.
- Fai clic su Tipo di applicazione > App desktop.
- Nel campo Nome, digita un nome per la credenziale. Questo nome viene visualizzato solo nella console Google Cloud.
- Fai clic su Crea. Viene visualizzata la schermata Creazione del client OAuth, in cui sono indicati il nuovo ID client e il client secret.
- Fai clic su Ok. La credenziale appena creata viene visualizzata in ID client OAuth 2.0.
Installa le librerie di autenticazione di Google
Installa le librerie di autenticazione di Google:
pip install google-auth google-auth-oauthlib
Esegui autorizzazione
L'API REST di Meet richiede le credenziali utente sotto forma di token di accesso OAuth 2.0. In questa sezione implementerai il flusso OAuth 2.0 per richiedere un token di accesso e un token di aggiornamento per l'utente.
Nella directory di lavoro, crea il file
main.py
e aggiungi il seguente contenuto: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()
Per eseguire il codice, sono obbligatori sia l'ID client sia il secret creato in precedenza. Copia il file del client secret scaricato nella directory di lavoro del progetto e rinominalo come
client_secret.json
.Se vuoi testare il funzionamento dell'autorizzazione, esegui questo comando. L'app richiede l'autorizzazione e crea un file
token.json
nella directory di lavoro del progetto dopo l'approvazione della richiesta.python3 main.py
Aggiungere l'API REST di Meet
Ora che il codice di autorizzazione è completo, è il momento di abilitare e chiamare l'API REST di Meet.
Abilita le API
Sebbene questa sezione sia incentrata sull'API REST Meet, questo tutorial utilizza anche Google Cloud Pub/Sub e l'API Google Workspace Eventi.
Console Google Cloud
Nella console Google Cloud, abilita l'API REST Google Meet, l'API Google Workspace Eventi e Google Cloud Pub/Sub.
Verifica di abilitare le API nel progetto Cloud corretto, quindi fai clic su Avanti.
Verifica di abilitare le API corrette e fai clic su Abilita.
Interfaccia a riga di comando gcloud
Se necessario, imposta l'attuale progetto Cloud su quello creato con il comando
gcloud config set project
:gcloud config set project PROJECT_ID
Sostituisci PROJECT_ID con l'ID progetto del progetto Cloud che hai creato.
Abilita l'API REST di Google Meet, l'API Google Workspace Eventi e Google Cloud Pub/Sub con il comando
gcloud services enable
:gcloud services enable meet.googleapis.com workspaceevents.googleapis.com pubsub.googleapis.com
Installa la libreria client dell'API REST di Meet
Per installare la libreria client dell'API REST di Meet:
Esegui il comando:
pip install google-apps-meet
Modifica il file
main.py
per importare il client:from google.apps import meet_v2 as meet
Crea uno spazio
Ora che l'API REST di Meet è disponibile, definisci una funzione per creare uno spazio per le riunioni a cui puoi iscriverti.
Modifica main.py
e aggiungi:
def create_space() -> meet.Space:
"""Create a meeting space."""
client = meet.SpacesServiceClient(credentials=USER_CREDENTIALS)
request = meet.CreateSpaceRequest()
return client.create_space(request=request)
Iscriviti agli eventi
Per ricevere eventi relativi a uno spazio per le riunioni, puoi creare un abbonamento utilizzando l'API Google Workspace Eventi. Devi inoltre creare e sottoscrivere un argomento di Google Cloud Pub/Sub che funge da endpoint di notifica in cui la tua app riceve gli eventi.
Configurare Google Cloud Pub/Sub
Per creare e sottoscrivere un argomento Pub/Sub:
Console Google Cloud
- Nella console Google Cloud, vai a Menu > Pub/Sub.
Assicurati che il progetto Cloud per la tua app sia selezionato.
- Fai clic su
- Inserisci
workspace-events
come nome dell'argomento. - Lascia selezionata l'opzione Aggiungi un abbonamento predefinito.
- Fai clic su Crea. Il nome completo dell'argomento è nel formato
projects/{project}/topics/{topic}
. Prendi nota di questo nome per utilizzarlo nei passaggi successivi.
Crea argomento e segui questi
passaggi:
- Inserisci
- Concedi l'accesso per pubblicare messaggi Pub/Sub nel tuo argomento:
- Nel riquadro laterale, apri la scheda Autorizzazioni.
- Fai clic su Aggiungi entità.
- In Nuove entità, inserisci
meet-api-event-push@system.gserviceaccount.com
. - In Assegna ruoli, seleziona
Pub/Sub Publisher
. - Fai clic su Salva.
L'aggiornamento delle autorizzazioni per l'argomento può richiedere qualche minuto.
Interfaccia a riga di comando gcloud
- Nel tuo progetto Cloud, crea un argomento eseguendo questo comando:
gcloud pubsub topics create workspace-events
L'output visualizza il nome completo dell'argomento, nel formato
projects/{project}/topics/{topic}
. Prendi nota di questo nome per utilizzarlo nei passaggi successivi. - Concedi l'accesso per pubblicare messaggi nell'argomento:
gcloud pubsub topics add-iam-policy-binding workspace-events --member='serviceAccount:meet-api-event-push@system.gserviceaccount.com' --role='roles/pubsub.publisher'
L'aggiornamento delle autorizzazioni per l'argomento può richiedere qualche minuto.
- Crea una sottoscrizione Pub/Sub per l'argomento:
gcloud pubsub subscriptions create workspace-events-sub --topic=TOPIC_NAME
Sostituisci quanto segue:
TOPIC_NAME
: il nome dell'argomento creato nel passaggio precedente.
Prendi nota del nome dell'argomento e assicurati che il valore di {project}
sia l'ID progetto Cloud della tua app. Utilizzerai il nome dell'argomento per creare l'abbonamento a Google Workspace in un secondo momento.
Crea un account di servizio
Console Google Cloud
- Nella console Google Cloud, vai a Menu > IAM e amministrazione > Account di servizio.
- Fai clic su Crea account di servizio.
- Inserisci i dettagli dell'account di servizio, quindi fai clic su Crea e continua.
- (Facoltativo) Assegna ruoli al tuo account di servizio per concedere l'accesso alle risorse del progetto Google Cloud. Per maggiori dettagli, vedi Concessione, modifica e revoca dell'accesso alle risorse.
- Fai clic su Continua.
- (Facoltativo) Inserisci gli utenti o i gruppi che possono gestire ed eseguire azioni con questo account di servizio. Per maggiori dettagli, consulta Gestire l'impersonificazione degli account di servizio.
- Fai clic su Fine. Prendi nota dell'indirizzo email dell'account di servizio.
Interfaccia a riga di comando gcloud
- Crea l'account di servizio:
gcloud iam service-accounts create meet-event-listener \ --display-name="meet-event-listener"
- (Facoltativo) Assegna ruoli al tuo account di servizio per concedere l'accesso alle risorse del progetto Google Cloud. Per maggiori dettagli, vedi Concessione, modifica e revoca dell'accesso alle risorse.
Utilizza l'account di servizio
Dopo aver creato l'account di servizio, concediti l'accesso per impersonare l'account di servizio.
Console Google Cloud
- Nella colonna Azioni per l'account di servizio appena creato, fai clic su > Gestisci autorizzazioni.
- Fai clic su Aggiungi chiave > Concedi l'accesso.
- Inserisci il tuo indirizzo email in Aggiungi entità.
- Seleziona Account di servizio > Creatore token account di servizio come ruolo.
- Fai clic su Salva.
Interfaccia a riga di comando gcloud
- Per aggiungere l'autorizzazione, esegui
gcloud iam service-accounts add-iam-policy-binding
utilizzando l'indirizzo email dell'account di servizio e dell'utente.gcloud iam service-accounts add-iam-policy-binding \ SERVICE_ACCOUNT_EMAIL \ --member="user:YOUR_EMAIL \ --role="roles/iam.serviceAccountTokenCreator"
- Accedi con
gcloud
per impostare le credenziali predefinite dell'applicazione per l'account di servizio. Quando viene richiesta l'autorizzazione, accedi con lo stesso account utilizzato nei passaggi precedenti.gcloud auth application-default login --impersonate-service-account=SERVICE_ACCOUNT_EMAIL
Installare la libreria client Pub/Sub
Usa
pip
per installare la libreria client per Pub/Sub:pip install google-cloud-pubsub
Quindi modifica
main.py
per importare il client:from google.cloud import pubsub_v1
Crea l'abbonamento a Google Workspace
Aggiungi il seguente codice a main.py
per definire un metodo di sottoscrizione agli eventi di Meet. Questo codice si abbona a tutti gli eventi per uno spazio per le riunioni. Una volta registrati, gli eventi vengono pubblicati nell'argomento 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
Quindi, aggiungi il codice corrispondente per il pull ed l'elaborazione degli eventi.
Ascoltare e gestire gli eventi
Continua a modificare main.py
e aggiungi il seguente codice di esempio. Questo codice implementa il lato ricevente e utilizza l'API Google Cloud Pub/Sub per eseguire il pull degli eventi non appena vengono resi disponibili. I vari metodi di gestione stampano
informazioni sugli eventi corrispondenti.
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")
Finalizza il codice
Aggiungi il seguente codice a main.py
per chiamare i metodi per creare lo spazio,
sottoscrivere gli eventi e ascoltare. Aggiorna le costanti TOPIC_NAME
e SUBSCRIPTION_NAME
con i tuoi nomi di argomenti
e abbonamenti creati in precedenza.
Aggiungi il codice 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)
Sostituisci quanto segue:
PROJECT_ID
: l'ID progetto cloud univoco della tua app, ad esempiomy-sample-project-191923
.TOPIC_ID
: il nome dell'argomento Pub/Sub che hai creato nel progetto Cloud.SUBSCRIPTION_ID
: il nome dell'abbonamento, ad esempioworkspace-events-sub
.
Esegui il programma:
python3 main.py
Se non hai eseguito in precedenza il programma, per la prima volta verrà richiesta l'autorizzazione. Concedi l'accesso all'applicazione per chiamare l'API REST di Meet. Una volta eseguito correttamente il programma, dovresti vedere un output simile al seguente:
Join the meeting at https://meet.google.com/abc-mnop-xyz
Partecipa alla conferenza
Per generare eventi per l'applicazione, partecipa alla conferenza utilizzando l'URL visualizzato dall'applicazione. Dopo aver accettato l'invito, puoi provare queste azioni per attivare gli eventi:
- Abbandona e partecipa di nuovo alla riunione.
- Invita altre persone o connettiti con il tuo smartphone.
- Abilita registrazioni e trascrizioni.
Ognuna di queste attività genera un evento che l'applicazione riceve e registra nella console Google Cloud.
Usa ctrl-c
per interrompere il programma al termine.
(Facoltativo) Passaggi aggiuntivi da provare
L'app registra i dettagli di base degli eventi. Per continuare a esplorare l'API REST di Meet, prova a modificare l'applicazione per eseguire queste azioni aggiuntive.
- Utilizza l'API People per recuperare ulteriori informazioni sui partecipanti che hanno eseguito l'accesso.
- Utilizza l'API Google Drive per scaricare registrazioni e trascrizioni.
- Invece di scaricare le trascrizioni da Google Drive, recuperale utilizzando i metodi di trascrizione strutturata nell'API REST di Meet.
Facoltativo: esegui la pulizia
Per evitare che al tuo account della console Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, ti consigliamo di eseguire la pulizia delle risorse e dei progetti creati.
Per eliminare la sottoscrizione:
Console
Nella console Google Cloud, vai a Menu > Pub/Sub > Abbonamenti
Seleziona l'abbonamento e fai clic su
Altre azioni.Fai clic su Elimina. Viene visualizzata la finestra Elimina abbonamento.
Fai clic su Elimina.
Interfaccia a riga di comando gcloud
Elimina la sottoscrizione:
gcloud pubsub subscriptions delete SUBSCRIPTION_NAME
Per eliminare l'argomento:
Console
Nella console Google Cloud, vai a Menu > Pub/Sub > Argomenti
Seleziona l'argomento e fai clic su
Altre azioni.Fai clic su Elimina. Viene visualizzata la finestra Elimina argomento.
Inserisci
delete
e fai clic su Elimina.
Interfaccia a riga di comando gcloud
Eliminare l'argomento:
gcloud pubsub topics delete TOPIC_NAME
Per eliminare il progetto:
Console
- Nella console Google Cloud, vai alla pagina Gestisci risorse. Fai clic su Menu > IAM e amministrazione > Gestisci risorse.
- Nell'elenco dei progetti, seleziona quello da eliminare e fai clic su Elimina .
- Nella finestra di dialogo, digita l'ID progetto e fai clic su Arresta per eliminare il progetto.
Interfaccia a riga di comando gcloud
Per eliminare un progetto, utilizza il comando gcloud projects delete:
gcloud projects delete PROJECT_ID
Argomenti correlati
- Scopri di più su cosa può fare l'API REST di Google Meet ed esamina la documentazione di riferimento.
- Scopri di più su come iscriversi agli eventi utilizzando l'API Eventi Google Workspace.
- Per scoprire di più sull'autenticazione, consulta Configurare la schermata per il consenso OAuth e scegliere gli ambiti.