Membuat rumus untuk menskalakan simpul komputasi secara otomatis dalam kumpulan Batch

  • Artikel

Azure Batch dapat secara otomatis menskalakan kumpulan berdasarkan parameter yang Anda tentukan, sehingga menghemat waktu dan uang Anda. Dengan penskalaan otomatis, Batch secara dinamis menambahkan simpul ke kumpulan saat tuntutan tugas meningkat, dan menghapus simpul komputasi saat tuntutan tugas berkurang.

Untuk mengaktifkan penskalaan otomatis pada kumpulan simpul komputasi, Anda mengaitkan kumpulan dengan rumus skala otomatis yang Anda tentukan. Layanan Batch menggunakan rumus skala otomatis untuk menentukan berapa banyak simpul yang diperlukan untuk menjalankan beban kerja Anda. Simpul ini dapat berupa simpul khusus atau simpul Azure Spot. Batch secara berkala meninjau data metrik layanan dan menggunakannya untuk menyesuaikan jumlah simpul dalam kumpulan berdasarkan rumus Anda dan pada interval yang Anda tentukan.

Anda dapat mengaktifkan penskalaan otomatis saat membuat kumpulan, atau menerapkannya ke kumpulan yang ada. Batch memungkinkan Anda mengevaluasi rumus sebelum menetapkannya ke kumpulan dan untuk memantau status eksekusi penskalaan otomatis. Setelah Mengonfigurasi kumpulan dengan penskalaan otomatis, Anda bisa membuat perubahan pada rumus nanti.

Penting

Saat Membuat akun Batch, Anda dapat menentukan mode alokasi kumpulan, yang menentukan apakah kumpulan dialokasikan dalam langganan layanan Batch (default) atau di langganan pengguna Anda. Jika Anda membuat akun Batch dengan konfigurasi layanan Batch default, maka akun Anda terbatas pada jumlah maksimum core yang dapat digunakan untuk pemrosesan. Layanan Batch menskalakan simpul komputasi hanya sampai batas inti tersebut. Untuk alasan ini, layanan Batch mungkin tidak mencapai jumlah target simpul komputasi yang ditentukan oleh rumus skala otomatis. Untuk mempelajari cara melihat dan meningkatkan kuota akun Anda, lihat Kuota dan batasan untuk layanan Azure Batch.

Jika Anda membuat akun dengan mode langganan pengguna, maka akun Anda akan berbagi dalam kuota inti untuk langganan. Untuk informasi selengkapnya, lihat batas Komputer Virtual di langganan Azure dan batas layanan, kuota, dan batasan.

Rumus skala otomatis

Rumus skala otomatis adalah nilai untai yang Anda tentukan yang berisi satu atau beberapa pernyataan. Rumus skala otomatis ditetapkan ke elemen AutoScaleFormula kumpulan (Batch REST) atau properti CloudPool.AutoScaleFormula (Batch .NET). Layanan Batch menggunakan rumus Anda untuk menentukan jumlah target simpul komputasi dalam kumpulan untuk interval pemrosesan berikutnya. Untai rumus tidak boleh melebihi 8 KB, dapat menyertakan hingga 100 pernyataan yang dipisahkan oleh titik koma, dan dapat menyertakan jeda baris dan komentar.

Anda dapat menganggap rumus penskalaan otomatis sebagai "bahasa" skala otomatis Batch. Pernyataan rumus adalah ekspresi yang dibentuk bebas yang dapat mencakup variabel yang ditentukan layanan, yang ditentukan oleh layanan Batch, dan variabel yang ditentukan pengguna. Rumus bisa melakukan berbagai operasi pada nilai-nilai ini dengan menggunakan jenis, operator, dan fungsi bawaan. Misalnya, pernyataan mungkin berupa formulir berikut:

$myNewVariable = function($ServiceDefinedVariable, $myCustomVariable);

Rumus umumnya berisi beberapa pernyataan yang melakukan operasi pada nilai yang diperoleh dalam pernyataan sebelumnya. Misalnya, pertama-tama Anda mendapatkan nilai untuk variable1, lalu meneruskannya ke fungsi untuk mengisi variable2:

$variable1 = function1($ServiceDefinedVariable);
$variable2 = function2($OtherServiceDefinedVariable, $variable1);

Sertakan pernyataan ini dalam rumus skala otomatis Anda untuk sampai pada target jumlah simpul komputasi. Node khusus dan node Spot masing-masing memiliki pengaturan target mereka sendiri. Rumus skala otomatis dapat menyertakan nilai target untuk node khusus, nilai target untuk node Spot, atau keduanya.

Jumlah target simpul mungkin lebih tinggi, lebih rendah, atau sama dengan jumlah simpul saat ini dari jenis tersebut dalam kumpulan. Batch mengevaluasi rumus skala otomatis kumpulan pada interval penskalaan otomatis tertentu. Batch menyesuaikan jumlah target setiap jenis simpul dalam kumpulan ke angka yang ditentukan rumus skala otomatis Anda pada saat evaluasi.

Contoh rumus skala otomatis

Contoh berikut menunjukkan dua rumus skala otomatis, yang dapat disesuaikan untuk bekerja untuk sebagian besar skenario. Variabel startingNumberOfVMs dan maxNumberofVMs dalam contoh rumus dapat disesuaikan dengan kebutuhan Anda.

Tugas tertunda

Dengan rumus skala otomatis ini, kumpulan awalnya dibuat dengan satu VM. $PendingTasksMetrik menentukan jumlah tugas yang sedang berjalan atau diantrekan. Rumus menemukan jumlah rata-rata tugas yang tertunda dalam 180 detik terakhir dan menetapkan variabel $TargetDedicatedNodes. Rumus ini memastikan bahwa jumlah target simpul khusus tidak pernah melebihi 25 VM. Saat tugas baru dikirimkan, kumpulan secara otomatis bertambah besar. Saat tugas selesai, VM menjadi kosong dan rumus penskalaan otomatis menyusutkan kumpulan.

Rumus ini menskalakan node khusus, tetapi dapat dimodifikasi untuk diterapkan guna menskalakan node Spot juga.

startingNumberOfVMs = 1;
maxNumberofVMs = 25;
pendingTaskSamplePercent = $PendingTasks.GetSamplePercent(180 * TimeInterval_Second);
pendingTaskSamples = pendingTaskSamplePercent < 70 ? startingNumberOfVMs : avg($PendingTasks.GetSample(180 * TimeInterval_Second));
$TargetDedicatedNodes=min(maxNumberofVMs, pendingTaskSamples);
$NodeDeallocationOption = taskcompletion;

Penting

Saat ini, Layanan Batch memiliki batasan dengan resolusi tugas yang tertunda. Saat tugas ditambahkan ke pekerjaan, tugas juga ditambahkan ke dalam antrean internal yang digunakan oleh layanan Batch untuk penjadwalan. Jika tugas dihapus sebelum dapat dijadwalkan, tugas mungkin bertahan dalam antrean, menyebabkannya masih dihitung dalam $PendingTasks. Tugas yang dihapus ini akhirnya akan dihapus dari antrean ketika Batch mendapat kesempatan untuk menarik tugas dari antrean ke jadwal dengan simpul menganggur di kumpulan Batch.

