Hospede seu LLM no Amazon SageMaker para programar com IA

A programação assistida por IA mudou de forma profunda o desenvolvimento de software: automatiza tarefas repetitivas, aumenta a precisão e libera os desenvolvedores para se concentrarem em problemas mais complexos. Cada vez mais, as empresas optam por hospedar seus LLMs em ambientes privados, sobretudo para proteger propriedade intelectual sensível e código proprietário, atender às normas de proteção de dados e viabilizar customizações sob medida para cada organização.

Neste post, vamos hospedar um LLM de marketplace no seu ambiente Amazon SageMaker, usando um modelo do Amazon SageMaker Jumpstart. A maioria dos agentes autônomos de programação com IA — como Roo Code, Cline e Continue.dev — oferece suporte a protocolos abertos como o da OpenAI, o que faz do LiteLLM um proxy OpenAI ideal para a inferência no SageMaker.

As empresas ganham com LLMs self-hosted em três frentes:

• Privacidade e segurança dos dados: hospedar internamente protege dados sensíveis, código-fonte e algoritmos proprietários.
• Customização: dá para adaptar os modelos de IA a estilos de código, regras de negócio e exigências regulatórias específicas.
• Otimização de custos: gerenciar e otimizar os recursos com eficiência reduz os custos em comparação com serviços de IA de terceiros.

A programação assistida por IA aumenta a produtividade e a eficiência em várias etapas do desenvolvimento de software, como:

• Automatizar a geração de código boilerplate
• Apoiar o debugging e a identificação de gargalos de desempenho
• Aprimorar processos de code review
• Acelerar o onboarding e o treinamento de novos desenvolvedores

• Segurança e conformidade: configure corretamente as roles do IAM, a criptografia e os controles de acesso.
• Gestão de custos: monitore e otimize o uso da infraestrutura de forma contínua.
• Otimização de desempenho: escolha os tipos de instância do SageMaker mais adequados à demanda dos seus workloads.

O Amazon SageMaker simplifica o self-hosting ao oferecer:

• Acesso a uma ampla variedade de LLMs pré-treinados pelo SageMaker Jumpstart.
• Gerenciamento de infraestrutura escalável, seguro e de alto desempenho.
• Integração fluida com os serviços da AWS, reduzindo a complexidade operacional.

Usar o AWS Fargate para implantar o proxy LiteLLM reduz bastante o overhead operacional, pois:

• Elimina a necessidade de gerenciar infraestrutura manualmente e fazer manutenção de servidores.
• Cuida automaticamente do escalonamento e da disponibilidade, garantindo desempenho consistente.
• Reduz a complexidade da gestão de segurança com isolamento e ambientes gerenciados pela AWS.

1. Implante um modelo no endpoint do Amazon SageMaker para inferência em tempo real;
2. Os Engineers que usam assistentes de programação com IA em IDEs locais, como o VSCodium, conectam-se com segurança ao LiteLLM OpenAI Proxy por um canal protegido para invocá-lo.

Primeiro, vamos implantar um modelo pré-treinado como endpoint do Amazon SageMaker. Em seguida, vamos rodar um proxy OpenAI com LiteLLM como serviço ECS.

A partir daí, os desenvolvedores já podem se conectar ao proxy OpenAI. Para simplificar, este tutorial faz a conexão pelo IP público da task ECS.

Pré-requisito: antes de provisionar um endpoint do Amazon SageMaker, talvez seja preciso confirmar que sua conta tem cota de pelo menos 1 para o tipo de instância que será usado no endpoint. Você pode verificar em https://console.aws.amazon.com/servicequotas/home/services/sagemaker/quotas. Vamos usar a ml.g5.12xlarge, então sua conta precisa ter cota de pelo menos 1. Caso contrário, é possível abrir uma solicitação selecionando "Request increase at account level."

1. Se você ainda não tem uma execution role do Amazon SageMaker (https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html), crie uma role do IAM para a execução do SageMaker. Vamos chamá-la de AmazonSageMaker-Endpoints-ExecutionRole, anexar a managed policy arn:aws:iam::aws:policy/AmazonSageMakerFullAccess e a trust policy para sagemaker.amazonaws.com:

