All Products
Search
Document Center

Simple Log Service:Instal LoongCollector di Kubernetes

Last Updated:May 28, 2026

LoongCollector adalah agen pengumpulan log generasi berikutnya untuk Simple Log Service (SLS) dan penerus Logtail. Instalasikan di kluster Kubernetes menggunakan mode DaemonSet atau sidecar.

Prasyarat

Sebelum menginstal LoongCollector, verifikasi konektivitas jaringan antara node kluster Anda dan titik akhir SLS.

  1. Dapatkan titik akhir:

    1. Masuk ke Konsol Simple Log Service. Di daftar proyek, klik proyek tujuan.

    2. Klik ikon image di samping nama proyek untuk membuka halaman ikhtisar proyek.

    3. Di bagian titik akhir, temukan titik akhir publik dan pribadi untuk wilayah proyek tersebut.

  2. Jalankan uji konektivitas: Masuk ke node kluster dan jalankan perintah curl berikut. Ganti ${PROJECT_NAME} dan ${SLS_ENDPOINT} dengan nilai aktual Anda.

    curl https://${PROJECT_NAME}.${SLS_ENDPOINT}
  3. Periksa hasilnya:

    • Jika perintah mengembalikan {"Error":{"Code":"OLSInvalidMethod",...}}, koneksi jaringan antara node Anda dan Simple Log Service telah terbentuk.

      Catatan

      Error ini diharapkan — pengujian hanya memverifikasi konektivitas jaringan. SLS mengembalikan error karena permintaan tidak memiliki parameter API yang diperlukan.

    • Jika perintah timeout atau mengembalikan error seperti Connection refused, periksa konfigurasi jaringan node, aturan security group, dan resolusi DNS.

Pilih metode instalasi

Pilih metode berdasarkan jenis kluster Anda.

Metode instalasi

Kasus penggunaan

Instal di kluster ACK (mode DaemonSet)

Kumpulkan log dari kluster ACK yang dikelola dan kluster khusus dalam akun dan wilayah Alibaba Cloud yang sama.

Instal di kluster self-managed (mode DaemonSet)

  • Kumpulkan log dari kluster ACK di akun atau wilayah Alibaba Cloud yang berbeda.

  • Kumpulkan log dari kluster Kubernetes di pusat data lokal.

  • Kumpulkan log dari kluster Kubernetes di penyedia cloud lain.

Instal dalam mode Sidecar

Kumpulkan log dari aplikasi tertentu dengan persyaratan berikut:

  • Isolasi resource: Mencegah agen DaemonSet memengaruhi pod lain di node tersebut.

  • Pengumpulan detail halus: Konfigurasikan sumber pengumpulan, aturan filter, dan tujuan output yang terpisah untuk setiap aplikasi.

Instal di kluster ACK (mode DaemonSet)

Catatan

Jika melakukan upgrade dari logtail-ds, uninstal terlebih dahulu sebelum menginstal LoongCollector.

Instal LoongCollector dengan satu klik di Konsol ACK. Secara default, log kontainer dikumpulkan ke proyek dalam akun dan wilayah yang sama. Untuk pengumpulan cross-account atau cross-region, lihat Instal di kluster self-managed (mode DaemonSet).

Kluster ACK yang sudah ada

  1. Masuk ke Konsol ACK. Di panel navigasi kiri, klik Clusters.

  2. Di halaman Clusters, klik nama kluster Anda. Di panel navigasi kiri, klik Components and Add-ons.

  3. Di tab Logs and Monitoring, temukan LoongCollector, lalu klik Install.

  4. Setelah instalasi, SLS secara otomatis membuat resource berikut di wilayah kluster, yang dapat dilihat di Konsol Simple Log Service.

    Type

    Parameter

    Deskripsi

    Project

    k8s-log-${cluster_id}

    Unit manajemen sumber daya yang mengisolasi log dari layanan berbeda.

    machine group

    k8s-group-${cluster_id}

    Machine group untuk pengumpulan log loongcollector-ds.

    k8s-group-${cluster_id}-cluster

    Machine group untuk pengumpulan metrik loongcollector-cluster.

    k8s-group-${cluster_id}-singleton

    Machine group untuk pengumpulan instans tunggal.

    Penting

    LoongCollector tidak membuat LogStore bernama config-operation-log. Jika sudah ada, LoongCollector tidak menulis ke dalamnya.

Kluster ACK baru

  1. Masuk ke Konsol ACK. Di panel navigasi kiri, klik Clusters.

  2. Klik Create Cluster. Di halaman Component Configurations, pilih kotak centang Enable Log Service, lalu pilih Create New Project atau Use Existing Project.

    Topik ini hanya mencakup konfigurasi terkait SLS. Pengaturan kluster lainnya didokumentasikan di Buat kluster ACK yang dikelola.
  3. Jika Anda memilih Create Project, SLS secara otomatis membuat resource berikut. Anda dapat melihatnya di Konsol Simple Log Service.

    Type

    Parameter

    Deskripsi

    Project

    k8s-log-${cluster_id}

    Unit manajemen sumber daya yang mengisolasi log dari layanan berbeda.

    machine group

    k8s-group-${cluster_id}

    Machine group untuk pengumpulan log loongcollector-ds.

    k8s-group-${cluster_id}-cluster

    Machine group untuk pengumpulan metrik loongcollector-cluster.

    k8s-group-${cluster_id}-singleton

    Machine group untuk pengumpulan instans tunggal.

    Penting

    LoongCollector tidak membuat LogStore bernama config-operation-log. Jika sudah ada, LoongCollector tidak menulis ke dalamnya.

Instal di kluster self-managed (mode DaemonSet)

Kasus penggunaan

  • Kluster Kubernetes di pusat data lokal

  • Kluster Kubernetes yang dideploy di penyedia cloud lain

  • Mengumpulkan log kontainer dari kluster ACK Alibaba Cloud di akun atau wilayah berbeda

Catatan

Pastikan kluster self-managed Anda menjalankan Kubernetes 1.6 atau lebih baru.

