Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# SageMaker Componentes de IA para tuberías de Kubeflow
Con los componentes de SageMaker IA para Kubeflow Pipelines, puedes crear y supervisar trabajos nativos de entrenamiento, ajuste, implementación de terminales y transformación por lotes de SageMaker IA desde tus canalizaciones de Kubeflow. Al ejecutar las tareas de Kubeflow Pipeline con SageMaker IA, puedes trasladar las tareas de procesamiento y formación de datos del clúster de Kubernetes al servicio gestionado optimizado para el aprendizaje automático de la IA. SageMaker En este documento se presupone tener conocimientos previos de Kubernetes y Kubeflow.
**Topics**
+ [¿Qué son las canalizaciones de Kubeflow?](#what-is-kubeflow-pipelines)
+ [¿Qué son los componentes de una canalización de Kubeflow?](#kubeflow-pipeline-components)
+ [¿Por qué usar componentes de SageMaker IA para las canalizaciones de Kubeflow?](#why-use-sagemaker-components)
+ [SageMaker Componentes de IA para las versiones de Kubeflow Pipelines](#sagemaker-components-versions)
+ [Lista de componentes de SageMaker IA para las canalizaciones de Kubeflow](#sagemaker-components-list)
+ [Permisos de IAM](#iam-permissions)
+ [Conversión de canalizaciones para usar IA SageMaker](#converting-pipelines-to-use-amazon-sagemaker)
+ [Instalar canalizaciones de Kubeflow](kubernetes-sagemaker-components-install.md)
+ [Usa componentes de IA SageMaker](kubernetes-sagemaker-components-tutorials.md)
## ¿Qué son las canalizaciones de Kubeflow?
Las canalizaciones de Kubeflow (KFP) son una plataforma para crear e implementar flujos de trabajo de machine learning (ML) portátiles y escalables basados en contenedores de Docker. La plataforma de canalizaciones de Kubeflow consta de lo siguiente:
+ Una interfaz de usuario (UI) para administrar y rastrear experimentos, trabajos y ejecuciones.
+ Un motor (Argo) para programar flujos de trabajo de ML de varios pasos.
+ Un SDK para definir y manipular canalizaciones y componentes.
+ Cuadernos para interactuar con el sistema mediante el SDK.
Una canalización es una descripción de un flujo de trabajo de ML que se expresa como un [gráfico acíclico dirigido](https://www.kubeflow.org/docs/pipelines/concepts/graph/). [Cada paso del flujo de trabajo se expresa como un componente de Kubeflow Pipeline, que es un módulo.](https://www.kubeflow.org/docs/pipelines/overview/concepts/component/) AWS SDK para Python (Boto3)
Para obtener más información sobre las canalizaciones de Kubeflow, consulte la [documentación de las canalizaciones de Kubeflow](https://www.kubeflow.org/docs/pipelines/).
## ¿Qué son los componentes de una canalización de Kubeflow?
Un componente de canalización de Kubeflow es un conjunto de códigos que se utiliza para ejecutar un paso de una canalización de Kubeflow. Los componentes se representan mediante un módulo de Python integrado en una imagen de Docker. Cuando se ejecuta la canalización, se crea una instancia del contenedor del componente en uno de los nodos de trabajo del clúster de Kubernetes que ejecuta Kubeflow, y se ejecuta su lógica. Los componentes de la canalización pueden leer las salidas de los componentes anteriores y crear salidas que el siguiente componente de la canalización puede consumir. Estos componentes facilitan y agilizan la creación de canalizaciones para entornos de experimentación y producción sin tener que interactuar con la infraestructura subyacente de Kubernetes.
Puedes usar componentes de SageMaker IA en tu canalización de Kubeflow. En lugar de encapsular la lógica en un contenedor personalizado, basta con cargar los componentes y describir la canalización mediante el SDK de las canalizaciones de Kubeflow. Cuando la canalización se ejecuta, tus instrucciones se traducen en una tarea o implementación de SageMaker IA. A continuación, la carga de trabajo se ejecuta en la infraestructura totalmente gestionada de la SageMaker IA.
## ¿Por qué usar componentes de SageMaker IA para las canalizaciones de Kubeflow?
SageMaker Los componentes de IA para Kubeflow Pipelines ofrecen una alternativa a las tareas que requieren un uso intensivo de cómputo a partir de la IA. SageMaker Los componentes integran la SageMaker IA con la portabilidad y la organización de Kubeflow Pipelines. Con los componentes de SageMaker IA para Kubeflow Pipelines, puedes crear y supervisar tus recursos de SageMaker IA como parte de un flujo de trabajo de Kubeflow Pipelines. Cada uno de los trabajos en proceso se ejecuta con SageMaker IA y no con el clúster local de Kubernetes, lo que te permite aprovechar las principales funciones de la SageMaker IA, como el etiquetado de datos, el ajuste de hiperparámetros a gran escala y los trabajos de formación distribuidos, o el despliegue de modelos escalables y seguros con un solo clic. Los parámetros del trabajo, el estado, los registros y los resultados de la SageMaker IA siguen siendo accesibles desde la interfaz de usuario de Kubeflow Pipelines.
Los componentes de SageMaker IA integran las principales funciones de la SageMaker IA en sus flujos de trabajo de aprendizaje automático, desde la preparación de datos hasta la creación, el entrenamiento y la implementación de modelos de aprendizaje automático. Puede crear una canalización de Kubeflow creada íntegramente con estos componentes o integrar componentes individuales en su flujo de trabajo según sea necesario. Los componentes están disponibles en una o dos versiones. Cada versión de un componente utiliza un backend diferente. Para obtener más información acerca de las versiones, consulte [SageMaker Componentes de IA para las versiones de Kubeflow Pipelines](#sagemaker-components-versions).
El uso de componentes de SageMaker IA para Kubeflow Pipelines no conlleva ningún cargo adicional. Se le cobrará por cualquier recurso de SageMaker IA que utilice a través de estos componentes.
## SageMaker Componentes de IA para las versiones de Kubeflow Pipelines
SageMaker Los componentes de IA para Kubeflow Pipelines vienen en dos versiones. Cada versión utiliza un backend diferente para crear y gestionar los recursos de la IA. SageMaker
+ **[Los componentes de SageMaker IA de la versión 1 de Kubeflow Pipelines (v1.x o inferior) utilizan Boto3 () como backend.](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html)**AWS SDK para Python (Boto3)
+ [La versión 2 (v2.0.0-alpha2 y versiones posteriores) de AI Components for Kubeflow Pipelines utiliza SageMaker AI Operator for Kubernetes (ACK). SageMaker ](https://github.com/aws-controllers-k8s/sagemaker-controller)
AWS [introdujo ACK para facilitar una forma nativa de Kubernetes de gestionar los recursos de la nube.](https://aws-controllers-k8s.github.io/community/) AWS ACK incluye un conjunto de controladores AWS específicos para cada servicio, uno de los cuales es el controlador de IA. SageMaker El controlador de SageMaker IA facilita que los desarrolladores de aprendizaje automático y los científicos de datos utilicen Kubernetes como plano de control para entrenar, ajustar e implementar modelos de aprendizaje automático (ML) en la IA. SageMaker Para obtener más información, consulte Operadores de [SageMaker IA](https://aws-controllers-k8s.github.io/community/docs/tutorials/sagemaker-example/) para Kubernetes
Se admiten ambas versiones de los componentes de SageMaker IA para Kubeflow Pipelines. Sin embargo, la versión 2 ofrece algunas ventajas adicionales. En concreto, ofrece:
1. Una experiencia coherente para gestionar tus recursos de SageMaker IA desde cualquier aplicación, ya sea que utilices canalizaciones de Kubeflow o la CLI (`kubectl`) de Kubernetes u otras aplicaciones de Kubeflow, como Notebooks.
1. La flexibilidad necesaria para gestionar y supervisar tus SageMaker recursos de IA fuera del flujo de trabajo de Kubeflow Pipeline.
1. No tendrás tiempo de configuración para usar los componentes de SageMaker IA si implementaste el [Kubeflow completo en](https://awslabs.github.io/kubeflow-manifests/docs/about/) el momento del AWS lanzamiento, ya que el Operador de SageMaker IA forma parte de su despliegue.
## Lista de componentes de SageMaker IA para las canalizaciones de Kubeflow
La siguiente es una lista de todos los componentes de SageMaker IA para Kubeflow Pipelines y sus versiones disponibles. También puedes encontrar todos los [componentes de SageMaker IA para Kubeflow](https://github.com/kubeflow/pipelines/tree/master/components/aws/sagemaker#versioning) Pipelines en. GitHub
**nota**
Recomendamos a los usuarios que utilicen la versión 2 de un componente de SageMaker IA siempre que esté disponible.
### Componentes Ground Truth
+ **Ground Truth**
El componente Ground Truth le permite enviar trabajos de etiquetado de SageMaker AI Ground Truth directamente desde un flujo de trabajo de Kubeflow Pipelines.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/kubernetes-sagemaker-components-for-kubeflow-pipelines.html)
+ **Workteam**
El componente Workteam te permite crear trabajos de SageMaker IA para equipos de trabajo privados directamente desde un flujo de trabajo de Kubeflow Pipelines.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/kubernetes-sagemaker-components-for-kubeflow-pipelines.html)
### Componentes de procesamiento de datos
+ **Procesando**
El componente de procesamiento te permite enviar trabajos de procesamiento a SageMaker AI directamente desde un flujo de trabajo de Kubeflow Pipelines.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/kubernetes-sagemaker-components-for-kubeflow-pipelines.html)
### Componentes de entrenamiento
+ **Entrenamiento**
El componente de formación te permite enviar trabajos de SageMaker formación directamente desde un flujo de trabajo de Kubeflow Pipelines.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/kubernetes-sagemaker-components-for-kubeflow-pipelines.html)
+ **Optimización de hiperparámetros**
El componente de optimización de hiperparámetros te permite enviar trabajos de ajuste de hiperparámetros a SageMaker AI directamente desde un flujo de trabajo de Kubeflow Pipelines.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/kubernetes-sagemaker-components-for-kubeflow-pipelines.html)
### Componentes de inferencias
+ **Implementación de alojamiento**
Los componentes de alojamiento permiten implementar un modelo mediante servicios de alojamiento de SageMaker IA desde un flujo de trabajo de Kubeflow Pipelines.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/kubernetes-sagemaker-components-for-kubeflow-pipelines.html)
+ **Transformación por lotes**
El componente Batch Transform te permite ejecutar trabajos de inferencia para un conjunto de datos completo en SageMaker IA desde un flujo de trabajo de Kubeflow Pipelines.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/kubernetes-sagemaker-components-for-kubeflow-pipelines.html)
+ **Monitor de modelos**
Los componentes de Model Monitor le permiten monitorear la calidad de los modelos de aprendizaje automático de SageMaker IA en producción a partir de un flujo de trabajo de Kubeflow Pipelines.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/kubernetes-sagemaker-components-for-kubeflow-pipelines.html)
## Permisos de IAM
La implementación de Kubeflow Pipelines con componentes de SageMaker IA requiere los siguientes tres niveles de autenticación:
+ Un rol de IAM que otorga a su nodo de puerta de enlace (que puede ser su equipo local o una instancia remota) acceso al clúster de Amazon Elastic Kubernetes Service (Amazon EKS).
El usuario que accede al nodo de puerta de enlace asume este rol para:
+ Crear un clúster de Amazon EKS e instalar KFP.
+ Crear roles de IAM.
+ Crear buckets de Amazon S3 para sus datos de entrada de muestra.
El rol requiere los siguientes permisos:
+ 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)
+ IAMFullAcceso
+ Amazon S3 FullAccess
+ Amazon EC2 FullAccess
+ EKSAdminPolítica de Amazon (cree esta política con el esquema de los ejemplos de [políticas basadas en la identidad de Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/security_iam_id-based-policy-examples.html))
+ Una función de ejecución de la IAM de Kubernetes asumida por los módulos de canalización de Kubernetes (**kfp-example-pod-role**) o el operador de IA para el pod de controladores de Kubernetes para acceder a la SageMaker IA. SageMaker Esta función se utiliza para crear y supervisar trabajos de IA desde Kubernetes. SageMaker
El rol requiere el siguiente permiso:
+ AmazonSageMakerFullAccess
Puede limitar los permisos a los pods de control y KFP creando y asociando su propia política personalizada.
+ Una función de ejecución de IAM de SageMaker IA que asumen los trabajos de SageMaker IA para acceder a AWS recursos como Amazon S3 o Amazon ECR (**kfp-example-sagemaker-execution-role**).
SageMaker Los trabajos de IA utilizan esta función para:
+ Acceda a los recursos de SageMaker IA
+ Ingresar datos desde Amazon S3.
+ Guardar su modelo de salida en Amazon S3.
El rol requiere los siguientes permisos:
+ AmazonSageMakerFullAccess
+ Amazon S3 FullAccess
## Conversión de canalizaciones para usar IA SageMaker
Para convertir una canalización existente para usar SageMaker IA, puedes portar tus contenedores genéricos de [procesamiento de Python y contenedores](https://docs.aws.amazon.com/sagemaker/latest/dg/amazon-sagemaker-containers.html) [de entrenamiento](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo.html). Si utilizas la SageMaker IA para realizar inferencias, también debes adjuntar los permisos de IAM a tu clúster y convertir un artefacto en un modelo.
# Instalar canalizaciones de Kubeflow
Las [canalizaciones de Kubeflow (KFP)](https://www.kubeflow.org/docs/components/pipelines/v2/introduction/) son el componente de orquestación de las canalizaciones de Kubeflow.
Puede implementar las canalizaciones de Kubeflow (KFP) en un Amazon Elastic Kubernetes Service (Amazon EKS) existente o crear un nuevo clúster de Amazon EKS. Utilice un nodo de puerta de enlace para interactuar con el clúster. El nodo de puerta de enlace puede ser su equipo local o una instancia de Amazon EC2.
En la siguiente sección, se explican los pasos necesarios para instalar y configurar estos recursos.
**Topics**
+ [Elegir una opción de instalación](#choose-install-option)
+ [Configura los permisos de tu canalización para acceder a la IA SageMaker](#configure-permissions-for-pipeline)
+ [Acceder a la interfaz de usuario de KFP (panel de Kubeflow)](#access-the-kfp-ui)
## Elegir una opción de instalación
Kubeflow Pipelines está disponible como un componente principal de la distribución completa de Kubeflow en una instalación independiente o como una instalación independiente. AWS
Seleccione la opción que se aplique a su caso de uso:
1. [Kubeflow completo en el momento de la implementación AWS](#full-kubeflow-deployment)
Para usar otros componentes de Kubeflow además de las canalizaciones de Kubeflow, elija la implementación completa de [distribución de AWS de Kubeflow](https://awslabs.github.io/kubeflow-manifests).
1. [Implementación independiente de canalizaciones de Kubeflow](#kubeflow-pipelines-standalone)
Para usar las canalizaciones de Kubeflow sin los demás componentes de Kubeflow, instale las canalizaciones de Kubeflow de forma independiente.
### Kubeflow completo en el momento de la implementación AWS
Para instalar la versión completa de Kubeflow AWS, elige la opción de implementación básica en la [guía de implementación de Kubeflow on AWS](https://awslabs.github.io/kubeflow-manifests/docs/deployment/) o cualquier otra opción de implementación que admita integraciones con varios servicios ( AWS Amazon S3, Amazon RDS, Amazon Cognito).
### Implementación independiente de canalizaciones de Kubeflow
En esta sección se supone que el usuario tiene permisos para crear roles y definir políticas para el rol.
#### Configurar un nodo de puerta de enlace
Puede utilizar su equipo local o una instancia de Amazon EC2 como nodo de puerta de enlace. Se utiliza un nodo de puerta de enlace para crear un clúster de Amazon EKS y acceder a la interfaz de usuario de las canalizaciones de Kubeflow.
Realice los siguientes pasos para configurar su nodo.
1.
**Cree un nodo de puerta de enlace.**
Puede utilizar una instancia de Amazon EC2 existente o crear una nueva instancia con la versión más reciente de DLAMI de Ubuntu 18.04 según los pasos que se indican en [Launching and Configuring a DLAMI](https://docs.aws.amazon.com/dlami/latest/devguide/launch-config.html).
1.
**Cree un rol de IAM para permitir que su nodo de puerta de enlace acceda a los recursos. AWS**
Cree un rol de IAM con permisos para los siguientes recursos: CloudWatch,, IAM CloudFormation, Amazon EC2, Amazon S3, Amazon EKS.
Adjunte las políticas siguientes al rol de 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)
+ IAMFullAcceda
+ Amazon S3 FullAccess
+ Amazon EC2 FullAccess
+ EKSAdminPolítica de Amazon (cree esta política con el esquema de los ejemplos de [políticas basadas en la identidad de Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/security_iam_id-based-policy-examples.html))
Para obtener información sobre cómo permisos de IAM a un rol de IAM, consulte [Adición y eliminación de permisos de identidad de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html).
1.
**Instale las siguientes herramientas y clientes.**
Instale y configure las siguientes herramientas y recursos en su nodo de puerta de enlace para acceder al clúster de Amazon EKS y a la interfaz de usuario (UI) de KFP.
+ [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html): La herramienta de línea de comandos para trabajar con AWS los servicios. Para obtener información sobre la configuración de AWS CLI , consulte [Configuración del 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)versión 0.1.31 y versiones posteriores: herramienta que utiliza las credenciales de AWS IAM para autenticarse en un clúster de Kubernetes.
+ [https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html), versión superior a 0.15: la herramienta de línea de comandos para trabajar con clústeres de Amazon EKS.
+ [https://kubernetes.io/docs/tasks/tools/install-kubectl/#install-kubectl](https://kubernetes.io/docs/tasks/tools/install-kubectl/#install-kubectl): la herramienta de línea de comandos para trabajar con clústeres de Kubernetes. La versión debe coincidir con su versión de Kubernetes dentro de una versión secundaria.
+ [https://aws.amazon.com/sdk-for-python/](https://aws.amazon.com/sdk-for-python/).
```
pip install boto3
```
#### Configurar un clúster de Amazon EKS
1. Si no tiene un clúster de Amazon EKS existente, ejecute los siguientes pasos desde la línea de comandos de su nodo de puerta de enlace; de lo contrario, omita este paso.
1. Ejecute el siguiente comando para crear un clúster de Amazon EKS con la versión 1.17 o superior. Reemplace `` por el nombre del clúster.
```
eksctl create cluster --name --region us-east-1 --auto-kubeconfig --timeout=50m --managed --nodes=1
```
1. Cuando se complete la creación del clúster, asegúrese de tener acceso a él mediante una lista de los nodos del clúster.
```
kubectl get nodes
```
1. Asegúrese de que el contexto `kubectl` actual apunta al clúster con el siguiente comando. El contexto actual se marca con un asterisco (\$1) en la salida.
```
kubectl config get-contexts
CURRENT NAME CLUSTER
* @.us-east-1.eksctl.io .us-east-1.eksctl.io
```
1. Si el clúster deseado no está configurado como el predeterminado actual, actualícelo con el siguiente comando.
```
aws eks update-kubeconfig --name --region us-east-1
```
#### Instalar canalizaciones de Kubeflow
Ejecute los siguientes pasos desde la terminal de su nodo de puerta de enlace para instalar canalizaciones de Kubeflow en su clúster.
1. Instale todos los [componentes 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 las canalizaciones de 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. Asegúrese de que el servicio de canalizaciones de Kubeflow y otros recursos relacionados funcionen.
```
kubectl -n kubeflow get all | grep pipeline
```
El resultado debería tener el siguiente aspecto.
```
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
```
## Configura los permisos de tu canalización para acceder a la IA SageMaker
En esta sección, crearás una función de ejecución de IAM que permita a los pods de Kubeflow Pipeline acceder a SageMaker los servicios de IA.
### Configuración de los componentes de SageMaker IA, versión 2
Para ejecutar la versión 2 de SageMaker AI Components para Kubeflow Pipelines, debes instalar [SageMaker AI Operator para Kubernetes y configurar el control de acceso basado en roles (RBAC) para](https://github.com/aws-controllers-k8s/sagemaker-controller) que los pods de Kubeflow Pipelines puedan crear recursos de IA personalizados en tu clúster de Kubernetes. SageMaker
**importante**
Siga esta sección si va a utilizar la implementación independiente de las canalizaciones de Kubeflow. Si utilizas la AWS distribución de Kubeflow en la versión 1.6.0-aws-b1.0.0 o superior, los componentes de IA de la versión 2 ya están configurados. SageMaker
1. Instala SageMaker AI Operator para Kubernetes para usar los componentes de IA de la versión 2. SageMaker
Siga la sección de *configuración* del [tutorial Machine Learning with ACK SageMaker AI Controller](https://aws-controllers-k8s.github.io/community/docs/tutorials/sagemaker-example/#setup).
1. Configure los permisos RBAC para el rol de ejecución (cuenta de servicio) que utilizan los pods de las canalizaciones de Kubeflow. En la implementación independiente de las canalizaciones de Kubeflow, las ejecuciones de la canalización se ejecutan en el espacio de nombres `kubeflow` mediante la cuenta de servicio `pipeline-runner`.
1. Cree una [RoleBinding](https://kubernetes.io/docs/reference/access-authn-authz/rbac/#rolebinding-example)que dé permiso a la cuenta de servicio para administrar los recursos personalizados de SageMaker IA.
```
cat > manage_sagemaker_cr.yaml <
Para ejecutar la versión 1 de SageMaker AI Components para Kubeflow Pipelines, los pods de Kubeflow Pipeline necesitan acceso a la IA. SageMaker
**importante**
Sigue esta sección tanto si utilizas el Kubeflow completo durante la implementación como si utilizas Kubeflow Pilepines de forma independiente. AWS
Para crear una función de ejecución de IAM que permita a los módulos de canalización de Kubeflow acceder a la IA, sigue estos pasos: SageMaker
1. Exporta el nombre del clúster (p. ej. *my-cluster-name*) y la región del clúster (p. ej., *us-east-1*).
```
export CLUSTER_NAME=my-cluster-name
export CLUSTER_REGION=us-east-1
```
1. Exporte el espacio de nombres y el nombre de la cuenta de servicio a su instalación.
+ Para obtener el Kubeflow completo durante la AWS instalación, exporta tu perfil `namespace` (por ejemplo *kubeflow-user-example-com*) y el editor *predeterminado como cuenta de servicio.*
```
export NAMESPACE=kubeflow-user-example-com
export KUBEFLOW_PIPELINE_POD_SERVICE_ACCOUNT=default-editor
```
+ Para la implementación independiente de las canalizaciones, exporte *kubeflow* como el `namespace` y *pipeline-runner* como la cuenta de servicio.
```
export NAMESPACE=kubeflow
export KUBEFLOW_PIPELINE_POD_SERVICE_ACCOUNT=pipeline-runner
```
1. Cree un [proveedor de OIDC de IAM para el clúster de Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) con el siguiente comando.
```
eksctl utils associate-iam-oidc-provider --cluster ${CLUSTER_NAME} \
--region ${CLUSTER_REGION} --approve
```
1. Cree una función de ejecución de IAM para que los pods de KFP accedan AWS a los servicios (AI,). SageMaker 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
```
[Una vez que sus permisos de canalización estén configurados para acceder a la versión 1 de SageMaker AI Components, siga la guía de componentes de SageMaker IA para canalizaciones de Kubeflow que se encuentra en la documentación de Kubeflow on. AWS](https://awslabs.github.io/kubeflow-manifests/docs/amazon-sagemaker-integration/sagemaker-components-for-kubeflow-pipelines/)
## Acceder a la interfaz de usuario de KFP (panel de Kubeflow)
La interfaz de usuario de las canalizaciones de Kubeflow se utiliza para administrar y realizar un seguimiento de los experimentos, los trabajos y las ejecuciones en el clúster. Para obtener instrucciones sobre cómo acceder a la interfaz de usuario de las canalizaciones de Kubeflow desde su nodo de puerta de enlace, siga los pasos correspondientes a la opción de implementación en esta sección.
### Kubeflow completo en el momento de la implementación AWS
Sigue las instrucciones del [AWS sitio web de Kubeflow](https://awslabs.github.io/kubeflow-manifests/docs/deployment/connect-kubeflow-dashboard/) para conectarte al panel de control de Kubeflow y acceder a la pestaña de canalizaciones.
### Implementación independiente de canalizaciones de Kubeflow
Use el reenvío de puertos para acceder a la interfaz de usuario de canalizaciones de Kubeflow desde su nodo de puerta de enlace según estos pasos.
#### Configurar el reenvío de puertos al servicio de interfaz de usuario de KFP
Ejecute el siguiente comando desde la línea de comandos de su nodo de puerta de enlace.
1. Compruebe que el servicio de interfaz de usuario de KFP se ejecute mediante el siguiente comando.
```
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. Ejecute el siguiente comando para configurar el reenvío de puertos al servicio de interfaz de usuario de KFP. Esto reenvía la interfaz de usuario de KFP al puerto 8080 de su nodo de puerta de enlace y le permite acceder a la interfaz de usuario de KFP desde su navegador.
```
kubectl port-forward -n kubeflow service/ml-pipeline-ui 8080:80
```
El reenvío de puertos desde su equipo remoto se interrumpe si no hay actividad. Vuelva a ejecutar este comando si su panel no puede obtener registros o actualizaciones. Si los comandos devuelven un error, asegúrese de que no haya ningún proceso en ejecución en el puerto que está intentando utilizar.
#### Acceder al servicio de interfaz de usuario de KFP
El método de acceso a la interfaz de usuario de KFP depende del tipo de nodo de la puerta de enlace.
+ Equipo local como nodo de puerta de enlace:
1. Acceda al panel de su navegador de la siguiente manera:
```
http://localhost:8080
```
1. Seleccione **Canalizaciones** para acceder a la interfaz de usuario de las canalizaciones.
+ Instancia de Amazon EC2 como nodo de puerta de enlace:
1. Debe configurar un túnel SSH en su instancia de Amazon EC2 para acceder al panel de Kubeflow desde el navegador de su equipo local.
Desde una nueva sesión de terminal en su equipo local, ejecute lo siguiente. Reemplace `` por la dirección IP de la instancia que se encuentra en la consola de Amazon EC2. También puede usar el DNS público. Reemplace `` por la ruta de acceso a la clave pem utilizada para acceder al nodo de puerta de enlace.
```
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. Acceda al panel de su navegador.
```
http://localhost:9000
```
1. Elija **Canalizaciones** para acceder a la interfaz de usuario de KFP.
#### (Opcional) Conceda acceso a las instancias de notebook de SageMaker IA a Amazon EKS y ejecute los pipelines de KFP desde su notebook.
Una instancia de SageMaker notebook es una instancia de cómputo de Amazon EC2 totalmente gestionada que ejecuta la aplicación Jupyter Notebook. Puede usar una instancia de cuaderno para crear y administrar cuadernos de Jupyter y, a continuación, definir, compilar, implementar y ejecutar sus canalizaciones de KFP mediante AWS SDK para Python (Boto3) o la CLI de KFP.
1. Siga los pasos que se indican en [Crear una instancia de SageMaker Notebook para crear su instancia](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-setup-working-env.html) de Notebook y, a continuación, adjunte la `S3FullAccess` política a su función de ejecución de IAM.
1. Desde la línea de comandos del nodo de puerta de enlace, ejecute el siguiente comando para recuperar el ARN del rol de IAM de la instancia de cuaderno que creó. Reemplace `` por el nombre de la instancia.
```
aws sagemaker describe-notebook-instance --notebook-instance-name --region --output text --query 'RoleArn'
```
Este comando muestra el ARN del rol de IAM en el formato `arn:aws:iam:::role/`. Tome nota de este ARN.
1. Ejecute este comando para adjuntar las siguientes políticas (Amazon AmazonSageMakerFullAccess EKSWorkerNodePolicy, AmazonS3FullAccess) a esta función de IAM. Reemplace el `` por el `` de su 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. Los clústeres de Amazon EKS utilizan roles de IAM para controlar el acceso al clúster. Las reglas se implementan en un mapa de configuración denominado `aws-auth`. `eksctl` proporciona comandos para leer y editar el mapa de configuración `aws-auth`. Solo los usuarios que tienen acceso al clúster pueden editar este mapa de configuración.
`system:masters` es uno de los grupos de usuarios predeterminados con permisos de superusuario para el clúster. Agregue su usuario a este grupo o cree un grupo con permisos más restrictivos.
1. Implemente el rol en el clúster ejecutando el siguiente comando. Reemplace el `` por el ARN del rol de IAM. `` puede ser cualquier nombre de usuario único.
```
eksctl create iamidentitymapping \
--cluster \
--arn \
--group system:masters \
--username \
--region
```
1. Abre un cuaderno de Jupyter en tu instancia de SageMaker IA y ejecuta el siguiente comando para asegurarte de que tiene acceso al clúster.
```
aws eks --region update-kubeconfig --name
kubectl -n kubeflow get all | grep pipeline
```
# Usa componentes de IA SageMaker
En este tutorial, ejecutarás una canalización con componentes de SageMaker IA para Kubeflow Pipelines para entrenar un modelo de clasificación con Kmeans con el conjunto de datos MNIST en IA. SageMaker El flujo de trabajo utiliza Kubeflow Pipelines como orquestador y SageMaker la IA para ejecutar cada paso del flujo de trabajo. El ejemplo se tomó de un [ejemplo de SageMaker IA](https://github.com/aws/amazon-sagemaker-examples/blob/8279abfcc78bad091608a4a7135e50a0bd0ec8bb/sagemaker-python-sdk/1P_kmeans_highlevel/kmeans_mnist.ipynb) existente y se modificó para que funcionara con los componentes de SageMaker IA de Kubeflow Pipelines.
Puede definir su canalización en Python utilizando, a AWS SDK para Python (Boto3) continuación, el panel de control de KFP, la CLI de KFP o Boto3 para compilar, implementar y ejecutar sus flujos de trabajo. El código completo del ejemplo de canalización de clasificación del MNIST está disponible en el [repositorio Github de Kubeflow](https://github.com/kubeflow/pipelines/tree/master/samples/contrib/aws-samples/mnist-kmeans-sagemaker#mnist-classification-with-kmeans). Para usarlo, clone los archivos de Python en su nodo de puerta de enlace.
Puedes encontrar más ejemplos de canalizaciones de [ SageMaker AI Kubeflow](https://github.com/kubeflow/pipelines/tree/master/samples/contrib/aws-samples) en. GitHub [Para obtener información sobre los componentes utilizados, consulta el repositorio de Pipelines. KubeFlow GitHub ](https://github.com/kubeflow/pipelines/tree/master/components/aws/sagemaker)
Para ejecutar el ejemplo del proceso de clasificación, cree una función de ejecución de SageMaker IA IAM que conceda a su trabajo de formación el permiso para acceder a AWS los recursos y, a continuación, continúe con los pasos correspondientes a su opción de despliegue.
## Cree un rol de ejecución de SageMaker IA
La función de `kfp-example-sagemaker-execution-role` IAM es una función de tiempo de ejecución que asumen los trabajos de SageMaker IA para acceder a AWS los recursos. En el siguiente comando, se crea una función de ejecución de IAM denominada`kfp-example-sagemaker-execution-role`, se adjuntan dos políticas gestionadas (AmazonSageMakerFullAccessAmazonS3FullAccess) y se crea una relación de confianza con la SageMaker IA para conceder a los trabajos de SageMaker IA el acceso a esos recursos. AWS
Proporcionará este rol como parámetro de entrada al ejecutar la canalización.
Ejecute el siguiente comando para crear el rol. Tome nota del ARN que se devuelve como su salida.
```
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 en el momento de la implementación AWS
Siga las instrucciones del [tutorial SageMaker Training Pipeline para la clasificación del MNIST](https://awslabs.github.io/kubeflow-manifests/docs/amazon-sagemaker-integration/sagemaker-components-for-kubeflow-pipelines/) con K-Means.
## Implementación independiente de canalizaciones de Kubeflow
### Preparación de conjuntos de datos
Para ejecutar las canalizaciones, debe cargar el script de preprocesamiento de extracción de datos en un bucket de Amazon S3. Este bucket y todos los recursos de este ejemplo deben estar ubicados en la región `us-east-1`. Para obtener información sobre la creación de un bucket, consulte la sección de [creación de un bucket](https://docs.aws.amazon.com/AmazonS3/latest/gsg/CreatingABucket.html).
Desde la carpeta `mnist-kmeans-sagemaker` del repositorio de Kubeflow que clonó en su nodo de puerta de enlace, ejecute el siguiente comando para cargar el archivo `kmeans_preprocessing.py` en su bucket de Amazon S3. Cambie `` por el nombre de su bucket de Amazon S3.
```
aws s3 cp mnist-kmeans-sagemaker/kmeans_preprocessing.py s3:///mnist_kmeans_example/processing_code/kmeans_preprocessing.py
```
### Compilación e implementación de la canalización
Tras definir la canalización, debe compilarla en una representación intermedia antes de enviarla al servicio de canalizaciones de Kubeflow de su clúster. La representación intermedia es una especificación de flujo de trabajo en forma de archivo YAML comprimido en un archivo tar.gz. Necesitará el SDK de KFP para compilar la canalización.
#### Instalación del SDK de KFP
Ejecute lo siguiente desde la línea de comandos de su nodo de puerta de enlace:
1. Instale el SDK de KFP según las instrucciones de la [documentación sobre las canalizaciones de Kubeflow](https://www.kubeflow.org/docs/pipelines/sdk/install-sdk/).
1. Verifique que el SDK de KFP esté instalado mediante el siguiente comando:
```
pip show kfp
```
1. Compruebe que `dsl-compile` se ha instalado correctamente de la siguiente manera:
```
which dsl-compile
```
#### Compilación de la canalización
Tienes tres opciones para interactuar con las canalizaciones de Kubeflow: la interfaz de usuario de KFP, la CLI de KFP o el SDK de KFP. Las siguientes secciones ilustran el flujo de trabajo mediante la interfaz de usuario y la CLI de KFP.
Complete los siguientes pasos en el nodo de puerta de enlace.
1. Modifique el archivo Python con el nombre del bucket de Amazon S3 y el ARN del rol de IAM.
1. Usa el comando `dsl-compile` de la línea de comandos para compilar la canalización de la siguiente manera. Reemplace `` por la ruta a la canalización y `` por la ubicación en la que quiere que esté el archivo tar.gz.
```
dsl-compile --py --output
```
#### Carga y ejecución de la canalización mediante la CLI de KFP
Complete los pasos siguientes desde la línea de comandos de su nodo de la puerta de enlace. KFP organiza las ejecuciones de su canalización como experimentos. Tiene la opción de especificar un nombre para el experimento. Si no especifica ninguno, la ejecución aparecerá en la lista de experimentos **predeterminados**.
1. Cargue su canalización de la siguiente manera:
```
kfp pipeline upload --pipeline-name
```
El resultado debería tener el siguiente aspecto. Tome nota del `ID` de la canalización.
```
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. Cree una ejecución mediante el comando siguiente. El comando de ejecución de la CLI de KFP actualmente no admite la especificación de parámetros de entrada al crear la ejecución. Debe actualizar los parámetros en el archivo de AWS SDK para Python (Boto3) canalización antes de compilarlos. Reemplace `` y `` por cualquier nombre. Reemplace `` por el ID de la canalización enviada. Reemplace `` por el ARN del `kfp-example-pod-role`. Reemplace `` por el nombre del bucket de Amazon S3 que ha creado.
```
kfp run submit --experiment-name --run-name --pipeline-id role_arn="" bucket_name=""
```
También puede enviar una ejecución directamente mediante el paquete de canalización compilado creado como la salida del comando `dsl-compile`.
```
kfp run submit --experiment-name --run-name --package-file role_arn="" bucket_name=""
```
El resultado debería tener el siguiente aspecto:
```
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. Vaya a la interfaz de usuario para comprobar el progreso del trabajo.
#### Carga y ejecución de la canalización mediante la interfaz de usuario de KFP
1. En el panel izquierdo, elija la pestaña **Canalizaciones**.
1. **En la esquina superior derecha, selecciona \$1. UploadPipeline**
1. Ingrese el nombre y la descripción de la canalización.
1. Elija **Cargar un archivo** e ingrese la ruta al archivo tar.gz que creó mediante la CLI o con AWS SDK para Python (Boto3).
1. En el panel izquierdo, elija la pestaña **Canalizaciones**.
1. Busque la canalización que ha creado.
1. Elija **\$1CreateRun**.
1. Ingrese los parámetros de entrada.
1. Seleccione **Ejecutar**.
### Ejecución de predicciones
Una vez implementada la canalización de clasificación, puede ejecutar predicciones de clasificación en el punto de conexión creado por el componente Deploy. Utilice la interfaz de usuario de KFP para comprobar los artefactos de salida de `sagemaker-deploy-model-endpoint_name`. Descargue el archivo.tgz para extraer el nombre del terminal o compruebe la consola de SageMaker IA de la región que utilizó.
#### Configuración de los permisos para ejecutar predicciones
Si desea ejecutar predicciones desde su nodo de puerta de enlace, omita esta sección.
**Para usar cualquier otro equipo para ejecutar predicciones, asigne el permiso `sagemaker:InvokeEndpoint` al rol de IAM utilizado por el equipo cliente.**
1. En su nodo de puerta de enlace, ejecute lo siguiente para crear un archivo de política de IAM:
```
cat < ./sagemaker-invoke.json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sagemaker:InvokeEndpoint"
],
"Resource": "*"
}
]
}
EoF
```
1. Adjunte la política al rol de IAM del nodo cliente.
Ejecute el comando siguiente. Reemplace `` por el nombre del rol de IAM. Reemplace `` por la ruta al archivo de política que ha creado.
```
aws iam put-role-policy --role-name --policy-name sagemaker-invoke-for-worker --policy-document file://
```
#### Ejecución de predicciones
1. Cree un AWS SDK para Python (Boto3) archivo desde su máquina cliente `mnist-predictions.py` con el nombre siguiente. Reemplace la variable `ENDPOINT_NAME`. El script carga el conjunto de datos MNIST, crea un CSV a partir de esos dígitos y, a continuación, lo envía al punto de conexión para realizar la predicción e imprime los 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. Ejecute el AWS SDK para Python (Boto3) archivo de la siguiente manera:
```
python mnist-predictions.py
```
### Ver resultados y registros
Cuando la canalización está en ejecución, puede elegir cualquier componente para comprobar los detalles de la ejecución, como las entradas y las salidas. Aquí se muestran los nombres de los recursos creados.
Si la solicitud de KFP se procesa correctamente y se crea un trabajo de SageMaker IA, los registros de componentes de la interfaz de usuario de KFP proporcionan un enlace al trabajo creado en SageMaker AI. Los CloudWatch registros también se proporcionan si el trabajo se ha creado correctamente.
Si ejecuta demasiados trabajos de canalización en el mismo clúster, es posible que aparezca un mensaje de error que indique que no tiene suficientes pods disponibles. Para solucionar este problema, inicia sesión en su nodo de puerta de enlace y elimine los pods creados por las canalizaciones que no esté utilizando:
```
kubectl get pods -n kubeflow
kubectl delete pods -n kubeflow
```
### Limpieza
Cuando termine con la canalización, tendrá que borrar los recursos.
1. Desde el panel de KFP, para finalizar las ejecuciones de la canalización si no terminan correctamente, elija **Finalizar**.
1. Si la opción **Finalizar** no funciona, inicie sesión en su nodo de puerta de enlace y finalice manualmente todos los pods creados por su canalización, de la siguiente manera:
```
kubectl get pods -n kubeflow
kubectl delete pods -n kubeflow
```
1. Con su AWS cuenta, inicie sesión en el servicio de SageMaker IA. Detenga manualmente todos los trabajos de entrenamiento, transformación por lotes y HPO. Elimine los modelos, los buckets de datos y los puntos de conexión para evitar incurrir en cargos adicionales. Poner fin a los oleoductos no detiene los trabajos en la SageMaker IA.