Osserva gli eventi delle riunioni con Python e l'API REST di Google Meet

Questo tutorial mostra come utilizzare l'API REST di Google Meet insieme all'API Google Workspace Events e a Google Cloud Pub/Sub per osservare e reagire agli eventi in uno spazio di riunione di Meet. L'applicazione di esempio registra quando le conferenze iniziano e terminano, quando i partecipanti si uniscono o se ne vanno e quando sono disponibili gli elementi della riunione generati.

Anziché iscriverti a uno spazio di riunione specifico, puoi iscriverti a un utente Meet per ricevere gli eventi di qualsiasi spazio di riunione di proprietà o organizzato dall'utente. Per maggiori dettagli, consulta Iscriversi agli eventi di Google Meet nella documentazione dell'API Google Workspace Events.

Prerequisiti

Se hai bisogno che uno di questi prerequisiti venga attivato per la tua organizzazione, chiedi all'amministratore di Google Workspace di attivarlo:

prepara l'ambiente

Questa sezione mostra come creare e configurare l'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 i seguenti 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

Crea un progetto Google Cloud

Console Google Cloud

  1. Nella console Google Cloud, vai a Menu > IAM e amministrazione > Crea un progetto.

    Vai a Crea un progetto

  2. 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 l'intera durata del progetto.

  3. Nel campo Località, fai clic su Sfoglia per visualizzare le potenziali località per il tuo progetto. Quindi, fai clic su Seleziona.
  4. Fai clic su Crea. La console Google Cloud passa alla pagina Dashboard e il progetto viene creato entro 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.
    Attiva Cloud Shell
  • Shell locale: per utilizzare un ambiente di sviluppo locale, installa e inizializza l'interfaccia a riga di comando gcloud.
    Per creare un progetto Cloud, utilizza il comando gcloud projects create:
    gcloud projects create PROJECT_ID
    Sostituisci PROJECT_ID impostando l'ID del progetto che vuoi creare.

Abilita la fatturazione per il progetto Google Cloud

Console Google Cloud

  1. Nella console Google Cloud, vai a Fatturazione. Fai clic su Menu > Fatturazione > I miei progetti.

    Vai a Fatturazione per i miei progetti

  2. In Seleziona un'organizzazione, scegli l'organizzazione associata al tuo progetto Google Cloud.
  3. Nella riga del progetto, apri il menu Azioni (), fai clic su Modifica fatturazione e scegli l'account di fatturazione Cloud.
  4. Fai clic su Imposta account.

Interfaccia a riga di comando gcloud

  1. Per elencare gli account di fatturazione disponibili, esegui:
    gcloud billing accounts list
  2. 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 attivare la fatturazione.
    • BILLING_ACCOUNT_ID è l'ID account di fatturazione da collegare al progetto Google Cloud.

Configurare l'autenticazione e l'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 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 che seguono suggeriscono informazioni segnaposto per configurare la schermata di consenso OAuth per la tua app. Prima di pubblicare l'app esternamente, aggiorna queste informazioni.

  1. Nella console Google Cloud, vai a Menu > API e servizi > Schermata del consenso OAuth.

    Vai alla schermata per il consenso OAuth

  2. In Tipo di utente, seleziona Interno e poi fai clic su Crea.
  3. In Nome dell'app, inserisci Meet REST API Tutorial.
  4. Completa il modulo di registrazione dell'app, quindi fai clic su Salva e continua.
  5. Fai clic su Aggiungi o rimuovi ambiti. Viene visualizzato un riquadro con un elenco di ambiti per ogni API che hai attivato nel tuo progetto Google Cloud.
  6. In Aggiungi ambiti manualmente, incolla i seguenti ambiti:
    • https://www.googleapis.com/auth/meetings.space.created
  7. Fai clic su Aggiungi alla tabella.
  8. Fai clic su Aggiorna.
  9. Dopo aver selezionato gli ambiti richiesti dalla tua app, fai clic su Salva e continua.
  10. Se hai selezionato Esterno come tipo di utente, aggiungi gli utenti di test:
    1. In Utenti di test, fai clic su Aggiungi utenti.
    2. Inserisci il tuo indirizzo email e gli altri utenti di test autorizzati, quindi fai clic su Salva e continua.
  11. Rivedi il riepilogo della registrazione dell'app. Per apportare modifiche, fai clic su Modifica. Se la registrazione dell'app sembra corretta, fai clic su Torna alla dashboard.

