Amazon Chime SDK

Une suite d'outils puissante et flexible pour intégrer du chat, de la visioconférence et des appels audio dans vos applications avec une qualité professionnelle.

Retour aux compétences Documentation officielle

Pour les non-initiés

Qu'est-ce qu'Amazon Chime SDK ?

Imaginez que vous souhaitiez ajouter des fonctionnalités de communication en temps réel dans votre application ou site web : chat, appels audio, visioconférence, partage d'écran... Traditionnellement, cela nécessiterait des mois de développement et une infrastructure complexe à maintenir.

Amazon Chime SDK est comme une boîte à outils complète qui vous permet d'intégrer facilement ces fonctionnalités dans vos propres applications. Plutôt que de construire un système de communication de zéro, vous utilisez des briques préfabriquées de haute qualité.

Pourquoi utiliser Chime SDK ?

Expérience utilisateur transparente

Intègre des communications de haute qualité directement dans vos applications, offrant une expérience fluide à vos utilisateurs.

Gain de temps et d'argent

Évite des mois de développement et d'infrastructure complexe en utilisant des composants éprouvés, avec un paiement à l'usage.

En résumé, Amazon Chime SDK permet à n'importe quelle entreprise d'offrir des expériences de communication en temps réel de qualité professionnelle, sans avoir à développer et maintenir l'infrastructure sous-jacente.

Pour les développeurs

Fonctionnement technique

Amazon Chime SDK est une suite de composants permettant d'intégrer des fonctionnalités de communication en temps réel dans vos applications. Il est divisé en plusieurs parties principales qui peuvent être utilisées indépendamment ou ensemble.

Principales composantes

Chime SDK Meetings

Permet d'intégrer des fonctionnalités de visioconférence, d'audio et de partage d'écran dans vos applications à l'aide de WebRTC. Le backend gère la création de réunions et de participants, tandis que les bibliothèques client gèrent l'interface utilisateur et la gestion des médias.

Création d'une réunion avec l'API Meetings

// Création d'une réunion avec AWS Chime SDK
const { ChimeSDKMeetingsClient, CreateMeetingCommand } = require("@aws-sdk/client-chime-sdk-meetings");

// Créer un client Chime SDK Meetings
const chimeClient = new ChimeSDKMeetingsClient({ region: "us-east-1" });

async function createMeeting() {
  try {
    // Configurer les options de la réunion
    const params = {
      ClientRequestToken: Date.now().toString(), // Jeton unique pour l'idempotence
      MediaRegion: "eu-central-1", // Région la plus proche des participants
      ExternalMeetingId: "MeetingRoom-12345", // ID externe pour référence
      MeetingFeatures: {
        Audio: {
          EchoReduction: "ENABLED" // Réduction d'écho
        },
        Video: {
          MaxResolution: "FHD" // Résolution Full HD
        },
        Content: {
          MaxResolution: "FHD" // Résolution Full HD pour le partage de contenu
        }
      },
      NotificationsConfiguration: {
        SnsTopicArn: "arn:aws:sns:us-east-1:123456789012:ChimeMeetingNotifications",
        SqsQueueArn: "arn:aws:sqs:us-east-1:123456789012:ChimeMeetingEvents"
      },
      Tags: [
        {
          Key: "Department",
          Value: "Sales"
        },
        {
          Key: "Purpose",
          Value: "ClientDemo"
        }
      ]
    };

    // Créer la réunion
    const data = await chimeClient.send(new CreateMeetingCommand(params));
    console.log("Réunion créée avec succès :", data);

    // Renvoyer les informations de la réunion
    return {
      meetingId: data.Meeting.MeetingId,
      mediaPlacement: data.Meeting.MediaPlacement,
      mediaRegion: data.Meeting.MediaRegion,
      meetingArn: data.Meeting.MeetingArn
    };
  } catch (err) {
    console.error("Erreur lors de la création de la réunion :", err);
    throw err;
  }
}

Une fois la réunion créée, vous pouvez y ajouter des participants :

Ajout d'un participant à une réunion

// Création d'un participant pour une réunion
const { ChimeSDKMeetingsClient, CreateAttendeeCommand } = require("@aws-sdk/client-chime-sdk-meetings");

