All Products
Search
Document Center

Container Service for Kubernetes:Colokasikan layanan online dengan aplikasi transkoding video

Last Updated:Mar 26, 2026

ack-koordinator menyediakan penjadwalan workload yang mempertimbangkan Service Level Objective (SLO), memungkinkan Anda menjalankan workload online dan offline pada node yang sama—menjaga performa layanan online sekaligus meningkatkan pemanfaatan resource kluster secara keseluruhan. Topik ini menjelaskan langkah-langkah untuk menjalankan layanan web NGINX dan aplikasi transkoding video FFmpeg secara bersamaan menggunakan ack-koordinator.

Latar Belakang

Menjalankan workload online dan offline pada node yang sama masuk akal karena pola permintaan resource mereka saling melengkapi: layanan online memiliki beban bervariasi dan mengonsumsi resource secara burst, sedangkan job batch offline berjalan terus-menerus dan dapat mentoleransi prioritas resource yang lebih rendah.

Beban Kerja OnlineWorkload offline
Aplikasi khasLayanan web, API, microservicesTranskoding video, pemrosesan big data, pelatihan AI
LatensiSensitifTidak sensitif
SLOTinggiRendah
Pola penggunaan resourceBursty, berbasis waktuKontinu
Toleransi terhadap kegagalanRendah — memerlukan ketersediaan tinggiTinggi — memungkinkan kegagalan dan retry

ack-koordinator menggunakan kelas Quality of Service (QoS) untuk mengatur prioritas resource antar workload yang di-colokasikan. Dua kelas yang digunakan dalam topik ini adalah:

Kelas QoSNilai labelPenggunaan khasPrioritas CPUPrioritas memori
Latency-sensitive (LS)koordinator.sh/qosClass: LSLayanan online (misalnya, NGINX)TinggiTinggi
Best-effort (BE)koordinator.sh/qosClass: BEJob batch offline (misalnya, FFmpeg)RendahRendah

Cara kerja

Dalam topik ini, layanan NGINX (kelas QoS LS) dan aplikasi transkoding video FFmpeg (kelas QoS BE) dijalankan pada node yang sama. Dua fitur colocation bekerja bersama untuk melindungi performa NGINX:

  • Penggunaan ulang resource: Workload BE dapat menggunakan resource yang dialokasikan untuk workload LS namun sedang idle, sehingga meningkatkan pemanfaatan resource kluster. Untuk informasi lebih lanjut, lihat Dynamic resource overcommitment.

  • Isolasi resource: Berbagai mekanisme membatasi penggunaan resource oleh workload BE dan memprioritaskan permintaan resource dari workload LS. Untuk informasi selengkapnya, lihat CPU QoS, CPU Suppress, dan Resource isolation based on the L3 cache and MBA.

image

Topik ini menerapkan aplikasi dalam tiga mode dan membandingkan hasilnya:

ModeDeskripsi
Penerapan eksklusif (garis dasar)Hanya NGINX yang berjalan pada node.
Default Kubernetes colocation (kontrol)NGINX dan FFmpeg berjalan pada node yang sama dengan kelas QoS Kubernetes standar — tanpa resource ekstensi atau fitur isolasi ack-koordinator.
Colocation berbasis SLO (eksperimen)NGINX dan FFmpeg berjalan pada node yang sama dengan fitur isolasi ack-koordinator diaktifkan.

Prasyarat

Sebelum memulai, pastikan Anda telah menyiapkan:

CPU QoS memerlukan Alibaba Cloud Linux sebagai OS node. Isolasi resource berbasis cache L3 dan MBA memerlukan Instans Mesin Fisik ECS.

Terapkan layanan NGINX dan wrk

Terapkan layanan NGINX pada mesin uji dan tool pengujian beban wrk pada mesin uji stres.