Prosedur

  1. Unduh dan ekstrak paket instalasi: Di mesin dengan kubectl yang telah dikonfigurasi, jalankan perintah sesuai wilayah kluster Anda.

    # Wilayah di Tiongkok daratan
    wget https://aliyun-observability-release-cn-shanghai.oss-cn-shanghai.aliyuncs.com/loongcollector/k8s-custom-pkg/3.2.6/loongcollector-custom-k8s-package.tgz; tar xvf loongcollector-custom-k8s-package.tgz; chmod 744 ./loongcollector-custom-k8s-package/k8s-custom-install.sh
    # Wilayah di luar Tiongkok daratan
    wget https://aliyun-observability-release-ap-southeast-1.oss-ap-southeast-1.aliyuncs.com/loongcollector/k8s-custom-pkg/3.2.6/loongcollector-custom-k8s-package.tgz; tar xvf loongcollector-custom-k8s-package.tgz; chmod 744 ./loongcollector-custom-k8s-package/k8s-custom-install.sh
  2. Edit values.yaml: Di direktori loongcollector-custom-k8s-package, edit ./loongcollector/values.yaml.

    Deskripsi

    values.yaml

    # ===================== Parameter Wajib =====================
    # Nama Proyek untuk pengumpulan log di kluster ini. Contoh: k8s-log-custom-sd89ehdq
    projectName: ""
    # Wilayah Proyek. Contoh untuk Shanghai: cn-shanghai
    region: ""
    # ID akun Alibaba Cloud yang memiliki Proyek. Sertakan ID dalam tanda kutip. Contoh: "123456789"
    aliUid: ""
    # Jenis jaringan yang digunakan. Opsi: Internet atau Intranet. Default: Internet
    net: Internet
    # ID AccessKey dan rahasia AccessKey dari akun Alibaba Cloud atau Pengguna RAM.
    accessKeyID: ""
    accessKeySecret: ""
    # ID kluster kustom. ID dapat berisi huruf kapital, huruf kecil, angka, dan tanda hubung (-).
    clusterID: ""
    
    # ... Parameter opsional lainnya dihilangkan ...

    projectName String (Wajib)

    Nama Proyek tempat LoongCollector mengunggah log. Konvensi penamaan sebagai berikut:

    • Nama Proyek hanya boleh berisi huruf kecil, angka, dan tanda hubung (-).

    • Harus dimulai dengan huruf kecil dan diakhiri dengan huruf kecil atau angka.

    • Nama harus terdiri dari 3 hingga 63 karakter.

    region String (Wajib)

    ID wilayah tempat Proyek berada. Untuk daftar ID wilayah, lihat Wilayah.

    aliUid String (Wajib)

    ID Akun Alibaba Cloud yang memiliki Proyek.

    net String (Wajib)

    Jenis jaringan yang digunakan untuk transmisi data log.

    • Internet (default): Jaringan publik.

    • Intranet: Jaringan internal.

    accessKeyID  String (Wajib)

    ID AccessKey untuk akun yang memiliki proyek. Untuk keamanan lebih baik, gunakan AccessKey Pengguna RAM dengan kebijakan AliyunLogFullAccess. Ikhtisar Pengguna RAM.

    accessKeySecret String (Wajib)

    Rahasia AccessKey untuk ID AccessKey yang ditentukan.

    clusterID String (Wajib)

    ID kustom untuk kluster. ID hanya boleh berisi huruf kapital, huruf kecil, angka, dan tanda hubung (-).

    Penting

    Jangan memberikan ID kluster yang sama untuk kluster Kubernetes yang berbeda.

  3. Jalankan skrip instalasi: Dari direktori loongcollector-custom-k8s-package, jalankan perintah berikut untuk menginstal LoongCollector.

    bash k8s-custom-install.sh install
  4. Verifikasi instalasi: Jalankan perintah berikut untuk memeriksa status komponen:

    # Periksa status pod
    kubectl get po -n kube-system | grep loongcollector-ds

    Contoh output:

    loongcollector-ds-gnmnh   1/1     Running   0    63s

    Jika komponen gagal dimulai (statusnya bukan Running):

    1. Periksa parameter di values.yaml.

    2. Periksa image: Jalankan perintah berikut dan periksa bagian Events untuk memastikan image berhasil ditarik.

      kubectl describe pod loongcollector-ds -n kube-system
  5. Setelah instalasi, SLS secara otomatis membuat resource berikut, yang dapat dilihat di Konsol Simple Log Service.

    Jenis resource

    Nama resource

    Tujuan

    Project

    projectName yang ditentukan di file values.yaml

    Unit manajemen sumber daya yang mengisolasi log dari layanan berbeda.

    machine group

    k8s-group-${cluster_id}

    Sekelompok node yang digunakan untuk pengumpulan log.

    k8s-group-${cluster_id}-cluster

    Machine group untuk loongcollector-cluster. Digunakan untuk pengumpulan metrik.

    k8s-group-${cluster_id}-singleton

    Machine group instans tunggal untuk pengumpulan instans tunggal.

    Penting

    LoongCollector tidak membuat Logstore bernama config-operation-log. Jika sudah ada, LoongCollector berhenti menulis ke dalamnya.

Instal dalam mode sidecar

Gunakan mode sidecar untuk manajemen log detail halus, isolasi multi-tenant, atau pengumpulan log yang terikat siklus hidup. Kontainer LoongCollector khusus disuntikkan ke setiap pod aplikasi. Untuk menguji prosesnya, gunakan Lampiran: Contoh YAML.

