ApsaraVideo Live:Otentikasi token

Pembuatan sisi server (disarankan)

Alibaba Cloud menyediakan contoh kode untuk Go, Java, Python, dan bahasa lainnya. Lihat Contoh kode pembuatan token.

Pembuatan sisi client (hanya untuk pengembangan dan debugging)

Selama pengembangan dan debugging, jika server aplikasi Anda belum menghasilkan token, Anda dapat sementara waktu menghasilkannya di sisi client dengan mengacu pada logika APIExample. Kode contoh:

Hasilkan token di client Android: Android/ARTCExample/KeyCenter/src/main/java/com/aliyun/artc/api/keycenter/ARTCTokenHelper.java

Hasilkan token di client iOS: iOS/ARTCExample/Common/ARTCTokenHelper.swift

Bergabung ke channel dengan token

Gunakan token untuk bergabung ke channel di client Android: Android/ARTCExample/QuickStart/src/main/java/com/aliyun/artc/api/quickstart/TokenGenerate/TokenGenerateActivity.java
Gunakan token untuk bergabung ke channel di client iOS: iOS/ARTCExample/QuickStart/TokenGenerate/TokenGenerateVC.swift

Alur kerja token

1. Client meminta token dari server aplikasi. Server aplikasi menghasilkan token berdasarkan aturan yang ditentukan dan mengembalikannya.

2. Client menggunakan token, AppID, ID channel, ID pengguna, dan informasi lainnya untuk bergabung ke channel yang ditentukan.

3. Layanan ARTC Alibaba Cloud memvalidasi token tersebut sehingga client diperbolehkan bergabung ke channel.

Pembuatan token

Tabel berikut menjelaskan parameter yang digunakan untuk menghasilkan token.

Contoh proses pembuatan token:

Contoh kode pembuatan token:

// 1. Gabungkan bidang-bidang: AppID+AppKey+ChannelID+UserID+Nonce+Timestamp
// 2. Gunakan algoritma SHA-256 untuk meng-hash string yang digabungkan dan menghasilkan token.
token = sha256(AppID+AppKey+ChannelId+UserID+Nonce+timestamp)
// Contoh:
AppID = "abc",AppKey="abckey",ChannelID="abcChannel",UserID="abcUser",Nonce="",Timestamp=1699423634
token = sha256("abcabckeyabcChannelabcUser1699423634") = "3c9ee8d9f8734f0b7560ed8022a0590659113955819724fc9345ab8eedf84f31"

Metode parameter tunggal (disarankan)

SDK ARTC menyediakan API satu parameter untuk bergabung ke channel. Pendekatan ini mencegah kegagalan bergabung akibat ketidakkonsistenan parameter antara server aplikasi dan client. Kemas token, appid, channelid, nonce, userid, dan timestamp ke dalam objek JSON, lalu encode string JSON tersebut dengan Base64 untuk membuat string otentikasi baru (token Base64).

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) {
        // Hitung timestamp kedaluwarsa (24 jam dari sekarang)
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.HOUR_OF_DAY, 24);
        long timestamp = calendar.getTimeInMillis() / 1000;

        // Gabungkan string
        String stringBuilder = appid + appkey + channelid + userid + timestamp;

        // Hitung hash SHA-256
        String token = sha256(stringBuilder);

        // Buat objek JSON
        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);

        // Konversi objek JSON ke string dan encode dalam 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);
    }
}

package main

import (
	"crypto/sha256"
	"encoding/base64"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"time"
)

func createBase64Token(appid, appkey, channelID, userID string) (string, error) {
	// Hitung timestamp kedaluwarsa (24 jam dari sekarang)
	timestamp := time.Now().Add(24 * time.Hour).Unix()

	// Gabungkan string
	stringBuilder := appid + appkey + channelID + userID + fmt.Sprintf("%d", timestamp)

	// Hitung hash SHA-256
	hasher := sha256.New()
	hasher.Write([]byte(stringBuilder))
	token := hasher.Sum(nil)

	// Konversi hash ke string heksadesimal menggunakan encoding/hex
	tokenHex := hex.EncodeToString(token)

	// Buat objek JSON
	tokenJSON := map[string]interface{}{
		"appid":     appid,
		"channelid": channelID,
		"userid":    userID,
		"nonce":     "",
		"timestamp": timestamp,
		"token":     tokenHex,
	}

	// Konversi objek JSON ke string dan encode dalam 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)
}

#!/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':app_id,
                 'channelid':channel_id,
                 'userid':user_id,
                 'nonce':'',
                 'timestamp':timestamp,
                 'token':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()

