Object Storage Service：Gunakan hingga 100 Gbit/s bandwidth melalui jaringan internal

Kemampuan Penerimaan Jaringan

Jika Anda menginstal klien OSS pada instance ECS, kecepatan unduhan data dibatasi oleh kecepatan jaringan instance ECS. Model Alibaba Cloud dengan kemampuan jaringan terkuat dapat menyediakan bandwidth hingga 160 Gbit/s. Jika Anda menerapkan beberapa instance dalam kluster, total bandwidth dapat mencapai 100 Gbit/s ketika klien diakses secara konkuren. Untuk satu instance, gunakan keluarga instance yang ditingkatkan jaringannya atau keluarga instance dengan kecepatan clock tinggi untuk performa optimal saat menerima sejumlah besar paket data.

Disk I/O

Setelah data diunduh ke komputer lokal, jika Anda ingin menyimpan data di disk, kecepatan unduhan dibatasi oleh performa disk. Secara default, alat seperti ossutil dan ossfs menyimpan data di disk. Dalam hal ini, gunakan disk berperforma tinggi atau disk memori untuk meningkatkan kecepatan unduhan, seperti ditunjukkan pada gambar berikut.

Gunakan VPC

Jaringan internal Alibaba Cloud dioptimalkan untuk permintaan data jaringan. Saat menggunakan titik akhir VPC, jaringan lebih stabil daripada Internet. Untuk mencapai bandwidth unduhan maksimum, gunakan VPC.

Instance ECS Anda berjalan di VPC Anda. OSS menyediakan domain internal terpadu yang dapat diakses oleh pelanggan mana pun melalui VPC, misalnya: oss-cn-beijing-internal.aliyuncs.com. Aliran data antara ECS dan OSS melewati Server Load Balancer (SLB), dan permintaan dikirim ke kluster terdistribusi backend. Ini mendistribusikan permintaan data secara merata di seluruh kluster dan memberikan OSS kemampuan pemrosesan konkuren tinggi yang kuat.

Unduhan konkuren

OSS menggunakan protokol HTTP untuk mentransmisikan data. Karena keterbatasan performa permintaan HTTP tunggal, unduhan konkuren digunakan untuk mempercepat unduhan data. Misalnya, Anda dapat membagi objek menjadi beberapa rentang sehingga setiap permintaan hanya mengakses satu rentang untuk mencapai bandwidth unduhan maksimum. Anda dikenakan biaya berdasarkan jumlah Operasi API. Semakin banyak rentang berarti semakin banyak Operasi API, tetapi tidak menjamin kecepatan unduhan puncak selama unduhan data aliran tunggal. Untuk informasi lebih lanjut tentang cara menggunakan alat umum untuk unduhan konkuren, lihat Optimalkan unduhan konkuren menggunakan alat umum.

Lingkungan Pengujian

Prosedur Pengujian

1. Konfigurasikan variabel lingkungan.

   export OSS_ACCESS_KEY_ID=<ALIBABA_CLOUD_ACCESS_KEY_ID>
   export OSS_ACCESS_KEY_SECRET=<ALIBABA_CLOUD_ACCESS_KEY_SECRET>

