Intelligent Media Services:Generate an ARTC authentication token

Como funciona

O SDK do AICallKit inicia chamadas de agentes de IA a partir do cliente. O servidor da sua aplicação deve gerar o token de autenticação e expor um endpoint para que o cliente possa obtê-lo antes de cada chamada.

Procedimento

Para gerar um token de autenticação ARTC, você precisa do App ID e da AppKey da sua aplicação ARTC.

1. Acesse o console IMS e clique em seu agente de IA para abrir a página de detalhes.

   Na aba Basic Information, localize a seção Workflow Configuration e anote o RTC App ID listado em ARTC application.

2. Clique no RTC App ID para abrir o console do ApsaraVideo Live e obter o App ID e a AppKey.

   Na página Application Management, clique em nome da sua aplicação, vá para a aba Basic Information e copie o App ID e a AppKey.

3. Utilize o App ID e a AppKey para gerar o token de autenticação ARTC. O token é calculado da seguinte forma.

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

   Parâmetro	Descrição
   AppID	ID e chave da sua aplicação ARTC, gerados quando você cria uma aplicação ARTC no console do ApsaraVideo Live. Consulte Obter parâmetros de desenvolvimento da aplicação.
   AppKey
   ChannelId	ID de canal definido pelo usuário. O valor deve ser uma string e não pode ser do tipo Long. Pode conter dígitos, letras maiúsculas, letras minúsculas, hifens (-) e sublinhados (_), com limite de 64 caracteres. O anfitrião e os convidados de co-streaming devem usar o mesmo ID de canal.
   UserID	ID de usuário definido pelo usuário. O valor deve ser uma string e não pode ser do tipo Long. Pode conter dígitos, letras maiúsculas, letras minúsculas, hifens (-) e sublinhados (_), com limite de 64 caracteres.
   nonce	O nonce pode ser uma string vazia. Recomendamos deixá-lo vazio.
   timestamp	Timestamp de expiração em segundos. Recomendamos definir a expiração para 24 horas. Para configurar esse prazo, adicione 86.400 (24 60 60) ao timestamp atual em segundos.

   • Geração de token no servidor: Gere um token no servidor da sua aplicação usando um destes exemplos.

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

   • Geração de token no cliente: Durante o desenvolvimento, é possível gerar tokens diretamente no cliente em vez do servidor. Construa um objeto JSON com o token calculado e cinco parâmetros: App ID, channel ID, nonce, user ID e timestamp. Codifique o objeto JSON em Base64 e passe-o para o SDK ARTC. Inclua um campo UserName para facilitar a solução de problemas.

     Importante

     Este método incorpora sua AppKey e outras informações confidenciais na aplicação. Utilize-o apenas para testes e desenvolvimento. Não use este método em produção. Expor sua AppKey no lado do cliente representa um risco grave de segurança e pode resultar no roubo dessa credencial.