Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Démarrage
Ce guide explique comment déployer des modèles Amazon Nova personnalisés sur des points de terminaison SageMaker en temps réel, configurer les paramètres d'inférence et invoquer vos modèles à des fins de test.
## Conditions préalables
Les conditions requises pour déployer des modèles Amazon Nova par SageMaker inférence sont les suivantes :
+ Créer un Compte AWS - Si vous n'en avez pas déjà un, consultez la section [Création d'un AWS compte](https://docs.aws.amazon.com//sagemaker/latest/dg/gs-set-up.html#sign-up-for-aws).
+ Autorisations IAM requises : assurez-vous que les politiques gérées suivantes sont associées à votre utilisateur ou à votre rôle IAM :
+ `AmazonSageMakerFullAccess`
+ `AmazonS3FullAccess`
+ SDKs/CLI Versions requises : les versions du SDK suivantes ont été testées et validées par inférence avec les modèles Amazon SageMaker Nova :
+ SageMaker SDK Python v3.0.0\+ (`sagemaker>=3.0.0`) pour une approche d'API basée sur les ressources
+ Boto3 version 1.35.0\+ (`boto3>=1.35.0`) pour les appels d'API directs. Les exemples présentés dans ce guide utilisent cette approche.
+ Augmentation du quota de service : demandez une augmentation du quota de SageMaker service Amazon pour le type d'instance ML que vous prévoyez d'utiliser pour votre point de terminaison SageMaker Inference (par exemple,`ml.p5.48xlarge for endpoint usage`). Pour obtenir la liste des types d’instances, consultez [Modèles et instances pris en charge](nova-model-sagemaker-inference.md#nova-sagemaker-inference-supported). Pour demander une augmentation, voir [Demande d'augmentation de quota](https://docs.aws.amazon.com//servicequotas/latest/userguide/request-quota-increase.html). Pour plus d'informations sur les quotas d' SageMaker instance, consultez la section [SageMaker Points de terminaison et quotas](https://docs.aws.amazon.com//general/latest/gr/sagemaker.html).
**Astuce**
Pour un déploiement rapide de bout en bout, vous pouvez exécuter le [bloc-notes Custom Nova Model SageMaker Inference](https://github.com/aws-samples/amazon-nova-samples/blob/main/customization/Nova_2.0/05_deployment/Custom-Nova-Model-SageMaker-Inference.ipynb) pour déployer un modèle Amazon Nova personnalisé par SageMaker inférence dans un seul bloc-notes.
## Étape 1 : Configuration des AWS informations d'identification
Configurez vos AWS informations d'identification à l'aide de l'une des méthodes suivantes :
**Option 1 : AWS CLI (recommandée)**
```
aws configure
```
Entrez votre clé AWS d'accès, votre clé secrète et votre région par défaut lorsque vous y êtes invité.
**Option 2 : fichier AWS d'informations d'identification**
Créez ou modifiez `~/.aws/credentials` :
```
[default]
aws_access_key_id = YOUR_ACCESS_KEY
aws_secret_access_key = YOUR_SECRET_KEY
```
**Option 3 : variables d'environnement**
```
export AWS_ACCESS_KEY_ID=your_access_key
export AWS_SECRET_ACCESS_KEY=your_secret_key
```
**Note**
Pour plus d'informations sur les informations AWS d'identification, consultez [Configuration et paramètres du fichier d'informations d'identification](https://docs.aws.amazon.com//cli/latest/userguide/cli-configure-files.html).
**Initialiser les clients AWS **
Créez un script ou un bloc-notes Python avec le code suivant pour initialiser le AWS SDK et vérifier vos informations d'identification :
```
import boto3
# AWS Configuration - Update these for your environment
REGION = "us-east-1" # Supported regions: us-east-1, us-west-2
AWS_ACCOUNT_ID = "YOUR_ACCOUNT_ID" # Replace with your AWS account ID
# Initialize AWS clients using default credential chain
sagemaker = boto3.client('sagemaker', region_name=REGION)
sts = boto3.client('sts')
# Verify credentials
try:
identity = sts.get_caller_identity()
print(f"Successfully authenticated to AWS Account: {identity['Account']}")
if identity['Account'] != AWS_ACCOUNT_ID:
print(f"Warning: Connected to account {identity['Account']}, expected {AWS_ACCOUNT_ID}")
except Exception as e:
print(f"Failed to authenticate: {e}")
print("Please verify your credentials are configured correctly.")
```
Si l'authentification est réussie, vous devriez voir un message confirmant l'identifiant de votre AWS compte.
## Étape 2 : Création d'un rôle SageMaker d'exécution
Un rôle SageMaker d'exécution est un rôle IAM qui accorde des SageMaker autorisations pour accéder aux AWS ressources en votre nom, telles que les compartiments Amazon S3 pour les artefacts du modèle et CloudWatch pour la journalisation.
**Création du rôle d'exécution**
**Note**
La création de rôles IAM nécessite `iam:CreateRole` et `iam:AttachRolePolicy` autorisations. Assurez-vous que votre utilisateur ou rôle IAM dispose de ces autorisations avant de continuer.
Le code suivant crée un rôle IAM doté des autorisations nécessaires pour déployer des modèles personnalisés Amazon Nova :
```
import json
# Create SageMaker Execution Role
role_name = f"SageMakerInference-ExecutionRole-{AWS_ACCOUNT_ID}"
trust_policy = {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {"Service": "sagemaker.amazonaws.com"},
"Action": "sts:AssumeRole"
}
]
}
iam = boto3.client('iam', region_name=REGION)
# Create the role
role_response = iam.create_role(
RoleName=role_name,
AssumeRolePolicyDocument=json.dumps(trust_policy),
Description='SageMaker execution role with S3 and SageMaker access'
)
# Attach required policies
iam.attach_role_policy(
RoleName=role_name,
PolicyArn='arn:aws:iam::aws:policy/AmazonSageMakerFullAccess'
)
iam.attach_role_policy(
RoleName=role_name,
PolicyArn='arn:aws:iam::aws:policy/AmazonS3FullAccess'
)
SAGEMAKER_EXECUTION_ROLE_ARN = role_response['Role']['Arn']
print(f"Created SageMaker execution role: {SAGEMAKER_EXECUTION_ROLE_ARN}")
```
**Utilisation d'un rôle d'exécution existant (facultatif)**
Si vous avez déjà un rôle SageMaker d'exécution, vous pouvez l'utiliser à la place :
```
# Replace with your existing role ARN
SAGEMAKER_EXECUTION_ROLE_ARN = "arn:aws:iam::YOUR_ACCOUNT_ID:role/YOUR_EXISTING_ROLE_NAME"
```
Pour rechercher des SageMaker rôles existants dans votre compte, procédez comme suit :
```
iam = boto3.client('iam', region_name=REGION)
response = iam.list_roles()
sagemaker_roles = [role for role in response['Roles'] if 'SageMaker' in role['RoleName']]
for role in sagemaker_roles:
print(f"{role['RoleName']}: {role['Arn']}")
```
**Important**
Le rôle d'exécution doit avoir une relation de confiance `sagemaker.amazonaws.com` et être autorisé à accéder à Amazon S3 et à SageMaker ses ressources.
Pour plus d'informations sur les rôles SageMaker d'exécution, consultez la section [SageMaker Rôles](https://docs.aws.amazon.com//sagemaker/latest/dg/sagemaker-roles.html).
## Étape 3 : Configuration des paramètres du modèle
Configurez les paramètres de déploiement pour votre modèle Amazon Nova. Ces paramètres contrôlent le comportement du modèle, l'allocation des ressources et les caractéristiques d'inférence. Pour obtenir une liste des types d'instances pris en charge et des valeurs CONTEXT\_LENGTH et MAX\_CONCURRENCY prises en charge pour chacun, consultez. [Modèles et instances pris en charge](nova-model-sagemaker-inference.md#nova-sagemaker-inference-supported) Pour une liste complète des fonctionnalités supplémentaires du conteneur, telles que les valeurs par défaut d'échantillonnage, le décodage spéculatif et la quantification, consultez. [Caractéristiques du conteneur d'inférence](nova-sagemaker-inference-container-features.md)
**Paramètres requis**
+ `IMAGE`: URI de l'image du conteneur Docker pour le conteneur d'inférence Amazon Nova. Cela sera fourni par AWS.
+ `CONTEXT_LENGTH`: longueur du contexte du modèle.
+ `MAX_CONCURRENCY`: nombre maximum de séquences par itération ; définit la limite du nombre de demandes utilisateur individuelles (invites) pouvant être traitées simultanément au sein d'un même lot sur le GPU. Plage : entier supérieur à 0.
**Configurez votre déploiement**
```
# AWS Configuration
REGION = "us-east-1" # Must match region from Step 1
# ECR Account mapping by region
ECR_ACCOUNT_MAP = {
"us-east-1": "708977205387",
"us-west-2": "176779409107"
}
# Container Image
IMAGE = f"{ECR_ACCOUNT_MAP[REGION]}.dkr.ecr.{REGION}.amazonaws.com/nova-inference-repo:SM-Inference-latest"
print(f"IMAGE = {IMAGE}")
# Required parameters
CONTEXT_LENGTH = "8000" # Maximum total context length
MAX_CONCURRENCY = "8" # Maximum concurrent sequences
# Build environment variables for the container
environment = {
'CONTEXT_LENGTH': CONTEXT_LENGTH,
'MAX_CONCURRENCY': MAX_CONCURRENCY,
# Optional: add container feature environment variables here.
# See "Inference Container Features" for the full list.
# Examples:
# 'DEFAULT_TEMPERATURE': '0.7',
# 'DEFAULT_MAX_NEW_TOKENS': '512',
# 'QUANTIZATION_DTYPE': 'fp8',
}
print("Environment configuration:")
for key, value in environment.items():
print(f" {key}: {value}")
```
**Configuration des paramètres spécifiques au déploiement**
Configurez maintenant les paramètres spécifiques pour le déploiement de votre modèle Amazon Nova, notamment l'emplacement des artefacts du modèle et la sélection du type d'instance.
**Définir l'identifiant de déploiement**
```
# Deployment identifier - use a descriptive name for your use case
JOB_NAME = "my-nova-deployment"
```
**Spécifier l'emplacement des artefacts du modèle**
Indiquez l'URI Amazon S3 où sont stockés vos artefacts de modèle Amazon Nova entraînés. Il doit s'agir de l'emplacement de sortie de votre tâche d'entraînement ou de mise au point de votre modèle.
```
# S3 location of your trained Nova model artifacts
# Replace with your model's S3 URI - must end with /
MODEL_S3_LOCATION = "s3://your-bucket-name/path/to/model/artifacts/"
```
**Sélectionnez la variante du modèle et le type d'instance**
```
# Configure model variant and instance type
TESTCASE = {
"model": "micro", # Options: micro, lite, lite2
"instance": "ml.g5.12xlarge" # Refer to "Supported models and instances" section
}
# Generate resource names
INSTANCE_TYPE = TESTCASE["instance"]
MODEL_NAME = JOB_NAME + "-" + TESTCASE["model"] + "-" + INSTANCE_TYPE.replace(".", "-")
ENDPOINT_CONFIG_NAME = MODEL_NAME + "-Config"
ENDPOINT_NAME = MODEL_NAME + "-Endpoint"
print(f"Model Name: {MODEL_NAME}")
print(f"Endpoint Config: {ENDPOINT_CONFIG_NAME}")
print(f"Endpoint Name: {ENDPOINT_NAME}")
```
**Conventions de dénomination**
Le code génère automatiquement des noms cohérents pour les AWS ressources :
+ Nom du modèle : `{JOB_NAME}-{model}-{instance-type}`
+ Config du point de terminaison : `{MODEL_NAME}-Config`
+ Nom du point de terminaison : `{MODEL_NAME}-Endpoint`
## Étape 4 : créer des SageMaker ressources et déployer le point de terminaison
SageMaker propose deux approches pour déployer des modèles sur des terminaux en temps réel. Choisissez l'approche adaptée à votre cas d'utilisation :
+ **Composants d'inférence** (recommandé) : déploie des modèles en tant que composants d'inférence sur un point de terminaison. Cette approche vous permet d'héberger plusieurs modèles sur un seul point de terminaison, de dimensionner les modèles indépendamment et d'optimiser l'utilisation des ressources.
+ **Points de terminaison de modèle uniques** : déploie un seul modèle directement sur un point de terminaison à l'aide d'un objet modèle et d'une configuration de point de terminaison. Cette approche est plus simple à configurer et convient au développement, aux tests ou aux charges de travail qui ne nécessitent qu'un seul modèle par point de terminaison.
### Option A : Création à l'aide de composants d'inférence
Avec les composants d'inférence, vous créez d'abord un point de terminaison, puis vous déployez votre modèle en tant que composant d'inférence sur ce point de terminaison. Cela permet de dissocier le modèle de l'infrastructure des terminaux, ce qui vous donne plus de flexibilité.
**Création de la configuration du point de terminaison**
Créez une configuration de point de terminaison qui définit l'infrastructure sans spécifier de modèle. Le type et le nombre d'instances sont gérés au niveau du point de terminaison :
```
# Create Endpoint Configuration for inference components
INFERENCE_COMPONENT_NAME = MODEL_NAME + "-IC"
try:
config_response = sagemaker.create_endpoint_config(
EndpointConfigName=ENDPOINT_CONFIG_NAME,
ProductionVariants=[
{
'VariantName': 'primary',
'InstanceType': INSTANCE_TYPE,
'InitialInstanceCount': 1,
'RoutingConfig': {
'RoutingStrategy': 'LEAST_OUTSTANDING_REQUESTS'
}
}
],
Tags=[
{
'Key': 'sagemaker:nova-inference-component',
'Value': 'true'
}
]
)
print("Endpoint configuration created successfully!")
print(f"Config ARN: {config_response['EndpointConfigArn']}")
except sagemaker.exceptions.ClientError as e:
print(f"Error creating endpoint configuration: {e}")
```
**Création et déploiement du point de terminaison**
```
import time
try:
endpoint_response = sagemaker.create_endpoint(
EndpointName=ENDPOINT_NAME,
EndpointConfigName=ENDPOINT_CONFIG_NAME
)
print("Endpoint creation initiated successfully!")
print(f"Endpoint ARN: {endpoint_response['EndpointArn']}")
except Exception as e:
print(f"Error creating endpoint: {e}")
# Wait for endpoint to be InService
print("Waiting for endpoint to be InService...")
print("This typically takes 5-10 minutes...\n")
while True:
try:
response = sagemaker.describe_endpoint(EndpointName=ENDPOINT_NAME)
status = response['EndpointStatus']
if status == 'Creating':
print(f"⏳ Status: {status} - Provisioning infrastructure...")
elif status == 'InService':
print(f"✅ Status: {status}")
print(f"\nEndpoint '{ENDPOINT_NAME}' is ready.")
break
elif status == 'Failed':
print(f"❌ Status: {status}")
print(f"Failure Reason: {response.get('FailureReason', 'Unknown')}")
break
else:
print(f"Status: {status}")
except Exception as e:
print(f"Error checking endpoint status: {e}")
break
time.sleep(30)
```
**Création du composant d'inférence**
Une fois le point de terminaison InService installé, déployez votre modèle Amazon Nova en tant que composant d'inférence :
```
try:
ic_response = sagemaker.create_inference_component(
InferenceComponentName=INFERENCE_COMPONENT_NAME,
EndpointName=ENDPOINT_NAME,
VariantName='primary',
Specification={
'Container': {
'Image': IMAGE,
'ArtifactUrl': MODEL_S3_LOCATION,
'Environment': environment
},
'ComputeResourceRequirements': {
'NumberOfCpuCoresRequired': 15,
'NumberOfAcceleratorDevicesRequired': 4,
'MinMemoryRequiredInMb': 25000
}
},
RuntimeConfig={
'CopyCount': 1
}
)
print("Inference component creation initiated!")
print(f"Inference Component ARN: {ic_response['InferenceComponentArn']}")
except sagemaker.exceptions.ClientError as e:
print(f"Error creating inference component: {e}")
```
Paramètres clés :
+ `InferenceComponentName`: identifiant unique pour votre composant d'inférence
+ `EndpointName`: point de terminaison sur lequel déployer le composant
+ `Image`: URI de l'image du conteneur Docker pour l'inférence Amazon Nova
+ `ArtifactUrl`: emplacement des artefacts de votre modèle sur Amazon S3
+ `Environment`: variables d'environnement configurées à l'étape 3
+ `NumberOfCpuCoresRequired`: nombre de cœurs de processeur requis par copie de modèle
+ `NumberOfAcceleratorDevicesRequired`: Nombre de dispositifs accélérateurs (GPU) requis par modèle de copie
+ `MinMemoryRequiredInMb`: mémoire minimale en Mo requise par copie du modèle
+ `CopyCount`: nombre de copies du modèle à déployer
**Surveiller le déploiement des composants d'inférence**
```
# Wait for inference component to be InService
print("Waiting for inference component deployment...")
print("This typically takes 10-20 minutes as the model is loaded...\n")
while True:
try:
ic_desc = sagemaker.describe_inference_component(
InferenceComponentName=INFERENCE_COMPONENT_NAME
)
ic_status = ic_desc['InferenceComponentStatus']
if ic_status == 'Creating':
print(f"⏳ Status: {ic_status} - Loading model artifacts...")
elif ic_status == 'InService':
print(f"✅ Status: {ic_status}")
print(f"\nInference component '{INFERENCE_COMPONENT_NAME}' is ready!")
break
elif ic_status == 'Failed':
print(f"❌ Status: {ic_status}")
print(f"Failure Reason: {ic_desc.get('FailureReason', 'Unknown')}")
break
else:
print(f"Status: {ic_status}")
except Exception as e:
print(f"Error checking inference component status: {e}")
break
time.sleep(30)
```
**Note**
Lorsque vous appelez le point de terminaison à l'étape 5, vous devez inclure le `InferenceComponentName` paramètre dans vos appels d'appel. Reportez-vous à l'étape 5 pour plus de détails.
### Option B : Création avec des points de terminaison d'un seul modèle
Avec des points de terminaison à modèle unique, vous créez un objet SageMaker modèle, une configuration de point de terminaison, puis vous déployez le point de terminaison. Cette approche intègre le modèle directement dans la configuration du point de terminaison.
**Création du SageMaker modèle**
Le code suivant crée un SageMaker modèle qui fait référence aux artefacts de votre modèle Amazon Nova :
```
try:
model_response = sagemaker.create_model(
ModelName=MODEL_NAME,
PrimaryContainer={
'Image': IMAGE,
'ModelDataSource': {
'S3DataSource': {
'S3Uri': MODEL_S3_LOCATION,
'S3DataType': 'S3Prefix',
'CompressionType': 'None'
}
},
'Environment': environment
},
ExecutionRoleArn=SAGEMAKER_EXECUTION_ROLE_ARN,
EnableNetworkIsolation=True
)
print("Model created successfully!")
print(f"Model ARN: {model_response['ModelArn']}")
except sagemaker.exceptions.ClientError as e:
print(f"Error creating model: {e}")
```
Paramètres clés :
+ `ModelName`: identifiant unique pour votre modèle
+ `Image`: URI de l'image du conteneur Docker pour l'inférence Amazon Nova
+ `ModelDataSource`: emplacement des artefacts de votre modèle sur Amazon S3
+ `Environment`: variables d'environnement configurées à l'étape 3
+ `ExecutionRoleArn`: rôle IAM à partir de l'étape 2
+ `EnableNetworkIsolation`: défini sur True pour une sécurité renforcée (empêche le conteneur de passer des appels réseau sortants)
**Création de la configuration du point de terminaison**
Créez ensuite une configuration de point de terminaison qui définit votre infrastructure de déploiement :
```
# Create Endpoint Configuration
try:
production_variant = {
'VariantName': 'primary',
'ModelName': MODEL_NAME,
'InitialInstanceCount': 1,
'InstanceType': INSTANCE_TYPE,
}
config_response = sagemaker.create_endpoint_config(
EndpointConfigName=ENDPOINT_CONFIG_NAME,
ProductionVariants=[production_variant]
)
print("Endpoint configuration created successfully!")
print(f"Config ARN: {config_response['EndpointConfigArn']}")
except sagemaker.exceptions.ClientError as e:
print(f"Error creating endpoint configuration: {e}")
```
Paramètres clés :
+ `VariantName`: identifiant pour cette variante de modèle (utilisez « principal » pour les déploiements à modèle unique)
+ `ModelName`: fait référence au modèle créé ci-dessus
+ `InitialInstanceCount`: nombre d'instances à déployer (commencez par 1, puis augmentez ultérieurement si nécessaire)
+ `InstanceType`: type d'instance ML sélectionné à l'étape 3
**Déployer le terminal**
```
import time
try:
endpoint_response = sagemaker.create_endpoint(
EndpointName=ENDPOINT_NAME,
EndpointConfigName=ENDPOINT_CONFIG_NAME
)
print("Endpoint creation initiated successfully!")
print(f"Endpoint ARN: {endpoint_response['EndpointArn']}")
except Exception as e:
print(f"Error creating endpoint: {e}")
```
**Surveillez la création de terminaux**
Le code suivant interroge l'état du terminal jusqu'à ce que le déploiement soit terminé :
```
# Monitor endpoint creation progress
print("Waiting for endpoint creation to complete...")
print("This typically takes 15-30 minutes...\n")
while True:
try:
response = sagemaker.describe_endpoint(EndpointName=ENDPOINT_NAME)
status = response['EndpointStatus']
if status == 'Creating':
print(f"⏳ Status: {status} - Provisioning infrastructure and loading model...")
elif status == 'InService':
print(f"✅ Status: {status}")
print("\nEndpoint creation completed successfully!")
print(f"Endpoint Name: {ENDPOINT_NAME}")
print(f"Endpoint ARN: {response['EndpointArn']}")
break
elif status == 'Failed':
print(f"❌ Status: {status}")
print(f"Failure Reason: {response.get('FailureReason', 'Unknown')}")
print("\nFull response:")
print(response)
break
else:
print(f"Status: {status}")
except Exception as e:
print(f"Error checking endpoint status: {e}")
break
time.sleep(30) # Check every 30 seconds
```
**Vérifier la création de ressources**
Vous pouvez vérifier que vos ressources ont été créées avec succès :
```
# Describe the model
model_info = sagemaker.describe_model(ModelName=MODEL_NAME)
print(f"Model Status: {model_info['ModelName']} created")
# Describe the endpoint configuration
config_info = sagemaker.describe_endpoint_config(EndpointConfigName=ENDPOINT_CONFIG_NAME)
print(f"Endpoint Config Status: {config_info['EndpointConfigName']} created")
```
**Vérifiez que le terminal est prêt**
Quelle que soit l'approche que vous avez choisie, vous pouvez vérifier la configuration du point de terminaison :
```
# Get detailed endpoint information
endpoint_info = sagemaker.describe_endpoint(EndpointName=ENDPOINT_NAME)
print("\n=== Endpoint Details ===")
print(f"Endpoint Name: {endpoint_info['EndpointName']}")
print(f"Endpoint ARN: {endpoint_info['EndpointArn']}")
print(f"Status: {endpoint_info['EndpointStatus']}")
print(f"Creation Time: {endpoint_info['CreationTime']}")
print(f"Last Modified: {endpoint_info['LastModifiedTime']}")
# Get endpoint config for instance type details
endpoint_config_name = endpoint_info['EndpointConfigName']
endpoint_config = sagemaker.describe_endpoint_config(EndpointConfigName=endpoint_config_name)
# Display production variant details
for variant in endpoint_info['ProductionVariants']:
print(f"\nProduction Variant: {variant['VariantName']}")
print(f" Current Instance Count: {variant['CurrentInstanceCount']}")
print(f" Desired Instance Count: {variant['DesiredInstanceCount']}")
# Get instance type from endpoint config
for config_variant in endpoint_config['ProductionVariants']:
if config_variant['VariantName'] == variant['VariantName']:
print(f" Instance Type: {config_variant['InstanceType']}")
break
```
**Résolution des problèmes de création de terminaux**
Raisons de défaillance courantes :
+ **Capacité insuffisante** : le type d'instance demandé n'est pas disponible dans votre région
+ Solution : essayez un autre type d'instance ou demandez une augmentation de quota
+ **Autorisations IAM** : le rôle d'exécution ne dispose pas des autorisations nécessaires
+ Solution : vérifier que le rôle a accès aux artefacts du modèle Amazon S3 et aux SageMaker autorisations nécessaires
+ **Artefacts du modèle introuvables** : l'URI Amazon S3 est incorrecte ou inaccessible
+ Solution : vérifiez l'URI Amazon S3 et les autorisations du bucket, assurez-vous que vous vous trouvez dans la bonne région
+ Limites de **ressources : limites** de compte dépassées pour les points de terminaison ou les instances
+ Solution : demander une augmentation du quota de service via Service Quotas ou AWS Support
**Note**
Si vous devez supprimer un point de terminaison défaillant et recommencer à zéro :
```
sagemaker.delete_endpoint(EndpointName=ENDPOINT_NAME)
```
## Étape 5 : Invoquer le point de terminaison
Une fois que votre point de terminaison est en place InService, vous pouvez envoyer des demandes d'inférence pour générer des prédictions à partir de votre modèle Amazon Nova. SageMaker prend en charge les points de terminaison synchrones (en temps réel avec les modes streaming/non -streaming) et les points de terminaison asynchrones (Amazon S3-based pour le traitement par lots).
**Configuration du client d'exécution**
Créez un client SageMaker Runtime avec les paramètres de délai d'expiration appropriés :
```
import json
import boto3
import botocore
from botocore.exceptions import ClientError
# Configure client with appropriate timeouts
config = botocore.config.Config(
read_timeout=120, # Maximum time to wait for response
connect_timeout=10, # Maximum time to establish connection
retries={'max_attempts': 3} # Number of retry attempts
)
# Create SageMaker Runtime client
runtime_client = boto3.client('sagemaker-runtime', config=config, region_name=REGION)
```
**Création d'une fonction d'inférence universelle**
La fonction suivante gère à la fois les demandes de streaming et les demandes non liées au streaming. Il utilise la `INFERENCE_COMPONENT_NAME` variable définie à l'étape 4. Si vous avez déployé à l'aide de composants d'inférence (option A), ce paramètre était défini sur. `MODEL_NAME + "-IC"` Si vous avez déployé à l'aide de points de terminaison à modèle unique (option B), cela n'a pas été défini. Configurez-le donc sur `None` avant d'exécuter cette étape :
```
# Only needed if you followed Option B (single model endpoints) in Step 4:
# INFERENCE_COMPONENT_NAME = None
def invoke_nova_endpoint(request_body):
"""
Invoke Nova endpoint with automatic streaming detection.
Supports both inference component and single model endpoint deployments.
Args:
request_body (dict): Request payload containing prompt and parameters
Returns:
dict: Response from the model (for non-streaming requests)
None: For streaming requests (prints output directly)
"""
body = json.dumps(request_body)
is_streaming = request_body.get("stream", False)
# Build invoke parameters
invoke_params = {
'EndpointName': ENDPOINT_NAME,
'ContentType': 'application/json',
'Body': body
}
# Add InferenceComponentName if using inference components
if INFERENCE_COMPONENT_NAME:
invoke_params['InferenceComponentName'] = INFERENCE_COMPONENT_NAME
try:
print(f"Invoking endpoint ({'streaming' if is_streaming else 'non-streaming'})...")
if is_streaming:
response = runtime_client.invoke_endpoint_with_response_stream(**invoke_params)
event_stream = response['Body']
for event in event_stream:
if 'PayloadPart' in event:
chunk = event['PayloadPart']
if 'Bytes' in chunk:
data = chunk['Bytes'].decode()
print("Chunk:", data)
else:
# Non-streaming inference
invoke_params['Accept'] = 'application/json'
response = runtime_client.invoke_endpoint(**invoke_params)
response_body = response['Body'].read().decode('utf-8')
result = json.loads(response_body)
print("✅ Response received successfully")
return result
except ClientError as e:
error_code = e.response['Error']['Code']
error_message = e.response['Error']['Message']
print(f"❌ AWS Error: {error_code} - {error_message}")
except Exception as e:
print(f"❌ Unexpected error: {str(e)}")
```
**Exemple 1 : fin du Non-streaming chat**
Utilisez le format de chat pour les interactions conversationnelles :
```
# Non-streaming chat request
chat_request = {
"messages": [
{"role": "user", "content": "Hello! How are you?"}
],
"max_tokens": 100,
"max_completion_tokens": 100, # Alternative to max_tokens
"stream": False,
"temperature": 0.7,
"top_p": 0.9,
"top_k": 50,
"logprobs": True,
"top_logprobs": 3,
"allowed_token_ids": None, # List of allowed token IDs
"truncate_prompt_tokens": None, # Truncate prompt to this many tokens
"stream_options": None
}
response = invoke_nova_endpoint(chat_request)
```
**Exemple de réponse**:
```
{
"id": "chatcmpl-123456",
"object": "chat.completion",
"created": 1234567890,
"model": "default",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": "Hello! I'm doing well, thank you for asking. I'm here and ready to help you with any questions or tasks you might have. How can I assist you today?"
},
"logprobs": {
"content": [
{
"token": "Hello",
"logprob": -0.123,
"top_logprobs": [
{"token": "Hello", "logprob": -0.123},
{"token": "Hi", "logprob": -2.456},
{"token": "Hey", "logprob": -3.789}
]
}
# Additional tokens...
]
},
"finish_reason": "stop"
}
],
"usage": {
"prompt_tokens": 12,
"completion_tokens": 28,
"total_tokens": 40
}
}
```
**Exemple 2 : complétion de texte simple**
Utilisez le format de complétion pour une génération de texte simple :
```
# Simple completion request
completion_request = {
"prompt": "The capital of France is",
"max_tokens": 50,
"stream": False,
"temperature": 0.0,
"top_p": 1.0,
"top_k": -1, # -1 means no limit
"logprobs": 3, # Number of log probabilities to return
"allowed_token_ids": None, # List of allowed token IDs
"truncate_prompt_tokens": None, # Truncate prompt to this many tokens
"stream_options": None
}
response = invoke_nova_endpoint(completion_request)
```
**Exemple de réponse**:
```
{
"id": "cmpl-789012",
"object": "text_completion",
"created": 1234567890,
"model": "default",
"choices": [
{
"text": " Paris.",
"index": 0,
"logprobs": {
"tokens": [" Paris", "."],
"token_logprobs": [-0.001, -0.002],
"top_logprobs": [
{" Paris": -0.001, " London": -5.234, " Rome": -6.789},
{".": -0.002, ",": -4.567, "!": -7.890}
]
},
"finish_reason": "stop"
}
],
"usage": {
"prompt_tokens": 6,
"completion_tokens": 2,
"total_tokens": 8
}
}
```
**Exemple 3 : fin du chat en streaming**
```
# Streaming chat request
streaming_request = {
"messages": [
{"role": "user", "content": "Tell me a short story about a robot"}
],
"max_tokens": 200,
"stream": True,
"temperature": 0.7,
"top_p": 0.95,
"top_k": 40,
"logprobs": True,
"top_logprobs": 2,
"stream_options": {"include_usage": True}
}
invoke_nova_endpoint(streaming_request)
```
**Exemple de sortie de streaming :**
```
Chunk: data: {"id":"chatcmpl-029ca032-fa01-4868-80b7-c4cb1af90fb9","object":"chat.completion.chunk","created":1772060532,"model":"default","choices":[{"index":0,"delta":{"role":"assistant","content":""},"logprobs":null,"finish_reason":null}],"prompt_token_ids":null}
Chunk: data: {"id":"chatcmpl-029ca032-fa01-4868-80b7-c4cb1af90fb9","object":"chat.completion.chunk","created":1772060532,"model":"default","choices":[{"index":0,"delta":{"content":" Once"},"logprobs":{"content":[{"token":"\u2581Once","logprob":-0.6078429222106934,"bytes":[226,150,129,79,110,99,101],"top_logprobs":[{"token":"\u2581Once","logprob":-0.6078429222106934,"bytes":[226,150,129,79,110,99,101]},{"token":"\u2581In","logprob":-0.7864127159118652,"bytes":[226,150,129,73,110]}]}]},"finish_reason":null,"token_ids":null}]}
Chunk: data: {"id":"chatcmpl-029ca032-fa01-4868-80b7-c4cb1af90fb9","object":"chat.completion.chunk","created":1772060532,"model":"default","choices":[{"index":0,"delta":{"content":" upon"},"logprobs":{"content":[{"token":"\u2581upon","logprob":-0.0012345,"bytes":[226,150,129,117,112,111,110],"top_logprobs":[{"token":"\u2581upon","logprob":-0.0012345,"bytes":[226,150,129,117,112,111,110]},{"token":"\u2581a","logprob":-6.789,"bytes":[226,150,129,97]}]}]},"finish_reason":null,"token_ids":null}]}
Chunk: data: {"id":"chatcmpl-029ca032-fa01-4868-80b7-c4cb1af90fb9","object":"chat.completion.chunk","created":1772060532,"model":"default","choices":[{"index":0,"delta":{"content":" a"},"logprobs":{"content":[{"token":"\u2581a","logprob":-0.0001234,"bytes":[226,150,129,97],"top_logprobs":[{"token":"\u2581a","logprob":-0.0001234,"bytes":[226,150,129,97]},{"token":"\u2581time","logprob":-9.123,"bytes":[226,150,129,116,105,109,101]}]}]},"finish_reason":null,"token_ids":null}]}
Chunk: data: {"id":"chatcmpl-029ca032-fa01-4868-80b7-c4cb1af90fb9","object":"chat.completion.chunk","created":1772060532,"model":"default","choices":[{"index":0,"delta":{"content":" time"},"logprobs":{"content":[{"token":"\u2581time","logprob":-0.0023456,"bytes":[226,150,129,116,105,109,101],"top_logprobs":[{"token":"\u2581time","logprob":-0.0023456,"bytes":[226,150,129,116,105,109,101]},{"token":",","logprob":-6.012,"bytes":[44]}]}]},"finish_reason":null,"token_ids":null}]}
# Additional chunks...
Chunk: data: {"id":"chatcmpl-029ca032-fa01-4868-80b7-c4cb1af90fb9","object":"chat.completion.chunk","created":1772060532,"model":"default","choices":[{"index":0,"delta":{},"logprobs":null,"finish_reason":"stop"}],"usage":{"prompt_tokens":15,"completion_tokens":87,"total_tokens":102}}
Chunk: data: [DONE]
```
**Exemple 4 : achèvement d'une conversation multimodale**
Utilisez le format multimodal pour les entrées d'image et de texte :
```
# Multimodal chat request (if supported by your model)
multimodal_request = {
"messages": [
{
"role": "user",
"content": [
{"type": "text", "text": "What's in this image?"},
{"type": "image_url", "image_url": {"url": "data:image/jpeg;base64,..."}}
]
}
],
"max_tokens": 150,
"temperature": 0.3,
"top_p": 0.8,
"stream": False
}
response = invoke_nova_endpoint(multimodal_request)
```
**Exemple de réponse**:
```
{
"id": "chatcmpl-345678",
"object": "chat.completion",
"created": 1234567890,
"model": "default",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": "The image shows..."
},
"finish_reason": "stop"
}
],
"usage": {
"prompt_tokens": 1250,
"completion_tokens": 45,
"total_tokens": 1295
}
}
```
## Étape 6 : Nettoyer les ressources (facultatif)
Pour éviter d'encourir des frais inutiles, supprimez les AWS ressources que vous avez créées au cours de ce didacticiel. SageMaker les terminaux sont soumis à des frais pendant leur fonctionnement, même si vous ne faites pas activement de demandes d'inférence.
**Important**
La suppression de ressources est permanente et ne peut pas être annulée. Assurez-vous de ne plus avoir besoin de ces ressources avant de continuer.
**Initialiser le client de nettoyage**
```
import boto3
import time
# Initialize SageMaker client
sagemaker = boto3.client('sagemaker', region_name=REGION)
```
**Supprimer le composant d'inférence (si vous utilisez l'option A)**
Si vous avez déployé à l'aide de composants d'inférence, supprimez d'abord le composant d'inférence avant de supprimer le point de terminaison :
```
# Delete inference component (Option A only)
try:
print("Deleting inference component...")
sagemaker.delete_inference_component(InferenceComponentName=INFERENCE_COMPONENT_NAME)
print(f"✅ Inference component '{INFERENCE_COMPONENT_NAME}' deletion initiated")
except Exception as e:
print(f"❌ Error deleting inference component: {e}")
# Wait for inference component to be deleted before proceeding
print("Waiting for inference component deletion...")
while True:
try:
sagemaker.describe_inference_component(InferenceComponentName=INFERENCE_COMPONENT_NAME)
time.sleep(10)
except sagemaker.exceptions.ClientError as e:
if e.response['Error']['Code'] == 'ValidationException':
print("✅ Inference component successfully deleted")
break
else:
print(f"Error: {e}")
break
```
**Supprimer le point de terminaison**
```
try:
print("Deleting endpoint...")
sagemaker.delete_endpoint(EndpointName=ENDPOINT_NAME)
print(f"✅ Endpoint '{ENDPOINT_NAME}' deletion initiated")
print("Charges will stop once deletion completes (typically 2-5 minutes)")
except Exception as e:
print(f"❌ Error deleting endpoint: {e}")
```
**Note**
La suppression du point de terminaison est asynchrone. Vous pouvez contrôler l'état de suppression :
```
import time
print("Monitoring endpoint deletion...")
while True:
try:
response = sagemaker.describe_endpoint(EndpointName=ENDPOINT_NAME)
status = response['EndpointStatus']
print(f"Status: {status}")
time.sleep(10)
except sagemaker.exceptions.ClientError as e:
if e.response['Error']['Code'] == 'ValidationException':
print("✅ Endpoint successfully deleted")
break
else:
print(f"Error: {e}")
break
```
**Supprimer la configuration du point de terminaison**
Une fois le point de terminaison supprimé, supprimez la configuration du point de terminaison :
```
try:
print("Deleting endpoint configuration...")
sagemaker.delete_endpoint_config(EndpointConfigName=ENDPOINT_CONFIG_NAME)
print(f"✅ Endpoint configuration '{ENDPOINT_CONFIG_NAME}' deleted")
except Exception as e:
print(f"❌ Error deleting endpoint configuration: {e}")
```
**Supprimer le modèle (option B uniquement)**
Si vous avez utilisé des points de terminaison uniques, supprimez l'objet du SageMaker modèle :
```
try:
print("Deleting model...")
sagemaker.delete_model(ModelName=MODEL_NAME)
print(f"✅ Model '{MODEL_NAME}' deleted")
except Exception as e:
print(f"❌ Error deleting model: {e}")
```