Anuncio de compatibilidad con API compatible con OpenAI para puntos finales de IA de Amazon SageMaker

Hoy, Amazon SageMaker AI presenta compatibilidad con API compatible con OpenAI para puntos finales de inferencia en tiempo real. Si utiliza OpenAI SDK, LangChain o Strands Agents, ahora puede invocar modelos en SageMaker AI cambiando solo la URL de su punto final. No necesita un cliente personalizado, un contenedor SigV4 ni reescrituras de código.

Descripción general

Con este lanzamiento, los puntos finales de SageMaker AI exponen una ruta /openai/v1 que acepta solicitudes de finalización de chat y devuelve respuestas tal cual desde el contenedor, incluida la transmisión. Los puntos finales de OpenAI están activados para todos los puntos finales y componentes de inferencia mediante el SDK y las API de IA estándar de SageMaker.

SageMaker AI enruta según el nombre del punto final en la URL, por lo que cualquier cliente compatible con OpenAI funciona de inmediato. Ahora puede crear tokens al portador por tiempo limitado para sus puntos finales y usarlos con sus clientes OpenAI.

Para ver un ejemplo práctico que incluye implementación e invocación, consulte el cuaderno adjunto en GitHub.

"Ejecutamos agentes de codificación de IA que utilizan múltiples proveedores de LLM a través de una puerta de enlace de LLM (Bifrost) que utiliza el protocolo de finalización de chat de OpenAI. La función de token de portador nos permite agregar SageMaker como un punto final de inferencia compatible con OpenAI (sin firma SigV4 personalizada), por lo que funciona de forma nativa con nuestra puerta de enlace, Vercel AI SDK y clientes OpenAI estándar". dice Giorgio Piatti (ingeniero de IA/ML – Caffeine.AI)

Casos de uso

Flujos de trabajo agentes en infraestructura propia

Si crea agentes de IA de varios pasos con marcos como Strands Agents o LangChain, ahora puede ejecutar esos flujos de trabajo completamente en sus propios puntos finales de IA de SageMaker. Sus agentes llaman a los modelos utilizando la misma interfaz compatible con OpenAI en la que se crearon, pero la inferencia se ejecuta en instancias de GPU dedicadas en su propia cuenta.

Alojamiento multimodelo con una única interfaz

Si ejecuta varios modelos (por ejemplo, Llama para tareas generales, un Mistral optimizado para trabajos de dominios específicos y un modelo más pequeño para clasificación), puede alojarlos todos en un único punto final de SageMaker AI utilizando componentes de inferencia. Cada modelo tiene su propia asignación de recursos y todos se pueden llamar a través del mismo SDK de OpenAI. No necesita clientes API independientes ni lógica de enrutamiento en el código de la aplicación.

Sirviendo modelos ajustados sin cambios de código

Si ajusta los modelos de código abierto para su caso de uso específico, puede implementarlos en SageMaker AI y llamarlos a través de la misma interfaz compatible con OpenAI que ya usan sus aplicaciones. El único cambio es la URL del punto final. El resto de la aplicación (las llamadas al SDK, la lógica de transmisión, el formato del mensaje) permanece igual.

Descripción general de la solución

En esta publicación, analizamos lo siguiente:

Cómo funciona la autenticación de token de portador con los puntos finales de SageMaker AI. Implementar e invocar un punto final de modelo único. Implementar e invocar componentes de inferencia para implementaciones multimodelo. Integración con el framework Strands Agents.

Requisitos previos

Para seguir este tutorial, debe tener lo siguiente:

Una cuenta de AWS con permisos para crear puntos finales de SageMaker AI. El SDK de Python de SageMaker (pip install sagemaker). El SDK de OpenAI Python (pip install openai). Un modelo almacenado en Amazon Simple Storage Service (Amazon S3). Por ejemplo, Qwen3-4B descargado de Hugging Face. Un rol de ejecución de AWS Identity and Access Management (IAM) para crear los puntos finales, con la política AmazonSageMakerFullAccess. Una función de ejecución de IAM con los permisos sagemaker:CallWithBearerToken y sagemaker:InvokeEndpoint para invocar el punto final.

Autenticación con tokens al portador

