Bereitstellen eines Modells in einem Azure Kubernetes Service-Cluster mit v1

Erfahren Sie, wie Sie ein Modell mit Azure Machine Learning als Webdienst in Azure Kubernetes Service (AKS) bereitstellen. AKS eignet sich gut für umfangreiche Produktionsbereitstellungen. Verwenden Sie AKS, wenn Sie eine oder mehrere der folgenden Funktionen benötigen:

• Schnelle Antwortzeiten
• Autoskalierung des bereitgestellten Diensts
• Logging
• Modelldatensammlung
• Authentifizierung
• TLS-Terminierung
• Optionen für die Hardwarebeschleunigung, beispielsweise GPU und FPGA (Field-Programmable Gate Arrays)

Bei der Bereitstellung in AKS stellen Sie ein AKS-Cluster bereit, das mit Ihrem Arbeitsbereich verbunden ist. Informationen zum Verbinden eines AKS-Clusters mit Ihrem Arbeitsbereich finden Sie unter Erstellen und Anfügen eines Azure Kubernetes Service-Clusters.

Voraussetzungen

• Ein Azure Machine Learning-Arbeitsbereich. Weitere Informationen finden Sie unter Erstellen eines Azure Machine Learning-Arbeitsbereichs.

• Ein Machine Learning-Modell, das in Ihrem Arbeitsbereich registriert ist. Wenn Sie kein registriertes Modell besitzen, lesen Sie Bereitstellen von Machine Learning-Modellen in Azure.

• Die Azure CLI-Erweiterung (v1) für Machine Learning Service, das Azure Machine Learning Python SDK oder die Visual Studio Code-Erweiterung für Azure Machine Learning.

  Wichtig

  Einige Azure CLI-Befehle in diesem Artikel verwenden die Erweiterung azure-cli-ml oder v1 für Azure Machine Learning. Der Support für die v1-Erweiterung endet am 30. September 2025. Sie können die v1-Erweiterung bis zu diesem Datum installieren und verwenden.

  Es wird empfohlen, vor dem 30. September 2025 zur ml- oder v2-Erweiterung zu wechseln. Weitere Informationen zur v2-Erweiterung finden Sie unter Was sind die Azure Machine Learning CLI und das Python SDK v2?.

• Bei den in diesem Artikel verwendeten Python-Codeausschnitten wird davon ausgegangen, dass die folgenden Variablen festgelegt sind:

  • ws: Legen Sie diese Variable auf Ihren Arbeitsbereich fest.
  • model: Legen Sie diese Variable auf Ihr registriertes Modell fest.
  • inference_config: Legen Sie diese Variable auf die Rückschlusskonfiguration für das Modell fest.

  Weitere Informationen zum Festlegen dieser Variablen finden Sie unter Wie und wo Modelle bereitgestellt werden.

• Bei den CLI-Codeausschnitten in diesem Artikel wird davon ausgegangen, dass Sie bereits ein inferenceconfig.json-Dokument erstellt haben. Weitere Informationen zum Erstellen dieses Dokuments finden Sie unter Bereitstellen von Machine Learning-Modellen in Azure.

• Ein mit Ihrem Arbeitsbereich verbundenes AKS-Cluster. Weitere Informationen finden Sie unter Erstellen und Anfügen eines Azure Kubernetes Service-Clusters.

  • Wenn Sie Modelle auf GPU-Knoten oder FPGA-Knoten (oder einem bestimmten Produkt) bereitstellen möchten, müssen Sie ein Cluster mit dem jeweiligen Produkt erstellen. Das Erstellen eines sekundären Knotenpools in einem vorhandenen Cluster und das Bereitstellen von Modellen im sekundären Knotenpool wird nicht unterstützt.

Grundlegendes zu Bereitstellungsprozessen

Das Wort Bereitstellung wird sowohl in Kubernetes als auch in Azure Machine Learning verwendet. Bereitstellung hat in diesen beiden Kontexten unterschiedliche Bedeutungen. In Kubernetes ist eine Bereitstellung eine konkrete Entität, die mit einer deklarativen YAML-Datei angegeben wird. Eine Kubernetes-Bereitstellung verfügt über einen definierten Lebenszyklus und konkrete Beziehungen zu anderen Kubernetes-Entitäten wie Pods und ReplicaSets. Informationen zu Kubernetes in Form von Dokumenten und Videos finden Sie unter Was ist Kubernetes?.

In Azure Machine Learning wird „Bereitstellung“ allgemeiner für das Verfügbarmachen und Bereinigen Ihrer Projektressourcen verwendet. Folgende Schritte werden in Azure Machine Learning als Teil der Bereitstellung betrachtet:

1. Zippen der Dateien in Ihrem Projektordner, wobei die in .amlignore oder .gitignore angegebenen Dateien ignoriert werden
2. Zentrales Hochskalieren Ihres Computeclusters (bezieht sich auf Kubernetes)
3. Erstellen oder Herunterladen des Dockerfiles auf den Serverknoten (bezieht sich auf Kubernetes)
   1. Das System berechnet einen Hashwert aus:
      • Dem Basisimage
      • Benutzerdefinierten Docker-Schritten (siehe Bereitstellen eines Modells mithilfe eines benutzerdefinierten Docker-Basisimages)
      • Der Conda-Definitions-YAML-Datei (siehe Erstellen und Verwenden von Softwareumgebungen in Azure Machine Learning)
   2. Das System verwendet diesen Hash als Schlüssel in einer Suche nach der Azure Container Registry (ACR) für den Arbeitsbereich.
   3. Wenn er nicht gefunden wird, wird nach einer Übereinstimmung in der globalen ACR gesucht
   4. Wenn keine gefunden wird, erstellt das System ein neues Image (das zwischengespeichert und an die ACR des Arbeitsbereichs übermittelt wird)
4. Herunterladen der gezippten Projektdatei in den temporären Speicher auf dem Serverknoten
5. Entzippen der Projektdatei
6. Ausführen von python <entry script> <arguments> auf dem Serverknoten
7. Speichern von Protokollen, Modelldateien und anderen Dateien, die in dem Speicherkonto, das dem Arbeitsbereich zugeordnet ist, in ./outputs geschrieben werden
8. Zentrales Herunterskalieren von Compute, einschließlich Entfernen des temporären Speichers (bezieht sich auf Kubernetes)

Azure Machine Learning-Router

Die Front-End-Komponente (azureml-fe), die eingehende Rückschlussanforderungen an bereitgestellte Dienste weiterleitet, wird automatisch nach Bedarf skaliert. Die Skalierung von azureml-fe basiert dem Zweck und der Größe (Anzahl der Knoten) des AKS-Clusters. Clusterzweck und -knoten werden konfiguriert, wenn Sie einen AKS-Cluster erstellen oder anfügen. Es gibt einen azureml-fe-Dienst pro Cluster, der auf mehreren Pods ausgeführt werden kann.

Azureml-fe wird sowohl (vertikal) hochskaliert, um mehr Kerne zu verwenden, als auch (horizontal) aufskaliert, um mehr Pods zu verwenden. Wenn Sie die Entscheidung zum zentralen Hochskalieren treffen, wird die Zeit herangezogen, die zum Weiterleiten eingehender Rückschlussanforderungen benötigt wird. Wenn diese Zeit den Schwellenwert überschreitet, erfolgt eine Hochskalierung. Wenn die Zeit zum Weiterleiten eingehender Anforderungen weiterhin den Schwellenwert überschreitet, erfolgt eine Aufskalierung.

Beim Herunter- und Abskalieren wird die CPU-Auslastung verwendet. Wenn der Schwellenwert für die CPU-Auslastung erreicht ist, wird das Front-End zuerst herunterskaliert. Wenn die CPU-Auslastung auf den Schwellenwert für die Abskalierung sinkt, erfolgt eine Abskalierung. Ein Hoch- und Aufskalieren erfolgt nur, wenn genügend Clusterressourcen verfügbar sind.

Beim Hoch- oder Herunterskalieren werden Pods vom Typ azureml-fe neu gestartet, um die Änderungen an CPU bzw. Arbeitsspeicher zu übernehmen. Neustarts wirken sich nicht auf das Ableiten von Anforderungen aus.

Grundlegendes zu Konnektivitätsanforderungen für AKS-Rückschlusscluster

Wenn Azure Machine Learning einen AKS-Cluster erstellt oder anfügt, wird das AKS-Cluster mit einem der beiden folgenden Netzwerkmodelle bereitgestellt:

• Kubenet-Netzwerke: Die Netzwerkressourcen werden normalerweise bei der Bereitstellung des AKS-Clusters erstellt und konfiguriert.
• Azure Container Networking Interface (CNI)-Netzwerke: Das AKS-Cluster wird mit einer vorhandenen virtuellen Netzwerkressource und -konfigurationen verbunden.

Für das Kubenet-Netzwerk wird das Netzwerk für den Azure Machine Learning Service erstellt und ordnungsgemäß konfiguriert. Für das CNI-Netzwerk müssen Sie die Konnektivitätsanforderungen verstehen und die DNS-Auflösung und die ausgehende Konnektivität für AKS-Rückschlüsse sicherstellen. So können Sie z. B. eine Firewall verwenden, um den Netzwerkdatenverkehr zu blockieren.

