User's blog

Como criar um portal personalizado com o Amazon SageMaker AI MLflow Apps incorporado

Written by

Make.com Service User

in

O problema de acesso ao MLflow em equipes que crescem

Conforme as equipes de Machine Learning (ML) crescem dentro das organizações, gerenciar o acesso ao Amazon SageMaker AI MLflow Apps começa a se tornar um gargalo operacional. Distribuir URLs pré-assinadas não escala para times com dezenas de cientistas de dados, e conceder acesso individual ao Console de Gerenciamento da AWS gera sobrecarga administrativa considerável.

Para equipes que já utilizam portais internos integrados com Autenticação Única (SSO), o ideal é que o rastreamento de experimentos do MLflow esteja acessível pelo mesmo ambiente, com uma URL fixa e navegável. A AWS publicou um guia que mostra exatamente como construir essa solução: um portal customizado com o MLflow Apps incorporado, sem URLs pré-assinadas e sem precisar abrir o console AWS para cada usuário.

Visão geral da solução

A arquitetura proposta combina quatro componentes principais que trabalham em conjunto para oferecer acesso autenticado ao MLflow diretamente pelo navegador.

Application Load Balancer (ALB)

O Application Load Balancer funciona como o ponto de entrada único para os usuários. Ele gerencia o encerramento HTTPS, roteia o tráfego para os alvos corretos no backend e oferece uma URL estável que pode se integrar à infraestrutura de DNS e SSO já existente na organização. Ele distribui o tráfego tanto para o painel React quanto para as chamadas de API do MLflow. Para ambientes de produção, a recomendação é adicionar HTTPS com certificado SSL/TLS via AWS Certificate Manager (ACM).

Front-end React

O front-end em React oferece um ponto de entrada com a identidade visual da organização. Ele incorpora a interface do MLflow dentro de um iframe e serve como ponto de integração para ferramentas e branding internos. Os arquivos estáticos são entregues pelo proxy Flask a partir do caminho /app.

Serviço de proxy reverso Flask

O proxy Flask fica entre o front-end e o backend do MLflow, cuidando da autenticação para que os usuários nunca precisem lidar com credenciais AWS diretamente. A aplicação Python com Flask é responsável por:

  • Interceptar requisições de entrada, incluindo caminhos de interface e chamadas à API REST;
  • Assinar cada requisição com AWS Signature Version 4 (SigV4) usando credenciais temporárias obtidas ao assumir uma role dedicada do AWS Identity and Access Management (IAM);
  • Encaminhar as requisições assinadas para o endpoint do Amazon SageMaker AI MLflow Apps;
  • Reescrever URLs absolutas do MLflow para caminhos relativos e remover cabeçalhos X-Frame-Options para que a interface renderize corretamente dentro do iframe.

Amazon SageMaker AI MLflow Apps

O SageMaker AI gerencia o MLflow Apps de forma totalmente gerenciada — sem servidores para provisionar ou atualizar. Ele oferece rastreamento de experimentos com execuções, métricas, parâmetros e artefatos, além de um registro de modelos para versionamento e gerenciamento de ciclo de vida.

Fluxo de requisições na arquitetura

O fluxo completo de uma requisição do usuário funciona assim:

  • O usuário acessa a URL do ALB no navegador, diretamente ou por um link no portal interno da organização;
  • O ALB roteia a requisição para a instância do Amazon Elastic Compute Cloud (Amazon EC2) que executa o proxy Flask;
  • O proxy Flask serve o painel React (a partir do caminho /app);
  • O app React renderiza a página e carrega a interface do MLflow dentro de um iframe apontando para /mlflow-ui/;
  • A partir desse ponto, cada requisição do iframe passa pelo proxy Flask — seja para carregar páginas da interface ou para chamar endpoints como /api/2.0/mlflow/experiments/search;
  • O proxy assina cada requisição com SigV4 usando credenciais temporárias e a encaminha para o endpoint serverless do MLflow App;
  • Quando o MLflow App responde, o proxy reescreve URLs absolutas para caminhos relativos e remove os cabeçalhos X-Frame-Options antes de devolver a resposta ao navegador.

