Créer et configurer toutes les ressources pour l’inférence du modèle Azure AI

Article
02/20/2025

Important

Les éléments marqués (préversion) dans cet article sont actuellement en préversion publique. Cette préversion est fournie sans contrat de niveau de service, nous la déconseillons dans des charges de travail de production. Certaines fonctionnalités peuvent être limitées ou non prises en charge. Pour plus d’informations, consultez Conditions d’Utilisation Supplémentaires relatives aux Évaluations Microsoft Azure.

Dans cet article, vous allez apprendre à créer les ressources nécessaires pour utiliser l’inférence de modèle Azure AI et utiliser des modèles phares à partir du catalogue de modèles Azure AI.

Prérequis

Pour effectuer ce qui est décrit dans cet article, vous avez besoin des éléments suivants :

Un abonnement Azure. Si vous utilisez des modèles GitHub, vous pouvez mettre à niveau votre expérience et créer un abonnement Azure dans le processus. Lisez Passer des modèles GitHub à l’inférence de modèle Azure AI si vous êtes dans ce cas.

Important

Le portail Azure AI Foundry utilise des projets et des hubs pour créer des comptes Azure AI Services et configurer l’inférence de modèle Azure AI. Si vous ne souhaitez pas utiliser de hubs et de projets, vous pouvez créer les ressources à l’aide des Azure CLI, Bicepou Créer la ressource des services Azure AI à l’aide du portail Azure.

Créer les ressources

Pour créer un projet avec un compte Azure AI Services, procédez comme suit :

Accédez au portail Azure AI Foundry.
Dans la page d’arrivée, sélectionnez Créer un projet.
Donnez un nom au projet, par exemple « my-project ».
Dans ce tutoriel, nous créons un nouveau projet sous un nouveau hub IA, par conséquent, sélectionnez Créer un hub.
Donnez un nom au hub, par exemple « my-hub », puis sélectionnez Suivant.
L’Assistant se met à jour avec des détails sur les ressources qui vont être créées. Sélectionnez Ressources Azure à créer pour afficher les détails.

Vous pouvez voir que les ressources suivantes ont été créées :

Propriété	Description
Resource group	Conteneur principal pour toutes les ressources dans Azure. Cela permet d'organiser les ressources qui travaillent ensemble. Il permet également d’avoir une portée pour les coûts associés à l’ensemble du projet.
Emplacement	Région des ressources que vous créez.
Hub	Conteneur principal pour les projets IA dans Azure AI Foundry. Hubs promeut la collaboration et vous permet de stocker des informations pour vos projets.
Services IA	Ressource permettant d’accéder aux modèles phares dans le catalogue de modèles Azure AI. Dans ce tutoriel, un nouveau compte est créé, mais les ressources des services Azure AI peuvent être partagées entre plusieurs hubs et projets. Les hubs utilisent une connexion à la ressource pour avoir accès aux modèles de déploiements disponibles. Pour savoir comment créer des connexions entre des projets et Azure AI Services pour utiliser l’inférence du modèle Azure AI, vous pouvez lire Connecter votre projet IA.

Sélectionnez Créer. Le processus de création de ressources démarre.
Une fois terminé, votre projet est prêt à être configuré.
L’inférence de modèle Azure AI est une fonctionnalité en préversion qui doit être activée dans Azure AI Foundry. Dans la barre de navigation supérieure, dans le coin droit, sélectionnez les fonctionnalités de l’icône Préversion. Un panneau contextuel s’affiche à droite de l’écran.
Activez la fonctionnalité Déployer des modèles vers le service d'inférence de modèles Azure AI.
Fermer le panneau.
Pour utiliser l’inférence du modèle IA Azure, vous devez ajouter des modèles de déploiements à votre compte de services Azure AI.

Étapes suivantes

Ajouter et configurer des modèles

Important