Simpul yang didahulukan

Contoh ini membuat kumpulan yang dimulai dengan 25 node Spot. Setiap kali node Spot didahulukan, simpul diganti dengan node khusus. Seperti contoh pertama, maxNumberofVMs variabel mencegah kumpulan melebihi 25 VM. Contoh ini berguna untuk memanfaatkan Spot VM sekaligus memastikan bahwa hanya jumlah preemption tetap yang terjadi selama masa pakai kumpulan.

maxNumberofVMs = 25;
$TargetDedicatedNodes = min(maxNumberofVMs, $PreemptedNodeCount.GetSample(180 * TimeInterval_Second));
$TargetLowPriorityNodes = min(maxNumberofVMs , maxNumberofVMs - $TargetDedicatedNodes);
$NodeDeallocationOption = taskcompletion;

Anda akan mempelajari selengkapnya tentang cara membuat rumus skala otomatis dan melihat contoh rumus skala otomatis lainnya nanti di artikel ini.

Variabel

Anda dapat menggunakan variabel yang ditentukan-layanan dan yang ditentukan-pengguna dalam rumus skala otomatis Anda.

Variabel yang ditentukan layanan dibangun ke layanan Batch. Beberapa variabel yang ditentukan layanan adalah baca-tulis, dan beberapa lainnya baca-saja.

Variabel yang ditentukan pengguna adalah variabel yang Anda tentukan. Dalam contoh sebelumnya, $TargetDedicatedNodes dan $PendingTasks merupakan variabel yang ditentukan layanan, sementara startingNumberOfVMs dan maxNumberofVMs merupakan variabel yang ditentukan pengguna.

Catatan

Variabel yang ditentukan layanan selalu didahului oleh tanda dolar ($). Untuk variabel yang ditentukan pengguna, tanda dolar bersifat opsional.

Tabel berikut menunjukkan variabel baca-tulis dan baca-saja yang ditentukan oleh layanan Batch.

Variabel yang ditentukan layanan baca-tulis

Anda bisa mendapatkan dan mengatur nilai variabel yang ditentukan layanan ini untuk mengelola jumlah simpul komputasi dalam kumpulan.

Variabel Deskripsi
$TargetDedicatedNodes Jumlah target simpul komputasi khusus untuk kumpulan. Ditentukan sebagai target karena kumpulan mungkin tidak selalu mencapai jumlah simpul yang diinginkan. Misalnya, jika jumlah target simpul khusus dimodifikasi oleh evaluasi skala otomatis sebelum kumpulan mencapai target awal, kumpulan mungkin tidak mencapai target.

Kumpulan dalam akun yang dibuat dalam mode layanan Batch mungkin tidak mencapai targetnya jika target melebihi simpul akun Batch atau kuota inti. Kumpulan dalam akun yang dibuat dalam mode langganan pengguna mungkin tidak mencapai targetnya jika target melebihi kuota inti bersama untuk langganan.
$TargetLowPriorityNodes Jumlah target node komputasi Spot untuk kumpulan. Ditentukan sebagai target karena kumpulan mungkin tidak selalu mencapai jumlah simpul yang diinginkan. Misalnya, jika jumlah target simpul Spot dimodifikasi oleh evaluasi skala otomatis sebelum kumpulan mencapai target awal, kumpulan mungkin tidak mencapai target. Kumpulan mungkin juga tidak mencapai targetnya jika target melebihi simpul akun Batch atau kuota inti.

Untuk informasi selengkapnya tentang node komputasi Spot, lihat Menggunakan mesin virtual Spot dengan Batch.
$NodeDeallocationOption Tindakan yang terjadi ketika simpul komputasi dihapus dari kumpulan. Kemungkinan nilai adalah:
- Mengantre ulang: Nilai default. Segera mengakhiri tugas dan menempatkannya kembali pada antrean pekerjaan sehingga dijadwalkan ulang. Tindakan ini memastikan jumlah target simpul tercapai secepat mungkin. Namun, mungkin kurang efisien, karena tugas yang sedang berjalan terganggu dan kemudian harus dimulai ulang.
- mengakhiri: Segera mengakhiri tugas dan menghapusnya dari antrean pekerjaan.
- penyelesaian tugas: Menunggu tugas yang sedang berjalan selesai dan kemudian menghapus simpul dari kumpulan. Gunakan opsi ini untuk mencegah tugas terganggu dan diantre ulang, membuang pekerjaan apa pun yang telah dilakukan tugas.
- retaineddata: Menunggu semua data yang dipertahankan tugas lokal pada simpul untuk dibersihkan sebelum menghapus simpul dari kumpulan.

Catatan

Variabel $TargetDedicatedNodes ini juga dapat ditentukan menggunakan alias $TargetDedicated. Demikian pula, variabel $TargetLowPriorityNodes dapat ditentukan menggunakan alias $TargetLowPriority. Jika variabel bernama penuh dan aliasnya diatur oleh rumus, nilai yang ditetapkan ke variabel bernama lengkap lebih diutamakan.

Variabel yang ditentukan layanan baca-saja

Anda bisa mendapatkan nilai variabel yang ditentukan layanan ini untuk membuat penyesuaian yang didasarkan pada metrik dari layanan Batch.

Penting

Tugas rilis pekerjaan saat ini tidak disertakan dalam variabel yang menyediakan jumlah tugas, seperti $ActiveTasks dan $PendingTasks. Bergantung pada rumus skala otomatis Anda, ini dapat mengakibatkan simpul dihapus, tanpa simpul yang tersedia untuk menjalankan tugas rilis pekerjaan.

Tip

Variabel yang ditentukan layanan baca-saja adalah objek yang menyediakan berbagai metode untuk mengakses data yang terkait dengan masing-masing. Untuk informasi selengkapnya, lihat Mendapatkan data sampel nanti di artikel ini.

