Comment déployer Llama 4 sur AWS, Azure et Hugging Face

Ce guide fournit des instructions étape par étape pour le déploiement des modèles Llama 4 de Meta (Scout et Maverick) sur trois plateformes majeures : AWS, Azure et Hugging Face. Ces modèles offrent des capacités avancées, notamment le traitement multimodal, des fenêtres contextuelles massives et des performances de pointe.

Prérequis et exigences matérielles pour le déploiement de Llama 4

• Accès aux modèles Llama 4 via l'accord de licence de Meta
• Compte Hugging Face avec jeton d'accès READ
• Compte AWS, Azure ou Hugging Face Pro selon les besoins de votre cible de déploiement
• Compréhension de base de la conteneurisation et des services cloud

AWS (via TensorFuse)

• Scout : 8x GPU H100 pour un contexte de 1M tokens
• Maverick : 8x GPU H100 pour un contexte de 430K tokens
• Alternative : 8x GPU A100 (fenêtre contextuelle réduite)

Azure

(Ceci s'aligne sur les directives générales d'Azure ML pour les grands modèles de langage, mais aucune documentation spécifique à Llama 4 n'a été trouvée pour confirmer les exigences exactes.)

• Recommandé : ND A100 série v4 (8 GPU NVIDIA A100)
• Minimum : Standard_ND40rs_v2 ou supérieur

Hugging Face

• Recommandé : Matériel A10G-Large Space
• Alternative : A100-Large (option matérielle premium)
• Le matériel de niveau gratuit est insuffisant pour les modèles complets

1. Déploiement de Llama 4 sur AWS à l'aide de TensorFuse

1.1 Configuration d'AWS et de TensorFuse

Installer TensorFuse CLI :

pip install tensorfuse

Configurer les informations d'identification AWS :

aws configure

Initialiser TensorFuse avec votre compte AWS :

tensorkube init

1.2 Créer les secrets requis

Stocker votre jeton Hugging Face :

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

Créer un jeton d'authentification API :

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

1.3 Créer un Dockerfile pour Llama 4

Pour le modèle 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}"]

Pour le modèle 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 Créer la configuration de déploiement

Créer deployment.yaml :

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

1.5 Déployer sur AWS

Déployer votre service :

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

1.6 Accéder à votre service déployé

Lister les déploiements pour obtenir l'URL de votre point de terminaison :

tensorkube deployment list

Tester votre déploiement :

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": "Earth to Llama 4. What can you do?",
    "max_tokens": 1000
  }'

2. Déploiement de Llama 4 sur Azure

2.1 Configuration de l'espace de travail Azure ML

Installer les extensions Azure CLI et ML :

pip install azure-cli azure-ml
az login

Créer un espace de travail Azure ML :

az ml workspace create --name llama4-workspace --resource-group your-resource-group

2.2 Créer un cluster de calcul

az ml compute create --name llama4-cluster --type amlcompute --min-instances 0 \\\\
  --max-instances 1 --size Standard_ND40rs_v2 --vnet-name your-vnet-name \\\\
  --subnet your-subnet --resource-group your-resource-group --workspace-name llama4-workspace

2.3 Enregistrer le modèle Llama 4 dans Azure ML

Créer 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"

Enregistrer le modèle :

az ml model create --file model.yml --resource-group your-resource-group --workspace-name llama4-workspace

2.4 Créer la configuration de déploiement

Créer 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

Créer conda.yml :

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

2.5 Créer un point de terminaison et déployer

az ml online-endpoint create --name llama4-endpoint \\\\
  --resource-group your-resource-group --workspace-name llama4-workspace

az ml online-deployment create --file deployment.yml \\\\
  --resource-group your-resource-group --workspace-name llama4-workspace

2.6 Tester le déploiement

az ml online-endpoint invoke --name llama4-endpoint --request-file request.json \\\\
  --resource-group your-resource-group --workspace-name llama4-workspace

Où request.json contient :

{
  "model": "meta-llama/Llama-4-Scout-17B-16E-Instruct",
  "prompt": "Earth to Llama 4. What can you do?",
  "max_tokens": 1000
}