Los puntos finales compatibles con SageMaker AI OpenAI utilizan autenticación de token de portador. El SDK de SageMaker Python incluye un generador de tokens que crea tokens de tiempo limitado (válidos por hasta 12 horas) a partir de sus credenciales de AWS existentes. No se requieren secretos ni claves API adicionales.

El token contiene su rol o credenciales de usuario y requiere los permisos de acción sagemaker:CallWithBearerToken y sagemaker:InvokeEndpoint.

Generar una ficha

Utilice el siguiente script de Python para generar un token.

desde sagemaker.core.token_generator importar generate_token desde fecha y hora importar timedelta token = generate_token(region="us-west-2", expiry=timedelta(minutos=5))

El generador de tokens utiliza cualquier credencial de AWS que esté disponible en su entorno: credenciales de usuario de IAM, un perfil de instancia en Amazon Elastic Compute Cloud (Amazon EC2) o una sesión de AWS IAM Identity Center (SSO).

La función generate_token genera un token de portador por tiempo limitado para autenticarse con las API de SageMaker. De forma predeterminada, los tokens son válidos durante 12 horas, aunque puede anular esto con el parámetro de caducidad utilizando un valor delta de tiempo entre 1 segundo y 12 horas. La función acepta una región, un aws_credentials_provider opcional y la duración de vencimiento. Si no se proporciona ninguna región de AWS, recurre a la variable de entorno AWS_REGION. Si no se proporciona ningún proveedor de credenciales, las resuelve utilizando la cadena de credenciales de AWS predeterminada, que busca múltiples fuentes, incluidas variables de entorno, ~/.aws/credentials, ~/.aws/config, credenciales de contenedor y perfiles de instancia. Para obtener el orden de resolución completa, consulte la documentación de credenciales de Boto3.

Tokens de actualización automática para aplicaciones de larga ejecución

Para aplicaciones que se ejecutan continuamente, puede implementar un patrón de actualización automática usando httpx para que se genere un token nuevo en cada solicitud:

importar httpx desde sagemaker.core.token_generator importar generar_token clase SageMakerAuth(httpx.Auth): def __init__(self, región: str): self.region = región def auth_flow(self, solicitud): request.headers["Autorización"] = f"Portador {generate_token(region=self.region)}" solicitud de rendimiento http_client = httpx.Client(auth=SageMakerAuth(region="us-west-2"))

permisos de IAM

El rol de IAM o el usuario que invoca el punto final necesita los siguientes permisos:

{ "Versión": "2012-10-17", "Declaración": [ { "Efecto": "Permitir", "Acción": "sagemaker:InvokeEndpoint", "Recurso": "arn:aws:sagemaker:::endpoint/" }, { "Efecto": "Permitir", "Acción": "sagemaker:CallWithBearerToken", "Recurso": "*" } ] }

Como práctica recomendada, restrinja siempre el recurso a ARN de punto final específicos para InvokeEndpoint en lugar de utilizar un comodín. El token de portador generado a partir de esta función tiene el mismo nivel de acceso, por lo que una política de alcance limitado limita el radio de explosión si un token queda expuesto inadvertidamente. Tenga en cuenta que CallWithBearerToken requiere un comodín ("*") para el campo Recurso. No admite restricciones a nivel de recursos.

Cómo funciona la ficha

El token de portador es una URL prefirmada SigV4 codificada en base64. Cuando llama a generate_token, el SDK de SageMaker AI construye una solicitud al servicio SageMaker AI para la acción CallWithBearerToken, la firma localmente usando sus credenciales de AWS y codifica la URL firmada resultante como una cadena de token portátil. No se realiza ninguna llamada de red durante la generación del token. La firma se realiza íntegramente del lado del cliente. Cuando presenta este token a un punto final de SageMaker AI, el servicio lo decodifica, valida la firma SigV4, verifica que el token no haya caducado y confirma que la identidad de IAM de origen tiene los permisos necesarios. La vida útil efectiva del token es el menor entre el valor de caducidad y la validez restante de las credenciales de AWS utilizadas para firmarlo.

Mejores prácticas de seguridad: el token de portador lleva la misma autorización que las credenciales de AWS subyacentes utilizadas para generarlo. Trate los tokens con el mismo cuidado que las credenciales. Alcance la función de IAM utilizada para la generación de tokens con los permisos mínimos requeridos, específicamente sagemaker:InvokeEndpoint y sagemaker:CallWithBearerToken solo en los ARN de punto final a los que la persona que llama necesita acceder. No genere tokens a partir de roles con permisos amplios, como los otorgados por las políticas administradas de AdministratorAccess o SageMakerFullAccess.

