Bagikan melalui


Kluster CycleCloud GridEngine

Open Grid Scheduler (Grid Engine) dapat dengan mudah diaktifkan pada kluster Azure CycleCloud dengan memodifikasi "run_list" dalam definisi kluster. Dua komponen dasar kluster Grid Engine adalah node 'master' yang menyediakan sistem file bersama tempat perangkat lunak Grid Engine berjalan, dan node 'execute' yang merupakan host yang memasang sistem file bersama dan menjalankan pekerjaan yang dikirimkan. Misalnya, cuplikan templat kluster Grid Engine sederhana mungkin terlihat seperti:

[cluster grid-engine]

[[node master]]
    ImageName = cycle.image.centos7
    MachineType = Standard_A4 # 8 cores

    [[[configuration]]]
    run_list = role[sge_master_role]

[[nodearray execute]]
    ImageName = cycle.image.centos7
    MachineType = Standard_A1  # 1 core

    [[[configuration]]]
    run_list = role[sge_execute_role]

Catatan

Nama peran berisi 'sge' karena alasan warisan: Grid Engine adalah produk dari Sun Microsystems.

Mengimpor dan memulai kluster dengan definisi di CycleCloud akan menghasilkan satu simpul 'master'. Node eksekusi dapat ditambahkan ke kluster melalui cyclecloud add_node perintah . Misalnya, untuk menambahkan 10 simpul eksekusi lainnya:

cyclecloud add_node grid-engine -t execute -c 10

Autoscaling Mesin Kisi

Azure CycleCloud mendukung penskalaan otomatis untuk Grid Engine, yang berarti bahwa perangkat lunak akan memantau status antrean Anda dan mengaktifkan dan menonaktifkan simpul sesuai kebutuhan untuk menyelesaikan pekerjaan dalam jumlah waktu/biaya yang optimal. Anda dapat mengaktifkan penskalaan otomatis untuk Grid Engine dengan menambahkan Autoscale = true ke definisi kluster Anda:

[cluster grid-engine]
Autoscale = True

Secara default, semua pekerjaan yang dikirimkan ke dalam antrean Grid Engine akan berjalan pada mesin jenis 'execute', ini adalah mesin yang ditentukan oleh array node bernama 'execute'. Anda tidak terbatas pada nama 'execute', anda juga tidak terbatas pada satu jenis konfigurasi mesin untuk menjalankan pekerjaan dan autoscale aktif.

Sebagai contoh, kasus umum mungkin adalah Anda memiliki kluster dengan dua definisi node yang berbeda satu adalah untuk menjalankan pekerjaan 'normal' yang menggunakan CPU standar sementara jenis pekerjaan lain dapat menggunakan komputer GPU. Dalam hal ini Anda ingin menskalakan antrean Anda secara independen dengan pekerjaan normal serta pekerjaan GPU untuk memastikan Anda memiliki jumlah yang sesuai dari setiap komputer untuk mengonsumsi antrean kerja. Contoh definisi akan menjadi sesuatu seperti:

[cluster grid-engine]
Autoscale = True

[[node master]]
    ImageName = cycle.image.centos7
    MachineType = Standard_A3  # 4 cores

    [[[configuration]]]
    run_list = role[sge_master_role]

[[nodearray execute]]
    ImageName = cycle.image.centos7
    MachineType = Standard_A4  # 8 cores

    [[[configuration]]]
    run_list = role[sge_execute_role]

[[nodearray gpu]]
    MachineType = Standard_NV12 # 2 GPUs
    ImageName = cycle.image.centos7

    # Set the number of cores to the number of GPUs for autoscaling purposes
    CoreCount = 2  

    [[[configuration]]]
    run_list = role[sge_execute_role]
    gridengine.slot_type = gpu
    gridengine.slots = 2

Dalam contoh di atas, sekarang ada dua array node: Satu adalah array node eksekusi 'standar', yang kedua diberi nama 'gpu' yang menyediakan MachineType yang memiliki dua GPU Nvidia (Standard_NV12 di Azure). Perhatikan juga bahwa sekarang ada dua item baru di bagian konfigurasi selain resep 'csge:sgeexec'. gridengine.slot_type = gpu Menambahkan memberi tahu penjadwal Grid Engine bahwa simpul ini harus diberi nama node 'gpu' dan dengan demikian hanya boleh menjalankan pekerjaan 'gpu'. Nama 'gpu' bersifat arbitrer, tetapi nama yang menggambarkan node paling berguna. Atur gridengine.slots = 2, yang memberi tahu perangkat lunak untuk memastikan bahwa jenis simpul ini hanya dapat menjalankan dua pekerjaan sekaligus (Standard_NV12 hanya memiliki 2 GPU). Secara default, jumlah slot per simpul di Grid Engine akan menjadi jumlah CPU pada sistem yang, dalam hal ini, akan menyebabkan terlalu banyak pekerjaan untuk dijalankan secara bersamaan pada simpul. Dalam contoh di atas, CoreCount=2 diatur pada nodearray agar sesuai dengan jumlah GPU yang tersedia di MachineType, memungkinkan CycleCloud untuk menskalakan array tersebut dengan benar pada jumlah GPU vs CPU.

