Videokonferenzen mit Python und der Google Meet REST API beobachten

In dieser Anleitung wird gezeigt, wie Sie die Google Meet REST API zusammen mit der Google Workspace Events API und Google Cloud Pub/Sub verwenden, um Ereignisse in einem Meet-Konferenzraum zu beobachten und darauf zu reagieren. Die Beispielanwendung zeichnet auf, wann Konferenzen beginnen und enden, wann Teilnehmer beitreten oder die Konferenz verlassen und wann generierte Konferenzartefakte verfügbar sind.

Anstatt einen bestimmten Besprechungsraum zu abonnieren, können Sie einen Meet-Nutzer abonnieren, um Besprechungen für alle Besprechungsräume zu erhalten, deren Inhaber oder Organisator der Nutzer ist. Weitere Informationen finden Sie in der Dokumentation zur Google Workspace Events API unter Google Meet-Ereignisse abonnieren.

Vorbereitung

Wenn eine dieser Voraussetzungen für Ihre Organisation aktiviert werden muss, bitten Sie Ihren Google Workspace-Administrator, sie zu aktivieren:

• Ein Google Workspace-Konto mit Zugriff auf Google Meet
• Zugriff zum Erstellen eines Google Cloud-Projekts
• Python 3 ist installiert.
• Die gcloud CLI muss installiert sein.

Umgebung vorbereiten

In diesem Abschnitt erfahren Sie, wie Sie die lokale Umgebung und das Google Cloud-Projekt für diese Anleitung erstellen und konfigurieren.

Arbeitsverzeichnis und virtuelle Python-Umgebung erstellen

Führen Sie die folgenden Befehle in Ihrem Terminal aus, um eine neue virtuelle Umgebung zu erstellen und zu aktivieren.

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

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

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

Google Cloud-Projekt erstellen

Abrechnung für das Google Cloud-Projekt aktivieren

Authentifizierung und Autorisierung einrichten

Durch Authentifizierung und Autorisierung kann die App auf Meet REST API-Ressourcen zugreifen. Für den Aufruf der Meet REST API ist eine Nutzerautorisierung erforderlich. In diesem Abschnitt wird beschrieben, wie Sie Nutzeranmeldedaten konfigurieren und eine Autorisierung anfordern.

OAuth-Zustimmungsbildschirm konfigurieren und Bereiche auswählen

In den folgenden Schritten werden Platzhalterinformationen zur Konfiguration des OAuth-Zustimmungsbildschirms für Ihre App vorgeschlagen. Aktualisieren Sie diese Informationen, bevor Sie die App extern veröffentlichen.

1. Klicken Sie in der Google Cloud Console auf das Dreistrich-Menü menu > APIs und Dienste > OAuth-Zustimmungsbildschirm.

   Zum OAuth-Zustimmungsbildschirm

2. Wählen Sie unter Nutzertyp die Option Intern aus und klicken Sie auf Erstellen.
3. Geben Sie unter App-Name Meet REST API Tutorial ein.
4. Füllen Sie das Formular zur App-Registrierung aus und klicken Sie dann auf Speichern und fortfahren.
5. Klicken Sie auf Bereiche hinzufügen oder entfernen. Ein Bereich mit einer Liste der Bereiche für jede API wird angezeigt, die Sie in Ihrem Google Cloud-Projekt aktiviert haben.
6. Fügen Sie unter Bereiche manuell hinzufügen die folgenden Bereiche ein:
   • https://www.googleapis.com/auth/meetings.space.created
7. Klicken Sie auf Zur Tabelle hinzufügen.
8. Klicken Sie auf Aktualisieren.
9. Wählen Sie die für Ihre App erforderlichen Bereiche aus und klicken Sie auf Speichern und fortfahren.
10. Wenn Sie als Nutzertyp Extern ausgewählt haben, fügen Sie Testnutzer hinzu:
    1. Klicken Sie unter Testnutzer auf Nutzer hinzufügen.
    2. Geben Sie Ihre E-Mail-Adresse und die E-Mail-Adressen aller anderen autorisierten Testnutzer ein und klicken Sie auf Speichern und fortfahren.
11. Überprüfen Sie die Zusammenfassung der App-Registrierung. Wenn Sie Änderungen vornehmen möchten, klicken Sie auf Bearbeiten. Wenn die App-Registrierung korrekt ist, klicken Sie auf Zurück zum Dashboard.

Client-ID erstellen