{
    "Version": "2012-10-17",
    "Statement": [\
        {\
            "Effect": "Allow",\
            "Principal": {\
                "Service": "sagemaker.amazonaws.com"\
            },\
            "Action": "sts:AssumeRole"\
        }\
    ]
}

2. Identifique a VPC, as Subnets privadas e o endpoint do Amazon SageMaker que será implantado.

3. Crie um VPC endpoint do S3 para que o endpoint do Amazon SageMaker consiga baixar o modelo pré-treinado do bucket S3:

aws ec2 create-vpc-endpoint \
    --private-dns-enabled \
    --vpc-id <vpc-id> \
    --service-name com.amazonaws.<region>.s3 \
    --route-table-ids <route-table-id>

Se o comando rodar com sucesso, a route table deve listar o VPC Endpoint junto com o NAT, por exemplo:

% aws ec2 describe-route-tables --route-table-ids <route-table-id> --query 'RouteTables[*].Routes'
[\
    [\
        {\
            "DestinationCidrBlock": "10.0.0.0/23",\
            "GatewayId": "local",\
            "Origin": "CreateRouteTable",\
            "State": "active"\
        },\
        {\
            "DestinationCidrBlock": "0.0.0.0/0",\
            "NatGatewayId": "nat-<NAT GW ID>",\
            "Origin": "CreateRoute",\
            "State": "active"\
        },\
        {\
            "DestinationPrefixListId": "pl-63a5400a",\
            "GatewayId": "vpce-<VPCE ID>",\
            "Origin": "CreateRoute",\
            "State": "active"\
        }\
    ]\
]

3. Crie um Security Group ecs-sagemaker-endpoint com:

Regra de entrada (inbound):

• Protocolo: HTTPS (443)
• Origem: o próprio security group (autorreferencial)

Regra de saída (outbound):

• Protocolo: HTTPS (443)
• Destino: VPC endpoint do S3

Observação: como boa prática de cibersegurança, o Security Group default não deve permitir nenhuma regra de entrada ou saída. Mais detalhes em https://docs.aws.amazon.com/securityhub/latest/userguide/ec2-controls.html#ec2-2

1. Escolha seu modelo no Amazon SageMaker Jumpstart (por exemplo, Qwen2, Mistral, Llama 3.2). A lista de modelos pré-treinados está em https://sagemaker.readthedocs.io/en/stable/doc_utils/pretrainedmodels.html.

2. Anote o Model ID e a versão para criar um modelo no Amazon SageMaker:

from sagemaker.jumpstart.model import JumpStartModel
jump_start_model = JumpStartModel(
    model_id="huggingface-llm-qwen2-7b-instruct",
    model_version="1.2.0",
    role="AmazonSageMaker-Endpoints-ExecutionRole",# ou a execution role do Amazon SageMaker correspondente
    vpc_config={
        "Subnets": [ "Private Subnets" ],
        "SecurityGroupIds": [ "ecs-sagemaker-endpoint" ]
    },
)
jump_start_model.deploy(
    initial_instance_count=1,
    instance_type="ml.g5.12xlarge",
    accept_eula=True,
    endpoint_name="jumpstart-model"
)

Confirme o status do endpoint pelo AWS CLI:

% aws sagemaker list-endpoints
{
    "Endpoints": [\
        {\
            "EndpointName": "jumpstart-model",\
            "EndpointArn": "arn:aws:sagemaker:<AWS REGION>:<AWS ACCOUNT ID>:endpoint/jumpstart-model",\
            "CreationTime": "<CreationTime>",\
            "LastModifiedTime": "<LastModifiedTime>",\
            "EndpointStatus": "InService"\
        }\
    ]
}

Detalhes sobre como configurar o proxy LiteLLM estão em https://docs.litellm.ai/docs/proxy/configs

1. Crie um arquivo YAML de configuração (config.yaml) para mapear o endpoint do SageMaker:

model_list:
  - model_name: jumpstart-model
    litellm_params:
      model: sagemaker/jumpstart-model # usa o namespace sagemaker e aponta para o nome do endpoint do Amazon SageMaker

2. Faça upload do config.yaml para um bucket S3.

