Générer un jeton d'authentification ARTC | AICallKit - Intelligent Media Services

Générez le jeton d'authentification ARTC requis par le SDK AICallKit pour initier un appel.

Fonctionnement

Le SDK AICallKit lance les appels d'agent IA depuis le client. Votre serveur d'application doit générer le jeton d'authentification et exposer un endpoint permettant au client de le récupérer avant chaque appel.

Procédure

Pour générer un jeton d'authentification ARTC, vous devez disposer de l'App ID et de l'AppKey de votre application ARTC.

Accédez à la console IMS et cliquez sur votre agent IA pour ouvrir sa page de détails.

Dans l'onglet Basic Information, localisez la section Workflow Configuration et notez le RTC App ID indiqué sous ARTC application.
Cliquez sur le RTC App ID pour ouvrir la console ApsaraVideo Live et obtenir l'App ID ainsi que l'AppKey.

Sur la page Application Management, cliquez sur le nom de votre application, accédez à l'onglet Basic Information, puis copiez l'App ID et l'AppKey.

Utilisez l'App ID et l'AppKey pour générer le jeton d'authentification ARTC. Le jeton se calcule comme suit.

// 1. Concatenate the fields: AppID+AppKey+ChannelID+UserID+Nonce+Timestamp
// 2. Use the SHA-256 algorithm to hash the concatenated string and generate the token.
token = sha256(AppID+AppKey+ChannelId+UserID+Nonce+timestamp)
// Example:
AppID = "abc",AppKey="abckey",ChannelID="abcChannel",UserID="abcUser",Nonce="",Timestamp=1699423634
token = sha256("abcabckeyabcChannelabcUser1699423634") = "3c9ee8d9f8734f0b7560ed8022a0590659113955819724fc9345ab8eedf84f31"

Paramètre	Description
AppID	Identifiant et clé de votre application ARTC, générés lors de la création d'une application ARTC dans la console ApsaraVideo Live. Consultez Obtenir les paramètres de développement de l'application.
AppKey
ChannelId	ID de canal défini par l'utilisateur. La valeur doit être une chaîne de caractères (string) et ne peut pas être un Long. Elle peut contenir des chiffres, des lettres majuscules et minuscules, des tirets (-) et des traits de soulignement (_), sans dépasser 64 caractères. L'hôte et les invités en co-streaming doivent utiliser le même ID de canal.
UserID	ID utilisateur défini par l'utilisateur. La valeur doit être une chaîne de caractères (string) et ne peut pas être un Long. Elle peut contenir des chiffres, des lettres majuscules et minuscules, des tirets (-) et des traits de soulignement (_), sans dépasser 64 caractères.
nonce	Le nonce peut être une chaîne vide. Nous recommandons de le laisser vide.
timestamp	Horodatage d'expiration en secondes. Nous recommandons de définir une expiration de 24 heures. Pour cela, ajoutez 86 400 (24 60 60) à l'horodatage actuel en secondes.

Génération du jeton côté serveur : générez un jeton sur votre serveur d'application à l'aide de l'un des exemples suivants.

Java

package com.example;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;
import java.util.Calendar;
import org.json.JSONObject;
public class App {
    public static String createBase64Token(String appid, String appkey, String channelid, String userid) {
        // Calculate the expiration timestamp (24 hours from now)
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.HOUR_OF_DAY, 24);
        long timestamp = calendar.getTimeInMillis() / 1000;
        // Concatenate the strings
        String stringBuilder = appid + appkey + channelid + userid + timestamp;
        // Calculate the SHA-256 hash
        String token = sha256(stringBuilder);
        // Create the JSON object
        JSONObject base64tokenJson = new JSONObject();
        base64tokenJson.put("appid", appid);
        base64tokenJson.put("channelid", channelid);
        base64tokenJson.put("userid", userid);
        base64tokenJson.put("nonce", "");
        base64tokenJson.put("timestamp", timestamp);
        base64tokenJson.put("token", token);
        // Convert the JSON object to a string and encode it in Base64
        String jsonStr = base64tokenJson.toString();
        String base64token = Base64.getEncoder().encodeToString(jsonStr.getBytes(StandardCharsets.UTF_8));
        return base64token;
    }
    private static String sha256(String input) {
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            byte[] hash = digest.digest(input.getBytes(StandardCharsets.UTF_8));
            StringBuilder hexString = new StringBuilder();
            for (byte b : hash) {
                String hex = Integer.toHexString(0xff & b);
                if (hex.length() == 1)
                    hexString.append('0');
                hexString.append(hex);
            }
            return hexString.toString();
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }
    }
    public static void main(String[] args) {
        String appid = "your_appid";
        String appkey = "your_appkey";
        String channel_id = "your_channel_id";
        String user_id = "your_user_id";
        String base64token = createBase64Token(appid, appkey, channel_id, user_id);
        System.out.println("Base64 Token: " + base64token);
    }
}

