Skapa och konfigurera alla resurser för Azure AI-modellinferens

Artikel
01/30/2025

Viktigt!

Objekt markerade (förhandsversion) i den här artikeln är för närvarande i offentlig förhandsversion. Den här förhandsversionen tillhandahålls utan ett serviceavtal och vi rekommenderar det inte för produktionsarbetsbelastningar. Vissa funktioner kanske inte stöds eller kan vara begränsade. Mer information finns i Kompletterande villkor för användning av Microsoft Azure-förhandsversioner.

I den här artikeln får du lära dig hur du skapar de resurser som krävs för att använda Azure AI-modellinferens och använder flaggskeppsmodeller från Azure AI-modellkatalogen.

Förutsättningar

För att slutföra den här artikeln behöver du:

En Azure-prenumeration Om du använder GitHub-modeller kan du uppgradera din upplevelse och skapa en Azure-prenumeration i processen. Läs Uppgradera från GitHub-modeller till Azure AI-modellinferens om så är fallet.

Viktigt!

Azure AI Foundry-portalen använder projekt och hubbar för att skapa Azure AI Services-konton och konfigurera Azure AI-modellinferens. Om du inte vill använda hubbar och projekt kan du skapa resurserna med antingen Azure CLI, Bicep eller skapa Azure AI-tjänstresursen med hjälp av Azure Portal.

Skapa resurserna

Följ dessa steg för att skapa ett projekt med ett Azure AI Services-konto:

Gå till Azure AI Foundry-portalen.
På landningssidan väljer du Skapa projekt.
Ge projektet ett namn, till exempel "my-project".
I den här självstudien skapar vi ett helt nytt projekt under en ny AI-hubb och väljer därför Skapa ny hubb.
Ge hubben ett namn, till exempel "my-hub" och välj Nästa.
Guiden uppdateras med information om de resurser som ska skapas. Välj Azure-resurser som ska skapas för att se informationen.

Du kan se att följande resurser skapas:

Property	beskrivning
Resursgrupp	Huvudcontainern för alla resurser i Azure. Detta hjälper dig att organisera resurser som fungerar tillsammans. Det hjälper också till att ha ett omfång för de kostnader som är kopplade till hela projektet.
Plats	Regionen för de resurser som du skapar.
Hubb	Huvudcontainern för AI-projekt i Azure AI Foundry. Hubbar främjar samarbete och gör att du kan lagra information för dina projekt.
AI-tjänster	Resursen som ger åtkomst till flaggskeppsmodellerna i Azure AI-modellkatalogen. I den här självstudien skapas ett nytt konto, men Azure AI-tjänstresurser kan delas mellan flera hubbar och projekt. Hubbar använder en anslutning till resursen för att ha åtkomst till de modelldistributioner som är tillgängliga där. Om du vill veta hur du kan skapa anslutningar mellan projekt och Azure AI Services för att använda Azure AI-modellinferens kan du läsa Ansluta ditt AI-projekt.

Välj Skapa. Processen för att skapa resurser startar.
När projektet är klart är det klart att konfigureras.
Azure AI-modellinferens är en förhandsversionsfunktion som måste aktiveras i Azure AI Foundry. I det övre navigeringsfältet, i det högra hörnet, väljer du ikonen Förhandsgranskningsfunktioner . Ett sammanhangsberoende blad visas till höger på skärmen.
Aktivera funktionen Distribuera modeller till Azure AI-modellinferenstjänsten .
Stäng panelen.
Om du vill använda Azure AI-modellinferens måste du lägga till modelldistributioner till ditt Azure AI-tjänstkonto.

Lägga till och konfigurera modeller

Viktigt!

Du kan bestämma och konfigurera vilka modeller som är tillgängliga för slutsatsdragning i slutpunkten för slutsatsdragning. När en viss modell har konfigurerats kan du generera förutsägelser från den genom att ange dess modellnamn eller distributionsnamn på dina begäranden. Inga ytterligare ändringar krävs i koden för att använda den.

I den här artikeln får du lära dig hur du lägger till en ny modell i Azure AI-modellinferens i Azure AI Foundry.

Förutsättningar

För att slutföra den här artikeln behöver du:

En Azure-prenumeration Om du använder GitHub-modeller kan du uppgradera din upplevelse och skapa en Azure-prenumeration i processen. Läs Uppgradera från GitHub-modeller till Azure AI-modellinferens om så är fallet.
En Azure AI-tjänstresurs.

Installera Azure CLI och cognitiveservices tillägget för Azure AI Services:
```
az extension add -n cognitiveservices
```
Vissa av kommandona i den här självstudien jq använder verktyget, som kanske inte är installerat i systemet. Installationsinstruktioner finns i Ladda ned jq.
Identifiera följande information:
- ditt prenumerations-ID för Azure
- Ditt Azure AI Services-resursnamn.
- Resursgruppen där Azure AI Services-resursen distribueras.

Lägg till modeller

Om du vill lägga till en modell måste du först identifiera den modell som du vill distribuera. Du kan fråga de tillgängliga modellerna på följande sätt:

Logga in på din Azure-prenumeration:
```
az login
```
Om du har fler än en prenumeration väljer du den prenumeration där resursen finns:
```
az account set --subscription $subscriptionId>
```
Ange följande miljövariabler med namnet på den Azure AI Services-resurs som du planerar att använda och resursgruppen.
```
accountName="<ai-services-resource-name>"
resourceGroupName="<resource-group>"
```
Om du inte har skapat ett Azure AI Services-konto ännu kan du skapa ett på följande sätt:
```
az cognitiveservices account create -n $accountName -g $resourceGroupName
```