Vous pouvez déterminer quels sont les modèles disponibles pour une inférence dans le point de terminaison de l’inférence et les configurer. Lorsqu’un modèle donné est configuré, vous pouvez ensuite générer des prédictions à partir de celui-ci en indiquant son nom de modèle ou son nom de déploiement dans vos demandes. Aucune autre modification n’est requise dans votre code pour l’utiliser.

Dans cet article, vous découvrez comment ajouter un nouveau modèle à l’inférence de modèle Azure AI dans Azure AI Foundry.

Prérequis

Pour effectuer ce qui est décrit dans cet article, vous avez besoin des éléments suivants :

Un abonnement Azure. Si vous utilisez des modèles GitHub, vous pouvez mettre à niveau votre expérience et créer un abonnement Azure dans le processus. Lisez Passer des modèles GitHub à l’inférence de modèle Azure AI si vous êtes dans ce cas.
Une ressource Azure AI services.

Installer Azure CLI et l’extension cognitiveservices pour Azure AI Services :
```
az extension add -n cognitiveservices
```
Certaines des commandes de ce tutoriel utilisent l’outil jq, qui peut ne pas être installé dans votre système. Pour connaître les instructions d’installation, consultez Télécharger jq.
Identifiez les informations suivantes :
- Votre ID d’abonnement Azure.
- Le nom de votre ressource Azure AI Services.
- Le groupe de ressources dans lequel la ressource Azure AI Services est déployée.

Ajouter des modèles

Pour ajouter un modèle, vous devez d’abord identifier le modèle que vous souhaitez déployer. Vous pouvez interroger les modèles disponibles comme suit :

Connectez-vous à votre abonnement Azure :
```
az login
```
Si vous avez plusieurs abonnements, sélectionnez celui dans lequel se trouve votre ressource :
```
az account set --subscription $subscriptionId>
```
Définissez les variables d’environnement suivantes avec le nom de la ressource Azure AI Services que vous envisagez d’utiliser et le groupe de ressources.
```
accountName="<ai-services-resource-name>"
resourceGroupName="<resource-group>"
```

Si vous n’avez pas encore de compte Azure AI Services, vous pouvez en créer un comme suit :

az cognitiveservices account create -n $accountName -g $resourceGroupName --custom-domain $accountName

Voyons d’abord quels modèles sont disponibles et sous quelle référence SKU. La commande suivante répertorie toutes les définitions de modèle disponibles :

az cognitiveservices account list-models \
    -n $accountName \
    -g $resourceGroupName \
| jq '.[] | { name: .name, format: .format, version: .version, sku: .skus[0].name, capacity: .skus[0].capacity.default }'

Les sorties se présentent comme suit :

{
  "name": "Phi-3.5-vision-instruct",
  "format": "Microsoft",
  "version": "2",
  "sku": "GlobalStandard",
  "capacity": 1
}

Identifiez le modèle que vous souhaitez déployer. Vous avez besoin des propriétés name, format, version et sku. Une capacité peut également être nécessaire selon le type de déploiement.

Conseil

Remarquez que les modèles ne sont pas tous disponibles dans toutes les références SKU.

Ajoutez le modèle de déploiement à la ressource. L'exemple suivant ajoute Phi-3.5-vision-instruct :

az cognitiveservices account deployment create \
    -n $accountName \
    -g $resourceGroupName \
    --deployment-name Phi-3.5-vision-instruct \
    --model-name Phi-3.5-vision-instruct \
    --model-version 2 \
    --model-format Microsoft \
    --sku-capacity 1 \
    --sku-name GlobalStandard

Le modèle est prêt à être consommé.

Vous pouvez déployer le même modèle plusieurs fois si nécessaire, mais sous un nom de déploiement différent. Cette fonctionnalité peut être utile si vous souhaitez tester différentes configurations d’un modèle donné, notamment la sécurité du contenu.

Gérer les déploiements

Vous pouvez afficher tous les déploiements disponibles à l’aide de la CLI :

Exécutez la commande suivante pour afficher tous les déploiements actifs :

az cognitiveservices account deployment list -n $accountName -g $resourceGroupName

Vous pouvez afficher les détails d’un déploiement donné :