1. Modifikasi konfigurasi YAML pod

  1. Definisikan volume bersama

    Di spec.template.spec.volumes, tambahkan tiga volume bersama pada level yang sama dengan containers:

    volumes:
      # Direktori log bersama (ditulis oleh kontainer aplikasi, dibaca oleh sidecar)
      - name: ${shared_volume_name} # <-- Nama harus sesuai dengan nama di volumeMounts
        emptyDir: {}
      # Direktori sinyal untuk komunikasi antar-kontainer (untuk mulai/berhenti mulus)
      - name: tasksite
        emptyDir:
          medium: Memory  # Gunakan memori sebagai media untuk performa lebih baik
          sizeLimit: "50Mi"
      # Konfigurasi zona waktu host bersama: Menyinkronkan zona waktu untuk semua kontainer di pod
      - name: tz-config # <-- Nama harus sesuai dengan nama di volumeMounts
        hostPath:
          path: /usr/share/zoneinfo/Asia/Shanghai  # Ubah zona waktu sesuai kebutuhan
    
  2. Konfigurasikan mount kontainer aplikasi

    Di bagian volumeMounts kontainer aplikasi Anda, seperti your-business-app-container, tambahkan mount volume berikut:

    Pastikan kontainer aplikasi menulis log ke direktori ${shared_volume_path} agar LoongCollector dapat mengumpulkannya.
    volumeMounts:
      # Mount volume log bersama ke direktori output log aplikasi
      - name: ${shared_volume_name}
        mountPath: ${shared_volume_path}  # Contoh: /var/log/app
      # Mount direktori komunikasi
      - name: tasksite
        mountPath: /tasksite  # Direktori bersama untuk komunikasi dengan kontainer LoongCollector
      # Mount file zona waktu
      - name: tz-config
        mountPath: /etc/localtime
        readOnly: true
    
  3. Suntikkan kontainer sidecar LoongCollector

    Di array spec.template.spec.containers, tambahkan definisi kontainer sidecar berikut:

    - name: loongcollector
      image: aliyun-observability-release-registry.cn-shenzhen.cr.aliyuncs.com/loongcollector/loongcollector:v3.1.1.0-20fa5eb-aliyun
      command: ["/bin/bash", "-c"]
      args:
        - |
          echo "[$(date)] LoongCollector: Memulai inisialisasi"
          # Mulai layanan LoongCollector
          /etc/init.d/loongcollectord start
          # Tunggu konfigurasi diunduh dan layanan siap
          sleep 15
          # Verifikasi status layanan
          if /etc/init.d/loongcollectord status; then
            echo "[$(date)] LoongCollector: Layanan berhasil dimulai"
            touch /tasksite/cornerstone
          else
            echo "[$(date)] LoongCollector: Gagal memulai layanan"
            exit 1
          fi
          # Tunggu kontainer aplikasi selesai (melalui sinyal file tombstone)
          echo "[$(date)] LoongCollector: Menunggu kontainer aplikasi selesai"
          until [[ -f /tasksite/tombstone ]]; do
            sleep 2
          done
          # Beri waktu untuk mengunggah log yang tersisa
          echo "[$(date)] LoongCollector: Bisnis selesai, menunggu transmisi log"
          sleep 30
          # Hentikan layanan
          echo "[$(date)] LoongCollector: Menghentikan layanan"
          /etc/init.d/loongcollectord stop
          echo "[$(date)] LoongCollector: Shutdown selesai"
      # Pemeriksaan kesehatan
      livenessProbe:
        exec:
          command: ["/etc/init.d/loongcollectord", "status"]
        initialDelaySeconds: 30
        periodSeconds: 10
        timeoutSeconds: 5
        failureThreshold: 3
      # Konfigurasi resource
      resources:
        requests:
          cpu: "100m"
          memory: "128Mi"
        limits:
          cpu: "2000m"
          memory: "2048Mi"
      # Konfigurasi variabel lingkungan
      env:
        - name: ALIYUN_LOGTAIL_USER_ID
          value: "${your_aliyun_user_id}"
        - name: ALIYUN_LOGTAIL_USER_DEFINED_ID
          value: "${your_machine_group_user_defined_id}"
        - name: ALIYUN_LOGTAIL_CONFIG
          value: "/etc/ilogtail/conf/${your_region_config}/ilogtail_config.json"
        # Aktifkan mode full drain untuk memastikan semua log dikirim sebelum pod dihentikan
        - name: enable_full_drain_mode
          value: "true"  
        # Tambahkan informasi lingkungan pod sebagai tag log
        - name: ALIYUN_LOG_ENV_TAGS
          value: "_pod_name_|_pod_ip_|_namespace_|_node_name_|_node_ip_"
        # Secara otomatis menyuntikkan metadata pod dan node sebagai tag log
        - name: "_pod_name_"
          valueFrom:
            fieldRef:
              fieldPath: metadata.name
        - name: "_pod_ip_"
          valueFrom:
            fieldRef:
              fieldPath: status.podIP
        - name: "_namespace_"
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace
        - name: "_node_name_"
          valueFrom:
            fieldRef:
              fieldPath: spec.nodeName
        - name: "_node_ip_"
          valueFrom:
            fieldRef:
              fieldPath: status.hostIP
      # Mount volume (dibagi dengan kontainer aplikasi)
      volumeMounts:
        # Mount baca-saja untuk direktori log aplikasi
        - name: ${shared_volume_name} # <-- Nama direktori log bersama
          mountPath: ${dir_containing_your_files} # <-- Path ke direktori bersama di sidecar
          readOnly: true
        # Mount direktori komunikasi
        - name: tasksite
          mountPath: /tasksite
        # Mount zona waktu
        - name: tz-config
          mountPath: /etc/localtime
          readOnly: true
    

2. Sesuaikan logika siklus hidup kontainer aplikasi

Bergantung pada jenis workload, modifikasi kontainer aplikasi untuk mendukung keluar yang terkoordinasi dengan sidecar:

Tugas berumur pendek (Job/CronJob)

# 1. Tunggu LoongCollector siap
echo "[$(date)] Aplikasi: Menunggu LoongCollector siap..."
until [[ -f /tasksite/cornerstone ]]; do
  sleep 1
