Modell üzembe helyezése egy Azure Kubernetes Service fürtön

Megtudhatja, hogyan helyezhet Azure Machine Learning modellt webszolgáltatásként a Azure Kubernetes Service (AKS) használatával. Azure Kubernetes Service nagy léptékű éles környezetekben való üzembe helyezéshez megfelelő. Akkor használja az Azure Kubernetes Service-t, ha az alábbi képességek közül egy vagy többre van szüksége:

  • Gyors válaszidő
  • Az üzembe helyezett szolgáltatás automatikus skálázása
  • Logging
  • Modelladatok gyűjtése
  • Hitelesítés
  • TLS-letöltés
  • Hardvergyorsítási lehetőségek, például GPU és helyszínen programozható kaputömbök (FPGA)

Az üzembe helyezés Azure Kubernetes Service a munkaterülethez csatlakozó AKS-fürtön történik. Az AKS-fürtök munkaterülethez való csatlakoztatásával kapcsolatos információkért lásd: Fürtfürt létrehozása Azure Kubernetes Service csatolása.

Fontos

A webszolgáltatásban való üzembe helyezés előtt javasoljuk a helyi hibakeresést. További információ: Helyi hibakeresés

További információ: Azure Machine Learning – Üzembe helyezés helyi notebookba

Előfeltételek

  • Egy Azure Machine Learning-munkaterület. További információ: Create an Azure Machine Learning workspace(Munkaterület Azure Machine Learning létrehozása).

  • A munkaterületen regisztrált gépi tanulási modell. Ha még nem regisztrált modellel, tekintse meg a modellek üzembe helyezésének mikéntjéhez és helyéhez lásd:.

  • Az Azure CLI-bővítmény Machine Learning szolgáltatáshoz, Azure Machine Learning Python SDK-hozvagy a Azure Machine Learning Visual Studio Code-bővítményhez.

  • A cikkben a Python-kódrészletek feltételezik, hogy a következő változók vannak beállítva:

    • ws – Állítsa be a munkaterületet.
    • model – Állítsa be a regisztrált modellt.
    • inference_config – Állítsa be a modell következtetési konfigurációját.

    A változók beállításával kapcsolatos további információkért lásd: Modellek üzembehelyezése.

  • A cikkben olvasható CLI-kódrészletek feltételezik, hogy létrehozott egy inferenceconfig.json dokumentumot. További információ a dokumentum létrehozásáról: Modellek üzembehelyezése.

  • Egy Azure Kubernetes Service a munkaterülethez csatlakoztatva. További információ: Create and attach an Azure Kubernetes Service cluster (Fürt létrehozása Azure Kubernetes Service csatolása).

    • Ha modelleket szeretne üzembe helyezni GPU-csomópontokon vagy FPGA-csomópontokon (vagy bármely adott termékváltozatban), létre kell hoznia egy fürtöt az adott termékváltozattal. A másodlagos csomópontkészletek meglévő fürtben való létrehozása és a modellek a másodlagos csomópontkészletben való üzembe helyezése nem támogatott.

Az üzembe helyezési folyamatok

Az "üzembe helyezés" szó a Kubernetesben és a Azure Machine Learning. Ebben a két kontextusban az "üzembe helyezés" különböző jelentéssel bír. A Kubernetesben az egy Deployment konkrét entitás, amely egy deklaratív YAML-fájllal van megadva. A Kubernetes meghatározott életciklussal és konkrét kapcsolatokkal rendelkezik más Kubernetes-entitásokkal, például a és a Deployment Pods ReplicaSets entitásokkal. A Kubernetesről a Mi az a Kubernetes?című cikkből származó dokumentumokból és videókból tanulhat.

A Azure Machine Learning az "üzembe helyezést" általában a projekterőforrások elérhetővé és tisztítására használják. Az üzembe helyezés Azure Machine Learning a következő lépéseket kell figyelembe vennie:

  1. Tömöríti a projektmappában lévő fájlokat, figyelmen kívül hagyva az .amlignore vagy .gitignore fájlban megadott fájlokat
  2. A számítási fürt felméretezése (a Kuberneteshez kapcsolódik)
  3. A dockerfile kiépítése vagy letöltése a számítási csomópontra (a Kuberneteshez kapcsolódik)
    1. A rendszer a következő kivonatát számítja ki:
    2. A rendszer ezt a kivonatot használja kulcsként a munkaterület-Azure Container Registry (ACR)
    3. Ha nem található, egyezést keres a globális ACR-ban
    4. Ha nem található, a rendszer egy új rendszerképet hoz létre (amely gyorsítótárazva lesz, és le lesz küldve a munkaterület ACR-nek)
  4. A tömörített projektfájl letöltése ideiglenes tárolóba a számítási csomóponton
  5. A projektfájl kicsomagolása
  6. A végrehajtás alatt álló számítási csomópont python <entry script> <arguments>
  7. Naplók, modellfájlok és a munkaterülethez társított tárfiókba írt egyéb ./outputs fájlok mentése
  8. Számítási erőforrások leméretezése, beleértve az ideiglenes tárterület eltávolítását (a Kuberneteshez kapcsolódik)