// Créer un client Chime SDK Meetings
const chimeClient = new ChimeSDKMeetingsClient({ region: "us-east-1" });

async function createAttendee(meetingId, externalUserId) {
  try {
    // Configurer les paramètres du participant
    const params = {
      MeetingId: meetingId,
      ExternalUserId: externalUserId, // ID unique de l'utilisateur dans votre système
      Capabilities: {
        Audio: "SendReceive", // Peut envoyer et recevoir de l'audio
        Video: "SendReceive", // Peut envoyer et recevoir de la vidéo
        Content: "SendReceive"  // Peut partager son écran
      },
      Tags: [
        {
          Key: "Role",
          Value: "Presenter"
        }
      ]
    };

    // Créer le participant
    const data = await chimeClient.send(new CreateAttendeeCommand(params));
    console.log("Participant créé avec succès :", data);

    // Renvoyer les informations du participant
    return {
      attendeeId: data.Attendee.AttendeeId,
      joinToken: data.Attendee.JoinToken,
      externalUserId: data.Attendee.ExternalUserId
    };
  } catch (err) {
    console.error("Erreur lors de la création du participant :", err);
    throw err;
  }
}

Intégration frontend

Pour intégrer les réunions dans votre application frontend, vous utilisez généralement une bibliothèque cliente comme amazon-chime-sdk-js. Elle gère la connectivité WebRTC, l'envoi et la réception d'audio et de vidéo, et fournit des hooks pour personnaliser l'expérience utilisateur. C'est particulièrement facile à intégrer avec React et Next.js.

Intégration frontend avec React

// Intégration frontend avec le SDK Chime pour le navigateur
import React, { useEffect, useState, useRef } from 'react';
import {
  ConsoleLogger,
  DefaultDeviceController,
  DefaultMeetingSession,
  LogLevel,
  MeetingSessionConfiguration
} from 'amazon-chime-sdk-js';

