Desenvolvimentos recentes em aprendizado de máquina (ML) levaram a modelos cada vez maiores, alguns dos quais exigem centenas de bilhões de parâmetros. Embora sejam mais poderosos, o treinamento e a inferência sobre esses modelos requerem recursos computacionais significativos. Apesar da disponibilidade de bibliotecas avançadas de treinamento distribuídas, é comum que trabalhos de treinamento e inferência precisem de centenas de aceleradores (GPUs ou chips de ML específicos, como Treinamento AWS e Inferência da AWS) e, portanto, dezenas ou centenas de instâncias.

Nesses ambientes distribuídos, a observabilidade das instâncias e dos chips de ML torna-se fundamental para o ajuste fino do desempenho do modelo e a otimização de custos. As métricas permitem que as equipes entendam o comportamento da carga de trabalho e otimizem a alocação e utilização de recursos, diagnostiquem anomalias e aumentem a eficiência geral da infraestrutura. Para os cientistas de dados, a utilização e saturação dos chips de ML também são relevantes para o planejamento da capacidade.

Esta postagem orienta você Padrão de observabilidade de código aberto para AWS Inferentia, que mostra como monitorar o desempenho de chips de ML, usados ​​em um Serviço Amazon Elastic Kubernetes (Amazon EKS), com nós de plano de dados baseados em Amazon Elastic Compute Nuvem (Amazon EC2) instâncias do tipo Inf1 e Inf2.

O padrão faz parte do Acelerador de observabilidade AWS CDK, um conjunto de módulos opinativos para ajudar você a definir a observabilidade para clusters do Amazon EKS. O AWS CDK Observability Accelerator é organizado em torno de padrões, que são unidades reutilizáveis ​​para implantação de vários recursos. O conjunto de padrões de observabilidade de código aberto instrumenta a observabilidade com Grafana gerenciada pela Amazon painéis, um Distribuição da AWS para OpenTelemetry coletor para coletar métricas, e Amazon Managed Service para Prometheus para armazená-los.

Visão geral da solução

O diagrama a seguir ilustra a arquitetura da solução.

Esta solução implanta um cluster do Amazon EKS com um grupo de nós que inclui instâncias Inf1.

O tipo de AMI do grupo de nós é AL2_x86_64_GPU, que usa o Amazon EKS otimizado e acelerado Amazon Linux AMI. Além da configuração padrão da AMI otimizada para Amazon EKS, a AMI acelerada inclui o Tempo de execução do NeuronX.

Para acessar os chips de ML do Kubernetes, o padrão implanta o Neurônio AWS plug-in do dispositivo.

As métricas são expostas ao Amazon Managed Service for Prometheus pelo neuron-monitor DaemonSet, que implanta um contêiner mínimo, com o Ferramentas de neurônios instalado. Especificamente, o neuron-monitor DaemonSet executa o neuron-monitor comando canalizado para o neuron-monitor-prometheus.py script complementar (ambos os comandos fazem parte do contêiner):

neuron-monitor | neuron-monitor-prometheus.py --port <port>

O comando usa os seguintes componentes:

• neuron-monitor coleta métricas e estatísticas dos aplicativos Neuron em execução no sistema e transmite os dados coletados para stdout em Formato JSON
• neuron-monitor-prometheus.py mapeia e expõe os dados de telemetria do formato JSON para um formato compatível com Prometheus

Os dados são visualizados no Amazon Managed Grafana pelo painel correspondente.

O restante da configuração para coletar e visualizar métricas com Amazon Managed Service for Prometheus e Amazon Managed Grafana é semelhante ao usado em outros padrões baseados em código aberto, incluídos no AWS Observability Accelerator for CDK Repositório GitHub.

Pré-requisitos

Você precisa do seguinte para concluir as etapas desta postagem:

Configure o ambiente

Conclua as etapas a seguir para configurar seu ambiente:

1. Abra uma janela de terminal e execute os seguintes comandos:

