Kluster CycleCloud GridEngine

ReadME Proyek Kluster CycleCloud GridEngine

Open Grid Scheduler (Grid Engine) dapat dengan mudah diaktifkan pada kluster Azure CycleCloud dengan memodifikasi "run_list" dalam definisi kluster. Kluster Grid Engine terdiri dari dua komponen utama. Yang pertama adalah simpul 'master', yang menyediakan sistem file bersama tempat perangkat lunak Grid Engine berjalan. Yang kedua adalah kumpulan simpul 'eksekusi', yang merupakan host yang memasang sistem file bersama dan menjalankan pekerjaan yang telah diajukan. 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]

Nota

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

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

cyclecloud add_node grid-engine -t execute -c 10

Penyesuaian Otomatis Grid Engine

Azure CycleCloud mendukung penskalaan otomatis untuk Grid Engine. Perilaku ini berarti perangkat lunak terus memantau status antrean Anda dan secara otomatis mengaktifkan atau menonaktifkan simpul sesuai kebutuhan untuk menyelesaikan beban kerja secara efisien dalam hal waktu dan biaya. Anda dapat mengaktifkan penskalaan otomatis untuk Grid Engine dengan menambahkan Autoscale = true ke definisi kluster Anda:

[cluster grid-engine]
Autoscale = True

Secara bawaan, semua tugas yang dikirimkan ke antrean Grid Engine berjalan pada mesin dengan tipe 'execute'. Mesin-mesin ini ditentukan oleh array node bernama 'execute'. Anda tidak terbatas pada nama 'execute', demikian pula Anda tidak terbatas pada satu jenis konfigurasi mesin untuk menjalankan pekerjaan dan melakukan penskalaan otomatis.

Misalnya, skenario umum melibatkan kluster dengan dua definisi simpul yang berbeda. Salah satunya dirancang untuk menjalankan pekerjaan 'normal' yang menggunakan CPU standar. Yang lain ditujukan untuk pekerjaan yang memerlukan komputer berkemampuan GPU. Dalam hal ini, Anda ingin menskalakan antrean Anda secara independen dengan pekerjaan normal dan 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 yang ditunjukkan, sekarang terdapat dua array simpul: Satu adalah array simpul 'standar' 'eksekusi', yang kedua diberi nama 'gpu' dan menyediakan MachineType yang dilengkapi dengan dua GPU NVIDIA (Standard_NV12 di Azure). Perhatikan juga bahwa sekarang ada dua item baru di bagian konfigurasi selain resep 'csge:sgeexec'. Menambahkan gridengine.slot_type = gpu memberi tahu penjadwal Grid Engine bahwa simpul ini harus dinamai sebagai node 'gpu' dan oleh karena itu hanya boleh menjalankan pekerjaan 'gpu'. Nama 'gpu' bersifat arbitrer, tetapi nama yang menjelaskan simpul 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, Grid Engine menetapkan jumlah slot per simpul berdasarkan jumlah CPU sistem. Dalam hal ini, perilaku default tersebut dapat mengakibatkan terlalu banyak pekerjaan yang berjalan bersamaan pada satu simpul. Dalam contoh yang ditampilkan, CoreCount=2 diatur pada nodearray untuk mencocokkan 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 terdapat satu dari setiap 'slot_type' yang disebut 'execute' dan 'gpu'. slot_types dikonfigurasi secara individual, dan jumlah slot untuk slot 'eksekusi' adalah 4, yang sesuai dengan jumlah CPU di dalam mesin. 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 Grid Engine

Pengaturan konfigurasi ini memungkinkan penyesuaian lanjutan node dan array node. Misalnya, jika tugas memerlukan jumlah memori tertentu, katakanlah masing-masing 10 GB, Anda dapat menentukan nodearray 'execute' yang memulai mesin dengan memori 60 GB, kemudian menambahkan opsi konfigurasi gridengine.slots = 6 untuk memastikan bahwa hanya 6 tugas yang dapat dijalankan secara bersamaan pada jenis node ini (memastikan bahwa setiap tugas memiliki setidaknya 10 GB memori untuk bekerja).

Node yang Dikelompokkan di Mesin Kisi

Saat pekerjaan paralel diajukan ke grid engine, perilaku skala otomatis bawaan yang digunakan CycleCloud memperlakukan setiap pekerjaan MPI sebagai permintaan kumpulan nodus. Simpul yang dikelompokkan terhubung dengan erat dan sangat cocok untuk alur kerja MPI.

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

Otomatisasi CycleCloud secara otomatis meminta node yang dikelompokkan dan mengalokasikannya ke grup afinitas yang tersedia ketika pekerjaan paralel terjadi.

Mengirimkan Pekerjaan ke Grid Engine

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

