Kubernetes es una plataforma de orquestación popular para administrar contenedores. Sus capacidades de escalabilidad y equilibrio de carga lo hacen ideal para manejar las cargas de trabajo variables típicas de las aplicaciones de aprendizaje automático (ML). Los ingenieros de DevOps suelen usar Kubernetes para administrar y escalar aplicaciones de ML, pero antes de que un modelo de ML esté disponible, debe entrenarse y evaluarse y, si la calidad del modelo obtenido es satisfactoria, cargarse en un registro de modelos.

Amazon SageMaker proporciona capacidades para eliminar el trabajo pesado no diferenciado de crear e implementar modelos de ML. SageMaker simplifica el proceso de gestión de dependencias, imágenes de contenedores, escalado automático y monitoreo. Específicamente para la etapa de creación de modelos, Canalizaciones de Amazon SageMaker automatiza el proceso al administrar la infraestructura y los recursos necesarios para procesar datos, entrenar modelos y ejecutar pruebas de evaluación.

Un desafío para los ingenieros de DevOps es la complejidad adicional que supone usar Kubernetes para gestionar la etapa de implementación mientras se recurre a otras herramientas (como el SDK de AWS o Formación en la nube de AWS) para gestionar el proceso de creación de modelos. Una alternativa para simplificar este proceso es utilizar Controladores de AWS para Kubernetes (ACK) para administrar e implementar un flujo de trabajo de capacitación de SageMaker. ACK le permite aprovechar los flujos de trabajo de creación de modelos administrados sin necesidad de definir recursos fuera del clúster de Kubernetes.

En esta publicación, presentamos un ejemplo para ayudar a los ingenieros de DevOps a gestionar todo el ciclo de vida de ML, incluido el entrenamiento y la inferencia, utilizando el mismo kit de herramientas.

Descripción general de la solución

Consideramos un caso de uso en el que un ingeniero de ML configura una canalización de creación de modelos de SageMaker utilizando un cuaderno Jupyter. Esta configuración toma la forma de un gráfico acíclico dirigido (DAG) representado como un Definición de canalización JSONEl documento JSON se puede almacenar y versionar en un Servicio de almacenamiento simple de Amazon (Amazon S3) bucket. Si se requiere cifrado, se puede implementar mediante un Servicio de administración de claves de AWS (AWS KMS) administrado clave para Amazon S3Un ingeniero de DevOps con acceso para obtener este archivo de definición de Amazon S3 puede cargar la definición de canalización en un controlador de servicio ACK para SageMaker, que se ejecuta como parte de un Servicio Kubernetes elástico de Amazon (Clúster de Amazon EKS). El ingeniero de DevOps puede utilizar las API de Kubernetes proporcionadas por ACK para enviar la definición de la canalización e iniciar una o más ejecuciones de canalización en SageMaker. Todo este flujo de trabajo se muestra en el siguiente diagrama de solución.

Prerrequisitos

Para seguir el curso es necesario cumplir con los siguientes requisitos previos:

• Un Clúster EKS donde se creará el pipeline de ML.
• Un usuario con acceso a un Gestión de identidad y acceso de AWS Rol (IAM) que tiene permisos de IAM (iam:CreateRole, iam:AttachRolePolicyy iam:PutRolePolicy) para permitir la creación de roles y asociar políticas a los roles.
• Las siguientes herramientas de línea de comandos en la máquina local o el entorno de desarrollo basado en la nube se utilizan para acceder al clúster de Kubernetes:

Instalar el controlador de servicio ACK de SageMaker

El controlador de servicio SageMaker ACK facilita que los ingenieros de DevOps utilicen Kubernetes como plano de control para crear y administrar canales de ML. Para instalar el controlador en su clúster EKS, complete los siguientes pasos:

1. Configure los permisos de IAM para asegurarse de que el controlador tenga acceso a los recursos de AWS adecuados.
2. Instale el controlador utilizando un gráfico Helm de SageMaker para que esté disponible en la máquina cliente.

La siguiente tutorial Proporciona instrucciones paso a paso con los comandos necesarios para instalar el controlador de servicio ACK para SageMaker.

Generar una definición JSON de canalización

En la mayoría de las empresas, los ingenieros de ML son responsables de crear el pipeline de ML en su organización. A menudo trabajan con ingenieros de DevOps para operar esos pipelines. En SageMaker, los ingenieros de ML pueden usar el SDK de Python de SageMaker para generar una definición de pipeline en formato JSON. Una definición de pipeline de SageMaker debe seguir los esquemaque incluye imágenes base, dependencias, pasos y tipos y tamaños de instancias necesarios para definir completamente la canalización. Luego, el ingeniero de DevOps recupera esta definición para implementar y mantener la infraestructura necesaria para la canalización.

A continuación se muestra un ejemplo de definición de canalización con un paso de entrenamiento:

{
  "Version": "2020-12-01",
  "Steps": [
  {
    "Name": "AbaloneTrain",
    "Type": "Training",
    "Arguments": {
      "RoleArn": "<<YOUR_SAGEMAKER_ROLE_ARN>>",
      "HyperParameters": {
        "max_depth": "5",
        "gamma": "4",
        "eta": "0.2",
        "min_child_weight": "6",
        "objective": "multi:softmax",
        "num_class": "10",
        "num_round": "10"
     },
     "AlgorithmSpecification": {
     "TrainingImage": "683313688378.dkr.ecr.us-east-1.amazonaws.com/sagemaker-xgboost:1.7-1",
     "TrainingInputMode": "File"
   },
   "OutputDataConfig": {
     "S3OutputPath": "s3://<<YOUR_BUCKET_NAME>>/sagemaker/"
   },
   "ResourceConfig": {
     "InstanceCount": 1,
     "InstanceType": "ml.m4.xlarge",
     "VolumeSizeInGB": 5
   },
   "StoppingCondition": {
     "MaxRuntimeInSeconds": 86400
   },
   "InputDataConfig": [
   {
     "ChannelName": "train",
     "DataSource": {
       "S3DataSource": {
         "S3DataType": "S3Prefix",
         "S3Uri": "s3://<<YOUR_BUCKET_NAME>>/sagemaker/xgboost/train/",
         "S3DataDistributionType": "
       }
     },
     "ContentType": "text/libsvm"
   },
   {
     "ChannelName": "validation",
     "DataSource": {
       "S3DataSource": {
         "S3DataType": "S3Prefix",
         "S3Uri": "s3://<<YOUR_BUCKET_NAME>>/sagemaker/xgboost/validation/",
         "S3DataDistributionType": "FullyReplicated"
       }
     },
     "ContentType": "text/libsvm"
   }]
  }
 }]
}

Con SageMaker, los artefactos del modelo ML y otros artefactos del sistema se cifran en tránsito y en reposo. SageMaker los cifra de forma predeterminada mediante la clave administrada de AWS para Amazon S3. Opcionalmente, puede especificar una clave personalizada mediante la clave KmsKeyId propiedad de la OutputDataConfig argumento. Para obtener más información sobre cómo SageMaker protege los datos, consulte Protección de datos en Amazon SageMaker.

Además, recomendamos proteger el acceso a los artefactos de la canalización, como los resultados del modelo y los datos de entrenamiento, a un conjunto específico de roles de IAM creados para científicos de datos e ingenieros de ML. Esto se puede lograr adjuntando un Política de cubosPara obtener más información sobre las mejores prácticas para proteger los datos en Amazon S3, consulte Las 10 mejores prácticas de seguridad para proteger los datos en Amazon S3.

Crear y enviar una especificación YAML de canalización

En el mundo de Kubernetes, objetos son las entidades persistentes del clúster de Kubernetes que se utilizan para representar el estado del clúster. Cuando crea un objeto en Kubernetes, debe proporcionar la especificación del objeto que describe su estado deseado, así como información básica sobre el objeto (como un nombre). Luego, con herramientas como kubectl, proporciona la información en un archivo de manifiesto en formato YAML (o JSON) para comunicarse con la API de Kubernetes.

Consulte lo siguiente Especificación YAML de Kubernetes para una canalización de SageMakerLos ingenieros de DevOps necesitan modificar el .spec.pipelineDefinition Introduce la clave en el archivo y añade la definición JSON de la canalización proporcionada por el ingeniero de ML. A continuación, preparan y envían una especificación YAML de ejecución de canalización independiente para ejecutar la canalización en SageMaker. Hay dos formas de enviar una especificación YAML de canalización:

• Pase la definición de la canalización en línea como un objeto JSON a la especificación YAML de la canalización.
• Convierta la definición de la canalización JSON en formato de cadena mediante la utilidad de línea de comandos jq. Por ejemplo, puede utilizar el siguiente comando para convertir la definición de la canalización en una cadena codificada en JSON:

jq -r tojson <pipeline-definition.json>

En esta publicación, usamos la primera opción y preparamos la especificación YAML (my-pipeline.yaml) de la siguiente manera:

apiVersion: sagemaker.services.k8s.aws/v1alpha1
kind: Pipeline
metadata:
  name: my-kubernetes-pipeline
