SDK untuk Python - Platform For AI

Kami merekomendasikan penggunaan Elastic Algorithm Service (EAS) SDK resmi untuk mengurangi waktu dalam menentukan logika pemanggilan dan meningkatkan stabilitas pemanggilan. Topik ini menjelaskan EAS SDK untuk Python serta menyediakan input, output, dan demo umum untuk menunjukkan cara menggunakan EAS SDK untuk Python guna memanggil layanan.

Instalasi SDK

pip install -U eas-prediction --user

Metode

Deskripsi parameter umum

endpoint: Titik akhir server.

Untuk memanggil layanan dalam mode reguler, atur parameter ini ke titik akhir gateway default. Contoh: 182848887922***.cn-shanghai.pai-eas.aliyuncs.com.
Untuk memanggil layanan melalui koneksi langsung Virtual Private Cloud (VPC), atur parameter ini ke titik akhir umum wilayah tersebut. Sebagai contoh, di wilayah China (Shanghai), atur parameter ini ke pai-eas-vpc.cn-shanghai.aliyuncs.com.

PredictClient

Metode	Deskripsi
`PredictClient(endpoint, service_name, custom_url)`	Deskripsi: membuat objek klien dari kelas PredictClient. Parameter: endpoint: titik akhir server. Untuk informasi lebih lanjut, lihat Deskripsi parameter umum. service_name: nama layanan. custom_url: URL layanan. Parameter ini opsional dan hanya diperlukan untuk layanan yang titik akhirnya tidak dalam format `<uid>.<region>.pai-eas.aliyuncs.com`, seperti layanan antarmuka web. Anda dapat mengonfigurasi parameter ini untuk membuat klien. Contoh: `client = PredictClient(custom_url='<url>')`.
`set_endpoint(endpoint)`	Deskripsi: menentukan titik akhir server. Untuk informasi lebih lanjut, lihat Deskripsi parameter umum. Parameter: endpoint: titik akhir server.
`set_service_name(service_name)`	Deskripsi: menentukan nama layanan. Parameter: service_name: nama layanan.
`set_endpoint_type(endpoint_type)`	Deskripsi: menentukan jenis gateway server. Parameter: endpoint_type: jenis gateway yang akan digunakan. Jenis gateway yang didukung adalah sebagai berikut: ENDPOINT_TYPE_GATEWAY: gateway default. ENDPOINT_TYPE_DIRECT: saluran koneksi langsung VPC. Jika Anda tidak mengatur parameter ini, gateway default akan digunakan untuk mengakses layanan.
`set_token(token)`	Deskripsi: menentukan token yang digunakan untuk mengakses layanan. Parameter: token: token untuk akses layanan.
`set_retry_count(max_retry_count)`	Deskripsi: menetapkan jumlah maksimum percobaan ulang setelah permintaan gagal. Parameter: max_retry_count: jumlah maksimum percobaan ulang setelah permintaan gagal. Nilai default: 5. null Klien harus mengirim ulang permintaan jika terjadi kesalahan proses di server, kesalahan server, atau koneksi persisten ke gateway ditutup. Oleh karena itu, kami merekomendasikan agar Anda tidak mengatur parameter ini menjadi 0.
`set_max_connection_count(max_connection_count)`	Deskripsi: menentukan jumlah maksimum koneksi persisten yang diizinkan dalam kumpulan koneksi klien. Untuk mencapai performa yang lebih baik, klien membentuk koneksi persisten ke server dan menyimpan koneksi persisten tersebut dalam kumpulan koneksi. Setiap kali Anda memulai permintaan, klien menggunakan koneksi idle dalam kumpulan koneksi untuk mengakses layanan yang diperlukan. Parameter: max_connection_count: jumlah maksimum koneksi persisten yang diizinkan dalam kumpulan koneksi. Nilai default: 100.
`set_timeout(timeout)`	Deskripsi: menentukan periode timeout permintaan. Parameter: timeout: periode timeout permintaan. Nilai default: 5000. Satuan: milidetik.
`init()`	Deskripsi: menginisialisasi objek klien. Setelah semua metode sebelumnya dipanggil, Anda harus memanggil metode `Init()` agar parameter-parameter tersebut berlaku.
`predict(request)`	Deskripsi: mengirim permintaan prediksi ke layanan prediksi online. Parameter: request: sebuah kelas abstrak, yang bisa berupa request dari berbagai kelas, seperti kelas StringRequest atau TFRequest. Nilai kembali: respons terhadap permintaan prediksi.