az cognitiveservices account deployment show \
    --deployment-name "Phi-3.5-vision-instruct" \
    -n $accountName \
    -g $resourceGroupName

Vous pouvez supprimer un déploiement donné comme suit :

    az cognitiveservices account deployment delete \
    --deployment-name "Phi-3.5-vision-instruct" \
    -n $accountName \
    -g $resourceGroupName

Utiliser le modèle

Les modèles déployés dans l’inférence de modèle Azure AI peuvent être consommés à l’aide du point de terminaison d’inférence du modèle Azure AI de la ressource. Lors de la création de votre requête, indiquez le paramètre model et insérez le nom du modèle de déploiement que vous avez créé. Vous pouvez obtenir par programmation l’URI du point de terminaison d’inférence à l’aide du code suivant :

Point de terminaison d'inférence

az cognitiveservices account show  -n $accountName -g $resourceGroupName | jq '.properties.endpoints["Azure AI Model Inference API"]'

Pour effectuer des demandes au point de terminaison d’inférence du modèle Azure AI, ajoutez l’itinéraire models, par exemple https://<resource>.services.ai.azure.com/models. Vous pouvez voir la référence de l’API du point de terminaison sur la page de référence de l’API d’inférence du modèle Azure AI.

Clés d’inférence

az cognitiveservices account keys list  -n $accountName -g $resourceGroupName

Important

Prérequis

Pour effectuer ce qui est décrit dans cet article, vous avez besoin des éléments suivants :

Un abonnement Azure. Si vous utilisez des modèles GitHub, vous pouvez mettre à niveau votre expérience et créer un abonnement Azure dans le processus. Lisez Passer des modèles GitHub à l’inférence de modèle Azure AI si vous êtes dans ce cas.

Installez Azure CLI.
Identifiez les informations suivantes :
- Votre ID d’abonnement Azure.

À propos de ce didacticiel

L'exemple présenté dans cet article est basé sur les échantillons de code contenus dans le référentiel Azure-Samples/azureai-model-inference-bicep. Pour exécuter les commandes localement sans avoir à copier ou coller le contenu des fichiers, utilisez les commandes suivantes pour cloner le référentiel et vous rendre dans le dossier correspondant à votre langage de codage :

git clone https://github.com/Azure-Samples/azureai-model-inference-bicep

Les fichiers de cet exemple se situent dans :

cd azureai-model-inference-bicep/infra

Comprendre le risque

Le tutoriel vous aide à créer :

Une ressource Azure AI Services
Modèle de déploiement dans la référence SKU standard globale pour chacun des modèles prenant en charge le paiement à l’utilisation.
(Optionnellement) Un projet Azure AI et un hub.
(Facultatif) Connexion entre le hub et les modèles dans Azure AI Services.

Notez que vous devez déployer un projet Azure AI et un hub si vous envisagez d’utiliser le Portail Azure AI Foundry pour gérer la ressource, utiliser le terrain de jeu ou toute autre fonctionnalité du Portail.

Vous utilisez les ressources suivantes pour créer ces ressources :

Utilisez le modèle modules/ai-services-template.bicep pour décrire votre ressource Azure AI Services :

modules/ai-services-template.bicep

@description('Location of the resource.')
param location string = resourceGroup().location

@description('Name of the Azure AI Services account.')
param accountName string

@description('The resource model definition representing SKU')
param sku string = 'S0'

@description('Whether or not to allow keys for this account.')
param allowKeys bool = true

@allowed([
  'Enabled'
  'Disabled'
])
@description('Whether or not public endpoint access is allowed for this account.')
param publicNetworkAccess string = 'Enabled'

@allowed([
  'Allow'
  'Deny'
])
@description('The default action for network ACLs.')
param networkAclsDefaultAction string = 'Allow'