Låt oss först se vilka modeller som är tillgängliga för dig och under vilken SKU. Följande kommando visar alla tillgängliga modelldefinitioner:

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 }'

Utdata ser ut så här:

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

Identifiera den modell som du vill distribuera. Du behöver egenskaperna name, format, versionoch sku. Kapacitet kan också behövas beroende på typen av distribution.

Dricks

Observera att inte alla modeller är tillgängliga i alla SKU:er.

Lägg till modelldistributionen i resursen. Följande exempel lägger till 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

Modellen är redo att användas.

Du kan distribuera samma modell flera gånger om det behövs så länge den är under ett annat distributionsnamn. Den här funktionen kan vara användbar om du vill testa olika konfigurationer för en viss modell, inklusive innehållssäkerhet.

Hantera distributioner

Du kan se alla tillgängliga distributioner med hjälp av CLI:

Kör följande kommando för att se alla aktiva distributioner:

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

Du kan se information om en viss distribution:

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

Du kan ta bort en viss distribution på följande sätt:

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

Använda modellen

Distribuerade modeller i Azure AI-modellinferens kan användas med hjälp av Azure AI-modellens slutpunkt för inferens för resursen. När du skapar din begäran anger du parametern model och infogar det modelldistributionsnamn som du har skapat. Du kan programmatiskt hämta URI:n för slutpunkten för slutsatsdragning med hjälp av följande kod:

Slutpunkt för slutsatsdragning

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

Om du vill göra begäranden till slutpunkten för Azure AI-modellens slutsatsdragning lägger du till vägen models, till exempel https://<resource>.services.ai.azure.com/models. Du kan se API-referensen för slutpunkten på referenssidan för Azure AI-modellinferens-API.

Slutsatsdragningsnycklar

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

Viktigt!

I den här artikeln får du lära dig hur du skapar de resurser som krävs för att använda Azure AI-modellinferens och använder flaggskeppsmodeller från Azure AI-modellkatalogen.

Förutsättningar

För att slutföra den här artikeln behöver du:

En Azure-prenumeration Om du använder GitHub-modeller kan du uppgradera din upplevelse och skapa en Azure-prenumeration i processen. Läs Uppgradera från GitHub-modeller till Azure AI-modellinferens om så är fallet.

Installera Azure CLI.
Identifiera följande information:
- ditt prenumerations-ID för Azure

Om den här självstudiekursen

Exemplet i den här artikeln baseras på kodexempel som finns i lagringsplatsen Azure-Samples/azureai-model-inference-bicep . Om du vill köra kommandona lokalt utan att behöva kopiera eller klistra in filinnehåll använder du följande kommandon för att klona lagringsplatsen och gå till mappen för kodningsspråket:

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

Filerna för det här exemplet finns i:

cd azureai-model-inference-bicep/infra

Förstå resurserna

Självstudien hjälper dig att skapa:

En Azure AI Services-resurs.
En modelldistribution i den globala standard-SKU:n för var och en av modellerna som stöder betala per användning.
(Valfritt) Ett Azure AI-projekt och en hubb.
(Valfritt) En anslutning mellan hubben och modellerna i Azure AI Services.

Du använder följande tillgångar för att skapa dessa resurser:

Använd mallen modules/ai-services-template.bicep för att beskriva din Azure AI Services-resurs:

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: {
    publicNetworkAccess: publicNetworkAccess
    networkAcls: {
      defaultAction: networkAclsDefaultAction
    }
    disableLocalAuth: allowKeys
  }
}

output endpointUri string = account.properties.endpoints['Azure AI Model Inference API']
output id string = account.id

Använd mallen modules/ai-services-deployment-template.bicep för att beskriva modelldistributioner:

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
  }
}

För enkelhetens skull definierar vi den modell som vi vill ha tillgänglig i tjänsten med hjälp av en JSON-fil. Filen infra/models.json innehåller en lista över JSON-objekt med nycklarna name,version, provideroch sku, som definierar de modeller som distributionen ska etablera. Eftersom modellerna stöder betala per användning medför det inte extra kostnad att lägga till modelldistributioner. Ändra filen och ta bort/lägga till de modellposter som du vill ha tillgängliga. I följande exempel visas endast de första 7 raderna i JSON-filen:

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

Om du planerar att använda projekt (rekommenderas) behöver du mallarna för att skapa ett projekt, en hubb och en anslutning till Azure AI Services-resursen:

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
    }
  }
}

Skapa resurserna

Följ dessa steg i konsolen:

Definiera huvuddistributionen:

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

Logga in på Azure:
```
az login
```

Se till att du har rätt prenumeration:

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

Kör distributionen:

RESOURCE_GROUP="<resource-group-name>"

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

Om du bara vill distribuera Azure AI Services-resursen och modelldistributionerna använder du följande distributionsfil:

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

Kör distributionen:

RESOURCE_GROUP="<resource-group-name>"

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

Mallen matar ut slutpunkten för Azure AI-modellens slutsatsdragning som du kan använda för att använda någon av de modelldistributioner som du har skapat.

Nästa steg

Utveckla program med hjälp av Azure AI-modellinferenstjänsten i Azure AI-tjänster

Dela via

Skapa och konfigurera alla resurser för Azure AI-modellinferens

Förutsättningar

Skapa resurserna

Förutsättningar

Lägg till modeller

Hantera distributioner

Använda modellen

Förutsättningar

Om den här självstudiekursen

Förstå resurserna

Skapa resurserna

Nästa steg

Feedback

Ytterligare resurser