Dela via

Skapa och koppla ett Azure Kubernetes Service-kluster med v1

  • Artikel

GÄLLER FÖR: Python SDK azureml v1

GÄLLER FÖR: Azure CLI ml-tillägget v1

Viktigt!

Den här artikeln visar hur du använder CLI och SDK v1 för att skapa eller koppla ett Azure Kubernetes Service-kluster, som betraktas som en äldre funktion nu. Information om hur du kopplar Azure Kubernetes Service-kluster med den rekommenderade metoden för v2 finns i Introduktion till Kubernetes-beräkningsmål i v2.

Azure Mašinsko učenje kan distribuera tränade maskininlärningsmodeller till Azure Kubernetes Service. Du måste dock först antingen skapa ett AkS-kluster (Azure Kubernetes Service) från din Azure Mašinsko učenje-arbetsyta eller koppla ett befintligt AKS-kluster. Den här artikeln innehåller information om hur du både skapar och kopplar ett kluster.

Förutsättningar

Begränsningar

  • En AKS kan bara skapas eller kopplas som ett enda beräkningsmål i Azure Machine Learning-arbetsytan. Flera kopplingar för en AKS stöds inte.

  • Om du behöver ha en Standard Load Balancer(SLB) distribuerad i klustret i stället för en Basic Load Balancer(BLB) , skapar du ett kluster i AKS-portalen/CLI/SDK och kopplar det sedan till Azure Machine Learning-arbetsytan.

  • Om du har en Azure-princip som begränsar skapandet av offentliga IP-adresser misslyckas skapandet av AKS-klustret. AKS kräver en offentlig IP-adress för utgående trafik. Artikeln om utgående trafik innehåller också vägledning för att låsa utgående trafik från klustret via den offentliga IP-adressen, förutom några fullständigt kvalificerade domännamn. Det finns två sätt att aktivera en offentlig IP-adress:

    Azure Machine Learning-kontrollplanet kommunicerar inte med den här offentliga IP-adressen. Den pratar med AKS-kontrollplanet för distributioner.

  • Om du vill koppla ett AKS-kluster måste tjänstens huvudnamn/användare som utför åtgärden tilldelas rollen Ägare eller deltagare i rollbaserad åtkomstkontroll i Azure (Azure RBAC) för den Azure-resursgrupp som innehåller klustret. Tjänstens huvudnamn/användare måste också tilldelas administratörsrollen för Azure Kubernetes-tjänstkluster i klustret.

  • Om du kopplar ett AKS-kluster, som har ett auktoriserat IP-intervall aktiverat för åtkomst till API-servern, aktiverar du IP-intervall för Azure Machine Learning-kontrollplanet för AKS-klustret. Azure Machine Learning-kontrollplanet distribueras över länkade regioner och distribuerar slutsatsdragningspoddar i AKS-klustret. Utan åtkomst till API-servern kan slutsatsdragningspoddarna inte distribueras. Använd IP-intervallen för båda kopplade regionerna när du aktiverar IP-intervallen i ett AKS-kluster.

    Auktoriserade IP-intervall fungerar bara med Standard Load Balancer.

  • Om du vill använda ett privat AKS-kluster (med Azure Private Link) måste du först skapa klustret och sedan koppla det till arbetsytan. Mer information finns i Skapa ett privat Azure Kubernetes Service-kluster.

  • Användning av ett offentligt fullständigt domännamn (FQDN) med ett privat AKS-klusterstöds inte med Azure Machine Learning.

  • Beräkningsnamnet för AKS-klustret MÅSTE vara unikt i din Azure Machine Learning-arbetsyta. Det kan innehålla bokstäver, siffror och streck. Det måste börja med en bokstav, sluta med en bokstav eller siffra och vara mellan 3 och 24 tecken långt.

  • Om du vill distribuera modeller till GPU-noder eller FPGA-noder (eller någon specifik SKU) måste du skapa ett kluster med den specifika SKU:n. Det finns inget stöd för att skapa en sekundär nodpool i ett befintligt kluster och distribuera modeller i den sekundära nodpoolen.

  • När du skapar eller kopplar ett kluster kan du välja om du vill skapa klustret för dev-test eller produktion. Om du vill skapa ett AKS-kluster för utveckling, validering och testning i stället för produktion anger du klustrets syfte som dev-test. Om du inte anger klustrets syfte skapas ett produktionskluster.

    Viktigt!

    Ett dev-test-kluster är inte lämpligt för trafik på produktionsnivå och kan öka slutsatsdragningstiderna. Dev/test-kluster garanterar inte heller feltolerans.

  • Om klustret ska användas för produktion när du skapar eller kopplar ett kluster måste det innehålla minst 3 noder. Ett dev-test-kluster måste innehålla minst en nod.

  • Azure Machine Learning-SDK har inte stöd för skalning av AKS-kluster. Om du vill skala noderna i klustret använder du användargränssnittet för ditt AKS-kluster i Azure Machine Learning-studio. Du kan bara ändra antalet noder, inte VM-storleken för klustret. Mer information om hur du skalar noderna i ett AKS-kluster finns i följande artiklar:

  • Uppdatera inte klustret direkt med hjälp av en YAML-konfiguration. Azure Kubernetes Services stöder uppdateringar via YAML-konfiguration, men Azure Machine Learning-distributioner åsidosätter dina ändringar. De enda två YAML-fälten som inte skrivs över är begärandebegränsningar och CPU och minne.

  • Att skapa ett AKS-kluster med hjälp av Azure Mašinsko učenje Studio UI, SDK eller CLI-tillägget är inte idempotent. Om du försöker skapa resursen igen uppstår ett fel om att det redan finns ett kluster med samma namn.

    • Att använda en Azure Resource Manager-mall och resursen Microsoft.MachineLearningServices/workspaces/computes för att skapa ett AKS-kluster är inte heller idempotent. Om du försöker använda mallen för att uppdatera en redan befintlig resurs igen får du samma fel.