Variabel Deskripsi
$CPUPercent Persentase rata-rata penggunaan CPU.
$WallClockSeconds Jumlah detik yang dikonsumsi. Pensiun setelah 2024-Mar-31.
$MemoryBytes Jumlah rata-rata megabyte yang digunakan. Pensiun setelah 2024-Mar-31.
$DiskBytes Jumlah rata-rata gigabyte yang digunakan pada diska lokal. Pensiun setelah 2024-Mar-31.
$DiskReadBytes Jumlah byte yang dibaca. Pensiun setelah 2024-Mar-31.
$DiskWriteBytes Jumlah byte yang ditulis. Pensiun setelah 2024-Mar-31.
$DiskReadOps Hitungan operasi diska baca yang dilakukan. Pensiun setelah 2024-Mar-31.
$DiskWriteOps Hitungan operasi diska tulis yang dilakukan. Pensiun setelah 2024-Mar-31.
$NetworkInBytes Jumlah byte masuk. Pensiun setelah 2024-Mar-31.
$NetworkOutBytes Jumlah byte keluar. Pensiun setelah 2024-Mar-31.
$SampleNodeCount Hitungan simpul komputasi. Pensiun setelah 2024-Mar-31.
$ActiveTasks Jumlah tugas yang siap dijalankan tetapi belum dijalankan. Ini termasuk semua tugas yang dalam keadaan aktif dan yang dependensinya telah terpenuhi. Tugas apa pun yang berada dalam status aktif tetapi dependensinya belum terpenuhi dikecualikan dari $ActiveTasks hitungan. Untuk tugas multi-instans, $ActiveTasks sertakan jumlah instans yang ditetapkan pada tugas.
$RunningTasks Jumlah tugas dalam status berjalan.
$PendingTasks Jumlah dan $ActiveTasks$RunningTasks.
$SucceededTasks Jumlah tugas yang berhasil diselesaikan.
$FailedTasks Jumlah tugas yang gagal.
$TaskSlotsPerNode Jumlah slot tugas yang dapat digunakan untuk menjalankan tugas bersamaan pada satu simpul komputasi dalam kumpulan.
$CurrentDedicatedNodes Jumlah simpul komputasi khusus saat ini.
$CurrentLowPriorityNodes Jumlah simpul komputasi Spot saat ini, termasuk node apa pun yang telah dipindahkan.
$UsableNodeCount Jumlah simpul komputasi yang dapat digunakan.
$PreemptedNodeCount Jumlah simpul dalam kumpulan yang dalam keadaan dipindahkan.

Peringatan

Pilih variabel yang ditentukan layanan akan dihentikan setelah 31 Maret 2024 seperti yang tercantum dalam tabel di atas. Setelah tanggal penghentian, variabel yang ditentukan layanan ini tidak akan lagi diisi dengan data sampel. Harap berhenti menggunakan variabel ini sebelum tanggal ini.

Catatan

Gunakan $RunningTasks saat penskalaan berdasarkan jumlah tugas yang berjalan pada titik waktu tertentu, dan $ActiveTasks saat penskalaan berdasarkan jumlah tugas yang diantrekan untuk dijalankan.

Jenis

Rumus skala otomatis mendukung jenis berikut ini:

  • ganda
  • doubleVec
  • doubleVecList
  • string
  • tanda waktu--struktur gabungan yang berisi anggota berikut:
    • tahun
    • bulan (1-12)
    • hari (1-31)
    • hari kerja (dalam format angka; misalnya, 1 untuk Senin)
    • jam (dalam format angka 24 jam; misalnya, 13 berarti 1 siang)
    • menit (00-59)
    • detik (00-59)
  • timeinterval
    • TimeInterval_Zero
    • TimeInterval_100ns
    • TimeInterval_Microsecond
    • TimeInterval_Millisecond
    • TimeInterval_Second
    • TimeInterval_Minute
    • TimeInterval_Hour
    • TimeInterval_Day
    • TimeInterval_Week
    • TimeInterval_Year

Operasional

Operasi ini diperbolehkan pada jenis yang tercantum di bagian sebelumnya.

Operasi Operator yang didukung Jenis Hasil
ganda operator ganda +, -, *, / ganda
timeinterval operator ganda * timeinterval
ganda operator doubleVec +, -, *, / doubleVec
ganda operator doubleVec +, -, *, / doubleVec
ganda operator timeinterval *, / timeinterval
timeinterval operator timeinterval +, - timeinterval
tanda waktu operator timeinterval + rentang waktu
timeinterval operator tanda waktu + rentang waktu
tanda waktu operator tanda waktu - timeinterval
operator ganda -, ! ganda
timeinterval operator - timeinterval
ganda operator ganda <, <=, ==, >=, >, != ganda
untai operator untai <, <=, ==, >=, >, != ganda
tanda waktu operator tanda waktu <, <=, ==, >=, >, != ganda
timeinterval operator timeinterval <, <=, ==, >=, >, != ganda
ganda operator ganda &&, || ganda

Menguji ganda dengan operator terner (double ? statement1 : statement2), menghasilkan nonzero sebagai true, dan nol sebagai false.

Fungsi

Anda bisa menggunakan fungsi yang sudah ditentukan sebelumnya ini saat menentukan rumus skala otomatis.

Fungsi Tipe hasil Deskripsi
avg(doubleVecList) ganda Mengembalikan nilai rata-rata untuk semua nilai dalam doubleVecList.
ceil(double) ganda Mengembalikan nilai bilangan bulat terkecil tidak kurang dari ganda.
ceil(doubleVecList) doubleVec Mengembalikan komponen-bijaksana ceil dari doubleVecList.
floor(double) ganda Mengembalikan nilai bilangan bulat terbesar yang tidak lebih besar dari dua kali lipat.
floor(doubleVecList) doubleVec Mengembalikan komponen-bijaksana floor dari doubleVecList.
len(doubleVecList) ganda Mengembalikan panjang vektor yang dibuat dari doubleVecList.
lg(ganda) ganda Mengembalikan basis log 2 dari ganda.
lg(doubleVecList) doubleVec Mengembalikan komponen-bijaksana lg dari doubleVecList.
ln(double) ganda Mengembalikan log natural dari ganda.
ln(doubleVecList) doubleVec Mengembalikan komponen-bijaksana ln dari doubleVecList.
log(ganda) ganda Mengembalikan basis log 10 dari ganda.
log(doubleVecList) doubleVec Mengembalikan komponen-bijaksana log dari doubleVecList.
max(doubleVecList) ganda Mengembalikan nilai maksimum dalam doubleVecList.
min(doubleVecList) ganda Mengembalikan nilai minimum dalam doubleVecList.
norm(doubleVecList) ganda Mengembalikan dua-norma dari vektor yang dibuat dari doubleVecList.
percentile(doubleVec v, double p) ganda Mengembalikan elemen persentil dari vektor v.
rand() ganda Mengembalikan nilai acak antara 0,0 dan 1,0.
range(doubleVecList) ganda Mengembalikan perbedaan antara nilai min dan max dalam doubleVecList.
round(double) ganda Mengembalikan nilai bilangan bulat terdekat ke ganda (dalam format floating-point), membulatkan setengah huruf besar/kecil dari nol.
round(doubleVecList) doubleVec Mengembalikan komponen-bijaksana round dari doubleVecList.
std(doubleVecList) ganda Mengembalikan standar deviasi sampel dari nilai-nilai dalam doubleVecList.
stop() Menghentikan evaluasi ekspresi penskalaan otomatis.
sum(doubleVecList) ganda Mengembalikan jumlah semua komponen doubleVecList.
time(string dateTime="") rentang waktu Mengembalikan tanda waktu dari waktu saat ini jika tidak ada parameter yang dilewatkan, atau stempel waktu dari untai tanggalwaktu jika dilewatkan. Format tanggalwaktu yang didukung adalah W3C-DTF dan RFC 1123.
val(doubleVec v, double i) ganda Mengembalikan nilai elemen yang berada di lokasi i di vektor v, dengan indeks awal nol.

Beberapa fungsi yang diuraikan dalam tabel sebelumnya bisa menerima daftar sebagai argumen. Daftar yang dipisahkan koma adalah kombinasi dari double dan doubleVec. Contohnya:

doubleVecList := ( (double | doubleVec)+(, (double | doubleVec) )* )?

Nilai doubleVecList dikonversi menjadi single doubleVec sebelum dievaluasi. Misalnya, jika v = [1,2,3], maka panggilan avg(v) setara dengan panggilan avg(1,2,3). Panggilan avg(v, 7) setara dengan panggilan avg(1,2,3,7).

Metrik

Anda dapat menggunakan metrik sumber daya dan tugas saat menentukan rumus. Anda menyesuaikan jumlah target simpul khusus dalam kumpulan berdasarkan data metrik yang Anda peroleh dan evaluasi. Untuk informasi selengkapnya tentang setiap metrik, lihat bagian Variabel .

Metrik Deskripsi
Sumber daya Metrik sumber daya didasarkan pada CPU, bandwidth, penggunaan memori simpul komputasi, dan jumlah simpul.

Variabel yang ditentukan layanan ini berguna untuk membuat penyesuaian berdasarkan jumlah simpul:
- $TargetDedicatedNodes
- $TargetLowPriorityNodes
- $CurrentDedicatedNodes
- $CurrentLowPriorityNodes
- $PreemptedNodeCount
- $UsableNodeCount

Variabel yang ditentukan layanan ini berguna untuk membuat penyesuaian berdasarkan penggunaan sumber daya simpul:
- $CPUPercent
- $WallClockSeconds
- $MemoryBytes
- $DiskBytes
- $DiskReadBytes
- $DiskWriteBytes
- $DiskReadOps
- $DiskWriteOps
- $NetworkInBytes
- $NetworkOutBytes
Tugas Metrik tugas didasarkan pada status tugas, seperti Aktif, Tertunda, dan Selesai. Variabel yang ditentukan layanan berikut berguna untuk membuat penyesuaian ukuran kumpulan berdasarkan metrik tugas:
- $ActiveTasks
- $RunningTasks
- $PendingTasks
- $SucceededTasks
- $FailedTasks

Mendapatkan contoh data

Operasi inti rumus skala otomatis adalah mendapatkan data metrik tugas dan sumber daya (sampel), lalu menyesuaikan ukuran kumpulan berdasarkan data tersebut. Dengan demikian, penting untuk memiliki pemahaman yang jelas tentang bagaimana rumus skala otomatis berinteraksi dengan sampel.

Metode

Rumus skala otomatis bertindak berdasarkan sampel data metrik yang disediakan oleh layanan Batch. Rumus tumbuh atau menyusutkan simpul komputasi kumpulan berdasarkan nilai yang diperolehnya. Variabel yang ditentukan layanan adalah objek yang menyediakan metode untuk mengakses data yang terkait dengan objek tersebut. Misalnya, ekspresi berikut menunjukkan permintaan untuk mendapatkan lima menit terakhir penggunaan CPU:

$CPUPercent.GetSample(TimeInterval_Minute * 5)

Metode berikut dapat digunakan untuk mendapatkan data sampel tentang variabel yang ditentukan layanan.

Metode Deskripsi
GetSample() Metode GetSample() ini mengembalikan vektor sampel data.

Sampel bernilai 30 detik dari data metrik. Dengan kata lain, sampel diperoleh setiap 30 detik. Tetapi seperti yang disebutkan di bawah ini, ada penundaan antara ketika sampel dikumpulkan dan kapan tersedia untuk rumus. Dengan demikian, tidak semua sampel untuk periode waktu tertentu mungkin tersedia untuk dievaluasi oleh rumus.

- doubleVec GetSample(double count): Menentukan jumlah sampel yang akan diperoleh dari sampel terbaru yang dikumpulkan. GetSample(1) mengembalikan sampel terakhir yang tersedia. Namun, untuk metrik seperti $CPUPercent, GetSample(1) tidak boleh digunakan, karena tidak mungkin untuk mengetahui kapan sampel dikumpulkan. Bisa baru-baru ini, atau, karena masalah sistem, mungkin juga sudah terlalu lama. Dalam kasus seperti itu, lebih baik menggunakan interval waktu seperti yang ditunjukkan di bawah ini.

- doubleVec GetSample((timestamp or timeinterval) startTime [, double samplePercent]): Menentukan jangka waktu untuk mengumpulkan data sampel. Secara opsional, ini juga menentukan persentase sampel yang harus tersedia dalam jangka waktu yang diminta. Misalnya, $CPUPercent.GetSample(TimeInterval_Minute * 10) akan mengembalikan 20 sampel jika semua sampel selama 10 menit terakhir ada dalam CPUPercent riwayat. Jika menit terakhir riwayat tidak tersedia, hanya 18 sampel yang akan dikembalikan. Dalam kasus ini $CPUPercent.GetSample(TimeInterval_Minute * 10, 95) akan gagal karena hanya 90 persen sampel yang tersedia, tetapi $CPUPercent.GetSample(TimeInterval_Minute * 10, 80) akan berhasil.

- doubleVec GetSample((timestamp or timeinterval) startTime, (timestamp or timeinterval) endTime [, double samplePercent]): Menentukan jangka waktu untuk mengumpulkan data, dengan waktu mulai dan waktu akhir. Seperti disebutkan di atas, ada penundaan antara ketika sampel dikumpulkan dan ketika tersedia untuk rumus. Pertimbangkan penundaan ini saat Anda menggunakan metode GetSample ini. Lihat GetSamplePercent bawah.
GetSamplePeriod() Mengembalikan periode sampel yang diambil dalam rangkaian data sampel riwayat.
Count() Mengembalikan jumlah total sampel dalam riwayat metrik.
HistoryBeginTime() Mengembalikan tanda waktu sampel data tertua yang tersedia untuk metrik.
GetSamplePercent() Mengembalikan persentase sampel yang tersedia untuk interval waktu tertentu. Contohnya,doubleVec GetSamplePercent( (timestamp or timeinterval) startTime [, (timestamp or timeinterval) endTime] ). Karena metode GetSample gagal jika persentase sampel yang dikembalikan kurang dari samplePercent yang ditentukan, Anda dapat menggunakan metode GetSamplePercent untuk memeriksa terlebih dahulu. Kemudian Anda dapat melakukan tindakan alternatif jika sampel yang tidak mencukupi ada, tanpa menghentikan evaluasi penskalaan otomatis.

Sampel

Layanan Batch secara berkala mengambil sampel metrik tugas dan sumber daya dan membuatnya tersedia untuk rumus skala otomatis Anda. Sampel ini dicatat setiap 30 detik oleh layanan Batch. Namun, biasanya ada penundaan antara kapan sampel tersebut direkam dan kapan sampel tersebut tersedia untuk (dan dibaca oleh) rumus skala otomatis Anda. Selain itu, sampel mungkin tidak direkam untuk interval tertentu karena faktor-faktor seperti jaringan atau masalah infrastruktur lainnya.

Sampel persentase

Ketika samplePercent diteruskan ke GetSample() metode atau GetSamplePercent() metode dipanggil, persen mengacu pada perbandingan antara jumlah total kemungkinan sampel yang dicatat oleh layanan Batch dan jumlah sampel yang tersedia untuk rumus skala otomatis Anda.