done
echo "[$(date)] Aplikasi: LoongCollector siap, memulai logika aplikasi"
# 2. Jalankan logika inti aplikasi (pastikan log ditulis ke direktori bersama)
echo "Hello, World!" >> /app/logs/business.log
# 3. Simpan kode keluar
retcode=$?
echo "[$(date)] Aplikasi: Tugas selesai dengan kode keluar: $retcode"
# 4. Beri tahu LoongCollector bahwa tugas aplikasi selesai
touch /tasksite/tombstone
echo "[$(date)] Aplikasi: Tombstone dibuat, keluar"
exit $retcode

Layanan berumur panjang (Deployment / StatefulSet)

# Definisikan fungsi penanganan sinyal
_term_handler() {
    echo "[$(date)] [nginx-demo] Menerima SIGTERM, memulai shutdown mulus..."
    # Kirim sinyal QUIT ke Nginx untuk berhenti mulus
    if [ -n "$NGINX_PID" ]; then
        kill -QUIT "$NGINX_PID" 2>/dev/null || true
        echo "[$(date)] [nginx-demo] Mengirim SIGQUIT ke PID Nginx: $NGINX_PID"
        # Tunggu Nginx berhenti secara mulus
        wait "$NGINX_PID"
        EXIT_CODE=$?
        echo "[$(date)] [nginx-demo] Nginx berhenti dengan kode keluar: $EXIT_CODE"
    fi
    # Beri tahu LoongCollector bahwa kontainer aplikasi telah berhenti
    echo "[$(date)] [nginx-demo] Menulis file tombstone"
    touch /tasksite/tombstone
    exit $EXIT_CODE
}
# Daftarkan penanganan sinyal
trap _term_handler SIGTERM SIGINT SIGQUIT
# Tunggu LoongCollector siap
echo "[$(date)] [nginx-demo]: Menunggu LoongCollector siap..."
until [[ -f /tasksite/cornerstone ]]; do 
    sleep 1
done
echo "[$(date)] [nginx-demo]: LoongCollector siap, memulai logika aplikasi"
# Mulai Nginx
echo "[$(date)] [nginx-demo] Memulai Nginx..."
nginx -g 'daemon off;' &
NGINX_PID=$!
echo "[$(date)] [nginx-demo] Nginx dimulai dengan PID: $NGINX_PID"
# Tunggu proses Nginx
wait $NGINX_PID
EXIT_CODE=$?
# Juga beri tahu LoongCollector jika keluar bukan karena sinyal
if [ ! -f /tasksite/tombstone ]; then
    echo "[$(date)] [nginx-demo] Keluar tak terduga, menulis tombstone"
    touch /tasksite/tombstone
fi
exit $EXIT_CODE

3. Atur periode tenggang terminasi

Di spec.template.spec, atur periode tenggang terminasi yang cukup lama untuk memungkinkan LoongCollector mengunggah semua log yang tersisa.

spec:
  # ... Konfigurasi spec lainnya ...
  template:
    spec:
      terminationGracePeriodSeconds: 600  # Periode berhenti mulus 10 menit

4. Variabel

Parameter

Deskripsi

${your_aliyun_user_id}

ID akun Alibaba Cloud Anda. Untuk informasi selengkapnya, lihat Konfigurasi pengenal pengguna.

${your_machine_group_user_defined_id}

Pengenal kustom yang digunakan untuk membuat machine group. Contoh: nginx-log-sidecar.

Penting

Pastikan pengenal ini unik dalam wilayah Proyek.

${your_region_config}

Konfigurasi yang sesuai dengan wilayah dan jenis akses jaringan Proyek Layanan Log Anda. Untuk informasi tentang wilayah, lihat Wilayah layanan.

Contoh: Jika Proyek Anda berada di wilayah Tiongkok (Hangzhou), gunakan cn-hangzhou untuk akses jaringan internal Alibaba Cloud atau cn-hangzhou-internet untuk akses jaringan publik.

${shared_volume_name}

Nama kustom untuk volume bersama.

Penting

name di volumeMounts harus sesuai dengan name di volumes. Ini memastikan kedua kontainer memasang volume bersama yang sama.

${dir_containing_your_files}

Path mount di kontainer LoongCollector tempat log teks berada.

5. Terapkan konfigurasi dan verifikasi

  1. Jalankan perintah berikut untuk menerapkan perubahan:

    kubectl apply -f <YOUR-YAML>
  2. Periksa status pod untuk memastikan kontainer LoongCollector berhasil disuntikkan:

    kubectl describe pod <YOUR-POD-NAME>

    Jika Anda melihat dua kontainer (kontainer aplikasi dan loongcollector) dan statusnya Running, suntikan berhasil.

6. Buat kelompok mesin pengenal kustom

  1. Masuk ke Konsol Simple Log Service dan klik proyek target.

  2. Di bilah navigasi kiri, pilih imageResources > Machine Groups, lalu klik Machine Group > Create Machine Group di sebelah kanan Machine Groups.

  3. Di kotak dialog Create Machine Group, konfigurasikan parameter berikut dan klik OK.

    • Name: Nama machine group. Nama tidak dapat diubah setelah dibuat. Konvensi penamaan sebagai berikut:

      • Hanya boleh berisi huruf kecil, angka, tanda hubung (-), dan garis bawah (_).

      • Harus dimulai dan diakhiri dengan huruf kecil atau angka.

      • Harus terdiri dari 2 hingga 128 karakter.

    • Machine Group Identifier: Pilih Custom Identifier.

    • Custom Identifier: Masukkan nilai variabel lingkungan ALIYUN_LOGTAIL_USER_DEFINED_ID yang Anda atur untuk kontainer LoongCollector di 1. Modifikasi konfigurasi YAML Pod layanan. Nilainya harus persis sama, atau asosiasi akan gagal.

  4. Setelah machine group dibuat, periksa status heartbeat-nya dengan mengklik namanya dan melihat area status.

    • OK: LoongCollector berhasil terhubung ke Simple Log Service dan mendaftarkan machine group.

    • FAIL:

Setiap pod menjalankan instans LoongCollector sendiri. Gunakan pengenal kustom unik per aplikasi atau lingkungan untuk manajemen detail halus.

FAQ

Pengumpulan cross-account atau cross-region