StringRequest

Metode	Deskripsi
`StringRequest(request_data)`	Deskripsi: membuat objek dari kelas StringRequest. Parameter: request_data: string permintaan yang akan dikirim.

StringResponse

Metode	Deskripsi
`to_string()`	Deskripsi: mengonversi respons dari kelas StringResponse menjadi string. Nilai kembali: badan respons dari permintaan.

TFRequest

Metode	Deskripsi
`TFRequest(signature_name)`	Deskripsi: membuat objek dari kelas TFRequest. Parameter: signature_name: nama tanda tangan model layanan yang akan dipanggil.
`add_feed(self, input_name, shape, data_type, content)`	Deskripsi: menentukan tensor input layanan prediksi online TensorFlow yang akan dipanggil. Parameter: input_name: alias tensor input. shape: bentuk tensor input. data_type: tipe data tensor input. Tipe data yang didukung adalah sebagai berikut: TFRequest.DT_FLOAT TFRequest.DT_DOUBLE TFRequest.DT_INT8 TFRequest.DT_INT16 TFRequest.DT_INT32 TFRequest.DT_INT64 TFRequest.DT_STRING TFRequest.TF_BOOL content: isi tensor input. Isi tersebut dalam bentuk array satu dimensi.
`add_fetch(self, output_name)`	Deskripsi: menentukan alias tensor output yang akan dikembalikan saat layanan prediksi online TensorFlow dipanggil. Parameter: output_name: alias tensor output yang akan dikembalikan. Jika model TensorFlow dalam format SavedModel, parameter ini bersifat opsional. Jika parameter ini tidak ditentukan, semua tensor output akan dikembalikan. Jika model TensorFlow adalah model beku, parameter ini wajib.
`to_string()`	Deskripsi: menyerilisasi objek protocol buffer (PB) menjadi string. Objek PB dibuat dengan menggunakan kelas TFRequest dan digunakan untuk mentransmisikan permintaan. Nilai kembali: string yang diperoleh dari serialisasi berbasis TFRequest.

TFResponse

Metode	Deskripsi
`get_tensor_shape(output_name)`	Deskripsi: memeriksa bentuk tensor output yang diidentifikasi oleh alias tertentu. Parameter: output_name: alias tensor output yang ingin Anda periksa. Nilai kembali: bentuk tensor output.
`get_values(output_name)`	Deskripsi: memeriksa vektor data tensor output yang ditentukan. Parameter: output_name: alias tensor output yang ingin Anda periksa. Nilai kembali: array satu dimensi. Anda dapat memanggil metode ini bersama dengan metode `get_tensor_shape()` untuk memeriksa bentuk tensor output dan mengembalikan array satu dimensi ke array multi-dimensi yang diperlukan. Tipe data tensor output menentukan tipe data array satu dimensi yang dikembalikan.

TorchRequest

Metode	Deskripsi
`TorchRequest()`	Deskripsi: membuat objek dari kelas TorchRequest.
`add_feed(self, index, shape, data_type, content)`	Deskripsi: menentukan tensor input layanan prediksi online PyTorch yang akan dipanggil. Parameter: index: indeks tensor input. shape: bentuk tensor input. data_type: tipe data tensor input. Tipe data yang didukung adalah sebagai berikut: TFRequest.DT_FLOAT TFRequest.DT_DOUBLE TFRequest.DT_INT8 TFRequest.DT_INT16 TFRequest.DT_INT32 TFRequest.DT_INT64 TFRequest.DT_STRING TFRequest.TF_BOOL content: isi tensor input. Isi tersebut dalam bentuk array satu dimensi.
`add_fetch(self, output_index)`	Deskripsi: menentukan indeks tensor output yang akan dikembalikan saat layanan prediksi online PyTorch dipanggil. Metode ini bersifat opsional. Jika Anda tidak memanggil metode ini untuk menentukan indeks tensor output, semua tensor output akan dikembalikan. Parameter: output_index: indeks tensor output yang akan dikembalikan.
`to_string()`	Deskripsi: menyerilisasi objek PB menjadi string. Objek PB dibuat dengan menggunakan kelas TorchRequest dan digunakan untuk mentransmisikan permintaan. Nilai kembali: string yang diperoleh dari serialisasi berbasis TorchRequest.

TorchResponse