qsub my_job.sh

Perintah ini mengirimkan pekerjaan yang berjalan pada node jenis 'execute', yaitu node yang ditentukan oleh nodearray 'execute'. Untuk menjalankan tugas pada node array dengan jenis yang berbeda, misalnya jenis node 'gpu' yang ditampilkan, kami memodifikasi pengajuan kami.

qsub -l slot_type=gpu my_gpu_job.sh

Perintah ini memastikan bahwa pekerjaan hanya berjalan pada 'slot_type', yaitu 'gpu'.

Jika slot_type dihilangkan, 'jalankan' secara otomatis ditetapkan ke pekerjaan. Pengguna dapat mengubah mekanisme yang secara otomatis menetapkan slot_type ke pekerjaan. 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 dalam bentuk kamus dari pekerjaan, yang mirip dengan output dari perintah qstat -j JOB_ID dan harus mengembalikan kamus sumber daya fisik atau material yang perlu diperbarui untuk pekerjaan tersebut.

Sebagai contoh, skrip berikut menetapkan pekerjaan ke 'gpu' slot_type jika nama pekerjaan menyertakan huruf 'gpu'. Pengguna diizinkan untuk mengirimkan pekerjaan mereka secara otomatis tanpa mengubah parameter pekerjaan, sambil tetap memastikan pekerjaan berjalan 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 menetapkan slot_type secara otomatis berdasarkan parameter pekerjaan apa pun yang ditentukan, seperti argumen, persyaratan sumber daya seperti memori, atau pengguna yang mengirimkan.

Misalkan Anda mengajukan 5 tugas untuk 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, lima pekerjaan dengan 'gpu' di namanya akan dikonfigurasi secara otomatis untuk hanya berjalan pada simpul dengan 'slot_type=gpu'. Mekanisme skala otomatis CycleCloud akan mendeteksi bahwa ada 5 tugas 'gpu' dan 5 tugas 'eksekusi'. 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 'eksekusi' memiliki masing-masing 4 CPU, CycleCloud memulai 2 simpul ini untuk menangani pekerjaan (5/4=1,25 dibulatkan menjadi 2). Setelah periode startup singkat, simpul yang baru diluncurkan melakukan booting dan mengonfigurasi dirinya sendiri. Setelah siap, semua 10 pekerjaan dijalankan hingga selesai. Kelima simpul tersebut kemudian dimatikan secara otomatis sebelum siklus penagihan lainnya dimulai dengan penyedia cloud.

Pekerjaan diasumsikan memiliki durasi satu jam. Jika runtime pekerjaan diketahui, algoritma skala otomatis dapat memperoleh manfaat dari informasi ini. Informasikan skala otomatis waktu proses pekerjaan yang diharapkan dengan menambahkannya ke konteks pekerjaan. Contoh berikut mengatur waktu operasi tugas untuk skala otomatis ke 10 menit:

qsub -ac average_runtime=10 job_with_duration_of_10m.sh

Referensi Konfigurasi Grid Engine

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 oleh simpul. Defaultnya adalah 'execute'. Ketika pekerjaan ditandai dengan sumber daya keras 'slot_type=', pekerjaan itu hanya berjalan pada komputer dengan jenis slot yang sama. Pemberian tag ini memungkinkan Anda membuat konfigurasi perangkat lunak dan perangkat keras yang berbeda per simpul dan memastikan pekerjaan yang sesuai selalu dijadwalkan pada jenis node yang benar.
gridengine.ignore_fqdn Bawaan: benar. Atur ke false jika semua simpul di kluster Anda bukan bagian dari satu domain DNS.
gridengine.version Bawaan: '2011.11'. Opsi konfigurasi ini menentukan versi Grid Engine untuk diinstal dan dijalankan. Saat ini, ini adalah opsi default dan satu-satunya yang tersedia. Versi lain dari perangkat lunak Grid Engine mungkin didukung di masa mendatang.
gridengine.root Default: '/sched/sge/sge-2011.11' Lokasi ini adalah tempat Grid Engine menginstal dan memasang pada setiap node dalam sistem. Yang terbaik adalah menjaga nilai ini tidak berubah. Namun, jika Anda memodifikasi, pastikan untuk mengatur nilai yang sama pada setiap simpul dalam kluster.

CycleCloud mendukung sekumpulan atribut autostop standar di seluruh penjadwal:

Karakteristik Deskripsi
cyclecloud.cluster.otomatis.diperlambat_aktif Mengaktifkan autostop pada simpul ini. [benar/salah]
cyclecloud.cluster.autoscale.waktu_diam_setelah_pekerjaan Jumlah waktu (dalam detik) sebuah simpul menganggur setelah menyelesaikan pekerjaan sebelum berhenti secara otomatis.
cyclecloud.cluster.autoscale.waktu_idle_sebelum_pekerjaan Jumlah waktu (dalam detik) bagi simpul dalam keadaan tidak aktif setelah menyelesaikan pekerjaan sebelum berhenti secara otomatis.

Masalah yang Diketahui

  • qsh perintah untuk sesi interaktif tidak berfungsi. Gunakan qrsh sebagai alternatif.
  • Skala otomatis tidak menghormati exclusive=1 kompleks, yang dapat menyebabkan lebih sedikit simpul dari yang diharapkan untuk memulai.

Nota

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

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

Mengonfigurasi Sumber Daya

Aplikasi cyclecloud-gridengine mencocokkan sumber daya sge dengan sumber daya Azure cloud untuk menyediakan alat yang kaya untuk konfigurasi kluster dan pengaturan skala otomatis. Aplikasi ini 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 mengikuti proses yang sama. Aplikasi ini memerlukan python3 dengan virtualenv.

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

File Penting

Aplikasi mengurai konfigurasi SGE setiap kali berjalan - tugas, antrian, kompleksitas. Informasi disediakan ke dalam stderr dan stdout dari perintah serta ke dalam file log, yang semuanya berada 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
Catatan 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, 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 dan 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 memulai setidaknya satu VM. Ketika kluster ditambahkan, kluster bergabung dengan kelompok host @mpihg02 karena itulah kelompok host yang tersedia baik untuk antrean maupun untuk lingkungan paralel. Ini juga bergabung dalam @allhosts, sebuah grup host khusus.

Jika Anda mengirimkan pekerjaan dengan qsub -q short.q my-script.sh dan tidak menentukan lingkungan paralel (pe), VM yang dihasilkan bergabung dengan grup host @allhosts dan @lowpriority yang ditautkan ke antrean yang tidak memiliki lingkungan paralel (pe) apa pun.

Terakhir, pekerjaan yang dikirimkan dengan qsub -q short.q -pe mpi0* 12 my-script.sh 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 memilih keluar.

Di sini kita tidak menggunakan grup penempatan untuk membuat pe:

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

Grup Penempatan CycleCloud

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

Menentukan lingkungan paralel untuk sebuah pekerjaan membatasi pekerjaan tersebut untuk dijalankan dalam grup penempatan melalui logika penugasan grup host cerdas. Anda dapat menonaktifkan perilaku ini melalui konfigurasi yang sesuai di autoscale.json: "required_placement_groups" : false.

Konfigurasi penskalaan otomatis

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

  • Mengatur detail koneksi cyclecloud
  • Mengatur timer penghentian untuk simpul diam
  • Autoscaling multi-dimensi didukung. Anda dapat mengonfigurasi atribut mana yang akan digunakan dalam pengemasan pekerjaan, misalnya, slot atau memori
  • Daftarkan antrean, lingkungan paralel, dan grup host yang akan dikelola
Konfigurasi Tipe Deskripsi
URL string CC URL
nama pengguna/kata sandi string Detail Koneksi CC
nama_kluster string Nama Kluster CC
sumber_daya_default Peta Menautkan sumber daya simpul ke sumber daya host Grid Engine untuk skala otomatis
batas waktu diam Integer Waktu tunggu sebelum mengakhiri simpul yang menganggur (detik)
waktu tunggu boot Integer Waktu tunggu sebelum mengakhiri simpul selama fase konfigurasi panjang (s)
mesin_jaringan.kompleks_relevan Daftar (String) Kompleks grid engine yang perlu dipertimbangkan dalam penyesuaian skala otomatis, misalnya, slot, mem_free
gridengine.logging Arsip Lokasi file konfigurasi pengelogan
gridengine.pes Struktur Tentukan perilaku PEs (misalnya, requires_placement_group = false)

Program autoscaling hanya mempertimbangkan Sumber Daya yang Relevan

Sumber daya autoscaling lainnya

Secara default, pekerjaan meminta banyak slot, dan kluster diskalakan berdasarkan permintaan tersebut.

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

  1. Tambahkan m_mem_free ke gridengine.relevant_resources dalamautoscale.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 Tipe Deskripsi
nodearray string Nama nodearray cyclecloud
kelompok_penempatan string Nama grup penempatan cyclecloud dalam nodearray
vm_size string Nama produk VM, misalnya, "Standard_F2s_v2"
vcpu_count Integer CPU virtual tersedia pada simpul seperti yang ditunjukkan pada halaman produk individual
pcpu_count (jumlah_pcpu) Integer CPU fisik tersedia pada simpul
memori string Perkiraan memori fisik yang tersedia di VM dengan indikator unit, misalnya, "8.0g"

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

