Videokonferenzen mit Python und der Google Meet REST API beobachten

In dieser Anleitung erfahren Sie, wie Sie die Google Meet REST API mit der Google Workspace Events API und Google Cloud Pub/Sub zur Beobachtung und Reaktion Meeting-Terminen. Die Beispielanwendung zeichnet auf, wann Konferenzen beginnen und enden. wann Teilnehmer beitreten oder sie verlassen und wenn generierte Videokonferenzelemente verfügbar.

Weitere Informationen zum Arbeiten mit Terminen finden Sie unter Google Meet abonnieren. Ereignisse in der Google Workspace Events API Dokumentation.

Vorbereitung

Wenn eine dieser Voraussetzungen für Ihre Organisation aktiviert sein muss, fragen Sie nach Ihren Google Workspace-Administrator, um sie zu aktivieren:

• Ein Google Workspace-Konto mit auf Google Meet zugreifen können.
• Zugriff zum Erstellen eines Google Cloud-Projekts.
• Python 3 installiert.
• Die installierte gcloud CLI.

Umgebung vorbereiten

In diesem Abschnitt erfahren Sie, wie Sie Ihre lokale Umgebung und den Google Cloud-Projekt für diese Anleitung.

Arbeitsverzeichnis und virtuelle Python-Umgebung erstellen

Um ein neues virtuelles Umgebung, führen Sie den folgenden Befehl aus: in Ihrem Terminal.

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 die Meet REST API zugreifen Ressourcen. Zum Aufrufen der Meet REST API ist eine Nutzerautorisierung erforderlich. In diesem Abschnitt erfahren Sie, wie Sie Nutzeranmeldedaten konfigurieren und Autorisierung.

OAuth-Zustimmungsbildschirm konfigurieren und Bereiche auswählen

In den folgenden Schritten werden Platzhalterinformationen zum Konfigurieren vorgeschlagen den OAuth-Zustimmungsbildschirm für für Ihre App. Bevor Sie die App extern veröffentlichen, aktualisieren Sie diese Informationen.

1. Öffnen Sie in der Google Cloud Console das Menü menu. > APIs und Dienste > OAuth-Zustimmungsbildschirm.

   Zum OAuth-Zustimmungsbildschirm

2. Wählen Sie unter Nutzertyp die Option Intern aus und klicken Sie dann auf Erstellen. <ph type="x-smartling-placeholder">
3. Geben Sie unter App-Name Meet REST API Tutorial ein.
4. Füllen Sie das App-Registrierungsformular aus und klicken Sie dann auf Speichern und fortfahren.
5. Klicken Sie auf Bereiche hinzufügen oder entfernen. Ein Steuerfeld mit einer Liste der Bereiche wird angezeigt für jede API, die Sie in Ihrem Google Cloud-Projekt aktiviert haben.
6. Fügen Sie unter Bereiche manuell hinzufügen die folgenden Bereiche ein: <ph type="x-smartling-placeholder">
   </ph>
   • https://www.googleapis.com/auth/meetings.space.created
7. Klicken Sie auf Zu Tabelle hinzufügen.
8. Klicken Sie auf Aktualisieren.
9. Nach Auswahl der erforderlichen Bereiche angezeigt wird, klicken Sie auf Speichern und fortfahren.
10. Wenn Sie als Nutzertyp Extern ausgewählt haben, fügen Sie Testnutzer hinzu: <ph type="x-smartling-placeholder">
    </ph>
    1. Klicken Sie unter Testnutzer auf Nutzer hinzufügen.
    2. Geben Sie Ihre E-Mail-Adresse und weitere autorisierte Testnutzer ein und klicken Sie dann auf Speichern und fortfahren.
11. Überprüfen Sie die Registrierungsübersicht der App. Klicken Sie auf Bearbeiten, um Änderungen vorzunehmen. Wenn die App mit der Registrierung in Ordnung ist, klicken Sie auf Zurück zum Dashboard.

Client-ID erstellen

Die Client-ID dient während des OAuth 2.0-Vorgangs als Anmeldedaten für Ihre Anwendung. fließen. Da die Anwendung lokal ausgeführt wird, erstellen Sie eine Desktop-Client-ID.

1. Öffnen Sie in der Google Cloud Console das Dreistrich-Menü menu &gt; APIs und Dienste &gt; Anmeldedaten.

   Zu den Anmeldedaten

2. Klicken Sie auf Anmeldedaten erstellen &gt; OAuth-Client-ID.
3. Klicken Sie auf Anwendungstyp &gt; Desktop-App.
4. Geben Sie in das 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 mit Ihrer neuen Client-ID und Ihrem Clientschlüssel angezeigt.
6. Klicken Sie auf OK. Die neu erstellten Anmeldedaten werden unter OAuth 2.0-Client-IDs angezeigt.

Google-Authentifizierungsbibliotheken installieren

Installieren Sie die Google-Authentifizierungsbibliotheken:

pip install google-auth google-auth-oauthlib

Autorisierung ausführen

Für die Meet REST API sind Nutzeranmeldedaten in Form von OAuth 2.0 erforderlich ein Zugriffstoken hinzufügen. In diesem Abschnitt implementieren Sie den OAuth 2.0-Vorgang zum Anfordern einer Zugriffs-Token und ein Aktualisierungs-Token für den Nutzer.