'use strict'
const crypto = require('crypto')
function create_base64_token(appid, appkey, channelid, userid) {
    let timestamp = Math.floor(Date.now() / 1000 + 24 * 60 * 60)

    let string_builder = appid + appkey + channelid + userid + timestamp.toString()
    let token = crypto.createHash('sha256').update(string_builder).digest('hex')
    let base64tokenJson = {
        appid:appid,
        channelid:channelid,
        userid:userid,
        nonce:'',
        timestamp:timestamp,
        token:token
    }
    let base64token = Buffer.from(JSON.stringify(base64tokenJson), 'utf-8').toString('base64')
    return base64token
}

let appid = "your_appid";
let appkey = "your_appkey";
let channel_id = "your_channel_id";
let user_id = "your_user_id";

let base64token = create_base64_token(appid, appkey, channel_id, user_id)
console.log(base64token)

use chrono::{Duration, Utc};
use sha2::{Sha256, Digest};
use serde_json::json;
use base64::encode;

fn create_base64_token(appid: &str, appkey: &str, channel_id: &str, user_id: &str) -> String {
    // Hitung timestamp kedaluwarsa (24 jam dari sekarang)
    let timestamp = (Utc::now() + Duration::hours(24)).timestamp();

    // Gabungkan string
    let string_builder = format!("{}{}{}{}{}", appid, appkey, channel_id, user_id, timestamp);

    // Hitung hash SHA-256
    let mut hasher = Sha256::new();
    hasher.update(string_builder);
    let token = hasher.finalize();
    let token_hex = format!("{:x}", token);

    // Buat objek JSON
    let token_json = json!({
        "appid": appid,
        "channelid": channel_id,
        "userid": user_id,
        "nonce": "",
        "timestamp": timestamp,
        "token": token_hex
    });

    // Konversi objek JSON ke string dan encode dalam Base64
    let base64_token = encode(token_json.to_string());

    base64_token
}

fn main() {
    let appid = "your_appid";
    let appkey = "your_appkey";
    let channel_id = "your_channel_id";
    let user_id = "your_user_id";

    let token = create_base64_token(appid, appkey, channel_id, user_id);
    println!("Base64 Token: {}", token);
}

Contoh pemanggilan API client

Setelah client memperoleh token Base64 dari server aplikasi Anda, client tersebut menggunakan token tersebut untuk bergabung ke channel.

• Android:

  // Anda dapat mengatur channelId dan userId ke null. Jika Anda memberikan nilai untuk channelId dan userId, nilainya harus sesuai dengan yang digunakan untuk menghasilkan token. Fitur ini dapat digunakan untuk memverifikasi konsistensi parameter antara server dan client.
  // base64Token adalah token yang di-encode Base64.
  // username adalah identifikasi yang dikirimkan untuk keperluan troubleshooting.
  mAliRtcEngine.joinChannel(base64Token, null, null, "username");

• iOS:

  // Anda dapat mengatur channelId dan userId ke null. Jika Anda memberikan nilai untuk channelId dan userId, nilainya harus sesuai dengan yang digunakan untuk menghasilkan token. Fitur ini dapat digunakan untuk memverifikasi konsistensi parameter antara server dan client.
  // base64Token adalah token yang di-encode Base64.
  // username adalah identifikasi yang dikirimkan untuk keperluan troubleshooting.
  [self.engine joinChannel:base64Token channelId:nil userId:nil name:@"username" onResultWithUserId:nil];

Metode multi-parameter

SDK ARTC juga menyediakan API multi-parameter untuk bergabung ke channel. Metode ini menggunakan struktur data AliRtcAuthInfo untuk menyimpan token dan informasi pengguna guna otentikasi.

• Android:

  // Kirim token dan informasi pengguna untuk metode multi-parameter.
  AliRtcAuthInfo authInfo = new AliRtcAuthInfo();
  authInfo.appId = appId;
  authInfo.channelId = channelId;
  authInfo.userId = userId;
  authInfo.timestamp = timestamp;
  authInfo.nonce = nonce;
  authInfo.token = token;
  // Bergabung ke channel.
  mAliRtcEngine.joinChannel(authInfo, "");

• iOS:

  // Kirim token dan informasi pengguna untuk metode multi-parameter.
  let authInfo = AliRtcAuthInfo()
  authInfo.appId = appId
  authInfo.channelId = channelId
  authInfo.nonce = nonce
  authInfo.userId = userId
  authInfo.timestamp = timestamp
  authInfo.token = authToken
  // Bergabung ke channel.
  self.rtcEngine?.joinChannel(authInfo, name: nil)