Creare un ID client

L'ID client funge da credenziali per la tua applicazione durante i flussi OAuth 2.0. Poiché l'app viene eseguita localmente, crea un ID client desktop.

  1. Nella console Google Cloud, vai a Menu > API e servizi > Credenziali.

    Vai a credenziali

  2. Fai clic su Crea credenziali > ID client OAuth.
  3. Fai clic su Tipo di applicazione > App desktop.
  4. Nel campo Nome, digita un nome per la credenziale. Questo nome viene visualizzato solo nella console Google Cloud.
  5. Fai clic su Crea. Viene visualizzata la schermata del client OAuth creato, che mostra il nuovo ID client e il nuovo client secret.
  6. Fai clic su OK. La credenziale appena creata viene visualizzata in ID client OAuth 2.0.

Installa le librerie di autenticazione Google

Installa le librerie di autenticazione di Google:

pip install google-auth google-auth-oauthlib

Autorizzazione di esecuzione

L'API REST di Meet richiede le credenziali utente sotto forma di un token di accesso OAuth 2.0. In questa sezione, implementi il flusso OAuth 2.0 per richiedere un token di accesso e un token di aggiornamento per l'utente.

  1. Nella directory di lavoro, crea il file main.py e aggiungi i seguenti contenuti:

    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. Per eseguire il codice, sono obbligatori sia l'ID client sia il secret creati in precedenza. Copia il file del secret client scaricato nella directory di lavoro del progetto e rinominalo in client_secret.json.

  3. Se vuoi testare il funzionamento dell'autorizzazione, esegui il seguente 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

Aggiungi l'API REST di Meet

Ora che il codice di autorizzazione è completo, è il momento di attivare e chiamare l'API REST di Meet.

Abilita le API

Sebbene questa sezione sia incentrata sull'API REST di Meet, questo tutorial utilizza anche Google Cloud Pub/Sub e l'API Google Workspace Events.

Console Google Cloud

  1. Nella console Google Cloud, abilita l'API REST di Google Meet, l'API Events di Google Workspace e Google Cloud Pub/Sub.

    Attiva le API

  2. Verifica di attivare le API nel progetto Cloud corretto, poi fai clic su Avanti.

  3. Verifica di attivare le API corrette, quindi fai clic su Attiva.

Interfaccia a riga di comando gcloud

  1. Se necessario, imposta il progetto Cloud corrente su quello che hai 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.

  2. Abilita l'API REST di Google Meet, l'API Eventi di Google Workspace 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:

  1. Esegui il comando:

    pip install google-apps-meet
  2. 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 un spazio di riunione a cui è possibile iscriversi.

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)

Iscriversi agli eventi

Per ricevere eventi relativi a uno spazio di riunione, crea un abbonamento utilizzando l'API Google Workspace Events. Devi anche creare e iscriverti a un argomento 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 un argomento Pub/Sub e iscriverti:

Console Google Cloud

  1. Nella console Google Cloud, vai a Menu > Pub/Sub.

    Vai a Pub/Sub.

    Assicurati che il progetto Cloud per la tua app sia selezionato.

  2. Fai clic su Crea argomento ed esegui quanto segue:
    1. Inserisci workspace-events come nome dell'argomento.
    2. Lascia selezionata l'opzione Aggiungi una sottoscrizione predefinita.
    3. Fai clic su Crea. Il nome completo dell'argomento è formattato come projects/{project}/topics/{topic}. Prendi nota di questo nome per utilizzarlo nei passaggi successivi.
  3. Concedi l'accesso per pubblicare messaggi Pub/Sub nel tuo argomento:
    1. Nel riquadro laterale, apri la scheda Autorizzazioni.
    2. Fai clic su Aggiungi entità.
    3. In Nuove entità, inserisci meet-api-event-push@system.gserviceaccount.com.
    4. In Assegna i ruoli, seleziona Pub/Sub Publisher.
    5. Fai clic su Salva.

    L'aggiornamento delle autorizzazioni per l'argomento potrebbe richiedere alcuni minuti.