const VideoConference = ({ meetingData, attendeeData, username }) => {
  const [isMeetingStarted, setIsMeetingStarted] = useState(false);
  const [isMuted, setIsMuted] = useState(false);
  const [isVideoEnabled, setIsVideoEnabled] = useState(false);
  
  // Références pour les éléments DOM
  const videoRef = useRef(null);
  const meetingRef = useRef(null);
  const tileIdRef = useRef(null);

  // Configuration et démarrage de la réunion
  useEffect(() => {
    const startMeeting = async () => {
      try {
        // Créer une configuration de session de réunion avec les données reçues du backend
        const configuration = new MeetingSessionConfiguration(
          meetingData,
          attendeeData
        );

        // Configurer la journalisation
        const logger = new ConsoleLogger('ChimeMeetingLogs', LogLevel.INFO);
        
        // Créer un contrôleur de périphérique
        const deviceController = new DefaultDeviceController(logger);
        
        // Initialiser la session de réunion
        const meetingSession = new DefaultMeetingSession(
          configuration,
          logger,
          deviceController
        );
        
        // Stocker la référence pour une utilisation ultérieure
        meetingRef.current = meetingSession;
        
        // Observer les changements de tuiles vidéo
        meetingSession.audioVideo.addVideoTileObserver({
          videoTileDidUpdate: (tileState) => {
            if (!tileState.isContent && !tileState.localTile) {
              // Afficher la vidéo d'un participant distant
              meetingSession.audioVideo.bindVideoElement(
                tileState.tileId,
                videoRef.current
              );
            } else if (tileState.localTile) {
              // Stocker l'ID de tuile locale pour référence
              tileIdRef.current = tileState.tileId;
            }
          },
          videoTileWasRemoved: (tileId) => {
            // Gérer la suppression de tuile vidéo
            console.log(`La tuile vidéo ${tileId} a été supprimée`);
          }
        });
        
        // Démarrer les dispositifs audio et vidéo
        await meetingSession.audioVideo.startAudioInput(
          await meetingSession.audioVideo.listAudioInputDevices()[0].deviceId
        );
        
        // Se connecter à la réunion
        meetingSession.audioVideo.start();
        
        // Marquer la réunion comme démarrée
        setIsMeetingStarted(true);
      } catch (error) {
        console.error('Erreur lors du démarrage de la réunion :', error);
      }
    };

    if (meetingData && attendeeData) {
      startMeeting();
    }

    // Nettoyage lors du démontage du composant
    return () => {
      if (meetingRef.current) {
        meetingRef.current.audioVideo.stop();
      }
    };
  }, [meetingData, attendeeData]);

  // Gérer l'activation/désactivation de la vidéo
  const toggleVideo = async () => {
    if (!meetingRef.current) return;
    
    if (!isVideoEnabled) {
      try {
        // Démarrer la vidéo
        await meetingRef.current.audioVideo.startVideoInput(
          await meetingRef.current.audioVideo.listVideoInputDevices()[0].deviceId
        );
        meetingRef.current.audioVideo.startLocalVideoTile();
        setIsVideoEnabled(true);
      } catch (err) {
        console.error('Erreur lors de l\'activation de la vidéo :', err);
      }
    } else {
      // Arrêter la vidéo
      meetingRef.current.audioVideo.stopVideoInput();
      meetingRef.current.audioVideo.stopLocalVideoTile();
      setIsVideoEnabled(false);
    }
  };

  // Gérer l'activation/désactivation du microphone
  const toggleMute = () => {
    if (!meetingRef.current) return;
    
    if (isMuted) {
      meetingRef.current.audioVideo.realtimeUnmuteLocalAudio();
      setIsMuted(false);
    } else {
      meetingRef.current.audioVideo.realtimeMuteLocalAudio();
      setIsMuted(true);
    }
  };

  // Quitter la réunion
  const leaveMeeting = () => {
    if (meetingRef.current) {
      meetingRef.current.audioVideo.stop();
      setIsMeetingStarted(false);
    }
  };

  return (
    <div className="video-conference-container">
      <h2>Réunion: {meetingData?.ExternalMeetingId || "Sans titre"}</h2>
      <p>Participant: {username}</p>
      
      {/* Affichage de la vidéo */}
      <div className="video-container">
        <video ref={videoRef} width="640" height="480" />
      </div>
      
      {/* Contrôles de la réunion */}
      <div className="meeting-controls">
        <button onClick={toggleMute}>
          {isMuted ? "Activer le micro" : "Couper le micro"}
        </button>
        <button onClick={toggleVideo}>
          {isVideoEnabled ? "Désactiver la caméra" : "Activer la caméra"}
        </button>
        <button onClick={leaveMeeting}>Quitter la réunion</button>
      </div>
    </div>
  );
};

export default VideoConference;

Chime SDK Messaging

Fournit des fonctionnalités de messagerie en temps réel et persistante pour vos applications. Vous pouvez créer des canaux de discussion, gérer des membres et envoyer/recevoir des messages avec différents types de contenus.

Implémentation de messagerie avec Chime SDK

// Implémentation de messagerie avec AWS Chime SDK Messaging
const { 
  ChimeSDKMessagingClient, 
  CreateChannelCommand,
  CreateChannelMembershipCommand,
  ListChannelMembershipsCommand,
  SendChannelMessageCommand
} = require('@aws-sdk/client-chime-sdk-messaging');

// Créer un client Chime SDK Messaging
const messagingClient = new ChimeSDKMessagingClient({ region: 'us-east-1' });

// Créer un canal de discussion
async function createChannel(appInstanceArn, name, description, moderatorArn) {
  try {
    const params = {
      AppInstanceArn: appInstanceArn,
      Name: name,
      Mode: 'UNRESTRICTED', // ou 'RESTRICTED' pour les canaux privés
      Privacy: 'PUBLIC', // ou 'PRIVATE'
      ChannelType: 'STANDARD', // type de canal standard
      Description: description,
      ModeratorArn: moderatorArn, // ARN de l'utilisateur qui sera modérateur
      ChimeBearer: moderatorArn // L'utilisateur qui crée le canal
    };

    const data = await messagingClient.send(new CreateChannelCommand(params));
    console.log('Canal créé avec succès:', data.ChannelArn);
    return data.ChannelArn;
  } catch (err) {
    console.error('Erreur lors de la création du canal:', err);
    throw err;
  }
}

