Menyebarkan model ke kluster Azure Kubernetes Service

Pelajari cara menggunakan Azure Machine Learning untuk menyebarkan model sebagai layanan web di Azure Kubernetes Service (AKS). Azure Kubernetes Service baik untuk penyebaran produksi skala tinggi. Gunakan Azure Kubernetes Services jika kamu membutuhkan satu atau beberapa kemampuan berikut:

  • Waktu respons cepat
  • Penghitungan otomatis layanan yang disebarkan
  • Pengelogan
  • Pengumpulan data model
  • Autentikasi
  • Penghentian TLS
  • Opsi akselerasi perangkat keras seperti GPU dan array gerbang yang dapat diprogram bidang (FPGA)

Saat menyebarkan ke Azure Kubernetes Service, Anda menyebarkan ke klaster AKS yang terhubung ke ruang kerja Anda. Untuk informasi tentang menghubungkan kluster AKS ke ruang kerja, lihat Membuat dan melampirkan kluster Azure Kubernetes Service.

Penting

Kami menyarankan agar Anda men-debug secara lokal sebelum menyebarkan ke layanan web. Untuk mengetahui informasi selengkapnya, lihat Debug Secara Lokal.

Anda juga bisa merujuk ke Azure Machine Learning - Menyebarkan ke Local Notebook

Catatan

Titik Akhir Pembelajaran Mesin Azure (pratinjau) memberikan pengalaman penyebaran yang lebih baik dan lebih sederhana. Titik akhir mendukung skenario inferensi real-time dan batch. Titik akhir menyediakan antarmuka terpadu untuk menjalankan dan mengelola penyebaran model di seluruh jenis komputasi. Lihat Apa yang dimaksud dengan titik akhir Pembelajaran Mesin Azure (pratinjau)?.

Prasyarat

Memahami proses penyebaran

Kata "penyebaran" digunakan dalam Kubernetes dan Azure Machine Learning. "Penyebaran" memiliki arti yang berbeda dalam dua konteks ini. Dalam Kubernetes, Deployment adalah entitas konkret, ditentukan dengan berkas YAML deklaratif. Sebuah Kubernetes Deployment memiliki siklus hidup yang ditentukan dan hubungan konkret dengan entitas Kubernetes lainnya seperti Pods dan ReplicaSets. Anda bisa belajar tentang Kubernetes dari dokumen dan video di Apa itu Kubernetes?

Di Azure Machine Learning, "penyebaran" digunakan dalam arti yang lebih umum untuk menyediakan dan membersihkan sumber daya proyek Anda. Langkah-langkah yang dipertimbangkan Azure Machine Learning sebagai bagian dari penyebaran adalah:

  1. Zipping file di folder proyek Anda, mengabaikan yang ditentukan dalam .amlignore atau .gitignore
  2. Meningkatkan klaster komputasi (Berkaitan dengan Kubernetes)
  3. Membangun atau mengunduh dockerfile ke node komputasi (Berkaitan dengan Kubernetes)
    1. Sistem menghitung hash dari:
    2. Sistem menggunakan hash ini sebagai kunci dalam pencarian ruang kerja Azure Container Registry (ACR)
    3. Jika tidak ditemukan, sistem akan mencari kecocokan di ACR global
    4. Jika tidak ditemukan, sistem membangun gambar baru (yang akan di-cache dan terdaftar di ruang kerja ACR)
  4. Mengunduh file proyek zip Anda ke penyimpanan sementara pada node komputasi
  5. Mengekstrak file proyek
  6. Node komputasi yang mengeksekusi python <entry script> <arguments>
  7. Menyimpan log, file model, dan file lain yang ditulis ke ./outputs akun penyimpanan yang terkait dengan ruang kerja
  8. Menghitung mundur komputasi, termasuk menghapus penyimpanan sementara (Berkaitan dengan Kubernetes)

Router Azure ML