spec:
  parallelismConfiguration:
  	maxParallelExecutionSteps: 2
  pipelineName: my-kubernetes-pipeline
  pipelineDefinition: |
  {
    "Version": "2020-12-01",
    "Steps": [
    {
      "Name": "AbaloneTrain",
      "Type": "Training",
      "Arguments": {
        "RoleArn": "<<YOUR_SAGEMAKER_ROLE_ARN>>",
        "HyperParameters": {
          "max_depth": "5",
          "gamma": "4",
          "eta": "0.2",
          "min_child_weight": "6",
          "objective": "multi:softmax",
          "num_class": "10",
          "num_round": "30"
        },
        "AlgorithmSpecification": {
          "TrainingImage": "683313688378.dkr.ecr.us-east-1.amazonaws.com/sagemaker-xgboost:1.7-1",
          "TrainingInputMode": "File"
        },
        "OutputDataConfig": {
          "S3OutputPath": "s3://<<YOUR_S3_BUCKET>>/sagemaker/"
        },
        "ResourceConfig": {
          "InstanceCount": 1,
          "InstanceType": "ml.m4.xlarge",
          "VolumeSizeInGB": 5
        },
        "StoppingCondition": {
          "MaxRuntimeInSeconds": 86400
        },
        "InputDataConfig": [
        {
          "ChannelName": "train",
          "DataSource": {
            "S3DataSource": {
              "S3DataType": "S3Prefix",
              "S3Uri": "s3://<<YOUR_S3_BUCKET>>/sagemaker/xgboost/train/",
              "S3DataDistributionType": "FullyReplicated"
            }
          },
          "ContentType": "text/libsvm"
        },
        {
          "ChannelName": "validation",
          "DataSource": {
            "S3DataSource": {
              "S3DataType": "S3Prefix",
              "S3Uri": "s3://<<YOUR_S3_BUCKET>>/sagemaker/xgboost/validation/",
              "S3DataDistributionType": "FullyReplicated"
            }
          },
          "ContentType": "text/libsvm"
        }
      ]
    }
  }
]}
pipelineDisplayName: my-kubernetes-pipeline
roleARN: <<YOUR_SAGEMAKER_ROLE_ARN>>

Envíe el pipeline a SageMaker

Para enviar su especificación de canalización preparada, aplique la especificación a su clúster de Kubernetes de la siguiente manera:

kubectl apply -f my-pipeline.yaml

Crear y enviar una especificación YAML de ejecución de canalización

Consulte lo siguiente Especificación YAML de Kubernetes para una canalización de SageMaker. Prepare la especificación YAML de ejecución de la canalización (pipeline-execution.yaml) de la siguiente manera:

apiVersion: sagemaker.services.k8s.aws/v1alpha1
kind: PipelineExecution
metadata:
  name: my-kubernetes-pipeline-execution
spec:
  parallelismConfiguration:
  	maxParallelExecutionSteps: 2
  pipelineExecutionDescription: "My first pipeline execution via Amazon EKS cluster."
  pipelineName: my-kubernetes-pipeline

Para iniciar una ejecución del pipeline, utilice el siguiente código:

kubectl apply -f pipeline-execution.yaml

Revisar y solucionar problemas de ejecución de la canalización

Para enumerar todas las canalizaciones creadas mediante el controlador ACK, utilice el siguiente comando:

Para enumerar todas las ejecuciones de canalización, utilice el siguiente comando:

kubectl get pipelineexecution

Para obtener más detalles sobre el pipeline después de enviarlo, como verificar el estado, los errores o los parámetros del pipeline, use el siguiente comando:

kubectl describe pipeline my-kubernetes-pipeline

Para solucionar problemas en una ejecución de canalización revisando más detalles sobre la ejecución, utilice el siguiente comando:

kubectl describe pipelineexecution my-kubernetes-pipeline-execution

Limpiar

Utilice el siguiente comando para eliminar cualquier canalización que haya creado:

Utilice el siguiente comando para cancelar cualquier ejecución de canalización que haya iniciado:

kubectl delete pipelineexecution

Conclusión

En esta publicación, presentamos un ejemplo de cómo los ingenieros de ML familiarizados con los cuadernos Jupyter y los entornos SageMaker pueden trabajar de manera eficiente con ingenieros de DevOps familiarizados con Kubernetes y herramientas relacionadas para diseñar y mantener una canalización de ML con la infraestructura adecuada para su organización. Esto permite a los ingenieros de DevOps administrar todos los pasos del ciclo de vida de ML con el mismo conjunto de herramientas y el mismo entorno al que están acostumbrados, lo que permite a las organizaciones innovar de manera más rápida y eficiente.

Explorar el Repositorio de GitHub para ACK y el Controlador SageMaker para comenzar a administrar sus operaciones de ML con Kubernetes.

Acerca de los autores

Pratik Yeole es un arquitecto de soluciones sénior que trabaja con clientes globales y los ayuda a crear soluciones basadas en valor en AWS. Tiene experiencia en dominios de contenedores y MLOps. Fuera del trabajo, disfruta del tiempo con amigos, familia, música y cricket.

Felipe López es arquitecto de soluciones sénior especialista en IA/ML en AWS. Antes de unirse a AWS, Felipe trabajó en GE Digital y SLB, donde se centró en productos de modelado y optimización para aplicaciones industriales.