Interfaccia a riga di comando gcloud

  1. Nel tuo progetto Cloud, crea un argomento eseguendo quanto segue:
    gcloud pubsub topics create workspace-events

    L'output mostra il nome completo dell'argomento, formattato come projects/{project}/topics/{topic}. Prendi nota di questo nome per utilizzarlo nei passaggi successivi.

  2. Concedi l'accesso per pubblicare messaggi nel tuo 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 potrebbe richiedere alcuni minuti.

  3. 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 per la tua app. Utilizzerai il nome dell'argomento per creare in un secondo momento l'abbonamento a Google Workspace.

Crea un account di servizio

Console Google Cloud

  1. Nella console Google Cloud, vai a Menu > IAM e amministrazione > Account di servizio.

    Vai a Service account

  2. Fai clic su Crea account di servizio.
  3. Inserisci i dettagli dell'account di servizio e poi fai clic su Crea e continua.
  4. (Facoltativo) Assegna i ruoli all'account di servizio per concedere l'accesso alle risorse del progetto Google Cloud. Per ulteriori dettagli, consulta Concessione, modifica e revoca dell'accesso alle risorse.
  5. Fai clic su Continua.
  6. (Facoltativo) Inserisci gli utenti o i gruppi che possono gestire ed eseguire azioni con questo account di servizio. Per maggiori dettagli, vedi Gestire l'impersonificazione degli account di servizio.
  7. Fai clic su Fine. Prendi nota dell'indirizzo email dell'account di servizio.

Interfaccia a riga di comando gcloud

  1. Crea l'account di servizio:
    gcloud iam service-accounts create meet-event-listener \
      --display-name="meet-event-listener"
  2. (Facoltativo) Assegna i ruoli all'account di servizio per concedere l'accesso alle risorse del progetto Google Cloud. Per ulteriori dettagli, consulta Concessione, modifica e revoca dell'accesso alle risorse.

Utilizza l'account di servizio

Dopo aver creato l'account di servizio, concediti l'accesso per rubare l'identità dell'account di servizio.

Console Google Cloud

  1. Nella colonna Azioni per l'account di servizio appena creato, fai clic su > Gestisci autorizzazioni.
  2. Fai clic su Aggiungi chiave > Concedi l'accesso.
  3. Inserisci il tuo indirizzo email in Aggiungi entità.
  4. Seleziona Account di servizio > Creatore token account di servizio come ruolo.
  5. Fai clic su Salva.
  6. Torna al terminale e accedi con gcloud per impostare le credenziali predefinite dell'applicazione sull'account di servizio. Quando ti viene richiesta l'autorizzazione, accedi utilizzando lo stesso account utilizzato nei passaggi precedenti.
    gcloud auth application-default login --impersonate-service-account=SERVICE_ACCOUNT_EMAIL

Interfaccia a riga di comando gcloud

  1. 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"
  2. Accedi per impostare le credenziali predefinite dell'applicazione sull'account di servizio. Quando ti viene richiesta l'autorizzazione, accedi utilizzando lo stesso account utilizzato nei passaggi precedenti.
    gcloud auth application-default login --impersonate-service-account=SERVICE_ACCOUNT_EMAIL

Installa la libreria client Pub/Sub

  1. Utilizza pip per installare la libreria client per Pub/Sub:

    pip install google-cloud-pubsub
  2. 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 per iscriverti agli eventi di Meet. Questo codice si iscrive a tutti gli eventi per uno spazio riunioni. Quando ti abboni, 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