Tampilkan konten file YAML

  1. Buat file bernama ls-nginx.yaml dengan konten berikut:

    Tampilkan konten file YAML

    ---
    # Konfigurasi NGINX
    apiVersion: v1
    data:
      config: |-
        user  nginx;
        worker_processes  80; # Jumlah proses worker — mengontrol kapasitas permintaan konkuren.
    
        events {
            worker_connections  1024;  # Koneksi maksimum per worker. Default: 1024.
        }
    
        http {
            server {
                listen  8000;
    
                gzip off;
                gzip_min_length 32;
                gzip_http_version 1.0;
                gzip_comp_level 3;
                gzip_types *;
            }
        }
    
        #daemon off;
    kind: ConfigMap
    metadata:
      name: nginx-conf
    
    ---
    # Pod untuk layanan NGINX online (kelas QoS LS)
    apiVersion: v1
    kind: Pod
    metadata:
      labels:
        koordinator.sh/qosClass: LS
        app: nginx
      name: nginx
    spec:
      containers:
        - image: 'koordinatorsh/nginx:v1.18-koord-exmaple'
          imagePullPolicy: IfNotPresent
          name: nginx
          ports:
            - containerPort: 8000
              hostPort: 8000 # Port yang diekspos untuk pengujian beban.
              protocol: TCP
          resources:
            limits:
              cpu: '80'
              memory: 10Gi
            requests:
              cpu: '80'
              memory: 10Gi
          volumeMounts:
            - mountPath: /apps/nginx/conf
              name: config
      hostNetwork: true
      restartPolicy: Never
      volumes:
        - configMap:
            items:
              - key: config
                path: nginx.conf
            name: nginx-conf
          name: config
      nodeName: cn-beijing.192.168.2.93  # Ganti dengan nama node mesin uji Anda.
  2. Terapkan layanan NGINX:

    kubectl apply -f ls-nginx.yaml
  3. Verifikasi pod sedang berjalan:

    kubectl get pod -l app=nginx -o wide

    Output yang diharapkan:

    NAME    READY   STATUS    RESTARTS   AGE    IP               NODE                      NOMINATED NODE   READINESS GATES
    nginx   1/1     Running   0          43s    11.162.XXX.XXX   cn-beijing.192.168.2.93   <none>           <none>

    Status Running mengonfirmasi bahwa layanan NGINX aktif pada mesin uji.

Instal wrk pada mesin uji stres

Jalankan perintah berikut pada Node 2 (mesin uji stres) untuk menginstal wrk 4.2.0:

wget -O wrk-4.2.0.tar.gz https://github.com/wg/wrk/archive/refs/tags/4.2.0.tar.gz && tar -xvf wrk-4.2.0.tar.gz
cd wrk-4.2.0 && make && chmod +x ./wrk

Terapkan aplikasi FFmpeg