Komponen front-end (azureml-fe) yang merutekan permintaan inferensi masuk ke layanan yang digunakan secara otomatis menskalakan sesuai kebutuhan. Penskalaan azureml-fe didasarkan pada tujuan dan ukuran klaster AKS (jumlah node). Tujuan kluster dan node dikonfigurasi saat Anda membuat atau melampirkan klaster AKS. Ada satu layanan azureml-fe per klaster, yang mungkin berjalan pada beberapa pod.

Penting

Saat menggunakan kluster yang dikonfigurasi sebagai dev-test, skalar mandiri dinonaktifkan.

Azureml-fe menskalakan naik (vertikal) untuk menggunakan lebih banyak core, dan keluar (horizontal) untuk menggunakan lebih banyak pod. Saat membuat keputusan untuk meningkatkan skala, waktu yang diperlukan untuk merutekan permintaan inferensi masuk digunakan. Jika kali ini melebihi ambang batas, skala ke atas akan terjadi. Jika waktu untuk merutekan permintaan masuk terus melebihi ambang batas, skala keluar akan terjadi.

Saat menskalakan ke bawah dan ke dalam, penggunaan CPU digunakan. Jika ambang batas penggunaan CPU terpenuhi, ujung depan akan terlebih dahulu diskalakan ke bawah. Jika penggunaan CPU turun ke ambang batas skala ke dalam, operasi skala ke dalam akan terjadi. Penskalaan naik dan keluar hanya akan terjadi jika ada cukup sumber daya kluster yang tersedia.

Memahami persyaratan konektivitas untuk kluster inferensi AKS

Saat Azure Machine Learning membuat atau melampirkan klaster AKS, klaster AKS diterapkan dengan salah satu dari dua model jaringan berikut:

  • Sumber daya jaringan biasanya dibuat dan dikonfigurasi saat klaster AKS disebarkan.
  • Jaringan Antarmuka Jaringan Kontainer Azure (CNI) - Kluster AKS terhubung ke sumber daya dan konfigurasi jaringan virtual yang ada.

Untuk jaringan Kubenet, jaringan dibuat dan dikonfigurasi dengan benar untuk Azure Machine Learning service. Untuk jaringan CNI, Anda perlu memahami persyaratan konektivitas dan memastikan resolusi DNS dan konektivitas keluar untuk inferensi AKS. Misalnya, Anda mungkin menggunakan firewall untuk memblokir lalu lintas jaringan.

Diagram berikut menangkap semua persyaratan konektivitas untuk inferensi AKS. Panah hitam mewakili komunikasi yang sebenarnya, dan panah biru mewakili nama domain. Anda mungkin perlu menambahkan entri untuk host ini ke firewall Anda atau ke server DNS kustom Anda.

Persyaratan Konektivitas untuk Inferensi AKS

Untuk persyaratan konektivitas AKS umum, lihat Mengontrol lalu lintas keluar untuk node kluster di Azure Kubernetes Service.

Persyaratan resolusi DNS secara keseluruhan

Resolusi DNS dalam VNet yang ada berada di bawah kendali Anda. Misalnya, firewall atau server DNS kustom. Host berikut harus dapat dijangkau:

Nama Host Digunakan oleh
<cluster>.hcp.<region>.azmk8s.io Server API AKS
mcr.microsoft.com Microsoft Container Registry (MCR)
<ACR name>.azurecr.io Azure Container Registry (ACR) Anda
<account>.table.core.windows.net Akun Azure Storage (penyimpanan tabel)
<account>.blob.core.windows.net Akun Azure Storage (penyimpanan blob)
api.azureml.ms Autentikasi Azure Active Directory (AAD)
<leaf-domain-label + auto-generated suffix>.<region>.cloudapp.azure.com Nama domain titik akhir, jika Anda digenerasi secara otomatis dengan Azure Machine Learning. Jika Anda menggunakan nama domain kustom, Anda tidak memerlukan entri ini.

Persyaratan konektivitas dalam urutan kronologis: dari pembuatan klaster hingga penyebaran model