No almacene tokens en el disco, en variables de entorno, en archivos de configuración, en bases de datos o en cachés distribuidas. No registre tokens y transmítalos únicamente a través de protocolos de comunicación cifrados como HTTPS. La generación de tokens es una operación local sin sobrecarga de red, por lo que la práctica recomendada es generar un token nuevo en el punto de uso o utilizar el patrón httpx.Auth de actualización automática que se muestra en el ejemplo anterior. Esto evita el riesgo de fuga de tokens y le ayuda a utilizar un token con la máxima validez restante. Como práctica recomendada, establezca la caducidad del token en la duración más corta que requiera su carga de trabajo.

Implementar un punto final de un solo modelo

Un punto final de modelo único aloja un modelo y atiende solicitudes directamente. El siguiente ejemplo implementa Qwen3-4B utilizando el contenedor de aprendizaje profundo SageMaker AI vLLM en una instancia ml.g6.2xlarge.

Nota: Los puntos finales de SageMaker AI incurren en cargos mientras están en servicio, independientemente del tráfico. Para obtener más detalles, consulte la página de precios de Amazon SageMaker AI.

importar boto3 importar sagemaker tiempo de importación desde sagemaker.core.helper.session_helper importar sesión desde sagemaker.core.helper.session_helper importar get_execution_role # Configuración de AWS REGION = "us-west-2" # Resolver automáticamente el ID de cuenta y el rol de ejecución predeterminado de SageMaker sesión = Session(boto_session=boto3.Session(region_name=REGION)) ACCOUNT_ID = boto3.client("sts", nombre_región=REGION).get_caller_identity()["Cuenta"] EXECUTION_ROLE = get_execution_role(sagemaker_session=sesión) # ID de modelo HF MODEL_HF_ID = "Qwen/Qwen3-4B" # Contenedor de aprendizaje profundo SageMaker vLLM VLLM_IMAGE = f"763104351884.dkr.ecr.{REGION}.amazonaws.com/vllm:0.20.2-gpu-py312-cu130-ubuntu22.04-sagemaker" # Tipo de instancia (1x GPU NVIDIA L4) INSTANCE_TYPE = "ml.g6.2xlarge" sagemaker_client = boto3.client("sagemaker", nombre_región=REGIÓN) print(f"Región: {REGION}") print(f"ID de cuenta: {ACCOUNT_ID}") print(f"Rol de ejecución: {EXECUTION_ROLE}") print(f"ID de modelo HF: {MODEL_HF_ID}")
hora de importación TIMESTAMP = str(int(time.time())) SME_MODEL_NAME = f"openai-compat-sme-model-{TIMESTAMP}" SME_ENDPOINT_CONFIG_NAME = f"openai-compat-sme-epc-{TIMESTAMP}" SME_ENDPOINT_NAME = f"openai-compat-sme-ep-{TIMESTAMP}" print(f"Sufijo de marca de tiempo: {TIMESTAMP}") print(f"Modelo: {SME_MODEL_NAME}") print(f"Configuración del punto final: {SME_ENDPOINT_CONFIG_NAME}") print(f"Punto final: {SME_ENDPOINT_NAME}") sagemaker_client.create_model( ModelName=SME_MODEL_NAME, ExecutionRoleArn=EXECUTION_ROLE, PrimaryContainer={ "Imagen": VLLM_IMAGE, "Entorno": { "HF_MODEL_ID": MODEL_HF_ID, "SM_VLLM_TENSOR_PARALLEL_SIZE": "1", "SM_VLLM_MAX_NUM_SEQS": "4", "SM_VLLM_ENABLE_AUTO_TOOL_CHOICE": "true", "SM_VLLM_TOOL_CALL_PARSER": "hermes", "SAGEMAKER_ENABLE_LOAD_AWARE": "1", }, }, ) print(f"Modelo creado: {SME_MODEL_NAME}") sagemaker_client.create_endpoint_config( EndpointConfigName=SME_ENDPOINT_CONFIG_NAME, ProductionVariants=[ { "VariantName": "variant1", "ModelName": SME_MODEL_NAME, "InstanceType": INSTANCE_TYPE, "InitialInstanceCount": 1, } ], ) print(f"Configuración de punto final creada: {SME_ENDPOINT_CONFIG_NAME}") sagemaker_client.create_endpoint( EndpointName=SME_ENDPOINT_NAME, EndpointConfigName=SME_ENDPOINT_CONFIG_NAME, ) print(f"Creación de punto final iniciada: {SME_ENDPOINT_NAME}") print("Esperando a que el punto final alcance el estado En servicio (esto demora entre 5 y 10 minutos)…") camarero = sagemaker_client.get_waiter("endpoint_in_service") camarero.wait( EndpointName=SME_ENDPOINT_NAME, WaiterConfig={"Delay": 30, "MaxAttempts": 40}, ) print(f"El punto final está en servicio: {SME_ENDPOINT_NAME}")