export AWS_REGION=<YOUR AWS REGION>
export ACCOUNT_ID=$(aws sts get-caller-identity --query 'Account' --output text)

2. Recupere os IDs de espaço de trabalho de qualquer espaço de trabalho existente do Amazon Managed Grafana:

aws grafana list-workspaces

A seguir está nosso exemplo de saída:

{
  "workspaces": [
    {
      "authentication": {
        "providers": [
          "AWS_SSO"
        ]
      },
      "created": "2023-06-07T12:23:56.625000-04:00",
      "description": "accelerator-workspace",
      "endpoint": "g-XYZ.grafana-workspace.us-east-2.amazonaws.com",
      "grafanaVersion": "9.4",
      "id": "g-XYZ",
      "modified": "2023-06-07T12:30:09.892000-04:00",
      "name": "accelerator-workspace",
      "notificationDestinations": [
        "SNS"
      ],
      "status": "ACTIVE",
      "tags": {}
    }
  ]
}

3. Atribuir os valores de id e endpoint às seguintes variáveis ​​de ambiente:

export COA_AMG_WORKSPACE_ID="<<YOUR-WORKSPACE-ID, similar to the above g-XYZ, without quotation marks>>"
export COA_AMG_ENDPOINT_URL="<<https://YOUR-WORKSPACE-URL, including protocol (i.e. https://), without quotation marks, similar to the above https://g-XYZ.grafana-workspace.us-east-2.amazonaws.com>>"

COA_AMG_ENDPOINT_URL precisa incluir https://.

4. Crie uma chave de API do Grafana no espaço de trabalho Amazon Managed Grafana:

export AMG_API_KEY=$(aws grafana create-workspace-api-key 
--key-name "grafana-operator-key" 
--key-role "ADMIN" 
--seconds-to-live 432000 
--workspace-id $COA_AMG_WORKSPACE_ID 
--query key 
--output text)

5. Configure um segredo em Gerente de Sistemas AWS:

aws ssm put-parameter --name "/cdk-accelerator/grafana-api-key" 
--type "SecureString" 
--value $AMG_API_KEY 
--region $AWS_REGION

O segredo será acessado pelo complemento External Secrets e disponibilizado como um segredo nativo do Kubernetes no cluster EKS.

Inicialize o ambiente AWS CDK

A primeira etapa para qualquer implantação do AWS CDK é inicializar o ambiente. Você usa o cdk bootstrap comando na CLI do AWS CDK para preparar o ambiente (uma combinação de conta da AWS e região da AWS) com os recursos exigidos pelo AWS CDK para realizar implantações nesse ambiente. A inicialização do AWS CDK é necessária para cada combinação de conta e região. Portanto, se você já inicializou o AWS CDK em uma região, não será necessário repetir o processo de inicialização.

cdk bootstrap aws://$ACCOUNT_ID/$AWS_REGION

Implante a solução

Conclua as etapas a seguir para implementar a solução:

1. Clone o cdk-aws-acelerador de observabilidade repositório e instale os pacotes de dependência. Este repositório contém código AWS CDK v2 escrito em TypeScript.

git clone https://github.com/aws-observability/cdk-aws-observability-accelerator.git
cd cdk-aws-observability-accelerator

Espera-se que as configurações reais dos arquivos JSON do painel Grafana sejam especificadas no contexto do AWS CDK. Você precisa atualizar context no cdk.json arquivo, localizado no diretório atual. A localização do painel é especificada pelo fluxRepository.values.GRAFANA_NEURON_DASH_URL parâmetro, e neuronNodeGroup é usado para definir o tipo de instância, número e Loja de blocos elásticos da Amazon (Amazon EBS) tamanho usado para os nós.

2. Insira o seguinte trecho em cdk.json, substituindo context:

"context": {
    "fluxRepository": {
      "name": "grafana-dashboards",
      "namespace": "grafana-operator",
      "repository": {
        "repoUrl": "https://github.com/aws-observability/aws-observability-accelerator",
        "name": "grafana-dashboards",
        "targetRevision": "main",
        "path": "./artifacts/grafana-operator-manifests/eks/infrastructure"
      },
      "values": {
        "GRAFANA_CLUSTER_DASH_URL" : "https://raw.githubusercontent.com/aws-observability/aws-observability-accelerator/main/artifacts/grafana-dashboards/eks/infrastructure/cluster.json",
        "GRAFANA_KUBELET_DASH_URL" : "https://raw.githubusercontent.com/aws-observability/aws-observability-accelerator/main/artifacts/grafana-dashboards/eks/infrastructure/kubelet.json",
        "GRAFANA_NSWRKLDS_DASH_URL" : "https://raw.githubusercontent.com/aws-observability/aws-observability-accelerator/main/artifacts/grafana-dashboards/eks/infrastructure/namespace-workloads.json",
        "GRAFANA_NODEEXP_DASH_URL" : "https://raw.githubusercontent.com/aws-observability/aws-observability-accelerator/main/artifacts/grafana-dashboards/eks/infrastructure/nodeexporter-nodes.json",
        "GRAFANA_NODES_DASH_URL" : "https://raw.githubusercontent.com/aws-observability/aws-observability-accelerator/main/artifacts/grafana-dashboards/eks/infrastructure/nodes.json",
        "GRAFANA_WORKLOADS_DASH_URL" : "https://raw.githubusercontent.com/aws-observability/aws-observability-accelerator/main/artifacts/grafana-dashboards/eks/infrastructure/workloads.json",
        "GRAFANA_NEURON_DASH_URL" : "https://raw.githubusercontent.com/aws-observability/aws-observability-accelerator/main/artifacts/grafana-dashboards/eks/neuron/neuron-monitor.json"
      },
      "kustomizations": [
        {
          "kustomizationPath": "./artifacts/grafana-operator-manifests/eks/infrastructure"
        },
        {
          "kustomizationPath": "./artifacts/grafana-operator-manifests/eks/neuron"
        }
      ]
    },
     "neuronNodeGroup": {
      "instanceClass": "inf1",
      "instanceSize": "2xlarge",
      "desiredSize": 1, 
      "minSize": 1, 
      "maxSize": 3,
      "ebsSize": 512
    }
  }

Você pode substituir o tipo de instância Inf1 por Inf2 e alterar o tamanho conforme necessário. Para verificar a disponibilidade na região selecionada, execute o seguinte comando (alterar Values como achar melhor):

aws ec2 describe-instance-type-offerings 
--filters Name=instance-type,Values="inf1*" 
--query "InstanceTypeOfferings[].InstanceType" 
--region $AWS_REGION

3. Instale as dependências do projeto:

npm install

4. Execute os comandos a seguir para implementar o padrão de observabilidade de software livre:

make build
make pattern single-new-eks-inferentia-opensource-observability deploy

Valide a solução

Conclua as etapas a seguir para validar a solução:

1. execute o update-kubeconfig comando. Você deve conseguir obter o comando da mensagem de saída do comando anterior:

aws eks update-kubeconfig --name single-new-eks-inferentia-opensource... --region <your region> --role-arn arn:aws:iam::xxxxxxxxx:role/single-new-eks-....

2. Verifique os recursos que você criou:

kubectl get pods -A

A captura de tela a seguir mostra nosso exemplo de saída.

3. Verifique se o neuron-device-plugin-daemonset DaemonSet está em execução:

kubectl get ds neuron-device-plugin-daemonset --namespace kube-system

A seguir está nossa saída esperada:

NAME                             DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
neuron-device-plugin-daemonset   1         1         1       1            1           <none>          2h

4. Confirme se o neuron-monitor DaemonSet está em execução:

kubectl get ds neuron-monitor --namespace kube-system

A seguir está nossa saída esperada:

NAME             DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
neuron-monitor   1         1         1       1            1           <none>          2h