Dalam proses pembuatan atau pelampiran AKS, router Azure ML (azureml-fe) digunakan ke dalam klaster AKS. Untuk menyebarkan router Azure ML, node AKS harus dapat:

  • Mengatasi DNS untuk server API AKS
  • Atasi DNS untuk MCR untuk mengunduh gambar docker untuk router Azure ML
  • Unduh gambar dari MCR, di mana konektivitas keluar diperlukan

Tepat setelah azureml-fe disebarkan, azureml-fe akan mencoba untuk memulai dan ini mengharuskan untuk:

  • Mengatasi DNS untuk server API AKS
  • Kueri AKS API server untuk menemukan instance lain dari dirinya sendiri (itu adalah layanan multi-pod)
  • Menyambungkan ke contoh lain itu sendiri

Setelah azureml-fe dimulai, diperlukan konektivitas berikut agar azureml-fe berfungsi dengan baik:

  • Menyambungkan ke Azure Storage untuk mengunduh konfigurasi dinamis
  • Atasi DNS untuk server autentikasi AAD api.azureml.ms dan berkomunikasi dengannya ketika layanan yang diterapkan menggunakan autentikasi AAD.
  • Kueri AKS API server untuk menemukan model yang disebarkan
  • Berkomunikasi dengan POD model yang disebarkan

Pada waktu penyebaran model, untuk penyebaran model yang sukses, node AKS harus dapat:

  • Mengatasi DNS untuk ACR pelanggan
  • Unduh gambar dari ACR pelanggan
  • Mengatasi DNS untuk BLOB Azure tempat model disimpan
  • Unduh model dari BLOB Azure

Setelah model diterapkan dan layanan dimulai, azureml-fe akan secara otomatis menemukannya menggunakan AKS API dan akan siap untuk merutekan permintaan ke sana. Ini harus dapat berkomunikasi dengan pod model.

Catatan

Jika model yang diterapkan memerlukan konektivitas apa pun (misalnya kueri database eksternal atau layanan REST lainnya, mengunduh BLOB dll), maka resolusi DNS dan komunikasi keluar untuk layanan ini harus diaktifkan.

Sebarkan ke AKS

Untuk menyebarkan model ke Azure Kubernetes Service, buat konfigurasi penyebaran yang menjelaskan sumber daya komputasi yang diperlukan. Misalnya, jumlah inti dan memori. Anda juga memerlukan konfigurasi inferensi, yang menjelaskan lingkungan yang diperlukan untuk melakukan host model dan layanan web. Untuk informasi selengkapnya tentang membuat konfigurasi inferensi, lihat Cara dan tempat untuk menyebarkan model.

Catatan

Jumlah model yang akan disebarkan dibatasi hingga 1.000 model per penyebaran (per kontainer).

from azureml.core.webservice import AksWebservice, Webservice
from azureml.core.model import Model
from azureml.core.compute import AksCompute

aks_target = AksCompute(ws,"myaks")
# If deploying to a cluster configured for dev/test, ensure that it was created with enough
# cores and memory to handle this deployment configuration. Note that memory is also used by
# things such as dependencies and AML components.
deployment_config = AksWebservice.deploy_configuration(cpu_cores = 1, memory_gb = 1)
service = Model.deploy(ws, "myservice", [model], inference_config, deployment_config, aks_target)
service.wait_for_deployment(show_output = True)
print(service.state)
print(service.get_logs())

Untuk informasi selengkapnya tentang kelas, metode, dan parameter yang digunakan dalam contoh ini, lihat dokumen referensi berikut:

Penskalaan otomatis

Komponen yang menangani penskalaan otomatis untuk penyebaran model Azure ML adalah azureml-fe, yang merupakan router permintaan cerdas. Karena semua permintaan inferensi melaluinya, router ini memiliki data yang diperlukan untuk secara otomatis menskalakan model yang diterapkan.