Metode	Deskripsi
`get_tensor_shape(output_index)`	Deskripsi: memeriksa bentuk tensor output yang diidentifikasi oleh indeks tertentu. Parameter: output_index: indeks tensor output yang ingin Anda periksa. Nilai kembali: bentuk tensor output yang diidentifikasi oleh indeks tertentu.
`get_values(output_index)`	Deskripsi: memeriksa vektor data tensor output yang ditentukan. Nilai kembali adalah array satu dimensi. Anda dapat memanggil metode ini bersama dengan metode `get_tensor_shape()` untuk memeriksa bentuk tensor output dan mengembalikan array satu dimensi ke array multi-dimensi yang diperlukan. Tipe data tensor output menentukan tipe data array satu dimensi yang dikembalikan. Parameter: output_index: indeks tensor output yang ingin Anda periksa. Nilai kembali: array satu dimensi.

QueueClient

Metode	Deskripsi
`QueueClient(endpoint, queue_name)`	Deskripsi: membuat objek klien dari kelas QueueClient. Parameter: endpoint: titik akhir server. queue_name: nama antrian yang akan dibuat. Nilai kembali: objek klien yang telah dibuat.
`set_token(token)`	Deskripsi: membuat token untuk objek klien dari kelas QueueClient untuk autentikasi. Parameter: token: token dari antrian yang akan dibuat.
`init(uid=None,gid='eas')`	Deskripsi: menginisialisasi objek dari kelas QueueClient. Parameter: uid: ID pengguna klien. Klien digunakan untuk mendaftar di server. ID pengguna setiap instance klien harus unik, dan setiap ID pengguna hanya dapat didaftarkan sekali. Data yang didorong oleh server didistribusikan secara merata di antara ID pengguna. gid: ID grup klien. Klien digunakan untuk mendaftar di server. Secara default, klien dengan ID grup yang sama termasuk dalam grup yang sama. Jika ada grup berbeda, salinan data yang sama akan didorong ke semua grup.
`set_logger(logger=None)`	Deskripsi: mengonfigurasi logger untuk antrian. Secara default, logger menampilkan informasi peringatan sebagai output biasa. Untuk menonaktifkan logging, atur logger menjadi None. Parameter: logger: logger yang ingin Anda konfigurasikan.
`truncate(index)`	Deskripsi: memotong data dalam antrian sebelum indeks tertentu dan hanya menyimpan data setelah indeks tersebut. Parameter: index: indeks yang digunakan untuk memotong data dalam antrian.
`put(data,tags:dict={})`	Deskripsi: menulis catatan data ke antrian. Parameter: data: catatan data yang ingin Anda tulis ke antrian. tags: opsional. Tag dari catatan data yang ingin Anda tulis ke antrian. Nilai kembali: index: indeks dari catatan data yang ditulis ke antrian. Nilai ini dapat digunakan untuk memeriksa data dalam antrian. requestId: ID permintaan yang dihasilkan otomatis untuk catatan data yang ditulis ke antrian. Anda dapat menggunakan requestId sebagai tag khusus untuk memeriksa data dalam antrian.
`get(request_id=None, index=0, length=1, timeout='5s', auto_delete=True, tags={})`	Deskripsi: memeriksa data dalam antrian berdasarkan kondisi tertentu. Parameter: request_id: ID permintaan dari catatan data yang ingin Anda periksa. Jika parameter ini ditentukan, sistem akan memeriksa sejumlah catatan data yang ditentukan oleh length mulai dari indeks. Jika hasil pemeriksaan berisi catatan yang cocok dengan request ID, catatan tersebut akan dikembalikan. Jika tidak, null akan dikembalikan. index: indeks dari mana pemeriksaan dimulai. Nilai default: 0, yang menunjukkan bahwa pemeriksaan dimulai dari catatan data pertama. length: jumlah catatan data yang akan diperiksa. Jika parameter ini ditentukan, sistem akan mengembalikan maksimal length catatan data mulai dari indeks. Catatan data yang ditentukan oleh indeks juga akan dikembalikan. timeout: periode timeout dari pemeriksaan. Selama periode timeout, jika antrian berisi length catatan data, catatan data tersebut akan segera dikembalikan. Jika tidak, pemeriksaan akan berhenti setelah periode timeout yang ditentukan berakhir. auto_delete: menentukan apakah akan menghapus otomatis catatan data yang diperoleh dari antrian. Jika Anda mengatur auto_delete ke False, catatan data akan diperiksa berulang kali. Dalam hal ini, Anda dapat menggunakan metode `Del()` untuk menghapus data secara manual. tags: tag yang digunakan untuk memeriksa catatan data. Tipe data dari tag adalah dict. Jika parameter ini ditentukan, sistem akan memeriksa length catatan data mulai dari indeks yang ditentukan dan mengembalikan catatan data dengan tag yang ditentukan. Nilai kembali: catatan data yang diperoleh dalam format DataFrame.
`attributes()`	Deskripsi: memeriksa atribut antrian. Atribut mencakup panjang total antrian dan panjang data saat ini dalam antrian. Nilai kembali: attrs: atribut antrian. Tipe data atribut adalah dict.
`delete(indexes)`	Deskripsi: menghapus catatan data yang ditentukan oleh nilai indeks dari antrian. Parameter: indexes: nilai indeks yang ditentukan yang digunakan untuk menghapus catatan data. Anda dapat menentukan satu nilai indeks sebagai string atau beberapa nilai indeks sebagai daftar.
`search(index)`	Deskripsi: memeriksa informasi antrian dari catatan data. Parameter: index: indeks dari catatan data. Nilai kembali: informasi antrian dari catatan data. Informasi antrian bertipe JSONObject dan berisi bidang-bidang berikut: ConsumerId: ID instance yang memproses catatan data. IsPending: menunjukkan apakah catatan data sedang diproses. Nilai valid: True: Catatan data sedang diproses. False: Catatan data sedang menunggu dalam antrian untuk diproses. WaitCount: menunjukkan jumlah catatan data yang menunggu untuk diproses sebelum catatan data saat ini dalam antrian. Parameter ini valid hanya ketika IsPending diatur ke False. Jika IsPending diatur ke True, nilai parameter ini adalah 0. Contoh respons: Jika `{'ConsumerId': 'eas.****', 'IsPending': False, 'WaitCount':2}` dikembalikan, catatan data sedang menunggu untuk diproses dalam antrian. Jika log yang dikembalikan menampilkan `search error:Code 404, Message: b'no data in stream'` dan `{}` dikembalikan, catatan data tidak ditemukan dalam antrian. Hal ini mungkin karena catatan data telah diproses oleh server dan hasilnya telah dikembalikan ke klien, atau parameter indeks salah dikonfigurasi.
`watch(index, window, index_only=False, auto_commit=False)`	Deskripsi: berlangganan catatan data dalam antrian. Kemudian, layanan antrian mendorong data ke klien berdasarkan kondisi yang ditentukan. Parameter: index: indeks tempat langganan catatan data dimulai. window: jumlah maksimum catatan data yang diizinkan untuk didorong ke klien tunggal oleh layanan antrian. null Jika catatan data yang didorong belum dikomit, server tidak akan mendorong catatan data lain ke klien. Setelah N catatan data dikomit, server akan mendorong N catatan data ke klien untuk memastikan bahwa jumlah catatan data yang ditangani oleh klien tidak melebihi nilai yang ditentukan oleh window. Dengan cara ini, konkurensi sisi klien dalam pemrosesan data dikendalikan. index_only: menentukan apakah hanya nilai indeks yang akan didorong. auto_commit: menentukan apakah akan mengkomit otomatis catatan data setelah catatan data tersebut didorong. Kami merekomendasikan agar Anda mengatur auto_commit ke False. Dalam hal ini, Anda harus mengkomit secara manual catatan data setelah catatan data yang didorong diterima dan dihitung. Jika terjadi pengecualian pada suatu instance sebelum komputasi selesai, catatan data yang belum dikomit pada instance tersebut akan didorong ke instance lain oleh layanan antrian. Nilai kembali: watcher yang digunakan untuk membaca data yang didorong.
`commit(index)`	Deskripsi: mengkomit catatan data yang ditentukan oleh indeks. null Jika catatan data telah diproses dan tidak lagi perlu didorong ke instance lain, maka dikomit. Setelah itu, catatan data dapat dihapus dari antrian. Parameter: index: nilai indeks yang digunakan untuk menentukan catatan data yang akan dikomit. Anda dapat menentukan satu nilai indeks sebagai string atau beberapa nilai indeks sebagai daftar.