1. Erstellen Sie in Ihrem Arbeitsverzeichnis die Datei main.py und fügen Sie Folgendes hinzu: Inhalt:

   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 werden sowohl die Client-ID als auch das zuvor erstellte Secret verwendet erforderlich. Kopieren Sie die heruntergeladene Clientschlüsseldatei in das Projekt, das gerade arbeitet. und benennen Sie es in client_secret.json um.

3. Wenn Sie testen möchten, wie die Autorisierung funktioniert, führen Sie den folgenden Befehl aus. Die App fordert zur Autorisierung auf und erstellt eine token.json-Datei im Projektarbeitsverzeichnis erstellen, nachdem die Anfrage genehmigt wurde.

   python3 main.py
   

Meet REST API hinzufügen

Da der Autorisierungscode nun vollständig ist, können Sie die Funktion Meet REST API

APIs aktivieren

In diesem Abschnitt geht es um die Meet REST API. Google Cloud Pub/Sub und Google Workspace Events API

Clientbibliothek für die Meet REST API installieren

So installieren Sie die Clientbibliothek für die Meet REST API:

1. Führen Sie diesen Befehl aus:

   pip install google-apps-meet
   

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

   from google.apps import meet_v2 as meet
   

Gruppenbereich erstellen

Die Meet REST API ist jetzt verfügbar. Definieren Sie nun eine Funktion zum Erstellen einer abonnierbarer Konferenzraum.

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 Termine zu einem Besprechungsraum erhalten möchten, erstellen Sie ein Abo über die Google Workspace Events API Sie müssen außerdem eine Google Cloud Pub/Sub-Thema, das als Benachrichtigungsendpunkt dient, und App die Ereignisse empfängt.

Google Cloud Pub/Sub konfigurieren

So erstellen Sie ein Pub/Sub-Thema und abonnieren es:

Notieren Sie sich den Namen des Themas und achten Sie darauf, dass der Wert für {project} der Wert Cloud-Projekt-ID für Ihre Anwendung. Mit dem Themennamen erstellen Sie die Google Workspace-Abo.

Dienstkonto erstellen

Dienstkonto verwenden

Nachdem Sie das Dienstkonto erstellt haben, gewähren Sie sich selbst Zugriff, um die Identität des Dienstkonto.

Pub/Sub-Clientbibliothek installieren

1. Verwenden Sie pip, um die Clientbibliothek für Pub/Sub zu installieren:

   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üge main.py den folgenden Code hinzu, um eine Methode zum Abonnieren von Meet-Termine. Mit diesem Code werden alle Termine einer Besprechung abonniert Leerzeichen. Wenn Ereignisse abonniert werden, werden sie an das Pub/Sub-Thema gesendet.

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 diese verarbeiten

Fahren Sie mit der Bearbeitung von main.py fort und fügen Sie den folgenden Beispielcode hinzu. Dieser Code die Empfängerseite implementiert und die Google Cloud Pub/Sub API verwendet, um sobald sie verfügbar sind. Mit den verschiedenen Handler-Methoden werden Informationen zu den entsprechenden Ereignissen.

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 fertigstellen

Fügen Sie main.py den folgenden Code hinzu, um die Methoden zum Erstellen des Gruppenbereichs aufzurufen: Ereignisse abonnieren und warten zu können. TOPIC_NAME aktualisieren und SUBSCRIPTION_NAME Konstanten mit Ihrem eigenen Thema und Abonamen, die Sie zuvor erstellt.

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 für Ihre App, z. B. my-sample-project-191923.

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

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

2. Führen Sie das Programm aus:

   python3 main.py
   

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

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

An der Konferenz teilnehmen

Nehmen Sie über die URL an der Konferenz teil, um Ereignisse für die Anwendung zu generieren angezeigt wird. Nachdem Sie beigetreten sind, können Sie folgende Aktionen ausführen, um Trigger-Ereignisse:

• Verlassen Sie die Videokonferenz und treten Sie ihr wieder bei.
• Laden Sie andere ein oder wählen Sie sich über Ihr Telefon ein.
• Du kannst Aufzeichnungen und Transkripte aktivieren.

Jede dieser Aktivitäten generiert ein Ereignis, das die Anwendung empfängt und an die Google Cloud Console senden.

Du kannst ctrl-c verwenden, um das Programm zu unterbrechen, wenn du fertig bist.

Optional: Weitere Schritte zum Ausprobieren

Die Anwendung protokolliert grundlegende Details zu den Ereignissen. Wenn Sie mehr über die Meet REST API können Sie die Anwendung ändern, um diese zusätzlichen Aktionen.

• Verwenden Sie die People API, um zusätzliche Informationen über angemeldeten Teilnehmern
• Aufzeichnungen mit der Google Drive API herunterladen und Transkripte.
• Anstatt Transkripte aus Google Drive herunterzuladen, können Sie sie mit das strukturierte Transkript Methoden in der Meet REST API.

Optional: Bereinigung

So vermeiden Sie, dass Ihrem Google Cloud Console-Konto die Ressourcen in Rechnung gestellt werden die in dieser Anleitung verwendet werden, sollten Sie alle Ressourcen und Projekte erstellt.

So löschen Sie das Abo:

So löschen Sie das Thema:

So löschen Sie das Projekt:

Weitere Informationen

• Weitere Informationen zu den Funktionen der Google Meet REST API und finden Sie in der Referenzdokumentation.
• Weitere Informationen zum Abonnieren von Veranstaltungen mit Google Workspace Events API hinzu.
• Weitere Informationen zur Authentifizierung finden Sie unter OAuth-Zustimmungsbildschirm konfigurieren“. und wählen Sie Bereiche aus.