Secara default, LoongCollector yang diinstal dari Konsol ACK mengumpulkan log kontainer ke proyek SLS dalam akun yang sama. Untuk pengumpulan cross-account atau cross-region, gunakan salah satu metode berikut:

Metode 1: Uninstal dan instal ulang loongcollector.

  1. Masuk ke Konsol ACK. Di panel navigasi kiri, klik Clusters.

  2. Di halaman Clusters, klik nama kluster Anda. Di panel navigasi kiri, klik Components and Add-ons.

  3. Di tab Logs and Monitoring, temukan loongcollector dan klik Uninstall.

  4. Instal ulang menggunakan prosedur Instal di kluster self-managed (mode DaemonSet).

Metode 2: Perbarui konfigurasi Helm dan redeploy loongcollector.

  1. Masuk ke Konsol ACK. Di panel navigasi kiri, pilih Apply > Helm.

  2. Di halaman Helm, temukan loongcollector dan klik Update di kolom Actions. Di halaman Update Release, modifikasi parameter seperti pada tabel di bawah dan klik OK.

    Kluster dan proyek

    Parameter

    Akun sama, wilayah berbeda

    region: RegionID wilayah tempat proyek berada.

    net: Atur nilainya ke internet. Data tidak dapat ditransfer antar-wilayah melalui intranet.

    Akun berbeda, wilayah sama

    aliUid: ID akun Alibaba Cloud yang memiliki proyek Simple Log Service. Pisahkan beberapa ID akun dengan koma (,).

    net: Atur nilainya ke intranet. Transfer data dalam wilayah yang sama lebih efisien melalui intranet.

    Akun berbeda, wilayah berbeda

    aliUid: ID akun Alibaba Cloud yang memiliki proyek Simple Log Service. Pisahkan beberapa ID akun dengan koma (,).

    region: RegionID wilayah tempat proyek berada.

    net: Atur nilainya ke internet. Data tidak dapat ditransfer antar-wilayah melalui intranet.

  3. Buat machine group:

    1. Masuk ke Konsol Simple Log Service dan klik proyek target.

    2. Di panel navigasi kiri, pilih imageResources > > Machine Groups. Di sebelah Machine Groups, pilih Machine Group > > Create Machine Group.

    3. Di kotak dialog Create Machine Group, konfigurasikan parameter berikut dan klik OK.

      1. Masukkan nama untuk machine group.

      2. Untuk Machine Group Identifier, pilih Custom Identifier.

      3. Pengenal kustom: k8s-group-${cluster_id}. Ganti ${cluster_id} dengan clusterID aktual kluster.

    4. Setelah machine group dibuat, temukan di daftar machine group dan klik namanya. Di bagian Machine Group Configurations > > Machine Group Status, periksa status Heartbeat. Status Heartbeat OK menunjukkan machine group beroperasi dengan benar. Jika statusnya bukan OK, verifikasi bahwa pengenal pengguna dan pengenal kustom benar.

  4. Setelah selesai melakukan modifikasi, klik Update.


Pengumpulan log untuk kluster lain

Langkah selanjutnya

Setelah menginstal LoongCollector, tinjau Kumpulkan log kontainer dari kluster Kubernetes untuk konsep inti dan praktik terbaik, lalu buat konfigurasi pengumpulan:

Lampiran: Contoh YAML

Konfigurasi YAML lengkap untuk Job Kubernetes dan Deployment dengan kontainer sidecar LoongCollector.

Sebelum memulai, ganti tiga placeholder berikut:

  1. Ganti ${your_aliyun_user_id} dengan UID akun Alibaba Cloud Anda.

  2. Ganti ${your_machine_group_user_defined_id} dengan ID kustom machine group yang Anda buat di Langkah 3. ID harus persis sama.

  3. Ganti ${your_region_config} dengan nama konfigurasi yang sesuai dengan wilayah dan jenis jaringan Proyek Layanan Log (SLS) Anda.

    Contoh: Untuk Proyek di wilayah Tiongkok (Hangzhou), gunakan cn-hangzhou untuk akses jaringan internal atau cn-hangzhou-internet untuk akses jaringan publik.

Tugas berumur pendek (Job/CronJob)

apiVersion: batch/v1
kind: Job
metadata:
  name: demo-job
