Installer & utiliser l’interface CLI (v1)

Article
05/23/2023

S’APPLIQUE À :extension Azure CLI ml v1

Important

Les commandes Azure CLI de cet article requièrent l’extension azure-cli-ml, ou v1, pour Azure Machine Learning. La prise en charge de l’extension v1 se termine le 30 septembre 2025. Vous pourrez installer et utiliser l’extension v1 jusqu’à cette date.

Nous vous recommandons de passer à l’extension ml, ou v2, avant le 30 septembre 2025. Pour plus d’informations sur l’extension v2, consultez Extension Azure ML CLI et le SDK Python v2.

L'interface CLI Azure Machine Learning est une extension pour l'interface Azure, une interface de ligne de commande multiplateforme pour la plateforme Azure. Cette extension fournit les commandes à utiliser avec Azure Machine Learning. Il vous permet d’automatiser vos activités Machine Learning. La liste suivante fournit des exemples d’actions que vous pouvez effectuer avec l’extension CLI :

Exécuter des expérimentations pour créer des modèles Machine Learning
Inscrire des modèles Machine Learning pour l’usage des clients
Empaqueter, déployer et suivre le cycle de vie de vos modèles Machine Learning

L’interface CLI ne remplace pas le SDK Azure Machine Learning. C’est un outil complémentaire optimisé pour gérer les tâches hautement paramétrables qui se prêtent bien à l’automatisation.

Prérequis

Pour utiliser l'interface de ligne de commande, vous devez disposer d'un abonnement Azure. Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer. Essayez la version gratuite ou payante d’Azure Machine Learning dès aujourd’hui.
Pour utiliser les commandes CLI dans ce document à partir de votre environnement local, vous avez besoin d’Azure CLI.

Si vous utilisez Azure Cloud Shell, l’interface CLI est accessible via le navigateur et réside dans le cloud.

Documents de référence complets

Recherchez les documents de référence complets concernant l’extension azure-cli-ml d’Azure CLI.

Connexion de la CLI à votre abonnement Azure

Important

Si vous utilisez Azure Cloud Shell, vous pouvez ignorer cette section. Le shell cloud vous authentifie automatiquement à l’aide du compte avec lequel vous vous connectez à votre abonnement Azure.

Il existe plusieurs façons de vous authentifier auprès de votre abonnement Azure à partir de l’interface CLI. La plus simple consiste à s’authentifier de manière interactive à l’aide d’un navigateur. Pour vous authentifier de manière interactive, ouvrez une ligne de commande ou un terminal et utilisez la commande suivante :

az login

Si l’interface CLI peut ouvrir votre navigateur par défaut, elle le fera et chargera une page de connexion par la même occasion. Dans le cas contraire, vous devez ouvrir un navigateur et suivre les instructions de la ligne de commande. Les instructions impliquent de naviguer vers https://aka.ms/devicelogin et d’entrer un code d’autorisation.

Conseil

Après vous être connecté, vous voyez une liste des abonnements associés à votre compte Azure. Les informations d’abonnement avec isDefault: true correspond à l’abonnement actuellement activé pour les commandes Azure CLI. Cet abonnement doit être le même que celui qui contient votre espace de travail Azure Machine Learning. Vous pouvez trouver l’ID d’abonnement à partir du portail Azure en visitant la page Vue d’ensemble de votre espace de travail. Vous pouvez également utiliser le kit de développement logiciel (SDK) pour récupérer l’ID d’abonnement de l’objet d’espace de travail. Par exemple : Workspace.from_config().subscription_id.

Pour sélectionner un autre abonnement, utilisez la commande az account set -s <subscription name or ID> et spécifiez le nom ou l’ID de l’abonnement auquel vous voulez passer. Pour plus d’informations sur la sélection d’abonnements, consultez Utiliser plusieurs abonnements Azure.

Pour les autres méthodes d’authentification, consultez Se connecter avec Azure CLI.

Installer l’extension

Pour installer l’extension CLI (v1) :

az extension add -n azure-cli-ml

Mettre à jour de l’extension

Pour mettre à jour l’extension d’interface de ligne de commande Machine Learning, utilisez la commande suivante :

az extension update -n azure-cli-ml

Supprimer l’extension