resource account 'Microsoft.CognitiveServices/accounts@2023-05-01' = {
  name: accountName
  location: location
  identity: {
    type: 'SystemAssigned'
  }
  sku: {
    name: sku
  }
  kind: 'AIServices'
  properties: {
    customSubDomainName: accountName
    publicNetworkAccess: publicNetworkAccess
    networkAcls: {
      defaultAction: networkAclsDefaultAction
    }
    disableLocalAuth: allowKeys
  }
}

output endpointUri string = 'https://${account.outputs.name}.services.ai.azure.com/models'
output id string = account.id

Utilisez le modèle modules/ai-services-deployment-template.bicep pour décrire les modèles de déploiement :

modules/ai-services-deployment-template.bicep

@description('Name of the Azure AI services account')
param accountName string

@description('Name of the model to deploy')
param modelName string

@description('Version of the model to deploy')
param modelVersion string

@allowed([
  'AI21 Labs'
  'Cohere'
  'Core42'
  'DeepSeek'
  'Meta'
  'Microsoft'
  'Mistral AI'
  'OpenAI'
])
@description('Model provider')
param modelPublisherFormat string

@allowed([
    'GlobalStandard'
    'Standard'
    'GlobalProvisioned'
    'Provisioned'
])
@description('Model deployment SKU name')
param skuName string = 'GlobalStandard'

@description('Content filter policy name')
param contentFilterPolicyName string = 'Microsoft.DefaultV2'

@description('Model deployment capacity')
param capacity int = 1

resource modelDeployment 'Microsoft.CognitiveServices/accounts/deployments@2024-04-01-preview' = {
  name: '${accountName}/${modelName}'
  sku: {
    name: skuName
    capacity: capacity
  }
  properties: {
    model: {
      format: modelPublisherFormat
      name: modelName
      version: modelVersion
    }
    raiPolicyName: contentFilterPolicyName == null ? 'Microsoft.Nill' : contentFilterPolicyName
  }
}

Pour plus de commodité, nous définissons le modèle que nous voulons avoir disponible dans le service à l’aide d’un fichier JSON. Le fichier infra/models.json contient une liste d’objets JSON avec des clés name,version, provideret sku, qui définit les modèles que le déploiement approvisionnera. Étant donné que les modèles prennent en charge le paiement à l’utilisation, l’ajout de modèles de déploiements n’entraîne pas de coûts supplémentaires. Modifiez le fichier en supprimant/ajoutant les entrées du modèle que vous souhaitez avoir à votre disposition. L’exemple suivant affiche uniquement les 7 premières lignes du fichier JSON :

models.json
```
[
  {
    "name": "AI21-Jamba-1.5-Large",
    "version": "1",
    "provider": "AI21 Labs",
    "sku": "GlobalStandard"
  },
```

Si vous envisagez d’utiliser des projets (recommandé), vous avez besoin des modèles pour créer un projet, un hub et une connexion à la ressource Azure AI Services :

modules/project-hub-template.bicep

param location string = resourceGroup().location

@description('Name of the Azure AI hub')
param hubName string = 'hub-dev'

@description('Name of the Azure AI project')
param projectName string = 'intelligent-apps'

@description('Name of the storage account used for the workspace.')
param storageAccountName string = replace(hubName, '-', '')
param keyVaultName string = replace(hubName, 'hub', 'kv')
param applicationInsightsName string = replace(hubName, 'hub', 'log')

@description('The container registry resource id if you want to create a link to the workspace.')
param containerRegistryName string = replace(hubName, '-', '')

@description('The tags for the resources')
param tagValues object = {
  owner: 'santiagxf'
  project: 'intelligent-apps'
  environment: 'dev'
}

var tenantId = subscription().tenantId
var resourceGroupName = resourceGroup().name
var storageAccountId = resourceId(resourceGroupName, 'Microsoft.Storage/storageAccounts', storageAccountName)
var keyVaultId = resourceId(resourceGroupName, 'Microsoft.KeyVault/vaults', keyVaultName)
var applicationInsightsId = resourceId(resourceGroupName, 'Microsoft.Insights/components', applicationInsightsName)
var containerRegistryId = resourceId(
  resourceGroupName,
  'Microsoft.ContainerRegistry/registries',
  containerRegistryName
)