Watcher

Metode	Deskripsi
`run()`	Deskripsi: menjalankan watcher untuk membentuk koneksi WebSocket ke server, menerima data yang didorong dari server, dan mengembalikan data ke pemanggil secara real-time. Nilai kembali: data real-time yang didorong ke pemanggil dalam format DataFrame.
`close()`	Deskripsi: menutup watcher untuk mengakhiri koneksi backend. null Hanya satu watcher yang dapat dimulai untuk satu klien. Anda harus menutup watcher sebelum dapat memulai watcher lainnya.

Demo

Input and output as strings

Jika Anda menggunakan prosesor kustom untuk menerapkan layanan, string sering digunakan untuk memanggil layanan, seperti layanan yang diterapkan berdasarkan model Predictive Model Markup Language (PMML). Berikut adalah contoh kode demo:

#!/usr/bin/env python

from eas_prediction import PredictClient
from eas_prediction import StringRequest

if __name__ == '__main__':
    client = PredictClient('http://182848887922****.cn-shanghai.pai-eas.aliyuncs.com', 'scorecard_pmml_example')
    client.set_token('YWFlMDYyZDNmNTc3M2I3MzMwYmY0MmYwM2Y2MTYxMTY4NzBkNzdj****')
    client.init()

    request = StringRequest('[{"fea1": 1, "fea2": 2}]')
    for x in range(0, 1000000):
        resp = client.predict(request)
        print(resp)