O resultado é que os usuários veem a interface completa do MLflow — experimentos, execuções, métricas e registro de modelos — diretamente no navegador, com toda a autenticação AWS sendo tratada nos bastidores.

Pré-requisitos para o deploy

Antes de iniciar o processo de implantação, é necessário ter em mãos:

  • Uma conta AWS;
  • AWS Command Line Interface (AWS CLI) v2.34.5 ou posterior (necessário para os comandos create-mlflow-app, list-mlflow-apps e describe-mlflow-app);
  • Python 3.13 ou posterior instalado localmente;
  • AWS CDK v2 (aws-cdk-lib 2.243.0 ou posterior) instalado e com bootstrap feito na conta e região alvo. Para instruções, consulte Primeiros passos com o AWS CDK;
  • Node.js 18.x ou posterior instalado localmente para o deploy com CDK;
  • Permissões IAM suficientes para criar VPCs, instâncias EC2, ALBs, domínios SageMaker AI, MLflow Apps e roles IAM;
  • Uma AMI Ubuntu 24.04 LTS disponível na região AWS alvo (resolvida automaticamente via SSM Parameter Store).

Em relação aos custos, a solução cria recursos AWS que podem gerar cobranças — principalmente instâncias EC2, Application Load Balancer, recursos do SageMaker AI e armazenamento no Amazon Simple Storage Service (Amazon S3). Use a Calculadora de Preços da AWS para estimar os valores antes do deploy.

Realizando o deploy da solução

Passo 1: Clonar o repositório e implantar a infraestrutura

Faça o download do código da solução e instale as dependências:

# Clone the repository
git clone https://github.com/aws-samples/sample-sagemaker-mlflow-embedded-ui.git

# Navigate to project directory and install dependencies
cd sample-sagemaker-mlflow-embedded-ui
npm install

Defina o ID da conta AWS e a região como variáveis de ambiente:

export CDK_DEFAULT_ACCOUNT=<your-account-id>
export CDK_DEFAULT_REGION=<your-region>
export AWS_DEFAULT_REGION=<your-region>
export AWS_REGION=<your-region>

Se você já fez deploy em uma região diferente anteriormente, delete o arquivo de contexto em cache:

rm -f cdk.context.json

Faça o bootstrap do ambiente para o AWS CDK (pule este passo se a conta e região já estiverem com bootstrap feito):

cdk bootstrap aws://<ACCOUNT_ID>/<REGION>

Execute o script de deploy para implantar as stacks:

bash deploy.sh

Anote o nome DNS do ALB e o ID da instância EC2 gerados na saída do deploy — você precisará deles nos próximos passos.

Passo 2: Configurar o serviço de proxy Flask na instância EC2

Acesse a instância EC2 usando o ID obtido no Passo 1, via AWS Systems Manager Session Manager. Consulte o guia de conexão do Session Manager para instruções detalhadas.

Instale o Python 3.13 e as dependências:

# Switch to root user
sudo su -
cd /root

# Install Python and dependencies
chmod +x install_python13.sh
./install_python13.sh

Instale e inicie o serviço de proxy MLflow:

chmod +x setup_mlflow_proxy_app.sh
./setup_mlflow_proxy_app.sh

Verifique o status do serviço de proxy Flask:

systemctl status mlflowproxy

Se o serviço não estiver em execução, verifique os logs com:

journalctl -u mlflowproxy

Passo 3: Validar o deploy

Para recuperar a URL do ALB via AWS CloudFormation:

aws cloudformation describe-stacks --stack-name sagemaker-infra-flaskapp --query 'Stacks[0].Outputs[?OutputKey==`ALBUrl`].OutputValue' --output text

Acesse a URL do ALB no navegador em http://<ALB-URL>/. Você será redirecionado automaticamente para /app, onde o painel React exibirá a interface do MLflow incorporada em um iframe.

Verifique o endpoint de saúde do serviço:

curl http://<ALB-URL>/health

A resposta esperada é {"status": "healthy"}.