Python

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
import hashlib
import datetime
import time
import base64
import json
def create_base64_token(app_id, app_key, channel_id, user_id):
    expire = datetime.datetime.now() + datetime.timedelta(days=1)
    timestamp = int(time.mktime(expire.timetuple()))
    h = hashlib.sha256()
    h.update(str(app_id).encode('utf-8'))
    h.update(str(app_key).encode('utf-8'))
    h.update(str(channel_id).encode('utf-8'))
    h.update(str(user_id).encode('utf-8'))
    h.update(str(timestamp).encode('utf-8'))
    token = h.hexdigest()
    jsonToken = {'appid': str(app_id),
                 'channelid': str(channel_id),
                 'userid':str(user_id),
                 'nonce':'',
                 'timestamp':timestamp,
                 'token':str(token)
                }
    base64Token = base64.b64encode(json.dumps(jsonToken).encode())
    return base64Token
def main():
    app_id = 'your_appid'
    app_key = 'your_appkey'
    channel_id = 'your_channel_id'
    user_id = 'your_user_id'
    base64Token = create_base64_token(app_id, app_key, channel_id, user_id)
    print(base64Token)
if __name__ == '__main__':
    main()

Go

package main
import (
	"crypto/sha256"
	"encoding/base64"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"time"
)
func createBase64Token(appid, appkey, channelID, userID string) (string, error) {
	// Calculate the expiration timestamp (24 hours from now)
	timestamp := time.Now().Add(24 * time.Hour).Unix()
	// Concatenate the strings
	stringBuilder := appid + appkey + channelID + userID + fmt.Sprintf("%d", timestamp)
	// Calculate the SHA-256 hash
	hasher := sha256.New()
	hasher.Write([]byte(stringBuilder))
	token := hasher.Sum(nil)
	// Convert the hash to a hexadecimal string using encoding/hex
	tokenHex := hex.EncodeToString(token)
	// Create the JSON object
	tokenJSON := map[string]interface{}{
		"appid":     appid,
		"channelid": channelID,
		"userid":    userID,
		"nonce":     "",
		"timestamp": timestamp,
		"token":     tokenHex,
	}
	// Convert the JSON object to a string and encode it in Base64
	jsonBytes, err := json.Marshal(tokenJSON)
	if err != nil {
		return "", err
	}
	base64Token := base64.StdEncoding.EncodeToString(jsonBytes)
	return base64Token, nil
}
func main() {
	appid := "your_appid"
	appkey := "your_appkey"
	channelID := "your_channel_id"
	userID := "your_user_id"
	token, err := createBase64Token(appid, appkey, channelID, userID)
	if err != nil {
		fmt.Println("Error creating token:", err)
		return
	}
	fmt.Println("Base64 Token:", token)
}

Génération du jeton côté client : pendant le développement, vous pouvez générer les jetons directement sur le client plutôt que sur le serveur. Construisez un objet JSON contenant le jeton calculé ainsi que cinq paramètres : App ID, channel ID, nonce, user ID et timestamp. Encodez cet objet JSON en Base64 et transmettez-le au SDK ARTC. Incluez également un champ UserName pour faciliter le dépannage.

Important
Cette méthode incorpore votre AppKey et d'autres informations sensibles dans l'application. Réservez-la exclusivement aux tests et au développement. Ne l'utilisez jamais en production. L'exposition de votre AppKey côté client représente un risque de sécurité majeur pouvant entraîner son vol.