Azure Kubernetes Service-version

Med Azure Kubernetes Service kan du skapa ett kluster med en mängd olika Kubernetes-versioner. Mer information om tillgängliga versioner finns i Kubernetes-versioner som stöds i Azure Kubernetes Service.

När du skapar ett Azure Kubernetes Service-kluster med någon av följande metoder har du inget val i den version av klustret som skapas:

  • Azure Mašinsko učenje studio eller avsnittet Azure Mašinsko učenje i Azure-portalen.
  • Mašinsko učenje-tillägget för Azure CLI.
  • Azure Mašinsko učenje SDK.

De här metoderna för att skapa ett AKS-kluster använder standardversionen av klustret. Standardversionen ändras med tiden när nya Kubernetes-versioner blir tillgängliga.

När du kopplar ett befintligt AKS-kluster stöder vi alla AKS-versioner som stöds för närvarande.

Viktigt!

Azure Kubernetes Service använder Blobfuse FlexVolume-drivrutinen för versionerna <=1.16 och Blob CSI-drivrutinen för versionerna >=1.17. Därför är det viktigt att distribuera om eller uppdatera webbtjänsten efter klusteruppgradering för att distribuera till rätt blobfuse-metod för klusterversionen.

Kommentar

Det kan finnas gränsfall där du har ett äldre kluster som inte längre stöds. I det här fallet returnerar bifoga-åtgärden ett fel och listar de versioner som stöds för närvarande.

Du kan bifoga förhandsversioner . Förhandsversionsfunktioner tillhandahålls utan ett serviceavtal och rekommenderas inte för produktionsarbetsbelastningar. Vissa funktioner kanske inte stöds eller kan vara begränsade. Stöd för att använda förhandsversioner kan vara begränsat. Mer information finns i Kompletterande villkor för användning av Microsoft Azure-förhandsversioner.

Tillgängliga versioner och standardversioner

Om du vill hitta de tillgängliga och standardversionerna av AKS använder du Azure CLI-kommandot az aks get-versions. Följande kommando returnerar till exempel de versioner som är tillgängliga i regionen USA, västra:

az aks get-versions -l westus -o table

Utdata från det här kommandot liknar följande text:

KubernetesVersion    Upgrades
-------------------  ----------------------------------------
1.18.6(preview)      None available
1.18.4(preview)      1.18.6(preview)
1.17.9               1.18.4(preview), 1.18.6(preview)
1.17.7               1.17.9, 1.18.4(preview), 1.18.6(preview)
1.16.13              1.17.7, 1.17.9
1.16.10              1.16.13, 1.17.7, 1.17.9
1.15.12              1.16.10, 1.16.13
1.15.11              1.15.12, 1.16.10, 1.16.13

Om du vill hitta standardversionen som används när du skapar ett kluster via Azure Mašinsko učenje kan du använda parametern --query för att välja standardversionen:

az aks get-versions -l westus --query "orchestrators[?default == `true`].orchestratorVersion" -o table

Utdata från det här kommandot liknar följande text:

Result
--------
1.16.13

Om du vill kontrollera tillgängliga versioner programmatiskt använder du REST-API:et Container Service Client – List Orchestrators. Om du vill hitta de tillgängliga versionerna tittar du på posterna där orchestratorType är Kubernetes. De associerade orchestrationVersion posterna innehåller de tillgängliga versioner som kan kopplas till din arbetsyta.

Om du vill hitta standardversionen som används när du skapar ett kluster via Azure Mašinsko učenje letar du upp posten där orchestratorType är Kubernetes och default är true. Det associerade orchestratorVersion värdet är standardversionen. Följande JSON-kodfragment visar en exempelpost:

...
 {
        "orchestratorType": "Kubernetes",
        "orchestratorVersion": "1.16.13",
        "default": true,
        "upgrades": [
          {
            "orchestratorType": "",
            "orchestratorVersion": "1.17.7",
            "isPreview": false
          }
        ]
      },
...

Skapa ett nytt AKS-kluster

Tidsuppskattning: Cirka 10 minuter.

Att skapa eller ansluta ett AKS-kluster är en engångsprocess för din arbetsyta. Du kan återanvända det här klustret för flera distributioner. Om du tar bort klustret eller resursgruppen som innehåller det måste du skapa ett nytt kluster nästa gång du behöver distribuera. Du kan ha flera AKS-kluster kopplade till din arbetsyta.

I följande exempel visas hur du skapar ett nytt AKS-kluster med hjälp av SDK och CLI:

GÄLLER FÖR: Python SDK azureml v1

from azureml.core.compute import AksCompute, ComputeTarget

# Use the default configuration (you can also provide parameters to customize this).
# For example, to create a dev/test cluster, use:
# prov_config = AksCompute.provisioning_configuration(cluster_purpose = AksCompute.ClusterPurpose.DEV_TEST)
prov_config = AksCompute.provisioning_configuration()

# Example configuration to use an existing virtual network
# prov_config.vnet_name = "mynetwork"
# prov_config.vnet_resourcegroup_name = "mygroup"
# prov_config.subnet_name = "default"
# prov_config.service_cidr = "10.0.0.0/16"
# prov_config.dns_service_ip = "10.0.0.10"
# prov_config.docker_bridge_cidr = "172.17.0.1/16"

aks_name = 'myaks'
# Create the cluster
aks_target = ComputeTarget.create(workspace = ws,
                                    name = aks_name,
                                    provisioning_configuration = prov_config)

# Wait for the create process to complete
aks_target.wait_for_completion(show_output = True)

Mer information om de klasser, metoder och parametrar som används i det här exemplet finns i följande referensdokument:

Koppla ett befintligt AKS-kluster

Tidsuppskattning: Cirka 5 minuter.

Om du redan har AKS-kluster i din Azure-prenumeration kan du använda det med din arbetsyta.

Dricks

Det befintliga AKS-klustret kan finnas i en annan Azure-region än din Azure Mašinsko učenje-arbetsyta.

Varning

Skapa inte flera samtidiga bifogade filer till samma AKS-kluster. Du kan till exempel koppla ett AKS-kluster till en arbetsyta med två olika namn eller koppla ett AKS-kluster till en annan arbetsyta. Varje ny bifogad fil bryter de tidigare befintliga bifogade filerna och orsakar oförutsägbara fel.

Om du vill koppla om ett AKS-kluster, till exempel för att ändra TLS eller annan konfigurationsinställning för kluster, måste du först ta bort den befintliga bifogade filen med hjälp av AksCompute.detach().

Mer information om hur du skapar ett AKS-kluster med hjälp av Azure CLI eller portalen finns i följande artiklar:

I följande exempel visas hur du kopplar ett befintligt AKS-kluster till din arbetsyta:

GÄLLER FÖR: Python SDK azureml v1

from azureml.core.compute import AksCompute, ComputeTarget
# Set the resource group that contains the AKS cluster and the cluster name
resource_group = 'myresourcegroup'
cluster_name = 'myexistingcluster'

# Attach the cluster to your workgroup. If the cluster has less than 12 virtual CPUs, use the following instead:
# attach_config = AksCompute.attach_configuration(resource_group = resource_group,
#                                         cluster_name = cluster_name,
#                                         cluster_purpose = AksCompute.ClusterPurpose.DEV_TEST)
attach_config = AksCompute.attach_configuration(resource_group = resource_group,
                                         cluster_name = cluster_name)