2. Kode contoh:

   package main
   
   import (
       "context"
       "flag"
       "fmt"
       "io"
       "log"
       "time"
       "github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
       "github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
   )
   
   // Tentukan variabel global untuk menyimpan parameter baris perintah.
   var (
       region     string // Wilayah tempat bucket berada.
       endpoint    string // Titik akhir bucket tempat bucket berada.
       bucketName string                     // Nama bucket.
       objectName  string // Nama objek.
       chunkSize   int64  // Ukuran chunk. Unit: byte.
       prefetchNum int // Jumlah chunk yang akan diprefetch.
   )
   
   // Inisialisasi fungsi untuk mengurai parameter baris perintah.
   func init() {
       flag.StringVar(&region, "region", "", "Wilayah tempat bucket berada.")
       flag.StringVar(&endpoint, "endpoint", "", "Nama domain yang dapat digunakan layanan lain untuk mengakses OSS.")
       flag.StringVar(&bucketName, "bucket", "", "Nama bucket.")
       flag.StringVar(&objectName, "object", "", "Nama objek.")
       flag.Int64Var(&chunkSize, "chunk-size", 0, "Ukuran chunk, dalam byte")
       flag.IntVar(&prefetchNum, "prefetch-num", 0, "Jumlah prefetch")
   }
   
   func main() {
       // Mengurai parameter baris perintah.
       flag.Parse()
   
       // Periksa apakah parameter yang diperlukan telah ditentukan.
       if len(bucketName) == 0 {
           flag.PrintDefaults()
           log.Fatalf("parameter tidak valid, nama bucket diperlukan")
       }
   
       if len(region) == 0 {
           flag.PrintDefaults()
           log.Fatalf("parameter tidak valid, wilayah diperlukan")
       }
   
       // Konfigurasikan instance OSSClient.
       cfg := oss.LoadDefaultConfig().
           WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()). // Gunakan kredensial dalam variabel lingkungan.
           WithRegion(region) // Tentukan wilayah.
   
       // Jika titik akhir kustom disediakan, tentukan titik akhir.
       if len(endpoint) > 0 {
           cfg.WithEndpoint(endpoint)
       }
   
       // Buat instance OSSClient.
       client := oss.NewClient(cfg)
   
       // Buka objek OSS.
       f, err := client.OpenFile(context.TODO(), bucketName, objectName, func(oo *oss.OpenOptions) {
           oo.EnablePrefetch = true // Aktifkan mode prefetch.
           oo.ChunkSize = chunkSize      // Tentukan ukuran chunk.
           oo.PrefetchNum=prefetchNum // Tentukan jumlah chunk yang akan diprefetch.
           oo.PrefetchThreshold=int64 (0) // Tentukan ambang batas prefetch.
       })
   
       if err != nil {
           log.Fatalf("gagal membuka, err:%v", err)
       }
   
       // Catat waktu mulai.
       startTick := time.Now().UnixNano() / 1000 / 1000
   
       // Baca dan buang isi file yang digunakan untuk menguji kecepatan pembacaan.
       written, err := io.Copy(io.Discard, f)
   
       // Catat waktu akhir.
       endTick := time.Now().UnixNano() / 1000 / 1000
   
       if err != nil {
           log.Fatalf("gagal menyalin, err:%v", err)
       }
   
       // Hitung kecepatan pembacaan. Unit: MiB/s.
       speed := float64(written/1024/1024) / float64((endTick-startTick)/1000)
   
       // Tampilkan kecepatan pembacaan rata-rata.
       fmt.Printf("kecepatan rata-rata:%.2f(MiB/s)\n", speed)
   }

3. Mulai program pengujian.

   go run down_object.go -bucket yourbucket -endpoint oss-cn-hangzhou-internal.aliyuncs.com  -object 100GB.file -region cn-hangzhou -chunk-size 419430400 -prefetch-num 256

Kesimpulan Pengujian

Dalam proses di atas, kami menyesuaikan konkurensi dan ukuran chunk untuk mengamati perubahan durasi unduhan dan bandwidth puncak. Secara umum, kami merekomendasikan Anda mengatur konkurensi menjadi 1 hingga 4 kali jumlah core dan mengatur ukuran chunk menjadi nilai FileSize/Konkurensi. Ukuran chunk tidak boleh kurang dari 2 MB. Durasi unduhan terpendek dapat dicapai dan bandwidth puncak mencapai 100 Gbit/s berdasarkan konfigurasi parameter.

ossutil