Das folgende Diagramm zeigt die Konnektivitätsanforderungen für AKS-Rückschlüsse. Die schwarzen Pfeile stehen für die tatsächliche Kommunikation und die blauen Pfeile für die Domänennamen. Möglicherweise müssen Sie Einträge für diese Hosts zu Ihrer Firewall oder zu Ihrem benutzerdefinierten DNS-Server hinzufügen.

Allgemeine Anforderungen an die AKS-Konnektivität finden Sie unter Einschränken des Netzwerkdatenverkehrs mit Azure Firewall in AKS.

Informationen zum Zugreifen auf Azure Machine Learning-Dienste hinter einer Firewall finden Sie unter Konfigurieren von ein- und ausgehendem Netzwerkdatenverkehr.

Allgemeine Anforderungen an die DNS-Auflösung

Die DNS-Auflösung in einem vorhandenen virtuellen Netzwerk befindet sich unter Ihrer Kontrolle. Beispiel: Firewall oder benutzerdefinierter DNS-Server. Die folgenden Hosts müssen erreichbar sein:

Konnektivitätsanforderungen in chronologischer Reihenfolge

Beim Erstellen oder Anfügen von AKS wird der Azure Machine Learning-Router (azureml-fe) im AKS-Cluster bereitgestellt. Für die Bereitstellung des Azure Machine Learning-Routers sollte der AKS-Knoten Folgendes ermöglichen:

• Auflösen von DNS für den AKS-API-Server
• Auflösen von DNS für MCR, um Docker-Images für Azure Machine Learning-Router herunterzuladen
• Herunterladen von Images aus MCR, wo die ausgehende Konnektivität erforderlich ist

Direkt nach der Bereitstellung von azureml-fe versucht es zu starten, und dies erfordert Folgendes:

• Auflösen von DNS für den AKS-API-Server
• Fragen Sie den AKS-API-Server ab, um andere Instanzen von sich selbst zu ermitteln (es handelt sich um einen Multi-Pod-Dienst).
• Herstellen einer Verbindung mit anderen Instanzen von sich selbst

Nachdem azureml-fe gestartet wurde, benötigt es die folgende Konnektivität, um ordnungsgemäß zu funktionieren:

• Herstellen einer Verbindung mit Azure Storage zum Herunterladen einer dynamischen Konfiguration
• Lösen Sie das DNS für den Microsoft Entra-Authentifizierungsserver api.azureml.ms auf und kommunizieren Sie mit ihm, wenn der bereitgestellte Dienst die Microsoft Entra-Authentifizierung verwendet.
• Abfragen des AKS-API-Servers, um bereitgestellte Modelle zu entdecken
• Kommunizieren mit bereitgestellten Modell-PODs

Zum Zeitpunkt der Modellimplementierung sollte der AKS-Knoten zu Folgendem in der Lage sein:

• Auflösen von DNS für die ACR des Kunden
• Herunterladen von Images aus der ACR des Kunden
• Auflösen von DNS für Azure-BLOBs, in denen das Modell gespeichert wird
• Herunterladen von Modellen aus Azure-BLOBs

Nach der Bereitstellung des Modells und dem Start des Diensts wird azureml-fe automatisch mithilfe der AKS-API erkannt und ist bereit, Anforderungen an das Modell weiterzuleiten. Es muss in der Lage sein, mit den Modell-PODs zu kommunizieren.

Bereitstellen für AKS

Um ein Modell für AKS bereitzustellen, erstellen Sie eine Bereitstellungskonfiguration, welche die erforderlichen Computeressourcen beschreibt. Dies sind beispielsweise die Anzahl von Kernen und die Arbeitsspeichergröße. Außerdem benötigen Sie eine Rückschlusskonfiguration, in der die zum Hosten des Modells und des Webdiensts erforderliche Umgebung beschrieben wird. Weitere Informationen zum Erstellen der Rückschlusskonfiguration finden Sie unter Wie und wo Modelle bereitgestellt werden.

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

az ml model deploy --ct myaks -m mymodel:1 -n myservice --ic inferenceconfig.json --dc deploymentconfig.json

{
    "computeType": "aks",
    "autoScaler":
    {
        "autoscaleEnabled": true,
        "minReplicas": 1,
        "maxReplicas": 3,
        "refreshPeriodInSeconds": 1,
        "targetUtilization": 70
    },
    "dataCollection":
    {
        "storageEnabled": true
    },
    "authEnabled": true,
    "containerResourceRequirements":
    {
        "cpu": 0.5,
        "memoryInGB": 1.0
    }
}