spec:
  backoffLimit: 3                   
  activeDeadlineSeconds: 3600        
  completions: 1                     
  parallelism: 1                    
  template:
    spec:
      restartPolicy: Never         
      terminationGracePeriodSeconds: 300 
      containers:
        # Kontainer aplikasi
        - name: demo-job
          image: debian:bookworm-slim
          command: ["/bin/bash", "-c"]
          args:
            - |
              # Tunggu LoongCollector siap.
              echo "[$(date)] Bisnis: Menunggu LoongCollector siap..."
              until [[ -f /tasksite/cornerstone ]]; do 
                sleep 1
              done
              echo "[$(date)] Bisnis: LoongCollector siap, memulai logika bisnis"
              # Jalankan logika aplikasi.
              echo "Hello, World!" >> /app/logs/business.log
              # Simpan kode keluar.
              retcode=$?
              echo "[$(date)] Bisnis: Tugas selesai dengan kode keluar: $retcode"
              # Beri tahu LoongCollector bahwa tugas selesai.
              touch /tasksite/tombstone
              echo "[$(date)] Bisnis: Tombstone dibuat, keluar"
              exit $retcode
          # Permintaan dan batas resource
          resources:
            requests:
              cpu: "100m"
              memory: "128Mi"
            limits:
              cpu: "500"
              memory: "512Mi"
          # mount volume
          volumeMounts:
            - name: app-logs
              mountPath: /app/logs
            - name: tasksite
              mountPath: /tasksite
        # Kontainer sidecar LoongCollector
        - name: loongcollector
          image: aliyun-observability-release-registry.cn-hongkong.cr.aliyuncs.com/loongcollector/loongcollector:v3.1.1.0-20fa5eb-aliyun
          command: ["/bin/bash", "-c"]
          args:
            - |
              echo "[$(date)] LoongCollector: Memulai inisialisasi"
              # Mulai layanan LoongCollector.
              /etc/init.d/loongcollectord start
              # Tunggu konfigurasi diunduh dan layanan siap.
              sleep 15
              # Verifikasi status layanan.
              if /etc/init.d/loongcollectord status; then
                echo "[$(date)] LoongCollector: Layanan berhasil dimulai"
                touch /tasksite/cornerstone
              else
                echo "[$(date)] LoongCollector: Gagal memulai layanan"
                exit 1
              fi
              # Tunggu kontainer aplikasi selesai.
              echo "[$(date)] LoongCollector: Menunggu kontainer bisnis selesai"
              until [[ -f /tasksite/tombstone ]]; do 
                sleep 2
              done
              echo "[$(date)] LoongCollector: Bisnis selesai, menunggu transmisi log"
              # Beri waktu cukup untuk mengirim log yang tersisa.
              sleep 30
              echo "[$(date)] LoongCollector: Menghentikan layanan"
              /etc/init.d/loongcollectord stop
              echo "[$(date)] LoongCollector: Shutdown selesai"
          # pemeriksaan kesehatan
          livenessProbe:
            exec:
              command: ["/etc/init.d/loongcollectord", "status"]
            initialDelaySeconds: 30
            periodSeconds: 10
            timeoutSeconds: 5
            failureThreshold: 3
          # Permintaan dan batas resource
          resources:
            requests:
              cpu: "100m"
              memory: "128Mi"
            limits:
              cpu: "500m"
              memory: "512Mi"
          # variabel lingkungan
          env:
            - name: ALIYUN_LOGTAIL_USER_ID
              value: "your-user-id"
            - name: ALIYUN_LOGTAIL_USER_DEFINED_ID
              value: "your-user-defined-id"
            - name: ALIYUN_LOGTAIL_CONFIG
              value: "/etc/ilogtail/conf/cn-hongkong/ilogtail_config.json"
            - name: ALIYUN_LOG_ENV_TAGS
              value: "_pod_name_|_pod_ip_|_namespace_|_node_name_"
            # Suntikkan metadata pod.
            - name: "_pod_name_"
              valueFrom:
                fieldRef:
                  fieldPath: metadata.name
            - name: "_pod_ip_"
              valueFrom:
                fieldRef:
                  fieldPath: status.podIP
            - name: "_namespace_"
              valueFrom:
                fieldRef:
                  fieldPath: metadata.namespace
            - name: "_node_name_"
              valueFrom:
                fieldRef:
                  fieldPath: spec.nodeName
          # mount volume
          volumeMounts:
            - name: app-logs
              mountPath: /app/logs
              readOnly: true
            - name: tasksite
              mountPath: /tasksite
            - name: tz-config
              mountPath: /etc/localtime
              readOnly: true
      # Definisi volume
      volumes:
        - name: app-logs
          emptyDir: {}
        - name: tasksite
          emptyDir:
            medium: Memory
            sizeLimit: "10Mi"
        - name: tz-config
          hostPath:
            path: /usr/share/zoneinfo/Asia/Shanghai

Layanan berumur panjang (Deployment / StatefulSet)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-demo
  namespace: production
  labels:
    app: nginx-demo
    version: v1.0.0