• Deskripsi Parameter

  Parameter	Deskripsi
  --bigfile-threshold	Ambang batas ukuran objek untuk menggunakan unduhan yang dapat dilanjutkan. Nilai default: 104857600 (100 MB). Nilai valid: 0 hingga 9223372036854775807. Unit: byte.
  --range	Rentang byte objek yang akan diunduh. Byte dinomori mulai dari 0. Anda dapat menentukan rentang. Misalnya, 3-9 menunjukkan rentang dari byte 3 hingga byte 9, yang mencakup byte 3 dan byte 9. Anda dapat menentukan rentang dari mana unduhan dimulai. Misalnya, 3- menunjukkan rentang dari byte 3 hingga akhir objek, yang mencakup byte 3. Anda dapat menentukan rentang dari mana unduhan berakhir. Misalnya, -9 menunjukkan rentang dari byte 0 hingga byte 9, yang mencakup byte 9.
  --parallel	Jumlah operasi konkuren yang akan dilakukan pada satu objek. Nilai valid: 1 hingga 10000. Secara default, ossutil secara otomatis menetapkan nilai untuk opsi ini berdasarkan jenis operasi dan ukuran objek.
  --part-size	Ukuran bagian. Unit: byte. Nilai valid: 2097152 hingga 16777216 (2 hingga 16 MB). Dalam kebanyakan kasus, jika jumlah core CPU besar, Anda dapat mengatur ukuran bagian yang kecil. Jika jumlah core CPU kecil, Anda dapat meningkatkan ukuran bagian secara tepat.

• Contoh

  Jalankan perintah berikut untuk mengatur konkurensi menjadi 256 dan ukuran bagian menjadi 468435456 untuk mengunduh objek 100GB.file dari bucket tujuan ke direktori /dev/shm dan mencatat durasi unduhan.

  time ossutil --parallel=256 --part-size=468435456 --endpoint=oss-cn-hangzhou-internal.aliyuncs.com cp oss://cache-test/EcsTest/100GB.file /dev/shm/100GB.file

• Deskripsi Performa

  Kecepatan rata-rata ujung ke ujung adalah 2,94 GB/s (sekitar 24 Gbit/s).

  

ossfs

• Deskripsi Parameter

  Parameter	Deskripsi
  parallel_count	Jumlah bagian yang dapat diunduh secara konkuren saat pengunggahan multipart digunakan untuk mengunggah objek besar. Nilai default: 5.
  multipart_size	Ukuran bagian dalam MB saat pengunggahan multipart digunakan untuk mengunggah data. Nilai default: 10. Parameter ini membatasi ukuran maksimum objek yang dapat Anda unggah. Saat pengunggahan multipart digunakan, jumlah maksimum bagian yang dapat dibagi menjadi sebuah objek adalah 10.000. Secara default, ukuran maksimum objek yang dapat diunggah adalah 100 GB. Anda dapat mengubah nilai opsi ini untuk mengunggah objek yang lebih besar.
  direct_read	Mengaktifkan mode baca langsung. Secara default, ossfs menggunakan kapasitas penyimpanan disk untuk menyimpan data sementara yang diunggah atau diunduh. Anda dapat menentukan opsi ini untuk membaca data langsung dari OSS alih-alih disk lokal. Opsi ini dinonaktifkan secara default. Anda dapat menggunakan -odirect_read untuk mengaktifkan mode baca langsung. Catatan Baca langsung terganggu ketika operasi tulis, ubah nama, atau truncate dilakukan pada objek yang sedang dibaca. Dalam hal ini, objek keluar dari mode baca langsung dan harus dibuka kembali.
  direct_read_prefetch_chunks	Jumlah chunk yang dapat diprefetch ke memori. Opsi ini dapat digunakan untuk mengoptimalkan performa pembacaan sekuensial. Nilai default: 32. Opsi ini hanya berlaku jika opsi -odirect_read ditentukan.
  direct_read_chunk_size	Jumlah data yang dapat dibaca langsung dari OSS dalam satu permintaan baca. Unit: MB. Nilai default: 4. Nilai valid: 1 hingga 32. Opsi ini hanya berlaku jika opsi -odirect_read ditentukan.
  ensure_diskfree	Ukuran kapasitas disk yang dicadangkan, yang digunakan untuk mencegah kapasitas disk sepenuhnya terisi dan memengaruhi aplikasi lain untuk menulis data. Secara default, kapasitas disk tidak dicadangkan. Unit: MB. Sebagai contoh, jika Anda ingin mengatur kapasitas disk cadangan ossfs menjadi 1024 MB, Anda dapat menentukan -oensure_diskfree=1024.
  free_space_ratio	Rasio ruang disk tersisa minimum yang ingin Anda cadangkan. Sebagai contoh, jika ruang disk adalah 50 GB dan Anda mengatur -o free_space_ratio menjadi 20, maka 10 GB (50 GB x 20% = 10 GB) akan dicadangkan.
  max_stat_cache_size	Jumlah maksimum file yang metadata-nya dapat disimpan dalam cache metadata. Secara default, metadata hingga 100.000 objek dapat di-cache. Jika direktori berisi sejumlah besar objek, Anda dapat memodifikasi opsi ini untuk meningkatkan performa daftar objek dari perintah Is. Untuk menonaktifkan caching metadata, Anda dapat mengatur opsi ini ke 0.
  stat_cache_expire	Masa berlaku cache metadata objek. Unit: detik. Nilai default: 900.
  readdir_optimize	Menentukan apakah akan menggunakan optimasi cache. Nilai default: false. Jika Anda menentukan parameter ini, ossfs tidak akan mengirimkan permintaan HeadObject untuk mendapatkan metadata objek seperti gid dan uid saat Anda menjalankan perintah ls. Permintaan HeadObject hanya dikirim jika ukuran objek yang diakses adalah 0. Namun, sejumlah permintaan HeadObject tertentu mungkin masih dikirim karena alasan seperti pemeriksaan izin. Tentukan parameter berdasarkan karakteristik aplikasi. Untuk menggunakan optimasi cache, tentukan parameter -oreaddir_optimize.