Pour supprimer l'extension CLI, utilisez la commande suivante :

az extension remove -n azure-cli-ml

Gestion des ressources

Les commandes suivantes montrent comment utiliser l'interface de ligne de commande pour gérer les ressources utilisées par Azure Machine Learning.

Si vous n’en avez déjà un, créez un groupe de ressources :
```
az group create -n myresourcegroup -l westus2
```
Créez un espace de travail Azure Machine Learning :
```
az ml workspace create -w myworkspace -g myresourcegroup
```
Pour plus d’informations, consultez az ml workspace create.
Joignez la configuration d’un espace de travail à un dossier pour activer la prise en compte du contexte CLI.
```
az ml folder attach -w myworkspace -g myresourcegroup
```
Cette commande crée un sous-répertoire .azureml qui contient des exemples de fichiers d’environnement runconfig et conda. Il contient également un fichier config.json utilisé pour communiquer avec votre espace de travail Azure Machine Learning.

Pour plus d’informations, consultez az ml folder attach.
Joignez un conteneur d’objets blob Azure en tant que magasin de données.
```
az ml datastore attach-blob  -n datastorename -a accountname -c containername
```
Pour plus d’informations, consultez az ml datastore attach-blob.
Chargez les fichiers dans un magasin de données.
```
az ml datastore upload  -n datastorename -p sourcepath
```
Pour plus d’informations, voir az ml datastore upload.
Joignez un cluster AKS en tant que cible de calcul.
```
az ml computetarget attach aks -n myaks -i myaksresourceid -g myresourcegroup -w myworkspace
```
Pour plus d’informations, consultez az ml computetarget attach aks.

Clusters de calcul

Créez un cluster de calcul géré.

az ml computetarget create amlcompute -n cpu --min-nodes 1 --max-nodes 1 -s STANDARD_D3_V2

Créer un cluster de calcul géré avec une identité managée

Identité managée affectée par l’utilisateur

az ml computetarget create amlcompute --name cpu-cluster --vm-size Standard_NC6 --max-nodes 5 --assign-identity '/subscriptions/<subcription_id>/resourcegroups/<resource_group>/providers/Microsoft.ManagedIdentity/userAssignedIdentities/<user_assigned_identity>'

Identité managée affectée par le système

az ml computetarget create amlcompute --name cpu-cluster --vm-size Standard_NC6 --max-nodes 5 --assign-identity '[system]'

Ajouter une identité managée à un cluster existant :

Identité managée affectée par l’utilisateur

az ml computetarget amlcompute identity assign --name cpu-cluster '/subscriptions/<subcription_id>/resourcegroups/<resource_group>/providers/Microsoft.ManagedIdentity/userAssignedIdentities/<user_assigned_identity>'

Identité managée affectée par le système

az ml computetarget amlcompute identity assign --name cpu-cluster '[system]'

Pour plus d’informations, consultez aaz ml computetarget create amlcompute.

Notes

Les clusters de calcul Azure Machine Learning prennent en charge soit une seule identité attribuée par le système, soit plusieurs identités attribuées par l’utilisateur.

Instance de calcul

Gérer des instances de calcul. Dans tous les exemples ci-dessous, le nom de l’instance de calcul est cpu

Créer un nouveau computeinstance.
```
az ml computetarget create computeinstance -n cpu -s "STANDARD_D3_V2" -v
```
Pour plus d’informations, consultez az ml computetarget create computeinstance.
Arrêter un computeinstance.
```
az ml computetarget computeinstance stop -n cpu -v
```
Pour plus d’informations, consultez az ml computetarget computeinstance stop.
Démarrer un computeinstance.
```
az ml computetarget computeinstance start -n cpu -v
```
Pour plus d’informations, consultez az ml computetarget computeinstance start.
Redémarrer un computeinstance.
```
az ml computetarget computeinstance restart -n cpu -v
```
Pour plus d’informations, consultez az ml computetarget computeinstance restart.
Supprimer un computeinstance.
```
az ml computetarget delete -n cpu -v
```
Pour plus d’informations, consultez az ml computetarget delete computeinstance.

Exécuter des expériences