Azure ML-útválasztó

Az előtér-összetevő (azureml-fe), amely a bejövő következtetési kérelmeket az üzembe helyezett szolgáltatásokhoz használja, automatikusan méretez. Az azureml-fe méretezése az AKS-fürt célja és mérete (csomópontok száma) alapján van megszava. A fürt célja és a csomópontok az AKS-fürt létrehozásakor vagy csatolva vannak konfigurálva. Fürtönként egy azureml-fe szolgáltatás fut, amely több podon is futhat.

Fontos

Ha fejlesztői tesztként konfigurált fürtöt használ, az önméretozó le van tiltva.

Az Azureml-fe vertikálisan felskálál, hogy több magot használjon, és (vízszintesen) több podot használjon. A felskálásról szóló döntés meghozatalakor a rendszer a bejövő következtetési kérelmek útválasztásának idejét használja. Ha ez az idő meghaladja a küszöbértéket, felskálás történik. Ha a bejövő kérések útválasztási ideje továbbra is meghaladja a küszöbértéket, felskálás történik.

A le- és leméretezés cpu-használatot használ. Ha a processzorhasználat küszöbértéke teljesül, az előtere először le lesz skálázva. Ha a CPU-használat a leskálás küszöbértékre csökken, leskálás művelet történik. A fel- és felméretezés csak akkor történik meg, ha elegendő fürterőforrás áll rendelkezésre.

Az AKS következtetési fürtök kapcsolati követelményeinek ismertetése

Amikor Azure Machine Learning AKS-fürtöt hoz létre vagy csatol, az AKS-fürt a következő két hálózati modell egyikével lesz üzembe helyezni:

  • Kubenet-hálózat – A hálózati erőforrások általában az AKS-fürt üzembe helyezésekor vannak létrehozva és konfigurálva.
  • Azure Container Network Interface (CNI) hálózatkezelés – Az AKS-fürt a meglévő virtuális hálózati erőforrásokhoz és konfigurációkhoz csatlakozik.

Az első hálózati módban létrejön a hálózat, és megfelelően van konfigurálva a Azure Machine Learning service. A második hálózati mód esetén, mivel a fürt egy meglévő virtuális hálózathoz csatlakozik, különösen ha egyéni DNS-t használ a meglévő virtuális hálózathoz, az ügyfélnek külön figyelmet kell fordítania az AKS-következtetési fürt csatlakozási követelményeire, és biztosítania kell a DNS-feloldás és a kimenő kapcsolat az AKS-következtetéshez.

Az alábbi ábra az AKS-következtetés összes csatlakozási követelményét rögzíti. A fekete nyilak a tényleges kommunikációt, a kék nyilak pedig az ügyfél által vezérelt DNS által feloldott tartományneveket képviselik.

Az AKS-következtetés csatlakozási követelményei

A DNS-feloldás általános követelményei

A meglévő VNET-en belüli DNS-feloldás az ügyfél ellenőrzése alatt áll. A következő DNS-bejegyzéseknek feloldhatónak kell lennie:

  • AKS API-kiszolgáló <cluster> .hcp. <region> formájában. azmk8s.io
  • Microsoft Container Registry (MCR): mcr.microsoft.com
  • Az ügyfél Azure Container Registry (ARC) <ACR name> .azurecr.io
  • Azure Storage-fiók <account> .table.core.windows.net <account> és .blob.core.windows.net
  • (Nem kötelező) AAD-hitelesítés esetén: api.azureml.ms
  • Végpont tartománynevének pontozása, amelyet automatikusan hoz létre az Azure ML vagy az egyéni tartománynév. Az automatikusan létrehozott tartománynév így néz ki: <leaf-domain-label + auto-generated suffix> <region> . cloudapp.azure.com