Aggiungi il codice corrispondente per estrarre ed elaborare gli eventi.

Ascolta e gestisci gli eventi

Continua a modificare main.py e aggiungi il seguente codice di esempio. Questo codice implementa il lato di ricezione e utilizza l'API Google Cloud Pub/Sub per estrarre gli eventi man mano che vengono resi disponibili. I vari metodi di gestore 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 codice seguente a main.py per chiamare i metodi per creare lo spazio, abbonarti agli eventi e ascoltare. Aggiorna le costanti TOPIC_NAME e SUBSCRIPTION_NAME con i tuoi nomi di argomenti e abbonamenti che hai creato in precedenza.

  1. 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 per la tua app, ad esempio my-sample-project-191923.

    • TOPIC_ID: il nome dell'argomento Pub/Sub che hai creato nel tuo progetto Cloud.

    • SUBSCRIPTION_ID: il nome del tuo abbonamento, ad esempio workspace-events-sub.

  2. Esegui il programma:

    python3 main.py

Se non hai mai eseguito il programma, ti verrà richiesta l'autorizzazione la prima volta. Concedi all'applicazione l'accesso per chiamare l'API REST di Meet. Dopo l'esecuzione del programma, dovresti visualizzare un output simile al seguente:

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

Partecipare alla conferenza

Per generare eventi per l'applicazione, partecipa alla conferenza utilizzando l'URL visualizzato dall'applicazione. Dopo aver eseguito l'accesso, puoi provare queste azioni per attivare gli eventi:

  • Esci e rientra nella riunione.
  • Invita altre persone o chiama con il telefono.
  • Attiva le registrazioni e le 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) Ulteriori passaggi da provare

L'app registra i dettagli di base sugli eventi. Per continuare a esplorare l'API REST di Meet, prova a modificare l'applicazione per eseguire queste altre azioni.

  • Utilizza l'API People per recuperare ulteriori informazioni sui partecipanti che hanno eseguito l'accesso.
  • Utilizza l'API Google Drive per scaricare le registrazioni e le trascrizioni.
  • Anziché scaricare le trascrizioni da Google Drive, recuperale utilizzando i metodi per le trascrizioni strutturate nell'API REST di Meet.

(Facoltativo) Pulizia

Per evitare che al tuo account della console Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, ti consigliamo di eliminare le risorse e i progetti creati.

Per eliminare l'abbonamento:

Console

  1. Nella console Google Cloud, vai a Menu > Pub/Sub > Abbonamenti

    Vai agli abbonamenti

  2. Seleziona l'abbonamento e fai clic su Altre azioni.

  3. Fai clic su Elimina. Viene visualizzata la finestra Elimina abbonamento.

  4. Fai clic su Elimina.

Interfaccia a riga di comando gcloud

  1. Elimina l'abbonamento:

    gcloud pubsub subscriptions delete SUBSCRIPTION_NAME

Per eliminare l'argomento:

Console

  1. Nella console Google Cloud, vai a Menu > Pub/Sub > Argomenti

    Vai ad Argomenti

  2. Seleziona l'argomento e fai clic su Altre azioni.

  3. Fai clic su Elimina. Viene visualizzata la finestra Elimina argomento.

  4. Inserisci delete e fai clic su Elimina.

Interfaccia a riga di comando gcloud

  1. Elimina l'argomento:

    gcloud pubsub topics delete TOPIC_NAME

Per eliminare il progetto:

Console

  1. Nella console Google Cloud, vai alla pagina Gestisci risorse. Fai clic su Menu > IAM e amministrazione > Gestisci risorse.

    Vai a Resource Manager

  2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare e fai clic su Elimina .
  3. Nella finestra di dialogo, digita l'ID progetto e fai clic su Chiudi per eliminare il progetto.

Interfaccia a riga di comando gcloud

  1. Per eliminare un progetto, utilizza il comando gcloud projects delete:

    gcloud projects delete PROJECT_ID