Die Client-ID dient während der OAuth 2.0-Abläufe als Anmeldedaten für Ihre Anwendung. Da die App lokal ausgeführt wird, erstellen Sie eine Desktop-Client-ID.

1. Klicken Sie in der Google Cloud Console auf das Dreistrich-Menü menu > APIs und Dienste > Anmeldedaten.

   Zu den Anmeldedaten

2. Klicken Sie auf Anmeldedaten erstellen > OAuth-Client-ID.
3. Klicken Sie auf Anwendungstyp > Desktopanwendung.
4. Geben Sie im Feld Name einen Namen für die Anmeldedaten ein. Dieser Name wird nur in der Google Cloud Console angezeigt.
5. Klicken Sie auf Erstellen. Der Bildschirm „OAuth-Client erstellt“ wird angezeigt. Darauf sind Ihre neue Client-ID und Ihr Clientschlüssel zu sehen.
6. Klicken Sie auf OK. Die neu erstellten Anmeldedaten werden unter OAuth 2.0-Client-IDs angezeigt.

Google Auth-Bibliotheken installieren

Installieren Sie die Google Auth-Bibliotheken:

pip install google-auth google-auth-oauthlib

Autorisierung ausführen

Für die Meet REST API sind Nutzeranmeldedaten in Form eines OAuth 2.0-Zugriffstokens erforderlich. In diesem Abschnitt implementieren Sie den OAuth 2.0-Vorgang, um ein Zugriffstoken und ein Aktualisierungstoken für den Nutzer anzufordern.

1. Erstellen Sie im Arbeitsverzeichnis die Datei main.py und fügen Sie den folgenden Inhalt hinzu:

   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. Zum Ausführen des Codes sind sowohl die Client-ID als auch das zuvor erstellte Secret erforderlich. Kopieren Sie die heruntergeladene Clientsecret-Datei in das Arbeitsverzeichnis des Projekts und benennen Sie sie in client_secret.json um.

3. Wenn Sie die Autorisierung testen möchten, führen Sie den folgenden Befehl aus. Die App fordert zur Autorisierung auf und erstellt nach der Genehmigung der Anfrage eine token.json-Datei im Arbeitsverzeichnis des Projekts.

   python3 main.py
   

Meet REST API hinzufügen

Nachdem der Autorisierungscode fertig ist, können Sie die Meet REST API aktivieren und aufrufen.

APIs aktivieren

In diesem Abschnitt liegt der Schwerpunkt auf der Meet REST API. In dieser Anleitung werden aber auch die Google Cloud Pub/Sub API und die Google Workspace Events API verwendet.

Meet REST API-Clientbibliothek installieren

So installieren Sie die Meet REST API-Clientbibliothek:

1. Führen Sie diesen Befehl aus:

   pip install google-apps-meet
   

2. Bearbeiten Sie die Datei main.py, um den Kunden zu importieren:

   from google.apps import meet_v2 as meet
   

Gruppenbereich erstellen

Da die Meet REST API jetzt verfügbar ist, können Sie eine Funktion zum Erstellen eines Besprechungsraums definieren, der abonniert werden kann.

Bearbeiten Sie main.py und fügen Sie Folgendes hinzu:

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

Ereignisse abonnieren

Wenn Sie Benachrichtigungen zu einem Besprechungsraum erhalten möchten, erstellen Sie mit der Google Workspace Events API ein Abo. Außerdem musst du ein Google Cloud Pub/Sub-Thema erstellen und abonnieren, das als Benachrichtigungsendpunkt dient, über den deine App die Ereignisse empfängt.

Google Cloud Pub/Sub konfigurieren

So erstellst du ein Pub/Sub-Thema und abonnierst es:

Notieren Sie sich den Namen des Themas und achten Sie darauf, dass der Wert für {project} die Cloud-Projekt-ID Ihrer App ist. Mit dem Namen des Themas erstellen Sie später das Google Workspace-Abo.

Dienstkonto erstellen

Dienstkonto verwenden

Gewähren Sie sich nach dem Erstellen des Dienstkontos Zugriff, um die Identität des Dienstkontos zu übernehmen.

Pub/Sub-Clientbibliothek installieren

1. Installieren Sie die Clientbibliothek für Pub/Sub mit pip:

   pip install google-cloud-pubsub
   

2. Bearbeiten Sie dann main.py, um den Client zu importieren:

   from google.cloud import pubsub_v1
   