• Contoh

  Catatan

  Kami merekomendasikan Anda memodifikasi parameter berdasarkan kemampuan pemrosesan CPU dan bandwidth jaringan.

  • Mode baca default: Mount bucket bernama cache-test ke folder /mnt/cache-test di komputer Anda, atur jumlah bagian yang dapat diunduh secara konkuren menjadi 128, dan atur setiap bagian menjadi 32 MB.

    ossfs cache-test /mnt/cache-test -ourl=http://oss-cn-hangzhou-internal.aliyuncs.com  -oparallel_count=128 -omultipart_size=32 

  • Mode baca langsung: Mount bucket bernama cache-test ke folder /mnt/cache-test di komputer Anda, aktifkan mode baca langsung, atur jumlah chunk yang diprefetch menjadi 128, dan atur setiap chunk menjadi 32 MB.

    ossfs cache-test /mnt/cache-test -ourl=http://oss-cn-hangzhou-internal.aliyuncs.com  -odirect_read -odirect_read_prefetch_chunks=128 -odirect_read_chunk_size=32

• Deskripsi Performa

  Dalam mode baca default, ossfs mengunduh data ke disk lokal. Dalam mode baca langsung, data disimpan di memori, yang mempercepat akses, tetapi mengonsumsi lebih banyak memori.

  Catatan

  Dalam mode baca langsung, ossfs mengelola data yang diunduh dalam chunk. Ukuran setiap chunk adalah 4 MB secara default dan dapat diubah menggunakan parameter direct_read_chunk_size. Di memori, ossfs mempertahankan data dalam rentang berikut: [Chunk saat ini - 1, Chunk saat ini + direct_read_prefetch_chunks]. Tentukan apakah akan menggunakan mode baca langsung berdasarkan ukuran memori, terutama cache halaman. Dalam kebanyakan kasus, mode baca langsung cocok untuk skenario di mana kapasitas cache halaman tidak mencukupi. Sebagai contoh, jika total memori komputer Anda adalah 16 GB dan cache halaman dapat mengonsumsi 6 GB, Anda dapat menggunakan mode baca langsung ketika ukuran objek melebihi 6 GB. Untuk informasi lebih lanjut, lihat Mode baca langsung.

  Mode	Konkurensi	Ukuran chunk (MB)	Bandwidth puncak (Gbit/s)	Bandwidth E2E (Gbit/s)	Durasi E2E (s)
  Mode baca default	128	32	24	11.3	72.01
  Mode baca langsung	128	32	24	16.1	50.9

  Optimasi untuk pembacaan objek model:

  Ukuran objek model (GB)	Mode baca default (Durasi: s; memori maksimum: 6 GB)	Mode baca hybrid (Durasi: s)	Mode baca hybrid (Durasi: s; retensi data: [-32, +32])
  1	8.19	8.20	8.56
  2.4	24.5	20.43	20.02
  5	26.5	22.3	19.89
  5.5	22.8	23.1	22.98
  8.5	106.0	36.6	36.00
  12.6	154.6	42.1	41.9

