As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # SageMaker Componentes de IA para pipelines Kubeflow Com os componentes de SageMaker IA para o Kubeflow Pipelines, você pode criar e monitorar trabalhos nativos SageMaker de treinamento, ajuste, implantação de endpoints e transformação em lote de seus pipelines do Kubeflow. Ao executar trabalhos do Kubeflow Pipeline na SageMaker IA, você move os trabalhos de processamento e treinamento de dados do cluster Kubernetes para o serviço gerenciado otimizado para aprendizado de máquina da SageMaker IA. Este documento pressupõe conhecimento prévio do Kubernetes e do Kubeflow. **Topics** + [O que são pipelines Kubeflow?](#what-is-kubeflow-pipelines) + [Quais são os componentes do Kubeflow Pipeline?](#kubeflow-pipeline-components) + [Por que usar componentes de SageMaker IA para pipelines do Kubeflow?](#why-use-sagemaker-components) + [SageMaker Componentes de IA para versões do Kubeflow Pipelines](#sagemaker-components-versions) + [Lista de componentes de SageMaker IA para pipelines Kubeflow](#sagemaker-components-list) + [permissões do IAM](#iam-permissions) + [Conversão de pipelines para usar IA SageMaker](#converting-pipelines-to-use-amazon-sagemaker) + [Instalar Pipelines do Kubeflow](kubernetes-sagemaker-components-install.md) + [Use componentes de SageMaker IA](kubernetes-sagemaker-components-tutorials.md) ## O que são pipelines Kubeflow? O Kubeflow Pipelines (KFP) é uma plataforma para criar e implantar fluxos de trabalho de machine learning (ML) portáteis e escaláveis com base em contêineres do Docker. A plataforma Kubeflow Pipelines consiste no seguinte: + Uma interface de usuário (UI) para gerenciar e rastrear experimentos, trabalhos e execuções. + Um mecanismo (Argo) para programar fluxos de trabalho de ML em várias etapas. + Um SDK para definir e manipular pipelines e componentes. + Notebooks para interagir com o sistema usando o SDK. Um pipeline é uma descrição de um fluxo de trabalho de ML expressa como um [gráfico acíclico direcionado](https://www.kubeflow.org/docs/pipelines/concepts/graph/). Cada etapa do fluxo de trabalho é expressa como um [componente](https://www.kubeflow.org/docs/pipelines/overview/concepts/component/) do Kubeflow Pipeline, que é um AWS SDK para Python (Boto3) módulo. Para obter mais informações sobre o Kubeflow Pipelines, consulte a [documentação do Kubeflow Pipelines](https://www.kubeflow.org/docs/pipelines/). ## Quais são os componentes do Kubeflow Pipeline? Um componente do Kubeflow Pipeline é um conjunto de código usado para executar uma etapa de um pipeline do Kubeflow. Os componentes são representados por um módulo Python incorporado em uma imagem do Docker. Quando o pipeline é executado, o contêiner do componente é instanciado em um dos nós de processamento no cluster Kubernetes que executa o Kubeflow, e sua lógica é executada. Os componentes do pipeline podem ler as saídas dos componentes anteriores e criar saídas que o próximo componente do pipeline possa consumir. Esses componentes facilitam e agilizam a criação de pipelines para ambientes de experimentação e produção sem precisar interagir com a infraestrutura subjacente do Kubernetes. Você pode usar componentes de SageMaker IA em seu pipeline do Kubeflow. Em vez de encapsular sua lógica em um contêiner personalizado, basta carregar os componentes e descrever seu pipeline usando o SDK do Kubeflow Pipelines. Quando o pipeline é executado, suas instruções são traduzidas em um trabalho ou implantação de SageMaker IA. Em seguida, a carga de trabalho é executada na infraestrutura totalmente gerenciada da SageMaker IA. ## Por que usar componentes de SageMaker IA para pipelines do Kubeflow? SageMaker Os componentes de IA para o Kubeflow Pipelines oferecem uma alternativa ao lançamento de seus trabalhos de computação intensiva a partir da IA. SageMaker Os componentes integram a SageMaker IA com a portabilidade e a orquestração do Kubeflow Pipelines. Usando os componentes de SageMaker IA para o Kubeflow Pipelines, você pode criar e monitorar seus recursos de SageMaker IA como parte de um fluxo de trabalho do Kubeflow Pipelines. Cada um dos trabalhos em seus pipelines é executado em SageMaker IA em vez do cluster Kubernetes local, permitindo que você aproveite os principais recursos de SageMaker IA, como rotulagem de dados, ajuste de hiperparâmetros em grande escala e trabalhos de treinamento distribuídos, ou implantação de modelo seguro e escalável com um clique. Os parâmetros, o status, os registros e as saídas do trabalho da SageMaker IA ainda podem ser acessados na interface do usuário do Kubeflow Pipelines. Os componentes de SageMaker IA integram os principais recursos de SageMaker IA em seus fluxos de trabalho de ML, desde a preparação de dados até a criação, o treinamento e a implantação de modelos de ML. Você pode criar um Kubeflow Pipeline construído inteiramente usando esses componentes ou integrar componentes individuais ao seu fluxo de trabalho conforme necessário. Os componentes estão disponíveis em uma ou duas versões. Cada versão de um componente utiliza um backend diferente. Para obter mais informações sobre essas versões, consulte [SageMaker Componentes de IA para versões do Kubeflow Pipelines](#sagemaker-components-versions). Não há cobrança adicional pelo uso de componentes de SageMaker IA para pipelines do Kubeflow. Você incorre em cobranças por todos os recursos de SageMaker IA usados por meio desses componentes. ## SageMaker Componentes de IA para versões do Kubeflow Pipelines SageMaker Os componentes de IA para o Kubeflow Pipelines vêm em duas versões. Cada versão utiliza um back-end diferente para criar e gerenciar recursos em SageMaker IA. + Os componentes de SageMaker IA do Kubeflow Pipelines versão 1 (v1.x ou inferior) usam **[Boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html)** () como back-end.AWS SDK para Python (Boto3) + [A versão 2 (v2.0.0-alpha2 e superior) do SageMaker AI Components for Kubeflow Pipelines usa o AI Operator for Kubernetes (ACK). SageMaker ](https://github.com/aws-controllers-k8s/sagemaker-controller) AWS introduziu o [ACK](https://aws-controllers-k8s.github.io/community/) para facilitar uma forma nativa do Kubernetes de gerenciar recursos em nuvem. AWS O ACK inclui um conjunto de controladores AWS específicos de serviço, um dos quais é o SageMaker controlador de IA. O controlador de SageMaker IA facilita que desenvolvedores de aprendizado de máquina e cientistas de dados que usam o Kubernetes como plano de controle treinem, ajustem e implantem modelos de aprendizado de máquina (ML) na IA. SageMaker Para obter mais informações, consulte [Operadores de SageMaker IA para Kubernetes](https://aws-controllers-k8s.github.io/community/docs/tutorials/sagemaker-example/) Ambas as versões do SageMaker AI Components for Kubeflow Pipelines são compatíveis. No entanto, a versão 2 oferece algumas vantagens adicionais. Especificamente, ela oferece: 1. Uma experiência consistente para gerenciar seus recursos de SageMaker IA a partir de qualquer aplicativo, esteja você usando pipelines do Kubeflow, CLI (`kubectl`) do Kubernetes ou outros aplicativos do Kubeflow, como Notebooks. 1. A flexibilidade de gerenciar e monitorar seus recursos de SageMaker IA fora do fluxo de trabalho do pipeline do Kubeflow. 1. Tempo de configuração zero para usar os componentes de SageMaker IA se você implantou o [Kubeflow completo no AWS](https://awslabs.github.io/kubeflow-manifests/docs/about/) lançamento, já que o operador de SageMaker IA faz parte de sua implantação. ## Lista de componentes de SageMaker IA para pipelines Kubeflow Veja a seguir uma lista de todos os componentes de SageMaker IA para o Kubeflow Pipelines e suas versões disponíveis. Como alternativa, você pode encontrar todos os [componentes de SageMaker IA para pipelines do Kubeflow](https://github.com/kubeflow/pipelines/tree/master/components/aws/sagemaker#versioning) em. GitHub **nota** Incentivamos os usuários a utilizar a versão 2 de um componente de SageMaker IA onde quer que esteja disponível. ### Componentes do Ground Truth + **Ground Truth** O componente Ground Truth permite que você envie trabalhos de rotulagem do SageMaker AI Ground Truth diretamente de um fluxo de trabalho do Kubeflow Pipelines. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/kubernetes-sagemaker-components-for-kubeflow-pipelines.html) + **Equipe de trabalho** O componente Workteam permite que você crie trabalhos de equipe de trabalho privados de SageMaker IA diretamente de um fluxo de trabalho do Kubeflow Pipelines. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/kubernetes-sagemaker-components-for-kubeflow-pipelines.html) ### Componentes de processamento de dados + **Processamento** O componente Processing permite que você envie trabalhos de processamento para a SageMaker IA diretamente de um fluxo de trabalho do Kubeflow Pipelines. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/kubernetes-sagemaker-components-for-kubeflow-pipelines.html) ### Componentes de treinamento + **Treinamento** O componente de treinamento permite que você envie trabalhos de SageMaker treinamento diretamente de um fluxo de trabalho do Kubeflow Pipelines. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/kubernetes-sagemaker-components-for-kubeflow-pipelines.html) + **Otimização de hiperparâmetros** O componente Hyperparameter Optimization permite que você envie trabalhos de ajuste de hiperparâmetros para a SageMaker IA diretamente de um fluxo de trabalho do Kubeflow Pipelines. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/kubernetes-sagemaker-components-for-kubeflow-pipelines.html) ### Componentes de inferência + **Implantação de hospedagem** Os componentes de hospedagem permitem que você implante um modelo usando serviços de hospedagem de SageMaker IA a partir de um fluxo de trabalho do Kubeflow Pipelines. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/kubernetes-sagemaker-components-for-kubeflow-pipelines.html) + **Transformação em lote** O componente Batch Transform permite que você execute trabalhos de inferência para um conjunto de dados inteiro em SageMaker IA a partir de um fluxo de trabalho do Kubeflow Pipelines. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/kubernetes-sagemaker-components-for-kubeflow-pipelines.html) + **Model Monitor** Os componentes do Model Monitor permitem monitorar a qualidade dos modelos de aprendizado de máquina de SageMaker IA na produção a partir de um fluxo de trabalho do Kubeflow Pipelines. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/kubernetes-sagemaker-components-for-kubeflow-pipelines.html) ## permissões do IAM A implantação do Kubeflow Pipelines com componentes de SageMaker IA requer as três camadas de autenticação a seguir: + Umo perfil do IAM que concede ao seu nó de gateway (que pode ser sua máquina local ou uma instância remota) acesso ao cluster do Amazon Elastic Kubernetes Service (Amazon EKS). O usuário que acessa o nó do gateway assume essa função para: + Crie um cluster do Amazon EKS e instale o KFP + Criar perfil do IAM + Crie buckets do Amazon S3 para seus dados de entrada de amostra A função requer as seguintes permissões: + CloudWatchLogsFullAccess + [https://console.aws.amazon.com/iam/home?region=us-east-1#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAWSCloudFormationFullAccess](https://console.aws.amazon.com/iam/home?region=us-east-1#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAWSCloudFormationFullAccess) + IAMFullAcesso + Amazon S3 FullAccess + Amazon EC2 FullAccess + EKSAdminPolítica da Amazon (crie essa política usando o esquema dos exemplos de políticas [baseadas em identidade do Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/security_iam_id-based-policy-examples.html)) + Uma função de execução do Kubernetes IAM assumida pelos pods de pipeline do Kubernetes (**kfp-example-pod-role**) ou pelo pod controlador SageMaker AI Operator for Kubernetes para acessar a IA. SageMaker Essa função é usada para criar e monitorar trabalhos de SageMaker IA do Kubernetes. A função requer as seguintes permissões: + AmazonSageMakerFullAccess Você pode limitar as permissões para os pods do KFP e do controlador criando e anexando sua própria política personalizada. + **Uma função de execução do SageMaker AI IAM assumida por trabalhos de SageMaker IA para acessar AWS recursos como Amazon S3 ou Amazon ECR (kfp-example-sagemaker-execution-role).** SageMaker Os trabalhos de IA usam essa função para: + Acesse recursos de SageMaker IA + Obter dados de entrada do Amazon S3. + Armazenar seu modelo de saída no Amazon S3. A função requer as seguintes permissões: + AmazonSageMakerFullAccess + Amazon S3 FullAccess ## Conversão de pipelines para usar IA SageMaker Você pode converter um pipeline existente para usar a SageMaker IA portando seus contêineres genéricos de [processamento e contêineres de](https://docs.aws.amazon.com/sagemaker/latest/dg/amazon-sagemaker-containers.html) [treinamento](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo.html) do Python. Se você estiver usando SageMaker IA para inferência, também precisará anexar permissões do IAM ao seu cluster e converter um artefato em um modelo. # Instalar Pipelines do Kubeflow [O Kubeflow Pipelines (KFP)](https://www.kubeflow.org/docs/components/pipelines/v2/introduction/) é o componente de orquestração de pipeline do Kubeflow. Você pode implantar o Kubeflow Pipelines (KFP) em um Amazon Elastic Kubernetes Service (Amazon EKS) existente ou criar um novo cluster do Amazon EKS. Use um nó de gateway para interagir com seu cluster. O nó do gateway pode ser sua máquina local ou uma instância do Amazon EC2. A seção a seguir orienta você pelas etapas de instalação e configuração desses recursos. **Topics** + [Escolha uma opção de instalação](#choose-install-option) + [Configure suas permissões de pipeline para acessar a SageMaker IA](#configure-permissions-for-pipeline) + [Acesse a interface do usuário do KFP (painel do Kubeflow)](#access-the-kfp-ui) ## Escolha uma opção de instalação O Kubeflow Pipelines está disponível como um componente principal da distribuição completa do Kubeflow em AWS ou como uma instalação independente. Selecione a opção que se aplica ao seu caso de uso: 1. [Kubeflow completo na implantação AWS](#full-kubeflow-deployment) Para usar outros componentes do Kubeflow além dos Pipelines do Kubeflow, escolha a [distribuição completa AWS da implantação do Kubeflow](https://awslabs.github.io/kubeflow-manifests). 1. [Implantação autônoma do Kubeflow Pipelines](#kubeflow-pipelines-standalone) Para usar os pipelines do Kubeflow sem os outros componentes do Kubeflow, instale os pipelines do Kubeflow de forma independente. ### Kubeflow completo na implantação AWS Para instalar a versão completa do Kubeflow on AWS, escolha a opção de implantação básica no [guia de implantação do Kubeflow on ou qualquer outra opção de AWS implantação](https://awslabs.github.io/kubeflow-manifests/docs/deployment/) que ofereça suporte a integrações com vários serviços ( AWS Amazon S3, Amazon RDS, Amazon Cognito). ### Implantação autônoma do Kubeflow Pipelines Esta seção pressupõe que seu usuário tenha permissões para criar funções e definir políticas para a função. #### Configurar um nó de gateway Você pode usar sua máquina local ou uma instância do Amazon EC2 como seu nó de gateway. Um nó de gateway é usado para criar um cluster do Amazon EKS e acessar a interface do usuário do Kubeflow Pipelines. Concluir as etapas a seguir para configurar seu nó. 1. **Criar um nó de gateway.** Você pode usar uma instância existente do Amazon EC2 ou criar uma nova instância com a versão mais recente da DLAMI do Ubuntu 18.04 usando as etapas em [Iniciar e configurar uma DLAMI](https://docs.aws.amazon.com/dlami/latest/devguide/launch-config.html). 1. **Crie uma função do IAM para conceder acesso aos AWS recursos do nó do gateway.** Crie uma função do IAM com permissões para os seguintes recursos: CloudWatch,, IAM CloudFormation, Amazon EC2, Amazon S3, Amazon EKS. Anexe as políticas a seguir à perfil do IAM: + CloudWatchLogsFullAccess + [https://console.aws.amazon.com/iam/home?region=us-east-1#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAWSCloudFormationFullAccess](https://console.aws.amazon.com/iam/home?region=us-east-1#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAWSCloudFormationFullAccess) + IAMFullAcesso + Amazon S3 FullAccess + Amazon EC2 FullAccess + EKSAdminPolítica da Amazon (crie essa política usando o esquema dos exemplos de políticas [baseadas em identidade do Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/security_iam_id-based-policy-examples.html)) Para obter informações sobre como adicionar Permissões do IAM a um perfil do IAM consulte [Adicionando e removendo permissões de identidade do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html). 1. **Instale as seguintes ferramentas e clientes** Instale e configure as seguintes ferramentas e recursos em seu nó de gateway para acessar o cluster do Amazon EKS e a interface de usuário (UI) do KFP: + [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html): A ferramenta de linha de comando para trabalhar com AWS serviços. Para obter informações de AWS CLI configuração, consulte [Configurando o AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html). + [aws-iam-authenticator](https://docs.aws.amazon.com/eks/latest/userguide/install-aws-iam-authenticator.html)versão 0.1.31 e superior: uma ferramenta para usar credenciais AWS do IAM para se autenticar em um cluster Kubernetes. + A versão [https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html) acima de 0,15: a ferramenta de linha de comando para trabalhar com clusters do Amazon EKS. + [https://kubernetes.io/docs/tasks/tools/install-kubectl/#install-kubectl](https://kubernetes.io/docs/tasks/tools/install-kubectl/#install-kubectl): a ferramenta de linha de comando para trabalhar com clusters do Kubernetes. A versão precisa corresponder à sua versão do Kubernetes em uma versão secundária. + [https://aws.amazon.com/sdk-for-python/](https://aws.amazon.com/sdk-for-python/). ``` pip install boto3 ``` #### Configuração de um cluster do Amazon EKS 1. Se você não tiver um cluster do Amazon EKS existente, execute as seguintes etapas na linha de comando do seu nó de gateway; caso contrário, pule essa etapa: 1. Execute o comando a seguir para criar um cluster do Amazon EKS com a versão 1.17 ou superior. Substitua `` por qualquer nome para seu cluster. ``` eksctl create cluster --name --region us-east-1 --auto-kubeconfig --timeout=50m --managed --nodes=1 ``` 1. Quando a criação do cluster estiver concluída, certifique-se de ter acesso ao seu cluster listando os nós do cluster. ``` kubectl get nodes ``` 1. Certifique-se de que o `kubectl` contexto atual aponte para seu cluster com o seguinte comando: O contexto atual é marcado com um asterisco (\$1) na saída. ``` kubectl config get-contexts CURRENT NAME CLUSTER * @.us-east-1.eksctl.io .us-east-1.eksctl.io ``` 1. Se o cluster desejado não estiver configurado como padrão atual, atualize o padrão com o comando a seguir. ``` aws eks update-kubeconfig --name --region us-east-1 ``` #### Instalar Pipelines do Kubeflow Execute as etapas a seguir no terminal do seu nó de gateway para instalar o Kubeflow Pipelines em seu cluster. 1. Instale todos os [componentes do cert-manager](https://cert-manager.io/docs/installation/kubectl/). ``` kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.9.1/cert-manager.yaml ``` 1. Instale os pipelines do Kubeflow. ``` export PIPELINE_VERSION=2.0.0-alpha.5 kubectl apply -k "github.com/kubeflow/pipelines/manifests/kustomize/env/cert-manager/cluster-scoped-resources?ref=$KFP_VERSION" kubectl wait --for condition=established --timeout=60s crd/applications.app.k8s.io kubectl apply -k "github.com/kubeflow/pipelines/manifests/kustomize/env/cert-manager/dev?ref=$KFP_VERSION" ``` 1. Certifique-se de que o serviço Kubeflow Pipelines e outros recursos relacionados estejam em execução. ``` kubectl -n kubeflow get all | grep pipeline ``` A saída será semelhante à seguinte: ``` pod/ml-pipeline-6b88c67994-kdtjv                      1/1     Running            0          2d pod/ml-pipeline-persistenceagent-64d74dfdbf-66stk     1/1     Running            0          2d pod/ml-pipeline-scheduledworkflow-65bdf46db7-5x9qj    1/1     Running            0          2d pod/ml-pipeline-ui-66cc4cffb6-cmsdb                   1/1     Running            0          2d pod/ml-pipeline-viewer-crd-6db65ccc4-wqlzj            1/1     Running            0          2d pod/ml-pipeline-visualizationserver-9c47576f4-bqmx4   1/1     Running            0          2d service/ml-pipeline                       ClusterIP   10.100.170.170          8888/TCP,8887/TCP   2d service/ml-pipeline-ui                    ClusterIP   10.100.38.71            80/TCP              2d service/ml-pipeline-visualizationserver   ClusterIP   10.100.61.47            8888/TCP            2d deployment.apps/ml-pipeline                       1/1     1            1           2d deployment.apps/ml-pipeline-persistenceagent      1/1     1            1           2d deployment.apps/ml-pipeline-scheduledworkflow     1/1     1            1           2d deployment.apps/ml-pipeline-ui                    1/1     1            1           2d deployment.apps/ml-pipeline-viewer-crd            1/1     1            1           2d deployment.apps/ml-pipeline-visualizationserver   1/1     1            1           2d replicaset.apps/ml-pipeline-6b88c67994                      1         1         1       2d replicaset.apps/ml-pipeline-persistenceagent-64d74dfdbf     1         1         1       2d replicaset.apps/ml-pipeline-scheduledworkflow-65bdf46db7    1         1         1       2d replicaset.apps/ml-pipeline-ui-66cc4cffb6                   1         1         1       2d replicaset.apps/ml-pipeline-viewer-crd-6db65ccc4            1         1         1       2d replicaset.apps/ml-pipeline-visualizationserver-9c47576f4   1         1         1       2d ``` ## Configure suas permissões de pipeline para acessar a SageMaker IA Nesta seção, você cria uma função de execução do IAM que concede aos pods do Kubeflow Pipeline acesso aos serviços de IA. SageMaker ### Configuração para componentes de SageMaker IA versão 2 Para executar o SageMaker AI Components versão 2 para o Kubeflow Pipelines, você precisa instalar o [SageMaker AI Operator for Kubernetes](https://github.com/aws-controllers-k8s/sagemaker-controller) e configurar o Role-Based Access Control (RBAC), permitindo que os pods do Kubeflow Pipelines criem recursos personalizados de IA em seu cluster Kubernetes. SageMaker **Importante** Siga esta seção se você estiver usando a implantação autônoma do Kubeflow pipelines. Se você estiver usando a AWS distribuição do Kubeflow versão 1.6.0-aws-b1.0.0 ou superior, os componentes de IA versão 2 já estão configurados SageMaker . 1. Instale o SageMaker AI Operator for Kubernetes para usar os componentes de SageMaker IA versão 2. Siga a seção *Configuração* do [tutorial Machine Learning with ACK SageMaker AI Controller](https://aws-controllers-k8s.github.io/community/docs/tutorials/sagemaker-example/#setup). 1. Configure as permissões do RBAC para a função de execução (conta de serviço) usada pelos pods do Kubeflow Pipelines. Na implantação autônoma do Kubeflow Pipelines, as execuções do pipeline são executadas no namespace `kubeflow` usando a conta de serviço `pipeline-runner`. 1. Crie um [RoleBinding](https://kubernetes.io/docs/reference/access-authn-authz/rbac/#rolebinding-example)que dê permissão à conta de serviço para gerenciar recursos personalizados de SageMaker IA. ``` cat > manage_sagemaker_cr.yaml < Para executar a versão 1 do SageMaker AI Components para o Kubeflow Pipelines, os pods do Kubeflow Pipeline precisam acessar a IA. SageMaker **Importante** Siga esta seção se você estiver usando o Kubeflow completo na AWS implantação ou o Kubeflow Pilepines autônomo. Para criar uma função de execução do IAM que conceda aos pods do pipeline Kubeflow acesso à SageMaker IA, siga estas etapas: 1. Exporte o nome do cluster (por exemplo, *my-cluster-name*) e a região do cluster (por exemplo, *us-east-1*). ``` export CLUSTER_NAME=my-cluster-name export CLUSTER_REGION=us-east-1 ``` 1. Exporte o namespace e o nome da conta de serviço de acordo com sua instalação. + Para obter o Kubeflow completo na AWS instalação, exporte seu perfil `namespace` (por exemplo, *kubeflow-user-example-com*) e o *editor padrão como a conta de serviço*. ``` export NAMESPACE=kubeflow-user-example-com export KUBEFLOW_PIPELINE_POD_SERVICE_ACCOUNT=default-editor ``` + Para a implantação autônoma do Pipelines, exporte o *kubeflow* como a `namespace` e o *pipeline-runner* como a conta de serviço. ``` export NAMESPACE=kubeflow export KUBEFLOW_PIPELINE_POD_SERVICE_ACCOUNT=pipeline-runner ``` 1. Criar um o provedor [IAM OIDC para o cluster do Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) com o comando a seguir. ``` eksctl utils associate-iam-oidc-provider --cluster ${CLUSTER_NAME} \ --region ${CLUSTER_REGION} --approve ``` 1. Crie uma função de execução do IAM para que os pods do KFP acessem os AWS serviços (SageMaker AI,). CloudWatch ``` eksctl create iamserviceaccount \ --name ${KUBEFLOW_PIPELINE_POD_SERVICE_ACCOUNT} \ --namespace ${NAMESPACE} --cluster ${CLUSTER_NAME} \ --region ${CLUSTER_REGION} \ --attach-policy-arn arn:aws:iam::aws:policy/AmazonSageMakerFullAccess \ --attach-policy-arn arn:aws:iam::aws:policy/CloudWatchLogsFullAccess \ --override-existing-serviceaccounts \ --approve ``` Depois que suas permissões de pipeline estiverem configuradas para acessar a versão 1 dos componentes de SageMaker IA, siga o guia de componentes de SageMaker IA para pipelines do Kubeflow na documentação do [Kubeflow](https://awslabs.github.io/kubeflow-manifests/docs/amazon-sagemaker-integration/sagemaker-components-for-kubeflow-pipelines/) on. AWS ## Acesse a interface do usuário do KFP (painel do Kubeflow) A interface do usuário do Kubeflow Pipelines é usada para gerenciar e monitorar experimentos, trabalhos e execuções em seu cluster. Para obter instruções sobre como acessar a interface do usuário do Kubeflow Pipelines a partir do nó do gateway, siga as etapas que se aplicam à sua opção de implantação nesta seção. ### Kubeflow completo na implantação AWS Siga as instruções no [AWS site do Kubeflow on](https://awslabs.github.io/kubeflow-manifests/docs/deployment/connect-kubeflow-dashboard/) para se conectar ao painel do Kubeflow e navegar até a guia Pipelines. ### Implantação autônoma do Kubeflow Pipelines Use o encaminhamento de portas para acessar a interface do usuário do Kubeflow Pipelines a partir do nó do gateway seguindo essas etapas. #### Configurar o encaminhamento de portas para o serviço KFP UI Execute o comando a seguir na linha de comando do nó do gateway. 1. Verifique que o serviço KFP UI está em execução usando o comando a seguir. ``` kubectl -n kubeflow get service ml-pipeline-ui NAME             TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)   AGE ml-pipeline-ui   ClusterIP   10.100.38.71          80/TCP    2d22h ``` 1. Execute o comando a seguir para configurar o encaminhamento de portas para o serviço de interface do KFP. Isso encaminha a interface do usuário do KFP para a porta 8080 no nó do gateway e permite que você acesse a interface do KFP a partir do seu navegador. ``` kubectl port-forward -n kubeflow service/ml-pipeline-ui 8080:80 ``` A porta de encaminhamento da sua máquina remota é interrompida se não houver atividade. Execute esse comando novamente se o painel não conseguir obter logs ou atualizações. Se os comandos retornarem um erro, verifique se não há nenhum processo em execução na porta que você está tentando usar. #### Acesse o serviço KFP UI Seu método de acessar a interface do usuário do KFP depende do tipo de nó do gateway. + Máquina local como nó do gateway: 1. Acesse o painel em seu navegador da seguinte forma: ``` http://localhost:8080 ``` 1. Escolha **Pipelines** para acessar a interface do usuário dos pipelines. + Instância do Amazon EC2 como nó do gateway: 1. Você precisa configurar um túnel SSH na sua instância do Amazon EC2 para acessar o painel do Kubeflow a partir do navegador da sua máquina local. Em uma nova sessão de terminal em sua máquina local, execute o seguinte: Substitua `` pelo endereço IP da sua instância encontrado no console do Amazon EC2. Você também pode usar o DNS público. Substitua `` pelo caminho para a chave pem usada para acessar o nó do gateway. ``` public_DNS_address= key= on Ubuntu: ssh -i ${key} -L 9000:localhost:8080 ubuntu@${public_DNS_address} or on Amazon Linux: ssh -i ${key} -L 9000:localhost:8080 ec2-user@${public_DNS_address} ``` 1. Acesse o painel no seu navegador. ``` http://localhost:9000 ``` 1. Escolha **Pipelines** para acessar a interface do usuário do KFP. #### (Opcional) Conceda às instâncias de notebook de SageMaker IA acesso ao Amazon EKS e execute pipelines do KFP a partir do seu notebook. Uma instância de SageMaker notebook é uma instância computacional totalmente gerenciada do Amazon EC2 que executa o aplicativo Jupyter Notebook. Você pode usar uma instância de caderno para criar e gerenciar cadernos Jupyter e, em seguida, definir, compilar, implantar e executar seus pipelines do KFP usando ou a CLI do KFP AWS SDK para Python (Boto3) . 1. Siga as etapas em [Criar uma instância de SageMaker notebook para criar sua instância](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-setup-working-env.html) de notebook e, em seguida, anexe a `S3FullAccess` política à função de execução do IAM. 1. Na linha de comando do seu nó do gateway, execute o comando a seguir para recuperar o ARN da função IAM da instância do caderno que você criou. Substitua `` pelo nome da sua instância. ``` aws sagemaker describe-notebook-instance --notebook-instance-name --region --output text --query 'RoleArn' ``` Esse comando gera o ARN do perfil do IAM no `arn:aws:iam:::role/` formato. Anote este ARN. 1. Execute esse comando para anexar as seguintes políticas (Amazon AmazonSageMakerFullAccess EKSWorkerNodePolicy, AmazonS3FullAccess) a essa função do IAM. Substitua `` com `` em seu ARN. ``` aws iam attach-role-policy --role-name --policy-arn arn:aws:iam::aws:policy/AmazonSageMakerFullAccess aws iam attach-role-policy --role-name --policy-arn arn:aws:iam::aws:policy/AmazonEKSWorkerNodePolicy aws iam attach-role-policy --role-name --policy-arn arn:aws:iam::aws:policy/AmazonS3FullAccess ``` 1. Os clusters do Amazon EKS usam funções do IAM para controlar o acesso ao cluster. As regras são implementadas em um mapa de configuração chamado `aws-auth`. `eksctl` fornece comandos para ler e editar o mapa de configuração `aws-auth`. Somente os usuários que têm acesso ao cluster podem editar esse mapa de configuração. `system:masters`é um dos grupos de usuários padrão com permissões de superusuário no cluster. Adicione seu usuário a esse grupo ou crie um grupo com permissões mais restritivas. 1. Vincule a função ao seu cluster executando o comando a seguir. Substituir `` pelo ARN da perfil do IAM. `` pode ser qualquer nome de usuário exclusivo. ``` eksctl create iamidentitymapping \ --cluster \ --arn \ --group system:masters \ --username \ --region ``` 1. Abra um notebook Jupyter na sua instância de SageMaker IA e execute o comando a seguir para garantir que ele tenha acesso ao cluster. ``` aws eks --region update-kubeconfig --name kubectl -n kubeflow get all | grep pipeline ``` # Use componentes de SageMaker IA Neste tutorial, você executa um pipeline usando componentes de SageMaker IA para pipelines do Kubeflow para treinar um modelo de classificação usando o Kmeans com o conjunto de dados MNIST em IA. SageMaker O fluxo de trabalho usa o Kubeflow Pipelines como orquestrador e SageMaker IA para executar cada etapa do fluxo de trabalho. O exemplo foi retirado de um [exemplo de SageMaker IA](https://github.com/aws/amazon-sagemaker-examples/blob/8279abfcc78bad091608a4a7135e50a0bd0ec8bb/sagemaker-python-sdk/1P_kmeans_highlevel/kmeans_mnist.ipynb) existente e modificado para funcionar com componentes de SageMaker IA para pipelines do Kubeflow. Você pode definir seu pipeline em Python usando o painel do KFP AWS SDK para Python (Boto3) , a CLI do KFP ou o Boto3 para compilar, implantar e executar seus fluxos de trabalho. O código completo do exemplo do pipeline de classificação MNIST está disponível no repositório [Kubeflow](https://github.com/kubeflow/pipelines/tree/master/samples/contrib/aws-samples/mnist-kmeans-sagemaker#mnist-classification-with-kmeans) Github. Para usá-lo, clone os arquivos Python no nó do gateway. Você pode encontrar exemplos adicionais de [ SageMaker AI Kubeflow Pipelines](https://github.com/kubeflow/pipelines/tree/master/samples/contrib/aws-samples) em. GitHub Para obter informações sobre os componentes usados, consulte o [ GitHub repositório KubeFlow Pipelines](https://github.com/kubeflow/pipelines/tree/master/components/aws/sagemaker). Para executar o exemplo do pipeline de classificação, crie uma função de execução do SageMaker AI IAM concedendo ao seu trabalho de treinamento a permissão para acessar AWS recursos e continue com as etapas que correspondem à sua opção de implantação. ## Crie uma função de execução de SageMaker IA A função `kfp-example-sagemaker-execution-role` do IAM é uma função de tempo de execução assumida pelos trabalhos de SageMaker IA para acessar AWS recursos. No comando a seguir, você cria uma função de execução do IAM chamada`kfp-example-sagemaker-execution-role`, anexa duas políticas gerenciadas (AmazonSageMakerFullAccess, AmazonS3FullAccess) e cria uma relação de confiança com a SageMaker IA para conceder aos trabalhos de SageMaker IA acesso a esses recursos. AWS Você fornece essa função como um parâmetro de entrada ao executar o pipeline. Execute o comando da a seguir para criar a função. Anote o ID do ARN retornado na saída. ``` SAGEMAKER_EXECUTION_ROLE_NAME=kfp-example-sagemaker-execution-role TRUST="{ \"Version\": \"2012-10-17 \", \"Statement\": [ { \"Effect\": \"Allow\", \"Principal\": { \"Service\": \"sagemaker.amazonaws.com\" }, \"Action\": \"sts:AssumeRole\" } ] }" aws iam create-role --role-name ${SAGEMAKER_EXECUTION_ROLE_NAME} --assume-role-policy-document "$TRUST" aws iam attach-role-policy --role-name ${SAGEMAKER_EXECUTION_ROLE_NAME} --policy-arn arn:aws:iam::aws:policy/AmazonSageMakerFullAccess aws iam attach-role-policy --role-name ${SAGEMAKER_EXECUTION_ROLE_NAME} --policy-arn arn:aws:iam::aws:policy/AmazonS3FullAccess aws iam get-role --role-name ${SAGEMAKER_EXECUTION_ROLE_NAME} --output text --query 'Role.Arn' ``` ## Kubeflow completo na implantação AWS Siga as instruções do [tutorial do SageMaker Training Pipeline para classificação MNIST com K-Means](https://awslabs.github.io/kubeflow-manifests/docs/amazon-sagemaker-integration/sagemaker-components-for-kubeflow-pipelines/). ## Implantação autônoma do Kubeflow Pipelines ### Preparar conjuntos de dados Para executar os pipelines, você precisa fazer upload do script de pré-processamento da extração de dados em um bucket do Amazon S3. Esse bucket e todos os recursos desse exemplo devem estar localizados na `us-east-1` região. Para obter informações sobre como criar um bucket, consulte [Criar um bucket](https://docs.aws.amazon.com/AmazonS3/latest/gsg/CreatingABucket.html). Na `mnist-kmeans-sagemaker` pasta do repositório Kubeflow que você clonou no nó do gateway, execute o comando a seguir para fazer o upload do `kmeans_preprocessing.py` arquivo no bucket do Amazon S3. Altere `` para o nome do bucket do Amazon S3. ``` aws s3 cp mnist-kmeans-sagemaker/kmeans_preprocessing.py s3:///mnist_kmeans_example/processing_code/kmeans_preprocessing.py ``` ### Compile e implante seu pipeline Depois de definir o pipeline, você deve compilá-lo em uma representação intermediária antes de enviá-lo ao serviço Kubeflow Pipelines em seu cluster. A representação intermediária é uma especificação de fluxo de trabalho na forma de um arquivo YAML compactado em um arquivo tar.gz. Você precisa do SDK do KFP para compilar seu pipeline. #### Instalar o SDK do KFP Execute o seguinte na linha de comando do seu nó de gateway: 1. Instale o SDK do KFP seguindo as instruções na documentação dos pipelines do [Kubeflow](https://www.kubeflow.org/docs/pipelines/sdk/install-sdk/). 1. Verifique se o SDK do KFP está instalado com o seguinte comando: ``` pip show kfp ``` 1. Verifique se `dsl-compile` foi instalado corretamente da seguinte forma: ``` which dsl-compile ``` #### Compilar seu pipeline Você tem três opções para interagir com o Kubeflow Pipelines: KFP UI, KFP CLI ou KFP SDK. As seções a seguir ilustram o fluxo de trabalho usando a interface de usuário e a CLI do KFP. Concluir as etapas a seguir no nó do gateway. 1. Modifique seu arquivo Python com o nome do bucket do Amazon S3 e o ARN da perfil do IAM. 1. Use o comando `dsl-compile` da linha de comando para compilar seu pipeline da seguinte maneira: Substitua `` pelo caminho para seu pipeline e `` pelo local em que você deseja que seu arquivo tar.gz esteja. ``` dsl-compile --py --output ``` #### Carregue e execute o pipeline usando a CLI do KFP Conclua as etapas a seguir na linha de comando do seu nó do gateway. O KFP organiza as execuções do seu pipeline como experimentos. Você tem a opção de especificar o nome do experimento. Se você não especificar uma, a execução será listada em Experimento **padrão**. 1. Faça o upload do seu pipeline da seguinte forma: ``` kfp pipeline upload --pipeline-name ``` A saída será semelhante à seguinte: Anote o pipeline `ID`. ``` Pipeline 29c3ff21-49f5-4dfe-94f6-618c0e2420fe has been submitted Pipeline Details ------------------ ID           29c3ff21-49f5-4dfe-94f6-618c0e2420fe Name         sm-pipeline Description Uploaded at  2020-04-30T20:22:39+00:00 ... ... ``` 1. Criar uma execução usando o comando a seguir. Atualmente, o comando de execução da CLI do KFP não é compatível com a especificação de parâmetros de entrada ao criar a execução. Você precisa atualizar seus parâmetros no arquivo do AWS SDK para Python (Boto3) pipeline antes de compilar. Substitua `` e `` por qualquer nome. Substitua `` pelo ID do pipeline enviado. Substitua `` pelo ARN de `kfp-example-pod-role`. Substitua `` pelo nome do bucket do Amazon S3 que você criou. ``` kfp run submit --experiment-name --run-name --pipeline-id role_arn="" bucket_name="" ``` Você também pode enviar diretamente uma execução usando o pacote de pipeline compilado criado como saída do comando `dsl-compile`. ``` kfp run submit --experiment-name --run-name --package-file role_arn="" bucket_name="" ``` A saída será semelhante a: ``` Creating experiment aws. Run 95084a2c-f18d-4b77-a9da-eba00bf01e63 is submitted +--------------------------------------+--------+----------+---------------------------+ | run id                               | name   | status   | created at                | +======================================+========+==========+===========================+ | 95084a2c-f18d-4b77-a9da-eba00bf01e63 | sm-job |          | 2020-04-30T20:36:41+00:00 | +--------------------------------------+--------+----------+---------------------------+ ``` 1. Navegue até a interface do usuário para verificar o progresso do trabalho. #### Faça o upload e execute o pipeline usando a interface do usuário do KFP 1. No painel à esquerda, selecione a guia **Pipelines**. 1. **No canto superior direito, escolha \$1. UploadPipeline** 1. Inserir um nome descrição de pipeline. 1. Escolha **Fazer upload de um arquivo** e insira o caminho para o arquivo tar.gz que você criou usando a CLI ou com AWS SDK para Python (Boto3). 1. No painel à esquerda, selecione a guia **Pipelines**. 1. Encontre o pipeline que você criou. 1. Escolha **\$1CreateRun**. 1. Insira seus parâmetros de entrada. 1. Escolha **Executar**. ### Execute predições Depois que seu pipeline de classificação for implantado, você poderá executar predições de classificação em relação ao endpoint criado pelo componente Deploy. Use a interface do usuário do KFP para verificar os artefatos de saída `sagemaker-deploy-model-endpoint_name`. Faça o download do arquivo.tgz para extrair o nome do endpoint ou verifique o console de SageMaker IA na região que você usou. #### Configurar permissões para executar predições Se você quiser executar predições a partir do nó do gateway, pule esta seção. **Para usar qualquer outra máquina para executar predições, atribua a permissão `sagemaker:InvokeEndpoint` ao perfil do IAM usada pela máquina cliente.** 1. No nó do gateway, execute o seguinte para criar um arquivo de política do IAM: ``` cat < ./sagemaker-invoke.json {     "Version": "2012-10-17",     "Statement": [         {             "Effect": "Allow",             "Action": [                 "sagemaker:InvokeEndpoint"             ],             "Resource": "*"         }     ] } EoF ``` 1. Anexe a política ao perfil do IAM do nó do cliente. Execute o seguinte comando: Substitua `` pelo nome da perfil do IAM. Substitua `` pelo caminho para o arquivo de política que você criou. ``` aws iam put-role-policy --role-name --policy-name sagemaker-invoke-for-worker --policy-document file:// ``` #### Execute predições 1. Crie um AWS SDK para Python (Boto3) arquivo da sua máquina cliente chamado `mnist-predictions.py` com o conteúdo a seguir. Substitua a variável `ENDPOINT_NAME`. O script carrega o conjunto de dados MNIST, cria um CSV a partir desses dígitos e, em seguida, envia o CSV ao endpoint para predição e imprime os resultados. ``` import boto3 import gzip import io import json import numpy import pickle ENDPOINT_NAME='' region = boto3.Session().region_name # S3 bucket where the original mnist data is downloaded and stored downloaded_data_bucket = f"jumpstart-cache-prod-{region}" downloaded_data_prefix = "1p-notebooks-datasets/mnist" # Download the dataset s3 = boto3.client("s3") s3.download_file(downloaded_data_bucket, f"{downloaded_data_prefix}/mnist.pkl.gz", "mnist.pkl.gz") # Load the dataset with gzip.open('mnist.pkl.gz', 'rb') as f:     train_set, valid_set, test_set = pickle.load(f, encoding='latin1') # Simple function to create a csv from our numpy array def np2csv(arr):     csv = io.BytesIO()     numpy.savetxt(csv, arr, delimiter=',', fmt='%g')     return csv.getvalue().decode().rstrip() runtime = boto3.Session(region).client('sagemaker-runtime') payload = np2csv(train_set[0][30:31]) response = runtime.invoke_endpoint(EndpointName=ENDPOINT_NAME,                                    ContentType='text/csv',                                    Body=payload) result = json.loads(response['Body'].read().decode()) print(result) ``` 1. Execute o AWS SDK para Python (Boto3) arquivo da seguinte forma: ``` python mnist-predictions.py ``` ### Exibir resultados e logs Quando o pipeline está em execução, você pode escolher qualquer componente para verificar os detalhes da execução, como entradas e saídas. Isso lista os nomes dos recursos criados. Se a solicitação do KFP for processada com sucesso e um trabalho de SageMaker IA for criado, os registros do componente na interface do usuário do KFP fornecerão um link para o trabalho criado no AI. SageMaker Os CloudWatch registros também são fornecidos se o trabalho for criado com sucesso. Se você executar muitos trabalhos de pipeline no mesmo cluster, poderá ver uma mensagem de erro indicando que você não tem pods suficientes disponíveis. Para corrigir isso, faça login no nó do gateway e exclua os pods criados pelos pipelines que você não está usando: ``` kubectl get pods -n kubeflow kubectl delete pods -n kubeflow ``` ### Limpeza Quando você terminar seu pipeline, precisará limpar seus recursos. 1. **No painel do KFP, encerre as execuções do seu pipeline se elas não saírem corretamente, escolhendo Encerrar.** 1. Se a opção **Terminate** não funcionar, faça login no nó do gateway e encerre manualmente todos os pods criados pela execução do pipeline da seguinte maneira: ``` kubectl get pods -n kubeflow kubectl delete pods -n kubeflow ``` 1. Usando sua AWS conta, faça login no serviço de SageMaker IA. Interrompa manualmente todos os trabalhos de treinamento, transformação em lote e HPO. Exclua modelos, buckets de dados e endpoints para evitar custos adicionais. Encerrar as execuções do pipeline não interrompe os trabalhos na SageMaker IA.