A kapcsolódási követelmények időrendi sorrendben: a fürtök létrehozásától a modell üzembe helyezéséig

Az AKS létrehozása vagy csatolása során az Azure ML-útválasztó (azureml-fe) az AKS-fürtön lesz üzembe véve. Az Azure ML-útválasztó üzembe helyezéséhez az AKS-csomópontnak képesnek kell lennie a következőre:

  • Az AKS API-kiszolgáló DNS-ének feloldása
  • Az MCR DNS-ének feloldása docker-rendszerképek letöltéséhez az Azure ML-útválasztóhoz
  • Rendszerképek letöltése az MCR-ről, ahol kimenő kapcsolatra van szükség

Közvetlenül az azureml-fe üzembe helyezése után megpróbál elindulni, és ehhez a következőre van szükség:

  • Az AKS API-kiszolgáló DNS-ének feloldása
  • Az AKS API-kiszolgáló lekérdezése saját maga más példányainak felderítéséhez (ez egy több podos szolgáltatás)
  • Csatlakozás saját maga más példányaihoz

Az azureml-fe elindulás után további kapcsolatra van szükség a megfelelő működéshez:

  • Csatlakozás az Azure Storage-hoz a dinamikus konfiguráció letöltéséhez
  • Az AAD-hitelesítési kiszolgáló DNS-api.azureml.ms, és kommunikáljon vele, amikor az üzembe helyezett szolgáltatás AAD-hitelesítést használ.
  • AKS API-kiszolgáló lekérdezése az üzembe helyezett modellek felderítéséhez
  • Kommunikáció az üzembe helyezett modell POD-ival

A modell üzembe helyezésekor a modell sikeres üzembe helyezéséhez az AKS-csomópontnak képesnek kell lennie a következőre:

  • Dns feloldása az ügyfél ACR-hez
  • Rendszerképek letöltése az ügyfél ACR-ről
  • A modellt tároló Azure-blobok DNS-ének feloldása
  • Modellek letöltése az Azureblob-ból

A modell üzembe helyezése és a szolgáltatás indítása után az azureml-fe automatikusan felderíti azt az AKS API-val, és készen áll a kérések útválasztására. Képesnek kell lennie kommunikálni a modell POD-iival.

Megjegyzés

Ha az üzembe helyezett modellnek bármilyen kapcsolatra van szüksége (például külső adatbázis vagy más REST-szolgáltatás lekérdezése, blob letöltése stb.), akkor engedélyezni kell a DNS-feloldás és a szolgáltatások kimenő kommunikációját is.

Üzembe helyezés az AKS-ben

A modell üzembe helyezéséhez a Azure Kubernetes Service hozzon létre egy üzembe helyezési konfigurációt, amely leírja a szükséges számítási erőforrásokat. Például a magok száma és a memória. Emellett szükség van egy következtetési konfigurációra is, amely leírja a modell és a webszolgáltatás gazdagépéhez szükséges környezetet. A következtetési konfiguráció létrehozásával kapcsolatos további információkért lásd: Modelleküzembe helyezése.

Megjegyzés

Az üzembe helyezendő modellek száma üzemelő példányonként legfeljebb 1000 modell lehet (tárolónként).

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

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())

A példában használt osztályokkal, metódusokkal és paraméterekkel kapcsolatos további információkért tekintse meg a következő referenciadokumentumokat:

Automatikus skálázás

Az Azure ML-modellek üzembe helyezésének automatikus skálázását kezelő összetevő az azureml-fe, amely egy intelligens kérés-útválasztó. Mivel minden következtetési kérelem áthalad rajta, rendelkezik az üzembe helyezett modell(ök) automatikus méretezéséhez szükséges adatokkal.

Fontos

  • Ne engedélyezze a Kubernetes automatikus horizontális podméretezőt (HPA) a modell üzembe helyezéséhez. Ha így tesz, a két automatikus skálázású összetevő versenghet egymással. Az Azureml-fe az Azure ML által üzembe helyezett modellek automatikus skálázhatóságára lett tervezve, ahol a HPA-nak egy általános metrika, például a CPU-használat vagy egy egyéni metrikakonfiguráció alapján kellene kitalálnia vagy megközelítene a modellek kihasználtságát.

  • Az Azureml-fe nem skáláz a csomópontok számát egy AKS-fürtben, mivel ez váratlan költségnövekedéshez vezethet. Ehelyett skálázható a modell replikáinak száma a fizikai fürthatáron belül. Ha skáláznia kell a fürtön belüli csomópontok számát, skálázhatja manuálisan a fürtöt, vagy konfigurálhatja az automatikus AKS-fürtméretozót.