Google Workspace-Abo erstellen

Fügen Sie main.py den folgenden Code hinzu, um eine Methode zum Abonnieren von Meet-Ereignissen zu definieren. Mit diesem Code werden alle Ereignisse für einen Besprechungsraum abonniert. Wenn Sie ein Abo abschließen, werden Ereignisse im Pub/Sub-Thema veröffentlicht.

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

Fügen Sie als Nächstes den entsprechenden Code hinzu, um die Ereignisse abzurufen und zu verarbeiten.

Auf Ereignisse warten und sie verarbeiten

Bearbeiten Sie main.py weiter und fügen Sie den folgenden Beispielcode hinzu. Dieser Code implementiert die Empfängerseite und verwendet die Google Cloud Pub/Sub API, um Ereignisse abzurufen, sobald sie verfügbar sind. Die verschiedenen Handlermethoden drucken Informationen zu den entsprechenden Ereignissen aus.

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")

Code finalisieren

Fügen Sie main.py den folgenden Code hinzu, um die Methoden zum Erstellen des Gruppenbereichs aufzurufen, Ereignisse zu abonnieren und zu hören. Aktualisieren Sie die Konstanten TOPIC_NAME und SUBSCRIPTION_NAME mit Ihren eigenen Themen- und Abonamen, die Sie zuvor erstellt haben.

1. Fügen Sie den Code zu main.py hinzu:

   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)
   

   Ersetzen Sie Folgendes:

   • PROJECT_ID: Die eindeutige Cloud-Projekt-ID Ihrer App, z. B. my-sample-project-191923.

   • TOPIC_ID: Der Name des Pub/Sub-Themas, das Sie in Ihrem Cloud-Projekt erstellt haben.

   • SUBSCRIPTION_ID: Der Name Ihres Abos, z. B. workspace-events-sub.

2. Programm ausführen:

   python3 main.py
   

Wenn Sie das Programm noch nicht ausgeführt haben, werden Sie beim ersten Mal zur Autorisierung aufgefordert. Gewähren Sie der Anwendung Zugriff, um die Meet REST API aufzurufen. Nach der erfolgreichen Ausführung des Programms sollte die Ausgabe in etwa so aussehen:

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

An der Konferenz teilnehmen

Wenn Sie Ereignisse für die Anwendung generieren möchten, nehmen Sie über die von der Anwendung angezeigte URL an der Konferenz teil. Nachdem Sie der Gruppe beigetreten sind, können Sie mit diesen Aktionen Ereignisse auslösen:

• Verlassen Sie die Videokonferenz und treten Sie ihr wieder bei.
• Sie können andere einladen oder sich mit Ihrem Smartphone anmelden.
• Aktivieren Sie die Aufzeichnung und Transkription.

Jede dieser Aktivitäten generiert ein Ereignis, das von der Anwendung empfangen und in der Google Cloud Console protokolliert wird.

Wenn Sie fertig sind, können Sie das Programm mit ctrl-c unterbrechen.

Optional: Weitere Schritte

Die App protokolliert grundlegende Details zu den Ereignissen. Wenn Sie die Meet REST API weiter erkunden möchten, ändern Sie die Anwendung, um diese zusätzlichen Aktionen auszuführen.

• Mit der People API kannst du zusätzliche Informationen zu angemeldeten Teilnehmern abrufen.
• Mit der Google Drive API können Sie Aufnahmen und Transkripte herunterladen.
• Anstatt Transkripte aus Google Drive herunterzuladen, können Sie sie mithilfe der Methoden für strukturierte Transkripte in der Meet REST API abrufen.

Optional: Bereinigen

Damit Ihrem Google Cloud Console-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, empfehlen wir, alle erstellten Ressourcen und Projekte zu bereinigen.

So löschen Sie das Abo:

So löschen Sie das Thema:

So löschen Sie das Projekt:

Weitere Informationen

• Weitere Informationen zu den Arten von Meet-Ereignissen, für die Sie sich anmelden können
• Weitere Informationen zu den Funktionen der Google Meet REST API finden Sie hier. Außerdem können Sie sich die Referenzdokumentation ansehen.
• Erstellen Sie ein Google Workspace-Abo für Meet-Konferenzräume oder Nutzer, die die Google Workspace Events API verwenden.
• Weitere Informationen zur Authentifizierung finden Sie unter OAuth-Zustimmungsbildschirm konfigurieren und Bereiche auswählen.