Como Implantar Llama 4 na AWS, Azure e Hugging Face

Este guia fornece instruções passo a passo para implantar os modelos Llama 4 da Meta (Scout e Maverick) em três plataformas principais: AWS, Azure e Hugging Face. Esses modelos oferecem capacidades avançadas, incluindo processamento multimodal, janelas de contexto massivas e desempenho de última geração.

Pré-requisitos & Requisitos de Hardware para Implantação do Llama 4

• Acesso aos modelos Llama 4 através do contrato de licença da Meta
• Conta do Hugging Face com token de acesso para LEITURA
• Conta AWS, Azure ou Hugging Face Pro conforme necessário para seu alvo de implantação
• Entendimento básico de containerização e serviços em nuvem

AWS (via TensorFuse)

• Scout: 8x GPUs H100 para contexto de 1M tokens
• Maverick: 8x GPUs H100 para contexto de 430K tokens
• Alternativa: 8x GPUs A100 (janela de contexto reduzida)

Azure

(Isso está alinhado com as diretrizes gerais do Azure ML para grandes modelos de linguagem, mas nenhuma documentação específica do Llama 4 foi encontrada para confirmar os requisitos exatos.)

• Recomendado: ND A100 v4-series (8 GPUs NVIDIA A100)
• Mínimo: Standard_ND40rs_v2 ou superior

Hugging Face

• Recomendado: hardware A10G-Large
• Alternativa: A100-Large (opção de hardware premium)
• Hardware do nível gratuito é insuficiente para modelos completos

1. Implantando Llama 4 na AWS usando TensorFuse

1.1 Configurar AWS e TensorFuse

Instale o TensorFuse CLI:

pip install tensorfuse

Configure as credenciais da AWS:

aws configure

Inicialize o TensorFuse com sua conta AWS:

tensorkube init

1.2 Criar Segredos Necessários

Armazene seu token do Hugging Face:

tensorkube secret create hugging-face-secret YOUR_HF_TOKEN --env default HUGGING_FACE_HUB_TOKEN=

Criar token de autenticação da API:

tensorkube secret create vllm-token vllm-key --env default VLLM_API_KEY=

1.3 Criar Dockerfile para Llama 4

Para o modelo Scout:

FROM vllm/vllm-openai:v0.8.3
ENV HF_HUB_ENABLE_HF_TRANSFER=1
EXPOSE 80
ENTRYPOINT ["python3", "-m", "vllm.entrypoints.openai.api_server", \\\\
            "--model", "meta-llama/Llama-4-Scout-17B-16E-Instruct", \\\\
            "--dtype", "bfloat16", \\\\
            "--trust-remote-code", \\\\
            "--tensor-parallel-size", "8", \\\\
            "--max-model-len", "1000000", \\\\
            "--port", "80", \\\\
            "--override-generation-config", "{\\\\"attn_temperature_tuning\\\\": true}", \\\\
            "--limit-mm-per-prompt", "image=10", \\\\
            "--kv-cache-dtype", "fp8", \\\\
            "--api-key", "${VLLM_API_KEY}"]

Para o modelo Maverick:

FROM vllm/vllm-openai:v0.8.3
ENV HF_HUB_ENABLE_HF_TRANSFER=1
EXPOSE 80
ENTRYPOINT ["python3", "-m", "vllm.entrypoints.openai.api_server", \\\\
            "--model", "meta-llama/Llama-4-Maverick-17B-128E-Instruct", \\\\
            "--dtype", "bfloat16", \\\\
            "--trust-remote-code", \\\\
            "--tensor-parallel-size", "8", \\\\
            "--max-model-len", "430000", \\\\
            "--port", "80", \\\\
            "--override-generation-config", "{\\\\"attn_temperature_tuning\\\\": true}", \\\\
            "--limit-mm-per-prompt", "image=10", \\\\
            "--kv-cache-dtype", "fp8", \\\\
            "--api-key", "${VLLM_API_KEY}"]

1.4 Criar Configuração de Implantação

Criar deployment.yaml:

gpus: 8
gpu_type: h100
secret:
  - huggingfacesecret
  - vllmtoken
min-scale: 1
readiness:
  httpGet:
    path: /health
    port: 80