aks_target = ComputeTarget.attach(ws, 'myaks', attach_config)

# Wait for the attach process to complete
aks_target.wait_for_completion(show_output = True)

Mer information om de klasser, metoder och parametrar som används i det här exemplet finns i följande referensdokument:

Skapa eller koppla ett AKS-kluster med TLS-avslutning

När du skapar eller kopplar ett AKS-kluster kan du aktivera TLS-avslutning med konfigurationsobjekten AksCompute.provisioning_configuration() och AksCompute.attach_configuration(). Båda metoderna returnerar ett konfigurationsobjekt som har en enable_ssl-metod , och du kan använda enable_ssl metod för att aktivera TLS.

I följande exempel visas hur du aktiverar TLS-avslutning med automatisk generering och konfiguration av TLS-certifikat med hjälp av Microsoft-certifikat under huven.

GÄLLER FÖR: Python SDK azureml v1

   from azureml.core.compute import AksCompute, ComputeTarget
   
   # Enable TLS termination when you create an AKS cluster by using provisioning_config object enable_ssl method

   # Leaf domain label generates a name using the formula
   # "<leaf-domain-label>######.<azure-region>.cloudapp.azure.com"
   # where "######" is a random series of characters
   provisioning_config.enable_ssl(leaf_domain_label = "contoso")
   
   # Enable TLS termination when you attach an AKS cluster by using attach_config object enable_ssl method

   # Leaf domain label generates a name using the formula
   # "<leaf-domain-label>######.<azure-region>.cloudapp.azure.com"
   # where "######" is a random series of characters
   attach_config.enable_ssl(leaf_domain_label = "contoso")

I följande exempel visas hur du aktiverar TLS-avslutning med anpassat certifikat och anpassat domännamn. Med anpassad domän och certifikat måste du uppdatera DNS-posten så att den pekar på IP-adressen för bedömningsslutpunkten. Se Uppdatera din DNS

GÄLLER FÖR: Python SDK azureml v1

   from azureml.core.compute import AksCompute, ComputeTarget

   # Enable TLS termination with custom certificate and custom domain when creating an AKS cluster
   
   provisioning_config.enable_ssl(ssl_cert_pem_file="cert.pem",
                                        ssl_key_pem_file="key.pem", ssl_cname="www.contoso.com")
    
   # Enable TLS termination with custom certificate and custom domain when attaching an AKS cluster

   attach_config.enable_ssl(ssl_cert_pem_file="cert.pem",
                                        ssl_key_pem_file="key.pem", ssl_cname="www.contoso.com")

Kommentar

Mer information om hur du skyddar modelldistribution i AKS-kluster finns i Använda TLS för att skydda en webbtjänst via Azure Mašinsko učenje

Skapa eller koppla ett AKS-kluster för att använda intern lastbalanserare med privat IP

När du skapar eller kopplar ett AKS-kluster kan du konfigurera klustret så att det använder en intern lastbalanserare. Med en intern lastbalanserare använder bedömningsslutpunkter för dina distributioner till AKS en privat IP-adress i det virtuella nätverket. Följande kodfragment visar hur du konfigurerar en intern lastbalanserare för ett AKS-kluster.

GÄLLER FÖR: Python SDK azureml v1

Om du vill skapa ett AKS-kluster som använder en intern lastbalanserare använder du parametrarna load_balancer_type och load_balancer_subnet :

from azureml.core.compute.aks import AksUpdateConfiguration
from azureml.core.compute import AksCompute, ComputeTarget

# When you create an AKS cluster, you can specify Internal Load Balancer to be created with provisioning_config object
provisioning_config = AksCompute.provisioning_configuration(load_balancer_type = 'InternalLoadBalancer')

# Create the cluster
aks_target = ComputeTarget.create(workspace = ws,
                                name = aks_name,
                                provisioning_configuration = provisioning_config)

# Wait for the create process to complete
aks_target.wait_for_completion(show_output = True)

Viktigt!

Om DITT AKS-kluster har konfigurerats med en intern lastbalanserare stöds inte användning av ett Microsoft-certifikat och du måste använda anpassat certifikat för att aktivera TLS.

Kommentar

Mer information om hur du skyddar slutsatsdragningsmiljön finns i Skydda en Azure Mašinsko učenje-slutsatsdragningsmiljö