Input and output as tensors

Jika Anda menggunakan TensorFlow untuk menerapkan layanan, Anda harus menggunakan kelas TFRequest dan TFResponse untuk memanggil layanan. Berikut adalah contoh kode demo:

#!/usr/bin/env python

from eas_prediction import PredictClient
from eas_prediction import StringRequest
from eas_prediction import TFRequest

if __name__ == '__main__':
    client = PredictClient('http://182848887922****.cn-shanghai.pai-eas.aliyuncs.com', 'mnist_saved_model_example')
    client.set_token('YTg2ZjE0ZjM4ZmE3OTc0NzYxZDMyNmYzMTJjZTQ1YmU0N2FjMTAy****')
    client.init()

    #request = StringRequest('[{}]')
    req = TFRequest('predict_images')
    req.add_feed('images', [1, 784], TFRequest.DT_FLOAT, [1] * 784)
    for x in range(0, 1000000):
        resp = client.predict(req)
        print(resp)

Use a VPC direct connection channel to call a service
Anda dapat menggunakan saluran koneksi langsung VPC untuk mengakses layanan yang diterapkan dalam grup sumber daya khusus EAS. Untuk menggunakan saluran koneksi langsung VPC, grup sumber daya khusus EAS dan vSwitch yang ditentukan harus berada dalam VPC yang sama. Untuk informasi lebih lanjut tentang cara membeli grup sumber daya khusus EAS dan cara mengonfigurasi konektivitas jaringan, lihat Bekerja dengan grup sumber daya khusus dan Konfigurasikan konektivitas jaringan. Dibandingkan dengan mode reguler, mode ini mencakup satu baris kode tambahan: client.set_endpoint_type(ENDPOINT_TYPE_DIRECT). Mode ini cocok untuk skenario dengan konkurensi tinggi dan lalu lintas berat. Berikut adalah contoh kode demo:
```
#!/usr/bin/env python

from eas_prediction import PredictClient
from eas_prediction import StringRequest
from eas_prediction import TFRequest
from eas_prediction import ENDPOINT_TYPE_DIRECT

if __name__ == '__main__':
    client = PredictClient('http://pai-eas-vpc.cn-hangzhou.aliyuncs.com', 'mnist_saved_model_example')
    client.set_token('M2FhNjJlZDBmMzBmMGM3ZmE4ZmNjZDk0M2NiMDA3OTZmNzc1MTUx****')
    client.set_endpoint_type(ENDPOINT_TYPE_DIRECT)
    client.init()

    request = TFRequest('predict_images')
    request.add_feed('images', [1, 784], TFRequest.DT_FLOAT, [1] * 784)
    for x in range(0, 1000000):
        resp = client.predict(request)
        print(resp)
```

Call a PyTorch model

Jika Anda menggunakan PyTorch untuk menerapkan layanan, Anda harus menggunakan kelas TorchRequest dan TorchResponse untuk memanggil layanan. Berikut adalah contoh kode demo:

#!/usr/bin/env python

from eas_prediction import PredictClient
from eas_prediction import TorchRequest

if __name__ == '__main__':
    client = PredictClient('http://182848887922****.cn-shanghai.pai-eas.aliyuncs.com', 'pytorch_gpu_wl')
    client.init()

    req = TorchRequest()
    req.add_feed(0, [1, 3, 224, 224], TorchRequest.DT_FLOAT, [1] * 150528)
    # req.add_fetch(0)
    import time
    st = time.time()
    timer = 0
    for x in range(0, 10):
        resp = client.predict(req)
        timer += (time.time() - st)
        st = time.time()
        print(resp.get_tensor_shape(0))
        # print(resp)
    print("average response time: %s s" % (timer / 10) )