Exécutez votre expérimentation. Lorsque vous utilisez cette commande, spécifiez le nom du fichier runconfig (le texte avant *.runconfig si vous regardez le système de fichiers) avec le paramètre -c.
```
az ml run submit-script -c sklearn -e testexperiment train.py
```
Conseil

La commande az ml folder attach crée un sous-répertoire .azureml qui contient deux exemples de fichiers runconfig.

Si vous disposez d’un script Python qui crée un objet de configuration de série de tests par programmation, vous pouvez utiliser RunConfig.save() pour l’enregistrer dans un fichier runconfig.

Le schéma runconfig complet se trouve dans ce fichier JSON. Le schéma s’auto-documente à l’aide de la clé description de chaque objet. En outre, il existe des énumérations pour les valeurs possibles et un extrait de modèle à la fin.

Pour plus d’informations, consultez az ml run submit-script.
Afficher une liste des expériences :
```
az ml experiment list
```
Pour plus d’informations, consultez az ml experiment list.

Série de tests HyperDrive

Vous pouvez utiliser HyperDrive avec Azure CLI pour effectuer des séries de tests pour le réglage des paramètres. Commencez par créer un fichier de configuration HyperDrive au format suivant. Pour plus d’informations sur les paramètres de réglage des hyperparamètres, voir l’article Optimiser les hyperparamètres pour votre modèle.

# hdconfig.yml
sampling: 
    type: random # Supported options: Random, Grid, Bayesian
    parameter_space: # specify a name|expression|values tuple for each parameter.
    - name: --penalty # The name of a script parameter to generate values for.
      expression: choice # supported options: choice, randint, uniform, quniform, loguniform, qloguniform, normal, qnormal, lognormal, qlognormal
      values: [0.5, 1, 1.5] # The list of values, the number of values is dependent on the expression specified.
policy: 
    type: BanditPolicy # Supported options: BanditPolicy, MedianStoppingPolicy, TruncationSelectionPolicy, NoTerminationPolicy
    evaluation_interval: 1 # Policy properties are policy specific. See the above link for policy specific parameter details.
    slack_factor: 0.2
primary_metric_name: Accuracy # The metric used when evaluating the policy
primary_metric_goal: Maximize # Maximize|Minimize
max_total_runs: 8 # The maximum number of runs to generate
max_concurrent_runs: 2 # The number of runs that can run concurrently.
max_duration_minutes: 100 # The maximum length of time to run the experiment before cancelling.

Ajoutez ce fichier aux fichiers de configuration de série de tests. Ensuite, soumettez une série de tests HyperDrive en utilisant :

az ml run submit-hyperdrive -e <experiment> -c <runconfig> --hyperdrive-configuration-name <hdconfig> my_train.py

Notez la section arguments dans le fichier runconfig et la section parameter space dans le fichier config HyperDrive. Elles contiennent les arguments de ligne de commande à passer au script d’apprentissage. La valeur dans le fichier runconfig reste la même pour chaque itération, tandis que la plage dans le fichier config HyperDrive fait l’objet d’une itération. Ne spécifiez pas le même argument dans les deux fichiers.

Gestion des jeux de données

Les commandes suivantes montrent comment utiliser des jeux de données dans Azure Machine Learning :

Inscrire un jeu de données :
```
az ml dataset register -f mydataset.json
```
Pour obtenir des informations sur le format du fichier JSON utilisé pour définir le jeu de données, exécutez la commande az ml dataset register --show-template.

Pour plus d’informations, consultez az ml dataset register.
Lister tous les jeux de données dans un espace de travail :
```
az ml dataset list
```
Pour plus d’informations, consultez az ml dataset list.
Obtenir les détails d’un jeu de données :
```
az ml dataset show -n dataset-name
```
Pour plus d’informations, consultez az ml dataset show.
Désinscrire un jeu de données :
```
az ml dataset unregister -n dataset-name
```
Pour plus d’informations, consultez az ml dataset unregister.

Gestion de l’environnement

Les commandes suivantes montrent comment créer, inscrire et lister des environnements Azure Machine Learning pour votre espace de travail :