1.5 Implantar na AWS

Implante seu serviço:

tensorkube deploy --config-file ./deployment.yaml

1.6 Acessar Seu Serviço Implantado

Liste implantações para obter a URL do seu ponto de extremidade:

tensorkube deployment list

Teste sua implantação:

curl --request POST \\\\
  --url YOUR_APP_URL/v1/completions \\\\
  --header 'Content-Type: application/json' \\\\
  --header 'Authorization: Bearer vllm-key' \\\\
  --data '{
    "model": "meta-llama/Llama-4-Scout-17B-16E-Instruct",
    "prompt": "Terra para Llama 4. O que você pode fazer?",
    "max_tokens": 1000
  }'

2. Implantando Llama 4 no Azure

2.1 Configurar Espaço de Trabalho do Azure ML

Instale o Azure CLI e as extensões do ML:

pip install azure-cli azure-ml
az login

Crie um espaço de trabalho do Azure ML:

az ml workspace create --name llama4-workspace --resource-group seu-grupo-de-recursos

2.2 Criar Cluster de Computação

az ml compute create --name llama4-cluster --type amlcompute --min-instances 0 \\\\
  --max-instances 1 --size Standard_ND40rs_v2 --vnet-name seu-nome-vnet \\\\
  --subnet sua-subnet --resource-group seu-grupo-de-recursos --workspace-name llama4-workspace

2.3 Registrar Modelo Llama 4 no Azure ML

Criar model.yml:

$schema: <https://azuremlschemas.azureedge.net/latest/model.schema.json>
name: llama-4-scout
version: 1
path: .
properties:
  model_name: "meta-llama/Llama-4-Scout-17B-16E-Instruct"

Registre o modelo:

az ml model create --file model.yml --resource-group seu-grupo-de-recursos --workspace-name llama4-workspace

2.4 Criar Configuração de Implantação

Criar deployment.yml:

$schema: <https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json>
name: llama4-deployment
endpoint_name: llama4-endpoint
model: azureml:llama-4-scout@latest
instance_type: Standard_ND40rs_v2
instance_count: 1
environment_variables:
  HUGGING_FACE_HUB_TOKEN: ${{secrets.HF_TOKEN}}
  VLLM_API_KEY: ${{secrets.VLLM_KEY}}
environment:
  image: vllm/vllm-openai:v0.8.3
  conda_file: conda.yml

Criar conda.yml:

channels:
  - conda-forge
dependencies:
  - python=3.10
  - pip
  - pip:
    - vllm==0.8.3
    - transformers
    - accelerate

2.5 Criar Ponto de Extremidade e Implantar

az ml online-endpoint create --name llama4-endpoint \\\\
  --resource-group seu-grupo-de-recursos --workspace-name llama4-workspace

az ml online-deployment create --file deployment.yml \\\\
  --resource-group seu-grupo-de-recursos --workspace-name llama4-workspace

2.6 Testar a Implantação

az ml online-endpoint invoke --name llama4-endpoint --request-file request.json \\\\
  --resource-group seu-grupo-de-recursos --workspace-name llama4-workspace

Onde request.json contém:

{
  "model": "meta-llama/Llama-4-Scout-17B-16E-Instruct",
  "prompt": "Terra para Llama 4. O que você pode fazer?",
  "max_tokens": 1000
}

3. Implantando Llama 4 no Hugging Face

3.1 Configurar Conta do Hugging Face

1. Crie uma conta no Hugging Face em https://huggingface.co/
2. Aceite o contrato de licença para os modelos Llama 4 em https://huggingface.co/meta-llama

3.2 Implantar Usando Espaços do Hugging Face

Navegue até https://huggingface.co/spaces e clique em "Criar novo Espaço"

Configure seu Espaço:

• Nome: llama4-deployment
• Licença: Selecione a licença apropriada
• SDK: Escolha Gradio
• Hardware do Espaço: A10G-Large (para melhor desempenho)
• Visibilidade: Privado ou Público com base em suas necessidades

Clone o repositório do Espaço:

git clone <https://huggingface.co/spaces/YOUR_USERNAME/llama4-deployment>
cd llama4-deployment

3.3 Criar Arquivos da Aplicação