5. Para verificar se os dispositivos e núcleos do Neuron estão visíveis, execute o neuron-ls e neuron-top comandos de, por exemplo, seu pod de monitor de neurônios (você pode obter o nome do pod na saída de kubectl get pods -A):

kubectl exec -it {your neuron-monitor pod} -n kube-system -- /bin/bash -c "neuron-ls"

A captura de tela a seguir mostra nossa saída esperada.

kubectl exec -it {your neuron-monitor pod} -n kube-system -- /bin/bash -c "neuron-top"

A captura de tela a seguir mostra nossa saída esperada.

Visualize dados usando o painel Grafana Neuron

Faça login no espaço de trabalho do Amazon Managed Grafana e navegue até o Dashboards painel. Você deverá ver um painel chamado Neurônio / Monitor.

Para ver algumas métricas interessantes no painel do Grafana, aplicamos o seguinte manifesto:

curl https://raw.githubusercontent.com/aws-observability/aws-observability-accelerator/main/artifacts/k8s-deployment-manifest-templates/neuron/pytorch-inference-resnet50.yml | kubectl apply -f -

Este é um exemplo de carga de trabalho que compila o modelo torchvision ResNet50 e executa inferência repetitiva em um loop para gerar dados de telemetria.

Para verificar se o pod foi implantado com sucesso, execute o seguinte código:

kubectl get pods

Você deverá ver um pod chamado pytorch-inference-resnet50.

Depois de alguns minutos, olhando para o Neurônio / Monitor painel, você deverá ver as métricas coletadas semelhantes às capturas de tela a seguir.

Grafana Operator e Flux sempre trabalham juntos para sincronizar seus painéis com Git. Se você excluir seus painéis acidentalmente, eles serão provisionados novamente automaticamente.

limpar

Você pode excluir toda a pilha do AWS CDK com o seguinte comando:

make pattern single-new-eks-inferentia-opensource-observability destroy

Conclusão

Nesta postagem, mostramos como introduzir observabilidade, com ferramentas de código aberto, em um cluster EKS apresentando um plano de dados executando instâncias EC2 Inf1. Começamos selecionando a AMI acelerada otimizada para Amazon EKS para os nós do plano de dados, que inclui o tempo de execução do contêiner Neuron, fornecendo acesso aos dispositivos AWS Inferentia e Trainium Neuron. Em seguida, para expor os núcleos e dispositivos Neuron ao Kubernetes, implantamos o plug-in de dispositivo Neuron. A coleta e mapeamento reais de dados de telemetria em formato compatível com Prometheus foram realizados via neuron-monitor e neuron-monitor-prometheus.py. As métricas foram obtidas do Amazon Managed Service for Prometheus e exibidas no painel Neuron do Amazon Managed Grafana.

Recomendamos que você explore padrões de observabilidade adicionais no Acelerador de observabilidade da AWS para CDK Repositório GitHub. Para saber mais sobre o Neuron, consulte o Documentação do neurônio AWS.

Sobre o autor

Ricardo Freschi é arquiteto de soluções sênior na AWS, com foco na modernização de aplicativos. Ele trabalha em estreita colaboração com parceiros e clientes para ajudá-los a transformar seus cenários de TI em sua jornada para a Nuvem AWS, refatorando aplicativos existentes e criando novos.

• Conteúdo com tecnologia de SEO e distribuição de relações públicas. Seja amplificado hoje.
• PlatoData.Network Gerativa Vertical Ai. Capacite-se. Acesse aqui.
• PlatoAiStream. Inteligência Web3. Conhecimento Amplificado. Acesse aqui.
• PlatãoESG. Carbono Tecnologia Limpa, Energia, Ambiente, Solar, Gestão de resíduos. Acesse aqui.
• PlatoHealth. Inteligência em Biotecnologia e Ensaios Clínicos. Acesse aqui.
• Fonte: https://aws.amazon.com/blogs/machine-learning/open-source-observability-for-aws-inferentia-nodes-within-amazon-eks-clusters/