Compartilhar via

Criar e anexar um cluster do Serviço de Kubernetes do Azure com v1

  • Artigo

APLICA-SE A:SDK azureml do Python v1

APLICA-SE A:Extensão de ML da CLI do Azure v1

Importante

Este artigo mostra como usar a CLI e o SDK v1 para criar ou anexar um cluster do Serviço de Kubernetes do Azure, que agora é considerado um recurso herdado. Para anexar o cluster do Serviço de Kubernetes do Azure usando a abordagem recomendada para v2, confira Introdução ao destino de computação do Kubernetes na v2.

O Azure Machine Learning pode implementar modelos de machine learning treinados para o Serviço de Kubernetes do Azure. No entanto, primeiro, você precisa criar um cluster do AKS (Serviço de Kubernetes do Azure) por meio do workspace do Azure Machine Learning ou anexar um cluster do AKS existente. Este artigo fornece informações sobre como criar e anexar um cluster.

Pré-requisitos

Limitações

  • Um AKS só pode ser criado ou anexado como um destino de computação individual no workspace do Azure Machine Learning. Não há suporte para vários anexos em um AKS.

  • Caso você precise de um SLB (Standard Load Balancer) implantado no seu cluster em vez de um BLB (Load Balancer Básico), crie um cluster no portal do AKS/na CLI/no SDK e anexe-o ao workspace do Azure Machine Learning.

  • Se você tiver um Azure Policy restringindo a criação de endereços IP Públicos, a criação do cluster do AKS falhará. O AKS requer um IP Público para o tráfego de saída. O artigo tráfego de saída também fornece orientação para bloquear o tráfego de saída do cluster através do IP Público, com exceção de alguns nomes de domínio totalmente qualificados. Há duas maneiras de habilitar um IP Público:

    O painel de controle do Azure Machine Learning não se comunica com esse IP público. Ele se comunica com o plano de controle do AKS para implantações.

  • Para anexar um cluster AKS, a entidade de serviço/usuário que está executando a operação deve ser atribuída à função de Proprietário ou colaborador do Azure RBAC (controle de acesso baseado em função) do Azure no grupo de recursos do Azure que contém o cluster. A entidade de serviço/usuário também deve ser atribuída à função de Administrador de cluster do Serviço de Kubernetes do Azure no cluster.

  • Se você anexar um cluster do AKS que tenha um Intervalo de IP autorizado habilitado para acessar o servidor da API, habilite os intervalos de IP do painel de controle do Azure Machine Learning para o cluster do AKS. O painel de controle do Azure Machine Learning é implantado em regiões emparelhadas e implanta pods de inferência no cluster do AKS. Sem acesso ao servidor da API, o pod de inferência não pode ser implantado. Use os intervalos de IP para ambas regiões emparelhadas ao habilitar os intervalos de IP em um cluster do AKS.

    Os intervalos de IP autorizados só funcionam com Standard Load Balancer.

  • Se você quiser usar um cluster do AKS privado (usando o Link Privado do Azure), deverá primeiro criar o cluster e, em seguida, anexá-lo ao espaço de trabalho. Para obter mais informações, consulte Criar um cluster particular do Serviço de Kubernetes do Azure.

  • O uso de um FQDN (nome de domínio totalmente qualificado) público com um cluster AKS privadonão é compatível com o Azure Machine Learning.

  • O nome da computação do cluster do AKS PRECISA ser exclusivo no workspace do Azure Machine Learning. Ele pode incluir letras, dígitos e traços. Ele precisa começar com uma letra, terminar com uma letra ou um dígito, e precisa ter entre 3 e 24 caracteres.

  • Se você quiser implantar modelos em nós de GPU ou de FPGA (ou qualquer SKU específico), deverá criar um cluster com o SKU específico. Não há suporte para a criação de um pool de nós secundário em um cluster existente e para a implantação de modelos no pool de nós secundário.

  • Ao criar ou anexar um cluster, você pode selecionar se deseja criar o cluster para desenvolvimento/teste ou produção. Se você quiser criar um cluster do AKS para desenvolvimento, validaçãoe teste em vez de produção, defina a finalidade do cluster como desenvolvimento/teste. Se você não especificar a finalidade do cluster, um cluster de produção será criado.

    Importante

    Um cluster de desenvolvimento/teste não é adequado para o tráfego de nível de produção, e pode aumentar os tempos de inferência. Os clusters de desenvolvimento/teste também não garantem a tolerância a falhas.

  • Ao criar ou anexar um cluster, se o cluster for usado para produção, ele deverá conter pelo menos 3 nós. Para um cluster de desenvolvimento/teste, ele deve conter pelo menos um nó.

  • O SDK do Azure Machine Learning não fornece suporte para dimensionar um cluster do AKS. Para dimensionar os nós no cluster, use a interface do usuário do cluster do AKS no estúdio do Azure Machine Learning. Você só pode alterar a contagem de nós, não o tamanho da VM do cluster. Para saber mais sobre o dimensionamento de nós no cluster do AKS, consulte os artigos a seguir:

  • Não atualize diretamente o cluster usando uma configuração de YAML. Enquanto os Serviço de Kubernetes do Azure dão suporte a atualizações através da configuração do YAML, as implantações do Azure Machine Learning substituirão as alterações. Os únicos dois campos YAML que não serão substituídos são limites de solicitação e CPU e memória.

  • A criação de um cluster do AKS usando a interface do usuário do estúdio do Azure Machine Learning, o SDK ou a extensão da CLI não é idempotente. Tentar criar o recurso novamente resultará em um erro em que um cluster com o mesmo nome já existe.

    • Usar um modelo do Azure Resource Manager e o recurso Microsoft.MachineLearningServices/workspaces/computes para criar um cluster do AKS também não é idempotente. Se você tentar usar o modelo novamente para atualizar um recurso já existente, receberá o mesmo erro.