Python SDK

Dalam skenario pelatihan model AI, OSS SDK for Python mengakses layanan penyimpanan backend dalam mode serial secara default. Dengan menggunakan transformasi multi-threaded dari pustaka konkuren Python, bandwidth meningkat secara signifikan.

• Prasyarat

  Ukuran objek model sekitar 5,6 GB, dan spesifikasi mesin uji adalah ECS48vCPU, dengan bandwidth 16 Gbit/s dan memori 180 GB.

• Contoh

  import oss2
  import time
  import os
  import threading
  from io import BytesIO
  
  # Konfigurasikan parameter.
  OSS_CONFIG = {
      "bucket_endpoint": os.environ.get('OSS_BUCKET_ENDPOINT', 'oss-cn-hangzhou-internal.aliyuncs.com'), # Titik akhir default wilayah tempat bucket berada.
      "bucket_name": os.environ.get('OSS_BUCKET_NAME', 'bucket_name'), # Nama bucket.
      "access_key_id": os.environ['ACCESS_KEY_ID'], # ID AccessKey dari pengguna RAM.
      "access_key_secret": os.environ['ACCESS_KEY_SECRET'] # Rahasia AccessKey dari pengguna RAM.
  }
  
  # Inisialisasi bucket.
  def __bucket__():
      auth = oss2.Auth(OSS_CONFIG["access_key_id"], OSS_CONFIG["access_key_secret"])
      return oss2.Bucket(
          auth, 
          OSS_CONFIG["bucket_endpoint"], 
          OSS_CONFIG["bucket_name"], 
          enable_crc=False
      )
  
  # Kueri ukuran objek model.
  def __get_object_size(object_name):
      simplifiedmeta = __bucket__().get_object_meta(object_name)
      return int(simplifiedmeta.headers['Content-Length'])
  
  # Kueri waktu modifikasi terakhir objek model.
  def get_remote_model_mmtime(model_name):
      return __bucket__().head_object(model_name).last_modified
  
  # Daftar objek model.
  def list_remote_models(ext_filter=('.ckpt',)): # Tentukan filter ekstensi default.
      dir_prefix = ""
      output = []
      
      for obj in oss2.ObjectIteratorV2(
          __bucket__(),
          prefix=dir_prefix,
          delimiter='/',
          start_after=dir_prefix,
          fetch_owner=False
      ):
          if not obj.is_prefix():
              _, ext = os.path.splitext(obj.key)
              if ext.lower() in ext_filter:
                  output.append(obj.key)
      return output
  
  # Unduh fungsi thread unduhan multipart berdasarkan chunk.
  def __range_get(object_name, buffer, offset, start, end, read_chunk_size, progress_callback, total_bytes):
      chunk_size = int(read_chunk_size)
      with __bucket__().get_object(object_name, byte_range=(start, end)) as object_stream:
          s = start
          while True:
              chunk = object_stream.read(chunk_size)
              if not chunk:
                  break
              buffer.seek(s - offset)
              buffer.write(chunk)
              s += len(chunk)
              # Hitung jumlah byte yang diunduh dan panggil fungsi callback kemajuan unduhan.
              if progress_callback:
                  progress_callback(s - start, total_bytes)
  
  # Baca objek model dan tentukan parameter callback kemajuan opsional.
  def read_remote_model(
      checkpoint_file, 
      start=0, 
      size=-1, 
      read_chunk_size=2*1024*1024,  # 2MB
      part_size=256*1024*1024,      # 256MB
      progress_callback=None # Callback kemajuan unduhan.
  ):
      time_start = time.time()
      buffer = BytesIO()
      obj_size = __get_object_size(checkpoint_file)
      
      end = (obj_size if size == -1 else start + size) - 1
      s = start
      tasks = []
  
      # Hitung kemajuan.
      total_bytes = end - start + 1
      downloaded_bytes = 0
  
      while s <= end:
          current_end = min(s + part_size - 1, end)
          task = threading.Thread(
              target=__range_get,
              args=(checkpoint_file, buffer, start, s, current_end, read_chunk_size, progress_callback, total_bytes)
          )
          tasks.append(task)
          task.start()
          s += part_size
  
      for task in tasks:
          task.join()
  
      time_end = time.time()
      # Tampilkan total unduhan objek.
      print(f"Mengunduh {checkpoint_file} dalam {time_end - time_start:.2f} detik.")
  
       # Hitung dan tampilkan ukuran objek yang diunduh. Unit: GB.
      file_size_gb = obj_size / (1024 * 1024 * 1024)
      print(f"Total ukuran file yang diunduh: {file_size_gb:.2f} GB")
  
      buffer.seek(0)
      return buffer
  
  # Tentukan fungsi callback kemajuan unduhan.
  def show_progress(downloaded, total):
      progress = (downloaded / total) * 100
      print(f"Kemajuan: {progress:.2f}%", end="\r")
  
  # Panggil fungsi callback kemajuan unduhan.
  if __name__ == "__main__":
      # Gunakan metode list_remote_models untuk mendaftar objek model.
      models = list_remote_models()
      print("Model remote:", models)
  
      if models:
          # Unduh objek model pertama.
          first_model = models[0]
          buffer = read_remote_model(first_model, progress_callback=show_progress)
          print(f"\nMengunduh {first_model} ke buffer.")