Koppla från ett AKS-kluster

Om du vill koppla från ett kluster från arbetsytan använder du någon av följande metoder:

Varning

Om du använder Azure Mašinsko učenje studio, SDK eller Azure CLI-tillägget för maskininlärning för att koppla från ett AKS-kluster tas inte AKS-klustret bort. Information om hur du tar bort klustret finns i Använda Azure CLI med AKS.

GÄLLER FÖR: Python SDK azureml v1

aks_target.detach()

Felsökning

Uppdatera klustret

Uppdateringar av Azure Mašinsko učenje komponenter som installerats i ett Azure Kubernetes Service-kluster måste tillämpas manuellt.

Du kan tillämpa dessa uppdateringar genom att koppla bort klustret från Azure Mašinsko učenje-arbetsytan och koppla om klustret till arbetsytan.

GÄLLER FÖR: Python SDK azureml v1

compute_target = ComputeTarget(workspace=ws, name=clusterWorkspaceName)
compute_target.detach()
compute_target.wait_for_completion(show_output=True)

Innan du kan koppla klustret till din arbetsyta igen måste du först ta bort eventuella azureml-fe relaterade resurser. Om det inte finns någon aktiv tjänst i klustret kan du ta bort dina azureml-fe relaterade resurser med följande kod.

kubectl delete sa azureml-fe
kubectl delete clusterrole azureml-fe-role
kubectl delete clusterrolebinding azureml-fe-binding
kubectl delete svc azureml-fe
kubectl delete svc azureml-fe-int-http
kubectl delete deploy azureml-fe
kubectl delete secret azuremlfessl
kubectl delete cm azuremlfeconfig

Om TLS är aktiverat i klustret måste du ange TLS/SSL-certifikatet och den privata nyckeln när du kopplar om klustret.

GÄLLER FÖR: Python SDK azureml v1

attach_config = AksCompute.attach_configuration(resource_group=resourceGroup, cluster_name=kubernetesClusterName)

# If SSL is enabled.
attach_config.enable_ssl(
    ssl_cert_pem_file="cert.pem",
    ssl_key_pem_file="key.pem",
    ssl_cname=sslCname)

attach_config.validate_configuration()

compute_target = ComputeTarget.attach(workspace=ws, name=args.clusterWorkspaceName, attach_configuration=attach_config)
compute_target.wait_for_completion(show_output=True)

Om du inte längre har TLS/SSL-certifikatet och den privata nyckeln, eller om du använder ett certifikat som genererats av Azure Mašinsko učenje, kan du hämta filerna innan du kopplar från klustret genom att ansluta till klustret med hjälp kubectl av och hämta hemligheten azuremlfessl.

kubectl get secret/azuremlfessl -o yaml

Kommentar

Kubernetes lagrar hemligheterna i Base64-kodat format. Du måste Base64-avkoda cert.pem key.pem och komponenterna i hemligheterna innan du anger dem till attach_config.enable_ssl.

Webbtjänstfel

Många webbtjänstfel i AKS kan kopplas från genom att ansluta till klustret med hjälp av kubectl. Du kan hämta kubeconfig.json för ett AKS-kluster genom att köra

GÄLLER FÖR: Azure CLI ml-tillägget v1

az aks get-credentials -g <rg> -n <aks cluster name>

Om det inte finns någon aktiv tjänst i klustret när klustret har kopplats bort tar du bort de azureml-fe relaterade resurserna innan du kopplar igen:

kubectl delete sa azureml-fe
kubectl delete clusterrole azureml-fe-role
kubectl delete clusterrolebinding azureml-fe-binding
kubectl delete svc azureml-fe
kubectl delete svc azureml-fe-int-http
kubectl delete deploy azureml-fe
kubectl delete secret azuremlfessl
kubectl delete cm azuremlfeconfig

Lastbalanserare bör inte ha offentliga IP-adresser

När du försöker skapa eller koppla ett AKS-kluster kan du få ett meddelande om att begäran har nekats eftersom "Lastbalanserare inte ska ha offentliga IP-adresser". Det här meddelandet returneras när en administratör har tillämpat en princip som förhindrar användning av ett AKS-kluster med en offentlig IP-adress.

Lös problemet genom att skapa/koppla klustret med hjälp av parametrarna load_balancer_type och load_balancer_subnet . Mer information finns i Intern lastbalanserare (privat IP).

Nästa steg