El terminal pasa al estado InService en unos minutos. Cuando esté listo, sirve tanto la ruta estándar de SageMaker AI /invocaciones como la ruta compatible con OpenAI en /openai/v1/chat/completions.

Invocar un punto final de modelo único

Con el punto final en servicio, invoquelo utilizando el SDK de OpenAI Python. La URL base sigue este formato:

https://runtime.sagemaker..amazonaws.com/endpoints//openai/v1
desde openai importar OpenAI desde sagemaker.core.token_generator importar generar_token REGION = "us-west-2" sme_base_url = f"https://runtime.sagemaker.{REGION}.amazonaws.com/endpoints/{SME_ENDPOINT_NAME}/openai/v1" client = OpenAI( base_url=sme_base_url, api_key=generate_token(region=REGION) ) print(f"URL base: {sme_base_url}") stream = client.chat.completions.create( model="", mensajes=[ {"role": "system", "content": "Eres un asistente útil."}, {"role": "user", "content": "Explica cómo funcionan los transformadores en el aprendizaje automático, en tres oraciones."}, ], stream=True, ) para fragmento en flujo: si trozo.elecciones[0].delta.content: imprimir (fragmentos.opciones[0].delta.content, end="") imprimir()

El campo del modelo se pasa al contenedor. Debido a que SageMaker AI enruta las solicitudes según el nombre del punto final en la URL, puede mantener este campo vacío o configurarlo para que coincida con el nombre del modelo que espera su contenedor.

Implementar un punto final de componente de inferencia

Con los componentes de inferencia, puede alojar varios modelos en un único punto final, cada uno con asignaciones de recursos informáticos dedicados. Con los componentes de inferencia, el modelo está asociado con el componente en lugar de con la configuración del punto final:

IC_MODEL_NAME = f"openai-compat-ic-model-{TIMESTAMP}" IC_ENDPOINT_CONFIG_NAME = f"openai-compat-ic-epc-{TIMESTAMP}" IC_ENDPOINT_NAME = f"openai-compat-ic-ep-{TIMESTAMP}" IC_NAME = f"openai-compat-ic-qwen3-4b-{TIMESTAMP}" print(f"Modelo: {IC_MODEL_NAME}") print(f"Configuración del punto final: {IC_ENDPOINT_CONFIG_NAME}") print(f"Punto final: {IC_ENDPOINT_NAME}") print(f"Comp. de inferencia: {IC_NAME}") sagemaker_client.create_model( ModelName=IC_MODEL_NAME, ExecutionRoleArn=EXECUTION_ROLE, PrimaryContainer={ "Imagen": VLLM_IMAGE, "Entorno": { "HF_MODEL_ID": MODEL_HF_ID, "SM_VLLM_TENSOR_PARALLEL_SIZE": "1", "SM_VLLM_MAX_NUM_SEQS": "4", "SM_VLLM_ENABLE_AUTO_TOOL_CHOICE": "true", "SM_VLLM_TOOL_CALL_PARSER": "hermes", "SAGEMAKER_ENABLE_LOAD_AWARE": "1", }, }, ) print(f"Modelo creado: {IC_MODEL_NAME}") sagemaker_client.create_endpoint_config( EndpointConfigName=IC_ENDPOINT_CONFIG_NAME, ExecutionRoleArn=EXECUTION_ROLE, ProductionVariants=[ { "VariantName": "variant1", "InstanceType": INSTANCE_TYPE, "InitialInstanceCount": 1, } ], ) print(f"Configuración de punto final creada: {IC_ENDPOINT_CONFIG_NAME}") sagemaker_client.create_endpoint( EndpointName=IC_ENDPOINT_NAME, EndpointConfigName=IC_ENDPOINT_CONFIG_NAME, ) print(f"Creación de punto final iniciada: {IC_ENDPOINT_NAME}") print("Esperando a que el punto final alcance el estado En servicio (esto demora entre 5 y 10 minutos)…") camarero = sagemaker_client.get_waiter("endpoint_in_service") camarero.wait( EndpointName=IC_ENDPOINT_NAME, WaiterConfig={"Delay": 30, "MaxAttempts": 40}, ) print(f"El punto final está en servicio: {IC_ENDPOINT_NAME}") sagemaker_client.create_inference_component( InferenceComponentName=IC_NAME, EndpointName=IC_ENDPOINT_NAME, VariantName="variant1", Especificación={ "ModelName": IC_MODEL_NAME, "ComputeResourceRequirements": { "MinMemoryRequiredInMb": 1024, "NumberOfCpuCoresRequired": 2, "NumberOfAcceleratorDevicesRequired": 1, }, }, RuntimeConfig={"CopyCount": 1}, ) print(f"Creación del componente de inferencia iniciada: {IC_NAME}") print("Esperando que el componente de inferencia alcance el estado InService…") while True: desc = sagemaker_client.describe_inference_component(InferenceComponentName=IC_NAME) status = desc["InferenceComponentStatus"] if status == "InService": print(f"El componente de inferencia está en servicio: {IC_NAME}") break elif status == "Failed": rise RuntimeError(f"Error del componente de inferencia: {desc.get('FailureReason', 'unknown')}") time.sleep(30)