Créer des fichiers de génération de modèles automatique pour un environnement :
```
az ml environment scaffold -n myenv -d myenvdirectory
```
Pour plus d’informations, voir az ml environment scaffold.
Inscrivez un environnement :
```
az ml environment register -d myenvdirectory
```
Pour plus d’informations, voir az ml environment register.
Répertoriez les environnements inscrits :
```
az ml environment list
```
Pour plus d’informations, voir az ml environment list.
Téléchargez un environnement inscrit :
```
az ml environment download -n myenv -d downloaddirectory
```
Pour en savoir plus, voir az ml environment download.

Schéma de configuration de l’environnement

Si vous avez utilisé la commande az ml environment scaffold, elle génère un fichier azureml_environment.json de modèle qui peut être modifié et utilisé pour créer des configurations d’environnement personnalisées avec l’interface CLI. L’objet de niveau supérieur est mappé librement à la classe Environment dans le SDK Python.

{
    "name": "testenv",
    "version": null,
    "environmentVariables": {
        "EXAMPLE_ENV_VAR": "EXAMPLE_VALUE"
    },
    "python": {
        "userManagedDependencies": false,
        "interpreterPath": "python",
        "condaDependenciesFile": null,
        "baseCondaEnvironment": null
    },
    "docker": {
        "enabled": false,
        "baseImage": "mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04:20210615.v1",
        "baseDockerfile": null,
        "sharedVolumes": true,
        "shmSize": "2g",
        "arguments": [],
        "baseImageRegistry": {
            "address": null,
            "username": null,
            "password": null
        }
    },
    "spark": {
        "repositories": [],
        "packages": [],
        "precachePackages": true
    },
    "databricks": {
        "mavenLibraries": [],
        "pypiLibraries": [],
        "rcranLibraries": [],
        "jarLibraries": [],
        "eggLibraries": []
    },
    "inferencingStackVersion": null
}

Le tableau suivant détaille chaque champ de plus haut niveau dans le fichier JSON, son type et sa description. Si un type d’objet est lié à une classe du SDK Python, il existe une correspondance 1:1 libre entre chaque champ JSON et le nom de la variable publique dans la classe Python. Dans certains cas, le champ peut être mappé à un argument de constructeur au lieu d’une variable de classe. Par exemple, le champ environmentVariables est mappé à la variable environment_variables dans la classe Environment.

Champ JSON	Type	Description
`name`	`string`	Nom de l’environnement. Ne commencez pas le nom par Microsoft ou AzureML.
`version`	`string`	Version de l’environnement.
`environmentVariables`	`{string: string}`	Table de hachage des noms et valeurs de variables d’environnement.
`python`	`PythonSection`qui définit l’environnement et l’interpréteur Python à utiliser sur la ressource de calcul cible.
`docker`	`DockerSection`	Définit des paramètres permettant de personnaliser l’image Docker construite pour les spécifications de l’environnement.
`spark`	`SparkSection`	La section configure les paramètres Spark. Elle est utilisée seulement quand le framework est défini sur PySpark.
`databricks`	`DatabricksSection`	Configure les dépendances de bibliothèque Databricks.
`inferencingStackVersion`	`string`	Spécifie la version de pile d’inférence ajoutée à l’image. Pour éviter d’ajouter une pile d’inférence, laissez la valeur `null` dans ce champ. Valeur valide : « latest ».

Gestion des pipelines ML

Les commandes suivantes montrent comment travailler avec des pipelines d’apprentissage automatique :

Créez un pipeline d’apprentissage automatique :
```
az ml pipeline create -n mypipeline -y mypipeline.yml
```
Pour plus d’informations, consultez az ml pipeline create.

Pour plus d’informations sur le fichier YAML du pipeline, consultez Define machine learning pipelines in YAML (Définir des pipelines d’apprentissage automatique YAML).
Exécutez un pipeline :
```
az ml run submit-pipeline -n myexperiment -y mypipeline.yml
```
Pour plus d’informations, consultez az ml run submit-pipeline.

Pour plus d’informations sur le fichier YAML du pipeline, consultez Define machine learning pipelines in YAML (Définir des pipelines d’apprentissage automatique YAML).

Planifiez un pipeline :

az ml pipeline create-schedule -n myschedule -e myexperiment -i mypipelineid -y myschedule.yml

Pour plus d’informations, consultez az ml pipeline create-schedule.

Inscription, profilage, déploiement du modèle

Les commandes suivantes montrent comment inscrire un modèle entraîné, puis le déployer en tant que service de production :