Criar app.py:

import gradio as gr
import torch
from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
import os

# Adicione seu token HF ao ambiente ou Segredos
os.environ["HUGGING_FACE_HUB_TOKEN"] = "YOUR_HF_TOKEN"

# Carregue o modelo e o tokenizador com a configuração apropriada
model_id = "meta-llama/Llama-4-Scout-17B-16E-Instruct"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True
)

# Crie o pipeline
pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    max_length=2048
)

def generate_text(prompt, max_length=1000, temperature=0.7):
    # Formate o prompt de acordo com o formato Llama 4
    formatted_prompt = f"<|begin_of_text|><|user|>\\\\n{prompt}<|end_of_text|>\\\\n<|assistant|>"

    outputs = pipe(
        formatted_prompt,
        max_length=len(tokenizer.encode(formatted_prompt)) + max_length,
        temperature=temperature,
        do_sample=True,
    )

    return outputs[0]['generated_text'].replace(formatted_prompt, "")

# Crie a interface Gradio
demo = gr.Interface(
    fn=generate_text,
    inputs=[
        gr.Textbox(lines=4, placeholder="Digite seu prompt aqui...", label="Prompt"),
        gr.Slider(minimum=100, maximum=2000, value=1000, step=100, label="Comprimento Máximo"),
        gr.Slider(minimum=0.1, maximum=1.0, value=0.7, step=0.1, label="Temperatura")
    ],
    outputs="text",
    title="Demonstração do Llama 4",
    description="Gere texto utilizando o modelo Llama 4 da Meta",
)

demo.launch()

Criar requirements.txt:

accelerate>=0.20.3
bitsandbytes>=0.41.1
gradio>=3.50.0
torch>=2.0.1
transformers>=4.34.0

3.4 Implantar no Hugging Face

Faça o push para seu Espaço do Hugging Face:

git add app.py requirements.txt
git commit -m "Adicionar implantação do Llama 4"
git push

3.5 Monitorar a Implantação

1. Visite a URL do seu Espaço: https://huggingface.co/spaces/YOUR_USERNAME/llama4-deployment
2. A primeira construção levará tempo, pois precisa baixar e configurar o modelo
3. Uma vez implantado, você verá uma interface Gradio onde pode interagir com o modelo

4. Testando e Interagindo com Suas Implantações

4.1 Usando Cliente Python para Acesso à API (AWS e Azure)

import openai

# Para AWS
client = openai.OpenAI(
    base_url="YOUR_AWS_URL/v1",  # Da lista de implantações do tensorkube
    api_key="vllm-key"  # Sua chave da API configurada
)

# Para Azure
client = openai.AzureOpenAI(
    azure_endpoint="YOUR_AZURE_ENDPOINT",
    api_key="YOUR_API_KEY",
    api_version="2023-05-15"
)

# Faça uma requisição de completude de texto
response = client.completions.create(
    model="meta-llama/Llama-4-Scout-17B-16E-Instruct",
    prompt="Escreva um poema curto sobre inteligência artificial.",
    max_tokens=200
)

print(response.choices[0].text)

# Para capacidades multimodais (se suportadas)
import base64

# Carregue a imagem como base64
with open("image.jpg", "rb") as image_file:
    image_base64 = base64.b64encode(image_file.read()).decode('utf-8')

# Crie uma completude de chat com a imagem
response = client.chat.completions.create(
    model="meta-llama/Llama-4-Scout-17B-16E-Instruct",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Descreva esta imagem:"},
                {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{image_base64}"}}
            ]
        }
    ],
    max_tokens=300
)

print(response.choices[0].message.content)

Conclusão

Agora você possui instruções passo a passo para implantar modelos Llama 4 na AWS, Azure e Hugging Face. Cada plataforma oferece diferentes vantagens:

• AWS com TensorFuse: Controle total, alta escalabilidade, melhor desempenho
• Azure: Integração com o ecossistema da Microsoft, serviços de ML gerenciados
• Hugging Face: Configuração mais simples, excelente para prototipagem e demonstrações

Escolha a plataforma que melhor se encaixa em suas necessidades específicas de custo, escala, desempenho e facilidade de gerenciamento.