Enregistrer un appel au démarrage

2023-10-26

L’enregistrement des appels est souvent utilisé directement via l’interface utilisateur d’une application appelante, où l’utilisateur déclenche l’enregistrement. Pour les applications au sein de secteurs comme les banques ou les soins de santé, l’enregistrement des appels est requis à partir du get-go. Le service doit enregistrer automatiquement à des fins de conformité. Cet exemple montre comment enregistrer un appel au démarrage. Il utilise Azure Communication Services et Azure Event Grid pour déclencher une fonction Azure au démarrage d’un appel. Il enregistre automatiquement chaque appel dans votre ressource Azure Communication Services.

Dans ce guide de démarrage rapide, nous nous concentrons sur la présentation du traitement des événements démarrés par les appels via Azure Functions à l’aide de déclencheurs Event Grid. Nous utilisons le Kit de développement logiciel (SDK) Call Automation pour Azure Communication Services pour démarrer l’enregistrement.

Événement Call Started lorsqu’un démarrage d’appel est mis en forme de la façon suivante :


[
  {
    "id": "a8bcd8a3-12d7-46ba-8cde-f6d0bda8feeb",
    "topic": "/subscriptions/{subscription-id}/resourcegroups/{group-name}/providers/microsoft.communication/communicationservices/{communication-services-resource-name}",
    "subject": "call/{serverCallId}/startedBy/8:acs:bc360ba8-d29b-4ef2-b698-769ebef85521_0000000c-1fb9-4878-07fd-0848220077e1",
    "data": {
      "startedBy": {
        "communicationIdentifier": {
          "rawId": "8:acs:bc360ba8-d29b-4ef2-b698-769ebef85521_0000000c-1fb9-4878-07fd-0848220077e1",
          "communicationUser": {
            "id": "8:acs:bc360ba8-d29b-4ef2-b698-769ebef85521_0000000c-1fb9-4878-07fd-0848220077e1"
          }
        },
        "role": "{role}"
      },
      "serverCallId": "{serverCallId}",
      "group": {
        "id": "00000000-0000-0000-0000-000000000000"
      },
      "room": {
        "id": "{roomId}"
      },
      "isTwoParty": false,
      "correlationId": "{correlationId}",
      "isRoomsCall": true
    },
    "eventType": "Microsoft.Communication.CallStarted",
    "dataVersion": "1.0",
    "metadataVersion": "1",
    "eventTime": "2021-09-22T17:02:38.6905856Z"
  }
]

Remarque

L’utilisation d’Azure Event Grid entraîne des coûts supplémentaires. Pour plus d’informations, consultez Tarification Azure Event Grid.

Conditions préalables

Compte Azure avec un abonnement actif. Créez un compte gratuitement.
Une ressource Communication Services active et la chaîne de connexion. Créer une ressource Communication Services
Installez Azure CLI.

Configuration de notre environnement local

Installez l’extension Azure Functions en utilisant Visual Studio Code.

Créez une fonction Azure avec l’extension Azure en suivant ces instructions.

Configurez la fonction à l’aide des instructions suivantes :

Langage : C#
Modèle : déclencheur Azure Event Grid
Nom de la fonction : défini par l’utilisateur

Une fois créée, vous voyez une fonction créée dans votre répertoire comme suit :


using System;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.EventGrid;
using Microsoft.Extensions.Logging;
using Azure.Messaging.EventGrid;
using System.Threading.Tasks;

namespace Company.Function
{
    public static class acs_recording_test
    {
        [FunctionName("acs_recording_test")]
        public static async Task RunAsync([EventGridTrigger]EventGridEvent eventGridEvent, ILogger log)
        {
            log.LogInformation(eventGridEvent.EventType);
        }

    }
}

Configurer Azure Function pour recevoir `CallStarted` un événement

Configurez Azure Function pour effectuer des actions lorsque l’événement CallStarted se déclenche.


    public static async Task RunAsync([EventGridTrigger]EventGridEvent eventGridEvent, ILogger log)
    {
        if(eventGridEvent.EventType == "Microsoft.Communication.CallStarted")
        {
            log.LogInformation("Call started");
            var callEvent = eventGridEvent.Data.ToObjectFromJson<CallStartedEvent>();
            
            // CallStartedEvent class is defined in documentation, but the objects looks like this:
            // public class CallStartedEvent
            // {
            //     public StartedBy startedBy { get; set; }
            //     public string serverCallId { get; set; }
            //     public Group group { get; set; }
            //     public bool isTwoParty { get; set; }
            //     public string correlationId { get; set; }
            //     public bool isRoomsCall { get; set; }
            // }
            // public class Group
            // {
            //     public string id { get; set; }
            // }
            // public class StartedBy
            // {
            //     public CommunicationIdentifier communicationIdentifier { get; set; }
            //     public string role { get; set; }
            // }
            // public class CommunicationIdentifier
            // {
            //     public string rawId { get; set; }
            //     public CommunicationUser communicationUser { get; set; }
            // }
            // public class CommunicationUser
            // {
            //     public string id { get; set; }
            // }
        }
    }