Inscrivez un modèle dans Azure Machine Learning :
```
az ml model register -n mymodel -p sklearn_regression_model.pkl
```
Pour plus d’informations, consultez az ml model register.
FACULTATIF Profilez votre modèle pour obtenir des valeurs de processeur et de mémoire optimales pour le déploiement.
```
az ml model profile -n myprofile -m mymodel:1 --ic inferenceconfig.json -d "{\"data\": [[1,2,3,4,5,6,7,8,9,10],[10,9,8,7,6,5,4,3,2,1]]}" -t myprofileresult.json
```
Pour plus d’informations, consultez az ml model profile.
Déployer votre modèle sur AKS
```
az ml model deploy -n myservice -m mymodel:1 --ic inferenceconfig.json --dc deploymentconfig.json --ct akscomputetarget
```
Pour plus d’informations sur le schéma du fichier de configuration d'inférence, consultez Schéma de configuration de l’inférence.

Pour plus d’informations sur le schéma du fichier de configuration de déploiement, consultez Schéma de configuration de déploiement.

Pour plus d’informations, consultez az ml model deploy.

Schéma de configuration de l’inférence

Les entrées du mappage de document inferenceconfig.json correspondent aux paramètres de la classe InferenceConfig. Le tableau suivant décrit le mappage entre les entités dans le document JSON et les paramètres de la méthode :

Entité JSON	Paramètre de méthode	Description
`entryScript`	`entry_script`	Chemin vers un fichier local contenant le code à exécuter pour l’image.
`sourceDirectory`	`source_directory`	facultatif. Chemin vers des dossiers contenant tous les fichiers pour créer l’image, ce qui facilite l’accès à tous les fichiers de ce dossier ou sous-dossier. Vous pouvez charger un dossier entier à partir de votre ordinateur local en tant que dépendances pour le service web. Remarque : vos chemins d'accès entry_script, conda_file et extra_docker_file_steps sont des chemins d'accès relatifs au chemin source_directory.
`environment`	`environment`	facultatif. Environnement Azure Machine Learning.

Vous pouvez inclure les spécifications complètes d’un environnement Azure Machine Learning dans le fichier de configuration d’inférence. Si cet environnement n’existe pas dans votre espace de travail, Azure Machine Learning le crée. Dans le cas contraire, Azure Machine Learning met à jour l’environnement, si nécessaire. L’extrait JSON ci-dessous est un exemple :

{
    "entryScript": "score.py",
    "environment": {
        "docker": {
            "arguments": [],
            "baseDockerfile": null,
            "baseImage": "mcr.microsoft.com/azureml/intelmpi2018.3-ubuntu18.04",
            "enabled": false,
            "sharedVolumes": true,
            "shmSize": null
        },
        "environmentVariables": {
            "EXAMPLE_ENV_VAR": "EXAMPLE_VALUE"
        },
        "name": "my-deploy-env",
        "python": {
            "baseCondaEnvironment": null,
            "condaDependencies": {
                "channels": [
                    "conda-forge"
                ],
                "dependencies": [
                    "python=3.7",
                    {
                        "pip": [
                            "azureml-defaults",
                            "azureml-telemetry",
                            "scikit-learn==0.22.1",
                            "inference-schema[numpy-support]"
                        ]
                    }
                ],
                "name": "project_environment"
            },
            "condaDependenciesFile": null,
            "interpreterPath": "python",
            "userManagedDependencies": false
        },
        "version": "1"
    }
}

Vous pouvez également utiliser un environnement Azure Machine Learning existant dans des paramètres CLI distincts et supprimer la clé d'environnement du fichier de configuration d’inférence. Utilisez -e pour le nom de l’environnement, et --ev pour la version de l’environnement. À défaut d'indiquer --ev, la version la plus récente est utilisée. L'exemple suivant illustre un fichier de configuration d'inférence :

{
    "entryScript": "score.py",
    "sourceDirectory": null
}

La commande suivante montre comment déployer un modèle à l’aide du fichier de configuration d’inférence précédent (nommé myInferenceConfig.json).

Elle utilise également la version la plus récente d’un environnement Azure Machine Learning existant (nommé AzureML-Minimal).