spec:
  replicas: 3
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 1      
      maxSurge: 1          
  selector:
    matchLabels:
      app: nginx-demo
  template:
    metadata:
      labels:
        app: nginx-demo
        version: v1.0.0    
    spec:
      terminationGracePeriodSeconds: 600  # Periode shutdown mulus 10 menit
      containers:
        # Kontainer aplikasi - Aplikasi web
        - name: nginx-demo
          image: anolis-registry.cn-zhangjiakou.cr.aliyuncs.com/openanolis/nginx:1.14.1-8.6          
          # Perintah startup dan penanganan sinyal
          command: ["/bin/sh", "-c"]
          args:
            - |
              # Definisikan penanganan sinyal.
              _term_handler() {
                  echo "[$(date)] [nginx-demo] Menerima SIGTERM, memulai shutdown mulus..."
                  # Kirim sinyal QUIT ke Nginx untuk berhenti mulus.
                  if [ -n "$NGINX_PID" ]; then
                      kill -QUIT "$NGINX_PID" 2>/dev/null || true
                      echo "[$(date)] [nginx-demo] Mengirim SIGQUIT ke PID Nginx: $NGINX_PID"
                      # Tunggu Nginx berhenti secara mulus.
                      wait "$NGINX_PID"
                      EXIT_CODE=$?
                      echo "[$(date)] [nginx-demo] Nginx berhenti dengan kode keluar: $EXIT_CODE"
                  fi
                  # Beri tahu LoongCollector bahwa kontainer aplikasi telah berhenti.
                  echo "[$(date)] [nginx-demo] Menulis file tombstone"
                  touch /tasksite/tombstone
                  exit $EXIT_CODE
              }
              # Daftarkan penanganan sinyal.
              trap _term_handler SIGTERM SIGINT SIGQUIT
              # Tunggu LoongCollector siap.
              echo "[$(date)] [nginx-demo]: Menunggu LoongCollector siap..."
              until [[ -f /tasksite/cornerstone ]]; do 
                sleep 1
              done
              echo "[$(date)] [nginx-demo]: LoongCollector siap, memulai logika bisnis"
              # Mulai Nginx.
              echo "[$(date)] [nginx-demo] Memulai Nginx..."
              nginx -g 'daemon off;' &
              NGINX_PID=$!
              echo "[$(date)] [nginx-demo] Nginx dimulai dengan PID: $NGINX_PID"
              # Tunggu proses Nginx keluar.
              wait $NGINX_PID
              EXIT_CODE=$?
              # Jika proses keluar tanpa sinyal, beri tahu LoongCollector.
              if [ ! -f /tasksite/tombstone ]; then
                  echo "[$(date)] [nginx-demo] Keluar tak terduga, menulis tombstone"
                  touch /tasksite/tombstone
              fi
              exit $EXIT_CODE
          # Permintaan dan batas resource
          resources:
            requests:
              cpu: "200m"
              memory: "256Mi"
            limits:
              cpu: "1000m"
              memory: "1Gi"
          # mount volume
          volumeMounts:
            - name: nginx-logs
              mountPath: /var/log/nginx
            - name: tasksite
              mountPath: /tasksite
            - name: tz-config
              mountPath: /etc/localtime
              readOnly: true
        # Kontainer sidecar LoongCollector
        - name: loongcollector
          image: aliyun-observability-release-registry.cn-shenzhen.cr.aliyuncs.com/loongcollector/loongcollector:v3.1.1.0-20fa5eb-aliyun
          command: ["/bin/bash", "-c"]
          args:
            - |
              echo "[$(date)] LoongCollector: Memulai inisialisasi"
              # Mulai layanan LoongCollector.
              /etc/init.d/loongcollectord start
              # Tunggu konfigurasi diunduh dan layanan siap.
              sleep 15
              # Verifikasi status layanan.
              if /etc/init.d/loongcollectord status; then
                echo "[$(date)] LoongCollector: Layanan berhasil dimulai"
                touch /tasksite/cornerstone
              else
                echo "[$(date)] LoongCollector: Gagal memulai layanan"
                exit 1
              fi
              # Tunggu kontainer aplikasi selesai.
              echo "[$(date)] LoongCollector: Menunggu kontainer bisnis selesai"
              until [[ -f /tasksite/tombstone ]]; do 
                sleep 2
              done
              echo "[$(date)] LoongCollector: Bisnis selesai, menunggu transmisi log"
              # Beri waktu cukup untuk mengirim log yang tersisa.
              sleep 30
              echo "[$(date)] LoongCollector: Menghentikan layanan"
              /etc/init.d/loongcollectord stop
              echo "[$(date)] LoongCollector: Shutdown selesai"
          # pemeriksaan kesehatan
          livenessProbe:
            exec:
              command: ["/etc/init.d/loongcollectord", "status"]
            initialDelaySeconds: 30
            periodSeconds: 10
            timeoutSeconds: 5
            failureThreshold: 3
          # Permintaan dan batas resource
          resources:
            requests:
              cpu: "100m"
              memory: "128Mi"
            limits:
              cpu: "2000m"
              memory: "2048Mi"
          # variabel lingkungan
          env:
            - name: ALIYUN_LOGTAIL_USER_ID
              value: "${your_aliyun_user_id}"
            - name: ALIYUN_LOGTAIL_USER_DEFINED_ID
              value: "${your_machine_group_user_defined_id}"
            - name: ALIYUN_LOGTAIL_CONFIG
              value: "/etc/ilogtail/conf/${your_region_config}/ilogtail_config.json"
            # Aktifkan mode full drain untuk mengirim semua log saat pod berhenti.
            - name: enable_full_drain_mode
              value: "true"
            # Tambahkan informasi lingkungan pod sebagai tag log.
            - name: "ALIYUN_LOG_ENV_TAGS"
              value: "_pod_name_|_pod_ip_|_namespace_|_node_name_|_node_ip_"
            # Dapatkan informasi pod dan node.
            - name: "_pod_name_"
              valueFrom:
                fieldRef:
                  fieldPath: metadata.name
            - name: "_pod_ip_"
              valueFrom:
                fieldRef:
                  fieldPath: status.podIP
            - name: "_namespace_"
              valueFrom:
                fieldRef:
                  fieldPath: metadata.namespace
            - name: "_node_name_"
              valueFrom:
                fieldRef:
                  fieldPath: spec.nodeName
            - name: "_node_ip_"
              valueFrom:
                fieldRef:
                  fieldPath: status.hostIP
          # mount volume
          volumeMounts:
            - name: nginx-logs
              mountPath: /var/log/nginx
              readOnly: true
            - name: tasksite
              mountPath: /tasksite
            - name: tz-config
              mountPath: /etc/localtime
              readOnly: true
      # Definisi volume
      volumes:
        - name: nginx-logs
          emptyDir: {}
        - name: tasksite
          emptyDir:
            medium: Memory
            sizeLimit: "50Mi"
        - name: tz-config
          hostPath:
            path: /usr/share/zoneinfo/Asia/Shanghai

Referensi

Wilayah

  1. Masuk ke Konsol Simple Log Service. Di daftar Project, klik Project target.

  2. Klik ikon image di samping nama Project untuk membuka halaman ikhtisar proyek.

  3. Di bagian Informasi Dasar, Anda dapat melihat nama wilayah Project saat ini. Untuk pemetaan antara nama wilayah dan Region ID, lihat tabel berikut.

    Wilayah adalah lokasi pusat data fisik untuk sumber daya cloud Anda. Region ID secara unik mengidentifikasi setiap wilayah.

    Nama wilayah

    Region ID

    Tiongkok (Qingdao)

    cn-qingdao

    Tiongkok (Beijing)

    cn-beijing

    Tiongkok (Zhangjiakou)

    cn-zhangjiakou

    Tiongkok (Hohhot)

    cn-huhehaote

    Tiongkok (Ulanqab)

    cn-wulanchabu

    Tiongkok (Hangzhou)

    cn-hangzhou

    Tiongkok (Shanghai)

    cn-shanghai

    Tiongkok (Nanjing - Local Region - Decommissioning)

    cn-nanjing

    Tiongkok (Fuzhou - Local Region - Decommissioning)

    cn-fuzhou

    Tiongkok (Shenzhen)

    cn-shenzhen

    Tiongkok (Heyuan)

    cn-heyuan

    Tiongkok (Guangzhou)

    cn-guangzhou

    Filipina (Manila)

    ap-southeast-6

    Korea Selatan (Seoul)

    ap-northeast-2

    Malaysia (Kuala Lumpur)

    ap-southeast-3

    Jepang (Tokyo)

    ap-northeast-1

    Thailand (Bangkok)

    ap-southeast-7

    Tiongkok (Chengdu)

    cn-chengdu

    Singapura

    ap-southeast-1

    Indonesia (Jakarta)

    ap-southeast-5

    Tiongkok (Hong Kong)

    cn-hongkong

    Jerman (Frankfurt)

    eu-central-1

    AS (Virginia)

    us-east-1

    AS (Silicon Valley)

    us-west-1

    Inggris (London)

    eu-west-1

    UEA (Dubai)

    me-east-1

    Arab Saudi (Riyadh)

    me-central-1