Penting

  • Jangan aktifkan Kubernetes Horizontal Pod Autoscaler (HPA) untuk penyebaran model. Melakukannya akan menyebabkan dua komponen auto-scaling bersaing satu sama lain. Azureml-fe dirancang untuk model skala otomatis yang diterapkan oleh Azure ML, di mana HPA harus menebak atau memperkirakan pemanfaatan model dari metrik generik seperti penggunaan CPU atau konfigurasi metrik kustom.

  • Azureml-fe tidak menskalakan jumlah node dalam klaster AKS, karena ini dapat menyebabkan kenaikan biaya yang tidak terduga. Sebaliknya, ini menskalakan jumlah replika untuk model dalam batas klaster fisik. Jika Anda perlu menskalakan jumlah node dalam klaster, Anda dapat menskalakan klaster secara manual atau mengonfigurasi penskala otomatis kluster AKS.

Penskalaan otomatis dapat dikontrol dengan pengaturan autoscale_target_utilization, autoscale_min_replicas, dan autoscale_max_replicas untuk layanan web AKS. Contoh berikut menunjukkan cara mengaktifkan penskalaan otomatis:

aks_config = AksWebservice.deploy_configuration(autoscale_enabled=True, 
                                                autoscale_target_utilization=30,
                                                autoscale_min_replicas=1,
                                                autoscale_max_replicas=4)

Keputusan untuk meningkatkan/menurunkan skala didasarkan pada pemanfaatan replika kontainer saat ini. Jumlah replika yang sibuk (memproses permintaan) dibagi dengan jumlah total replika saat ini adalah pemanfaatan saat ini. Jika angka ini melebihi autoscale_target_utilization, maka lebih banyak replika akan dibuat. Jika lebih rendah, maka replika akan berkurang. Secara default, target utilisasi adalah 70%.

Keputusan untuk menambahkan replika sangat bersemangat dan cepat (sekitar 1 detik). Keputusan untuk menghapus replika bersifat konservatif (sekitar 1 menit).

Anda dapat menghitung replika yang diperlukan dengan menggunakan kode berikut:

from math import ceil
# target requests per second
targetRps = 20
# time to process the request (in seconds)
reqTime = 10
# Maximum requests per container
maxReqPerContainer = 1
# target_utilization. 70% in this example
targetUtilization = .7

concurrentRequests = targetRps * reqTime / targetUtilization

# Number of container replicas
replicas = ceil(concurrentRequests / maxReqPerContainer)

Untuk informasi selengkapnya terkait pengaturan autoscale_target_utilization, autoscale_max_replicas, dan autoscale_min_replicas, lihat referensi modul AksWebservice.

Menyebarkan model ke AKS menggunakan peluncuran terkontrol (pratinjau)

Analisis dan promosikan versi model dengan cara yang terkontrol menggunakan titik akhir. Anda dapat menyebarkan hingga enam versi di belakang satu titik akhir. Titik akhir menyediakan kapabilitas berikut:

  • Mengonfigurasi persentase lalu lintas penilaian yang dikirim ke setiap titik akhir. Misalnya, rute 20% dari lalu lintas ke titik akhir 'uji' dan 80% ke 'produksi'.

    Catatan

    Jika Anda tidak memperhitungkan 100% lalu lintas, persentase yang tersisa akan dialihkan ke versi titik akhir default. Misalnya, jika Anda mengonfigurasi versi titik akhir 'uji' untuk mendapatkan 10% lalu lintas, dan 'produksi' sebesar 30%, 60% sisanya dikirim ke versi titik akhir default.

    Versi titik akhir pertama yang dibuat secara otomatis dikonfigurasi sebagai default. Anda dapat mengubahnya dengan mengatur is_default=True ​​saat membuat atau memperbarui versi titik akhir.

  • Tandai versi titik akhir sebagai kontrol atau perawatan. Misalnya, versi titik akhir produksi saat ini mungkin merupakan kontrol, sementara model baru kemungkinan disebarkan sebagai versi perawatan. Setelah mengevaluasi performa versi perawatan, jika salah satu versi ini mengungguli versi kontrol saat ini, versi perawatan tersebut mungkin dipromosikan ke produksi/kontrol baru.

    Catatan

    Anda hanya dapat memiliki satu versi kontrol. Anda dapat memiliki beberapa versi perawatan.