Mari kita lihat rentang waktu 10 menit sebagai contoh. Karena sampel dicatat setiap 30 detik dalam rentang waktu 10 menit itu, jumlah total maksimum sampel yang dicatat oleh Batch adalah 20 sampel (2 per menit). Namun, karena latensi mekanisme pelaporan yang melekat dan masalah lain dalam Azure, mungkin hanya ada 15 sampel yang tersedia untuk rumus skala otomatis Anda untuk dibaca. Jadi, misalnya, untuk periode 10 menit itu, hanya 75 persen dari jumlah total sampel yang direkam mungkin tersedia untuk rumus Anda.

GetSample() dan rentang sampel

Rumus skala otomatis Anda bertambah dan menyusutkan kumpulan Anda dengan menambahkan atau menghapus simpul. Karena simpul membutuhkan biaya, pastikan rumus Anda menggunakan metode analisis cerdas yang didasarkan pada data yang memadai. Disarankan agar Anda menggunakan analisis jenis yang sedang tren dalam rumus Anda. Jenis ini membesarkan dan menyusutkan kumpulan Anda sesuai dengan rentang sampel yang dikumpulkan.

Untuk melakukannya, gunakan GetSample(interval look-back start, interval look-back end) untuk mengembalikan vektor sampel:

$runningTasksSample = $RunningTasks.GetSample(1 * TimeInterval_Minute, 6 * TimeInterval_Minute);

Saat Batch mengevaluasi baris di atas, Batch mengembalikan rentang sampel sebagai vektor nilai. Contohnya:

$runningTasksSample=[1,1,1,1,1,1,1,1,1,1];

Setelah mengumpulkan vektor sampel, Anda kemudian dapat menggunakan fungsi seperti min(), max(), dan avg() untuk mendapatkan nilai yang bermakna dari rentang yang dikumpulkan.

Untuk berhati-hati, Anda dapat memaksa evaluasi rumus gagal jika kurang dari persentase sampel tertentu tersedia untuk periode waktu tertentu. Saat Anda memaksa evaluasi rumus gagal, Anda menginstruksikan Batch untuk menghentikan evaluasi rumus lebih lanjut jika persentase sampel yang ditentukan tidak tersedia. Dalam hal ini, tidak ada perubahan yang dilakukan pada ukuran kumpulan. Untuk menentukan persentase sampel yang diperlukan agar evaluasi berhasil, tentukan sebagai parameter ketiga untuk GetSample(). Di sini, ditentukan persyaratan 75 persen sampel :

$runningTasksSample = $RunningTasks.GetSample(60 * TimeInterval_Second, 120 * TimeInterval_Second, 75);

Karena mungkin ada keterlambatan dalam ketersediaan sampel, Anda harus selalu menentukan rentang waktu dengan waktu mulai look-back yang lebih lama dari satu menit. Dibutuhkan sekitar satu menit agar sampel menyebar melalui sistem, sehingga sampel dalam rentang (0 * TimeInterval_Second, 60 * TimeInterval_Second) mungkin tidak tersedia. Sekali lagi, Anda dapat menggunakan parameter GetSample() persentase untuk memaksa persyaratan persentase sampel tertentu.

Penting

Kami sangat menyarankan agar Anda tidak mengandalkanhanya pada GetSample(1)penskalaan otomatis. Ini karena GetSample(1) pada dasarnya mengatakan kepada layanan Batch, "Beri saya sampel terakhir yang Anda miliki, tidak peduli berapa lama anda mengambilnya." Karena ini hanya sampel tunggal, dan mungkin sampel yang lebih lama, sampel mungkin tidak mewakili gambaran tugas atau status sumber daya terbaru yang lebih besar. Jika Anda menggunakan GetSample(1), pastikan bahwa itu adalah bagian dari pernyataan yang lebih besar dan bukan satu-satunya titik data yang diandalkan dalam rumus Anda.

Menulis rumus skala otomatis

Anda menyusun rumus skala otomatis dengan membentuk pernyataan yang menggunakan komponen di atas, lalu menggabungkan pernyataan tersebut ke dalam rumus lengkap. Di bagian ini, Anda membuat contoh rumus skala otomatis yang dapat melakukan keputusan penskalaan dunia nyata dan membuat penyesuaian.

Pertama, mari kita tentukan persyaratan untuk rumus skala otomatis baru kami. Rumus harus:

  • Meningkatkan jumlah target simpul komputasi khusus dalam kumpulan jika penggunaan CPU tinggi.
  • Mengurangi jumlah target simpul komputasi khusus dalam kumpulan saat penggunaan CPU rendah.
  • Selalu membatasi jumlah maksimum simpul khusus hingga 400.
  • Saat mengurangi jumlah simpul, jangan hapus simpul yang menjalankan tugas; jika perlu, tunggu sampai tugas selesai sebelum menghapus simpul.

Pernyataan pertama dalam rumus meningkatkan jumlah simpul selama penggunaan CPU yang tinggi. Anda menentukan pernyataan yang mengisi variabel yang ditentukan pengguna ($totalDedicatedNodes) dengan nilai yang 110 persen dari jumlah target simpul khusus saat ini, tetapi hanya jika penggunaan CPU rata-rata minimum selama 10 menit terakhir di atas 70 persen. Jika tidak, menggunakan nilai untuk jumlah simpul khusus saat ini.

$totalDedicatedNodes =
    (min($CPUPercent.GetSample(TimeInterval_Minute * 10)) > 0.7) ?
    ($CurrentDedicatedNodes * 1.1) : $CurrentDedicatedNodes;

Untuk mengurangi jumlah simpul khusus selama penggunaan CPU rendah, pernyataan berikutnya dalam rumus menetapkan variabel yang sama $totalDedicatedNodes menjadi 90 persen dari jumlah target simpul khusus saat ini, jika penggunaan CPU rata-rata dalam 60 menit terakhir kurang dari 20 persen. Jika tidak, ia menggunakan nilai saat ini yang $totalDedicatedNodes diisi dalam pernyataan di atas.

$totalDedicatedNodes =
    (avg($CPUPercent.GetSample(TimeInterval_Minute * 60)) < 0.2) ?
    ($CurrentDedicatedNodes * 0.9) : $totalDedicatedNodes;

Sekarang, batasi jumlah target simpul komputasi khusus hingga maksimum 400.

$TargetDedicatedNodes = min(400, $totalDedicatedNodes);

Terakhir, pastikan bahwa simpul tidak dihapus hingga tugasnya selesai.

$NodeDeallocationOption = taskcompletion;

Berikut rumus lengkapnya:

$totalDedicatedNodes =
    (min($CPUPercent.GetSample(TimeInterval_Minute * 10)) > 0.7) ?
    ($CurrentDedicatedNodes * 1.1) : $CurrentDedicatedNodes;
$totalDedicatedNodes =
    (avg($CPUPercent.GetSample(TimeInterval_Minute * 60)) < 0.2) ?
    ($CurrentDedicatedNodes * 0.9) : $totalDedicatedNodes;