Puede crear componentes de inferencia adicionales en el mismo punto final para alojar varios modelos con escalamiento y asignación de recursos independientes.

Invocar componentes de inferencia

Para invocar un componente de inferencia específico, incluya su nombre en la ruta URL:

https://runtime.sagemaker..amazonaws.com/endpoints//inference-components//openai/v1

El siguiente ejemplo muestra dos componentes de inferencia en un punto final compartido, cada uno de los cuales está dirigido a un cliente OpenAI independiente que comparte un grupo de conexiones:

importar httpx desde openai importar OpenAI desde sagemaker.core.token_generator importar generate_token share_http = httpx.Client() client_a = OpenAI( base_url=( f"https://runtime.sagemaker.{REGION}.amazonaws.com" f"/endpoints/{IC_ENDPOINT_NAME}/inference-components/{IC_NAME}/openai/v1" ), api_key=generate_token(region=REGION), http_client=shared_http, ) respuesta = client_a.chat.completions.create( model="", mensajes=[{"role": "usuario", "content": "¿Qué es 42 * 3? Responde con el número."}], ) print(f"Respuesta: {response.choices[0].message.content}") print(f"Grupo de conexiones activo: share_http es reutilizable en múltiples clientes IC")

El httpx.Client compartido permite que ambas instancias de cliente OpenAI reutilicen las mismas sesiones TLS y el mismo grupo de conexiones.

Integrarse con los agentes de Strands

Strands Agents es un SDK de código abierto para crear agentes de IA. Debido a que Strands Agents admite proveedores de modelos compatibles con OpenAI, ahora puede ejecutar flujos de trabajo de múltiples agentes completamente en su propia infraestructura de IA de SageMaker. Esto le brinda la flexibilidad de las aplicaciones agentes con el control de puntos finales dedicados. Sus datos nunca salen de su cuenta y usted elige exactamente qué versión de modelo ejecutan sus agentes.

de openai import AsyncOpenAI de strands import Agente, herramienta de strands.models.openai import OpenAIModel de sagemaker.core.token_generator import generate_token @tool def calculadora(expresión: str) -> str: """Evaluar una expresión matemática.""" return str(eval(expresión)) strands_client = AsyncOpenAI( base_url=f"https://runtime.sagemaker.{REGION}.amazonaws.com/endpoints/{SME_ENDPOINT_NAME}/openai/v1", api_key=generate_token(region=REGION), ) model = OpenAIModel(client=strands_client, model_id="", params={"temperature": 0.7}) coder = Agent( model=model, system_prompt=( "Es un desarrollador experto en Python. Escriba " "código Python limpio y bien documentado con sugerencias de tipo. Genere SÓLO el código, sin explicación." ), herramientas=[calculadora], ) reviewer = Agent( model=model, system_prompt=( "Es un revisor de código senior. Revise el código Python para verificar " "la corrección, el rendimiento y el estilo PEP 8. Haga una revisión concisa con sugerencias específicas." ), herramientas=[calculadora], )