3. Déploiement de Llama 4 sur Hugging Face

3.1 Configuration du compte Hugging Face

1. Créer un compte Hugging Face sur https://huggingface.co/
2. Accepter l'accord de licence pour les modèles Llama 4 sur https://huggingface.co/meta-llama

3.2 Déploiement à l'aide de Hugging Face Spaces

Accéder à https://huggingface.co/spaces et cliquer sur "Create new Space"

Configurer votre Space :

• Name : llama4-deployment
• License : Sélectionner la licence appropriée
• SDK : Choisir Gradio
• Space Hardware : A10G-Large (pour de meilleures performances)
• Visibility : Privé ou Public en fonction de vos besoins

Cloner le dépôt Space :

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

3.3 Créer les fichiers d'application

Créer app.py :

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

# Ajouter votre jeton HF à l'environnement ou aux Secrets
os.environ["HUGGING_FACE_HUB_TOKEN"] = "YOUR_HF_TOKEN"

# Charger le modèle et le tokenizer avec la configuration appropriée
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
)

# Créer le pipeline
pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    max_length=2048
)

def generate_text(prompt, max_length=1000, temperature=0.7):
    # Formater l'invite selon le format 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, "")

# Créer l'interface Gradio
demo = gr.Interface(
    fn=generate_text,
    inputs=[
        gr.Textbox(lines=4, placeholder="Entrez votre invite ici...", label="Invite"),
        gr.Slider(minimum=100, maximum=2000, value=1000, step=100, label="Longueur maximale"),
        gr.Slider(minimum=0.1, maximum=1.0, value=0.7, step=0.1, label="Température")
    ],
    outputs="text",
    title="Démo Llama 4",
    description="Générer du texte à l'aide du modèle Llama 4 de Meta",
)

demo.launch()

Créer requirements.txt :

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

3.4 Déployer sur Hugging Face

Envoyer vers votre Hugging Face Space :

git add app.py requirements.txt
git commit -m "Ajouter le déploiement Llama 4"
git push

3.5 Surveiller le déploiement

1. Visiter l'URL de votre Space : https://huggingface.co/spaces/YOUR_USERNAME/llama4-deployment
2. La première construction prendra du temps car elle doit télécharger et configurer le modèle
3. Une fois déployé, vous verrez une interface Gradio où vous pourrez interagir avec le modèle

4. Tester et interagir avec vos déploiements

4.1 Utilisation du client Python pour l'accès API (AWS et Azure)

import openai

# Pour AWS
client = openai.OpenAI(
    base_url="YOUR_AWS_URL/v1",  # De la liste de déploiement tensorkube
    api_key="vllm-key"  # Votre clé API configurée
)

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

# Effectuer une requête de complétion de texte
response = client.completions.create(
    model="meta-llama/Llama-4-Scout-17B-16E-Instruct",
    prompt="Écrivez un court poème sur l'intelligence artificielle.",
    max_tokens=200
)

print(response.choices[0].text)

# Pour les capacités multimodales (si prises en charge)
import base64

# Charger l'image en base64
with open("image.jpg", "rb") as image_file:
    image_base64 = base64.b64encode(image_file.read()).decode('utf-8')

# Créer une complétion de chat avec l'image
response = client.chat.completions.create(
    model="meta-llama/Llama-4-Scout-17B-16E-Instruct",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Décrivez cette image :"},
                {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{image_base64}"}}
            ]
        }
    ],
    max_tokens=300
)

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

Conclusion

Vous disposez maintenant d'instructions étape par étape pour le déploiement des modèles Llama 4 sur AWS, Azure et Hugging Face. Chaque plateforme offre des avantages différents :

• AWS avec TensorFuse : Contrôle total, haute évolutivité, meilleures performances
• Azure : Intégration avec l'écosystème Microsoft, services ML gérés
• Hugging Face : Configuration la plus simple, idéale pour le prototypage et les démos

Choisissez la plateforme qui correspond le mieux à vos exigences spécifiques en matière de coût, d'échelle, de performances et de facilité de gestion.