$TargetDedicatedNodes = min(400, $totalDedicatedNodes);
$NodeDeallocationOption = taskcompletion;

Catatan

Jika Anda memilih, Anda dapat menyertakan komentar dan hentian baris dalam string rumus. Perlu diketahui juga bahwa titik koma yang hilang dapat mengakibatkan kesalahan evaluasi.

Interval penskalaan otomatis

Secara default, layanan Batch menyesuaikan ukuran kumpulan sesuai dengan rumus skala otomatis setiap 15 menit. Interval ini dapat dikonfigurasi dengan menggunakan properti kumpulan berikut:

Interval minimum adalah lima menit, dan maksimum adalah 168 jam. Jika interval ditentukan di luar rentang ini, layanan Batch mengembalikan kesalahan Permintaan Buruk (400).

Catatan

Autoscaling saat ini tidak dimaksudkan untuk menanggapi perubahan dalam waktu kurang dari satu menit, melainkan dimaksudkan untuk menyesuaikan ukuran kumpulan Anda secara bertahap saat Anda menjalankan beban kerja.

Membuat kumpulan yang mendukung penskalaan otomatis dengan Batch SDK

Penskalaan otomatis kumpulan dapat dikonfigurasi menggunakan salah satu SDK Batch, REST API Batchcmdlet PowerShell Batch, dan CLI Batch. Di bagian ini, Anda dapat melihat contoh untuk .NET dan Python.

.NET

Untuk membuat kumpulan dengan penskalaan otomatis diaktifkan di .NET, ikuti langkah-langkah berikut:

  1. Buat kumpulan dengan BatchClient.PoolOperations.CreatePool.
  2. Atur properti CloudPool.AutoScaleEnabled ke true.
  3. Atur properti CloudPool.AutoScaleFormula dengan rumus skala otomatis Anda.
  4. (Opsional) Mengatur properti CloudPool.AutoScaleEvaluationInterval (defaultnya adalah 15 menit).
  5. Kirimkan kumpulan dengan CloudPool.Commit atau CommitAsync.

Contoh berikut membuat kumpulan yang mendukung penskalaan otomatis di .NET. Rumus penskalaan otomatis kumpulan menetapkan jumlah target simpul khusus menjadi 5 pada hari Senin, dan menjadi 1 pada setiap hari lainnya dalam seminggu. Interval penskalaan otomatis diatur ke 30 menit. Dalam cuplikan ini dan cuplikan C# lainnya dalam artikel ini, myBatchClient adalah instans yang diinisialisasi dengan benar dari kelas BatchClient.