Limpiar

Para evitar cargos continuos, elimine sus puntos finales y recursos asociados cuando haya terminado. Los puntos finales de SageMaker AI incurren en costos mientras están en servicio, independientemente de si reciben tráfico.

importar boto3 sagemaker_client = boto3.client("sagemaker", region_name="us-west-2") sagemaker_client.delete_inference_component(InferenceComponentName="") sagemaker_client.delete_endpoint(EndpointName="") sagemaker_client.delete_endpoint_config(EndpointConfigName="") sagemaker_client.delete_model(ModelName="")

Conclusión

Con compatibilidad con API compatible con OpenAI, Amazon SageMaker AI elimina la barrera de integración entre la ubicación actual de la mayoría de las aplicaciones de IA y la infraestructura que necesitan para escalar. Puede conservar su código existente, utilizar cualquier marco compatible con OpenAI y ejecutar inferencia en puntos finales dedicados con los controles de GPU, escalado y residencia de datos que necesita. Para comenzar, implemente un modelo en un punto final de SageMaker AI en tiempo real utilizando un contenedor compatible, instale el SDK de Python de SageMaker y apunte su cliente OpenAI a la URL del punto final. Para obtener más información, consulte Uso de SageMaker AI con API compatibles con OpenAI en la Guía para desarrolladores de Amazon SageMaker AI o abra la consola de Amazon SageMaker AI para crear su primer punto de enlace.

Sobre los autores

marc karp

Marc es arquitecto senior de aprendizaje automático en el equipo de servicios de inteligencia artificial de Amazon SageMaker. Se centra en ayudar a los clientes a diseñar, implementar y gestionar cargas de trabajo de IA/ML a escala. En su tiempo libre le gusta viajar y explorar nuevos lugares.

Kareem Syed-Mohammed

Kareem Syed-Mohammed

Kareem es gerente de producto en AWS. Se centra en permitir el desarrollo y la gobernanza del modelo de IA generativa en Amazon SageMaker HyperPod. Antes de esto, en Amazon Quick Sight, dirigió análisis integrados y experiencia de desarrollador. Además de Quick Sight, ha trabajado en AWS Marketplace y Amazon Retail como gerente de producto. Kareem comenzó su carrera como desarrollador de tecnologías de centros de llamadas, Local Expert y Ads para Expedia, y como consultor de gestión en McKinsey.

Shrijeet Joshi

Shrijeet Joshi

Shrijeet es ingeniero de software senior en AWS, donde ayuda a diseñar y construir la infraestructura central detrás de las plataformas de personalización de modelos e inferencia en tiempo real de Amazon SageMaker AI. Su trabajo impulsa los sistemas que los clientes utilizan para implementar, servir y ajustar modelos de aprendizaje automático a escala masiva en toda la presencia global de AWS. Fuera del trabajo, a Shrijeet le gusta hacer senderismo, acampar y mantenerse activo mediante deportes.

Dmitry Soldatkin

Dmitry Soldatkin

Dmitry es arquitecto senior de soluciones de aprendizaje automático en AWS y ayuda a los clientes a diseñar y crear soluciones de IA/ML. El trabajo de Dmitry cubre una amplia gama de casos de uso de ML, con un interés principal en la IA generativa, el aprendizaje profundo y la ampliación del ML en toda la empresa. Ha ayudado a empresas de muchos sectores, incluidos seguros, servicios financieros, servicios públicos y telecomunicaciones. Le apasiona la innovación continua y el uso de datos para impulsar los resultados comerciales. Antes de unirse a AWS, Dmitry fue arquitecto, desarrollador y líder tecnológico en los campos de análisis de datos y aprendizaje automático en la industria de servicios financieros.

Xu Deng

Xu Deng

Xu es gerente de ingeniería de software en el equipo de inteligencia artificial de Amazon SageMaker. Se centra en ayudar a los clientes a crear y optimizar su experiencia de inferencia de IA/ML en Amazon SageMaker AI. En su tiempo libre le encanta viajar y hacer snowboard.