Observer des événements de réunion à l'aide de Python et de l'API REST Google Meet

Ce tutoriel explique comment utiliser l'API REST Google Meet avec l'API Google Workspace Events et Google Cloud Pub/Sub pour observer les événements dans un espace de réunion Meet et y réagir. L'application exemple enregistre le début et la fin des conférences, l'arrivée et le départ des participants, ainsi que la disponibilité des artefacts de réunion générés.

Au lieu de vous abonner à un espace de réunion spécifique, vous pouvez vous abonner à un utilisateur Meet pour recevoir des événements pour tous les espaces de réunion dont il est propriétaire ou qu'il organise. Pour en savoir plus, consultez S'abonner aux événements Google Meet dans la documentation de l'API Google Workspace Events.

Prérequis

Si vous avez besoin d'activer l'un de ces prérequis pour votre organisation, demandez à votre administrateur Google Workspace de l'activer :

• Compte Google Workspace ayant accès à Google Meet.
• Vous devez avoir accès à la création d'un projet Google Cloud.
• Python 3 est installé.
• gcloud CLI installé.

Préparer votre environnement

Cette section explique comment créer et configurer votre environnement local et le projet Google Cloud pour ce tutoriel.

Créer un répertoire de travail et un environnement virtuel Python

Pour créer et activer un nouvel environnement virtuel, exécutez les commandes suivantes dans votre 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

Créer un projet Google Cloud

Activer la facturation pour le projet Google Cloud

Configurer l'authentification et l'autorisation

L'authentification et l'autorisation permettent à l'application d'accéder aux ressources de l'API REST Meet. L'autorisation de l'utilisateur est requise pour appeler l'API REST Meet. Cette section vous explique comment configurer les identifiants utilisateur et demander une autorisation.

Configurer l'écran de consentement OAuth et choisir des habilitations

Les étapes suivantes suggèrent des informations de substitution pour configurer l'écran de consentement OAuth pour votre application. Avant de publier l'application en externe, mettez à jour ces informations.

1. Dans la console Google Cloud, accédez à Menu menu > Google Auth platform > Branding.

   Accéder à "Branding"

2. Si vous avez déjà configuré Google Auth platform, vous pouvez configurer les paramètres de l'écran d'autorisation OAuth suivants dans Branding, Audience et Accès aux données. Si le message Google Auth platform pas encore configuré s'affiche, cliquez sur Commencer :
1. Sous Informations sur l'application, dans Nom de l'application, saisissez Meet REST API Tutorial.
2. Dans Adresse e-mail d'assistance utilisateur, sélectionnez une adresse e-mail d'assistance que les utilisateurs pourront contacter s'ils ont des questions sur leur consentement.
3. Cliquez sur Suivant.
4. Sous Audience, sélectionnez Interne.
5. Cliquez sur Suivant.
6. Sous Coordonnées, saisissez une adresse e-mail à laquelle vous pourrez être informé de toute modification apportée à votre projet.
7. Cliquez sur Suivant.
8. Sous Terminer, consultez le Règlement sur les données utilisateur dans les services d'API Google et, si vous l'acceptez, sélectionnez J'accepte le Règlement sur les données utilisateur dans les services d'API Google.
9. Cliquez sur Continuer.
10. Cliquez sur Créer.
11. Si vous avez sélectionné Externe comme type d'utilisateur, ajoutez des utilisateurs de test :
    1. Cliquez sur Audience.
    2. Sous Utilisateurs de test, cliquez sur Ajouter des utilisateurs.
    3. Saisissez votre adresse e-mail et celles des autres utilisateurs de test autorisés, puis cliquez sur Enregistrer.
3. Cliquez sur Accès aux données > Ajouter ou supprimer des niveaux d'accès. Un panneau s'affiche avec la liste des niveaux d'accès pour chaque API que vous avez activée dans votre projet Google Cloud.
4. Sous Ajouter manuellement des niveaux d'accès, collez les niveaux d'accès suivants :
   • https://www.googleapis.com/auth/meetings.space.created
5. Cliquez sur Ajouter au tableau.
6. Cliquez sur Mettre à jour.
7. Après avoir sélectionné les niveaux d'accès requis par votre application, cliquez sur Enregistrer.

Pour en savoir plus sur la configuration du consentement OAuth, consultez Premiers pas avec Google Auth platform.