CloudPool pool = myBatchClient.PoolOperations.CreatePool(
                    poolId: "mypool",
                    virtualMachineSize: "standard_d1_v2",
                    VirtualMachineConfiguration: new VirtualMachineConfiguration(
                        imageReference: new ImageReference(
                                            publisher: "MicrosoftWindowsServer",
                                            offer: "WindowsServer",
                                            sku: "2019-datacenter-core",
                                            version: "latest"),
                        nodeAgentSkuId: "batch.node.windows amd64");
pool.AutoScaleEnabled = true;
pool.AutoScaleFormula = "$TargetDedicatedNodes = (time().weekday == 1 ? 5:1);";
pool.AutoScaleEvaluationInterval = TimeSpan.FromMinutes(30);
await pool.CommitAsync();

Penting

Saat Anda membuat kumpulan berkemampuan skala otomatis, jangan tentukan parameter targetDedicatedNodes atau parameter targetLowPriorityNodes pada panggilan ke CreatePool. Sebagai gantinya, tentukan AutoScaleEnabled properti dan AutoScaleFormula pada kumpulan. Nilai untuk properti ini menentukan jumlah target dari setiap jenis simpul.

Untuk mengubah ukuran kumpulan yang mendukung penskalaan otomatis secara manual (misalnya, dengan BatchClient.PoolOperations.ResizePoolAsync), Anda harus terlebih dahulu menonaktifkan penskalaan otomatis pada kumpulan, lalu mengubah ukurannya.

Tip

Untuk contoh selengkapnya tentang menggunakan .NET SDK, lihat repositori Mulai Cepat Batch .NET di GitHub.

Python

Untuk membuat kumpulan berkemampuan skala otomatis dengan Python SDK:

  1. Buat kumpulan dan tentukan konfigurasinya.
  2. Tambahkan kumpulan ke klien layanan.
  3. Aktifkan skala otomatis pada kumpulan dengan rumus yang Anda tulis.

Contoh berikut mengilustrasikan langkah-langkah ini.

# Create a pool; specify configuration
new_pool = batch.models.PoolAddParameter(
    id="autoscale-enabled-pool",
    virtual_machine_configuration=batchmodels.VirtualMachineConfiguration(
        image_reference=batchmodels.ImageReference(
          publisher="Canonical",
          offer="UbuntuServer",
          sku="20.04-LTS",
          version="latest"
            ),
        node_agent_sku_id="batch.node.ubuntu 20.04"),
    vm_size="STANDARD_D1_v2",
    target_dedicated_nodes=0,
    target_low_priority_nodes=0
)
batch_service_client.pool.add(new_pool) # Add the pool to the service client

formula = """$curTime = time();
             $workHours = $curTime.hour >= 8 && $curTime.hour < 18;
             $isWeekday = $curTime.weekday >= 1 && $curTime.weekday <= 5;
             $isWorkingWeekdayHour = $workHours && $isWeekday;
             $TargetDedicated = $isWorkingWeekdayHour ? 20:10;""";

# Enable autoscale; specify the formula
response = batch_service_client.pool.enable_auto_scale(pool_id, auto_scale_formula=formula,
                                            auto_scale_evaluation_interval=datetime.timedelta(minutes=10),
                                            pool_enable_auto_scale_options=None,
                                            custom_headers=None, raw=False)

Tip

Untuk contoh selengkapnya tentang menggunakan Python SDK, lihat repositori Mulai Cepat Python Batch di GitHub.

Aktifkan penskalaan otomatis pada kumpulan yang ada

Setiap Batch SDK menyediakan cara untuk mengaktifkan penskalaan otomatis. Contohnya:

Saat Anda mengaktifkan penskalaan otomatis pada kumpulan yang ada, ingatlah:

  • Jika penskalaan otomatis saat ini dinonaktifkan pada kumpulan, Anda harus menentukan rumus skala otomatis yang valid saat Anda mengeluarkan permintaan. Anda dapat menentukan interval penskalaan otomatis secara opsional. Jika Anda tidak menentukan interval, akan digunakan nilai default 15 menit.
  • Jika penskalaan otomatis saat ini diaktifkan pada kumpulan, Anda bisa menentukan rumus baru, interval baru, atau keduanya. Anda harus menentukan minimal salah satu properti ini.
    • Jika Anda menentukan interval penskalaan otomatis baru, jadwal yang ada akan dihentikan dan jadwal baru dimulai. Waktu mulai jadwal baru adalah waktu di mana permintaan untuk mengaktifkan penskalaan otomatis dikeluarkan.
    • Jika Anda menghilangkan rumus atau interval skala otomatis, layanan Batch terus menggunakan nilai pengaturan tersebut saat ini.

Catatan

Jika Anda menentukan nilai untuk parameter targetDedicatedNodes atau targetLowPriorityNodes metode CreatePool saat Anda membuat kumpulan di .NET, atau untuk parameter yang sebanding dalam bahasa lain, maka nilai tersebut diabaikan saat rumus skala otomatis dievaluasi.

Contoh C# ini menggunakan pustaka .NET Batch untuk mengaktifkan penskalaan otomatis pada kumpulan yang ada.

// Define the autoscaling formula. This formula sets the target number of nodes
// to 5 on Mondays, and 1 on every other day of the week
string myAutoScaleFormula = "$TargetDedicatedNodes = (time().weekday == 1 ? 5:1);";

// Set the autoscale formula on the existing pool
await myBatchClient.PoolOperations.EnableAutoScaleAsync(
    "myexistingpool",
    autoscaleFormula: myAutoScaleFormula);

Menulis rumus skala otomatis

Untuk memperbarui rumus pada kumpulan berkemampuan skala otomatis yang sudah ada, hubungi operasi untuk mengaktifkan skala otomatis lagi dengan rumus baru. Misalnya, jika penskalaan otomatis sudah diaktifkan pada myexistingpool ketika kode .NET berikut dijalankan, rumus skala otomatisnya diganti dengan konten myNewFormula.

await myBatchClient.PoolOperations.EnableAutoScaleAsync(
    "myexistingpool",
    autoscaleFormula: myNewFormula);

Memperbarui interval skala otomatis

Untuk memperbarui interval evaluasi skala otomatis dari kumpulan berkemampuan skala otomatis yang ada, panggil operasi untuk mengaktifkan penskalaan otomatis lagi dengan interval baru. Misalnya, untuk mengatur interval evaluasi skala otomatis menjadi 60 menit untuk kumpulan yang sudah diaktifkan secara otomatis di .NET:

await myBatchClient.PoolOperations.EnableAutoScaleAsync(
    "myexistingpool",
    autoscaleEvaluationInterval: TimeSpan.FromMinutes(60));

Mengevaluasi rumus skala otomatis

Anda bisa mengevaluasi rumus sebelum menerapkannya ke kumpulan. Ini memungkinkan Anda menguji hasil rumus sebelum Anda memasukkannya ke dalam produksi.

Sebelum Anda bisa mengevaluasi rumus skala otomatis, Anda harus terlebih dahulu mengaktifkan penghitungan otomatis pada kumpulan dengan rumus yang valid, seperti rumus satu baris $TargetDedicatedNodes = 0. Lalu, gunakan salah satu hal berikut ini untuk mengevaluasi rumus yang ingin Anda uji:

Contoh Batch .NET berikut mengevaluasi rumus skala otomatis. Jika kumpulan belum menggunakan autoscaling, aktifkan terlebih dahulu.

// First obtain a reference to an existing pool
CloudPool pool = await batchClient.PoolOperations.GetPoolAsync("myExistingPool");

// If autoscaling isn't already enabled on the pool, enable it.
// You can't evaluate an autoscale formula on a non-autoscale-enabled pool.
if (pool.AutoScaleEnabled == false)
{
    // You need a valid autoscale formula to enable autoscaling on the
    // pool. This formula is valid, but won't resize the pool:
    await pool.EnableAutoScaleAsync(
        autoscaleFormula: "$TargetDedicatedNodes = $CurrentDedicatedNodes;",
        autoscaleEvaluationInterval: TimeSpan.FromMinutes(5));

    // Batch limits EnableAutoScaleAsync calls to once every 30 seconds.
    // Because you want to apply our new autoscale formula below if it
    // evaluates successfully, and you *just* enabled autoscaling on
    // this pool, pause here to ensure you pass that threshold.
    Thread.Sleep(TimeSpan.FromSeconds(31));

    // Refresh the properties of the pool so that we've got the
    // latest value for AutoScaleEnabled
    await pool.RefreshAsync();
}

// You must ensure that autoscaling is enabled on the pool prior to
// evaluating a formula
if (pool.AutoScaleEnabled == true)
{
    // The formula to evaluate - adjusts target number of nodes based on
    // day of week and time of day
    string myFormula = @"
        $curTime = time();
        $workHours = $curTime.hour >= 8 && $curTime.hour < 18;
        $isWeekday = $curTime.weekday >= 1 && $curTime.weekday <= 5;
        $isWorkingWeekdayHour = $workHours && $isWeekday;
        $TargetDedicatedNodes = $isWorkingWeekdayHour ? 20:10;
    ";

    // Perform the autoscale formula evaluation. Note that this code does not
    // actually apply the formula to the pool.
    AutoScaleRun eval =
        await batchClient.PoolOperations.EvaluateAutoScaleAsync(pool.Id, myFormula);

    if (eval.Error == null)
    {
        // Evaluation success - print the results of the AutoScaleRun.
        // This will display the values of each variable as evaluated by the
        // autoscale formula.
        Console.WriteLine("AutoScaleRun.Results: " +
            eval.Results.Replace("$", "\n    $"));

        // Apply the formula to the pool since it evaluated successfully
        await batchClient.PoolOperations.EnableAutoScaleAsync(pool.Id, myFormula);
    }
    else
    {
        // Evaluation failed, output the message associated with the error
        Console.WriteLine("AutoScaleRun.Error.Message: " +
            eval.Error.Message);
    }
}

Evaluasi yang berhasil dari rumus yang diperlihatkan dalam cuplikan kode ini memberikan hasil yang mirip dengan:

AutoScaleRun.Results:
    $TargetDedicatedNodes=10;
    $NodeDeallocationOption=requeue;
    $curTime=2016-10-13T19:18:47.805Z;
    $isWeekday=1;
    $isWorkingWeekdayHour=0;
    $workHours=0

Mendapatkan informasi tentang skala otomatis berjalan

Disarankan untuk secara berkala memeriksa evaluasi layanan Batch dari rumus skala otomatis Anda. Untuk melakukannya, dapatkan (atau refresh) referensi ke kumpulan, lalu periksa properti dari proses skala otomatis terakhirnya.

Dalam Batch .NET, properti CloudPool.AutoScaleRun memiliki beberapa properti yang menyediakan informasi tentang proses penskalaan otomatis terbaru yang dilakukan pada kumpulan:

Dalam REST API, Dapatkan informasi tentang permintaan kumpulan mengembalikan informasi tentang kumpulan, yang mencakup informasi proses penskalaan otomatis terbaru di properti autoScaleRun.

Contoh C# berikut menggunakan pustaka .NET Batch untuk mencetak informasi tentang penskalaan otomatis terakhir yang dijalankan pada kumpulan myPool.

await Cloud pool = myBatchClient.PoolOperations.GetPoolAsync("myPool");
Console.WriteLine("Last execution: " + pool.AutoScaleRun.Timestamp);
Console.WriteLine("Result:" + pool.AutoScaleRun.Results.Replace("$", "\n  $"));
Console.WriteLine("Error: " + pool.AutoScaleRun.Error);

Contoh output dari contoh sebelumnya:

Last execution: 10/14/2016 18:36:43
Result:
  $TargetDedicatedNodes=10;
  $NodeDeallocationOption=requeue;
  $curTime=2016-10-14T18:36:43.282Z;
  $isWeekday=1;
  $isWorkingWeekdayHour=0;
  $workHours=0
Error:

Dapatkan riwayat skala otomatis yang berjalan menggunakan peristiwa penskalaan otomatis kumpulan

Anda juga dapat memeriksa riwayat penskalaan otomatis dengan mengkueri PoolAutoScaleEvent. Batch memancarkan peristiwa ini untuk merekam setiap kemunculan evaluasi dan eksekusi rumus skala otomatis, yang dapat membantu memecahkan masalah potensial.

Contoh peristiwa untuk PoolAutoScaleEvent:

{
    "id": "poolId",
    "timestamp": "2020-09-21T23:41:36.750Z",
    "formula": "...",
    "results": "$TargetDedicatedNodes=10;$NodeDeallocationOption=requeue;$curTime=2016-10-14T18:36:43.282Z;$isWeekday=1;$isWorkingWeekdayHour=0;$workHours=0",
    "error": {
        "code": "",
        "message": "",
        "values": []
    }
}

Contoh rumus skala otomatis

Mari kita lihat beberapa rumus yang menunjukkan berbagai cara untuk menyesuaikan jumlah sumber daya komputasi dalam kumpulan.

Contoh 1: Penyesuaian berbasis waktu

Misalkan Anda ingin menyesuaikan ukuran kumpulan berdasarkan satu hari tertentu dalam seminggu dan waktu tertentu pada hari itu. Contoh ini menunjukkan cara meningkatkan atau mengurangi jumlah simpul dalam kumpulan yang sesuai.

Rumus ini pertama kali akan menggunakan waktu saat ini. Jika ini adalah hari kerja (1-5) dan dalam jam kerja (8 pagi hingga 6 sore), maka ukuran kumpulan target diatur ke 20 simpul. Jika tidak, ukurannya diatur ke 10 simpul.

$curTime = time();
$workHours = $curTime.hour >= 8 && $curTime.hour < 18;
$isWeekday = $curTime.weekday >= 1 && $curTime.weekday <= 5;
$isWorkingWeekdayHour = $workHours && $isWeekday;
$TargetDedicatedNodes = $isWorkingWeekdayHour ? 20:10;
$NodeDeallocationOption = taskcompletion;

$curTime dapat disesuaikan untuk mencerminkan zona waktu lokal Anda dengan menambahkan time() ke produk TimeZoneInterval_Hour dan sesuaikan dengan UTC, waktu Universal Terkoordinasi Anda. Untuk instans, gunakan $curTime = time() + (-6 * TimeInterval_Hour); untuk Waktu Musim Panas Gunung (MDT). Perlu diingat bahwa offset perlu disesuaikan pada awal dan akhir waktu musim panas, jika berlaku.

Contoh 2: Penyesuaian berbasis waktu

Dalam contoh C# ini, ukuran kumpulan disesuaikan berdasarkan jumlah tugas dalam antrean. Komentar dan hentian baris disertakan dalam string rumus.

// Get pending tasks for the past 15 minutes.
$samples = $PendingTasks.GetSamplePercent(TimeInterval_Minute * 15);
// If you have fewer than 70 percent data points, use the last sample point,
// otherwise use the maximum of last sample point and the history average.
$tasks = $samples < 70 ? max(0,$PendingTasks.GetSample(1)) : max( $PendingTasks.GetSample(1), avg($PendingTasks.GetSample(TimeInterval_Minute * 15)));
// If number of pending tasks is not 0, set targetVM to pending tasks, otherwise
// half of current dedicated.
$targetVMs = $tasks > 0? $tasks:max(0, $TargetDedicatedNodes/2);
// The pool size is capped at 20, if target VM value is more than that, set it
// to 20. This value should be adjusted according to your use case.
$TargetDedicatedNodes = max(0, min($targetVMs, 20));
// Set node deallocation mode - let running tasks finish before removing a node
$NodeDeallocationOption = taskcompletion;

Contoh 3: Akuntansi untuk tugas paralel

Contoh C# ini menyesuaikan ukuran kumpulan berdasarkan jumlah tugas. Rumus ini juga memperhitungkan nilai TaskSlotsPerNode yang telah diatur untuk kumpulan. Pendekatan ini berguna dalam situasi di mana eksekusi tugas paralel telah diaktifkan di kumpulan Anda.

// Determine whether 70 percent of the samples have been recorded in the past
// 15 minutes; if not, use last sample
$samples = $ActiveTasks.GetSamplePercent(TimeInterval_Minute * 15);
$tasks = $samples < 70 ? max(0,$ActiveTasks.GetSample(1)) : max( $ActiveTasks.GetSample(1),avg($ActiveTasks.GetSample(TimeInterval_Minute * 15)));
// Set the number of nodes to add to one-fourth the number of active tasks
// (the TaskSlotsPerNode property on this pool is set to 4, adjust
// this number for your use case)
$cores = $TargetDedicatedNodes * 4;
$extraVMs = (($tasks - $cores) + 3) / 4;
$targetVMs = ($TargetDedicatedNodes + $extraVMs);
// Attempt to grow the number of compute nodes to match the number of active
// tasks, with a maximum of 3
$TargetDedicatedNodes = max(0,min($targetVMs,3));
// Keep the nodes active until the tasks finish
$NodeDeallocationOption = taskcompletion;

Contoh 4: Mengatur ukuran kumpulan awal

Contoh ini memperlihatkan contoh C# dengan rumus skala otomatis yang mengatur ukuran kumpulan ke jumlah simpul tertentu untuk periode waktu awal. Setelah itu, formula itu menyesuaikan ukuran kumpulan berdasarkan jumlah tugas yang berjalan dan aktif.

Secara khusus, rumus ini melakukan hal berikut:

  • Menyetel ukuran kumpulan awal menjadi empat simpul.
  • Tidak menyesuaikan ukuran kumpulan dalam 10 menit pertama siklus hidup kumpulan.
  • Setelah 10 menit, mendapatkan nilai maksimal dari jumlah tugas yang berjalan dan aktif dalam 60 menit terakhir.
    • Jika kedua nilai adalah 0, menunjukkan bahwa tidak ada tugas yang berjalan atau aktif dalam 60 menit terakhir, ukuran kumpulan diatur ke 0.
    • Jika salah satu nilai lebih besar dari nol, tidak ada perubahan yang dilakukan.
string now = DateTime.UtcNow.ToString("r");
string formula = string.Format(@"
    $TargetDedicatedNodes = {1};
    lifespan         = time() - time(""{0}"");
    span             = TimeInterval_Minute * 60;
    startup          = TimeInterval_Minute * 10;
    ratio            = 50;

    $TargetDedicatedNodes = (lifespan > startup ? (max($RunningTasks.GetSample(span, ratio), $ActiveTasks.GetSample(span, ratio)) == 0 ? 0 : $TargetDedicatedNodes) : {1});
    ", now, 4);

Langkah berikutnya