Anda dapat mengaktifkan insight aplikasi untuk melihat metrik operasional titik akhir dan versi yang diterapkan.

Membuat titik akhir

Setelah siap untuk menyebarkan model Anda, buat titik akhir penilaian dan terapkan versi pertama Anda. Contoh berikut menunjukkan cara menyebarkan dan membuat titik akhir menggunakan SDK. Penyebaran pertama akan didefinisikan sebagai versi default, yang berarti bahwa persentil lalu lintas yang tidak ditentukan di semua versi akan masuk ke versi default.

Tip

Dalam contoh berikut, konfigurasi menetapkan versi titik akhir awal untuk menangani 20% lalu lintas. Karena versi ini adalah titik akhir pertama, berarti juga merupakan versi default. Dan karena kami tidak memiliki versi lain untuk 80% lalu lintas lainnya, versi ini dialihkan ke default juga. Sampai versi lain yang mengambil persentase lalu lintas disebarkan, versi ini secara efektif menerima 100% dari lalu lintas.

import azureml.core,
from azureml.core.webservice import AksEndpoint
from azureml.core.compute import AksCompute
from azureml.core.compute import ComputeTarget
# select a created compute
compute = ComputeTarget(ws, 'myaks')

# define the endpoint and version name
endpoint_name = "mynewendpoint"
version_name= "versiona"
# create the deployment config and define the scoring traffic percentile for the first deployment
endpoint_deployment_config = AksEndpoint.deploy_configuration(cpu_cores = 0.1, memory_gb = 0.2,
                                                              enable_app_insights = True,
                                                              tags = {'sckitlearn':'demo'},
                                                              description = "testing versions",
                                                              version_name = version_name,
                                                              traffic_percentile = 20)
 # deploy the model and endpoint
 endpoint = Model.deploy(ws, endpoint_name, [model], inference_config, endpoint_deployment_config, compute)
 # Wait for he process to complete
 endpoint.wait_for_deployment(True)

Memperbarui dan menambahkan versi ke titik akhir

Tambahkan versi lain ke titik akhir Anda dan konfigurasikan persentil lalu lintas penilaian ke versi tersebut. Ada dua jenis versi, versi kontrol dan versi perawatan. Ada beberapa versi perawatan guna membantu membandingkan dengan satu versi kontrol.

Tip

Versi kedua, dibuat oleh cuplikan kode berikut, menerima 10% lalu lintas. Versi pertama dikonfigurasi untuk 20%, jadi hanya 30% dari lalu lintas yang dikonfigurasi untuk versi tertentu. Sisanya 70% dikirim ke versi titik akhir pertama, karena juga merupakan versi default.

from azureml.core.webservice import AksEndpoint

# add another model deployment to the same endpoint as above
version_name_add = "versionb"
endpoint.create_version(version_name = version_name_add,
                       inference_config=inference_config,
                       models=[model],
                       tags = {'modelVersion':'b'},
                       description = "my second version",
                       traffic_percentile = 10)
endpoint.wait_for_deployment(True)

Perbarui versi yang sudah ada atau hapus versi tersebut di titik akhir. Anda dapat mengubah jenis default versi, jenis kontrol, dan persentil lalu lintas. Dalam contoh berikut, versi kedua meningkatkan lalu lintasnya menjadi 40% dan sekarang menjadi default.

Tip

