Referência de configuração do cluster do Kubernetes para o Azure Machine Learning

Este artigo contém informações de referência para configurar o Kubernetes com o Azure Machine Learning.

Versão e região compatíveis do Kubernetes

• Os clusters do Kubernetes que instalam a extensão do Azure Machine Learning têm uma janela de suporte de versão igual a "N-2", que está alinhada com a política de suporte de versão do AKS (Serviço de Kubernetes do Azure), em que "N" é a última versão secundária de GA do Serviço de Kubernetes do Azure.

  • Por exemplo, se o AKS introduzir a 1.20.a hoje, as versões 1.20.a, 1.20.b, 1.19.c, 1.19.d, 1.18.e e 1.18.f serão compatíveis.

  • Se os clientes estiverem executando uma versão do Kubernetes sem suporte, eles precisarão atualizá-la ao solicitar o suporte para o cluster. Os clusters que executam as versões sem suporte do Kubernetes não são cobertos pelas políticas de suporte de extensão do Azure Machine Learning.

• Disponibilidade da região da extensão do Azure Machine Learning:

  • A extensão do Azure Machine Learning pode ser implantada no AKS ou no Kubernetes habilitado para Azure Arc em regiões com suporte listadas em Suporte de regiões do Kubernetes habilitado para Azure Arc.

Planejamento de recursos recomendado

Quando você implantar a extensão do Azure Machine Learning, alguns serviços relacionados serão implantados no cluster do Kubernetes para o Azure Machine Learning. A tabela a seguir lista os Serviços Relacionados e seu uso de recursos no cluster:

Excluindo as implantações/pods do usuário, os requisitos mínimos totais de recursos do sistema são os seguintes:

Pré-requisitos para clusters ARO ou OCP

Desabilitar o SELinux (Security Enhanced Linux)

Em computadores com o SELinux habilitado, não há suporte para o conjunto de dados do Azure Machine Learning (um recurso do SDK v1 usado em trabalhos de treinamento do Azure Machine Learning). Portanto, você precisa desabilitar o selinux em todos os trabalhos para usar o conjunto de dados do Azure Machine Learning.

Configuração privilegiada para ARO e OCP

Para a implantação de extensão do Azure Machine Learning no cluster ARO ou OCP, permita acesso privilegiado às contas de serviço do Azure Machine Learning, execute o comando oc edit scc privileged e adicione as seguintes contas de serviço em "usuários:":

• system:serviceaccount:azure-arc:azure-arc-kube-aad-proxy-sa
• system:serviceaccount:azureml:{EXTENSION-NAME}-kube-state-metrics
• system:serviceaccount:azureml:prom-admission
• system:serviceaccount:azureml:default
• system:serviceaccount:azureml:prom-operator
• system:serviceaccount:azureml:load-amlarc-selinux-policy-sa
• system:serviceaccount:azureml:azureml-fe-v2
• system:serviceaccount:azureml:prom-prometheus
• system:serviceaccount:{KUBERNETES-COMPUTE-NAMESPACE}:default
• system:serviceaccount:azureml:azureml-ingress-nginx
• system:serviceaccount:azureml:azureml-ingress-nginx-admission

Detalhes do log coletado

Alguns logs sobre cargas de trabalho do Azure Machine Learning no cluster serão coletados por meio de componentes de extensão, como status, métricas, ciclo de vida etc. A lista a seguir mostra todos os detalhes do log coletados, incluindo o tipo dos logs coletados e para onde eles foram enviados ou armazenados.

Os trabalhos do Azure Machine Learning se conectam com o armazenamento de dados personalizado

PV (Volume Persistente) e PVC (Reivindicação de Volume Persistente) são conceitos do Kubernetes, permitindo que o usuário forneça e consuma vários recursos de armazenamento.

1. Crie um PV, usando o NFS como exemplo:

apiVersion: v1
kind: PersistentVolume
metadata:
  name: nfs-pv 
spec:
  capacity:
    storage: 1Gi 
  accessModes:
    - ReadWriteMany 
  persistentVolumeReclaimPolicy: Retain
  storageClassName: ""
  nfs: 
    path: /share/nfs
    server: 20.98.110.84 
    readOnly: false