Versão do Serviço de Kubernetes do Azure

O Serviço de Kubernetes do Azure permite que você crie um cluster usando diversas versões do kubernetes. Para obter mais informações sobre as versões disponíveis, consulte versões do Kubernetes com suporte no Serviço de Kubernetes do Azure.

Ao criar um cluster do Serviço de Kubernetes do Azure usando um dos seguintes métodos, você não pode escolher a versão do cluster que é criada:

  • Estúdio do Azure Machine Learning ou seção do Azure Machine Learning no portal do Azure.
  • Extensão do Machine Learning para CLI do Azure.
  • SDK do Azure Machine Learning.

Esses métodos de criação de um cluster do AKS usam a versão padrão do cluster. A versão padrão muda ao longo do tempo à medida que novas versões de Kubernetes se tornam disponíveis.

Ao anexar um cluster do AKS existente, damos suporte a todas as versões do AKS com suporte no momento.

Importante

O Serviço de Kubernetes do Azure usa o Driver Blobfuse FlexVolume para as versões <= 1,16 e o Driver CSI do Blob para as versões >= 1,17. Portanto, é importante reimplantar ou atualizar o serviço Web após a atualização do cluster para implantar o método blobfuse correto para a versão do cluster.

Observação

Pode haver casos de borda onde você tem um cluster mais antigo que não é mais compatível. Nesse caso, a operação de anexação retornará um erro e listará as versões compatíveis no momento.

Você pode anexar versões prévias. A funcionalidade de versão prévia é fornecida sem um Contrato de Nível de Serviço e não é recomendada para cargas de trabalho de produção. Alguns recursos podem não ter suporte ou podem ter restrição de recursos. O suporte para o uso de versões prévias pode ser limitado. Para obter mais informações, consulte Termos de Uso Complementares de Versões Prévias do Microsoft Azure.

Versões padrão e disponível

Para localizar as versões disponíveis e padrão do AKS, use o comando az aks get-versions do CLI do Azure. Por exemplo, o comando a seguir retorna as versões disponíveis no Oeste dos EUA:

az aks get-versions -l westus -o table

A saída desse comando é semelhante ao texto a seguir:

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

Para localizar a versão padrão que é usada ao criar um cluster no Azure Machine Learning, você pode usar o parâmetro --query para selecionar a versão padrão:

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

A saída desse comando é semelhante ao texto a seguir:

Result
--------
1.16.13

Se você quiser verificar de forma programática as versões disponíveis, use a API REST do Cliente do Serviço de Contêiner - Listar Orquestradores. Para localizar as versões disponíveis, examine as entradas onde orchestratorType é Kubernetes. As entradas orchestrationVersion associadas contêm as versões disponíveis que podem ser anexadas ao seu espaço de trabalho.

Para localizar a versão padrão que é usada ao criar um cluster no Azure Machine Learning, localize a entrada onde orchestratorType é Kubernetes e default é true. O valor orchestratorVersion associado é a versão padrão. O trecho JSON a seguir é um exemplo de entrada:

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

Criar um cluster do AKS

Tempo estimado: aproximadamente 10 minutos.

A criação ou anexação de um cluster AKS é um processo único em seu espaço de trabalho. Você pode reutilizar esse cluster para várias implantações. Se você excluir o cluster ou o grupo de recursos que o contém, será necessário criar outro cluster na próxima vez que precisar implantar. Você pode ter vários clusters do AKS anexados ao seu espaço de trabalho.

O exemplo a seguir demonstra como criar um novo cluster do AKS usando o SDK e a CLI:

APLICA-SE A:SDK azureml do Python 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)

Para obter mais informações sobre as classes, os métodos e os parâmetros usados neste exemplo, confira os seguintes documentos de referência:

Anexe um cluster AKS existente

Tempo estimado: aproximadamente 5 minutos.

Se você já tiver o cluster AKS na sua assinatura do Azure, poderá usá-lo no seu espaço de trabalho.

Dica

O cluster do AKS existente pode estar em uma região do Azure que não seja seu espaço de trabalho do Azure Machine Learning.

Aviso

Não crie vários anexos simultâneos para o mesmo cluster do AKS. Por exemplo, anexar um cluster do AKS a um workspace usando dois nomes diferentes ou anexar um cluster do AKS a um workspace diferente. Cada novo anexo eliminará os anexos anteriores existentes e causará um erro imprevisível.

Se você quiser anexar novamente um cluster do AKS, por exemplo, para alterar o TLS ou outra configuração de cluster, primeiro você deve remover o anexo existente usando AksCompute.detach().

Para obter mais informações sobre como criar um cluster do AKS usando o CLI do Azure ou o portal, consulte os seguintes artigos:

O exemplo a seguir demonstra como anexar um cluster do AKS existente ao espaço de trabalho:

APLICA-SE A:SDK azureml do Python 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)

Para obter mais informações sobre as classes, os métodos e os parâmetros usados neste exemplo, confira os seguintes documentos de referência:

Criar ou anexar um cluster do AKS com terminação TLS

Ao criar ou anexar um cluster do AKS, você pode habilitar a terminação TLS com os objetos de configuração AksCompute.provisioning_configuration() e AksCompute.attach_configuration() . Os dois métodos retornam um objeto de configuração que tem um método enable_ssl, e você pode usar o método enable_ssl para habilitar o TLS.

O exemplo a seguir mostra como habilitar a terminação TLS com a geração e configuração automáticas de certificado TLS usando o certificado oculto da Microsoft.

APLICA-SE A:SDK azureml do Python 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")

O exemplo a seguir mostra como habilitar a terminação TLS com o certificado personalizado e o nome de domínio personalizado. Com o domínio e certificado personalizados, você deve atualizar seu registro DNS para apontar para o endereço IP do ponto de extremidade de pontuação, consulte Atualizar seu DNS

APLICA-SE A:SDK azureml do Python 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")

Observação