3. Defina seu container ECS (container-definition.json):

[\
    {\
        "name": "litellm",\
        "image": "ghcr.io/berriai/litellm:main-latest",\
        "cpu": 0,\
        "portMappings": [\
            {\
                "containerPort": 4000,\
                "hostPort": 4000,\
                "protocol": "tcp"\
            }\
        ],\
        "essential": true,\
        "environment": [\
            {\
                "name": "LITELLM_CONFIG_BUCKET_OBJECT_KEY",\
                "value": "config.yaml"\
            },\
            {\
                "name": "LITELLM_CONFIG_BUCKET_NAME",\
                "value": "<S3 bucket>"\
            },\
            {\
                "name": "LITELLM_MASTER_KEY",\
                "value": "<API key para chamar o proxy, como sk-123123>"\
            }\
        ],\
        "mountPoints": [],\
        "volumesFrom": [],\
        "logConfiguration": {\
            "logDriver": "awslogs",\
            "options": {\
                "awslogs-group": "/ecs/litellm",\
                "awslogs-create-group": "true",\
                "awslogs-region": "us-east-1",\
                "awslogs-stream-prefix": "ecs"\
            }\
        },\
        "systemControls": []\
    }\
]

3. Crie uma role do IAM para a task role do ECS com privilégios mínimos, conforme abaixo:

{
    "Version": "2012-10-17",
    "Statement": [\
        {\
            "Sid": "Statement1",\
            "Effect": "Allow",\
            "Action": [\
                "sagemaker:InvokeEndpoint"\
            ],\
            "Resource": [\
                "arn:aws:sagemaker:<AWS REGION>:<AWS ACCOUNT ID>:endpoint/jumpstart-model"\
            ]\
        }\
    ]
}

4. Registre a task definition do ECS:

aws ecs register-task-definition \
    --family litellm-task \
    --requires-compatibilities FARGATE \
    --cpu 1024 \
    --memory 2048 \
    --network-mode awsvpc \
    --runtime-platform cpuArchitecture=ARM64 \
    --task-role-arn "<ECS Task Role ARN>" \
    --container-definitions file://./container-definition.json \
    --region $REGION

Antes de criar o serviço ECS, precisamos das seguintes informações:

• O ID da subnet em que as tasks ECS vão rodar.
• O Security Group que permite que as tasks ECS se conectem aos endpoints do Amazon SageMaker. Neste artigo, criamos como ecs-sagemaker-endpoint.

Também precisamos criar um security group para que as tasks ECS consigam baixar a imagem do container LiteLLM:

Regra de saída (outbound):

• Protocolo: HTTPS (443)
• Destino: 0.0.0.0/0
• Descrição: download da imagem das ECS Tasks

Outro Security Group para o proxy se comunicar com as tasks ECS:

Regra de entrada (inbound):

• Protocolo: porta do LiteLLM (4000)
• Origem: o próprio security group (autorreferencial)

Regra de saída (outbound):

• Protocolo: porta do LiteLLM (4000)
• Destino: o próprio security group (autorreferencial)
• Descrição: proxy e as tasks ECS

Crie um serviço ECS com a task definition e o ID da subnet:

aws ecs create-service \
    --cluster litellm-cluster \
    --service-name litellm-service \
    --task-definition litellm-task:1 \
    --desired-count 1 \
    --launch-type FARGATE \
    --platform-version LATEST \
    --network-configuration "awsvpcConfiguration={subnets=[<SUBNET ID>],assignPublicIp=DISABLED},securityGroups=[<sg-xxx for ecs-sagemaker-endpoint>,<sg-xxx for ecs-443-outbound>,<sg-xxx for proxy-ecs-4000>]" \
    --region $REGION

Observação: como boa prática de cibersegurança, serviços ECS não devem ter endereços IP públicos. Mais detalhes em https://docs.aws.amazon.com/securityhub/latest/userguide/ecs-controls.html#ecs- 2

Recupere o IP privado da task ECS:

CLUSTER="litellm-cluster"
# passo 1: obtenha o id da task ECS
TASK=$(aws ecs list-tasks --cluster ${CLUSTER} --query "taskArns[0]" --output text)
# passo 2: obtenha a eni a partir da task ECS
ENI=$(aws ecs describe-tasks --cluster $CLUSTER --tasks $TASK --query "tasks[0].attachments[0].details[?name=='networkInterfaceId'].value | [0]" --output text)
# passo 3: obtenha o endereço IP público da ENI
aws ec2 describe-network-interfaces --network-interface-ids $ENI --query 'NetworkInterfaces[0].PrivateIpAddress' --output text

Anote o IP privado da task — ele será usado na configuração do proxy.

Neste exemplo, vamos provisionar uma EC2 na mesma subnet privada, gerenciada pelo Amazon System Manager, para nos conectarmos ao proxy LiteLLM via port forwarding do SSM.

1. Crie um novo Security Group, ssm-outbound-sg, para permitir conexões de saída na porta 443:

Regra de saída (outbound):

• Protocolo: HTTPS (443)
• Destino: 0.0.0.0/0
• Descrição: conexões com endpoints do SSM

1. Crie três VPC endpoints para que a EC2 na subnet privada se conecte aos endpoints do SSM:

# Endpoint do Systems Manager
aws ec2 create-vpc-endpoint \
    --vpc-id <vpc-id> \
    --vpc-endpoint-type Interface \
    --service-name com.amazonaws.<region>.ssm \
    --subnet-ids <private subnet-id em que a EC2 será provisionada> \
    --security-group-ids <security-group-id ao qual a EC2 se conecta, como ec2-ssm>

# Endpoint do SSM Messages
aws ec2 create-vpc-endpoint \
    --vpc-id <vpc-id> \
    --vpc-endpoint-type Interface \
    --service-name com.amazonaws.<region>.ssmmessages \
    --subnet-ids <private subnet-id em que a EC2 será provisionada> \
    --security-group-ids <security-group-id ao qual a EC2 se conecta, como ec2-ssm>

# Endpoint do EC2 Messages
aws ec2 create-vpc-endpoint \
    --vpc-id <vpc-id> \
    --vpc-endpoint-type Interface \
    --service-name com.amazonaws.<region>.ec2messages \
    --subnet-ids <private subnet-id em que a EC2 será provisionada> \
    --security-group-ids <security-group-id ao qual a EC2 se conecta, como ec2-ssm>

1. Crie uma EC2 Graviton, como a t4g.small, com Amazon Linux, na subnet privada.
2. Anexe estes security groups a essa EC2:

• Litellm-proxy, que libera saída na porta 4000 para o mesmo security group, para que essa EC2 proxy consiga se conectar à task ECS
• ssm-outbound-sg, para permitir que a EC2 se conecte aos endpoints do SSM

3. Quando a EC2 estiver pronta, conecte-se usando o agente do SSM com port forwarding:

aws ssm start-session \
--target <ID da instância EC2, como i-012345> \
--document-name AWS-StartPortForwardingSessionToRemoteHost \
--parameters host="<IP privado da task ECS>",portNumber="4000",localPortNumber="4000"

Instale o Continue.dev pelo marketplace, por exemplo em https://open-vsx.org/extension/Continue/continue, e abra a configuração local.

Configure as tasks ECS recém-criadas como provedor de modelo:

  "models": [\
    {\
      "title": "litellm",\
      "provider": "openai",\
      "model": "jumpstart-model",\
      "apiBase": "http://localhost:4000/",\
    }\
  ],

Depois de atualizar a configuração, é só anexar um arquivo para a IA te ajudar.

OBSERVAÇÃO: é altamente recomendável manter uma conexão segura entre o notebook do Engineer e o endpoint do proxy LiteLLM, por exemplo, com o AWS Client VPN.

Hospedar seu LLM no Amazon SageMaker dá às empresas um controle sem igual, privacidade de dados robusta e ganhos expressivos de produtividade no desenvolvimento de software. A DoiT International ajuda sua empresa a navegar por todas as complexidades do design e da implementação de soluções de IA self-hosted, seguras e com bom custo-benefício, sob medida para as suas necessidades.

Pronto para turbinar sua programação com segurança? Fale hoje mesmo com a DoiT International para discutir sua estratégia de IA corporativa e garantir privacidade de dados robusta e conformidade.