Automatische Skalierung

GILT FÜR: Python SDK azureml v1

Die Komponente, die die automatische Skalierung für Implementierungen von Azure Machine Learning-Modellen behandelt, ist azureml-fe, ein intelligenter Anforderungsrouter. Da er von allen Rückschlussanforderungen durchlaufen wird, verfügt er über die zum automatischen Skalieren der bereitgestellten Modelle erforderlichen Daten.

Die automatische Skalierung kann durch Festlegen von autoscale_target_utilization, autoscale_min_replicas und autoscale_max_replicas für den AKS-Webdienst gesteuert werden. Die Aktivierung der automatischen Skalierung wird im folgenden Beispiel veranschaulicht:

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

Entscheidungen zum Hoch- oder Herunterskalieren werden auf der Grundlage der Auslastung der aktuellen Containerreplikate getroffen. Zur Ermittlung der aktuellen Auslastung wird die Anzahl ausgelasteter Replikate (Replikate, die eine Anforderung verarbeiten) durch die Gesamtanzahl aktueller Replikate geteilt. Übersteigt dieser Wert autoscale_target_utilization, werden weitere Replikate erstellt. Wenn es niedriger ist, werden Replikate reduziert. Die Zielauslastung ist standardmäßig auf 70 Prozent festgelegt.

Entscheidungen zum Hinzufügen von Replikaten sind eifrig und schnell (ungefähr 1 Sekunde). Die Entscheidung, Replikate zu entfernen, erfolgt zurückhaltend (etwa 1 Minute).

Die erforderlichen Replikate können mithilfe des folgenden Codes berechnet werden:

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)

Weitere Informationen zum Festlegen von autoscale_target_utilization, autoscale_max_replicas und autoscale_min_replicas finden Sie in der Modulreferenz zu AksWebservice.

Webdienstauthentifizierung

Bei der Bereitstellung in Azure Kubernetes Service ist die schlüsselbasierte Authentifizierung standardmäßig aktiviert. Sie können auch die tokenbasierte Authentifizierung aktivieren. Die tokenbasierte Authentifizierung erfordert, dass Clients ein Microsoft Entra-Konto verwenden, um ein Authentifizierungstoken anzufordern, mit dem Anforderungen an den bereitgestellten Dienst gesendet werden.

Um die Authentifizierung zu deaktivieren, legen Sie den Parameter auth_enabled=False beim Erstellen der Bereitstellungskonfiguration fest. Im folgenden Beispiel wird die Authentifizierung mithilfe des SDKs deaktiviert:

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

Informationen zum Authentifizieren aus einer Clientanwendung finden Sie unter Nutzen eines als Webdienst bereitgestellten Azure Machine Learning-Modells.

Authentifizierung mit Schlüsseln

Bei aktivierter Schlüsselauthentifizierung können Sie mithilfe der Methode get_keys einen primären und einen sekundären Authentifizierungsschlüssel abrufen:

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

Authentifizierung mit Tokens

Um die Tokenauthentifizierung zu aktivieren, legen Sie den token_auth_enabled=True Parameter fest, wenn Sie eine Bereitstellung erstellen oder aktualisieren. Im folgenden Beispiel wird die Authentifizierung mithilfe des SDKs aktiviert:

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

Bei aktivierter Tokenauthentifizierung können Sie mithilfe der Methode get_token ein JWT-Token und dessen Ablaufzeit abrufen:

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

Überprüfung auf Sicherheitsrisiken

Microsoft Defender for Cloud bietet eine einheitliche Sicherheitsverwaltung und erweiterten Bedrohungsschutz für Hybrid Cloud-Workloads. Sie sollten Microsoft Defender für Cloud erlauben, Ihre Ressourcen zu überprüfen, und die Empfehlungen befolgen. Weitere Informationen finden Sie unter Containersicherheit in Microsoft Defender für Container.

Zugehöriger Inhalt

• Verwenden der rollenbasierten Zugriffssteuerung in Azure für die Kubernetes-Autorisierung
• Schützen einer Azure Machine Learning-Rückschlussumgebung mit virtuellen Netzwerken
• Verwenden eines benutzerdefinierten Containers zum Bereitstellen eines Modells in einem Onlineendpunkt
• Behandeln von Problemen bei der Remotemodellimplementierung
• Aktualisieren eines bereitgestellten Webdiensts
• Verwenden von TLS zum Absichern eines Webdiensts mit Azure Machine Learning
• Nutzen eines als Webdienst bereitgestellten Azure Machine Learning-Modells
• Überwachen und Erfassen von Daten von ML-Webdienst-Endpunkten
• Sammeln von Daten von Modellen in der Produktion