Anda dapat memverifikasi jumlah slot dan slot_type yang dimiliki komputer Anda dengan menjalankan perintah:

    -bash-4.1# qstat -F slot_type
    queuename                      qtype resv/used/tot. load_avg arch          states
    ---------------------------------------------------------------------------------
    all.q@ip-0A000404              BIP   0/0/4          0.17     linux-x64
        hf:slot_type=execute
    ---------------------------------------------------------------------------------
    all.q@ip-0A000405              BIP   0/0/2          2.18     linux-x64
        hf:slot_type=gpu
    ---------------------------------------------------------------------------------
    all.q@ip-0A000406              BIP   0/0/4          0.25     linux-x64

Perhatikan bahwa ada salah satu dari setiap 'slot_type' yang kami tentukan (jalankan dan gpu) dan jumlah slot untuk slot 'eksekusi' adalah 4, yang merupakan jumlah CPU pada komputer. Jumlah slot untuk jenis slot 'gpu' adalah 2, yang kami tentukan dalam templat konfigurasi kluster kami. Komputer ketiga adalah simpul master yang tidak menjalankan pekerjaan.

Penggunaan Lanjutan Mesin Kisi

Pengaturan konfigurasi di atas memungkinkan penyesuaian lanjutan node dan array node. Misalnya, jika pekerjaan memerlukan jumlah memori tertentu, misalnya masing-masing 10GB, Anda dapat menentukan nodearray eksekusi yang memulai komputer dengan memori 60GB, lalu menambahkan opsi gridengine.slots = 6 konfigurasi untuk memastikan bahwa hanya 6 pekerjaan yang dapat dijalankan secara bersamaan pada jenis node ini (memastikan bahwa setiap pekerjaan akan memiliki setidaknya 10GB memori untuk dikerjakan).

Node yang Dikelompokkan di Grid Engine

Ketika pekerjaan paralel dikirimkan ke mesin kisi, perilaku skala otomatis default yang akan digunakan CycleCloud adalah memperlakukan setiap pekerjaan MPI sebagai permintaan simpul yang dikelompokkan. Simpul yang dikelompokkan digabungkan dengan erat dan sangat cocok untuk alur kerja MPI.

Ketika sekumpulan simpul yang dikelompokkan bergabung dengan kluster Grid Engine, id grup dari setiap simpul digunakan sebagai nilai nilai affinity_groupkompleks . Dengan mengharuskan affinity_group ditentukan untuk pekerjaan, ini memungkinkan penjadwal Grid Engine untuk memastikan bahwa pekerjaan hanya mendarat di mesin yang berada dalam grup yang sama.

Otomatisasi CycleCloud akan secara otomatis meminta simpul yang dikelompokkan dan menetapkannya ke grup afinitas yang tersedia saat pekerjaan paralel ditemui.

Mengirimkan Pekerjaan ke Mesin Kisi

Cara paling umum untuk mengirimkan pekerjaan ke penjadwal Grid Engine adalah perintah :

qsub my_job.sh

Perintah ini akan mengirimkan pekerjaan yang akan berjalan pada node jenis 'execute', yaitu node yang ditentukan oleh nodearray 'execute'. Untuk membuat pekerjaan berjalan pada nodearray dari jenis yang berbeda, misalnya jenis node 'gpu' di atas, kami memodifikasi pengiriman kami:

qsub -l slot_type=gpu my_gpu_job.sh

Perintah ini akan memastikan bahwa pekerjaan hanya berjalan pada 'slot_type' dari 'gpu'.