Jenis transfer jaringan

Titik akhir SLS adalah URL yang digunakan untuk mengakses proyek dan data log-nya. Titik akhir ditentukan oleh wilayah proyek. SLS menyediakan titik akhir pribadi, publik, dan percepatan. Untuk melihat titik akhir:

  1. Masuk ke Konsol Simple Log Service dan klik proyek target di daftar Project.

  2. Klik ikon image di samping nama proyek untuk membuka halaman Ikhtisar Proyek.

  3. Di bagian Titik Akhir, Anda dapat melihat informasi titik akhir untuk proyek saat ini. Metode transmisi jaringan berbeda menggunakan titik akhir berbeda. Memilih metode transmisi jaringan yang sesuai membantu memastikan transfer data lebih cepat dan stabil.

Jenis jaringan

Jenis titik akhir

Deskripsi

Skenario

Jaringan internal Alibaba Cloud

Titik akhir pribadi

Jaringan internal Alibaba Cloud adalah jaringan bersama gigabit. Mengirim data log melalui jaringan internal Alibaba Cloud lebih cepat dan stabil dibandingkan melalui internet. Jaringan internal mencakup VPC dan jaringan klasik.

Instance ECS dan proyek SLS berada di wilayah yang sama, atau server lokal terhubung ke jaringan internal.

Catatan

Buat proyek SLS di wilayah yang sama dengan instance ECS Anda. Ini memungkinkan pengumpulan log melalui jaringan internal Alibaba Cloud tanpa mengonsumsi bandwidth internet.

internet

Titik akhir publik

Mengirim data log melalui internet dibatasi oleh bandwidth jaringan dan dipengaruhi oleh faktor seperti jitter, latensi, dan kehilangan paket.

Anda dapat mentransmisikan data melalui internet dalam skenario berikut:

  • Instance ECS dan proyek SLS berada di wilayah berbeda.

  • Server berasal dari penyedia cloud lain atau merupakan IDC lokal.

Akselerasi transfer

Titik akhir percepatan

Metode ini menggunakan node edge CDN Alibaba Cloud untuk mempercepat pengumpulan log. Ini mengurangi latensi dan meningkatkan stabilitas dibandingkan pengumpulan log melalui internet, tetapi menimbulkan biaya trafik tambahan.

Untuk transmisi data lintas wilayah antara Tiongkok daratan dan wilayah lain, akselerasi transfer mengurangi latensi. Akselerasi transfer.

Mode operasi

Fitur

Mode DaemonSet

Sidecar mode

Metode deployment

Men-deploy satu kontainer pengumpulan di setiap node.

Men-deploy satu kontainer pengumpulan di setiap Pod.

Konsumsi resource

Rendah (berbagi resource node)

Lebih tinggi (setiap Pod mengonsumsi resource secara independen)

Kasus penggunaan

Pengumpulan log terpadu di tingkat node

Pengumpulan log terisolasi untuk aplikasi tertentu

Isolasi

Berbagi di tingkat node

Kemandirian di tingkat Pod

Mode DaemonSet

Agen LoongCollector dideploy di setiap node di kluster untuk mengumpulkan log dari semua kontainer di node tersebut. Mode ini memiliki operasi sederhana, konsumsi resource rendah, dan konfigurasi fleksibel, tetapi menawarkan isolasi yang lebih lemah antar-tenant.

  • Dalam mode DaemonSet, kluster Kubernetes memastikan hanya satu kontainer LoongCollector yang berjalan di setiap node untuk mengumpulkan log dari semua kontainer di node tersebut.

  • Ketika node baru bergabung ke kluster, Kubernetes secara otomatis membuat kontainer LoongCollector di atasnya. Ketika node meninggalkan kluster, Kubernetes secara otomatis menghancurkan kontainer LoongCollector di node tersebut. Penskalaan otomatis ini berarti Anda tidak perlu mengelola instans LoongCollector secara manual.

Mode Sidecar

Di setiap pod, kontainer sidecar LoongCollector disuntikkan bersama kontainer aplikasi. Direktori log kontainer aplikasi dipasang sebagai volume bersama menggunakan mekanisme volume Kubernetes, seperti emptyDir, hostPath, atau PVC. Hal ini membuat file log dapat diakses oleh kontainer aplikasi dan kontainer sidecar, sehingga LoongCollector dapat membacanya secara langsung. Mode ini menyediakan isolasi multi-tenant yang kuat dan performa tinggi tetapi mengonsumsi lebih banyak resource dan lebih kompleks untuk dikonfigurasi serta dipelihara.

  • Dalam mode sidecar, setiap pod menjalankan kontainer LoongCollector khusus untuk mengumpulkan log dari semua kontainer lain dalam pod yang sama. Pengumpulan log diisolasi antar-pod yang berbeda.

  • Untuk mengumpulkan file log dari kontainer lain dalam pod yang sama, Anda harus menggunakan volume bersama. Volume yang sama harus dipasang ke kontainer aplikasi dan kontainer LoongCollector.

  • Jika volume data dari satu pod di node sangat besar dan melebihi kapasitas pengumpulan agen DaemonSet, mode sidecar memungkinkan Anda mengalokasikan resource khusus untuk LoongCollector, meningkatkan performa dan stabilitas pengumpulannya.

  • Lingkungan kontainer serverless tidak memiliki konsep node, sehingga mode deployment DaemonSet tidak dapat diterapkan. Dalam kasus ini, mode sidecar terintegrasi secara efektif dengan arsitektur serverless, memastikan proses pengumpulan log yang fleksibel dan adaptif.