// Ajouter un membre au canal
async function addMemberToChannel(channelArn, memberArn, moderatorArn) {
  try {
    const params = {
      ChannelArn: channelArn,
      MemberArn: memberArn,
      Type: 'DEFAULT', // ou 'HIDDEN' pour les membres cachés
      ChimeBearer: moderatorArn
    };

    const data = await messagingClient.send(new CreateChannelMembershipCommand(params));
    console.log('Membre ajouté avec succès:', memberArn);
    return data;
  } catch (err) {
    console.error('Erreur lors de l\'ajout du membre:', err);
    throw err;
  }
}

// Lister les membres d'un canal
async function listChannelMembers(channelArn, userArn) {
  try {
    const params = {
      ChannelArn: channelArn,
      MaxResults: 100,
      ChimeBearer: userArn
    };

    const data = await messagingClient.send(new ListChannelMembershipsCommand(params));
    console.log('Membres du canal:', data.ChannelMemberships);
    return data.ChannelMemberships;
  } catch (err) {
    console.error('Erreur lors de la récupération des membres:', err);
    throw err;
  }
}

// Envoyer un message dans un canal
async function sendMessage(channelArn, content, senderArn, metadata = null) {
  try {
    const params = {
      ChannelArn: channelArn,
      Content: content,
      Type: 'STANDARD', // type de message standard
      Persistence: 'PERSISTENT', // ou 'NON_PERSISTENT' pour les messages éphémères
      ChimeBearer: senderArn
    };

    if (metadata) {
      params.Metadata = metadata;
    }

    const data = await messagingClient.send(new SendChannelMessageCommand(params));
    console.log('Message envoyé avec succès, ID:', data.MessageId);
    return data.MessageId;
  } catch (err) {
    console.error('Erreur lors de l\'envoi du message:', err);
    throw err;
  }
}

// Exemple d'utilisation
async function setupGroupChat() {
  const appInstanceArn = 'arn:aws:chime:us-east-1:123456789012:app-instance/abcdef12-3456-7890-abcd-ef1234567890';
  const adminArn = 'arn:aws:chime:us-east-1:123456789012:app-instance/abcdef12-3456-7890-abcd-ef1234567890/user/admin';
  const user1Arn = 'arn:aws:chime:us-east-1:123456789012:app-instance/abcdef12-3456-7890-abcd-ef1234567890/user/user1';
  const user2Arn = 'arn:aws:chime:us-east-1:123456789012:app-instance/abcdef12-3456-7890-abcd-ef1234567890/user/user2';

  try {
    // Créer un canal de discussion
    const channelArn = await createChannel(
      appInstanceArn, 
      'Projet Marketing 2023',
      'Canal de discussion pour le projet marketing Q2 2023',
      adminArn
    );

    // Ajouter des membres
    await addMemberToChannel(channelArn, user1Arn, adminArn);
    await addMemberToChannel(channelArn, user2Arn, adminArn);

    // Lister les membres
    const members = await listChannelMembers(channelArn, adminArn);

    // Envoyer un message de bienvenue
    await sendMessage(
      channelArn,
      'Bienvenue dans le canal de discussion du projet Marketing 2023!',
      adminArn,
      JSON.stringify({ importance: 'high', notification: true })
    );

    return {
      channelArn,
      members
    };
  } catch (err) {
    console.error('Erreur lors de la configuration du chat de groupe:', err);
    throw err;
  }
}

Chime SDK Voice & PSTN

Permet d'intégrer des fonctionnalités de téléphonie traditionnelle dans vos applications, comme passer des appels vers des numéros de téléphone réels, recevoir des appels, et créer des systèmes IVR (réponse vocale interactive).

Communication téléphonique avec Chime SDK Voice

// Communication via PSTN (téléphonie) avec AWS Chime SDK Voice
const { 
  ChimeSDKVoiceClient, 
  CreateSipMediaApplicationCallCommand 
} = require('@aws-sdk/client-chime-sdk-voice');

// Créer un client Chime SDK Voice
const voiceClient = new ChimeSDKVoiceClient({ region: 'us-east-1' });