Terapkan aplikasi transkoding video FFmpeg offline pada mesin uji. Konfigurasi YAML sedikit berbeda antara mode colocation Kubernetes default dan mode colocation berbasis SLO — komentar relevan dalam file menjelaskan setiap perbedaan tersebut.

  1. Buat file bernama be-ffmpeg.yaml dengan konten berikut:

    Tampilkan konten file YAML

    # Pod untuk aplikasi transkoding video FFmpeg offline (kelas QoS BE)
    apiVersion: v1
    kind: Pod
    metadata:
      name: be-ffmpeg
      labels:
        app: ffmpeg
      # Mode colocation Kubernetes default: hapus label koordinator.sh/qosClass: BE.
      # Mode colocation berbasis SLO: pertahankan label koordinator.sh/qosClass: BE.
        koordinator.sh/qosClass: BE
    spec:
      containers:
        # Tingkatkan jumlah proses untuk mengontrol pemanfaatan CPU aplikasi transkoding.
        # Default: 25 proses, masing-masing dengan 2 thread paralel.
        - command:
            - start-ffmpeg.sh
            - '25'
            - '2'
            - /apps/ffmpeg/input/HD2-h264.ts
            - /apps/ffmpeg/
          image: 'registry.cn-zhangjiakou.aliyuncs.com/acs/ffmpeg-4-4-1-for-slo-test:v0.1'
          imagePullPolicy: Always
          name: ffmpeg
          resources:
          # Mode colocation Kubernetes default: hapus resource ekstensi kubernetes.io/batch-cpu dan
          # kubernetes.io/batch-memory.
          # Mode colocation berbasis SLO: pertahankan, sesuaikan ukurannya dengan spesifikasi resource node Anda.
            limits:
              kubernetes.io/batch-cpu: 70k
              kubernetes.io/batch-memory: 22Gi
            requests:
              kubernetes.io/batch-cpu: 70k
              kubernetes.io/batch-memory: 22Gi
      hostNetwork: true
      restartPolicy: Never
      nodeName: cn-beijing.192.168.2.93  # Ganti dengan nama node mesin uji Anda.
  2. Terapkan aplikasi FFmpeg:

    kubectl apply -f be-ffmpeg.yaml
  3. Verifikasi pod sedang berjalan:

    kubectl get pod -l app=ffmpeg -o wide

    Output yang diharapkan:

    NAME        READY   STATUS    RESTARTS   AGE    IP               NODE                      NOMINATED NODE   READINESS GATES
    be-ffmpeg   1/1     Running   0          15s    11.162.XXX.XXX   cn-beijing.192.168.2.93   <none>           <none>

Jalankan pengujian stres

Jalankan pengujian pada setiap mode colocation dan bandingkan hasilnya. Metrik utama yang diamati adalah:

  • Persentil waktu respons (RT): RT-P90 adalah waktu maksimum untuk memproses 90% permintaan; RT-P99 mencakup 99% permintaan. Nilai yang lebih rendah menunjukkan performa NGINX yang lebih baik.

  • Rata-rata pemanfaatan CPU: diukur dengan kubectl top node.

Mode 1: Penerapan eksklusif (garis dasar)

Hanya layanan NGINX yang berjalan pada mesin uji.

  1. Terapkan NGINX seperti dijelaskan dalam Terapkan layanan NGINX dan wrk.

  2. Kirim beban dari mesin uji stres:

    # Ganti node_ip dengan alamat IP mesin uji.
    ./wrk -t6 -c54 -d60s --latency http://${node_ip}:8000/
  3. Periksa pemanfaatan CPU:

    kubectl top node

    Output yang diharapkan:

    NAME                      CPU(cores)   CPU%   MEMORY(bytes)   MEMORY%
    cn-beijing.192.168.2.93   29593m       29%    xxxx            xxxx
    cn-beijing.192.168.2.94   6874m        7%     xxxx            xxxx

    Pemanfaatan CPU pada mesin uji sekitar 29%.

  4. Setelah pengujian selesai, tinjau output wrk. Untuk hasil akurat, jalankan beberapa kali pengujian. Output yang diharapkan:

    Running 1m test @ http://192.168.2.94:8000/
      6 threads and 54 connections
      Thread Stats   Avg      Stdev     Max   +/- Stdev
        Latency   402.18us    1.07ms  59.56ms   99.83%
        Req/Sec    24.22k     1.12k   30.58k    74.15%
      Latency Distribution
         50%  343.00us
         75%  402.00us
         90%  523.00us
         99%  786.00us
      8686569 requests in 1.00m, 6.88GB read
    Requests/sec: 144537.08
    Transfer/sec:    117.16MB

    Bagian Latency Distribution menunjukkan nilai persentil RT. Dalam mode eksklusif: RT-P50 adalah 343 mikrodetik, RT-P90 adalah 523 mikrodetik, dan RT-P99 adalah 786 mikrodetik.

Mode 2: Colocation Kubernetes default (kontrol)

NGINX dan FFmpeg berjalan pada mesin uji tanpa fitur isolasi ack-koordinator.