Setelah cuplikan kode berikut, versi kedua sekarang menjadi default. Versi kedua kini dikonfigurasi untuk 40%, sementara versi asli masih dikonfigurasi untuk 20%. Ini berarti bahwa 40% lalu lintas tidak diperhitungkan oleh konfigurasi versi. Lalu lintas sisa akan dialihkan ke versi kedua, karena sekarang merupakan versi default. Versi tersebut secara efektif menerima 80% dari lalu lintas.

from azureml.core.webservice import AksEndpoint

# update the version's scoring traffic percentage and if it is a default or control type
endpoint.update_version(version_name=endpoint.versions["versionb"].name,
                       description="my second version update",
                       traffic_percentile=40,
                       is_default=True,
                       is_control_version_type=True)
# Wait for the process to complete before deleting
endpoint.wait_for_deployment(true)
# delete a version in an endpoint
endpoint.delete_version(version_name="versionb")

Autentikasi layanan web

Saat menyebarkan Azure Kubernetes Service, autentikasi berbasis kunci diaktifkan secara default. Anda juga dapat mengaktifkan autentikasi berbasis token. Autentikasi berbasis token mengharuskan klien untuk menggunakan akun Azure Active Directory untuk meminta token autentikasi, yang digunakan untuk membuat permintaan ke layanan yang disebarkan.

Untuk menonaktifkan autentikasi, atur parameter auth_enabled=False saat membuat konfigurasi penyebaran. Contoh berikut menonaktifkan autentikasi menggunakan SDK:

deployment_config = AksWebservice.deploy_configuration(cpu_cores=1, memory_gb=1, auth_enabled=False)

Untuk informasi tentang mengautentikasi dari aplikasi klien, lihat Menggunakan model Azure Machine Learning yang disebarkan sebagai layanan web.

Autentikasi dengan kunci

Jika otentikasi kunci diaktifkan, Anda dapat menggunakan metode get_keys ini untuk mengambil kunci autentikasi utama dan sekunder:

primary, secondary = service.get_keys()
print(primary)

Penting

Jika Anda perlu meregenerasi kunci, gunakan service.regen_key

Autentikasi dengan token

Untuk mengaktifkan autentikasi token, atur parameter token_auth_enabled=True saat Anda membuat atau memperbarui penyebaran. Contoh berikut mengaktifkan autentikasi token menggunakan SDK:

deployment_config = AksWebservice.deploy_configuration(cpu_cores=1, memory_gb=1, token_auth_enabled=True)

Jika autentikasi token diaktifkan, Anda dapat menggunakan metode get_token untuk mengambil token JWT dan waktu masa habis berlaku token tersebut:

token, refresh_by = service.get_token()
print(token)

Penting

Anda harus meminta token baru setelah waktu refresh_by token.

Microsoft sangat menyarankan agar Anda membuat ruang kerja Azure Machine Learning di wilayah yang sama dengan kluster Azure Kubernetes Service Anda. Untuk mengautentikasi dengan token, layanan web akan melakukan panggilan ke wilayah tempat ruang kerja Azure Machine Learning Anda dibuat. Jika wilayah ruang kerja Anda tidak tersedia, Anda tidak akan dapat mengambil token untuk layanan web, sekalipun kluster berada di wilayah yang berbeda dengan ruang kerja Anda. Hal ini secara efektif mengakibatkan Autentikasi berbasis Token tidak tersedia sampai wilayah ruang kerja Anda tersedia lagi. Selain itu, semakin jauh jarak antara wilayah kluster dengan wilayah ruang kerja Anda, semakin lama waktu yang diperlukan untuk mengambil token.

Untuk mengambil token, Anda harus menggunakan Azure Machine Learning SDK atau perintah az ml service get-access-token.

Pemindaian Kerentanan

Azure Security Center memberikan pengelolaan keamanan terpadu dan perlindungan ancaman canggih di seluruh beban kerja cloud hibrida. Anda harus mengizinkan Azure Security Center untuk memindai sumber daya Anda dan mengikuti rekomendasinya. Untuk informasi selengkapnya, lihat integrasi Azure Kubernetes Service dengan Security Center.

Langkah berikutnya