Call a Blade processor-based model

Jika Anda menggunakan prosesor Blade untuk menerapkan layanan, Anda harus menggunakan kelas BladeRequest dan BladeResponse untuk memanggil layanan. Berikut adalah contoh kode demo:

#!/usr/bin/env python

from eas_prediction import PredictClient
from eas_prediction import BladeRequest 

if __name__ == '__main__':
    client = PredictClient('http://182848887922****.cn-shanghai.pai-eas.aliyuncs.com', 'nlp_model_example')
    client.init()

    req = BladeRequest()

    req.add_feed('input_data', 1, [1, 360, 128], BladeRequest.DT_FLOAT, [0.8] * 85680)
    req.add_feed('input_length', 1, [1], BladeRequest.DT_INT32, [187])
    req.add_feed('start_token', 1, [1], BladeRequest.DT_INT32, [104])
    req.add_fetch('output', BladeRequest.DT_FLOAT)
    import time
    st = time.time()
    timer = 0
    for x in range(0, 10):
        resp = client.predict(req)
        timer += (time.time() - st)
        st = time.time()
        # print(resp)
        # print(resp.get_values('output'))
        print(resp.get_tensor_shape('output'))
    print("average response time: %s s" % (timer / 10) )

Call an EAS Blade processor-based model that is compatible with default TensorFlow methods

Anda dapat menggunakan kelas TFRequest dan TFResponse untuk memanggil model berbasis prosesor Blade yang kompatibel dengan metode TensorFlow default yang didukung oleh EAS. Berikut adalah contoh kode demo:

#!/usr/bin/env python

from eas_prediction import PredictClient
from eas_prediction.blade_tf_request import TFRequest # Perlu Mengimpor blade TFRequest 

if __name__ == '__main__':
    client = PredictClient('http://182848887922****.cn-shanghai.pai-eas.aliyuncs.com', 'nlp_model_example')
    client.init()

    req = TFRequest(signature_name='predict_words')

    req.add_feed('input_data', [1, 360, 128], TFRequest.DT_FLOAT, [0.8] * 85680)
    req.add_feed('input_length', [1], TFRequest.DT_INT32, [187])
    req.add_feed('start_token', [1], TFRequest.DT_INT32, [104])
    req.add_fetch('output')
    import time
    st = time.time()
    timer = 0
    for x in range(0, 10):
        resp = client.predict(req)
        timer += (time.time() - st)
        st = time.time()
        # print(resp)
        # print(resp.get_values('output'))
        print(resp.get_tensor_shape('output'))
    print("average response time: %s s" % (timer / 10) )

Use the queuing service to send and subscribe to data

Anda dapat mengirim dan memeriksa data dalam antrian, memeriksa status antrian, serta berlangganan data yang didorong oleh antrian. Dalam demo berikut, sebuah thread mendorong data ke antrian, dan thread lainnya menggunakan watcher untuk berlangganan data yang didorong. Berikut adalah contoh kode demo:

#!/usr/bin/env python

from eas_prediction import QueueClient
import threading

if __name__ == '__main__':
    endpoint = '182848887922****.cn-shanghai.pai-eas.aliyuncs.com'
    queue_name = 'test_group.qservice/sink'
    token = 'YmE3NDkyMzdiMzNmMGM3ZmE4ZmNjZDk0M2NiMDA3OTZmNzc1MTUx****'

    queue = QueueClient(endpoint, queue_name)
    queue.set_token(token)
    queue.init()
    queue.set_timeout(30000)

    # potong semua pesan dalam antrian
    attributes = queue.attributes()
    if 'stream.lastEntry' in attributes:
        queue.truncate(int(attributes['stream.lastEntry']) + 1)

    count = 100
    # buat thread untuk mengirim pesan ke antrian
    def send_thread():
        for i in range(count):
            index, request_id = queue.put('[{}]')
            print('send: ', i, index, request_id)

    # buat thread untuk melihat pesan dari antrian
    def watch_thread():
        watcher = queue.watch(0, 5, auto_commit=True)
        i = 0
        for x in watcher.run():
            print('recv: ', i, x.index, x.tags['requestId'])
            i += 1
            if i == count:
                break
        watcher.close()

    thread1 = threading.Thread(target=watch_thread)
    thread2 = threading.Thread(target=send_thread)

    thread1.start()
    thread2.start()

    thread1.join()
    thread2.join()