resource storageAccount 'Microsoft.Storage/storageAccounts@2019-04-01' = {
  name: storageAccountName
  location: location
  sku: {
    name: 'Standard_LRS'
  }
  kind: 'StorageV2'
  properties: {
    encryption: {
      services: {
        blob: {
          enabled: true
        }
        file: {
          enabled: true
        }
      }
      keySource: 'Microsoft.Storage'
    }
    supportsHttpsTrafficOnly: true
  }
  tags: tagValues
}

resource keyVault 'Microsoft.KeyVault/vaults@2019-09-01' = {
  name: keyVaultName
  location: location
  properties: {
    tenantId: tenantId
    sku: {
      name: 'standard'
      family: 'A'
    }
    enableRbacAuthorization: true
    accessPolicies: []
  }
  tags: tagValues
}

resource applicationInsights 'Microsoft.Insights/components@2018-05-01-preview' = {
  name: applicationInsightsName
  location: location
  kind: 'web'
  properties: {
    Application_Type: 'web'
  }
  tags: tagValues
}

resource containerRegistry 'Microsoft.ContainerRegistry/registries@2019-05-01' = {
  name: containerRegistryName
  location: location
  sku: {
    name: 'Standard'
  }
  properties: {
    adminUserEnabled: true
  }
  tags: tagValues
}

resource hub 'Microsoft.MachineLearningServices/workspaces@2024-07-01-preview' = {
  name: hubName
  kind: 'Hub'
  location: location
  identity: {
    type: 'systemAssigned'
  }
  sku: {
    tier: 'Standard'
    name: 'standard'
  }
  properties: {
    description: 'Azure AI hub'
    friendlyName: hubName
    storageAccount: storageAccountId
    keyVault: keyVaultId
    applicationInsights: applicationInsightsId
    containerRegistry: (empty(containerRegistryName) ? null : containerRegistryId)
    encryption: {
      status: 'Disabled'
      keyVaultProperties: {
        keyVaultArmId: keyVaultId
        keyIdentifier: ''
      }
    }
    hbiWorkspace: false
  }
  tags: tagValues
}

resource project 'Microsoft.MachineLearningServices/workspaces@2024-07-01-preview' = {
  name: projectName
  kind: 'Project'
  location: location
  identity: {
    type: 'systemAssigned'
  }
  sku: {
    tier: 'Standard'
    name: 'standard'
  }
  properties: {
    description: 'Azure AI project'
    friendlyName: projectName
    hbiWorkspace: false
    hubResourceId: hub.id
  }
  tags: tagValues
}

modules/ai-services-connection-template.bicep

@description('Name of the hub where the connection will be created')
param hubName string

@description('Name of the connection')
param name string

@description('Category of the connection')
param category string = 'AIServices'

@allowed(['AAD', 'ApiKey', 'ManagedIdentity', 'None'])
param authType string = 'AAD'

@description('The endpoint URI of the connected service')
param endpointUri string

@description('The resource ID of the connected service')
param resourceId string = ''

@secure()
param key string = ''


resource connection 'Microsoft.MachineLearningServices/workspaces/connections@2024-04-01-preview' = {
  name: '${hubName}/${name}'
  properties: {
    category: category
    target: endpointUri
    authType: authType
    isSharedToAll: true
    credentials: authType == 'ApiKey' ? {
      key: key
    } : null
    metadata: {
      ApiType: 'Azure'
      ResourceId: resourceId
    }
  }
}

Créer les ressources

Dans votre console, procédez comme suit :

Définir le déploiement principal :

deploy-with-project.bicep

@description('Location to create the resources in')
param location string = resourceGroup().location

@description('Name of the resource group to create the resources in')
param resourceGroupName string = resourceGroup().name

@description('Name of the AI Services account to create')
param accountName string = 'azurei-models-dev'

@description('Name of the project hub to create')
param hubName string = 'hub-azurei-dev'

@description('Name of the project to create in the project hub')
param projectName string = 'intelligent-apps'