Simpul Tipe Deskripsi
ncpus string Jumlah CPU yang tersedia di VM
pcpus string Jumlah CPU fisik yang tersedia di VM
ngpus Integer Jumlah GPU yang tersedia di VM
memb string Perkiraan memori fisik yang tersedia di VM dengan indikator unit, misalnya, "8,0b"
memkb string Perkiraan memori fisik yang tersedia di VM dengan indikator unit, misalnya, "8,0k"
memmb string Perkiraan memori fisik yang tersedia di VM dengan indikator unit, misalnya, "8,0m"
memgb string Perkiraan memori fisik yang tersedia di VM dengan indikator unit, misalnya, "8.0g"
memtb string Perkiraan memori fisik yang tersedia di VM dengan indikator unit, misalnya, "8.0t"
Slot Integer Sama seperti ncpus
tipe_slot string Label tambahan untuk ekstensi. Tidak digunakan.
m_mem_free string Memori bebas yang diharapkan pada host eksekusi, misalnya, "3.0g"
mfree string 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 vCPU simpul ke slot yang kompleks, dan memmb ke mem_free adalah default yang umum digunakan. Asosiasi pertama diperlukan.

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

Jika kompleks memiliki pintasan yang tidak sama dengan seluruh nilai, tentukan keduanya dalam 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"
    },
]

Kelompok Tuan Rumah

Penyusun skala otomatis CycleCloud, dalam upayanya memenuhi persyaratan pekerjaan, memetakan node ke kelompok host yang tepat. Antrean, lingkungan paralel, dan kompleks semuanya dipertimbangkan. Sebagian besar logika adalah mencocokkan wadah cyclecloud (dan jumlah 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 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. Konfigurasi batasan grup host tidak memfilternya.

Beberapa grup host mungkin memenuhi persyaratan ini. Ketika itu terjadi, sistem harus memutuskan mana yang akan digunakan. Ada tiga cara untuk mengatasi konflik keanggotaan grup host:

  1. Konfigurasikan antrean untuk menghindari 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.

Keterbatasan grup host

Ketika antrean atau xproject mendefinisikan beberapa grup host, salah satu grup tersebut berpotensi menerima host baru. Untuk mengontrol host mana yang memenuhi syarat untuk antrean mana, Anda dapat menerapkan batasan grup host 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 digunakan untuk melakukan autoscaling dan memecah semua subproses di bawah skala otomatis menjadi komponen terpisah. Perintah ini mengandalkan variabel lingkungan GridEngine yang akan diatur - Anda harus dapat memanggil qconf dan qsub dari profil yang sama di mana azge dipanggil.

perintah azge Deskripsi
memverifikasi Memeriksa kesalahan konfigurasi yang diketahui di autoscaler atau GridEngine
pekerjaan Menampilkan semua pekerjaan dalam antrean
Ember Memperlihatkan kumpulan sumber daya yang tersedia untuk penskalaan otomatis
Node Menampilkan host dan properti kluster
permintaan Mencocokkan persyaratan pekerjaan dengan wadah cyclecloud dan memberikan hasil skala otomatis
penskalaan otomatis Melakukan 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. Untuk memahami cara kerja skala otomatis, penting untuk membiasakan diri dengan konsep-konsep ini.

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

Setelah perintah berfungsi seperti yang diharapkan, aktifkan skala otomatis yang sedang berlangsung dengan menambahkan azge autoscale perintah ke crontab akar. Pastikan untuk sumber variabel lingkungan GridEngine terlebih dahulu.

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

Membuat kluster hibrid

CycleCloud mendukung skenario cloud bursting. Konfigurasi dasar mengasumsikan bahwa direktori $SGE_ROOT tersedia untuk node 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 di-mount oleh simpul eksekusi. Sistem file ini harus menyertakan ... direktori, dan Anda mengonfigurasi pemasangan di pengaturan opsional. Saat dependensi dari direktori sched dan shared dirilis, Anda dapat mematikan node penjadwal yang secara default merupakan bagian dari kluster 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, awalnya tidak ada node yang dijalankan.
  7. Konfigurasikan 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 mendokumentasikan cara menggunakan Altair GridEngine dengan proyek CycleCloud GridEngine.

Prasyarat

Contoh ini menggunakan versi demo 8.6.1, tetapi semua versi GE yang lebih besar dari 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 agar sesuai dengan cuplikan berikut. File tidak sensitif terhadap indentasi.

Nota

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 GridEngine ini menggantikan versi default GridEngine dan lokasi penginstalan ketika kluster mulai. Tidak aman untuk pindah dari /sched karena ini adalah lokasi NFS bersama di kluster.

  • Last updated on