az ml model deploy -m mymodel:1 --ic myInferenceConfig.json -e AzureML-Minimal --dc deploymentconfig.json

Schéma de configuration de déploiement

Schéma de configuration de déploiement local

Les entrées dans le document deploymentconfig.json correspondent aux paramètres pour LocalWebservice.deploy_configuration. Le tableau suivant décrit le mappage entre les entités dans le document JSON et les paramètres de la méthode :

Entité JSON	Paramètre de méthode	Description
`computeType`	N/D	La cible de calcul. Pour les cibles locales, la valeur doit être `local`.
`port`	`port`	Port local sur lequel exposer le point de terminaison HTTP du service.

Ce code JSON suivant est un exemple de configuration de déploiement à utiliser avec l’interface CLI :

{
    "computeType": "local",
    "port": 32267
}

Enregistrez ce code JSON dans un fichier nommé deploymentconfig.json.

Schéma de configuration de déploiement d’Azure Container Instance

Les entrées dans le document deploymentconfig.json correspondent aux paramètres pour AciWebservice.deploy_configuration. Le tableau suivant décrit le mappage entre les entités dans le document JSON et les paramètres de la méthode :

Entité JSON	Paramètre de méthode	Description
`computeType`	N/D	La cible de calcul. Pour ACI, la valeur doit être `ACI`.
`containerResourceRequirements`	N/D	Conteneur pour les entités UC et mémoire.
`cpu`	`cpu_cores`	Nombre de cœurs de processeur à allouer. Par défaut, `0.1`
`memoryInGB`	`memory_gb`	Quantité de mémoire (en Go) à allouer à ce service web. Par défaut, `0.5`
`location`	`location`	Région Azure dans laquelle déployer ce service web. Si elle n’est pas spécifiée, l’emplacement de l’espace de travail sera utilisé. Vous trouverez plus d’informations sur les régions disponibles ici : Régions ACI
`authEnabled`	`auth_enabled`	Indique s’il faut activer ou l’authentification pour ce service web. Par défaut, False
`sslEnabled`	`ssl_enabled`	Indique s’il faut activer le SSL pour ce service web. Valeur par défaut False.
`appInsightsEnabled`	`enable_app_insights`	Indique s’il faut activer AppInsights pour ce service Web. Par défaut, False
`sslCertificate`	`ssl_cert_pem_file`	Fichier de certificat requis si SSL est activé
`sslKey`	`ssl_key_pem_file`	Fichier de clé requis si SSL est activé
`cname`	`ssl_cname`	cname si SSL est activé
`dnsNameLabel`	`dns_name_label`	Étiquette du nom DNS pour le point de terminaison de scoring. Si elle n’est pas spécifiée, une étiquette de nom DNS unique sera générée pour le point de terminaison de scoring.

Le code JSON suivant est un exemple de configuration de déploiement à utiliser avec l’interface CLI :

{
    "computeType": "aci",
    "containerResourceRequirements":
    {
        "cpu": 0.5,
        "memoryInGB": 1.0
    },
    "authEnabled": true,
    "sslEnabled": false,
    "appInsightsEnabled": false
}

Schéma de configuration de déploiement d’Azure Kubernetes Service

Les entrées dans le document deploymentconfig.json correspondent aux paramètres pour AksWebservice.deploy_configuration. Le tableau suivant décrit le mappage entre les entités dans le document JSON et les paramètres de la méthode :