Az automatikus skálázás az AKS-webszolgáltatás , és beállításával autoscale_target_utilization autoscale_min_replicas autoscale_max_replicas szabályozható. Az alábbi példa az automatikus skálázás engedélyezését mutatja be:

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

A fel-/leskálával kapcsolatos döntések az aktuális tárolóreplikák kihasználtságán alapulnak. A foglalt replikák száma (kérés feldolgozása) és az aktuális replikák teljes száma az aktuális kihasználtság. Ha ez a szám nagyobb, autoscale_target_utilization mint , akkor több replika jön létre. Ha alacsonyabb, a replikák lecsökkennek. Alapértelmezés szerint a célkihasználtság 70%.

A replikák hozzáadására vonatkozó döntések lelkesek és gyorsak (körülbelül 1 másodperc). A replikák eltávolításával kapcsolatos döntések óvatosak (körülbelül 1 perc).

A szükséges replikákat a következő kóddal számíthatja ki:

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)

A , és beállításával autoscale_target_utilization autoscale_max_replicas kapcsolatos további információkért tekintse meg az autoscale_min_replicas AksWebservice modul referenciáját.

Modellek üzembe helyezése az AKS-be szabályozott bevezetés használatával (előzetes verzió)

Modellverziók ellenőrzött módon elemezhetők és előléptethetők végpontok használatával. Egyetlen végpont mögött legfeljebb hat verzió helyezhető üzembe. A végpontok a következő képességeket biztosítják:

  • Konfigurálja az egyes végpontokra küldött pontozási forgalom százalékos arányát. Például a forgalom 20%-át a "test" végpontra, a 80%-át pedig az "éles" végpontra irányíthatja.

    Megjegyzés

    Ha nem veszi figyelembe a forgalom 100%-át, a rendszer minden fennmaradó százalékot az alapértelmezett végpontverzióra irányít át. Ha például úgy konfigurálja a "test" végpontverziót, hogy az a forgalom 10%-át, a "prod" értéket pedig 30%-ra állítsa be, a fennmaradó 60% az alapértelmezett végpontverzióra lesz elküldve.

    A rendszer automatikusan alapértelmezettként konfigurálja az első létrehozott végpontverziót. Ezt a beállítást a végpontverzió is_default=True létrehozásakor vagy frissítésekkor módosíthatja.

  • Jelölje meg a végpontverziót vezérlőként vagy kezelésként. Előfordulhat például, hogy az éles végpont aktuális verziója a vezérlő, míg a lehetséges új modellek kezelési verzióként vannak üzembe telepítve. A kezelési verziók teljesítményének kiértékelését követően, ha az egyik a jelenleginél jobb, előléptetve lehet az új éles/kontrollos verzióra.

    Megjegyzés

    Csak egy vezérlővel lehet. Több kezelés is lehet.

Az App Insights segítségével megtekintheti a végpontok és az üzembe helyezett verziók működési metrikákat.

Végpont létrehozása

Ha készen áll a modellek üzembe helyezésére, hozzon létre egy pontozási végpontot, és telepítse az első verziót. Az alábbi példa bemutatja, hogyan helyezheti üzembe és hozhatja létre a végpontot az SDK használatával. Az első üzembe helyezés az alapértelmezett verzióként lesz meghatározva, ami azt jelenti, hogy az összes verzióra vonatkozó meghatározatlan forgalom percentilise az alapértelmezett verzióra fog átmenni.

Tipp

A következő példában a konfiguráció úgy állítja be a kezdeti végpontverziót, hogy az kezelje a forgalom 20%-át. Mivel ez az első végpont, egyben az alapértelmezett verzió is. Mivel a forgalom többi 80%-ában nincs más verzió, a rendszer az alapértelmezett verzióra is irányítva van. Amíg nem helyez üzembe más verziókat, amelyek a forgalom egy százalékát használják, ez gyakorlatilag a forgalom 100%-át kapja meg.

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)

Verziók frissítése és hozzáadása egy végponthoz

Adjon hozzá egy újabb verziót a végponthoz, és konfigurálja a pontozási forgalom percentilisét a verzióra. Kétféle verzió létezik: egy vezérlő és egy kezelési verzió. Több kezelési verzió is segíthet összehasonlítani őket egyetlen kontrollverzióval.