Créer un ID client

L'ID client sert d'identifiant pour votre application lors des flux OAuth 2.0. Étant donné que l'application s'exécute localement, créez un ID client pour ordinateur.

1. Dans la console Google Cloud, accédez à Menu menu > Google Auth platform > Clients.

   Accéder à "Clients"

2. Cliquez sur Créer un client.
3. Cliquez sur Type d'application > Application de bureau.
4. Dans le champ Nom, saisissez un nom pour l'identifiant. Ce nom n'apparaît que dans la console Google Cloud.
5. Cliquez sur Créer.

   Les identifiants que vous venez de créer s'affichent sous "ID client OAuth 2.0".

Installer les bibliothèques Google Auth

Installez les bibliothèques Google Auth :

pip install google-auth google-auth-oauthlib

Exécuter l'autorisation

L'API REST Meet nécessite des identifiants utilisateur sous la forme d'un jeton d'accès OAuth 2.0. Dans cette section, vous allez implémenter le flux OAuth 2.0 pour demander un jeton d'accès et un jeton d'actualisation pour l'utilisateur.

1. Dans votre répertoire de travail, créez le fichier main.py et ajoutez-y le contenu suivant :

   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. Pour exécuter le code, vous avez besoin de l'ID client et du code secret créés précédemment. Copiez le fichier du code secret du client téléchargé dans le répertoire de travail du projet et renommez-le client_secret.json.

3. Si vous souhaitez tester le fonctionnement de l'autorisation, exécutez la commande suivante. L'application demande une autorisation et crée un fichier token.json dans le répertoire de travail du projet une fois la demande approuvée.

   python3 main.py

Ajouter l'API Meet REST

Maintenant que le code d'autorisation est terminé, il est temps d'activer et d'appeler l'API REST Meet.

Activer les API

Bien que cette section soit axée sur l'API REST Meet, ce tutoriel utilise également l'API Google Cloud Pub/Sub et l'API Google Workspace Events.

Installer la bibliothèque cliente de l'API REST Meet

Pour installer la bibliothèque cliente de l'API REST Meet, procédez comme suit :

1. Exécutez la commande suivante :

   pip install google-apps-meet

2. Modifiez le fichier main.py pour importer le client :

   from google.apps import meet_v2 as meet
   

Créer un espace

Maintenant que l'API REST Meet est disponible, définissez une fonction pour créer un espace de réunion auquel il est possible de s'abonner.

Modifiez main.py et ajoutez :

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

S'abonner à des événements

Pour recevoir des événements concernant un espace de réunion, vous devez créer un abonnement à l'aide de l'API Google Workspace Events. Vous devez également créer un sujet Google Cloud Pub/Sub et vous y abonner. Il servira de point de terminaison de notification où votre application recevra les événements.

Configurer Google Cloud Pub/Sub

Pour créer un sujet Pub/Sub et vous y abonner :

Notez le nom du sujet et assurez-vous que la valeur de {project} correspond à l'ID du projet Cloud pour votre application. Vous utiliserez le nom du sujet pour créer l'abonnement Google Workspace ultérieurement.

Créer un compte de service

Utiliser le compte de service

Après avoir créé le compte de service, accordez-vous l'accès pour emprunter l'identité du compte de service.

Installer la bibliothèque cliente Pub/Sub

1. Utilisez pip pour installer la bibliothèque cliente pour Pub/Sub :

   pip install google-cloud-pubsub

2. Modifiez ensuite main.py pour importer le client :

   from google.cloud import pubsub_v1
   

Créer l'abonnement Google Workspace

Ajoutez le code suivant à main.py pour définir une méthode d'abonnement aux événements Meet. Ce code s'abonne à tous les événements d'un espace de réunion. Une fois l'abonnement souscrit, les événements sont publiés dans le sujet 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

Ajoutez ensuite le code correspondant pour extraire et traiter les événements.

Écouter et gérer les événements

Continuez à modifier main.py et ajoutez l'exemple de code suivant. Ce code implémente le côté réception et utilise l'API Google Cloud Pub/Sub pour extraire les événements à mesure qu'ils sont disponibles. Les différentes méthodes de gestionnaire affichent des informations sur les événements correspondants.

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

Finaliser le code

