Referência para configurar o 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 do Kubernetes suportadas

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

  • Por exemplo, se o AKS introduzir 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 suportadas.

  • Se os clientes estiverem executando uma versão do Kubernetes sem suporte, eles serão solicitados a atualizar ao solicitar suporte para o cluster. Os clusters que executam versões do Kubernetes sem suporte não são cobertos pelas políticas de suporte da extensão do Azure Machine Learning.

• Disponibilidade da região de 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 no suporte à região do Kubernetes habilitado para Azure Arc.

Planeamento de recursos recomendado

Quando você implanta a extensão do Azure Machine Learning, alguns serviços relacionados sã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 suas próprias implantações/pods, os requisitos mínimos totais de recursos do sistema são os seguintes:

Pré-requisitos para clusters ARO ou OCP

Desativar o Security Enhanced Linux (SELinux)

O conjunto de dados do Azure Machine Learning (um recurso do SDK v1 usado em trabalhos de treinamento do Azure Machine Learning) não é suportado em máquinas com o SELinux habilitado. Portanto, você precisa desabilitar selinux todos os trabalhadores para usar o conjunto de dados do Azure Machine Learning.

Configuração privilegiada para ARO e OCP

Para a implantação da extensão do Azure Machine Learning em cluster ARO ou OCP, conceda acesso privilegiado às contas de serviço do Azure Machine Learning, execute oc edit scc privileged o comando 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 de registo recolhidos

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 de log coletados, incluindo o tipo de logs coletados e para onde foram enviados ou armazenados.

Os trabalhos do Azure Machine Learning conectam-se ao armazenamento de dados personalizado

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

1. Crie PV, tome 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 PVC no mesmo namespace do Kubernetes com cargas de trabalho de ML. No metadata, você deve adicionar rótulo ml.azure.com/pvc: "true" para ser reconhecido pelo Aprendizado de Máquina do Azure e adicionar 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

Rejeições e tolerâncias do Azure Machine Learning suportadas

Taint e Toleration são conceitos do Kubernetes que trabalham juntos para garantir que os pods não sejam programados em nós inadequados.

Os clusters Kubernetes integrados com o Azure Machine Learning (incluindo clusters AKS e Arc Kubernetes) agora suportam manchas e tolerâncias específicas do Azure Machine Learning, permitindo que os usuários adicionem manchas específicas do Azure Machine Learning nos nós dedicados ao Azure Machine Learning, para evitar que cargas de trabalho que não sejam do Azure Machine Learning sejam agendadas nesses nós dedicados.

Suportamos apenas a colocação das manchas específicas do amlarc nos seus nós, que são definidos da seguinte forma:

Melhores práticas

De acordo com seus requisitos de agendamento dos nós dedicados ao Azure Machine Learning, você pode adicionar várias manchas específicas do amlarc para restringir quais cargas de trabalho do Azure Machine Learning podem ser executadas em nós. Listamos as melhores práticas para o uso de manchas de amlarc:

• Para evitar que cargas de trabalho que não sejam do Aprendizado de Máquina do Azure sejam executadas em nós/pools de nós dedicados ao Aprendizado de Máquina do Azure, basta adicionar a aml overall mancha a esses nós.
• Para evitar que pods que não sejam do sistema sejam executados em nós/pools de nós dedicados ao Aprendizado de Máquina do Azure, você precisa adicionar as seguintes manchas:
  • amlarc overall Mancha
  • amlarc system Mancha
• Para evitar que cargas de trabalho que não sejam de ml sejam executadas em nós/pools de nós dedicados ao Aprendizado de Máquina do Azure, você precisa adicionar as seguintes manchas:
  • amlarc overall Mancha
  • amlarc workloads Mancha
• Para evitar que cargas de trabalho não criadas a partir do espaço de trabalho X sejam executadas em nós/pools de nós dedicados ao Aprendizado de Máquina do Azure, você precisa adicionar as seguintes manchas:
  • amlarc overall Mancha
  • amlarc resource group (has this <workspace X>) Mancha
  • amlarc <workspace X> Mancha
• Para evitar que cargas de trabalho não criadas pelo destino de computação X sejam executadas em nós/pools de nós dedicados ao Aprendizado de Máquina do Azure, você precisa adicionar as seguintes manchas:
  • amlarc overall Mancha
  • amlarc resource group (has this <workspace X>) Mancha
  • amlarc workspace (has this <compute X>) Mancha
  • amlarc <compute X> Mancha

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

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

Este tutorial ajuda a ilustrar como integrar o Nginx Ingress Controller ou o Azure Application Gateway.

Pré-requisitos

• Implante a extensão do Azure Machine Learning com e allowInsecureConnections=True, para que o Nginx Ingress Controller possa lidar com inferenceRouterServiceType=ClusterIP a terminação TLS sozinha, em vez de entregá-la ao azureml-fe quando o serviço for exposto por HTTPS.
• Para integrar com o Nginx Ingress Controller, você precisa de uma configuração de cluster Kubernetes com o Nginx Ingress Controller.
  • Crie um controlador básico: se você estiver começando do zero, consulte estas instruções.
• Para integrar com o Gateway de Aplicativo do Azure, você precisa de uma configuração de cluster do Kubernetes com o Controlador de Ingresso do Gateway de Aplicativo do Azure.
  • Implantação Greenfield: Se você estiver começando do zero, consulte estas instruções.
  • Implantação de Brownfield: Se você tiver um cluster AKS e um Application Gateway existentes, consulte estas instruções.
• Se você quiser usar HTTPS neste aplicativo, você precisa de um certificado x509 e sua chave privada.

Expor serviços por 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 azureml-fe serviço 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 azureml-fe serviço e a implantação selecionada como um back-end padrão do Application Gateway.

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 log do controlador de entrada para obter o status da implantação.

3. Agora o azureml-fe aplicativo deve estar disponível. Você pode verificar visitando:

   • Nginx Ingress Controller: o endereço público LoadBalancer do Nginx Ingress Controller
   • Azure Application Gateway: o endereço público do Application Gateway.

4. Crie um trabalho de inferência e invoque.

   Nota

   Substitua o ip no scoring_uri pelo endereço público LoadBalancer do Nginx Ingress Controller antes de invocar.

Expor serviços por HTTPS

1. Antes de implantar a entrada, você precisa criar um segredo do 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 seguinte entrada. Na entrada, especifique o nome do segredo na secretName seção.

   # 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
   

   Nota

   Substitua <domain> e <ingress-secret-name> no Ingress Resource acima pelo domínio apontando para LoadBalancer do controlador de ingresso Nginx/Application Gateway e nome do seu segredo. Armazene o recurso de ingresso acima em um nome ing-azureml-fe-tls.yamlde arquivo .

3. Implante ing-azureml-fe-tls.yaml executando

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

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

5. Agora o azureml-fe aplicativo está disponível em HTTPS. Você pode verificar isso visitando o endereço público LoadBalancer do Nginx Ingress Controller.

6. Crie um trabalho de inferência e invoque.

   Nota

   Substitua o protocolo e o IP em scoring_uri por https e domínio apontando para LoadBalancer do Nginx Ingress Controller ou o Application Gateway antes de invocar.

Utilizar o Modelo do ARM para Implementar a Extensão

A extensão no cluster gerenciado pode ser implantada com o modelo ARM. Um modelo de exemplo pode ser encontrado 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

Mais informações sobre como usar o modelo ARM podem ser encontradas no documento de modelo ARM

Nota de versão da extensão AzuremML