Jika slot_type dihilangkan, 'jalankan' akan secara otomatis ditetapkan ke pekerjaan. Mekanisme yang secara otomatis menetapkan slot_type ke pekerjaan dapat dimodifikasi oleh pengguna. Skrip python yang terletak di /opt/cycle/jetpack/config/autoscale.py dapat dibuat yang harus menentukan satu fungsi "sge_job_handler". Fungsi ini menerima representasi kamus pekerjaan, mirip dengan output qstat -j JOB_ID perintah dan harus mengembalikan kamus sumber daya keras yang perlu diperbarui untuk pekerjaan tersebut. Sebagai contoh, di bawah ini adalah skrip yang akan menetapkan pekerjaan ke 'gpu' slot_type jika nama pekerjaan berisi huruf 'gpu'. Ini akan memungkinkan pengguna untuk mengirimkan pekerjaan mereka dari sistem otomatis tanpa harus memodifikasi parameter pekerjaan dan masih menjalankan pekerjaan dan menskalakan simpul yang benar secara otomatis:

#!/usr/env python
#
# File: /opt/cycle/jetpack/config/autoscale.py
#
def sge_job_handler(job):
  # The 'job' parameter is a dictionary containing the data present in a 'qstat -j JOB_ID':
    hard_resources = {'slot_type': 'execute', 'affinity_group' : 'default' }

  # Don't modify anything if the job already has a slot type
  # You could modify the slot type at runtime by not checking this
  if 'hard_resources' in job and 'slot_type' in job['hard_resources']:
      return hard_resources

  # If the job's script name contains the string 'gpu' then it's assumed to be a GPU job.
  # Return a dictionary containing the new job_slot requirement to be updated.
  # For example: 'big_data_gpu.sh' would be run on a 'gpu' node.
  if job['job_name'].find('gpu') != -1:
      hard_resources {'slot_type': 'gpu'}
  else:
      return hard_resources

Parameter 'pekerjaan' yang diteruskan adalah kamus yang berisi data dalam qstat -j JOB_ID panggilan:

{
    "job_number": 5,
    "job_name": "test.sh",
    "script_file": "test.sh",
    "account": "sge",
    "owner": "cluster.user",
    "uid": 100,
    "group": "cluster.user",
    "gid": 200,
    "submission_time": "2013-10-09T09:09:09",
    "job_args": ['arg1', 'arg2', 'arg3'],
    "hard_resources": {
       'mem_free': '15G',
       'slot_type': 'execute'
    }
}

Anda dapat menggunakan fungsionalitas pembuatan skrip ini untuk secara otomatis menetapkan slot_type berdasarkan parameter apa pun yang ditentukan dalam pekerjaan seperti argumen, persyaratan sumber daya lainnya seperti memori, mengirimkan pengguna, dll.

Jika Anda mengirimkan 5 pekerjaan dari setiap 'slot_type':

qsub -t 1:5 gpu_job.sh
qsub -t 1:5 normal_job.sh

Sekarang akan ada 10 pekerjaan dalam antrean. Karena skrip yang ditentukan di atas, lima pekerjaan dengan 'gpu' dalam nama akan secara otomatis dikonfigurasi untuk hanya berjalan pada simpul 'slot_type=gpu'. Mekanisme skala otomatis CycleCloud akan mendeteksi bahwa ada 5 pekerjaan 'gpu' dan 5 pekerjaan 'jalankan'. Karena nodearray 'gpu' didefinisikan sebagai memiliki 2 slot per simpul, CycleCloud akan memulai 3 simpul ini (5/2=2,5 dibulatkan hingga 3). Ada 5 pekerjaan normal, karena jenis mesin untuk nodearray 'jalankan' masing-masing memiliki 4 CPU, CycleCloud akan memulai 2 simpul ini untuk menangani pekerjaan (5/4=1,25 dibulatkan hingga 2). Setelah waktu yang singkat untuk simpul yang baru dimulai untuk boot dan mengonfigurasi, semua 10 pekerjaan akan berjalan hingga selesai dan kemudian 5 simpul akan secara otomatis dimatikan sebelum Anda ditagih lagi oleh Penyedia Cloud.

Pekerjaan diasumsikan memiliki durasi satu jam. Jika runtime pekerjaan diketahui algoritma skala otomatis dapat memperoleh manfaat dari informasi ini. Menginformasikan skala otomatis dari durasi pekerjaan yang diharapkan dengan menambahkannya ke konteks pekerjaan. Contoh berikut memberi tahu skala otomatis bahwa runtime pekerjaan rata-rata 10 menit:

qsub -ac average_runtime=10 job_with_duration_of_10m.sh

Referensi Konfigurasi Mesin Kisi

Berikut ini adalah opsi konfigurasi khusus Grid Engine yang dapat Anda alihkan untuk menyesuaikan fungsionalitas:

Opsi Konfigurasi SGE-Specific Deskripsi
gridengine.slots Jumlah slot untuk node tertentu untuk dilaporkan ke Grid Engine. Jumlah slot adalah jumlah pekerjaan bersamaan yang dapat dijalankan simpul, nilai ini default ke jumlah CPU pada komputer tertentu. Anda dapat mengambil alih nilai ini dalam kasus di mana Anda tidak menjalankan pekerjaan berdasarkan CPU tetapi pada memori, GPU, dll.
gridengine.slot_type Nama jenis 'slot' yang disediakan simpul. Defaultnya adalah 'execute'. Ketika pekerjaan ditandai dengan sumber daya keras 'slot_type=', pekerjaan tersebut hanya akan berjalan pada komputer dengan jenis slot yang sama. Ini memungkinkan Anda untuk membuat konfigurasi perangkat lunak dan perangkat keras yang berbeda per simpul dan memastikan pekerjaan yang sesuai selalu dijadwalkan pada jenis simpul yang benar.
gridengine.ignore_fqdn Default: true. Atur ke false jika semua node di kluster Anda bukan bagian dari satu domain DNS.
gridengine.version Default: '2011.11'. Ini adalah versi Grid Engine untuk diinstal dan dijalankan. Saat ini adalah opsi default dan satu-satunya . Di masa mendatang, versi tambahan perangkat lunak Grid Engine mungkin didukung.
gridengine.root Default: '/sched/sge/sge-2011.11' Di sinilah Grid Engine akan dipasang dan dipasang pada setiap node dalam sistem. Disarankan nilai ini tidak diubah, tetapi jika itu harus diatur ke nilai yang sama pada setiap simpul dalam kluster.

CycleCloud mendukung sekumpulan atribut autostop standar di seluruh penjadwal:

Atribut Deskripsi
cyclecloud.cluster.autoscale.stop_enabled Apakah autostop diaktifkan pada simpul ini? [benar/salah]
cyclecloud.cluster.autoscale.idle_time_after_jobs Jumlah waktu (dalam detik) untuk simpul untuk duduk diam setelah menyelesaikan pekerjaan sebelum diturunkan skalanya.
cyclecloud.cluster.autoscale.idle_time_before_jobs Jumlah waktu (dalam detik) untuk simpul untuk duduk diam sebelum menyelesaikan pekerjaan sebelum diturunkan skalanya.

Masalah Umum

  • qsh perintah untuk sesi interaktif tidak berfungsi. Gunakan qrsh sebagai alternatif.
  • Kompleks exclusive=1 ini tidak dihormati oleh skala otomatis. Lebih sedikit simpul dari yang diharapkan dapat dimulai sebagai hasilnya.

Catatan

Meskipun Windows adalah platform GridEngine yang didukung secara resmi, CycleCloud tidak mendukung menjalankan GridEngine di Windows saat ini.

Halaman ini menyangkut kemampuan dan konfigurasi penggunaan (Altair) GridEngine dengan CycleCloud.

Mengonfigurasi Sumber Daya

Aplikasi cyclecloud-gridengine cocok dengan sumber daya sge dengan sumber daya cloud azure untuk menyediakan alat penskalaan otomatis dan konfigurasi kluster yang kaya. Aplikasi akan disebarkan secara otomatis untuk kluster yang dibuat melalui UI CycleCloud atau dapat diinstal pada host admin gridengine apa pun pada kluster yang ada.

Menginstal atau Meningkatkan cyclecloud-gridengine

Bundel cyclecloud-gridengine tersedia di github sebagai artefak rilis. Menginstal dan memutakhirkan akan menjadi proses yang sama. Aplikasi ini membutuhkan python3 dengan virtualenv.

tar xzf cyclecloud-gridengine-pkg-*.tar.gz
cd cyclecloud-gridengine
./install.sh

File Penting

Aplikasi mengurai konfigurasi sge setiap kali disebut - pekerjaan, antrean, kompleks. Informasi disediakan dalam stderr dan stdout perintah serta ke file log, baik pada tingkat yang dapat dikonfigurasi. Semua perintah manajemen gridengine dengan argumen juga dicatat ke file.

Deskripsi Lokasi
Konfigurasi Skala Otomatis /opt/cycle/gridengine/autoscale.json
Log Skala Otomatis /opt/cycle/jetpack/logs/autoscale.log
log jejak qconf /opt/cycle/jetpack/logs/qcmd.log

Antrean SGE, grup host, dan lingkungan paralel