Para obter mais informações sobre como proteger a implantação de modelo no cluster do AKS, consulte use o TLS para proteger um serviço Web por meio do Azure Machine Learning

Criar ou anexar um cluster do AKS para usar o Load Balancer Interno com IP privado

Ao criar ou anexar um cluster do AKS, você pode configurar o cluster para usar um Load Balancer Interno. Com um Load Balancer Interno, a pontuação dos pontos de extremidade para suas implantações para AKS usarão um IP privado dentro da rede virtual. Os trechos de código a seguir mostram como configurar um Load Balancer Interno para um cluster do AKS.

APLICA-SE A:SDK azureml do Python v1

Para criar um cluster do AKS que usa um Load Balancer interno, use os parâmetros load_balancer_type e 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)

Importante

Se o cluster do AKS estiver configurado com um Load Balancer Interno, não haverá suporte para o uso de um certificado fornecido pela Microsoft e você deverá usar o certificado personalizado para habilitar o TLS.

Observação

Para obter mais informações sobre como proteger o ambiente de inferência, consulte Proteger um Ambiente de Inferência do Azure Machine Learning

Desanexar um cluster do AKS

Para desanexar um cluster do seu espaço de trabalho, use um dos seguintes métodos:

Aviso

Usar o estúdio do Azure Machine Learning, o SDK ou a extensão CLI do Azure para o aprendizado de máquina para desanexar um cluster do AKS não exclui o cluster do AKS. Para excluir o cluster, consulte USAR o CLI do Azure com AKS.

APLICA-SE A:SDK azureml do Python v1

aks_target.detach()

Solução de problemas

Atualize o cluster

As atualizações dos componentes do Azure Machine Learning instaladas em um cluster do Serviço de Kubernetes do Azure devem ser aplicadas manualmente.

Você pode aplicar essas atualizações desanexando o cluster do workspace do Azure Machine Learning e anexando novamente o cluster ao workspace.

APLICA-SE A:SDK azureml do Python v1

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

Para anexar novamente o cluster ao seu workspace, primeiro, você precisa excluir todos os recursos relacionados ao azureml-fe. Se não houver nenhum serviço ativo no cluster, exclua os recursos relacionados ao azureml-fe com o código a seguir.

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

Se o TLS estiver habilitado no cluster, será necessário fornecer o certificado TLS/SSL e a chave privada ao anexar novamente o cluster.

APLICA-SE A:SDK azureml do Python 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)

Se você não tiver mais o certificado TLS/SSL e a chave privada, ou se estiver usando um certificado gerado pelo Azure Machine Learning, você poderá recuperar os arquivos antes de desanexar o cluster conectando-se ao cluster usando kubectl e recuperando o segredo azuremlfessl.

kubectl get secret/azuremlfessl -o yaml

Observação

O Kubernetes armazena os segredos no formato codificado em Base64. Você precisará decodificar em Base64 os componentes cert.pem e key.pem dos segredos antes de fornecê-los a attach_config.enable_ssl.

Falhas do WebService

Muitas falhas de webservice no AKS podem ser depuradas conectando-se ao cluster com kubectl. Você pode obter o kubeconfig.json para um cluster do AKS executando

APLICA-SE A:Extensão de ML da CLI do Azure v1

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

Após a desanexação do cluster, se não houver nenhum serviço ativo no cluster, exclua os recursos relacionados ao azureml-fe antes de anexá-lo novamente:

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

Os balanceadores de carga não devem ter IPs públicos

Ao tentar criar ou anexar um cluster do AKS, você pode receber uma mensagem de que a solicitação foi negada porque "Os balanceadores de carga não devem ter IPs". Essa mensagem é retornada quando um administrador aplica uma política que impede o uso de um cluster do AKS com um IP.

Para resolver esse problema, crie/anexe o cluster usando os parâmetros load_balancer_type e load_balancer_subnet. Para obter mais informações, consulte Balanceador de carga interno (IP privado).

Próximas etapas