Tipp

Az alábbi kódrészlet által létrehozott második verzió a forgalom 10%-át fogadja el. Az első verzió 20%-ra van konfigurálva, így a forgalomnak csak 30%-a van konfigurálva adott verziókhoz. A rendszer a fennmaradó 70%-ot az első végpontverzióra küldi, mivel egyben az alapértelmezett verzió is.

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)

Frissítse a meglévő verziókat, vagy törölje őket egy végponton. Módosíthatja a verzió alapértelmezett típusát, vezérlőtípusát és a forgalom percentilisét. A következő példában a második verzió 40%-ra növeli a forgalmat, és mostantól ez az alapértelmezett.

Tipp

Az alábbi kódrészlet után a második verzió már alapértelmezett. Most már 40%-ra van konfigurálva, míg az eredeti verzió még mindig 20%-ra van konfigurálva. Ez azt jelenti, hogy a verziókonfigurációk nem veszik figyelembe a forgalom 40%-át. A rendszer a második verzióra fogja irányítva a maradék forgalmat, mivel ez az alapértelmezett beállítás. Hatékonyan fogadja a forgalom 80%-át.

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")

Webszolgáltatás-hitelesítés

A központi telepítés Azure Kubernetes Service a kulcsalapú hitelesítés alapértelmezés szerint engedélyezve van. Jogkivonat-alapú hitelesítést is engedélyezhet. A jogkivonat-alapú hitelesítéshez az ügyfeleknek egy Azure Active Directory-fiókot kell használnia a hitelesítési jogkivonat igényléséhez, amely az üzembe helyezett szolgáltatásnak való kérések igényléséhez használatos.

A hitelesítés letiltásához állítsa be a auth_enabled=False paramétert az üzembe helyezési konfiguráció létrehozásakor. Az alábbi példa letiltja az SDK-val való hitelesítést:

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

További információ az ügyfélalkalmazásból való hitelesítésről: Consume an Azure Machine Learning model deployed as a web service..

Hitelesítés kulcsokkal

Ha a kulcshitelesítés engedélyezve van, a módszerrel lekérhet egy elsődleges get_keys és egy másodlagos hitelesítési kulcsot:

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

Fontos

Ha újra létre kell hoznia egy kulcsot, használja a service.regen_key

Hitelesítés jogkivonatokkal

A jogkivonat-hitelesítés engedélyezéséhez állítsa be a paramétert az üzemelő példány token_auth_enabled=True létrehozásakor vagy frissítésekkor. Az alábbi példa engedélyezi a jogkivonatok SDK-val való hitelesítését:

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

Ha a jogkivonat-hitelesítés engedélyezve van, a metódussal lekérhet egy JWT-jogkivonatot és a jogkivonat get_token lejárati idejét:

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

Fontos

A jogkivonat lekérése után új jogkivonatot kell refresh_by kérnie.

A Microsoft határozottan javasolja, hogy a Azure Machine Learning munkaterületet ugyanabban a régióban hozza létre, mint a Azure Kubernetes Service fürtöt. A jogkivonattal való hitelesítéshez a webszolgáltatás hívást fog végezni arra a régióra, amelyben a Azure Machine Learning létrejön. Ha a munkaterület régiója nem érhető el, akkor nem fog tudni jogkivonatot lekérni a webszolgáltatáshoz még akkor sem, ha a fürt a munkaterülettől eltérő régióban van. Ez gyakorlatilag azt váltja ki, hogy a jogkivonat-alapú hitelesítés nem lesz elérhető, amíg a munkaterület régiója újra elérhetővé nem válik. Emellett minél nagyobb a távolság a fürt régiója és a munkaterület régiója között, annál hosszabb ideig tart lekérni a jogkivonatot.

Jogkivonat lekérése érdekében az Azure Machine Learning SDK-t vagy az az ml service get-access-token parancsot kell használnia.

Biztonsági rések vizsgálata

Az Azure Security Center egységes biztonsági felügyeletet és fejlett fenyegetésvédelmet biztosít a hibrid felhőalapú számítási feladatokhoz. Engedélyeznie kell, Azure Security Center hogy a felhasználók beolvassa az erőforrásokat, és követni tudja a rá vonatkozó javaslatokat. További információ: Az Azure Kubernetes Services integrációja a Security Center.

Következő lépések