Para testar o rastreamento de experimentos via API REST do MLflow, crie um experimento e anote o ID retornado na resposta:

curl -X POST http://<ALB-URL>/api/2.0/mlflow/experiments/create \
  -H "Content-Type: application/json" \
  -d '{"name": "my-first-experiment"}'

Crie uma execução (run) e registre métricas e parâmetros:

curl -X POST http://<ALB-URL>/api/2.0/mlflow/runs/create \
  -H "Content-Type: application/json" \
  -d '{"experiment_id": "<ID>", "run_name": "training-run-1"}'

curl -X POST http://<ALB-URL>/api/2.0/mlflow/runs/log-parameter \
  -H "Content-Type: application/json" \
  -d '{"run_id": "<RUN_ID>", "key": "learning_rate", "value": "0.01"}'

curl -X POST http://<ALB-URL>/api/2.0/mlflow/runs/log-metric \
  -H "Content-Type: application/json" \
  -d '{"run_id": "<RUN_ID>", "key": "accuracy", "value": 0.95, "timestamp": 1700000000000, "step": 1}'

Atualize o painel React em http://<ALB-URL>/app para visualizar o experimento, as execuções, as métricas e os parâmetros que acabaram de ser criados.

Limpeza dos recursos

Para evitar cobranças contínuas e remover os recursos criados pela solução, execute o script de limpeza a partir da raiz do projeto:

bash cleanup.sh

O script destrói os recursos na ordem inversa de dependência: primeiro a stack do app Flask, depois deleta o MLflow App serverless via AWS CLI e aguarda a conclusão da exclusão. Em seguida, remove os recursos MLflow, o domínio SageMaker e as stacks de rede. A stack de rede inclui um recurso customizado baseado em AWS Lambda que limpa automaticamente sistemas de arquivos Amazon Elastic File System (Amazon EFS) criados pelo SageMaker AI, interfaces de rede órfãs e grupos de segurança antes de deletar a VPC.

Limpeza manual: o bucket Amazon S3 de artefatos do MLflow tem uma política de remoção RETAIN e precisa ser deletado manualmente, caso não seja mais necessário. Consulte como deletar um bucket de uso geral no Guia do Usuário do Amazon S3.

Detalhes das stacks CDK

A solução implanta quatro stacks CDK, cada uma responsável por uma camada distinta da arquitetura:

  • Stack de rede: cria a VPC e os componentes de rede associados, incluindo sub-redes públicas e privadas, tabelas de rotas e grupos de segurança;
  • Stack do domínio SageMaker AI: configura o domínio Amazon SageMaker AI, que serve como contêiner organizacional para os recursos SageMaker e fornece o contexto de identidade e acesso necessário para o MLflow App;
  • Stack do SageMaker MLflow: implanta o MLflow App serverless dentro do domínio SageMaker AI, armazenando experimentos, execuções, métricas e dados do registro de modelos;
  • Stack da aplicação Flask: implanta o serviço de proxy reverso Flask em uma instância EC2 atrás de um ALB, gerenciando a autenticação SigV4 e servindo o portal front-end React.

Próximos passos recomendados

Após o deploy do portal, a AWS sugere as seguintes extensões para ambientes de produção:

Conclusão

A solução descrita pela AWS mostra como construir um painel React com a interface do Amazon SageMaker AI MLflow Apps incorporada via iframe, sustentado por um proxy Flask que cuida da autenticação SigV4. O resultado é uma URL persistente e navegável para o rastreamento de experimentos MLflow, sem necessidade de URLs pré-assinadas, com integração direta a portais internos protegidos por SSO e toda a infraestrutura implantada como código com provisionamento e limpeza automatizados.

Para começar, clone o repositório de exemplo e implante a stack na sua conta AWS.

Fonte

Build a custom portal with embedded Amazon SageMaker AI MLflow Apps (https://aws.amazon.com/blogs/machine-learning/build-a-custom-portal-with-embedded-amazon-sagemaker-ai-mlflow-apps/)

Comments

Leave a Reply

Your email address will not be published. Required fields are marked *

More posts