@description('Path to a JSON file with the list of models to deploy. Each model is a JSON object with the following properties: name, version, provider')
var models = json(loadTextContent('models.json'))

module aiServicesAccount 'modules/ai-services-template.bicep' = {
  name: 'aiServicesAccount'
  scope: resourceGroup(resourceGroupName)
  params: {
    accountName: accountName
    location: location
  }
}

module projectHub 'modules/project-hub-template.bicep' = {
  name: 'projectHub'
  scope: resourceGroup(resourceGroupName)
  params: {
    hubName: hubName
    projectName: projectName
  }
}

module aiServicesConnection 'modules/ai-services-connection-template.bicep' = {
  name: 'aiServicesConnection'
  scope: resourceGroup(resourceGroupName)
  params: {
    name: accountName
    authType: 'AAD'
    endpointUri: aiServicesAccount.outputs.endpointUri
    resourceId: aiServicesAccount.outputs.id
    hubName: hubName
  }
  dependsOn: [
    projectHub
  ]
}

@batchSize(1)
module modelDeployments 'modules/ai-services-deployment-template.bicep' = [
  for (item, i) in models: {
    name: 'deployment-${item.name}'
    scope: resourceGroup(resourceGroupName)
    params: {
      accountName: accountName
      modelName: item.name
      modelVersion: item.version
      modelPublisherFormat: item.provider
      skuName: item.sku
    }
    dependsOn: [
      aiServicesAccount
    ]
  }
]

output endpoint string = aiServicesAccount.outputs.endpointUri

Se connecter à Azure :
```
az login
```

Vérifiez que vous êtes dans le bon abonnement :

az account set --subscription "<subscription-id>"

Exécutez le déploiement :

RESOURCE_GROUP="<resource-group-name>"

az deployment group create \
  --resource-group $RESOURCE_GROUP \
  --template-file deploy-with-project.bicep

Si vous souhaitez déployer uniquement la ressource Azure AI Services et les modèles de déploiements, utilisez le fichier de déploiement suivant :

deploy.bicep

@description('Location to create the resources in')
param location string = resourceGroup().location

@description('Name of the resource group to create the resources in')
param resourceGroupName string = resourceGroup().name

@description('Name of the AI Services account to create')
param accountName string = 'azurei-models-dev'

@description('Path to a JSON file with the list of models to deploy. Each model is a JSON object with the following properties: name, version, provider')
var models = json(loadTextContent('models.json'))

module aiServicesAccount 'modules/ai-services-template.bicep' = {
  name: 'aiServicesAccount'
  scope: resourceGroup(resourceGroupName)
  params: {
    accountName: accountName
    location: location
  }
}

@batchSize(1)
module modelDeployments 'modules/ai-services-deployment-template.bicep' = [
  for (item, i) in models: {
    name: 'deployment-${item.name}'
    scope: resourceGroup(resourceGroupName)
    params: {
      accountName: accountName
      modelName: item.name
      modelVersion: item.version
      modelPublisherFormat: item.provider
      skuName: item.sku
    }
    dependsOn: [
      aiServicesAccount
    ]
  }
]

output endpoint string = aiServicesAccount.outputs.endpointUri

Exécutez le déploiement :

RESOURCE_GROUP="<resource-group-name>"

az deployment group create \
  --resource-group $RESOURCE_GROUP \
  --template-file deploy.bicep

Le modèle génère le point de terminaison d’inférence du modèle Azure AI que vous pouvez utiliser pour utiliser l’un des modèles de déploiements que vous avez créés.

Étapes suivantes

Utiliser le point de terminaison d’inférence

Partage via

Créer et configurer toutes les ressources pour l’inférence du modèle Azure AI

Prérequis

Créer les ressources

Étapes suivantes

Prérequis

Ajouter des modèles

Gérer les déploiements

Utiliser le modèle

Prérequis

À propos de ce didacticiel

Comprendre le risque

Créer les ressources

Étapes suivantes

Commentaires

Ressources supplémentaires