Ajoutez le code suivant à main.py pour appeler les méthodes permettant de créer l'espace, de s'abonner aux événements et d'écouter. Mettez à jour les constantes TOPIC_NAME et SUBSCRIPTION_NAME avec vos propres noms de thème et d'abonnement que vous avez créés précédemment.

1. Ajoutez le code à 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)
   if (subscription.status_code) == 200:
       listen_for_events(subscription_name=SUBSCRIPTION_NAME)
   else:
       print(f"Subscription to Meet events failed, response data: {subscription.content}")
   

   Remplacez les éléments suivants :

   • PROJECT_ID : ID unique du projet Cloud pour votre application, tel que my-sample-project-191923.

   • TOPIC_ID : nom du sujet Pub/Sub que vous avez créé dans votre projet Cloud.

   • SUBSCRIPTION_ID : nom de votre abonnement, tel que workspace-events-sub.

2. Exécutez le programme :

   python3 main.py

Si vous n'avez jamais exécuté le programme, il vous demandera une autorisation la première fois. Accorder l'accès à l'application pour appeler l'API REST Meet Une fois le programme exécuté, un résultat semblable à celui-ci devrait s'afficher :

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

Participer à la conférence

Pour générer des événements pour l'application, rejoignez la conférence à l'aide de l'URL affichée par l'application. Une fois que vous avez rejoint le canal, vous pouvez essayer les actions suivantes pour déclencher des événements :

• Quittez la réunion, puis rejoignez-la à nouveau.
• Invitez d'autres personnes ou rejoignez la réunion par téléphone.
• Activez les enregistrements et les transcriptions.

Chacune de ces activités génère un événement que l'application reçoit et consigne dans la console Google Cloud.

Utilisez ctrl-c pour interrompre le programme lorsque vous avez terminé.

Facultatif : Autres solutions

L'application enregistre des informations de base sur les événements. Pour continuer à explorer l'API REST Meet, essayez de modifier l'application pour effectuer ces actions supplémentaires.

• Utilisez l'API People pour récupérer des informations supplémentaires sur les participants connectés.

  def subscribe_to_user(user_name: str = None, topic_name: str = None) -> requests_lib.Response:
      """Subscribe to events for a user."""
      session = requests.AuthorizedSession(USER_CREDENTIALS)
      body = {
          "targetResource": f"//cloudidentity.googleapis.com/users/{user_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
  
  service = build("people", "v1", credentials=USER_CREDENTIALS)
  response = (
      service.people()
      .get(resourceName="people/me", personFields="names,emailAddresses")
      .execute()
  )
  resource_name = response.get("resourceName")
  if resource_name.startswith("people/"):
      resource_name = resource_name[len("people/") :]
  
  subscription = subscribe_to_user(topic_name=TOPIC_NAME, user_name=resource_name)
  

  Veillez à ajouter "https://www.googleapis.com/auth/userinfo.profile" dans la méthode d'autorisation des exemples d'identifiants ci-dessus.

• Utilisez l'API Google Drive pour télécharger les enregistrements et les transcriptions.

• Au lieu de télécharger les transcriptions depuis Google Drive, récupérez-les à l'aide des méthodes de transcription structurée de l'API REST Meet.

• obtenir un espace au lieu de le créer.

  def get_space(meeting_code: str) -> meet.Space:
      """Get a meeting space."""
      client = meet.SpacesServiceClient(credentials=USER_CREDENTIALS)
      return client.get_space(name="spaces/" + meeting_code)
  

  Veillez à ajouter "https://www.googleapis.com/auth/meetings.space.readonly" dans la méthode d'autorisation des exemples d'identifiants ci-dessus.

Facultatif : Effectuer un nettoyage

Pour éviter que les ressources utilisées dans ce tutoriel ne soient facturées sur votre compte de la console Google Cloud, nous vous recommandons de supprimer les ressources et les projets créés.

Pour supprimer l'abonnement :

Pour supprimer le thème :

Pour supprimer le projet :

Articles associés

• Découvrez les types d'événements Meet auxquels vous pouvez vous abonner.
• Découvrez ce que l'API REST Google Meet peut faire et consultez la documentation de référence.
• Créez un abonnement Google Workspace aux espaces de réunion ou aux utilisateurs Meet à l'aide de l'API Google Workspace Events.
• Pour en savoir plus sur l'authentification, consultez Configurer l'écran de consentement OAuth et choisir des habilitations.