// Passer un appel téléphonique sortant
async function makeOutboundCall(sipMediaApplicationId, phoneNumber, callerIdNumber, username) {
  try {
    // Configuration de l'appel
    const params = {
      SipMediaApplicationId: sipMediaApplicationId,
      FromPhoneNumber: callerIdNumber, // Numéro d'affichage pour l'appelant
      ToPhoneNumber: phoneNumber, // Numéro à appeler
      ArgumentsMap: {
        // Métadonnées supplémentaires pour l'application SIP
        username: username,
        callType: 'outbound',
        purpose: 'customer_service',
        timestamp: new Date().toISOString()
      }
    };

    // Initier l'appel
    const data = await voiceClient.send(new CreateSipMediaApplicationCallCommand(params));
    console.log('Appel sortant initié avec succès, ID:', data.SipMediaApplicationCall.TransactionId);
    return {
      callId: data.SipMediaApplicationCall.TransactionId,
      status: 'initiated'
    };
  } catch (err) {
    console.error('Erreur lors de l\'initiation de l\'appel:', err);
    throw err;
  }
}

// Exemple d'utilisation
async function callCustomer() {
  // ID de l'application SIP Media configurée dans AWS Chime SDK Voice
  const sipMediaApplicationId = 'abcdef12-3456-7890-abcd-ef1234567890';
  
  // Numéro à partir duquel l'appel sera passé (doit être réclamé dans la console AWS)
  const callerIdNumber = '+14155552671';
  
  // Numéro du client à appeler
  const customerNumber = '+33123456789';
  
  // Nom de l'agent qui initie l'appel
  const agentName = 'Sophie Martin';
  
  try {
    const callResult = await makeOutboundCall(
      sipMediaApplicationId,
      customerNumber,
      callerIdNumber,
      agentName
    );
    
    console.log(`Appel vers ${customerNumber} initié par ${agentName}:`, callResult);
    return callResult;
  } catch (err) {
    console.error('Erreur lors de l\'appel au client:', err);
    throw err;
  }
}

Services complémentaires

Transcription en temps réel - Intégration avec Amazon Transcribe pour convertir l'audio en texte pendant les réunions
Traduction en temps réel - Utilisation d'Amazon Translate pour traduire les messages ou transcriptions
Analyses et métriques - Collecte de métriques de qualité d'appel et d'usage pour optimiser l'expérience, exportables vers Datadog ou d'autres solutions d'analyse
Enregistrement - Capture des flux audio, vidéo et de partage d'écran pour une consultation ultérieure dans S3
Applications Media Insights - Traitement des événements audio et vidéo pour des cas d'usage avancés comme l'analyse sentimentale avec Amazon Comprehend

Applications concrètes

Cas d'usage

Télésanté

Applications permettant aux professionnels de santé de consulter leurs patients à distance avec vidéo HD, partage de documents et messagerie sécurisée, tout en respectant la conformité réglementaire.

Centres de contact virtuels

Solutions de service client omnicanal intégrant appels téléphoniques, vidéo, chat et partage d'écran pour une assistance client de qualité supérieure et personnalisée.

Éducation en ligne

Plateformes d'apprentissage virtuel avec cours en direct, salles de classe virtuelles, collaboration en temps réel et sessions en petits groupes pour une expérience pédagogique immersive.

Applications de collaboration

Outils de travail d'équipe intégrant messagerie, réunions vidéo, partage de fichiers et tableaux blancs virtuels pour améliorer la productivité des équipes distantes.

Avantages clés de Chime SDK

Déploiement mondial

Paiement à l'usage

Haute disponibilité

Extensible

Sécurisé

Personnalisable

Multi-plateforme

API robustes

Évolutif

Ressources complémentaires

Toutes les compétences

Technologies associées

Amazon Chime SDK

Qu'est-ce qu'Amazon Chime SDK ?

Pourquoi utiliser Chime SDK ?

Expérience utilisateur transparente

Gain de temps et d'argent

Fonctionnement technique

Principales composantes

Chime SDK Meetings

Intégration frontend

Chime SDK Messaging

Chime SDK Voice & PSTN

Services complémentaires

Cas d'usage

Télésanté

Centres de contact virtuels

Éducation en ligne

Applications de collaboration

Avantages clés de Chime SDK

Ressources complémentaires

Documentation officielle

SDK JavaScript

Exemples d'utilisation

Technologies associées

AWS Lambda

AWS S3

AWS Transcribe

AWS Polly

AWS Comprehend

React

Next.js

API Gateway