Skapa och koppla ett Azure Kubernetes Service kluster

GÄLLER FÖR:Python SDK azureml v1

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

Azure Machine Learning kan distribuera tränade maskininlärningsmodeller till Azure Kubernetes Service. Du måste dock först antingen skapa ett Azure Kubernetes Service-kluster (AKS) från din Azure ML-arbetsyta eller koppla ett befintligt AKS-kluster. Den här artikeln innehåller information om att både skapa och koppla ett kluster.

Förutsättningar

Begränsningar

  • Om du behöver 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 AML-arbetsytan.

  • Om du har en Azure Policy som begränsar skapandet av offentliga IP-adresser misslyckas AKS-klustrets skapande. 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:

    • Klustret kan använda den offentliga IP-adress som skapats som standard med BLB eller SLB, eller
    • Klustret kan skapas utan en offentlig IP-adress och sedan konfigureras en offentlig IP-adress med en brandvägg med en användardefinierad väg. Mer information finns i Anpassa klusterutgång med en användardefinierad väg.

    Det AML kontrollplanet pratar inte med den 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 för Azure (Azure RBAC) i Azure-resursgruppen som innehåller klustret. Tjänstens huvudnamn/användare måste också tilldelas Azure Kubernetes Service kluster Admin roll i klustret.

  • Om du kopplar ett AKS-kluster, som har ett auktoriserat IP-intervall aktiverat för åtkomst till API-servern, aktiverar du AML kontrollplanets IP-intervall för AKS-klustret. Det AML kontrollplanet distribueras över parkopplade regioner och distribuerar slutsatsdragningspoddar i AKS-klustret. Utan åtkomst till API-servern kan inte slutsatsdragningspoddarna distribueras. Använd IP-intervallen för båda de 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 kvalificerat 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 ML-arbetsyta. Den kan innehålla bokstäver, siffror och bindestreck. Den måste börja med en bokstav, sluta med en bokstav eller siffra och vara mellan 3 och 24 tecken lång.

  • 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 klustret ska skapas för utvecklingstest 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 till utvecklingstest. 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. För ett dev-test-kluster måste det innehålla minst 1 nod.

  • Azure Machine Learning SDK har inte stöd för skalning av ett AKS-kluster. Om du vill skala noderna i klustret använder du användargränssnittet för AKS-klustret i Azure Machine Learning-studio. Du kan bara ändra antalet noder, inte storleken på den virtuella datorn i 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 Azure Machine Learning-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 igen för att uppdatera en redan befintlig resurs får du samma fel.

Azure Kubernetes Service-version

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 Machine Learning-studio eller avsnittet Azure Machine Learning i Azure Portal.
  • Machine Learning för Azure CLI.
  • Azure Machine Learning 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 vi 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-drivrutin 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.

Anteckning

Det kan finnas gränsfall där du har ett äldre kluster som inte längre stöds. I det här fallet returnerar attach-å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 serviceavtal och rekommenderas inte för produktionsarbetsbelastningar. Vissa funktioner kanske inte stöds eller kan vara begränsade. Stödet 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 AzureCLI-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 för 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 Machine Learning 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 för det här kommandot liknar följande text:

Result
--------
1.16.13

Om du vill kontrollera de tillgängliga versionerna 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 Machine Learning 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 koppla 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.

Tips

Det befintliga AKS-klustret kan finnas i en annan Azure-region än din Azure Machine Learning arbetsyta.

Varning

Skapa inte flera samtidiga bifogade filer till samma AKS-kluster från din arbetsyta. Du kan till exempel koppla ett AKS-kluster till en arbetsyta med två olika namn. Varje ny bifogad fil bryter de tidigare befintliga bifogade filerna.

Om du vill koppla om ett AKS-kluster, till exempel för att ändra TLS eller annan konfigurationsinställning för klustret, 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. Mer information finns i 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")


Anteckning

Mer information om hur du skyddar modelldistribution i AKS-kluster finns i Använda TLS för att skydda en webbtjänst via Azure Machine Learning

Skapa eller koppla ett AKS-kluster för att använda interna Load Balancer med privat IP

När du skapar eller kopplar ett AKS-kluster kan du konfigurera klustret så att det använder en intern Load Balancer. Med en intern Load Balancer 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 Load Balancer 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 Load Balancer 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

# Change to the name of the subnet that contains AKS
subnet_name = "default"
# 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', load_balancer_subnet = subnet_name)

# 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 Load Balancer stöds inte användning av ett Certifikat från Microsoft och du måste använda anpassat certifikat för att aktivera TLS.

Anteckning

Mer information om hur du skyddar slutsatsdragningsmiljön finns i Skydda en Azure Machine Learning 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

Aks-klustret tas inte bort med hjälp av Azure Machine Learning-studio, SDK eller Azure CLI-tillägget för maskininlärning för att koppla från ett AKS-kluster. 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 Machine Learning komponenter som är installerade i ett Azure Kubernetes Service kluster måste tillämpas manuellt.

Du kan tillämpa de här uppdateringarna genom att koppla bort klustret från Azure Machine Learning-arbetsytan och koppla klustret till arbetsytan igen.

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 ansluta klustret till din arbetsyta igen måste du först ta bort relaterade azureml-fe 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 genereras av Azure Machine Learning, 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

Anteckning

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

Webbtjänstfel

Många webbtjänstfel i AKS kan felsökas 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ägg v1

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

Om det inte finns någon aktiv tjänst i klustret när du har kopplat från klustret 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 Load Balancer (privat IP).

Nästa steg