2. Crie um PVC no mesmo namespace do Kubernetes com cargas de trabalho de ML. Em metadata, você precisa adicionar o rótulo ml.azure.com/pvc: "true" para ser reconhecido pelo Azure Machine Learning e adicionar a anotação ml.azure.com/mountpath: <mount path> para definir o caminho de montagem.

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: nfs-pvc  
  namespace: default
  labels:
    ml.azure.com/pvc: "true"
  annotations:
    ml.azure.com/mountpath: "/mnt/nfs"
spec:
  storageClassName: ""
  accessModes:
  - ReadWriteMany      
  resources:
     requests:
       storage: 1Gi

Tolerâncias e taints do Azure Machine Learning com suporte

Taint e tolerância são conceitos do Kubernetes que funcionam juntos para garantir que os pods não sejam agendados em nós inadequados.

Os clusters do Kubernetes integrados ao Azure Machine Learning (incluindo clusters do AKS e do Arc Kubernetes) agora dão suporte a taints e tolerâncias específicos do Azure Machine Learning, permitindo que os usuários adicionem taints específicos do Azure Machine Learning em nós dedicados do Azure Machine Learning, para impedir que cargas de trabalho que não são do Azure Machine Learning sejam agendadas nesses nós dedicados.

Só damos suporte à colocação de taints específicos do amlarc em seus nós, que são definidos da seguinte maneira:

Práticas recomendadas

De acordo com seus requisitos de agendamento dos nós dedicados do Azure Machine Learning, você pode adicionar vários taints específicos do amlarc para restringir quais cargas de trabalho do Azure Machine Learning podem ser executadas em nós. Listamos as práticas recomendadas para usar taints do amlarc:

• Para impedir que as cargas de trabalho que são sejam do Azure Machine Learning sejam executadas em nós/pools de nós dedicados do Azure Machine Learning, basta adicionar o taint aml overall a esses nós.
• Para impedir que pods que não sejam do sistema sejam executados em nós/pools de nós dedicados ao Azure Machine Learning, você precisa adicionar os seguintes taints:
  • Taint amlarc overall
  • Taint amlarc system
• Para impedir que cargas de trabalho que não sejam do machine learning sejam executados em nós/pools de nós dedicados ao Azure Machine Learning, você precisa adicionar os seguintes taints:
  • Taint amlarc overall
  • Taint amlarc workloads
• Para impedir que cargas de trabalho não criadas a partir do workspace X sejam executadas em nós/pools de nós dedicados ao Azure Machine Learning, você precisa adicionar os seguintes taints:
  • Taint amlarc overall
  • Taint amlarc resource group (has this <workspace X>)
  • Taint amlarc <workspace X>
• Para impedir que cargas de trabalho não criadas pelo destino de computação X sejam executadas em nós/pools de nós dedicados ao Azure Machine Learning, você precisa adicionar os seguintes taints:
  • Taint amlarc overall
  • Taint amlarc resource group (has this <workspace X>)
  • Taint amlarc workspace (has this <compute X>)
  • Taint amlarc <compute X>

Integrar outro controlador de entrada com a extensão Azure Machine Learning por HTTP ou HTTPS

Além do balanceador de carga de inferência azureml-fe padrão do Azure Machine Learning, você também pode integrar outros balanceadores de carga à extensão do Azure Machine Learning por HTTP ou HTTPS.

Este tutorial ajuda a ilustrar como integrar o Nginx Ingress Controller ou o Gateway de Aplicativo do Azure.

Pré-requisitos

• Implante a extensão do Azure Machine Learning com inferenceRouterServiceType=ClusterIP e allowInsecureConnections=True, para que o Nginx Ingress Controller possa gerenciar a terminação TLS sozinho só em vez de enviá-la ao azureml-fe quando o serviço for exposto por HTTPS.
• Para fazer a integração com o Nginx Ingress Controller, você precisará de uma configuração de cluster do Kubernetes com o Nginx Ingress Controller.
  • Criar um controlador básico: se você estiver começando do zero, confira estas instruções.
• Para fazer a integração com Gateway de Aplicativo do Azure, você precisará de uma configuração de cluster do Kubernetes com o controlador de entrada do Gateway de Aplicativo do Azure.
  • Implantação do Greenfield: se você estiver começando do zero, confira estas instruções.
  • Implantação do Brownfield: se você já tiver um cluster do AKS e um Gateway de Aplicativo, siga estas instruções.
• Se você quiser usar HTTPS neste aplicativo, será necessário um certificado x509 e a respectiva chave privada.

Expor serviços via HTTP

Para expor o azureml-fe, usaremos o seguinte recurso de entrada:

# Nginx Ingress Controller example
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: azureml-fe
  namespace: azureml
spec:
  ingressClassName: nginx
  rules:
  - http:
      paths:
      - path: /
        backend:
          service:
            name: azureml-fe
            port:
              number: 80
        pathType: Prefix

Essa entrada expõe o serviço azureml-fe e a implantação selecionada como um back-end padrão do Nginx Ingress Controller.

# Azure Application Gateway example
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: azureml-fe
  namespace: azureml
spec:
  ingressClassName: azure-application-gateway
  rules:
  - http:
      paths:
      - path: /
        backend:
          service:
            name: azureml-fe
            port:
              number: 80
        pathType: Prefix

Essa entrada expõe o serviço azureml-fe e a implantação selecionada como um back-end padrão do Gateway de Aplicativo.

Salve o recurso de entrada acima como ing-azureml-fe.yaml.

1. Implante ing-azureml-fe.yaml executando:

   kubectl apply -f ing-azureml-fe.yaml
   

2. Verifique o status da implantação no log do controlador de entrada.

3. Agora o aplicativo azureml-fe deve estar disponível. Você pode conferir isso acessando:

   • Nginx Ingress Controller: o endereço do balanceador de carga público do Nginx Ingress Controller
   • Gateway de Aplicativo do Azure: o endereço público do Gateway de Aplicativo.

4. Criar um trabalho de inferência e invocá-lo.

   Observação

   Substitua o IP em scoring_uri pelo endereço público do balanceador de carga do Nginx Ingress Controller antes de fazer a invocação.

Expor serviços via HTTPS

1. Antes de implantar a entrada, você precisa criar um segredo de Kubernetes para hospedar o certificado e a chave privada. Você pode criar um segredo de Kubernetes executando

   kubectl create secret tls <ingress-secret-name> -n azureml --key <path-to-key> --cert <path-to-cert>
   

2. Defina a entrada a seguir. Na entrada, especifique o nome do segredo na seção secretName.

   # Nginx Ingress Controller example
   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     name: azureml-fe
     namespace: azureml
   spec:
     ingressClassName: nginx
     tls:
     - hosts:
       - <domain>
       secretName: <ingress-secret-name>
     rules:
     - host: <domain>
       http:
         paths:
         - path: /
           backend:
             service:
               name: azureml-fe
               port:
                 number: 80
           pathType: Prefix
   

   # Azure Application Gateway example
   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     name: azureml-fe
     namespace: azureml
   spec:
     ingressClassName: azure-application-gateway
     tls:
     - hosts:
       - <domain>
       secretName: <ingress-secret-name>
     rules:
     - host: <domain>
       http:
         paths:
         - path: /
           backend:
             service:
               name: azureml-fe
               port:
                 number: 80
           pathType: Prefix
   

   Observação

   Substitua <domain> e <ingress-secret-name> no recurso de entrada acima pelo domínio que aponta para o balanceador de carga do Nginx Ingress Controller/Gateway de Aplicativo e o nome do segredo. Armazene o Recurso de Entrada acima em um nome de arquivo ing-azureml-fe-tls.yaml.

3. Implantar o ing-azureml-fe-tls.yaml executando

   kubectl apply -f ing-azureml-fe-tls.yaml
   

4. Verifique o status da implantação no log do controlador de entrada.

5. Agora o aplicativo azureml-fe estará disponível em HTTPS. Você pode conferir isso verificando o endereço público do balanceador de carga do Nginx Ingress Controller.

6. Criar um trabalho de inferência e invocá-lo.

   Observação

   Substitua o protocolo e o IP em scoring_uri por HTTP e domínio o apontando para o balanceador de carga do Nginx Ingress Controller ou do Gateway de Aplicativo antes da invocação.

Usar o modelo do ARM para implantar a extensão

A extensão no cluster gerenciado pode ser implantada com o modelo do ARM. Veja um modelo de exemplo no deployextension.json, com um arquivo de parâmetro de demonstração deployextension.parameters.json

Para usar o modelo de implantação de exemplo, edite o arquivo de parâmetro com o valor correto e execute o seguinte comando:

az deployment group create --name <ARM deployment name> --resource-group <resource group name> --template-file deployextension.json --parameters deployextension.parameters.json

Veja mais informações de como usar o modelo do ARM na documentação de modelo do ARM

Nota de versão da extensão Azure ML