Terapkan NGINX seperti dijelaskan dalam Terapkan layanan NGINX dan wrk, lalu terapkan aplikasi FFmpeg menggunakan be-ffmpeg.yaml dengan modifikasi berikut:

  • Hapus label koordinator.sh/qosClass: BE.

  • Hapus resource ekstensi kubernetes.io/batch-cpu dan kubernetes.io/batch-memory.

Jalankan pengujian beban wrk dan kumpulkan pemanfaatan CPU seperti pada Mode 1. Dalam konfigurasi kontrol ini, pemanfaatan CPU node mencapai sekitar 65%.

Mode 3: Colocation berbasis SLO (eksperimen)

NGINX dan FFmpeg berjalan pada mesin uji dengan fitur isolasi ack-koordinator diaktifkan.

  1. Ikuti panduan Getting started untuk mengaktifkan colocation berbasis SLO, lalu konfigurasikan tiap fitur berikut:

    • [Dynamic resource overcommitment](https://www.alibabacloud.com/help/en/document_detail/412172.html#task-2190961): Gunakan konfigurasi default. Ini memungkinkan sistem mengalokasikan resource idle dari pod LS ke pod BE sebagai resource batch overcommitted (kubernetes.io/batch-cpu dan kubernetes.io/batch-memory).

    • [CPU Suppress](https://www.alibabacloud.com/help/en/document_detail/268626.html#task-2088911): Atur cpuSuppressThresholdPercent menjadi 65. Gunakan nilai default untuk pengaturan lainnya. Saat pemanfaatan CPU node melebihi 65%, fitur ini akan melakukan throttle terhadap penggunaan CPU pod BE untuk melindungi performa pod LS.

    • [CPU QoS](https://www.alibabacloud.com/help/en/document_detail/433810.html#task-2223861): Gunakan konfigurasi default. Ini mengaktifkan kemampuan CPU Identity pada Alibaba Cloud Linux, memberikan prioritas penjadwalan kepada pod LS dibanding pod BE — termasuk saat Simultaneous Multithreading (SMT) menjalankan thread dari kedua pod pada core fisik yang sama.

    • [Resource isolation based on the L3 cache and MBA](https://www.alibabacloud.com/help/en/document_detail/273042.html#task-2093499): Gunakan konfigurasi default. Pada Instans Mesin Fisik ECS, ini mengisolasi cache L3 (last level cache) dan alokasi bandwidth memori (MBA) sehingga pod LS mendapatkan akses prioritas.

    Penting

    CPU QoS memerlukan Alibaba Cloud Linux sebagai OS node. Isolasi cache L3 dan MBA memerlukan Instans Mesin Fisik ECS.

  2. Terapkan NGINX seperti dijelaskan dalam Terapkan layanan NGINX dan wrk.

  3. Buat file bernama besteffort-ffmpeg.yaml dengan konten berikut: Tampilkan konten file YAML

    # Pod untuk aplikasi transkoding video FFmpeg offline (kelas QoS BE, mode berbasis SLO)
    apiVersion: v1
    kind: Pod
    metadata:
      name: besteffort-ffmpeg
      labels:
        app: ffmpeg
        # Tetapkan kelas QoS ke BE untuk penjadwalan berbasis SLO.
        koordinator.sh/qosClass: BE
    spec:
      containers:
        - command:
            - start-ffmpeg.sh
            - '30'
            - '2'
            - /apps/ffmpeg/input/HD2-h264.ts
            - /apps/ffmpeg/
          image: 'registry.cn-zhangjiakou.aliyuncs.com/acs/ffmpeg-4-4-1-for-slo-test:v0.1'
          imagePullPolicy: Always
          name: ffmpeg
          resources:
            # Minta resource overcommitted dinamis.
            limits:
              kubernetes.io/batch-cpu: 70k
              kubernetes.io/batch-memory: 22Gi
            requests:
              kubernetes.io/batch-cpu: 70k
              kubernetes.io/batch-memory: 22Gi
      hostNetwork: true
      restartPolicy: Never
      nodeName: cn-beijing.192.168.2.93  # Ganti dengan nama node mesin uji Anda.
  4. Terapkan aplikasi FFmpeg:

    kubectl apply -f besteffort-ffmpeg.yaml
  5. Verifikasi pod FFmpeg sedang berjalan:

    kubectl get pod -l app=ffmpeg -o wide

    Output yang diharapkan:

    NAME                READY   STATUS    RESTARTS   AGE    IP               NODE                      NOMINATED NODE   READINESS GATES
    besteffort-ffmpeg   1/1     Running   0          15s    11.162.XXX.XXX   cn-beijing.192.168.2.93   <none>           <none>
  6. Kirim beban dari mesin uji stres:

    # Ganti node_ip dengan alamat IP mesin uji.
    ./wrk -t6 -c54 -d60s --latency http://${node_ip}:8000/
  7. Periksa pemanfaatan CPU:

    kubectl top node

    Output yang diharapkan:

    NAME                      CPU(cores)   CPU%   MEMORY(bytes)   MEMORY%
    cn-beijing.192.168.2.93   65424m       63%    xxxx            xxxx
    cn-beijing.192.168.2.94   7040m        7%     xxxx            xxxx

    Pemanfaatan CPU pada mesin uji sekitar 63%.

  8. Setelah pengujian selesai, tinjau output wrk dan bandingkan dengan hasil dari mode lainnya.

Hasil pengujian

Tabel berikut membandingkan waktu respons NGINX dan pemanfaatan CPU node di ketiga mode.

MetrikGaris dasar (eksklusif)Kontrol (Kubernetes default)Eksperimen (berbasis SLO)
NGINX RT-P90 (ms)0,5330,574 (+7,7%)0,548 (2,8%)
NGINX RT-P99 (ms)0,931,07 (+16%)0,96 (+3,2%)
Rata-rata pemanfaatan CPU29,6%65,1%64,8%

Pengamatan utama:

  • Colocation Kubernetes default vs. garis dasar: Pemanfaatan CPU meningkat dari 29,6% menjadi 65,1%, tetapi RT-P90 NGINX naik 7,7% dan RT-P99 naik 16%. Distribusi latensi memiliki ekor panjang.

  • Colocation berbasis SLO vs. garis dasar: Pemanfaatan CPU meningkat dari 29,6% menjadi 64,8%, sementara RT-P90 hanya naik 2,8% dan RT-P99 hanya naik 3,2%.

  • Colocation berbasis SLO vs. colocation Kubernetes default: Pemanfaatan CPU serupa (~65%), tetapi waktu respons NGINX jauh lebih rendah dan mendekati garis dasar penerapan eksklusif.

Colocation berbasis SLO mencapai peningkatan pemanfaatan CPU yang hampir sama dengan colocation standar, sekaligus menjaga latensi NGINX jauh lebih dekat ke garis dasar tanpa colocation.

FAQ

Mengapa wrk melaporkan "Socket errors: connect 54,"?

Galat ini berarti klien wrk tidak dapat membuat koneksi ke server NGINX karena jumlah koneksi melebihi batas sistem operasi. Perbaiki dengan mengaktifkan reuse koneksi TCP pada mesin uji stres (bukan mesin uji).

  1. Periksa apakah reuse koneksi TCP sudah diaktifkan:

    sudo sysctl -n net.ipv4.tcp_tw_reuse

    Nilai kembali 0 atau 2 berarti fitur ini dinonaktifkan.

  2. Aktifkan reuse koneksi TCP:

    sudo sysctl -w net.ipv4.tcp_tw_reuse=1
  3. Jalankan ulang pengujian stres wrk. Jika pesan Socket errors: connect 54 tidak muncul lagi, perbaikan berhasil.

Setelah pengujian selesai, nonaktifkan reuse koneksi TCP untuk menghindari efek tak terduga pada layanan lain: sysctl -w net.ipv4.tcp_tw_reuse=0.

Langkah selanjutnya