Utilitas skala otomatis cyclecloud-gridengine, azge, akan menambahkan host ke kluster sesuai dengan konfigurasi kluster. Operasi autoscaling melakukan tindakan berikut.

  1. Baca permintaan sumber daya pekerjaan dan temukan VM yang sesuai untuk memulai
  2. Mulai VM dan tunggu hingga siap
  3. Membaca antrean dan lingkungan paralel dari pekerjaan
  4. Berdasarkan antrean/pe, tetapkan host ke grup host yang sesuai
  5. Tambahkan host ke kluster serta ke antrean lain yang berisi grup host

Pertimbangkan definisi antrean berikut untuk antrean bernama short.q

hostlist              @allhosts @mpihg01 @mpihg02 @lowprio 
...
seq_no                10000,[@lowprio=10],[@mpihg01=100],[@mpihg02=200]
pe_list               NONE,[@mpihg01=mpi01], \
                      [@mpihg02=mpi02]

Mengirimkan pekerjaan dengan qsub -q short.q -pe mpi02 12 my-script.sh akan dimulai dari sewa satu VM, dan ketika ditambahkan ke kluster, grup host akan bergabung dengan grup host @mpihg02 karena itulah grup host yang tersedia untuk antrean dan lingkungan paralel. Ini juga akan ditambahkan ke @allhosts, yang merupakan grup host khusus.

Tanpa menentukan pe, qsub -q short.q my-script.sh VM yang dihasilkan akan ditambahkan ke @allhosts dan @lowpriority ini adalah grup host dalam antrean yang tidak ditetapkan pes.

Akhirnya, pekerjaan yang dikirimkan dengan qsub -q short.q -pe mpi0* 12 my-script.sh akan menghasilkan VM yang ditambahkan ke @mpihg01 atau @mpihg02 tergantung pada prediksi alokasi CycleCloud.

Lingkungan paralel secara implisit sama dengan grup penempatan cyclecloud. VM dalam PE dibatasi berada dalam jaringan yang sama. Jika Anda ingin menggunakan PE yang tidak menyimpan grup penempatan, gunakan autoscale.json untuk menolaknya.

Di sini kita memilih keluar dari grup penempatan untuk membuat pe:

"gridengine": {
    "pes": {
      "make": {
        "requires_placement_groups": false
      }
    },

Grup Penempatan CycleCloud

Grup penempatan CycleCloud memetakan satu-ke-satu ke Azure VMSS dengan SinglePlacementGroup - VM dalam grup penempatan berbagi Infiniband Fabric dan hanya berbagi dengan VM dalam grup penempatan. Untuk mempertahankan silo ini secara intuitif, grup penempatan memetakan 1:1 dengan lingkungan paralel gridengine juga.

Menentukan lingkungan paralel untuk pekerjaan akan membatasi pekerjaan untuk dijalankan dalam grup penempatan melalui logika penetapan grup host pintar. Anda dapat menolak perilaku ini dengan konfigurasi yang disebutkan di autoscale.json : "required_placement_groups" : false.

Konfigurasi skala otomatis

Plugin ini akan secara otomatis menskalakan kisi untuk memenuhi tuntutan beban kerja. File konfigurasi autoscale.json menentukan perilaku autoscaler Grid Engine.

  • Mengatur detail koneksi cyclecloud
  • Mengatur timer penghentian untuk simpul diam
  • Penskalaan otomatis multi-dimensi dimungkinkan, mengatur atribut mana yang akan digunakan dalam kemasan pekerjaan misalnya slot, memori
  • Daftarkan antrean, lingkungan paralel, dan grup host yang akan dikelola
Konfigurasi Jenis Deskripsi
url Untai (karakter) CC URL
nama pengguna/kata sandi Untai (karakter) Detail Koneksi CC
cluster_name Untai (karakter) Nama Kluster CC
default_resources Peta Menautkan sumber daya simpul ke sumber daya host Grid Engine untuk skala otomatis
idle_timeout Int Waktu tunggu sebelum mengakhiri simpul diam (s)
boot_timeout Int Waktu tunggu sebelum mengakhiri simpul selama fase konfigurasi panjang (s)
gridengine.relevant_complexes Daftar (String) Kompleks mesin kisi yang perlu dipertimbangkan dalam penskalaan otomatis misalnya slot, mem_free
gridengine.logging File Lokasi file konfigurasi pengelogan
gridengine.pes Struktur Tentukan perilaku PEs, misalnya requires_placement_group = false

Program autoscaling hanya akan mempertimbangkan Sumber Daya yang Relevan

Sumber daya autoscaling tambahan

Secara default, kluster dengan skala berdasarkan berapa banyak slot yang diminta oleh pekerjaan. Kita dapat menambahkan dimensi lain ke autoscaling.

Katakanlah kita ingin menskalakan otomatis dengan permintaan sumber daya pekerjaan untuk m_mem_free.

  1. Tambahkan m_mem_free ke gridengine.relevant_resources dalam autoscale.json
  2. Menautkan m_mem_free ke sumber daya memori tingkat simpul di autoscale.json

Atribut ini dapat menjadi referensi dengan node.* sebagai nilai dalam _default/sumber daya.

Simpul Jenis Deskripsi
nodearray Untai Nama nodearray cyclecloud
placement_group Untai (karakter) Nama grup penempatan cyclecloud dalam nodearray
vm_size Untai (karakter) Nama produk VM, misalnya "Standard_F2s_v2"
vcpu_count Int CPU virtual tersedia pada simpul seperti yang ditunjukkan pada halaman produk individual
pcpu_count Int CPU fisik tersedia pada simpul
memory Untai (karakter) Perkiraan memori fisik yang tersedia di VM dengan indikator unit, misalnya "8.0g"

Atribut tambahan ada di node.resources.* namespace, misalnya 'node.resources.

Simpul Jenis Deskripsi
ncpus Untai (karakter) Jumlah CPU yang tersedia di VM
pcpus Untai (karakter) Jumlah CPU fisik yang tersedia di VM
ngpus Bilangan bulat Jumlah GPU yang tersedia di VM
memb Untai (karakter) Perkiraan memori fisik yang tersedia di VM dengan indikator unit, misalnya "8,0b"
memkb Untai (karakter) Perkiraan memori fisik yang tersedia di VM dengan indikator unit, misalnya "8,0k"
memmb Untai (karakter) Perkiraan memori fisik yang tersedia di VM dengan indikator unit, misalnya "8,0m"
memgb Untai (karakter) Perkiraan memori fisik yang tersedia di VM dengan indikator unit, misalnya "8.0g"
memtb Untai (karakter) Perkiraan memori fisik yang tersedia di VM dengan indikator unit, misalnya "8.0t"
slots Bilangan bulat Sama seperti ncpus
slot_type Untai (karakter) Label tambahan untuk ekstensi. Tidak umumnya digunakan.
m_mem_free Untai (karakter) Memori bebas yang diharapkan pada host eksekusi, misalnya "3.0g"
mfree Untai (karakter) Sama seperti _m/_mem/gratis

Pemetaan Sumber Daya

Ada juga matematika yang tersedia untuk default_resources - kurangi slot pada array simpul tertentu dengan dua dan tambahkan sumber daya docker ke semua simpul:

    "default_resources": [
    {
      "select": {"node.nodearray": "beegfs"},
      "name": "slots",
      "value": "node.vcpu_count",
      "subtract": 2
    },
    {
      "select": {},
      "name": "docker",
      "value": true
    },

Memetakan simpul vCPU ke slot kompleks, dan memmb ke mem_free umumnya digunakan default. Asosiasi pertama diperlukan.

    "default_resources": [
    {
      "select": {},
      "name": "slots",
      "value": "node.vcpu_count"
    },
    {
      "select": {},
      "name": "mem_free",
      "value": "node.resources.memmb"
    }
 ],

Perhatikan bahwa jika kompleks memiliki pintasan yang tidak sama dengan seluruh nilai, maka tentukan keduanya di default_resources di mana physical_cpu adalah nama kompleks:

"default_resources": [
    {
      "select": {},
      "name": "physical_cpu",
      "value": "node.pcpu_count"
    },
    {
      "select": {},
      "name": "pcpu",
      "value": "node.resources.physical_cpu"
    }
]

Pengurutan penting ketika Anda menginginkan perilaku tertentu untuk atribut tertentu. Untuk mengalokasikan satu slot untuk nodearray tertentu sambil mempertahankan jumlah slot default untuk semua nodearray lainnya:

    "default_resources": [
    {
      "select": {"node.nodearray": "FPGA"},
      "name": "slots",
      "value": "1",
    },
    {
      "select": {},
      "name": "slots",
      "value": "node.vcpu_count"
    },
]

Grup host

Penskala otomatis CycleCloud, dalam mencoba memenuhi persyaratan pekerjaan, akan memetakan simpul ke grup host yang sesuai. Antrean, lingkungan paralel, dan kompleks semuanya dipertimbangkan. Sebagian besar logika cocok dengan wadah cyclecloud yang sesuai (dan kuantitas simpul) dengan grup host sge yang sesuai.

Untuk pekerjaan yang dikirimkan sebagai: qsub -q "cloud.q" -l "m_mem_free=4g" -pe "mpi*" 48 ./myjob.sh

CycleCloud akan menemukan persimpangan grup host yang:

  1. Disertakan dalam pe_list untuk cloud.q dan cocok dengan nama pe, misalnya pe_list [@allhosts=mpislots],[@hpc1=mpi].
  2. Memiliki sumber daya dan kuota langganan yang memadai untuk menyediakan semua sumber daya pekerjaan.
  3. Tidak difilter oleh konfigurasi batasan grup host.

Ada kemungkinan bahwa beberapa grup host akan memenuhi persyaratan ini, dalam hal ini logika perlu dipilih. Ada tiga cara untuk menyelesaikan ambiguitas dalam keanggotaan grup host:

  1. Konfigurasikan antrean sehingga tidak ada ambiguitas.
  2. Tambahkan batasan ke autoscale.json.
  3. Biarkan CycleCloud memilih grup host yang cocok dengan nama yang diurutkan dengan menyesuaikan weight_queue_host_sort < weight_queue_seqno dalam konfigurasi penjadwal.
  4. Atur seq_no 10000,[@hostgroup1=100],[@hostgroup2=200] dalam konfigurasi antrean untuk menunjukkan preferensi grup host.

Batasan grup host

Ketika beberapa grup host didefinisikan oleh antrean atau xproject, semua grup host ini berpotensi memiliki host yang ditambahkan ke dalamnya. Anda dapat membatasi jenis host apa yang dapat ditambahkan ke antrean mana dengan mengatur batasan grup host. Atur batasan berdasarkan properti simpul.

"gridengine": {
    "hostgroups": {
      "@mpi": {
        "constraints": {
          "node.vm_size": "Standard_H44rs"
        }
      },
      "@amd-mem": {
        "constraints" : { 
            "node.vm_size": "Standard_D2_v3",
            "node.nodearray": "hpc" 
            }
        },
    }
  }

PETUNJUK: Periksa semua properti simpul yang tersedia dengan azge buckets.

azge

Paket ini dilengkapi dengan baris perintah, azge. Program ini harus digunakan untuk melakukan autoscaling dan telah memecahkan semua subproses di bawah skala otomatis. Perintah ini bergantung pada variabel lingkungan gridengine yang akan diatur - Anda harus dapat memanggil qconf dan qsub dari profil yang sama di mana azge dipanggil.

perintah azge Deskripsi
validate Memeriksa kesalahan konfigurasi yang diketahui di autoscaler atau gridengine
jobs Menampilkan semua pekerjaan dalam antrean
wadah Memperlihatkan kumpulan sumber daya yang tersedia untuk penskalaan otomatis
nodes Menampilkan host dan properti kluster
Permintaan Cocok dengan persyaratan pekerjaan dengan bucket cyclecloud dan memberikan hasil skala otomatis
autoscale Apakah skala otomatis penuh, memulai dan menghapus simpul sesuai dengan konfigurasi

Saat memodifikasi konfigurasi penjadwal (qconf) atau konfigurasi skala otomatis (autoscale.json), atau bahkan menyiapkan untuk pertama kalinya, azge dapat digunakan untuk memeriksa perilaku skala otomatis cocok dengan harapan. Sebagai root, Anda dapat menjalankan operasi berikut. Disarankan untuk membiasakan diri dengan ini untuk memahami perilaku skala otomatis.

  1. Jalankan azge validate untuk memverifikasi konfigurasi untuk masalah yang diketahui.
  2. Jalankan azge buckets untuk memeriksa sumber daya apa yang ditawarkan kluster CycleCloud Anda.
  3. Jalankan azge jobs untuk memeriksa detail pekerjaan yang diantrekan.
  4. Jalankan azge demand melakukan pekerjaan untuk pencocokan wadah, periksa pekerjaan mana yang cocok dengan wadah dan grup host mana.
  5. Jalankan azge autoscale untuk memulai proses alokasi simpul, atau tambahkan simpul yang siap untuk bergabung.

Kemudian, ketika perintah ini berperilaku seperti yang diharapkan, aktifkan skala otomatis yang sedang berlangsung dengan menambahkan azge autoscale perintah ke crontab akar. (Souce variabel lingkungan gridengine)

* * * * * . $SGE_ROOT/common/settings.sh && /usr/local/bin/azge autoscale -c /opt/cycle/gridengine/autoscale.json

Membuat kluster hibrid

CycleCloud akan mendukung skenario bursting ke cloud. Konfigurasi dasar mengasumsikan bahwa $SGE_ROOT direktori tersedia untuk simpul cloud. Asumsi ini dapat dilonggarkan dengan mengatur gridengine.shared.spool = false, gridengine.shared.bin = false dan menginstal GridEngine secara lokal. Untuk kasus sederhana, Anda harus menyediakan sistem file yang dapat dipasang oleh simpul eksekusi yang berisi $SGE_ROOT direktori dan mengonfigurasi pemasangan tersebut di pengaturan opsional. Ketika dependensi direktori sched dan bersama dirilis, Anda dapat mematikan node penjadwal yang merupakan bagian dari kluster secara default dan menggunakan konfigurasi dari sistem file eksternal.

  1. Buat kluster gridengine baru.
  2. Nonaktifkan proksi pengembalian.
  3. Ganti /sched dan /shared dengan sistem file eksternal.
  4. Simpan kluster.
  5. Hapus simpul penjadwal sebagai tindakan di UI.
  6. Mulai kluster, node awalnya akan dimulai.
  7. Mengonfigurasi cyclecloud-gridengine dengan autoscale.json untuk menggunakan kluster baru

Menggunakan Univa Grid Engine di CycleCloud

Proyek CycleCloud untuk GridEngine menggunakan sge-2011.11 secara default. Anda dapat menggunakan alat penginstal Altair GridEngine Anda sendiri sesuai dengan perjanjian lisensi Altair Anda.
Bagian ini men dokumentasi cara menggunakan Altair GridEngine dengan proyek CycleCloud GridEngine.

Prasyarat

Contoh ini akan menggunakan versi demo 8.6.1, tetapi semua versi > ge 8.4.0 didukung.

  1. Pengguna harus menyediakan biner UGE
  • ge-8.6.x-bin-lx-amd64.tar.gz
  • ge-8.6.x-common.tar.gz
  1. CycleCloud CLI harus dikonfigurasi. Dokumentasi tersedia di sini

Salin biner ke loker cloud

Versi pelengkap AGE (8.6.7-demo) didistribusikan dengan CycleCloud. Untuk menggunakan versi lain, unggah biner ke akun penyimpanan yang digunakan CycleCloud.


$ azcopy cp ge-8.6.12-bin-lx-amd64.tar.gz https://<storage-account-name>.blob.core.windows.net/cyclecloud/gridengine/blobs/
$ azcopy cp ge-8.6.12-common.tar.gz https://<storage-account-name>.blob.core.windows.net/cyclecloud/gridengine/blobs/

Memodifikasi konfigurasi ke templat kluster

Buat salinan lokal templat gridengine dan ubah untuk menggunakan alat penginstal UGE alih-alih default.

wget https://raw.githubusercontent.com/Azure/cyclecloud-gridengine/master/templates/gridengine.txt

Dalam file gridengine.txt , temukan kemunculan [[[configuration]]] pertama dan sisipkan teks sehingga cocok dengan cuplikan di bawah ini. File ini tidak sensitif terhadap indentasi.

CATATAN: Detail dalam konfigurasi, terutama versi, harus cocok dengan nama file penginstal.

[[[configuration gridengine]]]
    make = ge
    version = 8.6.12-demo
    root = /sched/ge/ge-8.6.12-demo
    cell = "default"
    sge_qmaster_port = "537"
    sge_execd_port = "538"
    sge_cluster_name = "grid1"
    gid_range = "20000-20100"
    qmaster_spool_dir = "/sched/ge/ge-8.6.12-demo/default/spool/qmaster" 
    execd_spool_dir = "/sched/ge/ge-8.6.12-demo/default/spool"
    spooling_method = "berkeleydb"
    shadow_host = ""
    admin_mail = ""
    idle_timeout = 300

    managed_fs = true
    shared.bin = true

    ignore_fqdn = true
    group.name = "sgeadmin"
    group.gid = 536
    user.name = "sgeadmin"
    user.uid = 536
    user.gid = 536
    user.description = "SGE admin user"
    user.home = "/shared/home/sgeadmin"
    user.shell = "/bin/bash"

Konfigurasi ini akan menggantikan versi gridengine default dan lokasi penginstalan saat kluster dimulai. Tidak aman untuk pindah dari /sched karena ini adalah lokasi nfs yang dibagikan secara khusus di kluster.