Entité JSON	Paramètre de méthode	Description
`computeType`	N/D	La cible de calcul. Pour AKS, la valeur doit être `aks`.
`autoScaler`	N/D	Contient les éléments de configuration pour la mise à l’échelle automatique. Consultez le tableau de mise à l’échelle automatique.
`autoscaleEnabled`	`autoscale_enabled`	Indique s’il faut activer la mise à l’échelle automatique pour le service Web. Si `numReplicas` = `0`, `True` ; sinon, `False`.
`minReplicas`	`autoscale_min_replicas`	Nombre minimal de conteneurs à utiliser lors de la mise à l’échelle automatique de ce service web. Par défaut, `1`.
`maxReplicas`	`autoscale_max_replicas`	Nombre maximal de conteneurs à utiliser lors de la mise à l’échelle automatique de ce service web. Par défaut, `10`.
`refreshPeriodInSeconds`	`autoscale_refresh_seconds`	Fréquence à laquelle la mise à l’échelle automatique tente de mettre à l’échelle ce service web. Par défaut, `1`.
`targetUtilization`	`autoscale_target_utilization`	Utilisation cible (en pourcentage sur 100) que la mise à l’échelle automatique doit tenter de gérer pour ce service web. Par défaut, `70`.
`dataCollection`	N/D	Contient les éléments de configuration pour la collecte de données.
`storageEnabled`	`collect_model_data`	Indique s’il faut activer la collecte des données de modèle pour le service Web. Par défaut, `False`.
`authEnabled`	`auth_enabled`	Indique s’il faut ou non activer l’authentification de clé pour le service web. `tokenAuthEnabled` et `authEnabled` ne peuvent pas tous deux avoir la valeur `True`. Par défaut, `True`.
`tokenAuthEnabled`	`token_auth_enabled`	Indique s’il faut ou non activer l’authentification de jeton pour le service web. `tokenAuthEnabled` et `authEnabled` ne peuvent pas tous deux avoir la valeur `True`. Par défaut, `False`.
`containerResourceRequirements`	N/D	Conteneur pour les entités UC et mémoire.
`cpu`	`cpu_cores`	Nombre de cœurs de processeur à allouer pour ce service web. Par défaut, `0.1`
`memoryInGB`	`memory_gb`	Quantité de mémoire (en Go) à allouer à ce service web. Par défaut, `0.5`
`appInsightsEnabled`	`enable_app_insights`	Indique s’il faut activer la journalisation Application Insights pour le service Web. Par défaut, `False`.
`scoringTimeoutMs`	`scoring_timeout_ms`	Délai d’expiration à appliquer pour les appels de scoring au service web. Par défaut, `60000`.
`maxConcurrentRequestsPerContainer`	`replica_max_concurrent_requests`	Nombre maximal de demandes simultanées par nœud pour ce service web. Par défaut, `1`.
`maxQueueWaitMs`	`max_request_wait_time`	Durée maximale pendant laquelle une demande est conservée dans la file d’attente (en millisecondes) avant qu’une erreur 503 soit renvoyée. Par défaut, `500`.
`numReplicas`	`num_replicas`	Nombre de conteneurs à allouer pour ce service web. Pas de valeur par défaut. Si ce paramètre n’est pas défini, la mise à l’échelle automatique est activée par défaut.
`keys`	N/D	Contient les éléments de configuration pour les clés.
`primaryKey`	`primary_key`	Clé d’authentification principale à utiliser pour ce service web
`secondaryKey`	`secondary_key`	Clé d’authentification secondaire à utiliser pour ce service web
`gpuCores`	`gpu_cores`	Nombre de cœurs GPU (par réplica de conteneur) à allouer pour ce service web. 1 constitue la valeur par défaut. Prend en charge uniquement les valeurs numériques entières.
`livenessProbeRequirements`	N/D	Contient les éléments de configuration pour les exigences de probe liveness.
`periodSeconds`	`period_seconds`	Fréquence (en secondes) d’exécution de probe liveness. La valeur par défaut est 10 secondes. La valeur minimale est 1.
`initialDelaySeconds`	`initial_delay_seconds`	Nombre de secondes après le démarrage du conteneur avant le lancement des probes liveness. La valeur par défaut est 310
`timeoutSeconds`	`timeout_seconds`	Nombre de secondes après lequel la probe liveness expire. La valeur par défaut est de 2 secondes. La valeur minimale est 1
`successThreshold`	`success_threshold`	Nombre minimal de réussites consécutives pour que la probe liveness soit considérée comme réussie après avoir échoué. La valeur par défaut est de 1. La valeur minimale est 1.
`failureThreshold`	`failure_threshold`	Quand un Pod démarre et que la probe liveness échoue, Kubernetes essaie FailureThreshold times avant d’abandonner. La valeur par défaut est 3. La valeur minimale est 1.
`namespace`	`namespace`	Espace de noms Kubernetes dans lequel le service web est déployé. Jusqu’à 63 caractères alphanumériques ('a'-'z', '0'-'9') et le trait d’union ('-'). Le premier et le dernier caractères ne peuvent pas être des traits d’union.