• Kesimpulan

  Versi	Durasi OSS (s)	Bandwidth rata-rata OSS (Mbit/s)	Bandwidth puncak OSS (Mbit/s)
  OSS SDK for Python (mode serial)	109	53	100
  OSS SDK for Python (mode unduhan konkuren)	11.1	516	600

  Dari hasil di atas, OSS SDK for Python (mode unduhan konkuren) mengonsumsi sekitar 0,2% durasi yang dikonsumsi oleh OSS SDK for Python (mode serial), bandwidth rata-rata dan puncak OSS SDK for Python (mode unduhan konkuren) adalah sekitar 9,7 kali dan 6 kali dari OSS SDK for Python (mode serial), masing-masing. Saat menggunakan OSS SDK for Python untuk melatih model AI, mode unduhan konkuren dapat sangat meningkatkan efisiensi pemrosesan dan performa bandwidth.

• Solusi Lainnya

  Selain OSS SDK for Python, Alibaba Cloud menyediakan pustaka Python bernama osstorchconnector, yang terutama digunakan untuk mengakses dan menyimpan data OSS secara efisien dalam tugas pelatihan PyTorch. Pustaka ini telah menyelesaikan enkapsulasi sekunder unduhan konkuren untuk pengguna. Tabel berikut menjelaskan hasil pengujian pada pemuatan model AI menggunakan osstorchconnector. Untuk informasi lebih lanjut, lihat Pengujian Performa.

  Item	Deskripsi
  Skenario Pengujian	Pemuatan model dan chat Q&A
  Nama Model	gpt3-finnish-3B
  Ukuran Model	11 GB
  Skenario	Chat Q&A
  Konfigurasi Perangkat Keras	Instance ECS spesifikasi tinggi: 96 vCPU, 384 GiB memori, dan bandwidth internal 30 Gbit/s
  Kesimpulan	Bandwidth rata-rata sekitar 10 Gbit/s. OSS dapat mendukung 10 tugas untuk memuat model secara bersamaan.