Démarrer l’enregistrement

Créez une méthode pour gérer les CallStarted événements. Cette méthode déclenche l’enregistrement pour démarrer lors du démarrage de l’appel.


    public static async Task RunAsync([EventGridTrigger]EventGridEvent eventGridEvent, ILogger log)
    {
        if(eventGridEvent.EventType == "Microsoft.Communication.CallStarted")
        {
            log.LogInformation("Call started");
            var callEvent = eventGridEvent.Data.ToObjectFromJson<CallStartedEvent>();
            await startRecordingAsync(callEvent.serverCallId);
        }
    }

    public static async Task startRecordingAsync (String serverCallId)
    {
        CallAutomationClient callAutomationClient = new CallAutomationClient(Environment.GetEnvironmentVariable("ACS_CONNECTION_STRING"));
        StartRecordingOptions recordingOptions = new StartRecordingOptions(new ServerCallLocator(serverCallId));
        recordingOptions.RecordingChannel = RecordingChannel.Mixed;
        recordingOptions.RecordingContent = RecordingContent.AudioVideo;
        recordingOptions.RecordingFormat = RecordingFormat.Mp4;        
        var startRecordingResponse = await callAutomationClient.GetCallRecording()
            .StartRecordingAsync(recordingOptions).ConfigureAwait(false);
    }

Exécution locale

Pour exécuter la fonction localement, vous pouvez appuyer F5 sur Visual Studio Code. Nous utilisons ngrok pour connecter notre fonction Azure en cours d’exécution locale à Azure Event Grid.

Une fois la fonction en cours d’exécution, nous configurons ngrok. (Vous devez télécharger ngrok pour votre environnement.)
```
 ngrok http 7071
```
Copiez le lien ngrok fourni dans l’emplacement d’exécution de votre fonction.
Configurez des événements CallStarted via Event Grid dans votre ressource Azure Communication Services. Nous l’effectuons en tirant parti d’Azure CLI. Vous avez besoin de l’ID de ressource de votre ressource Azure Communication Services qui se trouve dans le Portail Azure. (L’ID de ressource ressemble à ceci : /subscriptions/<<AZURE SUBSCRIPTION ID>>/resourceGroups/<<RESOURCE GROUP NAME>>/providers/Microsoft.Communication/CommunicationServices/<<RESOURCE NAME>>)
```
az eventgrid event-subscription create --name "<<EVENT_SUBSCRIPTION_NAME>>" --endpoint-type webhook --endpoint "<<NGROK URL>>/runtime/webhooks/EventGrid?functionName=<<FUNCTION NAME>> " --source-resource-id "<<RESOURCE_ID>>"  --included-event-types Microsoft.Communication.CallStarted
```
Maintenant que tout est branché, testez le flux en démarrant un appel sur votre ressource. Vous devez voir les journaux de console sur votre terminal où la fonction est en cours d’exécution. Vous pouvez case activée que l’enregistrement commence à l’aide de la fonctionnalité d’enregistrement d’appel sur le Kit de développement logiciel (SDK) appelant et case activée pour que la valeur booléenne tourne TRUE.

Déployer sur Azure

Pour déployer Fonction Azure sur Azure, vous devez suivre ces instructions. Une fois déployée, nous configurons Event Grid pour la ressource Azure Communication Services. Avec l’URL de la fonction Azure déployée (URL trouvée dans le Portail Azure sous la fonction), nous exécutons une commande similaire :


az eventgrid event-subscription update --name "<<EVENT_SUBSCRIPTION_NAME>>" --endpoint-type azurefunction --endpoint "<<AZ FUNCTION URL>> " --source-resource-id "<<RESOURCE_ID>>"

Étant donné que nous mettons à jour l’abonnement aux événements que nous avons créé, veillez à utiliser le même nom d’abonnement d’événement que celui que vous avez utilisé à l’étape précédente.

Vous pouvez tester en démarrant un appel dans votre ressource, comme à l’étape précédente.

Partager via